+```
+
+# Understanding the Dataset
+
+
+
+
+
+
+
+
+
+
+ -- Neelabh Madan
+
+
+
+***
+This contains the code for **Stanford MRNet Challenge**. For more information - visit [**Stanford MRNet Challenge**](https://www.learnopencv.com/stanford-mrnet-challenge/)
+
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
+
+
+
+
+
+
diff --git a/MRNet-Single-Model/config.py b/MRNet-Single-Model/config.py
new file mode 100644
index 000000000..d73d95fcf
--- /dev/null
+++ b/MRNet-Single-Model/config.py
@@ -0,0 +1,13 @@
+config = {
+ 'max_epoch' : 50,
+ 'log_train' : 100,
+ 'lr' : 1e-5,
+ 'starting_epoch' : 0,
+ 'batch_size' : 1,
+ 'log_val' : 10,
+ 'task' : 'abnormal', # "meniscus" and "acl" are the other options
+ 'weight_decay' : 0.01,
+ 'patience' : 5,
+ 'save_model' : 1,
+ 'exp_name' : 'test'
+}
\ No newline at end of file
diff --git a/MRNet-Single-Model/content/logo.jpg b/MRNet-Single-Model/content/logo.jpg
new file mode 100644
index 000000000..9ce47a47b
Binary files /dev/null and b/MRNet-Single-Model/content/logo.jpg differ
diff --git a/MRNet-Single-Model/content/model.png b/MRNet-Single-Model/content/model.png
new file mode 100644
index 000000000..41b834d69
Binary files /dev/null and b/MRNet-Single-Model/content/model.png differ
diff --git a/MRNet-Single-Model/content/mri_scan.png b/MRNet-Single-Model/content/mri_scan.png
new file mode 100644
index 000000000..5556953e1
Binary files /dev/null and b/MRNet-Single-Model/content/mri_scan.png differ
diff --git a/MRNet-Single-Model/dataset/__init__.py b/MRNet-Single-Model/dataset/__init__.py
new file mode 100644
index 000000000..5d9ad0625
--- /dev/null
+++ b/MRNet-Single-Model/dataset/__init__.py
@@ -0,0 +1 @@
+from .dataset import MRData, load_data
\ No newline at end of file
diff --git a/MRNet-Single-Model/dataset/dataset.py b/MRNet-Single-Model/dataset/dataset.py
new file mode 100644
index 000000000..fe05b3a23
--- /dev/null
+++ b/MRNet-Single-Model/dataset/dataset.py
@@ -0,0 +1,173 @@
+import os
+import pandas as pd
+import numpy as np
+
+import torch
+import torch.utils.data as data
+
+from torchsample.transforms import RandomRotate, RandomTranslate, RandomFlip, ToTensor, Compose, RandomAffine
+from torchvision import transforms
+
+INPUT_DIM = 224
+MAX_PIXEL_VAL = 255
+MEAN = 58.09
+STDDEV = 49.73
+
+class MRData():
+ """This class used to load MRnet dataset from `./images` dir
+ """
+
+ def __init__(self,task = 'acl', train = True, transform = None, weights = None):
+ """Initialize the dataset
+ Args:
+ plane : along which plane to load the data
+ task : for which task to load the labels
+ train : whether to load the train or val data
+ transform : which transforms to apply
+ weights (Tensor) : Give wieghted loss to postive class eg. `weights=torch.tensor([2.223])`
+ """
+ # Define the three planes to use
+ self.planes=['axial', 'coronal', 'sagittal']
+ # Initialize the records as None
+ self.records = None
+ # an empty dictionary
+ self.image_path={}
+
+ # If we are in training loop
+ if train:
+ # Read data about patient records
+ self.records = pd.read_csv('./images/train-{}.csv'.format(task),header=None, names=['id', 'label'])
+
+ for plane in self.planes:
+ # For each plane, specify the image path
+ self.image_path[plane] = './images/train/{}/'.format(plane)
+ else:
+ # If we are in testing loop
+ # don't use any transformation
+ transform = None
+ # Read testing/validation data (patients records)
+ self.records = pd.read_csv('./images/valid-{}.csv'.format(task),header=None, names=['id', 'label'])
+
+ for plane in self.planes:
+ # Read path of images for each plane
+ self.image_path[plane] = './images/valid/{}/'.format(plane)
+
+ # Initialize the transformation to apply on images
+ self.transform = transform
+
+ # Append 0s to the patient record id
+ self.records['id'] = self.records['id'].map(
+ lambda i: '0' * (4 - len(str(i))) + str(i))
+ # empty dictionary
+ self.paths={}
+ for plane in self.planes:
+ # Get paths of numpy data files for each plane
+ self.paths[plane] = [self.image_path[plane] + filename +
+ '.npy' for filename in self.records['id'].tolist()]
+
+ # Convert labels from Pandas Series to a list
+ self.labels = self.records['label'].tolist()
+
+ # Total positive cases
+ pos = sum(self.labels)
+ # Total negative cases
+ neg = len(self.labels) - pos
+
+ # Find the wieghts of pos and neg classes
+ if weights:
+ self.weights = torch.FloatTensor(weights)
+ else:
+ self.weights = torch.FloatTensor([neg / pos])
+
+ print('Number of -ve samples : ', neg)
+ print('Number of +ve samples : ', pos)
+ print('Weights for loss is : ', self.weights)
+
+ def __len__(self):
+ """Return the total number of images in the dataset."""
+ return len(self.records)
+
+ def __getitem__(self, index):
+ """
+ Returns `(images,labels)` pair
+ where image is a list [imgsPlane1,imgsPlane2,imgsPlane3]
+ and labels is a list [gt,gt,gt]
+ """
+ img_raw = {}
+
+ for plane in self.planes:
+ # Load raw image data for each plane
+ img_raw[plane] = np.load(self.paths[plane][index])
+ # Resize the image loaded in the previous step
+ img_raw[plane] = self._resize_image(img_raw[plane])
+
+ label = self.labels[index]
+ # Convert label to 0 and 1
+ if label == 1:
+ label = torch.FloatTensor([1])
+ elif label == 0:
+ label = torch.FloatTensor([0])
+
+ # Return a list of three images for three planes and the label of the record
+ return [img_raw[plane] for plane in self.planes], label
+
+ def _resize_image(self, image):
+ """Resize the image to `(3,224,224)` and apply
+ transforms if possible.
+ """
+ # Resize the image
+ # Calculate extra padding present in the image
+ # which needs to be removed
+ pad = int((image.shape[2] - INPUT_DIM)/2)
+ # This is equivalent to center cropping the image
+ image = image[:,pad:-pad,pad:-pad]
+ # Normalize the image by subtracting it by mean and dividing by standard
+ # deviation
+ image = (image-np.min(image))/(np.max(image)-np.min(image))*MAX_PIXEL_VAL
+ image = (image - MEAN) / STDDEV
+
+ # If the transformation is not None
+ if self.transform:
+ # Transform the image based on the specified transformation
+ image = self.transform(image)
+ else:
+ # Else, just stack the image with itself in order to match the required
+ # dimensions
+ image = np.stack((image,)*3, axis=1)
+ # Convert the image to a FloatTensor and return it
+ image = torch.FloatTensor(image)
+ return image
+
+def load_data(task : str):
+
+ # Define the Augmentation here only
+ augments = Compose([
+ # Convert the image to Tensor
+ transforms.Lambda(lambda x: torch.Tensor(x)),
+ # Randomly rotate the image with an angle
+ # between -25 degrees to 25 degrees
+ RandomRotate(25),
+ # Randomly translate the image by 11% of
+ # image height and width
+ RandomTranslate([0.11, 0.11]),
+ # Randomly flip the image
+ RandomFlip(),
+ # Change the order of image channels
+ transforms.Lambda(lambda x: x.repeat(3, 1, 1, 1).permute(1, 0, 2, 3)),
+ ])
+
+ print('Loading Train Dataset of {} task...'.format(task))
+ # Load training dataset
+ train_data = MRData(task, train=True, transform=augments)
+ train_loader = data.DataLoader(
+ train_data, batch_size=1, num_workers=11, shuffle=True
+ )
+
+ print('Loading Validation Dataset of {} task...'.format(task))
+ # Load validation dataset
+ val_data = MRData(task, train=False)
+ val_loader = data.DataLoader(
+ val_data, batch_size=1, num_workers=11, shuffle=False
+ )
+
+ return train_loader, val_loader, train_data.weights, val_data.weights
diff --git a/MRNet-Single-Model/images/readme.md b/MRNet-Single-Model/images/readme.md
new file mode 100644
index 000000000..4aee530db
--- /dev/null
+++ b/MRNet-Single-Model/images/readme.md
@@ -0,0 +1,20 @@
+# Download and put data here
+
+Download the dataset (~5.7 GB), and put `train` and `valid` folders along with all the the `.csv` files inside `images` folder at root directory.
+```Shell
+ images/
+ train/
+ axial/
+ sagittal/
+ coronal/
+ val/
+ axial/
+ sagittal/
+ coronal/
+ train-abnormal.csv
+ train-acl.csv
+ train-meniscus.csv
+ valid-abnormal.csv
+ valid-acl.csv
+ valid-meniscus.csv
+```
\ No newline at end of file
diff --git a/MRNet-Single-Model/models/MRnet.py b/MRNet-Single-Model/models/MRnet.py
new file mode 100644
index 000000000..86db314e1
--- /dev/null
+++ b/MRNet-Single-Model/models/MRnet.py
@@ -0,0 +1,81 @@
+import torch
+import torch.nn as nn
+from torchvision import models
+import os
+
+class MRnet(nn.Module):
+ """MRnet uses pretrained resnet50 as a backbone to extract features
+ """
+
+ def __init__(self):
+ """This function will be used to initialize the
+ MRnet instance."""
+ # Initialize nn.Module instance
+ super(MRnet,self).__init__()
+
+ # Initialize three backbones for three axis
+ # All the three axes will use pretrained AlexNet model
+ # The models will be used for extracting features from
+ # the input images
+ self.axial = models.alexnet(pretrained=True).features
+ self.coronal = models.alexnet(pretrained=True).features
+ self.saggital = models.alexnet(pretrained=True).features
+
+ # Initialize 2D Adaptive Average Pooling layers
+ # The pooling layers will reduce the size of
+ # feature maps extracted from the previous axes
+ self.pool_axial = nn.AdaptiveAvgPool2d(1)
+ self.pool_coronal = nn.AdaptiveAvgPool2d(1)
+ self.pool_saggital = nn.AdaptiveAvgPool2d(1)
+
+ # Initialize a sequential neural network with
+ # a single fully connected linear layer
+ # The network will output the probability of
+ # having a particular disease
+ self.fc = nn.Sequential(
+ nn.Linear(in_features=3*256,out_features=1)
+ )
+
+ def forward(self,x):
+ """ Input is given in the form of `[image1, image2, image3]` where
+ `image1 = [1, slices, 3, 224, 224]`. Note that `1` is due to the
+ dataloader assigning it a single batch.
+ """
+
+ # squeeze the first dimension as there
+ # is only one patient in each batch
+ images = [torch.squeeze(img, dim=0) for img in x]
+
+ # Extract features across each of the three plane
+ # using the three pre-trained AlexNet models defined earlier
+ image1 = self.axial(images[0])
+ image2 = self.coronal(images[1])
+ image3 = self.saggital(images[2])
+
+ # Convert the image dimesnsions from [slices, 256, 1, 1] to
+ # [slices,256]
+ image1 = self.pool_axial(image1).view(image1.size(0), -1)
+ image2 = self.pool_coronal(image2).view(image2.size(0), -1)
+ image3 = self.pool_saggital(image3).view(image3.size(0), -1)
+
+ # Find maximum value in each slice
+ # This will reduce the dimensions of image to [1,256]
+ # This is done in order to keep only the most prevalent
+ # features for each slice
+ image1 = torch.max(image1,dim=0,keepdim=True)[0]
+ image2 = torch.max(image2,dim=0,keepdim=True)[0]
+ image3 = torch.max(image3,dim=0,keepdim=True)[0]
+
+ # Stack the 3 images together to create the output
+ # of size [1, 256*3]
+ output = torch.cat([image1,image2,image3], dim=1)
+
+ # Feed the output to the sequential network created earlier
+ # The network will return a probability of having a specific
+ # disease
+ output = self.fc(output)
+ return output
+
+ def _load_wieghts(self):
+ """load pretrained weights"""
+ pass
diff --git a/MRNet-Single-Model/models/__init__.py b/MRNet-Single-Model/models/__init__.py
new file mode 100644
index 000000000..7e95766c3
--- /dev/null
+++ b/MRNet-Single-Model/models/__init__.py
@@ -0,0 +1 @@
+from .MRnet import MRnet
\ No newline at end of file
diff --git a/MRNet-Single-Model/requirements.txt b/MRNet-Single-Model/requirements.txt
new file mode 100644
index 000000000..39cb69b34
--- /dev/null
+++ b/MRNet-Single-Model/requirements.txt
@@ -0,0 +1,41 @@
+absl-py==0.10.0
+cachetools==4.1.1
+certifi==2020.6.20
+chardet==3.0.4
+google-auth==1.21.3
+google-auth-oauthlib==0.4.1
+grpcio==1.32.0
+idna==2.10
+importlib-metadata==2.0.0
+joblib==0.16.0
+Markdown==3.2.2
+nibabel==3.1.1
+numpy==1.19.2
+oauthlib==3.1.0
+olefile==0.46
+packaging==20.4
+pandas==1.1.2
+Pillow
+protobuf==3.13.0
+pyasn1==0.4.8
+pyasn1-modules==0.2.8
+pyparsing==2.4.7
+python-dateutil==2.8.1
+pytz==2020.1
+requests==2.24.0
+requests-oauthlib==1.3.0
+rsa==4.6
+scikit-learn==0.23.2
+scipy==1.5.2
+six==1.15.0
+sklearn==0.0
+tensorboard==2.3.0
+tensorboard-plugin-wit==1.7.0
+threadpoolctl==2.1.0
+torch==1.6.0
+torchsample @ git+https://github.com/ncullen93/torchsample@ea4d1b3975f68be0521941e733887ed667a1b46e
+torchvision==0.7.0
+tqdm==4.49.0
+urllib3==1.25.10
+Werkzeug==1.0.1
+zipp==3.2.0
\ No newline at end of file
diff --git a/MRNet-Single-Model/train.py b/MRNet-Single-Model/train.py
new file mode 100644
index 000000000..b35a9e288
--- /dev/null
+++ b/MRNet-Single-Model/train.py
@@ -0,0 +1,110 @@
+from dataset import load_data
+from models import MRnet
+from config import config
+import torch
+from torch.utils.tensorboard import SummaryWriter
+from utils import _train_model, _evaluate_model, _get_lr
+import time
+import torch.utils.data as data
+import os
+
+"""Performs training of a specified model.
+
+Input params:
+ config_file: Takes in configurations to train with
+"""
+
+def train(config : dict):
+ """
+ Function where actual training takes place
+
+ Args:
+ config (dict) : Configuration to train with
+ """
+
+ print('Starting to Train Model...')
+
+ train_loader, val_loader, train_wts, val_wts = load_data(config['task'])
+
+ print('Initializing Model...')
+ model = MRnet()
+ if torch.cuda.is_available():
+ model = model.cuda()
+ train_wts = train_wts.cuda()
+ val_wts = val_wts.cuda()
+
+ print('Initializing Loss Method...')
+ criterion = torch.nn.BCEWithLogitsLoss(pos_weight=train_wts)
+ val_criterion = torch.nn.BCEWithLogitsLoss(pos_weight=val_wts)
+
+ if torch.cuda.is_available():
+ criterion = criterion.cuda()
+ val_criterion = val_criterion.cuda()
+
+ print('Setup the Optimizer')
+ optimizer = torch.optim.Adam(model.parameters(), lr=config['lr'], weight_decay=config['weight_decay'])
+ scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
+ optimizer, patience=3, factor=.3, threshold=1e-4, verbose=True)
+
+ starting_epoch = config['starting_epoch']
+ num_epochs = config['max_epoch']
+ patience = config['patience']
+ log_train = config['log_train']
+ log_val = config['log_val']
+
+ best_val_loss = float('inf')
+ best_val_auc = float(0)
+
+ print('Starting Training')
+
+ writer = SummaryWriter(comment='lr={} task={}'.format(config['lr'], config['task']))
+ t_start_training = time.time()
+
+ for epoch in range(starting_epoch, num_epochs):
+
+ current_lr = _get_lr(optimizer)
+ epoch_start_time = time.time() # timer for entire epoch
+
+ train_loss, train_auc = _train_model(
+ model, train_loader, epoch, num_epochs, optimizer, criterion, writer, current_lr, log_train)
+
+ val_loss, val_auc = _evaluate_model(
+ model, val_loader, val_criterion, epoch, num_epochs, writer, current_lr, log_val)
+
+ writer.add_scalar('Train/Avg Loss', train_loss, epoch)
+ writer.add_scalar('Val/Avg Loss', val_loss, epoch)
+
+ scheduler.step(val_loss)
+
+ t_end = time.time()
+ delta = t_end - epoch_start_time
+
+ print("train loss : {0} | train auc {1} | val loss {2} | val auc {3} | elapsed time {4} s".format(
+ train_loss, train_auc, val_loss, val_auc, delta))
+
+ print('-' * 30)
+
+ writer.flush()
+
+ if val_auc > best_val_auc:
+ best_val_auc = val_auc
+
+ if bool(config['save_model']):
+ file_name = 'model_{}_{}_val_auc_{:0.4f}_train_auc_{:0.4f}_epoch_{}.pth'.format(config['exp_name'], config['task'], val_auc, train_auc, epoch+1)
+ torch.save({
+ 'model_state_dict': model.state_dict()
+ }, './weights/{}/{}'.format(config['task'],file_name))
+
+ t_end_training = time.time()
+ print(f'training took {t_end_training - t_start_training} s')
+ writer.flush()
+ writer.close()
+
+if __name__ == '__main__':
+
+ print('Training Configuration')
+ print(config)
+
+ train(config=config)
+
+ print('Training Ended...')
diff --git a/MRNet-Single-Model/utils/__init__.py b/MRNet-Single-Model/utils/__init__.py
new file mode 100644
index 000000000..111b181ce
--- /dev/null
+++ b/MRNet-Single-Model/utils/__init__.py
@@ -0,0 +1 @@
+from .utils import _train_model, _evaluate_model, _get_lr
\ No newline at end of file
diff --git a/MRNet-Single-Model/utils/utils.py b/MRNet-Single-Model/utils/utils.py
new file mode 100644
index 000000000..7ba545f3d
--- /dev/null
+++ b/MRNet-Single-Model/utils/utils.py
@@ -0,0 +1,163 @@
+import torch
+from sklearn import metrics
+import numpy as np
+
+def _get_trainable_params(model):
+ """Get Parameters with `requires.grad` set to `True`"""
+ trainable_params = []
+ for x in model.parameters():
+ if x.requires_grad:
+ trainable_params.append(x)
+ return trainable_params
+
+def _evaluate_model(model, val_loader, criterion, epoch, num_epochs, writer, current_lr, log_every=20):
+ """Runs model over val dataset and returns auc and avg val loss"""
+
+ # Set to eval mode
+ model.eval()
+ # List of probabilities obtained from the model
+ y_probs = []
+ # List of groundtruth labels
+ y_gt = []
+ # List of losses obtained
+ losses = []
+
+ # Iterate over the validation dataset
+ for i, (images, label) in enumerate(val_loader):
+ # If GPU is available, load the images and label
+ # on GPU
+ if torch.cuda.is_available():
+ images = [image.cuda() for image in images]
+ label = label.cuda()
+
+ # Obtain the model output by passing the images as input
+ output = model(images)
+ # Evaluate the loss by comparing the output and groundtruth label
+ loss = criterion(output, label)
+ # Add loss to the list of losses
+ loss_value = loss.item()
+ losses.append(loss_value)
+ # Find probability for each class by applying
+ # sigmoid function on model output
+ probas = torch.sigmoid(output)
+ # Add the groundtruth to the list of groundtruths
+ y_gt.append(int(label.item()))
+ # Add predicted probability to the list
+ y_probs.append(probas.item())
+
+ try:
+ # Evaluate area under ROC curve based on the groundtruth label
+ # and predicted probability
+ auc = metrics.roc_auc_score(y_gt, y_probs)
+ except:
+ # Default area under ROC curve
+ auc = 0.5
+ # Add information to the writer about validation loss and Area under ROC curve
+ writer.add_scalar('Val/Loss', loss_value, epoch * len(val_loader) + i)
+ writer.add_scalar('Val/AUC', auc, epoch * len(val_loader) + i)
+
+ if (i % log_every == 0) & (i > 0):
+ # Display the information about average validation loss and area under ROC curve
+ print('''[Epoch: {0} / {1} | Batch : {2} / {3} ]| Avg Val Loss {4} | Val AUC : {5} | lr : {6}'''.
+ format(
+ epoch + 1,
+ num_epochs,
+ i,
+ len(val_loader),
+ np.round(np.mean(losses), 4),
+ np.round(auc, 4),
+ current_lr
+ )
+ )
+ # Add information to the writer about total epochs and Area under ROC curve
+ writer.add_scalar('Val/AUC_epoch', auc, epoch + i)
+ # Find mean area under ROC curve and validation loss
+ val_loss_epoch = np.round(np.mean(losses), 4)
+ val_auc_epoch = np.round(auc, 4)
+
+ return val_loss_epoch, val_auc_epoch
+
+def _train_model(model, train_loader, epoch, num_epochs, optimizer, criterion, writer, current_lr, log_every=100):
+
+ # Set to train mode
+ model.train()
+
+ # Initialize the predicted probabilities
+ y_probs = []
+ # Initialize the groundtruth labels
+ y_gt = []
+ # Initialize the loss between the groundtruth label
+ # and the predicted probability
+ losses = []
+
+ # Iterate over the training dataset
+ for i, (images, label) in enumerate(train_loader):
+ # Reset the gradient by zeroing it
+ optimizer.zero_grad()
+
+ # If GPU is available, transfer the images and label
+ # to the GPU
+ if torch.cuda.is_available():
+ images = [image.cuda() for image in images]
+ label = label.cuda()
+
+ # Obtain the prediction using the model
+ output = model(images)
+
+ # Evaluate the loss by comparing the prediction
+ # and groundtruth label
+ loss = criterion(output, label)
+ # Perform a backward propagation
+ loss.backward()
+ # Modify the weights based on the error gradient
+ optimizer.step()
+
+ # Add current loss to the list of losses
+ loss_value = loss.item()
+ losses.append(loss_value)
+
+ # Find probabilities from output using sigmoid function
+ probas = torch.sigmoid(output)
+
+ # Add current groundtruth label to the list of groundtruths
+ y_gt.append(int(label.item()))
+ # Add current probabilities to the list of probabilities
+ y_probs.append(probas.item())
+
+ try:
+ # Try finding the area under ROC curve
+ auc = metrics.roc_auc_score(y_gt, y_probs)
+ except:
+ # Use default value of area under ROC curve as 0.5
+ auc = 0.5
+
+ # Add information to the writer about training loss and Area under ROC curve
+ writer.add_scalar('Train/Loss', loss_value,
+ epoch * len(train_loader) + i)
+ writer.add_scalar('Train/AUC', auc, epoch * len(train_loader) + i)
+
+ if (i % log_every == 0) & (i > 0):
+ # Display the information about average training loss and area under ROC curve
+ print('''[Epoch: {0} / {1} | Batch : {2} / {3} ]| Avg Train Loss {4} | Train AUC : {5} | lr : {6}'''.
+ format(
+ epoch + 1,
+ num_epochs,
+ i,
+ len(train_loader),
+ np.round(np.mean(losses), 4),
+ np.round(auc, 4),
+ current_lr
+ )
+ )
+ # Add information to the writer about total epochs and Area under ROC curve
+ writer.add_scalar('Train/AUC_epoch', auc, epoch + i)
+
+ # Find mean area under ROC curve and training loss
+ train_loss_epoch = np.round(np.mean(losses), 4)
+ train_auc_epoch = np.round(auc, 4)
+
+ return train_loss_epoch, train_auc_epoch
+
+def _get_lr(optimizer):
+ for param_group in optimizer.param_groups:
+ return param_group['lr']
diff --git a/OCR/CMakeLists.txt b/OCR/CMakeLists.txt
new file mode 100644
index 000000000..2243541cc
--- /dev/null
+++ b/OCR/CMakeLists.txt
@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.5.1)
+
+project(ocr_simple)
+
+find_package(Threads REQUIRED)
+find_package(OpenCV REQUIRED)
+
+find_package( PkgConfig REQUIRED)
+pkg_search_module(TESSERACT REQUIRED tesseract)
+
+add_executable(ocr_simple ocr_simple.cpp)
+target_include_directories(ocr_simple PRIVATE ${OpenCV_INCLUDE_DIRS} ${TESSERACT_INCLUDE_DIRS})
+target_link_directories(ocr_simple PRIVATE ${TESSERACT_LIBRARY_DIRS})
+target_link_libraries(ocr_simple PRIVATE ${OpenCV_LIBS} ${TESSERACT_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
diff --git a/ObjectDetection-YOLO/object_detection_yolo.cpp b/ObjectDetection-YOLO/object_detection_yolo.cpp
index b9cc9ebac..7ea00301f 100644
--- a/ObjectDetection-YOLO/object_detection_yolo.cpp
+++ b/ObjectDetection-YOLO/object_detection_yolo.cpp
@@ -120,7 +120,7 @@ int main(int argc, char** argv)
break;
}
// Create a 4D blob from a frame.
- blobFromImage(frame, blob, 1/255.0, cvSize(inpWidth, inpHeight), Scalar(0,0,0), true, false);
+ blobFromImage(frame, blob, 1/255.0, cv::Size(inpWidth, inpHeight), Scalar(0,0,0), true, false);
//Sets the input to the network
net.setInput(blob);
diff --git a/OpenPose-Multi-Person/getModels.sh b/OpenPose-Multi-Person/getModels.sh
index 44ce5b73f..78d31a06d 100755
--- a/OpenPose-Multi-Person/getModels.sh
+++ b/OpenPose-Multi-Person/getModels.sh
@@ -1,16 +1,6 @@
-# ------------------------- BODY, FACE AND HAND MODELS -------------------------
-# Downloading body pose (COCO and MPI), face and hand models
-OPENPOSE_URL="http://posefs1.perception.cs.cmu.edu/OpenPose/models/"
-POSE_FOLDER="pose/"
-FACE_FOLDER="face/"
-HAND_FOLDER="hand/"
+# ------------------------- BODY KEYPOINT-DETECTION MODELS -------------------------
+# Downloading body pose (COCO)
+OPENPOSE_URL="https://www.dropbox.com/s/2h2bv29a130sgrk/pose_iter_440000.caffemodel"
-# ------------------------- POSE MODELS -------------------------
-# Body (COCO)
-COCO_FOLDER=${POSE_FOLDER}"coco/"
-COCO_MODEL=${COCO_FOLDER}"pose_iter_440000.caffemodel"
-wget -c ${OPENPOSE_URL}${COCO_MODEL} -P ${COCO_FOLDER}
-# Alternative: it will not check whether file was fully downloaded
-# if [ ! -f $COCO_MODEL ]; then
-# wget ${OPENPOSE_URL}$COCO_MODEL -P $COCO_FOLDER
-# fi
+OPENPOSE_FOLDER="pose/coco/"
+wget -c ${OPENPOSE_URL} -P ${OPENPOSE_FOLDER}
diff --git a/OpenPose-Multi-Person/multi-person-openpose.cpp b/OpenPose-Multi-Person/multi-person-openpose.cpp
index aa712a8a8..0dfc8ea7e 100644
--- a/OpenPose-Multi-Person/multi-person-openpose.cpp
+++ b/OpenPose-Multi-Person/multi-person-openpose.cpp
@@ -315,16 +315,35 @@ void getPersonwiseKeypoints(const std::vector>& validPair
int main(int argc,char** argv) {
std::string inputFile = "./group.jpg";
-
- if(argc > 1){
- inputFile = std::string(argv[1]);
- }
+ std::string device = "cpu";
+ std::cout << "USAGE : ./multi-person-openpose " << std::endl;
+ if (argc == 2){
+ if((std::string)argv[1] == "gpu")
+ device = "gpu";
+ else
+ inputFile = argv[1];
+ }
+ else if (argc == 3){
+ inputFile = argv[1];
+ if((std::string)argv[2] == "gpu")
+ device = "gpu";
+ }
cv::Mat input = cv::imread(inputFile, cv::IMREAD_COLOR);
std::chrono::time_point startTP = std::chrono::system_clock::now();
cv::dnn::Net inputNet = cv::dnn::readNetFromCaffe("./pose/coco/pose_deploy_linevec.prototxt","./pose/coco/pose_iter_440000.caffemodel");
+
+ if (device == "cpu"){
+ std::cout << "Using CPU device" << std::endl;
+ inputNet.setPreferableBackend(cv::dnn::DNN_TARGET_CPU);
+ }
+ else if (device == "gpu"){
+ std::cout << "Using GPU device" << std::endl;
+ inputNet.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
+ inputNet.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA);
+ }
cv::Mat inputBlob = cv::dnn::blobFromImage(input,1.0/255.0,cv::Size((int)((368*input.cols)/input.rows),368),cv::Scalar(0,0,0),false,false);
diff --git a/OpenPose-Multi-Person/multi-person-openpose.ipynb b/OpenPose-Multi-Person/multi-person-openpose.ipynb
index c63fb28b7..4a965935c 100644
--- a/OpenPose-Multi-Person/multi-person-openpose.ipynb
+++ b/OpenPose-Multi-Person/multi-person-openpose.ipynb
@@ -16,6 +16,15 @@
"from random import randint"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "device = \"gpu\" # please change it to \"gpu\" if the model needs to be run on cuda."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -62,7 +71,7 @@
" keypoints = []\n",
" \n",
" #find the blobs\n",
- " _, contours, _ = cv2.findContours(mapMask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n",
+ " contours, _ = cv2.findContours(mapMask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n",
" \n",
" #for each blob find the maxima\n",
" for cnt in contours:\n",
@@ -246,6 +255,14 @@
"t = time.time()\n",
"net = cv2.dnn.readNetFromCaffe(protoFile, weightsFile)\n",
"\n",
+ "if device == \"cpu\":\n",
+ " net.setPreferableBackend(cv2.dnn.DNN_TARGET_CPU)\n",
+ " print(\"Using CPU device\")\n",
+ "elif device == \"gpu\":\n",
+ " net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)\n",
+ " net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)\n",
+ " print(\"Using GPU device\")\n",
+ "\n",
"# Fix the input Height and get the width according to the Aspect Ratio\n",
"inHeight = 368\n",
"inWidth = int((inHeight/frameHeight)*frameWidth)\n",
@@ -383,7 +400,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.6.4"
+ "version": "3.6.9"
}
},
"nbformat": 4,
diff --git a/OpenPose-Multi-Person/multi-person-openpose.py b/OpenPose-Multi-Person/multi-person-openpose.py
index 0ab87a430..2ab535d20 100644
--- a/OpenPose-Multi-Person/multi-person-openpose.py
+++ b/OpenPose-Multi-Person/multi-person-openpose.py
@@ -2,8 +2,17 @@
import time
import numpy as np
from random import randint
+import argparse
-image1 = cv2.imread("group.jpg")
+parser = argparse.ArgumentParser(description='Run keypoint detection')
+parser.add_argument("--device", default="cpu", help="Device to inference on")
+parser.add_argument("--image_file", default="group.jpg", help="Input image")
+
+args = parser.parse_args()
+
+
+
+image1 = cv2.imread(args.image_file)
protoFile = "pose/coco/pose_deploy_linevec.prototxt"
weightsFile = "pose/coco/pose_iter_440000.caffemodel"
@@ -36,7 +45,7 @@ def getKeypoints(probMap, threshold=0.1):
keypoints = []
#find the blobs
- _, contours, _ = cv2.findContours(mapMask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+ contours, _ = cv2.findContours(mapMask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
#for each blob find the maxima
for cnt in contours:
@@ -164,6 +173,13 @@ def getPersonwiseKeypoints(valid_pairs, invalid_pairs):
t = time.time()
net = cv2.dnn.readNetFromCaffe(protoFile, weightsFile)
+if args.device == "cpu":
+ net.setPreferableBackend(cv2.dnn.DNN_TARGET_CPU)
+ print("Using CPU device")
+elif args.device == "gpu":
+ net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
+ net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)
+ print("Using GPU device")
# Fix the input Height and get the width according to the Aspect Ratio
inHeight = 368
diff --git a/OpenPose/OpenPoseImage.cpp b/OpenPose/OpenPoseImage.cpp
index 101f6dad9..9d25ac38d 100644
--- a/OpenPose/OpenPoseImage.cpp
+++ b/OpenPose/OpenPoseImage.cpp
@@ -44,14 +44,28 @@ int nPoints = 18;
int main(int argc, char **argv)
{
- cout << "USAGE : ./openpose " << endl;
+ cout << "USAGE : ./OpenPose " << endl;
+ cout << "USAGE : ./OpenPose " << endl;
+ string device = "cpu";
+
string imageFile = "single.jpeg";
// Take arguments from commmand line
if (argc == 2)
{
+ if((string)argv[1] == "gpu")
+ device = "gpu";
+ else
imageFile = argv[1];
}
+ else if (argc == 3)
+ {
+ imageFile = argv[1];
+ if((string)argv[2] == "gpu")
+ device = "gpu";
+ }
+
+
int inWidth = 368;
int inHeight = 368;
@@ -65,6 +79,18 @@ int main(int argc, char **argv)
double t = (double) cv::getTickCount();
Net net = readNetFromCaffe(protoFile, weightsFile);
+ if (device == "cpu")
+ {
+ cout << "Using CPU device" << endl;
+ net.setPreferableBackend(DNN_TARGET_CPU);
+ }
+ else if (device == "gpu")
+ {
+ cout << "Using GPU device" << endl;
+ net.setPreferableBackend(DNN_BACKEND_CUDA);
+ net.setPreferableTarget(DNN_TARGET_CUDA);
+ }
+
Mat inpBlob = blobFromImage(frame, 1.0 / 255, Size(inWidth, inHeight), Scalar(0, 0, 0), false, false);
net.setInput(inpBlob);
diff --git a/OpenPose/OpenPoseImage.py b/OpenPose/OpenPoseImage.py
index ca3ba32a4..b4642a4a5 100644
--- a/OpenPose/OpenPoseImage.py
+++ b/OpenPose/OpenPoseImage.py
@@ -1,6 +1,14 @@
import cv2
import time
import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(description='Run keypoint detection')
+parser.add_argument("--device", default="cpu", help="Device to inference on")
+parser.add_argument("--image_file", default="single.jpeg", help="Input image")
+
+args = parser.parse_args()
+
MODE = "COCO"
@@ -17,7 +25,7 @@
POSE_PAIRS = [[0,1], [1,2], [2,3], [3,4], [1,5], [5,6], [6,7], [1,14], [14,8], [8,9], [9,10], [14,11], [11,12], [12,13] ]
-frame = cv2.imread("single.jpeg")
+frame = cv2.imread(args.image_file)
frameCopy = np.copy(frame)
frameWidth = frame.shape[1]
frameHeight = frame.shape[0]
@@ -25,6 +33,14 @@
net = cv2.dnn.readNetFromCaffe(protoFile, weightsFile)
+if args.device == "cpu":
+ net.setPreferableBackend(cv2.dnn.DNN_TARGET_CPU)
+ print("Using CPU device")
+elif args.device == "gpu":
+ net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
+ net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)
+ print("Using GPU device")
+
t = time.time()
# input image dimensions for the network
inWidth = 368
diff --git a/OpenPose/OpenPoseVideo.cpp b/OpenPose/OpenPoseVideo.cpp
index a741903d2..7414f0dbe 100644
--- a/OpenPose/OpenPoseVideo.cpp
+++ b/OpenPose/OpenPoseVideo.cpp
@@ -44,14 +44,26 @@ int nPoints = 18;
int main(int argc, char **argv)
{
- cout << "USAGE : ./openpose " << endl;
+ cout << "USAGE : ./OpenPose " << endl;
+ cout << "USAGE : ./OpenPose " << endl;
+ string device = "cpu";
string videoFile = "sample_video.mp4";
+
// Take arguments from commmand line
if (argc == 2)
{
+ if((string)argv[1] == "gpu")
+ device = "gpu";
+ else
videoFile = argv[1];
}
+ else if (argc == 3)
+ {
+ videoFile = argv[1];
+ if((string)argv[2] == "gpu")
+ device = "gpu";
+ }
int inWidth = 368;
int inHeight = 368;
@@ -72,6 +84,19 @@ int main(int argc, char **argv)
VideoWriter video("Output-Skeleton.avi",VideoWriter::fourcc('M','J','P','G'), 10, Size(frameWidth,frameHeight));
Net net = readNetFromCaffe(protoFile, weightsFile);
+
+ if (device == "cpu")
+ {
+ cout << "Using CPU device" << endl;
+ net.setPreferableBackend(DNN_TARGET_CPU);
+ }
+ else if (device == "gpu")
+ {
+ cout << "Using GPU device" << endl;
+ net.setPreferableBackend(DNN_BACKEND_CUDA);
+ net.setPreferableTarget(DNN_TARGET_CUDA);
+ }
+
double t=0;
while( waitKey(1) < 0)
{
diff --git a/OpenPose/OpenPoseVideo.py b/OpenPose/OpenPoseVideo.py
index 846c051bb..76f61af8c 100644
--- a/OpenPose/OpenPoseVideo.py
+++ b/OpenPose/OpenPoseVideo.py
@@ -1,6 +1,13 @@
import cv2
import time
import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(description='Run keypoint detection')
+parser.add_argument("--device", default="cpu", help="Device to inference on")
+parser.add_argument("--video_file", default="sample_video.mp4", help="Input Video")
+
+args = parser.parse_args()
MODE = "MPI"
@@ -22,13 +29,20 @@
threshold = 0.1
-input_source = "sample_video.mp4"
+input_source = args.video_file
cap = cv2.VideoCapture(input_source)
hasFrame, frame = cap.read()
vid_writer = cv2.VideoWriter('output.avi',cv2.VideoWriter_fourcc('M','J','P','G'), 10, (frame.shape[1],frame.shape[0]))
net = cv2.dnn.readNetFromCaffe(protoFile, weightsFile)
+if args.device == "cpu":
+ net.setPreferableBackend(cv2.dnn.DNN_TARGET_CPU)
+ print("Using CPU device")
+elif args.device == "gpu":
+ net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
+ net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)
+ print("Using GPU device")
while cv2.waitKey(1) < 0:
t = time.time()
diff --git a/OpenPose/getModels.sh b/OpenPose/getModels.sh
index 5a6c94c40..ce71c9e3a 100755
--- a/OpenPose/getModels.sh
+++ b/OpenPose/getModels.sh
@@ -1,31 +1,13 @@
-# ------------------------- BODY, FACE AND HAND MODELS -------------------------
-# Downloading body pose (COCO and MPI), face and hand models
-OPENPOSE_URL="http://posefs1.perception.cs.cmu.edu/OpenPose/models/"
-POSE_FOLDER="pose/"
-FACE_FOLDER="face/"
-HAND_FOLDER="hand/"
-
# ------------------------- POSE MODELS -------------------------
-# Body (COCO)
-COCO_FOLDER=${POSE_FOLDER}"coco/"
-COCO_MODEL=${COCO_FOLDER}"pose_iter_440000.caffemodel"
-wget -c ${OPENPOSE_URL}${COCO_MODEL} -P ${COCO_FOLDER}
-# Alternative: it will not check whether file was fully downloaded
-# if [ ! -f $COCO_MODEL ]; then
-# wget ${OPENPOSE_URL}$COCO_MODEL -P $COCO_FOLDER
-# fi
-# Body (MPI)
-MPI_FOLDER=${POSE_FOLDER}"mpi/"
-MPI_MODEL=${MPI_FOLDER}"pose_iter_160000.caffemodel"
-wget -c ${OPENPOSE_URL}${MPI_MODEL} -P ${MPI_FOLDER}
-# "------------------------- FACE MODELS -------------------------"
-# Face
-FACE_MODEL=${FACE_FOLDER}"pose_iter_116000.caffemodel"
-wget -c ${OPENPOSE_URL}${FACE_MODEL} -P ${FACE_FOLDER}
+# Downloading the pose-model trained on COCO
+COCO_POSE_URL="https://www.dropbox.com/s/2h2bv29a130sgrk/pose_iter_440000.caffemodel"
+COCO_FOLDER="pose/coco/"
+wget -c ${COCO_POSE_URL} -P ${COCO_FOLDER}
+
+# Downloading the pose-model trained on MPI
+MPI_POSE_URL="https://www.dropbox.com/s/drumc6dzllfed16/pose_iter_160000.caffemodel"
+MPI_FOLDER="pose/mpi/"
+wget -c ${MPI_POSE_URL} -P ${MPI_FOLDER}
-# "------------------------- HAND MODELS -------------------------"
-# Hand
-HAND_MODEL=$HAND_FOLDER"pose_iter_102000.caffemodel"
-wget -c ${OPENPOSE_URL}${HAND_MODEL} -P ${HAND_FOLDER}
diff --git a/OpenVINO-OpenCV/image-classification.cpp b/OpenVINO-OpenCV/image-classification.cpp
index a8a216ee0..9470771e4 100644
--- a/OpenVINO-OpenCV/image-classification.cpp
+++ b/OpenVINO-OpenCV/image-classification.cpp
@@ -1,10 +1,14 @@
#include
#include
+#include
+#include
+#include
+
#include
#include
#include
-#include
-
+#include
+
using namespace std;
using namespace cv;
using namespace cv::dnn;
@@ -15,10 +19,12 @@ int main() {
string labels_file = "/home/ubuntu/caffe/data/ilsvrc12/synset_words.txt";
string prototxt = "/home/ubuntu/caffe/models/bvlc_reference_caffenet/deploy.prototxt";
string model = "/home/ubuntu/caffe/models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel";
+ vector classes;
// load the labels file
std::ifstream ifs(labels_file.c_str());
if (!ifs.is_open())
+ {
CV_Error(Error::StsError, "File " + labels_file + " not found");
string line;
while (std::getline(ifs, line))
@@ -26,17 +32,18 @@ int main() {
classes.push_back(line);
}
}
- blobFromImage(image, blob, 1, Size(224, 224), Scalar(104,117,123));
+
+ Mat blob = dnn::blobFromImage(image, 1, Size(224, 224), Scalar(104,117,123));
cout << "[INFO] loading model..." << endl;
- Net net = readNetFromCaffe(prototxt, model);
+ dnn::Net net = readNetFromCaffe(prototxt, model);
net.setPreferableBackend(DNN_BACKEND_INFERENCE_ENGINE);
net.setPreferableTarget(DNN_TARGET_CPU);
-
+
// set the blob as input to the network and perform a forward-pass to
// obtain our output classification
- net.setInput(blob)
- preds = net.forward()
-
+ net.setInput(blob);
+ Mat preds = net.forward();
+
double freq = getTickFrequency() / 1000;
std::vector layersTimes;
double t = net.getPerfProfile(layersTimes) / freq;
diff --git a/Playing-rock-paper-scissors-with-AI/README.md b/Playing-rock-paper-scissors-with-AI/README.md
new file mode 100644
index 000000000..51e9f20b2
--- /dev/null
+++ b/Playing-rock-paper-scissors-with-AI/README.md
@@ -0,0 +1,21 @@
+# Playing Rock, Paper, Scissors with AI
+
+This repository contains the notebook for "Playing Rock, Paper, Scissors with AI" Tutorial
+
+You can access the Tutorial for this [here](https://www.learnopencv.com/playing-rock-paper-scissors-with-ai/).
+
+[Playing Rock, Paper, Scissors with AI](Rock_paper_scissor.ipynb)
+
+You can download the rps3.h5 model from [this link](https://drive.google.com/file/d/1ZAEhMXlAxDkVbVo-1DE2aO_YphDscJLD/view?usp=sharing), although I would strongly suggest to train your own model on your own hands.
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
+
+
+
+
+
+
+
diff --git a/Playing-rock-paper-scissors-with-AI/Rock_paper_scissor.ipynb b/Playing-rock-paper-scissors-with-AI/Rock_paper_scissor.ipynb
new file mode 100644
index 000000000..a18a187b4
--- /dev/null
+++ b/Playing-rock-paper-scissors-with-AI/Rock_paper_scissor.ipynb
@@ -0,0 +1,985 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Playing Rock, Paper, Scissors with AI \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Import Libraries "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import cv2\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "import time\n",
+ "\n",
+ "import tensorflow as tf\n",
+ "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+ "from tensorflow.keras.models import Model, load_model\n",
+ "from tensorflow.keras.layers import Dense,MaxPool2D,Dropout,Flatten,Conv2D,GlobalAveragePooling2D,Activation\n",
+ "from tensorflow.keras.optimizers import Adam\n",
+ "from tensorflow.keras.utils import to_categorical\n",
+ "\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.preprocessing import LabelEncoder\n",
+ "\n",
+ "from random import choice,shuffle\n",
+ "from scipy import stats as st\n",
+ "\n",
+ "from collections import deque"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 1: Gather Data, for rock, paper scissor classes. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def gather_data(num_samples):\n",
+ " \n",
+ " global rock, paper, scissor, nothing\n",
+ " \n",
+ " # Initialize the camera\n",
+ " cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)\n",
+ "\n",
+ " # trigger tells us when to start recording\n",
+ " trigger = False\n",
+ " \n",
+ " # Counter keeps count of the number of samples collected\n",
+ " counter = 0\n",
+ " \n",
+ " # This the ROI size, the size of images saved will be box_size -10\n",
+ " box_size = 234\n",
+ " \n",
+ " # Getting the width of the frame from the camera properties\n",
+ " width = int(cap.get(3))\n",
+ "\n",
+ "\n",
+ " while True:\n",
+ " \n",
+ " # Read frame by frame\n",
+ " ret, frame = cap.read()\n",
+ " \n",
+ " # Flip the frame laterally\n",
+ " frame = cv2.flip(frame, 1)\n",
+ " \n",
+ " # Break the loop if there is trouble reading the frame.\n",
+ " if not ret:\n",
+ " break\n",
+ " \n",
+ " # If counter is equal to the number samples then reset triger and the counter\n",
+ " if counter == num_samples:\n",
+ " trigger = not trigger\n",
+ " counter = 0\n",
+ " \n",
+ " # Define ROI for capturing samples\n",
+ " cv2.rectangle(frame, (width - box_size, 0), (width, box_size), (0, 250, 150), 2)\n",
+ " \n",
+ " # Make a resizable window.\n",
+ " cv2.namedWindow(\"Collecting images\", cv2.WINDOW_NORMAL)\n",
+ " \n",
+ " \n",
+ " # If trigger is True than start capturing the samples\n",
+ " if trigger:\n",
+ " \n",
+ " # Grab only slected roi\n",
+ " roi = frame[5: box_size-5 , width-box_size + 5: width -5]\n",
+ " \n",
+ " # Append the roi and class name to the list with the selected class_name\n",
+ " eval(class_name).append([roi, class_name])\n",
+ " \n",
+ " # Increment the counter \n",
+ " counter += 1 \n",
+ " \n",
+ " # Text for the counter\n",
+ " text = \"Collected Samples of {}: {}\".format(class_name, counter)\n",
+ " \n",
+ " else:\n",
+ " text = \"Press 'r' to collect rock samples, 'p' for paper, 's' for scissor and 'n' for nothing\"\n",
+ " \n",
+ " # Show the counter on the imaege\n",
+ " cv2.putText(frame, text, (3, 350), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 255), 1, cv2.LINE_AA)\n",
+ " \n",
+ " # Display the window\n",
+ " cv2.imshow(\"Collecting images\", frame)\n",
+ " \n",
+ " # Wait 1 ms\n",
+ " k = cv2.waitKey(1)\n",
+ " \n",
+ " # If user press 'r' than set the path for rock directoryq\n",
+ " if k == ord('r'):\n",
+ " \n",
+ " # Trigger the variable inorder to capture the samples\n",
+ " trigger = not trigger\n",
+ " class_name = 'rock'\n",
+ " rock = []\n",
+ " \n",
+ " \n",
+ " # If user press 'p' then class_name is set to paper and trigger set to True \n",
+ " if k == ord('p'):\n",
+ " trigger = not trigger\n",
+ " class_name = 'paper'\n",
+ " paper = []\n",
+ " \n",
+ " # If user press 's' then class_name is set to scissor and trigger set to True \n",
+ " if k == ord('s'):\n",
+ " trigger = not trigger\n",
+ " class_name = 'scissor'\n",
+ " scissor = []\n",
+ " \n",
+ " # If user press 's' then class_name is set to nothing and trigger set to True\n",
+ " if k == ord('n'):\n",
+ " trigger = not trigger\n",
+ " class_name = 'nothing'\n",
+ " nothing = []\n",
+ " \n",
+ " # Exit if user presses 'q'\n",
+ " if k == ord('q'):\n",
+ " break\n",
+ " \n",
+ " # Release the camera and destroy the window\n",
+ " cap.release()\n",
+ " cv2.destroyAllWindows()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now run the function"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "no_of_samples = 100\n",
+ "gather_data(no_of_samples)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 2: (Optional) Visualize the Data:\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Set the figure size\n",
+ "plt.figure(figsize=[30,20])\n",
+ "\n",
+ "# Set the rows and columns\n",
+ "rows, cols = 4, 8\n",
+ "\n",
+ "# Iterate for each class\n",
+ "for class_index, each_list in enumerate([rock, paper, scissor,nothing]):\n",
+ " \n",
+ " # Get 8 random indexes, since we will be showing 8 examples of each class.\n",
+ " r = np.random.randint(no_of_samples, size=8);\n",
+ " \n",
+ " # Plot the examples\n",
+ " for i, example_index in enumerate(r,1):\n",
+ " plt.subplot(rows,cols,class_index*cols + i );plt.imshow(each_list[example_index][0][:,:,::-1]);plt.axis('off'); "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 3: Preprocess Data and Split it:\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Total images: 400 , Total Labels: 400\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Combine the labels of all classes together\n",
+ "labels = [tupl[1] for tupl in rock] + [tupl[1] for tupl in paper] + [tupl[1] for tupl in scissor] +[tupl[1] for tupl in nothing]\n",
+ "\n",
+ "# Combine the images of all classes together\n",
+ "images = [tupl[0] for tupl in rock] + [tupl[0] for tupl in paper] + [tupl[0] for tupl in scissor] +[tupl[0] for tupl in nothing]\n",
+ "\n",
+ "# Normalize the images by dividing by 255, now our images are in range 0-1. This will help in training.\n",
+ "images = np.array(images, dtype=\"float\") / 255.0\n",
+ "\n",
+ "# Print out the total number of labels and images.\n",
+ "print('Total images: {} , Total Labels: {}'.format(len(labels), len(images)))\n",
+ "\n",
+ "# Create an encoder Object\n",
+ "encoder = LabelEncoder()\n",
+ "\n",
+ "# Convert Lablels to integers. i.e. nothing = 0, paper = 1, rock = 2, scissor = 3 (mapping is done in alphabatical order)\n",
+ "Int_labels = encoder.fit_transform(labels)\n",
+ "\n",
+ "# Now the convert the integer labels into one hot format. i.e. 0 = [1,0,0,0] etc.\n",
+ "one_hot_labels = to_categorical(Int_labels, 4)\n",
+ "\n",
+ "# Now we're splitting the data, 75% for training and 25% for testing.\n",
+ "(trainX, testX, trainY, testY) = train_test_split(images, one_hot_labels, test_size=0.25, random_state=50)\n",
+ "\n",
+ "# Empty memory from RAM\n",
+ "images = []\n",
+ "\n",
+ "\n",
+ "# This can further free up memory from RAM but be careful, if you won't be able to chage split % after this.\n",
+ "# rock, paper, scissor = [], [], []"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 4: Prepare Our Model for Fine Tuning:\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Number of Layers in Model: 773\n"
+ ]
+ }
+ ],
+ "source": [
+ "# This is the input size which our model accepts.\n",
+ "image_size = 224\n",
+ "\n",
+ "# Loading pre-trained NASNETMobile Model without the head by doing include_top = False\n",
+ "N_mobile = tf.keras.applications.NASNetMobile( input_shape=(image_size, image_size, 3), include_top=False, weights='imagenet')\n",
+ "\n",
+ "# Freeze the whole model \n",
+ "N_mobile.trainable = False\n",
+ " \n",
+ "# Adding our own custom head\n",
+ "# Start by taking the output feature maps from NASNETMobile\n",
+ "x = N_mobile.output\n",
+ "\n",
+ "# Convert to a single dimensional vector by Global Average Pooling. \n",
+ "# We could also use Flatten()(x) GAP is more effective reduces params and controls overfitting.\n",
+ "x = GlobalAveragePooling2D()(x)\n",
+ "\n",
+ "# Adding a dense layer with 512 units\n",
+ "x = Dense(712, activation='relu')(x) \n",
+ "\n",
+ "# Dropout 20% of the activations, helps reduces overfitting\n",
+ "x = Dropout(0.40)(x)\n",
+ "\n",
+ "# The fianl layer will contain 4 output units (no of units = no of classes) with softmax function.\n",
+ "preds = Dense(4,activation='softmax')(x) \n",
+ "\n",
+ "# Construct the full model\n",
+ "model = Model(inputs=N_mobile.input, outputs=preds)\n",
+ "\n",
+ "# Check the number of layers in the final Model\n",
+ "print (\"Number of Layers in Model: {}\".format(len(model.layers[:])))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 5: Train Our Model:\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Adding transformations that I know would help, you can feel free to add more.\n",
+ "# I'm doing horizontal_flip = False, incase you aren't sure which hand you would be using you can make that True.\n",
+ "\n",
+ "augment = ImageDataGenerator( \n",
+ " \n",
+ " rotation_range=30,\n",
+ " zoom_range=0.25,\n",
+ " width_shift_range=0.10,\n",
+ " height_shift_range=0.10,\n",
+ " shear_range=0.10,\n",
+ " horizontal_flip=False, \n",
+ " fill_mode=\"nearest\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model.compile(optimizer=Adam(learning_rate=0.0001), loss='categorical_crossentropy', metrics=['accuracy'])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 1/15\n",
+ "15/15 [==============================] - 27s 2s/step - loss: 1.0857 - accuracy: 0.5600 - val_loss: 0.6256 - val_accuracy: 0.9200\n",
+ "Epoch 2/15\n",
+ "15/15 [==============================] - 22s 1s/step - loss: 0.5107 - accuracy: 0.8800 - val_loss: 0.3271 - val_accuracy: 0.9400\n",
+ "Epoch 3/15\n",
+ "15/15 [==============================] - 23s 2s/step - loss: 0.3125 - accuracy: 0.9333 - val_loss: 0.2120 - val_accuracy: 0.9400\n",
+ "Epoch 4/15\n",
+ "15/15 [==============================] - 22s 1s/step - loss: 0.2304 - accuracy: 0.9467 - val_loss: 0.1527 - val_accuracy: 0.9800\n",
+ "Epoch 5/15\n",
+ "15/15 [==============================] - 23s 2s/step - loss: 0.1893 - accuracy: 0.9533 - val_loss: 0.1240 - val_accuracy: 0.9800\n",
+ "Epoch 6/15\n",
+ "15/15 [==============================] - 22s 1s/step - loss: 0.1311 - accuracy: 0.9833 - val_loss: 0.1004 - val_accuracy: 1.0000\n",
+ "Epoch 7/15\n",
+ "15/15 [==============================] - 22s 1s/step - loss: 0.1168 - accuracy: 0.9833 - val_loss: 0.0849 - val_accuracy: 1.0000\n",
+ "Epoch 8/15\n",
+ "15/15 [==============================] - 23s 2s/step - loss: 0.1047 - accuracy: 0.9867 - val_loss: 0.0685 - val_accuracy: 1.0000\n",
+ "Epoch 9/15\n",
+ "15/15 [==============================] - 26s 2s/step - loss: 0.0888 - accuracy: 0.9933 - val_loss: 0.0608 - val_accuracy: 1.0000\n",
+ "Epoch 10/15\n",
+ "15/15 [==============================] - 23s 2s/step - loss: 0.0742 - accuracy: 0.9933 - val_loss: 0.0520 - val_accuracy: 1.0000\n",
+ "Epoch 11/15\n",
+ "15/15 [==============================] - 22s 1s/step - loss: 0.0635 - accuracy: 0.9933 - val_loss: 0.0445 - val_accuracy: 1.0000\n",
+ "Epoch 12/15\n",
+ "15/15 [==============================] - 24s 2s/step - loss: 0.0527 - accuracy: 0.9933 - val_loss: 0.0390 - val_accuracy: 1.0000\n",
+ "Epoch 13/15\n",
+ "15/15 [==============================] - 23s 2s/step - loss: 0.0521 - accuracy: 0.9967 - val_loss: 0.0338 - val_accuracy: 1.0000\n",
+ "Epoch 14/15\n",
+ "15/15 [==============================] - 22s 1s/step - loss: 0.0438 - accuracy: 0.9967 - val_loss: 0.0367 - val_accuracy: 1.0000\n",
+ "Epoch 15/15\n",
+ "15/15 [==============================] - 22s 1s/step - loss: 0.0476 - accuracy: 0.9967 - val_loss: 0.0279 - val_accuracy: 1.0000\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Set batchsize according to your system\n",
+ "epochs = 15\n",
+ "batchsize = 20\n",
+ "\n",
+ "# Start training\n",
+ "history = model.fit(x=augment.flow(trainX, trainY, batch_size=batchsize), validation_data=(testX, testY), \n",
+ "steps_per_epoch= len(trainX) // batchsize, epochs=epochs)\n",
+ "\n",
+ "# Use model.fit_generator function instead if TF version < 2.2\n",
+ "#history = model.fit_generator(x = augment.flow(trainX, trainY, batch_size=batchsize), validation_data=(testX, testY), \n",
+ "#steps_per_epoch= len(trainX) // batchsize, epochs=epochs)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 6: Check our Accuracy, Loss graphs & save the model.\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Plot the accuracy and loss curves\n",
+ "\n",
+ "acc = history.history['accuracy']\n",
+ "val_acc = history.history['val_accuracy']\n",
+ "loss = history.history['loss']\n",
+ "val_loss = history.history['val_loss']\n",
+ "\n",
+ "epochs = range(len(acc))\n",
+ "\n",
+ "plt.plot(epochs, acc, 'b', label='Training acc')\n",
+ "plt.plot(epochs, val_acc, 'r', label='Validation acc')\n",
+ "plt.title('Training accuracy')\n",
+ "plt.legend()\n",
+ "\n",
+ "plt.figure()\n",
+ "\n",
+ "plt.plot(epochs, loss, 'b', label='Training loss')\n",
+ "plt.plot(epochs, val_loss, 'r', label='Validation loss')\n",
+ "plt.title('Training loss')\n",
+ "plt.legend()\n",
+ "\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Save the model "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model.save(\"rps4.h5\", overwrite=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Load the model "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model = load_model(\"rps4.h5\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 7: Test on Live Webcam Feed:\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# This list will be used to map probabilities to class names, Label names are in alphabatical order.\n",
+ "label_names = ['nothing', 'paper', 'rock', 'scissor']\n",
+ "\n",
+ "cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)\n",
+ "box_size = 234\n",
+ "width = int(cap.get(3))\n",
+ "\n",
+ "while True:\n",
+ " \n",
+ " ret, frame = cap.read()\n",
+ " if not ret:\n",
+ " break\n",
+ " \n",
+ " frame = cv2.flip(frame, 1)\n",
+ " \n",
+ " cv2.rectangle(frame, (width - box_size, 0), (width, box_size), (0, 250, 150), 2)\n",
+ " \n",
+ " cv2.namedWindow(\"Rock Paper Scissors\", cv2.WINDOW_NORMAL)\n",
+ "\n",
+ " roi = frame[5: box_size-5 , width-box_size + 5: width -5]\n",
+ " \n",
+ " # Normalize the image like we did in the preprocessing step, also convert float64 array.\n",
+ " roi = np.array([roi]).astype('float64') / 255.0\n",
+ " \n",
+ " # Get model's prediction.\n",
+ " pred = model.predict(roi)\n",
+ " \n",
+ " # Get the index of the target class.\n",
+ " target_index = np.argmax(pred[0])\n",
+ "\n",
+ " # Get the probability of the target class\n",
+ " prob = np.max(pred[0])\n",
+ "\n",
+ " # Show results\n",
+ " cv2.putText(frame, \"prediction: {} {:.2f}%\".format(label_names[np.argmax(pred[0])], prob*100 ),\n",
+ " (10, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.90, (0, 0, 255), 2, cv2.LINE_AA)\n",
+ " \n",
+ " cv2.imshow(\"Rock Paper Scissors\", frame)\n",
+ " \n",
+ " \n",
+ " k = cv2.waitKey(1)\n",
+ " if k == ord('q'):\n",
+ " break\n",
+ "\n",
+ "cap.release()\n",
+ "cv2.destroyAllWindows()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 8: Create the Final Application:\n",
+ " \n",
+ " \n",
+ "\n",
+ " It’s time for the finale, we will now take our final model and build a full application out of it, for our final script we have 3 different helper functions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Function for finding the Winner \n",
+ "First we need a function that takes two moves, one by the user and one the computer and then finds out who won that round. This function is pretty simple as you can see below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def findout_winner(user_move, Computer_move):\n",
+ " \n",
+ " # All logic below is self explanatory \n",
+ " \n",
+ " if user_move == Computer_move:\n",
+ " return \"Tie\"\n",
+ " \n",
+ " \n",
+ " elif user_move == \"rock\" and Computer_move == \"scissor\":\n",
+ " return \"User\"\n",
+ " \n",
+ " elif user_move == \"rock\" and Computer_move == \"paper\":\n",
+ " return \"Computer\"\n",
+ " \n",
+ " elif user_move == \"scissor\" and Computer_move == \"rock\":\n",
+ " return \"Computer\"\n",
+ " \n",
+ " elif user_move == \"scissor\" and Computer_move == \"paper\":\n",
+ " return \"User\"\n",
+ " \n",
+ " elif user_move == \"paper\" and Computer_move == \"rock\":\n",
+ " return \"User\"\n",
+ " \n",
+ " elif user_move == \"paper\" and Computer_move == \"scissor\":\n",
+ " return \"Computer\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Let’s test this function.**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "User Selected 'paper' and computer selected 'paper' , winner is: 'Tie' \n"
+ ]
+ }
+ ],
+ "source": [
+ "user_move = 'paper'\n",
+ "computer_move = choice(['rock', 'paper', 'scissor'])\n",
+ "\n",
+ "winner = findout_winner(user_move, computer_move)\n",
+ "\n",
+ "print(\"User Selected '{}' and computer selected '{}' , winner is: '{}' \".format(user_move, computer_move, winner))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Let’s do another one.**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "User Selected 'paper' and computer selected 'rock' , winner is: 'User' \n"
+ ]
+ }
+ ],
+ "source": [
+ "user_move = 'paper'\n",
+ "computer_move = choice(['rock', 'paper', 'scissor'])\n",
+ "\n",
+ "winner = findout_winner(user_move, computer_move)\n",
+ "\n",
+ "print(\"User Selected '{}' and computer selected '{}' , winner is: '{}' \".format(user_move, computer_move, winner))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Function for Showing the Winner for the Full Game \n",
+ "\n",
+ "This function decides who's the winner based on the points and then shows an image with results, After the game is over you can press 'ENTER' to play again or any other key to exit."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def show_winner(user_socre, computer_score): \n",
+ " \n",
+ " if user_score > computer_score:\n",
+ " img = cv2.imread(\"images/youwin.jpg\")\n",
+ " \n",
+ " elif user_score < computer_score:\n",
+ " img = cv2.imread(\"images/comwins.jpg\")\n",
+ " \n",
+ " else:\n",
+ " img = cv2.imread(\"images/draw.jpg\")\n",
+ " \n",
+ " cv2.putText(img, \"Press 'ENTER' to play again, else exit\",\n",
+ " (150, 530), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255), 3, cv2.LINE_AA)\n",
+ " \n",
+ " cv2.imshow(\"Rock Paper Scissors\", img)\n",
+ " \n",
+ " # If enter is pressed.\n",
+ " k = cv2.waitKey(0)\n",
+ " \n",
+ " # If the user presses 'ENTER' key then return TRUE, otherwise FALSE\n",
+ " if k == 13:\n",
+ " return True\n",
+ "\n",
+ " else:\n",
+ " return False"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Function for Displaying Computer's Move (Optional) \n",
+ "\n",
+ "This function displays a picture of either 'rock', 'paper' or 'scissor' based on what the computer played. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def display_computer_move(computer_move_name, frame):\n",
+ " \n",
+ " icon = cv2.imread( \"images/{}.png\".format(computer_move_name), 1)\n",
+ " icon = cv2.resize(icon, (224,224))\n",
+ " \n",
+ " # This is the portion which we are going to replace with the icon image\n",
+ " roi = frame[0:224, 0:224]\n",
+ "\n",
+ " # Get binary mask from the transparent image, 4th channel is the alpha channel \n",
+ " mask = icon[:,:,-1] \n",
+ "\n",
+ " # Making the mask completely binary (black & white)\n",
+ " mask = cv2.threshold(mask, 1, 255, cv2.THRESH_BINARY)[1]\n",
+ "\n",
+ " # Store the normal bgr image\n",
+ " icon_bgr = icon[:,:,:3] \n",
+ " \n",
+ " # Now combine the foreground of the icon with background of ROI \n",
+ " \n",
+ " img1_bg = cv2.bitwise_and(roi, roi, mask = cv2.bitwise_not(mask))\n",
+ "\n",
+ " img2_fg = cv2.bitwise_and(icon_bgr, icon_bgr, mask = mask)\n",
+ "\n",
+ " combined = cv2.add(img1_bg, img2_fg)\n",
+ "\n",
+ " frame[0:224, 0:224] = combined\n",
+ "\n",
+ " return frame"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Final Application "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cap = cv2.VideoCapture(0)\n",
+ "box_size = 234\n",
+ "width = int(cap.get(3))\n",
+ "\n",
+ "# Specify the number of attempts you want. This means best of 5.\n",
+ "attempts = 5\n",
+ "\n",
+ "# Initially the moves will be `nothing`\n",
+ "computer_move_name= \"nothing\"\n",
+ "final_user_move = \"nothing\"\n",
+ "\n",
+ "label_names = ['nothing', 'paper', 'rock', 'scissor']\n",
+ "\n",
+ "# All scores are 0 at the start.\n",
+ "computer_score, user_score = 0, 0\n",
+ "\n",
+ "# The default color of bounding box is Blue\n",
+ "rect_color = (255, 0, 0)\n",
+ "\n",
+ "# This variables remembers if the hand is inside the box or not.\n",
+ "hand_inside = False\n",
+ "\n",
+ "# At each iteration we will decrease the total_attempts value by 1\n",
+ "total_attempts = attempts\n",
+ "\n",
+ "# We will only consider predictions having confidence above this threshold.\n",
+ "confidence_threshold = 0.70\n",
+ "\n",
+ "# Instead of working on a single prediciton, we will take the mode of 5 predictons by using a deque object\n",
+ "# This way even if we face a false postive, we would easily ignore it\n",
+ "smooth_factor = 5\n",
+ "\n",
+ "# Our initial deque list will have 'nothing' repeated 5 times.\n",
+ "de = deque(['nothing'] * 5, maxlen=smooth_factor)\n",
+ "\n",
+ "while True:\n",
+ " \n",
+ " ret, frame = cap.read()\n",
+ " \n",
+ " if not ret:\n",
+ " break\n",
+ " \n",
+ " frame = cv2.flip(frame, 1)\n",
+ " \n",
+ " cv2.namedWindow(\"Rock Paper Scissors\", cv2.WINDOW_NORMAL)\n",
+ "\n",
+ " # extract the region of image within the user rectangle\n",
+ " roi = frame[5: box_size-5 , width-box_size + 5: width -5]\n",
+ " \n",
+ " roi = np.array([roi]).astype('float64') / 255.0\n",
+ " \n",
+ " # Predict the move made\n",
+ " pred = model.predict(roi)\n",
+ " \n",
+ " # Get the index of the predicted class\n",
+ " move_code = np.argmax(pred[0])\n",
+ " \n",
+ " # Get the class name of the predicted class\n",
+ " user_move = label_names[move_code]\n",
+ " \n",
+ " # Get the confidence of the predicted class\n",
+ " prob = np.max(pred[0])\n",
+ " \n",
+ " # Make sure the probability is above our defined threshold\n",
+ " if prob >= confidence_threshold:\n",
+ " \n",
+ " # Now add the move to deque list from left\n",
+ " de.appendleft(user_move)\n",
+ " \n",
+ " # Get the mode i.e. which class has occured more frequently in the last 5 moves.\n",
+ " try:\n",
+ " final_user_move = st.mode(de)[0][0] \n",
+ " \n",
+ " except StatisticsError:\n",
+ " print('Stats error')\n",
+ " continue\n",
+ " \n",
+ " # If nothing is not true and hand_inside is False then proceed.\n",
+ " # Basically the hand_inside variable is helping us to not repeatedly predict during the loop\n",
+ " # So now the user has to take his hands out of the box for every new predicton.\n",
+ " \n",
+ " if final_user_move != \"nothing\" and hand_inside == False:\n",
+ " \n",
+ " # Set hand inside to True\n",
+ " hand_inside = True \n",
+ " \n",
+ " # Get Computer's move and then get the winner.\n",
+ " computer_move_name = choice(['rock', 'paper', 'scissor'])\n",
+ " winner = findout_winner(final_user_move, computer_move_name)\n",
+ " \n",
+ " # Display the computer's move\n",
+ " display_computer_move(computer_move_name, frame)\n",
+ " \n",
+ " # Subtract one attempt\n",
+ " total_attempts -= 1\n",
+ " \n",
+ " # If winner is computer then it gets points and vice versa.\n",
+ " # We're also changing the color of rectangle based on who wins the round.\n",
+ "\n",
+ " if winner == \"Computer\":\n",
+ " computer_score +=1\n",
+ " rect_color = (0, 0, 255)\n",
+ "\n",
+ " elif winner == \"User\":\n",
+ " user_score += 1;\n",
+ " rect_color = (0, 250, 0)\n",
+ " \n",
+ " \n",
+ " elif winner == \"Tie\":\n",
+ " rect_color = (255, 250, 255)\n",
+ " \n",
+ " \n",
+ " # If all the attempts are up then find our the winner \n",
+ " if total_attempts == 0:\n",
+ " \n",
+ " play_again = show_winner(user_score, computer_score)\n",
+ " \n",
+ " # If the user pressed Enter then restart the game by re initializing all variables\n",
+ " if play_again:\n",
+ " user_score, computer_score, total_attempts = 0, 0, attempts\n",
+ " \n",
+ " # Otherwise quit the program.\n",
+ " else:\n",
+ " break\n",
+ " \n",
+ " # Display images when the hand is inside the box even when hand_inside variable is True.\n",
+ " elif final_user_move != \"nothing\" and hand_inside == True:\n",
+ " display_computer_move(computer_move_name, frame)\n",
+ " \n",
+ " # If class is nothing then hand_inside becomes False\n",
+ " elif final_user_move == 'nothing': \n",
+ " hand_inside = False\n",
+ " rect_color = (255, 0, 0)\n",
+ " \n",
+ "\n",
+ " # This is where all annotation is happening. \n",
+ "\n",
+ " cv2.putText(frame, \"Your Move: \" + final_user_move,\n",
+ " (420, 270), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1, cv2.LINE_AA)\n",
+ "\n",
+ " cv2.putText(frame, \"Computer's Move: \" + computer_move_name,\n",
+ " (2, 270), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1, cv2.LINE_AA)\n",
+ "\n",
+ " cv2.putText(frame, \"Your Score: \" + str(user_score),\n",
+ " (420, 300), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1, cv2.LINE_AA)\n",
+ " cv2.putText(frame, \"Computer Score: \" + str(computer_score),\n",
+ " (2, 300), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1, cv2.LINE_AA)\n",
+ " \n",
+ " cv2.putText(frame, \"Attempts left: {}\".format(total_attempts), (190, 400), cv2.FONT_HERSHEY_COMPLEX, 0.7,\n",
+ " (100, 2, 255), 1, cv2.LINE_AA)\n",
+ " \n",
+ " \n",
+ " cv2.rectangle(frame, (width - box_size, 0), (width, box_size), rect_color, 2)\n",
+ "\n",
+ " # Display the image \n",
+ " cv2.imshow(\"Rock Paper Scissors\", frame)\n",
+ "\n",
+ " # Exit if 'q' is pressed \n",
+ " k = cv2.waitKey(10)\n",
+ " if k == ord('q'):\n",
+ " break\n",
+ "\n",
+ "# Relase the camera and destroy all windows.\n",
+ "cap.release()\n",
+ "cv2.destroyAllWindows()"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Playing-rock-paper-scissors-with-AI/images/comwins.jpg b/Playing-rock-paper-scissors-with-AI/images/comwins.jpg
new file mode 100644
index 000000000..19b56c52f
Binary files /dev/null and b/Playing-rock-paper-scissors-with-AI/images/comwins.jpg differ
diff --git a/Playing-rock-paper-scissors-with-AI/images/draw.jpg b/Playing-rock-paper-scissors-with-AI/images/draw.jpg
new file mode 100644
index 000000000..95901f021
Binary files /dev/null and b/Playing-rock-paper-scissors-with-AI/images/draw.jpg differ
diff --git a/Playing-rock-paper-scissors-with-AI/images/paper.png b/Playing-rock-paper-scissors-with-AI/images/paper.png
new file mode 100644
index 000000000..e93c22b75
Binary files /dev/null and b/Playing-rock-paper-scissors-with-AI/images/paper.png differ
diff --git a/Playing-rock-paper-scissors-with-AI/images/rock.png b/Playing-rock-paper-scissors-with-AI/images/rock.png
new file mode 100644
index 000000000..ed3306be3
Binary files /dev/null and b/Playing-rock-paper-scissors-with-AI/images/rock.png differ
diff --git a/Playing-rock-paper-scissors-with-AI/images/scissor.png b/Playing-rock-paper-scissors-with-AI/images/scissor.png
new file mode 100644
index 000000000..2170bf96b
Binary files /dev/null and b/Playing-rock-paper-scissors-with-AI/images/scissor.png differ
diff --git a/Playing-rock-paper-scissors-with-AI/images/youwin.jpg b/Playing-rock-paper-scissors-with-AI/images/youwin.jpg
new file mode 100644
index 000000000..a279a191d
Binary files /dev/null and b/Playing-rock-paper-scissors-with-AI/images/youwin.jpg differ
diff --git a/Playing-rock-paper-scissors-with-AI/requirements.txt b/Playing-rock-paper-scissors-with-AI/requirements.txt
new file mode 100644
index 000000000..087e53b80
--- /dev/null
+++ b/Playing-rock-paper-scissors-with-AI/requirements.txt
@@ -0,0 +1,6 @@
+opencv-contrib-python==4.3.0
+scikit-learn==0.11
+tensorflow==2.2.0
+numpy==1.18.3
+matplotlib==3.1.0
+scipy==1.4.1
\ No newline at end of file
diff --git a/PyTorch-ONNX-TensorRT-CPP/CMakeLists.txt b/PyTorch-ONNX-TensorRT-CPP/CMakeLists.txt
new file mode 100644
index 000000000..bcdc05df2
--- /dev/null
+++ b/PyTorch-ONNX-TensorRT-CPP/CMakeLists.txt
@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.10)
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}" ${CMAKE_MODULE_PATH})
+
+project(TensorRTSample)
+
+find_package(Threads)
+find_package(CUDA REQUIRED)
+find_package(OpenCV REQUIRED)
+find_package(TensorRT REQUIRED)
+
+# TARGETS --------------------------------------------------------------------------------------------------------------
+add_executable(trt_sample trt_sample.cpp)
+target_include_directories(trt_sample PUBLIC ${OpenCV_INCLUDE_DIRS} ${CUDA_INCLUDE_DIRS} ${TensorRT_INCLUDE_DIRS})
+target_link_libraries(trt_sample PUBLIC ${OpenCV_LIBS} ${CUDA_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${TensorRT_LIBRARIES})
diff --git a/PyTorch-ONNX-TensorRT-CPP/FindTensorRT.cmake b/PyTorch-ONNX-TensorRT-CPP/FindTensorRT.cmake
new file mode 100644
index 000000000..abe5d0ac2
--- /dev/null
+++ b/PyTorch-ONNX-TensorRT-CPP/FindTensorRT.cmake
@@ -0,0 +1,87 @@
+# source:
+# https://github.com/NVIDIA/tensorrt-laboratory/blob/master/cmake/FindTensorRT.cmake
+
+# This module defines the following variables:
+#
+# ::
+#
+# TensorRT_INCLUDE_DIRS
+# TensorRT_LIBRARIES
+# TensorRT_FOUND
+#
+# ::
+#
+# TensorRT_VERSION_STRING - version (x.y.z)
+# TensorRT_VERSION_MAJOR - major version (x)
+# TensorRT_VERSION_MINOR - minor version (y)
+# TensorRT_VERSION_PATCH - patch version (z)
+#
+# Hints
+# ^^^^^
+# A user may set ``TensorRT_DIR`` to an installation root to tell this module where to look.
+#
+set(_TensorRT_SEARCHES)
+
+if(TensorRT_DIR)
+ set(_TensorRT_SEARCH_ROOT PATHS ${TensorRT_DIR} NO_DEFAULT_PATH)
+ list(APPEND _TensorRT_SEARCHES _TensorRT_SEARCH_ROOT)
+endif()
+
+# appends some common paths
+set(_TensorRT_SEARCH_NORMAL
+ PATHS "/usr"
+ )
+list(APPEND _TensorRT_SEARCHES _TensorRT_SEARCH_NORMAL)
+
+# Include dir
+foreach(search ${_TensorRT_SEARCHES})
+ find_path(TensorRT_INCLUDE_DIR NAMES NvInfer.h ${${search}} PATH_SUFFIXES include)
+endforeach()
+
+if(NOT TensorRT_LIBRARY)
+ foreach(search ${_TensorRT_SEARCHES})
+ find_library(TensorRT_LIBRARY NAMES nvinfer ${${search}} PATH_SUFFIXES lib)
+ endforeach()
+endif()
+
+if(NOT TensorRT_PARSERS_LIBRARY)
+ foreach(search ${_TensorRT_SEARCHES})
+ find_library(TensorRT_NVPARSERS_LIBRARY NAMES nvparsers ${${search}} PATH_SUFFIXES lib)
+ endforeach()
+endif()
+
+if(NOT TensorRT_NVONNXPARSER_LIBRARY)
+ foreach(search ${_TensorRT_SEARCHES})
+ find_library(TensorRT_NVONNXPARSER_LIBRARY NAMES nvonnxparser ${${search}} PATH_SUFFIXES lib)
+ endforeach()
+endif()
+
+mark_as_advanced(TensorRT_INCLUDE_DIR)
+
+if(TensorRT_INCLUDE_DIR AND EXISTS "${TensorRT_INCLUDE_DIR}/NvInfer.h")
+ file(STRINGS "${TensorRT_INCLUDE_DIR}/NvInfer.h" TensorRT_MAJOR REGEX "^#define NV_TENSORRT_MAJOR [0-9]+.*$")
+ file(STRINGS "${TensorRT_INCLUDE_DIR}/NvInfer.h" TensorRT_MINOR REGEX "^#define NV_TENSORRT_MINOR [0-9]+.*$")
+ file(STRINGS "${TensorRT_INCLUDE_DIR}/NvInfer.h" TensorRT_PATCH REGEX "^#define NV_TENSORRT_PATCH [0-9]+.*$")
+
+ string(REGEX REPLACE "^#define NV_TENSORRT_MAJOR ([0-9]+).*$" "\\1" TensorRT_VERSION_MAJOR "${TensorRT_MAJOR}")
+ string(REGEX REPLACE "^#define NV_TENSORRT_MINOR ([0-9]+).*$" "\\1" TensorRT_VERSION_MINOR "${TensorRT_MINOR}")
+ string(REGEX REPLACE "^#define NV_TENSORRT_PATCH ([0-9]+).*$" "\\1" TensorRT_VERSION_PATCH "${TensorRT_PATCH}")
+ set(TensorRT_VERSION_STRING "${TensorRT_VERSION_MAJOR}.${TensorRT_VERSION_MINOR}.${TensorRT_VERSION_PATCH}")
+endif()
+
+include(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(TensorRT REQUIRED_VARS TensorRT_LIBRARY TensorRT_INCLUDE_DIR VERSION_VAR TensorRT_VERSION_STRING)
+
+if(TensorRT_FOUND)
+ set(TensorRT_INCLUDE_DIRS ${TensorRT_INCLUDE_DIR})
+
+ if(NOT TensorRT_LIBRARIES)
+ set(TensorRT_LIBRARIES ${TensorRT_LIBRARY} ${TensorRT_NVONNXPARSER_LIBRARY} ${TensorRT_NVPARSERS_LIBRARY})
+ endif()
+
+ if(NOT TARGET TensorRT::TensorRT)
+ add_library(TensorRT::TensorRT UNKNOWN IMPORTED)
+ set_target_properties(TensorRT::TensorRT PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${TensorRT_INCLUDE_DIRS}")
+ set_property(TARGET TensorRT::TensorRT APPEND PROPERTY IMPORTED_LOCATION "${TensorRT_LIBRARY}")
+ endif()
+endif()
diff --git a/PyTorch-ONNX-TensorRT-CPP/README.md b/PyTorch-ONNX-TensorRT-CPP/README.md
new file mode 100644
index 000000000..ece14ec23
--- /dev/null
+++ b/PyTorch-ONNX-TensorRT-CPP/README.md
@@ -0,0 +1,34 @@
+# How To Run Inference Using TensorRT C++ API
+The blog post is here: https://www.learnopencv.com/how-to-run-inference-using-tensorrt-c-api/
+
+### To run PyTorch part:
+```shell script
+python3 -m pip install -r requirements.txt
+python3 pytorch_model.py
+```
+
+### To run TensorRT part:
+1. Install [CMake](https://cmake.org/) at least 3.10 version
+2. Download and install NVIDIA CUDA 10.0 or later following by official instruction: [link](https://developer.nvidia.com/cuda-10.0-download-archive)
+3. Download and extract CuDNN library for your CUDA version (login required): [link](https://developer.nvidia.com/rdp/cudnn-download)
+4. Download and extract NVIDIA TensorRT library for your CUDA version (login required): [link](https://developer.nvidia.com/nvidia-tensorrt-6x-download). The minimum required version is 6.0.1.5
+5. Add the path to CUDA, TensorRT, CuDNN to PATH variable (or LD_LIBRARY_PATH)
+6. Build or install a pre-built version of OpenCV and OpenCV Contrib. The minimum required version is 4.0.0.
+
+```shell script
+mkdir build
+cd build
+cmake -DOpenCV_DIR=[path-to-opencv-build] -DTensorRT_DIR=[path-to-tensorrt] ..
+make -j8
+trt_sample[.exe] resnet50.onnx turkish_coffee.jpg
+```
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
+
+
+
+
+
\ No newline at end of file
diff --git a/PyTorch-ONNX-TensorRT-CPP/imagenet_classes.txt b/PyTorch-ONNX-TensorRT-CPP/imagenet_classes.txt
new file mode 100644
index 000000000..722c98456
--- /dev/null
+++ b/PyTorch-ONNX-TensorRT-CPP/imagenet_classes.txt
@@ -0,0 +1,1000 @@
+tench, Tinca tinca
+goldfish, Carassius auratus
+great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+tiger shark, Galeocerdo cuvieri
+hammerhead, hammerhead shark
+electric ray, crampfish, numbfish, torpedo
+stingray
+cock
+hen
+ostrich, Struthio camelus
+brambling, Fringilla montifringilla
+goldfinch, Carduelis carduelis
+house finch, linnet, Carpodacus mexicanus
+junco, snowbird
+indigo bunting, indigo finch, indigo bird, Passerina cyanea
+robin, American robin, Turdus migratorius
+bulbul
+jay
+magpie
+chickadee
+water ouzel, dipper
+kite
+bald eagle, American eagle, Haliaeetus leucocephalus
+vulture
+great grey owl, great gray owl, Strix nebulosa
+European fire salamander, Salamandra salamandra
+common newt, Triturus vulgaris
+eft
+spotted salamander, Ambystoma maculatum
+axolotl, mud puppy, Ambystoma mexicanum
+bullfrog, Rana catesbeiana
+tree frog, tree-frog
+tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+loggerhead, loggerhead turtle, Caretta caretta
+leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+mud turtle
+terrapin
+box turtle, box tortoise
+banded gecko
+common iguana, iguana, Iguana iguana
+American chameleon, anole, Anolis carolinensis
+whiptail, whiptail lizard
+agama
+frilled lizard, Chlamydosaurus kingi
+alligator lizard
+Gila monster, Heloderma suspectum
+green lizard, Lacerta viridis
+African chameleon, Chamaeleo chamaeleon
+Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+African crocodile, Nile crocodile, Crocodylus niloticus
+American alligator, Alligator mississipiensis
+triceratops
+thunder snake, worm snake, Carphophis amoenus
+ringneck snake, ring-necked snake, ring snake
+hognose snake, puff adder, sand viper
+green snake, grass snake
+king snake, kingsnake
+garter snake, grass snake
+water snake
+vine snake
+night snake, Hypsiglena torquata
+boa constrictor, Constrictor constrictor
+rock python, rock snake, Python sebae
+Indian cobra, Naja naja
+green mamba
+sea snake
+horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+diamondback, diamondback rattlesnake, Crotalus adamanteus
+sidewinder, horned rattlesnake, Crotalus cerastes
+trilobite
+harvestman, daddy longlegs, Phalangium opilio
+scorpion
+black and gold garden spider, Argiope aurantia
+barn spider, Araneus cavaticus
+garden spider, Aranea diademata
+black widow, Latrodectus mactans
+tarantula
+wolf spider, hunting spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse, partridge, Bonasa umbellus
+prairie chicken, prairie grouse, prairie fowl
+peacock
+quail
+partridge
+African grey, African gray, Psittacus erithacus
+macaw
+sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser, Mergus serrator
+goose
+black swan, Cygnus atratus
+tusker
+echidna, spiny anteater, anteater
+platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+wallaby, brush kangaroo
+koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+wombat
+jellyfish
+sea anemone, anemone
+brain coral
+flatworm, platyhelminth
+nematode, nematode worm, roundworm
+conch
+snail
+slug
+sea slug, nudibranch
+chiton, coat-of-mail shell, sea cradle, polyplacophore
+chambered nautilus, pearly nautilus, nautilus
+Dungeness crab, Cancer magister
+rock crab, Cancer irroratus
+fiddler crab
+king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+American lobster, Northern lobster, Maine lobster, Homarus americanus
+spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+crayfish, crawfish, crawdad, crawdaddy
+hermit crab
+isopod
+white stork, Ciconia ciconia
+black stork, Ciconia nigra
+spoonbill
+flamingo
+little blue heron, Egretta caerulea
+American egret, great white heron, Egretta albus
+bittern
+crane
+limpkin, Aramus pictus
+European gallinule, Porphyrio porphyrio
+American coot, marsh hen, mud hen, water hen, Fulica americana
+bustard
+ruddy turnstone, Arenaria interpres
+red-backed sandpiper, dunlin, Erolia alpina
+redshank, Tringa totanus
+dowitcher
+oystercatcher, oyster catcher
+pelican
+king penguin, Aptenodytes patagonica
+albatross, mollymawk
+grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+dugong, Dugong dugon
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog, Maltese terrier, Maltese
+Pekinese, Pekingese, Peke
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound, Afghan
+basset, basset hound
+beagle
+bloodhound, sleuthhound
+bluetick
+black-and-tan coonhound
+Walker hound, Walker foxhound
+English foxhound
+redbone
+borzoi, Russian wolfhound
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound, Ibizan Podenco
+Norwegian elkhound, elkhound
+otterhound, otter hound
+Saluki, gazelle hound
+Scottish deerhound, deerhound
+Weimaraner
+Staffordshire bullterrier, Staffordshire bull terrier
+American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier, Sealyham
+Airedale, Airedale terrier
+cairn, cairn terrier
+Australian terrier
+Dandie Dinmont, Dandie Dinmont terrier
+Boston bull, Boston terrier
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier, Scottish terrier, Scottie
+Tibetan terrier, chrysanthemum dog
+silky terrier, Sydney silky
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa, Lhasa apso
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla, Hungarian pointer
+English setter
+Irish setter, red setter
+Gordon setter
+Brittany spaniel
+clumber, clumber spaniel
+English springer, English springer spaniel
+Welsh springer spaniel
+cocker spaniel, English cocker spaniel, cocker
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog, bobtail
+Shetland sheepdog, Shetland sheep dog, Shetland
+collie
+Border collie
+Bouvier des Flandres, Bouviers des Flandres
+Rottweiler
+German shepherd, German shepherd dog, German police dog, alsatian
+Doberman, Doberman pinscher
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard, St Bernard
+Eskimo dog, husky
+malamute, malemute, Alaskan malamute
+Siberian husky
+dalmatian, coach dog, carriage dog
+affenpinscher, monkey pinscher, monkey dog
+basenji
+pug, pug-dog
+Leonberg
+Newfoundland, Newfoundland dog
+Great Pyrenees
+Samoyed, Samoyede
+Pomeranian
+chow, chow chow
+keeshond
+Brabancon griffon
+Pembroke, Pembroke Welsh corgi
+Cardigan, Cardigan Welsh corgi
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf, grey wolf, gray wolf, Canis lupus
+white wolf, Arctic wolf, Canis lupus tundrarum
+red wolf, maned wolf, Canis rufus, Canis niger
+coyote, prairie wolf, brush wolf, Canis latrans
+dingo, warrigal, warragal, Canis dingo
+dhole, Cuon alpinus
+African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+hyena, hyaena
+red fox, Vulpes vulpes
+kit fox, Vulpes macrotis
+Arctic fox, white fox, Alopex lagopus
+grey fox, gray fox, Urocyon cinereoargenteus
+tabby, tabby cat
+tiger cat
+Persian cat
+Siamese cat, Siamese
+Egyptian cat
+cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+lynx, catamount
+leopard, Panthera pardus
+snow leopard, ounce, Panthera uncia
+jaguar, panther, Panthera onca, Felis onca
+lion, king of beasts, Panthera leo
+tiger, Panthera tigris
+cheetah, chetah, Acinonyx jubatus
+brown bear, bruin, Ursus arctos
+American black bear, black bear, Ursus americanus, Euarctos americanus
+ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+sloth bear, Melursus ursinus, Ursus ursinus
+mongoose
+meerkat, mierkat
+tiger beetle
+ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+ground beetle, carabid beetle
+long-horned beetle, longicorn, longicorn beetle
+leaf beetle, chrysomelid
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant, emmet, pismire
+grasshopper, hopper
+cricket
+walking stick, walkingstick, stick insect
+cockroach, roach
+mantis, mantid
+cicada, cicala
+leafhopper
+lacewing, lacewing fly
+dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+damselfly
+admiral
+ringlet, ringlet butterfly
+monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+cabbage butterfly
+sulphur butterfly, sulfur butterfly
+lycaenid, lycaenid butterfly
+starfish, sea star
+sea urchin
+sea cucumber, holothurian
+wood rabbit, cottontail, cottontail rabbit
+hare
+Angora, Angora rabbit
+hamster
+porcupine, hedgehog
+fox squirrel, eastern fox squirrel, Sciurus niger
+marmot
+beaver
+guinea pig, Cavia cobaya
+sorrel
+zebra
+hog, pig, grunter, squealer, Sus scrofa
+wild boar, boar, Sus scrofa
+warthog
+hippopotamus, hippo, river horse, Hippopotamus amphibius
+ox
+water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+bison
+ram, tup
+bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+ibex, Capra ibex
+hartebeest
+impala, Aepyceros melampus
+gazelle
+Arabian camel, dromedary, Camelus dromedarius
+llama
+weasel
+mink
+polecat, fitch, foulmart, foumart, Mustela putorius
+black-footed ferret, ferret, Mustela nigripes
+otter
+skunk, polecat, wood pussy
+badger
+armadillo
+three-toed sloth, ai, Bradypus tridactylus
+orangutan, orang, orangutang, Pongo pygmaeus
+gorilla, Gorilla gorilla
+chimpanzee, chimp, Pan troglodytes
+gibbon, Hylobates lar
+siamang, Hylobates syndactylus, Symphalangus syndactylus
+guenon, guenon monkey
+patas, hussar monkey, Erythrocebus patas
+baboon
+macaque
+langur
+colobus, colobus monkey
+proboscis monkey, Nasalis larvatus
+marmoset
+capuchin, ringtail, Cebus capucinus
+howler monkey, howler
+titi, titi monkey
+spider monkey, Ateles geoffroyi
+squirrel monkey, Saimiri sciureus
+Madagascar cat, ring-tailed lemur, Lemur catta
+indri, indris, Indri indri, Indri brevicaudatus
+Indian elephant, Elephas maximus
+African elephant, Loxodonta africana
+lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+barracouta, snoek
+eel
+coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+rock beauty, Holocanthus tricolor
+anemone fish
+sturgeon
+gar, garfish, garpike, billfish, Lepisosteus osseus
+lionfish
+puffer, pufferfish, blowfish, globefish
+abacus
+abaya
+academic gown, academic robe, judge's robe
+accordion, piano accordion, squeeze box
+acoustic guitar
+aircraft carrier, carrier, flattop, attack aircraft carrier
+airliner
+airship, dirigible
+altar
+ambulance
+amphibian, amphibious vehicle
+analog clock
+apiary, bee house
+apron
+ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+assault rifle, assault gun
+backpack, back pack, knapsack, packsack, rucksack, haversack
+bakery, bakeshop, bakehouse
+balance beam, beam
+balloon
+ballpoint, ballpoint pen, ballpen, Biro
+Band Aid
+banjo
+bannister, banister, balustrade, balusters, handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel, cask
+barrow, garden cart, lawn cart, wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap, swimming cap
+bath towel
+bathtub, bathing tub, bath, tub
+beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+beacon, lighthouse, beacon light, pharos
+beaker
+bearskin, busby, shako
+beer bottle
+beer glass
+bell cote, bell cot
+bib
+bicycle-built-for-two, tandem bicycle, tandem
+bikini, two-piece
+binder, ring-binder
+binoculars, field glasses, opera glasses
+birdhouse
+boathouse
+bobsled, bobsleigh, bob
+bolo tie, bolo, bola tie, bola
+bonnet, poke bonnet
+bookcase
+bookshop, bookstore, bookstall
+bottlecap
+bow
+bow tie, bow-tie, bowtie
+brass, memorial tablet, plaque
+brassiere, bra, bandeau
+breakwater, groin, groyne, mole, bulwark, seawall, jetty
+breastplate, aegis, egis
+broom
+bucket, pail
+buckle
+bulletproof vest
+bullet train, bullet
+butcher shop, meat market
+cab, hack, taxi, taxicab
+caldron, cauldron
+candle, taper, wax light
+cannon
+canoe
+can opener, tin opener
+cardigan
+car mirror
+carousel, carrousel, merry-go-round, roundabout, whirligig
+carpenter's kit, tool kit
+carton
+car wheel
+cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello, violoncello
+cellular telephone, cellular phone, cellphone, cell, mobile phone
+chain
+chainlink fence
+chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+chain saw, chainsaw
+chest
+chiffonier, commode
+chime, bell, gong
+china cabinet, china closet
+Christmas stocking
+church, church building
+cinema, movie theater, movie theatre, movie house, picture palace
+cleaver, meat cleaver, chopper
+cliff dwelling
+cloak
+clog, geta, patten, sabot
+cocktail shaker
+coffee mug
+coffeepot
+coil, spiral, volute, whorl, helix
+combination lock
+computer keyboard, keypad
+confectionery, confectionary, candy store
+container ship, containership, container vessel
+convertible
+corkscrew, bottle screw
+cornet, horn, trumpet, trump
+cowboy boot
+cowboy hat, ten-gallon hat
+cradle
+crane
+crash helmet
+crate
+crib, cot
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam, dike, dyke
+desk
+desktop computer
+dial telephone, dial phone
+diaper, nappy, napkin
+digital clock
+digital watch
+dining table, board
+dishrag, dishcloth
+dishwasher, dish washer, dishwashing machine
+disk brake, disc brake
+dock, dockage, docking facility
+dogsled, dog sled, dog sleigh
+dome
+doormat, welcome mat
+drilling platform, offshore rig
+drum, membranophone, tympan
+drumstick
+dumbbell
+Dutch oven
+electric fan, blower
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa, boa
+file, file cabinet, filing cabinet
+fireboat
+fire engine, fire truck
+fire screen, fireguard
+flagpole, flagstaff
+flute, transverse flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn, horn
+frying pan, frypan, skillet
+fur coat
+garbage truck, dustcart
+gasmask, respirator, gas helmet
+gas pump, gasoline pump, petrol pump, island dispenser
+goblet
+go-kart
+golf ball
+golfcart, golf cart
+gondola
+gong, tam-tam
+gown
+grand piano, grand
+greenhouse, nursery, glasshouse
+grille, radiator grille
+grocery store, grocery, food market, market
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower, blow dryer, blow drier, hair dryer, hair drier
+hand-held computer, hand-held microcomputer
+handkerchief, hankie, hanky, hankey
+hard disc, hard disk, fixed disk
+harmonica, mouth organ, harp, mouth harp
+harp
+harvester, reaper
+hatchet
+holster
+home theater, home theatre
+honeycomb
+hook, claw
+hoopskirt, crinoline
+horizontal bar, high bar
+horse cart, horse-cart
+hourglass
+iPod
+iron, smoothing iron
+jack-o'-lantern
+jean, blue jean, denim
+jeep, landrover
+jersey, T-shirt, tee shirt
+jigsaw puzzle
+jinrikisha, ricksha, rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat, laboratory coat
+ladle
+lampshade, lamp shade
+laptop, laptop computer
+lawn mower, mower
+lens cap, lens cover
+letter opener, paper knife, paperknife
+library
+lifeboat
+lighter, light, igniter, ignitor
+limousine, limo
+liner, ocean liner
+lipstick, lip rouge
+Loafer
+lotion
+loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+loupe, jeweler's loupe
+lumbermill, sawmill
+magnetic compass
+mailbag, postbag
+mailbox, letter box
+maillot
+maillot, tank suit
+manhole cover
+maraca
+marimba, xylophone
+mask
+matchstick
+maypole
+maze, labyrinth
+measuring cup
+medicine chest, medicine cabinet
+megalith, megalithic structure
+microphone, mike
+microwave, microwave oven
+military uniform
+milk can
+minibus
+miniskirt, mini
+minivan
+missile
+mitten
+mixing bowl
+mobile home, manufactured home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter, scooter
+mountain bike, all-terrain bike, off-roader
+mountain tent
+mouse, computer mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook, notebook computer
+obelisk
+oboe, hautboy, hautbois
+ocarina, sweet potato
+odometer, hodometer, mileometer, milometer
+oil filter
+organ, pipe organ
+oscilloscope, scope, cathode-ray oscilloscope, CRO
+overskirt
+oxcart
+oxygen mask
+packet
+paddle, boat paddle
+paddlewheel, paddle wheel
+padlock
+paintbrush
+pajama, pyjama, pj's, jammies
+palace
+panpipe, pandean pipe, syrinx
+paper towel
+parachute, chute
+parallel bars, bars
+park bench
+parking meter
+passenger car, coach, carriage
+patio, terrace
+pay-phone, pay-station
+pedestal, plinth, footstall
+pencil box, pencil case
+pencil sharpener
+perfume, essence
+Petri dish
+photocopier
+pick, plectrum, plectron
+pickelhaube
+picket fence, paling
+pickup, pickup truck
+pier
+piggy bank, penny bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate, pirate ship
+pitcher, ewer
+plane, carpenter's plane, woodworking plane
+planetarium
+plastic bag
+plate rack
+plow, plough
+plunger, plumber's helper
+Polaroid camera, Polaroid Land camera
+pole
+police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+poncho
+pool table, billiard table, snooker table
+pop bottle, soda bottle
+pot, flowerpot
+potter's wheel
+power drill
+prayer rug, prayer mat
+printer
+prison, prison house
+projectile, missile
+projector
+puck, hockey puck
+punching bag, punch bag, punching ball, punchball
+purse
+quill, quill pen
+quilt, comforter, comfort, puff
+racer, race car, racing car
+racket, racquet
+radiator
+radio, wireless
+radio telescope, radio reflector
+rain barrel
+recreational vehicle, RV, R.V.
+reel
+reflex camera
+refrigerator, icebox
+remote control, remote
+restaurant, eating house, eating place, eatery
+revolver, six-gun, six-shooter
+rifle
+rocking chair, rocker
+rotisserie
+rubber eraser, rubber, pencil eraser
+rugby ball
+rule, ruler
+running shoe
+safe
+safety pin
+saltshaker, salt shaker
+sandal
+sarong
+sax, saxophone
+scabbard
+scale, weighing machine
+school bus
+schooner
+scoreboard
+screen, CRT screen
+screw
+screwdriver
+seat belt, seatbelt
+sewing machine
+shield, buckler
+shoe shop, shoe-shop, shoe store
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule, slipstick
+sliding door
+slot, one-armed bandit
+snorkel
+snowmobile
+snowplow, snowplough
+soap dispenser
+soccer ball
+sock
+solar dish, solar collector, solar furnace
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web, spider's web
+spindle
+sports car, sport car
+spotlight, spot
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch, stop watch
+stove
+strainer
+streetcar, tram, tramcar, trolley, trolley car
+stretcher
+studio couch, day bed
+stupa, tope
+submarine, pigboat, sub, U-boat
+suit, suit of clothes
+sundial
+sunglass
+sunglasses, dark glasses, shades
+sunscreen, sunblock, sun blocker
+suspension bridge
+swab, swob, mop
+sweatshirt
+swimming trunks, bathing trunks
+swing
+switch, electric switch, electrical switch
+syringe
+table lamp
+tank, army tank, armored combat vehicle, armoured combat vehicle
+tape player
+teapot
+teddy, teddy bear
+television, television system
+tennis ball
+thatch, thatched roof
+theater curtain, theatre curtain
+thimble
+thresher, thrasher, threshing machine
+throne
+tile roof
+toaster
+tobacco shop, tobacconist shop, tobacconist
+toilet seat
+torch
+totem pole
+tow truck, tow car, wrecker
+toyshop
+tractor
+trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+tray
+trench coat
+tricycle, trike, velocipede
+trimaran
+tripod
+triumphal arch
+trolleybus, trolley coach, trackless trolley
+trombone
+tub, vat
+turnstile
+typewriter keyboard
+umbrella
+unicycle, monocycle
+upright, upright piano
+vacuum, vacuum cleaner
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin, fiddle
+volleyball
+waffle iron
+wall clock
+wallet, billfold, notecase, pocketbook
+wardrobe, closet, press
+warplane, military plane
+washbasin, handbasin, washbowl, lavabo, wash-hand basin
+washer, automatic washer, washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool, woolen, woollen
+worm fence, snake fence, snake-rail fence, Virginia fence
+wreck
+yawl
+yurt
+web site, website, internet site, site
+comic book
+crossword puzzle, crossword
+street sign
+traffic light, traffic signal, stoplight
+book jacket, dust cover, dust jacket, dust wrapper
+menu
+plate
+guacamole
+consomme
+hot pot, hotpot
+trifle
+ice cream, icecream
+ice lolly, lolly, lollipop, popsicle
+French loaf
+bagel, beigel
+pretzel
+cheeseburger
+hotdog, hot dog, red hot
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini, courgette
+spaghetti squash
+acorn squash
+butternut squash
+cucumber, cuke
+artichoke, globe artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple, ananas
+banana
+jackfruit, jak, jack
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce, chocolate syrup
+dough
+meat loaf, meatloaf
+pizza, pizza pie
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff, drop, drop-off
+coral reef
+geyser
+lakeside, lakeshore
+promontory, headland, head, foreland
+sandbar, sand bar
+seashore, coast, seacoast, sea-coast
+valley, vale
+volcano
+ballplayer, baseball player
+groom, bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+corn
+acorn
+hip, rose hip, rosehip
+buckeye, horse chestnut, conker
+coral fungus
+agaric
+gyromitra
+stinkhorn, carrion fungus
+earthstar
+hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+bolete
+ear, spike, capitulum
+toilet tissue, toilet paper, bathroom tissue
\ No newline at end of file
diff --git a/PyTorch-ONNX-TensorRT-CPP/pytorch_model.py b/PyTorch-ONNX-TensorRT-CPP/pytorch_model.py
new file mode 100644
index 000000000..d3d79a5c4
--- /dev/null
+++ b/PyTorch-ONNX-TensorRT-CPP/pytorch_model.py
@@ -0,0 +1,79 @@
+import cv2
+import onnx
+import torch
+from albumentations import (Compose,Resize,)
+from albumentations.augmentations.transforms import Normalize
+from albumentations.pytorch.transforms import ToTensor
+from torchvision import models
+
+
+def preprocess_image(img_path):
+ # transformations for the input data
+ transforms = Compose([
+ Resize(224, 224, interpolation=cv2.INTER_NEAREST),
+ Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+ ToTensor(),
+ ])
+
+ # read input image
+ input_img = cv2.imread(img_path)
+ # do transformations
+ input_data = transforms(image=input_img)["image"]
+ # prepare batch
+ batch_data = torch.unsqueeze(input_data, 0)
+
+ return batch_data
+
+
+def postprocess(output_data):
+ # get class names
+ with open("imagenet_classes.txt") as f:
+ classes = [line.strip() for line in f.readlines()]
+ # calculate human-readable value by softmax
+ confidences = torch.nn.functional.softmax(output_data, dim=1)[0] * 100
+ # find top predicted classes
+ _, indices = torch.sort(output_data, descending=True)
+ i = 0
+ # print the top classes predicted by the model
+ while confidences[indices[0][i]] > 0.5:
+ class_idx = indices[0][i]
+ print(
+ "class:",
+ classes[class_idx],
+ ", confidence:",
+ confidences[class_idx].item(),
+ "%, index:",
+ class_idx.item(),
+ )
+ i += 1
+
+
+def main():
+ # load pre-trained model -------------------------------------------------------------------------------------------
+ model = models.resnet50(pretrained=True)
+
+ # preprocessing stage ----------------------------------------------------------------------------------------------
+ input = preprocess_image("turkish_coffee.jpg").cuda()
+
+ # inference stage --------------------------------------------------------------------------------------------------
+ model.eval()
+ model.cuda()
+ output = model(input)
+
+ # post-processing stage --------------------------------------------------------------------------------------------
+ postprocess(output)
+
+ # convert to ONNX --------------------------------------------------------------------------------------------------
+ ONNX_FILE_PATH = "resnet50.onnx"
+ torch.onnx.export(model, input, ONNX_FILE_PATH, input_names=["input"], output_names=["output"], export_params=True)
+
+ onnx_model = onnx.load(ONNX_FILE_PATH)
+ # check that the model converted fine
+ onnx.checker.check_model(onnx_model)
+
+ print("Model was successfully converted to ONNX format.")
+ print("It was saved to", ONNX_FILE_PATH)
+
+
+if __name__ == '__main__':
+ main()
diff --git a/PyTorch-ONNX-TensorRT-CPP/requirements.txt b/PyTorch-ONNX-TensorRT-CPP/requirements.txt
new file mode 100644
index 000000000..853ddc03c
--- /dev/null
+++ b/PyTorch-ONNX-TensorRT-CPP/requirements.txt
@@ -0,0 +1,6 @@
+torch==1.2.0
+torchvision==0.4.0
+albumentations==0.4.5
+onnx==1.4.1
+opencv-python==4.2.0.34
+
diff --git a/PyTorch-ONNX-TensorRT-CPP/resnet50.onnx b/PyTorch-ONNX-TensorRT-CPP/resnet50.onnx
new file mode 100644
index 000000000..ec9fc652f
--- /dev/null
+++ b/PyTorch-ONNX-TensorRT-CPP/resnet50.onnx
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c904c5d300d569ebb82fdc0701161659a371c122531232bc909afda33262e379
+size 102483848
diff --git a/PyTorch-ONNX-TensorRT-CPP/trt_inference.py b/PyTorch-ONNX-TensorRT-CPP/trt_inference.py
new file mode 100644
index 000000000..4354bfbc4
--- /dev/null
+++ b/PyTorch-ONNX-TensorRT-CPP/trt_inference.py
@@ -0,0 +1,76 @@
+from pytorch_model import preprocess_image, postprocess
+import torch
+import pycuda.driver as cuda
+import pycuda.autoinit
+import numpy as np
+import tensorrt as trt
+
+
+ONNX_FILE_PATH = "resnet50.onnx"
+# logger to capture errors, warnings, and other information during the build and inference phases
+TRT_LOGGER = trt.Logger()
+
+
+def build_engine(onnx_file_path):
+ # initialize TensorRT engine and parse ONNX model
+ builder = trt.Builder(TRT_LOGGER)
+ network = builder.create_network()
+ parser = trt.OnnxParser(network, TRT_LOGGER)
+
+ # allow TensorRT to use up to 1GB of GPU memory for tactic selection
+ builder.max_workspace_size = 1 << 30
+ # we have only one image in batch
+ builder.max_batch_size = 1
+ # use FP16 mode if possible
+ if builder.platform_has_fast_fp16:
+ builder.fp16_mode = True
+
+ # parse ONNX
+ with open(onnx_file_path, 'rb') as model:
+ print('Beginning ONNX file parsing')
+ parser.parse(model.read())
+ print('Completed parsing of ONNX file')
+
+ # generate TensorRT engine optimized for the target platform
+ print('Building an engine...')
+ engine = builder.build_cuda_engine(network)
+ context = engine.create_execution_context()
+ print("Completed creating Engine")
+ return engine, context
+
+
+def main():
+ # initialize TensorRT engine and parse ONNX model
+ engine, context = build_engine(ONNX_FILE_PATH)
+ # get sizes of input and output and allocate memory required for input data and for output data
+ for binding in engine:
+ if engine.binding_is_input(binding): # we expect only one input
+ input_shape = engine.get_binding_shape(binding)
+ input_size = trt.volume(input_shape) * engine.max_batch_size * np.dtype(np.float32).itemsize # in bytes
+ device_input = cuda.mem_alloc(input_size)
+ else: # and one output
+ output_shape = engine.get_binding_shape(binding)
+ # create page-locked memory buffers (i.e. won't be swapped to disk)
+ host_output = cuda.pagelocked_empty(trt.volume(output_shape) * engine.max_batch_size, dtype=np.float32)
+ device_output = cuda.mem_alloc(host_output.nbytes)
+
+ # Create a stream in which to copy inputs/outputs and run inference.
+ stream = cuda.Stream()
+
+
+ # preprocess input data
+ host_input = np.array(preprocess_image("turkish_coffee.jpg").numpy(), dtype=np.float32, order='C')
+ cuda.memcpy_htod_async(device_input, host_input, stream)
+
+ # run inference
+ context.execute_async(bindings=[int(device_input), int(device_output)], stream_handle=stream.handle)
+ cuda.memcpy_dtoh_async(host_output, device_output, stream)
+ stream.synchronize()
+
+ # postprocess results
+ output_data = torch.Tensor(host_output).reshape(engine.max_batch_size, output_shape[0])
+ postprocess(output_data)
+
+
+if __name__ == '__main__':
+ main()
diff --git a/PyTorch-ONNX-TensorRT-CPP/trt_sample.cpp b/PyTorch-ONNX-TensorRT-CPP/trt_sample.cpp
new file mode 100644
index 000000000..656d5b2a9
--- /dev/null
+++ b/PyTorch-ONNX-TensorRT-CPP/trt_sample.cpp
@@ -0,0 +1,219 @@
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+// utilities ----------------------------------------------------------------------------------------------------------
+// class to log errors, warnings, and other information during the build and inference phases
+class Logger : public nvinfer1::ILogger
+{
+public:
+ void log(Severity severity, const char* msg) override {
+ // remove this 'if' if you need more logged info
+ if ((severity == Severity::kERROR) || (severity == Severity::kINTERNAL_ERROR)) {
+ std::cout << msg << "\n";
+ }
+ }
+} gLogger;
+
+// destroy TensorRT objects if something goes wrong
+struct TRTDestroy
+{
+ template
+ void operator()(T* obj) const
+ {
+ if (obj)
+ {
+ obj->destroy();
+ }
+ }
+};
+
+template
+using TRTUniquePtr = std::unique_ptr;
+
+// calculate size of tensor
+size_t getSizeByDim(const nvinfer1::Dims& dims)
+{
+ size_t size = 1;
+ for (size_t i = 0; i < dims.nbDims; ++i)
+ {
+ size *= dims.d[i];
+ }
+ return size;
+}
+
+// get classes names
+std::vector getClassNames(const std::string& imagenet_classes)
+{
+ std::ifstream classes_file(imagenet_classes);
+ std::vector classes;
+ if (!classes_file.good())
+ {
+ std::cerr << "ERROR: can't read file with classes names.\n";
+ return classes;
+ }
+ std::string class_name;
+ while (std::getline(classes_file, class_name))
+ {
+ classes.push_back(class_name);
+ }
+ return classes;
+}
+
+// preprocessing stage ------------------------------------------------------------------------------------------------
+void preprocessImage(const std::string& image_path, float* gpu_input, const nvinfer1::Dims& dims)
+{
+ // read input image
+ cv::Mat frame = cv::imread(image_path);
+ if (frame.empty())
+ {
+ std::cerr << "Input image " << image_path << " load failed\n";
+ return;
+ }
+ cv::cuda::GpuMat gpu_frame;
+ // upload image to GPU
+ gpu_frame.upload(frame);
+
+ auto input_width = dims.d[2];
+ auto input_height = dims.d[1];
+ auto channels = dims.d[0];
+ auto input_size = cv::Size(input_width, input_height);
+ // resize
+ cv::cuda::GpuMat resized;
+ cv::cuda::resize(gpu_frame, resized, input_size, 0, 0, cv::INTER_NEAREST);
+ // normalize
+ cv::cuda::GpuMat flt_image;
+ resized.convertTo(flt_image, CV_32FC3, 1.f / 255.f);
+ cv::cuda::subtract(flt_image, cv::Scalar(0.485f, 0.456f, 0.406f), flt_image, cv::noArray(), -1);
+ cv::cuda::divide(flt_image, cv::Scalar(0.229f, 0.224f, 0.225f), flt_image, 1, -1);
+ // to tensor
+ std::vector chw;
+ for (size_t i = 0; i < channels; ++i)
+ {
+ chw.emplace_back(cv::cuda::GpuMat(input_size, CV_32FC1, gpu_input + i * input_width * input_height));
+ }
+ cv::cuda::split(flt_image, chw);
+}
+
+// post-processing stage ----------------------------------------------------------------------------------------------
+void postprocessResults(float *gpu_output, const nvinfer1::Dims &dims, int batch_size)
+{
+ // get class names
+ auto classes = getClassNames("imagenet_classes.txt");
+
+ // copy results from GPU to CPU
+ std::vector cpu_output(getSizeByDim(dims) * batch_size);
+ cudaMemcpy(cpu_output.data(), gpu_output, cpu_output.size() * sizeof(float), cudaMemcpyDeviceToHost);
+
+ // calculate softmax
+ std::transform(cpu_output.begin(), cpu_output.end(), cpu_output.begin(), [](float val) {return std::exp(val);});
+ auto sum = std::accumulate(cpu_output.begin(), cpu_output.end(), 0.0);
+ // find top classes predicted by the model
+ std::vector indices(getSizeByDim(dims) * batch_size);
+ std::iota(indices.begin(), indices.end(), 0); // generate sequence 0, 1, 2, 3, ..., 999
+ std::sort(indices.begin(), indices.end(), [&cpu_output](int i1, int i2) {return cpu_output[i1] > cpu_output[i2];});
+ // print results
+ int i = 0;
+ while (cpu_output[indices[i]] / sum > 0.005)
+ {
+ if (classes.size() > indices[i])
+ {
+ std::cout << "class: " << classes[indices[i]] << " | ";
+ }
+ std::cout << "confidence: " << 100 * cpu_output[indices[i]] / sum << "% | index: " << indices[i] << "\n";
+ ++i;
+ }
+}
+
+// initialize TensorRT engine and parse ONNX model --------------------------------------------------------------------
+void parseOnnxModel(const std::string& model_path, TRTUniquePtr& engine,
+ TRTUniquePtr& context)
+{
+ TRTUniquePtr builder{nvinfer1::createInferBuilder(gLogger)};
+ TRTUniquePtr network{builder->createNetwork()};
+ TRTUniquePtr parser{nvonnxparser::createParser(*network, gLogger)};
+ TRTUniquePtr config{builder->createBuilderConfig()};
+ // parse ONNX
+ if (!parser->parseFromFile(model_path.c_str(), static_cast(nvinfer1::ILogger::Severity::kINFO)))
+ {
+ std::cerr << "ERROR: could not parse the model.\n";
+ return;
+ }
+ // allow TensorRT to use up to 1GB of GPU memory for tactic selection.
+ config->setMaxWorkspaceSize(1ULL << 30);
+ // use FP16 mode if possible
+ if (builder->platformHasFastFp16())
+ {
+ config->setFlag(nvinfer1::BuilderFlag::kFP16);
+ }
+ // we have only one image in batch
+ builder->setMaxBatchSize(1);
+ // generate TensorRT engine optimized for the target platform
+ engine.reset(builder->buildEngineWithConfig(*network, *config));
+ context.reset(engine->createExecutionContext());
+}
+
+// main pipeline ------------------------------------------------------------------------------------------------------
+int main(int argc, char* argv[])
+{
+ if (argc < 3)
+ {
+ std::cerr << "usage: " << argv[0] << " model.onnx image.jpg\n";
+ return -1;
+ }
+ std::string model_path(argv[1]);
+ std::string image_path(argv[2]);
+ int batch_size = 1;
+
+ // initialize TensorRT engine and parse ONNX model
+ TRTUniquePtr engine{nullptr};
+ TRTUniquePtr context{nullptr};
+ parseOnnxModel(model_path, engine, context);
+
+ // get sizes of input and output and allocate memory required for input data and for output data
+ std::vector input_dims; // we expect only one input
+ std::vector output_dims; // and one output
+ std::vector buffers(engine->getNbBindings()); // buffers for input and output data
+ for (size_t i = 0; i < engine->getNbBindings(); ++i)
+ {
+ auto binding_size = getSizeByDim(engine->getBindingDimensions(i)) * batch_size * sizeof(float);
+ cudaMalloc(&buffers[i], binding_size);
+ if (engine->bindingIsInput(i))
+ {
+ input_dims.emplace_back(engine->getBindingDimensions(i));
+ }
+ else
+ {
+ output_dims.emplace_back(engine->getBindingDimensions(i));
+ }
+ }
+ if (input_dims.empty() || output_dims.empty())
+ {
+ std::cerr << "Expect at least one input and one output for network\n";
+ return -1;
+ }
+
+ // preprocess input data
+ preprocessImage(image_path, (float *) buffers[0], input_dims[0]);
+ // inference
+ context->enqueue(batch_size, buffers.data(), 0, nullptr);
+ // postprocess results
+ postprocessResults((float *) buffers[1], output_dims[0], batch_size);
+
+ for (void* buf : buffers)
+ {
+ cudaFree(buf);
+ }
+ return 0;
+}
diff --git a/PyTorch-ONNX-TensorRT-CPP/turkish_coffee.jpg b/PyTorch-ONNX-TensorRT-CPP/turkish_coffee.jpg
new file mode 100644
index 000000000..23a65a196
Binary files /dev/null and b/PyTorch-ONNX-TensorRT-CPP/turkish_coffee.jpg differ
diff --git a/PyTorch-Receptive-Field-With-Backprop/receptive_field_backpropagation.py b/PyTorch-Receptive-Field-With-Backprop/receptive_field_backpropagation.py
index 06ef4f292..eef3f077c 100644
--- a/PyTorch-Receptive-Field-With-Backprop/receptive_field_backpropagation.py
+++ b/PyTorch-Receptive-Field-With-Backprop/receptive_field_backpropagation.py
@@ -7,9 +7,11 @@
from torchvision import transforms
from FullyConvolutionalResnet18 import FullyConvolutionalResnet18
+import imutils
Rect = namedtuple('Rect', 'x1 y1 x2 y2')
+displayWidth = 1024
def backprop_receptive_field(image, predicted_class, scoremap, use_max_activation=True):
model = FullyConvolutionalResnet18()
@@ -137,18 +139,23 @@ def run_resnet_inference(original_image):
score_map = preds[0, predicted_class, :, :].cpu()
print('Score Map shape : ', score_map.shape)
- # Compute the receptive filed for the inference result
+ # Compute the receptive filed for the inference result for max activated pixel
receptive_field_map = backprop_receptive_field(image, scoremap=score_map, predicted_class=predicted_class)
+
+ # Compute the receptive filed for the inference result for the net prediction
+ receptive_field_net_pred_map = backprop_receptive_field(image, scoremap=score_map, predicted_class=predicted_class, use_max_activation=False)
# Resize score map to the original image size
score_map = score_map.numpy()[0]
score_map = cv2.resize(score_map, (original_image.shape[1], original_image.shape[0]))
# Display the images
- cv2.imshow("Original Image", original_image)
- cv2.imshow("Score map: activations and bbox", visualize_activations(original_image, score_map))
- cv2.imshow("receptive_field_max_activation", visualize_activations(original_image, receptive_field_map, show_bounding_rect=True))
+ cv2.imshow("Original Image", imutils.resize(original_image,width=displayWidth))
+ cv2.imshow("Score map: activations and bbox", imutils.resize(visualize_activations(original_image, score_map,show_bounding_rect=True),width=displayWidth))
+ cv2.imshow("receptive_field_max_activation", imutils.resize(visualize_activations(original_image, receptive_field_map, show_bounding_rect=True),width=displayWidth))
+ cv2.imshow("receptive_field_net_prediction", imutils.resize(visualize_activations(original_image, receptive_field_net_pred_map, show_bounding_rect=True),width=displayWidth))
cv2.waitKey(0)
+ cv2.destroyAllWindows()
def main():
diff --git a/PyTorch-Vision-Experiment-Logging/README.md b/PyTorch-Vision-Experiment-Logging/README.md
new file mode 100644
index 000000000..8eec3c0fc
--- /dev/null
+++ b/PyTorch-Vision-Experiment-Logging/README.md
@@ -0,0 +1,11 @@
+This contains the code for **Experiment Logging with TensorBoard and wandb**. For more information - visit [**Experiment Logging with TensorBoard and wandb**](https://www.learnopencv.com/experiment-logging-with-tensorboard-and-wandb)
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
+
+
+
+
+
\ No newline at end of file
diff --git a/PyTorch-Vision-Experiment-Logging/Torchvision-Experiment-Logging.ipynb b/PyTorch-Vision-Experiment-Logging/Torchvision-Experiment-Logging.ipynb
new file mode 100644
index 000000000..44b01f0cb
--- /dev/null
+++ b/PyTorch-Vision-Experiment-Logging/Torchvision-Experiment-Logging.ipynb
@@ -0,0 +1,858 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "experiment-logging.ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "toc_visible": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "accelerator": "GPU"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "colab_type": "text",
+ "id": "view-in-github"
+ },
+ "source": [
+ "
+
+
+
diff --git a/PyTorch-to-CoreML-model-conversion/requirements.txt b/PyTorch-to-CoreML-model-conversion/requirements.txt
new file mode 100644
index 000000000..9e9cdf3af
--- /dev/null
+++ b/PyTorch-to-CoreML-model-conversion/requirements.txt
@@ -0,0 +1,8 @@
+coremltools==3.4
+numpy==1.19.0
+onnx==1.7.0
+onnx-coreml==1.3
+onnx-simplifier==0.2.10
+onnxruntime==1.3.0
+torch==1.4.0
+torchvision==0.5.0
diff --git a/PyTorch-to-CoreML-model-conversion/torch_to_coreml.py b/PyTorch-to-CoreML-model-conversion/torch_to_coreml.py
new file mode 100644
index 000000000..7210541e2
--- /dev/null
+++ b/PyTorch-to-CoreML-model-conversion/torch_to_coreml.py
@@ -0,0 +1,155 @@
+import argparse
+import platform
+
+import coremltools
+import numpy as np
+import onnx
+import onnxruntime
+import torch
+import torch.onnx
+import torchvision
+from onnx_coreml import convert
+from onnxsim import simplify
+
+
+def check_onnx_output(filename, input_data, torch_output):
+ session = onnxruntime.InferenceSession(filename)
+ input_name = session.get_inputs()[0].name
+ result = session.run([], {input_name: input_data.numpy()})
+ for test_result, gold_result in zip(result, torch_output.values()):
+ np.testing.assert_almost_equal(
+ gold_result.cpu().numpy(), test_result, decimal=3,
+ )
+ return result
+
+
+def check_onnx_model(model, onnx_filename, input_image):
+ with torch.no_grad():
+ torch_out = {"output": model(input_image)}
+ check_onnx_output(onnx_filename, input_image, torch_out)
+ print("PyTorch output and ONNX output values are equal")
+ onnx_model = onnx.load(onnx_filename)
+ onnx.checker.check_model(onnx_model)
+ print("The model is checked!")
+ return onnx_model
+
+
+def check_coreml_model(coreml_filename, torch_model, input_data):
+
+ # get PyTorch model output
+ with torch.no_grad():
+ torch_output = {"output": torch_model(input_data)}
+
+ # get CoreML model output
+ coreml_model = coremltools.models.MLModel(coreml_filename, useCPUOnly=True)
+
+ # convert input to numpy and get coreml model prediction
+ input_data = input_data.cpu().numpy()
+ pred = coreml_model.predict({"input": input_data})
+
+ for key in pred:
+ np.testing.assert_almost_equal(
+ torch_output[key].cpu().numpy(), pred[key], decimal=3,
+ )
+ print("CoreML model is checked!")
+ return pred
+
+
+def save_onnx_from_torch(
+ model, model_name, input_image, input_names=None, output_names=None, simplify=False,
+):
+ # Section 1: PyTorch model conversion --
+ if input_names is None:
+ input_names = ["input"]
+ if output_names is None:
+ output_names = ["output"]
+
+ # set mode to evaluation and change device to cpu
+ model.eval()
+ model.cpu()
+ onnx_filename = model_name + ".onnx"
+
+ # export our model to ONNX format
+ torch.onnx.export(
+ model,
+ input_image,
+ onnx_filename,
+ verbose=True,
+ input_names=input_names,
+ output_names=output_names,
+ )
+
+ # Section 2: Model testing
+ onnx_model = check_onnx_model(model, onnx_filename, input_image)
+
+ # Section 3: ONNX simplifier
+ if simplify:
+ filename = model_name + "_simplified.onnx"
+ onnx_model_simplified, check = simplify_onnx(onnx_model, filename)
+ onnx.checker.check_model(onnx_model_simplified)
+ check_onnx_model(model, filename, input_image)
+ return onnx_model_simplified
+ else:
+ return onnx_model
+
+
+def simplify_onnx(onnx_model, filename):
+ simplified_model, check = simplify(onnx_model)
+ onnx.save_model(simplified_model, filename)
+ return simplified_model, check
+
+
+def convert_onnx_to_coreml(onnx_model, model_name, torch_model, input_data):
+ model_coreml = convert(onnx_model, minimum_ios_deployment_target="13")
+ coreml_filename = model_name + ".mlmodel"
+ model_coreml.save(coreml_filename)
+ if platform.system() == "Darwin":
+ check_coreml_model(coreml_filename, torch_model, input_data)
+ return model_coreml
+
+
+def main(args):
+ state = 42
+ np.random.seed(state)
+ torch.manual_seed(state)
+
+ print("Start model conversion")
+ model_name = args.model_name
+ input_size = args.input_size
+ simp = args.simplify
+
+ # get model from torchvision
+ torch_model = getattr(torchvision.models, model_name)(pretrained=True)
+
+ # random image to make a network forward pass
+ dummy_input = torch.randn(1, 3, input_size, input_size, device="cpu")
+
+ # save ONNX model
+ onnx_model = save_onnx_from_torch(
+ torch_model, model_name, input_image=dummy_input, simplify=simp,
+ )
+ convert_onnx_to_coreml(
+ onnx_model, model_name, torch_model=torch_model, input_data=dummy_input,
+ )
+
+ print("PyTorch model has been converted to CoreML format")
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser()
+ parser.add_argument(
+ "--model_name",
+ "-mn",
+ required=True,
+ type=str,
+ help="model name from torchvision.model",
+ )
+ parser.add_argument(
+ "--simplify",
+ "-s",
+ action="store_true",
+ help="Simplify ONNX model using onnx-simplifier",
+ )
+ parser.add_argument("--input_size", default=224, type=int, help="input image size")
+ args = parser.parse_args()
+ main(args)
diff --git a/README.md b/README.md
index 5c031070f..34f4d1c4c 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
# LearnOpenCV
-This repo contains code for Computer Vision, Deep learning, and AI articles shared on our blog [LearnOpenCV.com](https://www.LearnOpenCV.com).
+This repo contains code for Computer Vision, Deep learning, and AI articles shared on our blog [LearnOpenCV.com](https://www.LearnOpenCV.com).
-Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
-
+
@@ -14,6 +14,22 @@ Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/course
| Blog Post | |
| ------------- |:-------------|
|[PyTorch to Tensorflow Model Conversion](https://www.learnopencv.com/pytorch-to-tensorflow-model-conversion/) | [Code](https://github.com/spmallick/learnopencv/tree/master/PyTorch-to-TensorFlow-Model-Conversion) |
+|[Snake Game with OpenCV Python](https://www.learnopencv.com/snake-game-with-opencv-python/)|[Code](https://github.com/spmallick/learnopencv/tree/master/SnakeGame)|
+|[Stanford MRNet Challenge: Classifying Knee MRIs](https://www.learnopencv.com/stanford-mrnet-challenge-classifying-knee-mris/)|[Code](https://github.com/spmallick/learnopencv/tree/master/MRNet-Single-Model)|
+|[Experiment Logging with TensorBoard and wandb](https://www.learnopencv.com/experiment-logging-with-tensorboard-and-wandb)|[Code](https://github.com/spmallick/learnopencv/tree/master/PyTorch-Vision-Experiment-Logging)|
+|[Understanding Lens Distortion](https://www.learnopencv.com/understanding-lens-distortion/)|[Code](https://github.com/spmallick/learnopencv/tree/master/UnderstandingLensDistortion)|
+|[Image Matting with state-of-the-art Method “F, B, Alpha Matting”](https://www.learnopencv.com/image-matting-with-state-of-the-art-method-f-b-alpha-matting/)|[Code](https://github.com/spmallick/learnopencv/tree/master/FBAMatting) |
+|[Bag Of Tricks For Image Classification - Let's check if it is working or not](https://www.learnopencv.com/bag-of-tricks-for-image-classification-lets-check-if-it-is-working-or-not/)| [Code](https://github.com/spmallick/learnopencv/tree/master/Bag-Of-Tricks-For-Image-Classification)
+|[Getting Started with OpenCV CUDA Module](https://www.learnopencv.com/getting-started-opencv-cuda-module/)|[Code](https://github.com/spmallick/learnopencv/tree/master/Getting-Started-OpenCV-CUDA-Module)|
+|[Training a Custom Object Detector with DLIB & Making Gesture Controlled Applications](https://www.learnopencv.com/training-a-custom-object-detector-with-dlib-making-gesture-controlled-applications/)|[Code](https://github.com/spmallick/learnopencv/tree/master/Training_a_custom_hand_detector_with_dlib) |
+|[How To Run Inference Using TensorRT C++ API](https://www.learnopencv.com/how-to-run-inference-using-tensorrt-c-api/) | [Code](https://github.com/spmallick/learnopencv/tree/master/PyTorch-ONNX-TensorRT-CPP) |
+|[Using Facial Landmarks for Overlaying Faces with Medical Masks](https://www.learnopencv.com/using-facial-landmarks-for-overlaying-faces-with-masks/)|[Code](https://github.com/spmallick/learnopencv/tree/master/FaceMaskOverlay) |
+|[Tensorboard with PyTorch Lightning](https://www.learnopencv.com/tensorboard-with-pytorch-lightning)|[Code](https://github.com/spmallick/learnopencv/tree/master/TensorBoard-With-Pytorch-Lightning)
+|[Otsu's Thresholding with OpenCV](https://www.learnopencv.com/otsu-thresholding-with-opencv/)|[Code](https://github.com/spmallick/learnopencv/tree/master/otsu-method)
+|[PyTorch-to-CoreML-model-conversion](https://www.learnopencv.com/pytorch-to-coreml-model-conversion/) | [Code](https://github.com/spmallick/learnopencv/tree/master/PyTorch-to-CoreML-model-conversion)
+|[Playing Rock, Paper, Scissors with AI](https://www.learnopencv.com/playing-rock-paper-scissors-with-ai/) | [Code](https://github.com/spmallick/learnopencv/tree/master/Playing-rock-paper-scissors-with-AI) |
+|[CNN Receptive Field Computation Using Backprop with TensorFlow](https://www.learnopencv.com/cnn-receptive-field-computation-using-backprop-with-tensorflow/)|[Code](https://github.com/spmallick/learnopencv/tree/master/TensorFlow-Receptive-Field-With-Backprop)|
+|[CNN Fully Convolutional Image Classification with TensorFlow](https://www.learnopencv.com/cnn-fully-convolutional-image-classification-with-tensorflow) | [Code](https://github.com/spmallick/learnopencv/tree/master/TensorFlow-Fully-Convolutional-Image-Classification) |
|[How to convert a model from PyTorch to TensorRT and speed up inference](https://www.learnopencv.com/how-to-convert-a-model-from-pytorch-to-tensorrt-and-speed-up-inference/) | [Code](https://github.com/spmallick/learnopencv/tree/master/PyTorch-ONNX-TensorRT) |
|[Efficient image loading](https://www.learnopencv.com/efficient-image-loading/)|[Code](https://github.com/spmallick/learnopencv/tree/master/Efficient-image-loading) |
|[Graph Convolutional Networks: Model Relations In Data](https://www.learnopencv.com/graph-convolutional-networks-model-relations-in-data/)|[Code](https://github.com/spmallick/learnopencv/tree/master/Graph-Convolutional-Networks-Model-Relations-In-Data)|
@@ -25,6 +41,7 @@ Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/course
|[t-SNE for ResNet feature visualization](https://www.learnopencv.com/t-sne-for-resnet-feature-visualization/)|[Code](https://github.com/spmallick/learnopencv/tree/master/TSNE)|
|[Multi-Label Image Classification with Pytorch](https://www.learnopencv.com/multi-label-image-classification-with-pytorch/)|[Code](https://github.com/spmallick/learnopencv/tree/master/PyTorch-Multi-Label-Image-Classification)|
|[CNN Receptive Field Computation Using Backprop](https://www.learnopencv.com/cnn-receptive-field-computation-using-backprop/)|[Code](https://github.com/spmallick/learnopencv/tree/master/PyTorch-Receptive-Field-With-Backprop)|
+|[CNN Receptive Field Computation Using Backprop with TensorFlow](https://www.learnopencv.com/cnn-receptive-field-computation-using-backprop-with-tensorflow/)|[Code](https://github.com/spmallick/learnopencv/tree/master/TensorFlow-Receptive-Field-With-Backprop)|
|[Augmented Reality using AruCo Markers in OpenCV(C++ and Python)](https://www.learnopencv.com/augmented-reality-using-aruco-markers-in-opencv-(c++-python)/) |[Code](https://github.com/spmallick/learnopencv/tree/master/AugmentedRealityWithArucoMarkers)|
|[Fully Convolutional Image Classification on Arbitrary Sized Image](https://www.learnopencv.com/fully-convolutional-image-classification-on-arbitrary-sized-image/)|[Code](https://github.com/spmallick/learnopencv/tree/master/PyTorch-Fully-Convolutional-Image-Classification)|
|[Camera Calibration using OpenCV](https://www.learnopencv.com/camera-calibration-using-opencv/) |[Code](https://github.com/spmallick/learnopencv/tree/master/CameraCalibration)|
diff --git a/ReconstructFaceUsingEigenFaces/reconstructFace.cpp b/ReconstructFaceUsingEigenFaces/reconstructFace.cpp
index 2d1e14969..d9db9e9e5 100644
--- a/ReconstructFaceUsingEigenFaces/reconstructFace.cpp
+++ b/ReconstructFaceUsingEigenFaces/reconstructFace.cpp
@@ -20,7 +20,7 @@ Mat imVector, meanVector, eigenVectors, im, display;
// Right = Reconstructed Face
void displayResult( Mat &left, Mat &right)
{
- hconcat(left,right, display);
+ hconcat(left,right, display);
resize(display, display, Size(), 4, 4);
imshow("Result", display);
}
@@ -34,22 +34,21 @@ void reconstructFace(int sliderVal, void*)
{
// The weight is the dot product of the mean subtracted
// image vector with the EigenVector
- double weight = imVector.dot(eigenVectors.row(i));
+ double weight = imVector.dot(eigenVectors.row(i));
// Add weighted EigenFace to the output
- output = output + eigenFaces[i] * weight;
+ output = output + eigenFaces[i] * weight;
}
displayResult(im, output);
}
-
int main(int argc, char **argv)
{
// Read model file
string modelFile("pcaParams.yml");
- cout << "Reading model file " << modelFile << " ... " ;
+ cout << "Reading model file " << modelFile << " ... ";
FileStorage file(modelFile, FileStorage::READ);
@@ -65,11 +64,11 @@ int main(int argc, char **argv)
// Extract maximum number of EigenVectors.
// This is the max(numImagesUsedInTraining, w * h * 3)
- // where w = width, h = height of the training images.
+ // where w = width, h = height of the training images.
int numEigenFaces = eigenVectors.size().height;
cout << "DONE" << endl;
- cout << "Extracting mean face and eigen faces ... ";
+ cout << "Extracting mean face and eigen faces ... ";
// Extract mean vector and reshape it to obtain average face
averageFace = meanVector.reshape(3,sz.height);
@@ -82,27 +81,27 @@ int main(int argc, char **argv)
}
cout << "DONE" << endl;
- // Read new test image. This image was not used in traning.
+ // Read new test image. This image was not used in traning.
string imageFilename("test/satya1.jpg");
cout << "Read image " << imageFilename << " and vectorize ... ";
im = imread(imageFilename);
im.convertTo(im, CV_32FC3, 1/255.0);
// Reshape image to one long vector and subtract the mean vector
- imVector = im.clone();
+ imVector = im.clone();
imVector = imVector.reshape(1, 1) - meanVector;
- cout << "DONE" << endl;
+ cout << "DONE" << endl;
// Show mean face first
- output = averageFace.clone();
+ output = averageFace.clone();
- cout << "Usage:" << endl
+ cout << "Usage:" << endl
<< "\tChange the slider to change the number of EigenFaces" << endl
<< "\tHit ESC to terminate program." << endl;
-
- namedWindow("Result", CV_WINDOW_AUTOSIZE);
- int sliderValue;
+
+ namedWindow("Result", cv::WINDOW_AUTOSIZE);
+ int sliderValue;
// Changing the slider value changes the number of EigenVectors
// used in reconstructFace.
@@ -110,10 +109,7 @@ int main(int argc, char **argv)
// Display original image and the reconstructed image size by side
displayResult(im, output);
-
waitKey(0);
destroyAllWindows();
}
-
-
diff --git a/RedEyeRemover/removeRedEyes.cpp b/RedEyeRemover/removeRedEyes.cpp
index e84f6167c..2304c9929 100644
--- a/RedEyeRemover/removeRedEyes.cpp
+++ b/RedEyeRemover/removeRedEyes.cpp
@@ -11,11 +11,11 @@ using namespace cv;
void fillHoles(Mat &mask)
{
- /*
+ /*
This hole filling algorithm is decribed in this post
https://www.learnopencv.com/filling-holes-in-an-image-using-opencv-python-c/
*/
-
+
Mat maskFloodfill = mask.clone();
floodFill(maskFloodfill, cv::Point(0,0), Scalar(255));
Mat mask2;
@@ -27,30 +27,28 @@ void fillHoles(Mat &mask)
int main(int argc, char** argv )
{
// Read image
- Mat img = imread("red_eyes2.jpg",CV_LOAD_IMAGE_COLOR);
+ Mat img = imread("red_eyes2.jpg", cv::IMREAD_COLOR);
// Output image
Mat imgOut = img.clone();
-
+
// Load HAAR cascade
CascadeClassifier eyesCascade("haarcascade_eye.xml");
-
+
// Detect eyes
std::vector eyes;
eyesCascade.detectMultiScale( img, eyes, 1.3, 4, 0 |CASCADE_SCALE_IMAGE, Size(100, 100) );
-
// For every detected eye
for( size_t i = 0; i < eyes.size(); i++ )
{
-
// Extract eye from the image.
Mat eye = img(eyes[i]);
-
+
// Split eye image into 3 channels.
vectorbgr(3);
split(eye,bgr);
-
+
// Simple red eye detector
Mat mask = (bgr[2] > 150) & (bgr[2] > ( bgr[1] + bgr[0] ));
@@ -58,8 +56,6 @@ int main(int argc, char** argv )
fillHoles(mask);
dilate(mask, mask, Mat(), Point(-1, -1), 3, 1, 1);
-
-
// Calculate the mean channel by averaging
// the green and blue channels
@@ -74,12 +70,10 @@ int main(int argc, char** argv )
// Copy the fixed eye to the output image.
eyeOut.copyTo(imgOut(eyes[i]));
-
}
// Display Result
imshow("Red Eyes", img);
imshow("Red Eyes Removed", imgOut);
waitKey(0);
-
}
diff --git a/SnakeGame/README.md b/SnakeGame/README.md
new file mode 100644
index 000000000..81558b93c
--- /dev/null
+++ b/SnakeGame/README.md
@@ -0,0 +1,19 @@
+# Implementing Snake Game using OpenCV and Python
+
+This folder contains the code for implementing the famous snakes game in Python using OpenCV. The tutorial for this code can be found at [Snake Game with OpenCV Python](https://www.learnopencv.com/snake-game-with-opencv-python/)
+
+## USAGE
+
+```
+python snake.py
+```
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
+
+
+
+
+
diff --git a/SnakeGame/snake.py b/SnakeGame/snake.py
new file mode 100644
index 000000000..778c459e7
--- /dev/null
+++ b/SnakeGame/snake.py
@@ -0,0 +1,163 @@
+import cv2
+import numpy as np
+from random import randint
+from random import choice
+
+
+class SnakePart:
+ def __init__(self, front, x, y):
+ self.front = front
+ self.x = x
+ self.y = y
+
+ def move(self):
+ # Moves by following the part in front of it
+ self.x = self.front.x
+ self.y = self.front.y
+
+class Head:
+ def __init__(self, direction, x, y):
+ self.direction = direction
+ self.x = x
+ self.y = y
+
+ def move(self):
+ # Checks what its current direction is and moves accordingly
+ if self.direction == 0:
+ self.x += 1
+ elif self.direction == 1:
+ self.y += 1
+ elif self.direction == 2:
+ self.x -= 1
+ elif self.direction == 3:
+ self.y -= 1
+
+def display():
+
+ # Create a blank image
+ board = np.zeros([BOARD_SIZE, BOARD_SIZE, 3])
+
+ # Color the snake green
+ for part in snake:
+ board[part.y, part.x] = [0, 255, 0]
+
+ # Color the apple red
+ board[appley, applex] = [0, 0, 255]
+
+ # Display board
+ cv2.imshow("Snake Game", np.uint8(board.repeat(CELL_SIZE, 0).repeat(CELL_SIZE, 1)))
+ key = cv2.waitKey(int(1000/SPEED))
+
+ # Return the key pressed. It is -1 if no key is pressed.
+ return key
+
+def win_focus():
+ # Ugly trick to get the window in focus.
+ # Opens an image in fullscreen and then back to normal window
+ cv2.namedWindow("Snake Game", cv2.WINDOW_AUTOSIZE);
+ board = np.zeros([BOARD_SIZE * CELL_SIZE, BOARD_SIZE * CELL_SIZE, 3])
+ cv2.imshow("Snake Game", board);
+ cv2.setWindowProperty("Snake Game", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN);
+ cv2.waitKey(2000)
+ cv2.setWindowProperty("Snake Game", cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_AUTOSIZE)
+
+
+if __name__ == '__main__' :
+
+ # Size of each cell in the board game
+ CELL_SIZE = 20
+ # Number of cells along the width in the game
+ BOARD_SIZE = 45
+ # Change SPEED to make the game go faster
+ SPEED = 12
+ # After eating an apple the snake grows by GROWTH units
+ GROWTH = 3
+
+
+ # Variable to track if apple is eaten
+ eaten = True
+ # Variable to check if the game should quit
+ quit = False
+ # Variable to track growth.
+ grow = 0
+
+ # Array for storing snake
+ snake = []
+
+ #snake's head starts at the center of the board.
+ head = Head(0, int((BOARD_SIZE - 1)/2), int((BOARD_SIZE - 1)/2))
+ snake.append(head)
+
+ # Start the game by printing instructions
+ print('w = top, a = left, s = down, d = right')
+ # Ugly trick to bring the window in focus
+ win_focus()
+
+ while True:
+
+ # Checks if the apple is eaten and generates a new one
+ if eaten:
+ # Create a list of all possible locations
+ s = list(range(0, BOARD_SIZE ** 2))
+ # Delete cells that are part of the snake
+ for part in snake:
+ s.remove(part.x * BOARD_SIZE + part.y)
+
+ # Randomly pick from one of the remaining cells
+ a = choice(s)
+ applex = int(a/BOARD_SIZE)
+ appley = a % BOARD_SIZE
+
+ eaten = False
+
+ # Makes and displays the board
+ key = display()
+
+
+ # Gets key presses and moves accordingly
+ # 8 and 27 are delete and escape keys
+ # Arrow keys are tricky in OpenCV. So we use
+ # keys 'w', 'a','s','d' for movement.
+ # w = top, a = left, s = down, d = right
+
+
+ if key == 8 or key == 27:
+ break
+ elif key == ord("d") :
+ head.direction = 0
+ elif key == ord("s") :
+ head.direction = 1
+ elif key == ord("a") :
+ head.direction = 2
+ elif key == ord("w") :
+ head.direction = 3
+
+ # Moving the snake
+ for part in snake[::-1]:
+ part.move()
+
+ # Collision rules
+
+ if head.x < 0 or head.x > BOARD_SIZE - 1 or head.y < 0 or head.y > BOARD_SIZE - 1:
+ break
+
+ for part in snake[1:]:
+ if head.x == part.x and head.y == part.y:
+ quit = True
+ break
+
+ if quit:
+ break
+
+ # The snake grows graduallly over multiple frames
+ if grow > 0:
+ snake.append(SnakePart(snake[-1], subx, suby))
+ grow -= 1
+
+ # Grows the snake when it eats an apple
+ if applex == head.x and appley == head.y:
+ subx = snake[-1].x
+ suby = snake[-1].y
+ eaten = True
+ grow += GROWTH
+
diff --git a/TensorBoard-With-Pytorch-Lightning/README.md b/TensorBoard-With-Pytorch-Lightning/README.md
new file mode 100644
index 000000000..47e2bfdee
--- /dev/null
+++ b/TensorBoard-With-Pytorch-Lightning/README.md
@@ -0,0 +1,13 @@
+This contains the code for **TensorBoard with PyTorch Lightning**. For more information - visit [**TensorBoard with PyTorch Lightning**](https://www.learnopencv.com/tensorboard-with-pytorch-lightning/)
+
+
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
+
+
+
+
+
diff --git a/TensorBoard-With-Pytorch-Lightning/Tensorboard-with-PyTorch-Lightning.ipynb b/TensorBoard-With-Pytorch-Lightning/Tensorboard-with-PyTorch-Lightning.ipynb
new file mode 100644
index 000000000..0481768c2
--- /dev/null
+++ b/TensorBoard-With-Pytorch-Lightning/Tensorboard-with-PyTorch-Lightning.ipynb
@@ -0,0 +1,7146 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "Tensorboard Testing.ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "toc_visible": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "accelerator": "GPU",
+ "widgets": {
+ "application/vnd.jupyter.widget-state+json": {
+ "06add6832ae94410861e93402a4407ce": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_82b5bdbec056425d9db5e91973d2fd69",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_13b64b55c89b4d5a8c3956e6b4fa5ce8",
+ "IPY_MODEL_df98408aa4784329ac6f6844d4645742"
+ ]
+ }
+ },
+ "82b5bdbec056425d9db5e91973d2fd69": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "13b64b55c89b4d5a8c3956e6b4fa5ce8": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_13be7a9e4ac447a984e0ec938ba3b132",
+ "_dom_classes": [],
+ "description": "Validation sanity check: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_2fec21701d2d4834b17b120b47495b01"
+ }
+ },
+ "df98408aa4784329ac6f6844d4645742": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_41fa426d84d14762b074d103c433425c",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 2/2 [00:01<00:00, 1.33s/it]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_f33ecdfc71df4ed995f8c59e70231f99"
+ }
+ },
+ "13be7a9e4ac447a984e0ec938ba3b132": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "2fec21701d2d4834b17b120b47495b01": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "41fa426d84d14762b074d103c433425c": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "f33ecdfc71df4ed995f8c59e70231f99": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "166788b33ec140b9bf6891b3f8797d32": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_50b8bfa175444793a272bf0c34a618ba",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_6106b9226019481c8304fcde0e63a202",
+ "IPY_MODEL_66bd8a471c3c45ad816e79c7db7c35de"
+ ]
+ }
+ },
+ "50b8bfa175444793a272bf0c34a618ba": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "6106b9226019481c8304fcde0e63a202": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_eaa96ec7f3f6458b96ff978ebbb52157",
+ "_dom_classes": [],
+ "description": "Epoch 10: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "success",
+ "max": 470,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 470,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_468f884d5cf249ab9878cd83cec045ed"
+ }
+ },
+ "66bd8a471c3c45ad816e79c7db7c35de": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_f962be9fcfbd45d68cbc85d07a7dbf49",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 470/470 [00:16<00:00, 28.95it/s, loss=1.514, v_num=1]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_72a068171fcc44b08e4300bbeba2dd9a"
+ }
+ },
+ "eaa96ec7f3f6458b96ff978ebbb52157": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "468f884d5cf249ab9878cd83cec045ed": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "f962be9fcfbd45d68cbc85d07a7dbf49": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "72a068171fcc44b08e4300bbeba2dd9a": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "547946b574294a5fac045a78e815c747": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_8d1ee977e12343518eb1f3638b3a8d68",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_b3c16289906d427f8e5aa58a96e0dcb8",
+ "IPY_MODEL_674ef45d923045b29c5284159016420d"
+ ]
+ }
+ },
+ "8d1ee977e12343518eb1f3638b3a8d68": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "b3c16289906d427f8e5aa58a96e0dcb8": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_6e92cd364ab64a3d859d8dff72db10b7",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_fd905497be90433b93f3a3891b574dc1"
+ }
+ },
+ "674ef45d923045b29c5284159016420d": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_3435de8896dd45e8b680ddbc9cd4f8a1",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 2.23it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_9a29111183184f4693ba5de7c6cbea94"
+ }
+ },
+ "6e92cd364ab64a3d859d8dff72db10b7": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "fd905497be90433b93f3a3891b574dc1": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "3435de8896dd45e8b680ddbc9cd4f8a1": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "9a29111183184f4693ba5de7c6cbea94": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "bc5080cb96a24b2cb5b85813fa77e12e": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_3251321b00714f8680e455a191fbc9ca",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_b9d725a2bf8043988d75cd9abce113f4",
+ "IPY_MODEL_3c359db366174498b4cd240b5414dd7f"
+ ]
+ }
+ },
+ "3251321b00714f8680e455a191fbc9ca": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "b9d725a2bf8043988d75cd9abce113f4": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_51669199bff44a3b85d90665f409832e",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_3404f6f821b648bea27397e9ca4fd568"
+ }
+ },
+ "3c359db366174498b4cd240b5414dd7f": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_19cc5abdec474fa48b076e411d1af943",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 2.19it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_c48dcb96532f4553941801dc714d4735"
+ }
+ },
+ "51669199bff44a3b85d90665f409832e": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "3404f6f821b648bea27397e9ca4fd568": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "19cc5abdec474fa48b076e411d1af943": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "c48dcb96532f4553941801dc714d4735": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "117258bc0cdd4e3198e173476200435c": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_feae4123dd8b4300bc3f08125c6b1948",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_8b9b116ea4cb43b99a207e689e56ba4f",
+ "IPY_MODEL_e1a8289ca5144d9fb0999590bd5e79e2"
+ ]
+ }
+ },
+ "feae4123dd8b4300bc3f08125c6b1948": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "8b9b116ea4cb43b99a207e689e56ba4f": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_e00d9fd453034c02b9b06b29ae65e4f8",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_cbf9a18ad6b44b6380122311380a967c"
+ }
+ },
+ "e1a8289ca5144d9fb0999590bd5e79e2": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_e07bea8e56624fc4be74f789b2861a21",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 2.20it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_a34abcdf62da4d96a91bf30515d86ba0"
+ }
+ },
+ "e00d9fd453034c02b9b06b29ae65e4f8": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "cbf9a18ad6b44b6380122311380a967c": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "e07bea8e56624fc4be74f789b2861a21": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "a34abcdf62da4d96a91bf30515d86ba0": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "1b21483222ba416fa8f456a87782af73": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_524fc16894714aa098982b707219f360",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_2b51fccadb1544deb4212f8f2dc6ae36",
+ "IPY_MODEL_4d662f31c2b44e6aad5c07e2eec2fd08"
+ ]
+ }
+ },
+ "524fc16894714aa098982b707219f360": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "2b51fccadb1544deb4212f8f2dc6ae36": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_7baa37345df5472380aa3a20f4d515b0",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_626067a3ea2e489e930357298bf4edec"
+ }
+ },
+ "4d662f31c2b44e6aad5c07e2eec2fd08": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_baf7d82752fe4afc94bdef0ff90449ad",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 2.13it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_0bebb09292e9421295fda7ca8da23b28"
+ }
+ },
+ "7baa37345df5472380aa3a20f4d515b0": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "626067a3ea2e489e930357298bf4edec": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "baf7d82752fe4afc94bdef0ff90449ad": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "0bebb09292e9421295fda7ca8da23b28": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "bc28ca7097de4a2cbc46f0d42ebb5e70": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_8c60047983b84f4982da13b69511959d",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_be4bdcc280c24bf08f50f0581cc43e45",
+ "IPY_MODEL_1efb02f06f594569862225631367274f"
+ ]
+ }
+ },
+ "8c60047983b84f4982da13b69511959d": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "be4bdcc280c24bf08f50f0581cc43e45": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_b0fccc4a75414c6fbee773f7fa20edb8",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_293a945ce7a849cd858b9dfd93d07638"
+ }
+ },
+ "1efb02f06f594569862225631367274f": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_b2d0417743e746e490ccffc502c65e33",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 1.48it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_6e55c115dc02444a9592166ffb1a3494"
+ }
+ },
+ "b0fccc4a75414c6fbee773f7fa20edb8": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "293a945ce7a849cd858b9dfd93d07638": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "b2d0417743e746e490ccffc502c65e33": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "6e55c115dc02444a9592166ffb1a3494": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "822ef578aeb4482ca09f2c3884014cf5": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_e8ffe3de6ca54df484958a9cf13d3252",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_79f86fee27cd4dc9b55eba51e2dafd8e",
+ "IPY_MODEL_b9733d27c6df42e0a7cf1e410962ad07"
+ ]
+ }
+ },
+ "e8ffe3de6ca54df484958a9cf13d3252": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "79f86fee27cd4dc9b55eba51e2dafd8e": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_3adde1e02cf543c2ab97c1c945b4c896",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_60c0822e465f46b49848030e0619ae27"
+ }
+ },
+ "b9733d27c6df42e0a7cf1e410962ad07": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_4b40e778bae6427198289a348c0e839e",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 2.20it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_0f00a93e2586456590762cc71a364704"
+ }
+ },
+ "3adde1e02cf543c2ab97c1c945b4c896": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "60c0822e465f46b49848030e0619ae27": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "4b40e778bae6427198289a348c0e839e": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "0f00a93e2586456590762cc71a364704": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "fa7ff58db3644e2fa695ca889534222b": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_2a94537b83ac4a99b31a9ba42f820fe7",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_aec0c015057f4fdebc72b4aaf1e6ec71",
+ "IPY_MODEL_9c61a20668c347eea6bad88f2819330f"
+ ]
+ }
+ },
+ "2a94537b83ac4a99b31a9ba42f820fe7": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "aec0c015057f4fdebc72b4aaf1e6ec71": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_442a99e054d54b4f8511673eebad2d7f",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_2af3f7ec723042b28fbf060b2ba9c02b"
+ }
+ },
+ "9c61a20668c347eea6bad88f2819330f": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_4edc3548d1364b69a33be523b24165a7",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 2.24it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_dd94806e23ab40bbbc4b65fa95478a35"
+ }
+ },
+ "442a99e054d54b4f8511673eebad2d7f": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "2af3f7ec723042b28fbf060b2ba9c02b": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "4edc3548d1364b69a33be523b24165a7": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "dd94806e23ab40bbbc4b65fa95478a35": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "12272021c2234ace8b0825fc4011a919": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_b3536c933c604fb889c0a6629ce0a43b",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_165d809cf2694bfa89202ef2fed621ea",
+ "IPY_MODEL_261b218116a74baab4f1b430204bcd84"
+ ]
+ }
+ },
+ "b3536c933c604fb889c0a6629ce0a43b": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "165d809cf2694bfa89202ef2fed621ea": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_323778f9289f4992be97b592769a7eb3",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_57feb1626025410f9fb518707724f0f1"
+ }
+ },
+ "261b218116a74baab4f1b430204bcd84": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_e0d925454000435782fb9a46654a1dc0",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 2.24it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_e1c5e4bd40fb4197812204b9f90233d9"
+ }
+ },
+ "323778f9289f4992be97b592769a7eb3": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "57feb1626025410f9fb518707724f0f1": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "e0d925454000435782fb9a46654a1dc0": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "e1c5e4bd40fb4197812204b9f90233d9": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "1c2da3c953d64f2f8f0d52d53ef9a76e": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_e3fdc27e03254b4c85a334cb8257203d",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_51acdd35dd534dc696c7b6942f5eb4d0",
+ "IPY_MODEL_670fd15bfad64fac9bdea338e118c613"
+ ]
+ }
+ },
+ "e3fdc27e03254b4c85a334cb8257203d": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "51acdd35dd534dc696c7b6942f5eb4d0": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_f968728971b14f83bc635efccf191073",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_5142d3a0327f41c29d6e1dce42de2d49"
+ }
+ },
+ "670fd15bfad64fac9bdea338e118c613": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_dbd0b779711d42b893ed6427a0e200cd",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 1.50it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_417a972906784467af59f5880aca329b"
+ }
+ },
+ "f968728971b14f83bc635efccf191073": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "5142d3a0327f41c29d6e1dce42de2d49": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "dbd0b779711d42b893ed6427a0e200cd": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "417a972906784467af59f5880aca329b": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "444e17ff24bb4034a1687413ce81c706": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_378472c5ac2b4266bea077c384330e28",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_6a894f5f3ada42c1b04502b50f7cc7e1",
+ "IPY_MODEL_33f4347b60084c2bbc2954a1a4244d14"
+ ]
+ }
+ },
+ "378472c5ac2b4266bea077c384330e28": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "6a894f5f3ada42c1b04502b50f7cc7e1": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_89ab9598547e4d82839d9c5c35448832",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_29d183cbb8eb4f2a80624bf9cf258d4c"
+ }
+ },
+ "33f4347b60084c2bbc2954a1a4244d14": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_51e6dbea5ba34115a7ef056880ce2773",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 2.13it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_3d6d28ee166248e6964291bd5ac8fbc6"
+ }
+ },
+ "89ab9598547e4d82839d9c5c35448832": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "29d183cbb8eb4f2a80624bf9cf258d4c": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "51e6dbea5ba34115a7ef056880ce2773": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "3d6d28ee166248e6964291bd5ac8fbc6": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "f6b418ac9a784cf39f537e93b9712b0f": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_bbb09b3b11454d3d902c981c1874e227",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_727f101faa1147dca0bab10a1b867754",
+ "IPY_MODEL_4ffae6daab15469181ad62dcf4b6755f"
+ ]
+ }
+ },
+ "bbb09b3b11454d3d902c981c1874e227": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "727f101faa1147dca0bab10a1b867754": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_b067a85aa69c4acc8f38077444b0b62b",
+ "_dom_classes": [],
+ "description": "Validation sanity check: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_702e0c51876d491d84eeb7b93e021416"
+ }
+ },
+ "4ffae6daab15469181ad62dcf4b6755f": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_695279db98734f72b5a8187f484ed4eb",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 2/2 [00:01<00:00, 1.30s/it]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_b801e6dda709479fb28a11ccff2e9fd2"
+ }
+ },
+ "b067a85aa69c4acc8f38077444b0b62b": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "702e0c51876d491d84eeb7b93e021416": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "695279db98734f72b5a8187f484ed4eb": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "b801e6dda709479fb28a11ccff2e9fd2": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "b0caff9a0db3449da90c4696ff0c6dc0": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_23f2a1c6eadb415c9253c74dbefd701e",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_8d61e6981653498dbfe5cd863d1d4abf",
+ "IPY_MODEL_bbbf9723a0214db3a55f7c643650a59e"
+ ]
+ }
+ },
+ "23f2a1c6eadb415c9253c74dbefd701e": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "8d61e6981653498dbfe5cd863d1d4abf": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_e0543446503d4548bf7b49a1ba1c8811",
+ "_dom_classes": [],
+ "description": "Epoch 4: 91%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "danger",
+ "max": 470,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 430,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_a0b0e0209c5d4148bb50ef2defc83cef"
+ }
+ },
+ "bbbf9723a0214db3a55f7c643650a59e": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_c863ca4c52dd45bbb4b8d04ac7bbf13e",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 430/470 [00:15<00:01, 27.35it/s, loss=1.589, v_num=1]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_69c58acf0f1b477fb9486b214ed10ef8"
+ }
+ },
+ "e0543446503d4548bf7b49a1ba1c8811": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "a0b0e0209c5d4148bb50ef2defc83cef": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "c863ca4c52dd45bbb4b8d04ac7bbf13e": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "69c58acf0f1b477fb9486b214ed10ef8": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "cfe1eb2121444a0a84266c3d75fcd963": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_3756191380f34b33a371f7956c88dfe6",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_6e0b815542c94c2a8d3f7c5272ae87b2",
+ "IPY_MODEL_fe1bd530a464467d915d23b7bf82dbe7"
+ ]
+ }
+ },
+ "3756191380f34b33a371f7956c88dfe6": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "6e0b815542c94c2a8d3f7c5272ae87b2": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_2bb4b7c9b0104bfbb4699c0ae914fc53",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_aa0cc4c7dce948bdaa0857e028eadbc6"
+ }
+ },
+ "fe1bd530a464467d915d23b7bf82dbe7": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_c62dcf23227f4cbcbaa2ea8297455c76",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 2.05it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_7329aace66ce4a5290e0b8acb9273aba"
+ }
+ },
+ "2bb4b7c9b0104bfbb4699c0ae914fc53": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "aa0cc4c7dce948bdaa0857e028eadbc6": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "c62dcf23227f4cbcbaa2ea8297455c76": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "7329aace66ce4a5290e0b8acb9273aba": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "86169559e322466f9868a541c1f6724c": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_448a75c288ab40e59b8e9efbf083ba06",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_478a909bdccb44949182a485aa4c7aac",
+ "IPY_MODEL_83cc7e5988fa4699843a873408375ec7"
+ ]
+ }
+ },
+ "448a75c288ab40e59b8e9efbf083ba06": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "478a909bdccb44949182a485aa4c7aac": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_ccec043d8c8c47dd826612978a1d8fec",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_37a1ca16333841039c6b1b3b260aebb9"
+ }
+ },
+ "83cc7e5988fa4699843a873408375ec7": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_3813ceefeb3841d9887c82ba0a3e659f",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 2.06it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_d1c400398bc74762b2f7882d1cc57702"
+ }
+ },
+ "ccec043d8c8c47dd826612978a1d8fec": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "37a1ca16333841039c6b1b3b260aebb9": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "3813ceefeb3841d9887c82ba0a3e659f": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "d1c400398bc74762b2f7882d1cc57702": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "40180487115c473a872d7c896bacb3ff": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_f00cd38365174318af3c49ba42d67bc5",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_704f7b19739a4c05ae46a0d6ffa7a865",
+ "IPY_MODEL_33306403471c4538abdab5bfa05b4610"
+ ]
+ }
+ },
+ "f00cd38365174318af3c49ba42d67bc5": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "704f7b19739a4c05ae46a0d6ffa7a865": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_ffcb6cca375c4c8b9dfd9190671ff348",
+ "_dom_classes": [],
+ "description": "Validating: 100%",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 1,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_149e414e1c9441019eb052a4c36d19a9"
+ }
+ },
+ "33306403471c4538abdab5bfa05b4610": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_fb7cab66a2474ab6bcd7946a2fb60f42",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 40/40 [00:02<00:00, 2.06it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_5e54c83fcc3a4efba43349a1b08061fd"
+ }
+ },
+ "ffcb6cca375c4c8b9dfd9190671ff348": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "149e414e1c9441019eb052a4c36d19a9": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "fb7cab66a2474ab6bcd7946a2fb60f42": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "5e54c83fcc3a4efba43349a1b08061fd": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "02ec7b2afb7d4456bbfed4efe0ed3df4": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HBoxModel",
+ "state": {
+ "_view_name": "HBoxView",
+ "_dom_classes": [],
+ "_model_name": "HBoxModel",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "box_style": "",
+ "layout": "IPY_MODEL_7d8abb71feeb4a64a7e21e645d5da2f4",
+ "_model_module": "@jupyter-widgets/controls",
+ "children": [
+ "IPY_MODEL_26cf343f24e44198808769ff76958275",
+ "IPY_MODEL_e755ff286a074c42a236062a763ed59c"
+ ]
+ }
+ },
+ "7d8abb71feeb4a64a7e21e645d5da2f4": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": "row wrap",
+ "width": "100%",
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": "inline-flex",
+ "left": null
+ }
+ },
+ "26cf343f24e44198808769ff76958275": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "FloatProgressModel",
+ "state": {
+ "_view_name": "ProgressView",
+ "style": "IPY_MODEL_d5a5178a43c1418092f7dd604b8f1305",
+ "_dom_classes": [],
+ "description": "Validating: ",
+ "_model_name": "FloatProgressModel",
+ "bar_style": "info",
+ "max": 1,
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": 0,
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "orientation": "horizontal",
+ "min": 0,
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_67161adc5d514547a036374dee270d7d"
+ }
+ },
+ "e755ff286a074c42a236062a763ed59c": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "HTMLModel",
+ "state": {
+ "_view_name": "HTMLView",
+ "style": "IPY_MODEL_59a1f9c386db47e7b4d263adaa4a720b",
+ "_dom_classes": [],
+ "description": "",
+ "_model_name": "HTMLModel",
+ "placeholder": "",
+ "_view_module": "@jupyter-widgets/controls",
+ "_model_module_version": "1.5.0",
+ "value": " 0/? [00:00<?, ?it/s]",
+ "_view_count": null,
+ "_view_module_version": "1.5.0",
+ "description_tooltip": null,
+ "_model_module": "@jupyter-widgets/controls",
+ "layout": "IPY_MODEL_6a9b117e0050412f85013848881988de"
+ }
+ },
+ "d5a5178a43c1418092f7dd604b8f1305": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "ProgressStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "ProgressStyleModel",
+ "description_width": "initial",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "bar_color": null,
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "67161adc5d514547a036374dee270d7d": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": "2",
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ },
+ "59a1f9c386db47e7b4d263adaa4a720b": {
+ "model_module": "@jupyter-widgets/controls",
+ "model_name": "DescriptionStyleModel",
+ "state": {
+ "_view_name": "StyleView",
+ "_model_name": "DescriptionStyleModel",
+ "description_width": "",
+ "_view_module": "@jupyter-widgets/base",
+ "_model_module_version": "1.5.0",
+ "_view_count": null,
+ "_view_module_version": "1.2.0",
+ "_model_module": "@jupyter-widgets/controls"
+ }
+ },
+ "6a9b117e0050412f85013848881988de": {
+ "model_module": "@jupyter-widgets/base",
+ "model_name": "LayoutModel",
+ "state": {
+ "_view_name": "LayoutView",
+ "grid_template_rows": null,
+ "right": null,
+ "justify_content": null,
+ "_view_module": "@jupyter-widgets/base",
+ "overflow": null,
+ "_model_module_version": "1.2.0",
+ "_view_count": null,
+ "flex_flow": null,
+ "width": null,
+ "min_width": null,
+ "border": null,
+ "align_items": null,
+ "bottom": null,
+ "_model_module": "@jupyter-widgets/base",
+ "top": null,
+ "grid_column": null,
+ "overflow_y": null,
+ "overflow_x": null,
+ "grid_auto_flow": null,
+ "grid_area": null,
+ "grid_template_columns": null,
+ "flex": null,
+ "_model_name": "LayoutModel",
+ "justify_items": null,
+ "grid_row": null,
+ "max_height": null,
+ "align_content": null,
+ "visibility": null,
+ "align_self": null,
+ "height": null,
+ "min_height": null,
+ "padding": null,
+ "grid_auto_rows": null,
+ "grid_gap": null,
+ "max_width": null,
+ "order": null,
+ "_view_module_version": "1.2.0",
+ "grid_template_areas": null,
+ "object_position": null,
+ "object_fit": null,
+ "grid_auto_columns": null,
+ "margin": null,
+ "display": null,
+ "left": null
+ }
+ }
+ }
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "VCkEWKWlD3p6",
+ "colab_type": "text"
+ },
+ "source": [
+ "#Pytorch Lightning Installation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "zw8Dr4nFRM86",
+ "colab_type": "code",
+ "outputId": "7f2f17b7-adf0-4f97-acaa-1c930cfbcd2f",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 812
+ }
+ },
+ "source": [
+ "!pip install pytorch_lightning"
+ ],
+ "execution_count": 1,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "text": [
+ "Collecting pytorch_lightning\n",
+ "\u001b[?25l Downloading https://files.pythonhosted.org/packages/71/ab/561d1fa6e5af30b2fd7cb4001f93eb08531e1b72976f13eebf7f7cdc021c/pytorch_lightning-0.7.6-py3-none-any.whl (248kB)\n",
+ "\r\u001b[K |█▎ | 10kB 16.7MB/s eta 0:00:01\r\u001b[K |██▋ | 20kB 1.7MB/s eta 0:00:01\r\u001b[K |████ | 30kB 2.3MB/s eta 0:00:01\r\u001b[K |█████▎ | 40kB 2.5MB/s eta 0:00:01\r\u001b[K |██████▋ | 51kB 2.0MB/s eta 0:00:01\r\u001b[K |████████ | 61kB 2.3MB/s eta 0:00:01\r\u001b[K |█████████▏ | 71kB 2.4MB/s eta 0:00:01\r\u001b[K |██████████▌ | 81kB 2.7MB/s eta 0:00:01\r\u001b[K |███████████▉ | 92kB 2.9MB/s eta 0:00:01\r\u001b[K |█████████████▏ | 102kB 2.8MB/s eta 0:00:01\r\u001b[K |██████████████▌ | 112kB 2.8MB/s eta 0:00:01\r\u001b[K |███████████████▉ | 122kB 2.8MB/s eta 0:00:01\r\u001b[K |█████████████████ | 133kB 2.8MB/s eta 0:00:01\r\u001b[K |██████████████████▍ | 143kB 2.8MB/s eta 0:00:01\r\u001b[K |███████████████████▊ | 153kB 2.8MB/s eta 0:00:01\r\u001b[K |█████████████████████ | 163kB 2.8MB/s eta 0:00:01\r\u001b[K |██████████████████████▍ | 174kB 2.8MB/s eta 0:00:01\r\u001b[K |███████████████████████▊ | 184kB 2.8MB/s eta 0:00:01\r\u001b[K |█████████████████████████ | 194kB 2.8MB/s eta 0:00:01\r\u001b[K |██████████████████████████▎ | 204kB 2.8MB/s eta 0:00:01\r\u001b[K |███████████████████████████▋ | 215kB 2.8MB/s eta 0:00:01\r\u001b[K |█████████████████████████████ | 225kB 2.8MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▎ | 235kB 2.8MB/s eta 0:00:01\r\u001b[K |███████████████████████████████▋| 245kB 2.8MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 256kB 2.8MB/s \n",
+ "\u001b[?25hRequirement already satisfied: tensorboard>=1.14 in /usr/local/lib/python3.6/dist-packages (from pytorch_lightning) (2.2.1)\n",
+ "Requirement already satisfied: tqdm>=4.41.0 in /usr/local/lib/python3.6/dist-packages (from pytorch_lightning) (4.41.1)\n",
+ "Requirement already satisfied: torch>=1.1 in /usr/local/lib/python3.6/dist-packages (from pytorch_lightning) (1.5.0+cu101)\n",
+ "Collecting future>=0.17.1\n",
+ "\u001b[?25l Downloading https://files.pythonhosted.org/packages/45/0b/38b06fd9b92dc2b68d58b75f900e97884c45bedd2ff83203d933cf5851c9/future-0.18.2.tar.gz (829kB)\n",
+ "\u001b[K |████████████████████████████████| 829kB 8.4MB/s \n",
+ "\u001b[?25hRequirement already satisfied: numpy>=1.16.4 in /usr/local/lib/python3.6/dist-packages (from pytorch_lightning) (1.18.4)\n",
+ "Requirement already satisfied: pyyaml>=3.13 in /usr/local/lib/python3.6/dist-packages (from pytorch_lightning) (3.13)\n",
+ "Requirement already satisfied: protobuf>=3.6.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=1.14->pytorch_lightning) (3.10.0)\n",
+ "Requirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=1.14->pytorch_lightning) (46.4.0)\n",
+ "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=1.14->pytorch_lightning) (1.6.0.post3)\n",
+ "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=1.14->pytorch_lightning) (1.0.1)\n",
+ "Requirement already satisfied: grpcio>=1.24.3 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=1.14->pytorch_lightning) (1.29.0)\n",
+ "Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=1.14->pytorch_lightning) (0.9.0)\n",
+ "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=1.14->pytorch_lightning) (3.2.2)\n",
+ "Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=1.14->pytorch_lightning) (1.12.0)\n",
+ "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=1.14->pytorch_lightning) (2.23.0)\n",
+ "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=1.14->pytorch_lightning) (0.4.1)\n",
+ "Requirement already satisfied: google-auth<2,>=1.6.3 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=1.14->pytorch_lightning) (1.7.2)\n",
+ "Requirement already satisfied: wheel>=0.26; python_version >= \"3\" in /usr/local/lib/python3.6/dist-packages (from tensorboard>=1.14->pytorch_lightning) (0.34.2)\n",
+ "Requirement already satisfied: importlib-metadata; python_version < \"3.8\" in /usr/local/lib/python3.6/dist-packages (from markdown>=2.6.8->tensorboard>=1.14->pytorch_lightning) (1.6.0)\n",
+ "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard>=1.14->pytorch_lightning) (2020.4.5.1)\n",
+ "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard>=1.14->pytorch_lightning) (3.0.4)\n",
+ "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard>=1.14->pytorch_lightning) (2.9)\n",
+ "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard>=1.14->pytorch_lightning) (1.24.3)\n",
+ "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.6/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=1.14->pytorch_lightning) (1.3.0)\n",
+ "Requirement already satisfied: rsa<4.1,>=3.1.4 in /usr/local/lib/python3.6/dist-packages (from google-auth<2,>=1.6.3->tensorboard>=1.14->pytorch_lightning) (4.0)\n",
+ "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.6/dist-packages (from google-auth<2,>=1.6.3->tensorboard>=1.14->pytorch_lightning) (0.2.8)\n",
+ "Requirement already satisfied: cachetools<3.2,>=2.0.0 in /usr/local/lib/python3.6/dist-packages (from google-auth<2,>=1.6.3->tensorboard>=1.14->pytorch_lightning) (3.1.1)\n",
+ "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.6/dist-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard>=1.14->pytorch_lightning) (3.1.0)\n",
+ "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.6/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=1.14->pytorch_lightning) (3.1.0)\n",
+ "Requirement already satisfied: pyasn1>=0.1.3 in /usr/local/lib/python3.6/dist-packages (from rsa<4.1,>=3.1.4->google-auth<2,>=1.6.3->tensorboard>=1.14->pytorch_lightning) (0.4.8)\n",
+ "Building wheels for collected packages: future\n",
+ " Building wheel for future (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+ " Created wheel for future: filename=future-0.18.2-cp36-none-any.whl size=491057 sha256=935aea8e476324af1e7d1251a1466a35c30499ad9e3e0b65c5cd2a4c75327f60\n",
+ " Stored in directory: /root/.cache/pip/wheels/8b/99/a0/81daf51dcd359a9377b110a8a886b3895921802d2fc1b2397e\n",
+ "Successfully built future\n",
+ "Installing collected packages: future, pytorch-lightning\n",
+ " Found existing installation: future 0.16.0\n",
+ " Uninstalling future-0.16.0:\n",
+ " Successfully uninstalled future-0.16.0\n",
+ "Successfully installed future-0.18.2 pytorch-lightning-0.7.6\n"
+ ],
+ "name": "stdout"
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XsFtJWh9NFkY",
+ "colab_type": "text"
+ },
+ "source": [
+ "# **1. Using Default Lightning Logger**\n",
+ "We will see simple logging using in-built tensorboard support for Lightning"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "He01VrrONse2",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "'''\n",
+ "Neural Network architecture inspired from: \n",
+ "https://towardsdatascience.com/convolutional-neural-network-for-image-classification-with-implementation-on-python-using-pytorch-7b88342c9ca9\n",
+ "'''\n",
+ "\n",
+ "#importing necessary libraries\n",
+ "import os\n",
+ "import torch\n",
+ "from torch.nn import functional as F\n",
+ "from torch.utils.data import DataLoader,random_split\n",
+ "from torchvision.datasets import MNIST\n",
+ "from torchvision import transforms\n",
+ "import pytorch_lightning as pl\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "import torchvision\n",
+ "\n",
+ "\n",
+ "#defining the model\n",
+ "class smallAndSmartModel(pl.LightningModule):\n",
+ "\n",
+ "\n",
+ " def __init__(self):\n",
+ " #this is the init function where we will defnine the architecture\n",
+ " super(smallAndSmartModel, self).__init__()\n",
+ " \n",
+ " self.layer1 = torch.nn.Sequential(\n",
+ " torch.nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1),\n",
+ " torch.nn.ReLU(),\n",
+ " torch.nn.MaxPool2d(kernel_size=2, stride=2),\n",
+ " torch.nn.Dropout(p=0.5))\n",
+ " self.layer2 = torch.nn.Sequential(\n",
+ " torch.nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),\n",
+ " torch.nn.ReLU(),\n",
+ " torch.nn.MaxPool2d(kernel_size=2, stride=2),\n",
+ " torch.nn.Dropout(p=0.5))\n",
+ " self.layer3 = torch.nn.Sequential(\n",
+ " torch.nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),\n",
+ " torch.nn.ReLU(),\n",
+ " torch.nn.MaxPool2d(kernel_size=2, stride=2, padding=1),\n",
+ " torch.nn.Dropout(p=0.5))\n",
+ "\n",
+ " self.fc1 = torch.nn.Linear(4 * 4 * 128, 625, bias=True)\n",
+ " torch.nn.init.xavier_uniform(self.fc1.weight)\n",
+ " self.layer4 = torch.nn.Sequential(\n",
+ " self.fc1,\n",
+ " torch.nn.ReLU(),\n",
+ " torch.nn.Dropout(p=0.5))\n",
+ " self.dense1_bn = torch.nn.BatchNorm1d(625)\n",
+ " self.fc2 = torch.nn.Linear(625, 10, bias=True)\n",
+ " self.dense2_bn = torch.nn.BatchNorm1d(10)\n",
+ " torch.nn.init.xavier_uniform_(self.fc2.weight) # initialize parameters\n",
+ "\n",
+ " def prepare_data(self):\n",
+ " \n",
+ " # This contains the manupulation on data that needs to be done only once such as downloading it\n",
+ "\n",
+ " #download the MNIST dataset\n",
+ " MNIST(os.getcwd(), train=True, download =True)\n",
+ " MNIST(os.getcwd(), train=False, download =True)\n",
+ " \n",
+ " # See here I have set download to false as it is already downloaded\n",
+ " mnist_train=MNIST(os.getcwd(), train=True, download =False,transform=transforms.ToTensor())\n",
+ "\n",
+ " #dividing into validation and training set\n",
+ " self.train_set, self.val_set= random_split(mnist_train,[55000,5000])\n",
+ " \n",
+ " def train_dataloader(self):\n",
+ " # REQUIRED\n",
+ " # This is an essential function. Needs to be included in the code\n",
+ " \n",
+ " return DataLoader(self.train_set,batch_size=128,num_workers=32)\n",
+ " \n",
+ " def val_dataloader(self):\n",
+ " # OPTIONAL\n",
+ " #loading validation dataset\n",
+ " return DataLoader(self.val_set, batch_size=128,num_workers=32)\n",
+ "\n",
+ " def test_dataloader(self):\n",
+ " # OPTIONAL\n",
+ " # loading test dataset\n",
+ " return DataLoader(MNIST(os.getcwd(), train=False, download=False, transform=transforms.ToTensor()), batch_size=128,num_workers=32)\n",
+ " \n",
+ "\n",
+ " def forward(self,x):\n",
+ " # evaluating the batch data as it moves forward in the netowrk\n",
+ " out = self.layer1(x)\n",
+ " out = self.layer2(out)\n",
+ " out = self.layer3(out)\n",
+ " out = out.view(out.size(0), -1) # Flatten them for FC\n",
+ " # out = self.fc1(out)\n",
+ " out = self.dense1_bn(self.fc1(out))\n",
+ " \n",
+ " # out = self.fc2(out)\n",
+ " out = self.dense2_bn(self.fc2(out))\n",
+ " # print(out.shape)\n",
+ " return F.softmax(out,dim=1)\n",
+ "\n",
+ " def validation_step(self, batch, batch_nb):\n",
+ " # OPTIONAL\n",
+ " # The code that runs as we forward pass a validation batch\n",
+ " x, y = batch\n",
+ " y_hat = self(x)\n",
+ " correct=y_hat.argmax(dim=1).eq(y).sum().item()\n",
+ " total=len(y)\n",
+ " return {'val_loss': F.cross_entropy(y_hat, y),\"correct\": correct,\"total\": total}\n",
+ "\n",
+ " def validation_epoch_end(self, outputs):\n",
+ " # OPTIONAL\n",
+ " # The code that runs as a validation epoch finished\n",
+ " # Used for metric evaluation\n",
+ " avg_loss = torch.stack([x['val_loss'] for x in outputs]).mean()\n",
+ " correct=sum([x[\"correct\"] for x in outputs])\n",
+ " total=sum([x[\"total\"] for x in outputs])\n",
+ " print(\"Loss val= {}\".format(avg_loss))\n",
+ " print(\"Number of Correctly identified Validation Images {} from aset of {}. \\nAccuracy= {} \".format(correct,total,correct/total))\n",
+ " \n",
+ " tensorboard_logs = {'val_loss': avg_loss,\"Accuracy\": correct/total}\n",
+ " return {'val_loss': avg_loss, 'log': tensorboard_logs}\n",
+ "\n",
+ " def test_step(self, batch, batch_nb):\n",
+ " # OPTIONAL\n",
+ " # The code that runs as we forward pass a test batch\n",
+ "\n",
+ " x, y = batch\n",
+ " y_hat = self(x)\n",
+ " correct=y_hat.argmax(dim=1).eq(y).sum().item()\n",
+ " total=len(y)\n",
+ " # returning the batch_dictionary\n",
+ " return {'test_loss': F.cross_entropy(y_hat, y),\n",
+ " \"correct\": correct,\n",
+ " \"total\": total}\n",
+ "\n",
+ " def test_epoch_end(self, outputs):\n",
+ " # OPTIONAL\n",
+ " # The code that runs as a validation epoch finished\n",
+ " # Used for metric evaluation\n",
+ " correct=sum([x[\"correct\"] for x in outputs])\n",
+ " total=sum([x[\"total\"] for x in outputs])\n",
+ " print(\"Number of Correctly identified Testing Images {} from aset of {}. \\nAccuracy= {} \".format(testCorrect,testTotal,testCorrect/testTotal))\n",
+ " avg_loss = torch.stack([x['test_loss'] for x in outputs]).mean()\n",
+ " print(\"Loss= {}\".format(avg_loss))\n",
+ " logs = {'test_loss': avg_loss}\n",
+ " return {'test_loss': avg_loss, 'log': logs, 'progress_bar': logs}\n",
+ "\n",
+ " def configure_optimizers(self):\n",
+ " # REQUIRED\n",
+ " # Can return multiple optimizers and learning_rate schedulers\n",
+ " return torch.optim.Adam(self.parameters(), lr=0.0005)\n",
+ "\n",
+ " def training_step(self,batch,batch_idx):\n",
+ " #REQUIRED\n",
+ " # extracting input and output from the batch\n",
+ " x,labels=batch\n",
+ " pred=self.forward(x)\n",
+ "\n",
+ " correct=pred.argmax(dim=1).eq(labels).sum().item()\n",
+ " total=len(labels)\n",
+ " #calculating the loss\n",
+ " train_loss = F.cross_entropy(pred, labels)\n",
+ "\n",
+ " #logs\n",
+ " logs={\"train_loss\": train_loss}\n",
+ "\n",
+ " output={\n",
+ " #REQUIRED: It ie required for us to return \"loss\"\n",
+ " \"loss\": train_loss,\n",
+ " #optional for logging purposes\n",
+ " \"log\": logs,\n",
+ " \"correct\": correct,\n",
+ " \"total\": total\n",
+ " }\n",
+ "\n",
+ " return output\n",
+ " \n",
+ " def training_epoch_end(self,outputs):\n",
+ "\n",
+ " avg_loss = torch.stack([x['loss'] for x in outputs]).mean()\n",
+ " print(\"Loss train= {}\".format(avg_loss))\n",
+ " correct=sum([x[\"correct\"] for x in outputs])\n",
+ " total=sum([x[\"total\"] for x in outputs])\n",
+ " tensorboard_logs = {'loss': avg_loss,\"Accuracy\": correct/total}\n",
+ " print(\"Number of Correctly identified Training Set Images {} from a set of {}. \\nAccuracy= {} \".format(correct,total,correct/total))\n",
+ " return {'loss': avg_loss, 'log': tensorboard_logs}"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "wSRlyxbaZvAI",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Training"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "H-AFLIIDZtpc",
+ "colab_type": "code",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000,
+ "referenced_widgets": [
+ "06add6832ae94410861e93402a4407ce",
+ "82b5bdbec056425d9db5e91973d2fd69",
+ "13b64b55c89b4d5a8c3956e6b4fa5ce8",
+ "df98408aa4784329ac6f6844d4645742",
+ "13be7a9e4ac447a984e0ec938ba3b132",
+ "2fec21701d2d4834b17b120b47495b01",
+ "41fa426d84d14762b074d103c433425c",
+ "f33ecdfc71df4ed995f8c59e70231f99",
+ "166788b33ec140b9bf6891b3f8797d32",
+ "50b8bfa175444793a272bf0c34a618ba",
+ "6106b9226019481c8304fcde0e63a202",
+ "66bd8a471c3c45ad816e79c7db7c35de",
+ "eaa96ec7f3f6458b96ff978ebbb52157",
+ "468f884d5cf249ab9878cd83cec045ed",
+ "f962be9fcfbd45d68cbc85d07a7dbf49",
+ "72a068171fcc44b08e4300bbeba2dd9a",
+ "547946b574294a5fac045a78e815c747",
+ "8d1ee977e12343518eb1f3638b3a8d68",
+ "b3c16289906d427f8e5aa58a96e0dcb8",
+ "674ef45d923045b29c5284159016420d",
+ "6e92cd364ab64a3d859d8dff72db10b7",
+ "fd905497be90433b93f3a3891b574dc1",
+ "3435de8896dd45e8b680ddbc9cd4f8a1",
+ "9a29111183184f4693ba5de7c6cbea94",
+ "bc5080cb96a24b2cb5b85813fa77e12e",
+ "3251321b00714f8680e455a191fbc9ca",
+ "b9d725a2bf8043988d75cd9abce113f4",
+ "3c359db366174498b4cd240b5414dd7f",
+ "51669199bff44a3b85d90665f409832e",
+ "3404f6f821b648bea27397e9ca4fd568",
+ "19cc5abdec474fa48b076e411d1af943",
+ "c48dcb96532f4553941801dc714d4735",
+ "117258bc0cdd4e3198e173476200435c",
+ "feae4123dd8b4300bc3f08125c6b1948",
+ "8b9b116ea4cb43b99a207e689e56ba4f",
+ "e1a8289ca5144d9fb0999590bd5e79e2",
+ "e00d9fd453034c02b9b06b29ae65e4f8",
+ "cbf9a18ad6b44b6380122311380a967c",
+ "e07bea8e56624fc4be74f789b2861a21",
+ "a34abcdf62da4d96a91bf30515d86ba0",
+ "1b21483222ba416fa8f456a87782af73",
+ "524fc16894714aa098982b707219f360",
+ "2b51fccadb1544deb4212f8f2dc6ae36",
+ "4d662f31c2b44e6aad5c07e2eec2fd08",
+ "7baa37345df5472380aa3a20f4d515b0",
+ "626067a3ea2e489e930357298bf4edec",
+ "baf7d82752fe4afc94bdef0ff90449ad",
+ "0bebb09292e9421295fda7ca8da23b28",
+ "bc28ca7097de4a2cbc46f0d42ebb5e70",
+ "8c60047983b84f4982da13b69511959d",
+ "be4bdcc280c24bf08f50f0581cc43e45",
+ "1efb02f06f594569862225631367274f",
+ "b0fccc4a75414c6fbee773f7fa20edb8",
+ "293a945ce7a849cd858b9dfd93d07638",
+ "b2d0417743e746e490ccffc502c65e33",
+ "6e55c115dc02444a9592166ffb1a3494",
+ "822ef578aeb4482ca09f2c3884014cf5",
+ "e8ffe3de6ca54df484958a9cf13d3252",
+ "79f86fee27cd4dc9b55eba51e2dafd8e",
+ "b9733d27c6df42e0a7cf1e410962ad07",
+ "3adde1e02cf543c2ab97c1c945b4c896",
+ "60c0822e465f46b49848030e0619ae27",
+ "4b40e778bae6427198289a348c0e839e",
+ "0f00a93e2586456590762cc71a364704",
+ "fa7ff58db3644e2fa695ca889534222b",
+ "2a94537b83ac4a99b31a9ba42f820fe7",
+ "aec0c015057f4fdebc72b4aaf1e6ec71",
+ "9c61a20668c347eea6bad88f2819330f",
+ "442a99e054d54b4f8511673eebad2d7f",
+ "2af3f7ec723042b28fbf060b2ba9c02b",
+ "4edc3548d1364b69a33be523b24165a7",
+ "dd94806e23ab40bbbc4b65fa95478a35",
+ "12272021c2234ace8b0825fc4011a919",
+ "b3536c933c604fb889c0a6629ce0a43b",
+ "165d809cf2694bfa89202ef2fed621ea",
+ "261b218116a74baab4f1b430204bcd84",
+ "323778f9289f4992be97b592769a7eb3",
+ "57feb1626025410f9fb518707724f0f1",
+ "e0d925454000435782fb9a46654a1dc0",
+ "e1c5e4bd40fb4197812204b9f90233d9",
+ "1c2da3c953d64f2f8f0d52d53ef9a76e",
+ "e3fdc27e03254b4c85a334cb8257203d",
+ "51acdd35dd534dc696c7b6942f5eb4d0",
+ "670fd15bfad64fac9bdea338e118c613",
+ "f968728971b14f83bc635efccf191073",
+ "5142d3a0327f41c29d6e1dce42de2d49",
+ "dbd0b779711d42b893ed6427a0e200cd",
+ "417a972906784467af59f5880aca329b",
+ "444e17ff24bb4034a1687413ce81c706",
+ "378472c5ac2b4266bea077c384330e28",
+ "6a894f5f3ada42c1b04502b50f7cc7e1",
+ "33f4347b60084c2bbc2954a1a4244d14",
+ "89ab9598547e4d82839d9c5c35448832",
+ "29d183cbb8eb4f2a80624bf9cf258d4c",
+ "51e6dbea5ba34115a7ef056880ce2773",
+ "3d6d28ee166248e6964291bd5ac8fbc6"
+ ]
+ },
+ "outputId": "43a2c43f-b70f-456a-8f98-dd8019420850"
+ },
+ "source": [
+ "# Using the Lightning trainer and specifing the requied parameters as arguments\n",
+ "myTrainer=pl.Trainer(gpus=1,max_nb_epochs=10,checkpoint_callback=False)\n",
+ "\n",
+ "myModel=smallAndSmartModel()\n",
+ "\n",
+ "# Begin Training\n",
+ "myTrainer.fit(myModel)"
+ ],
+ "execution_count": 5,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "text": [
+ "GPU available: True, used: True\n",
+ "No environment variable for node rank defined. Set as 0.\n",
+ "CUDA_VISIBLE_DEVICES: [0]\n",
+ "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:44: UserWarning: nn.init.xavier_uniform is now deprecated in favor of nn.init.xavier_uniform_.\n",
+ "\n",
+ " | Name | Type | Params\n",
+ "--------------------------------------\n",
+ "0 | layer1 | Sequential | 320 \n",
+ "1 | layer1.0 | Conv2d | 320 \n",
+ "2 | layer1.1 | ReLU | 0 \n",
+ "3 | layer1.2 | MaxPool2d | 0 \n",
+ "4 | layer1.3 | Dropout | 0 \n",
+ "5 | layer2 | Sequential | 18 K \n",
+ "6 | layer2.0 | Conv2d | 18 K \n",
+ "7 | layer2.1 | ReLU | 0 \n",
+ "8 | layer2.2 | MaxPool2d | 0 \n",
+ "9 | layer2.3 | Dropout | 0 \n",
+ "10 | layer3 | Sequential | 73 K \n",
+ "11 | layer3.0 | Conv2d | 73 K \n",
+ "12 | layer3.1 | ReLU | 0 \n",
+ "13 | layer3.2 | MaxPool2d | 0 \n",
+ "14 | layer3.3 | Dropout | 0 \n",
+ "15 | fc1 | Linear | 1 M \n",
+ "16 | layer4 | Sequential | 1 M \n",
+ "17 | layer4.1 | ReLU | 0 \n",
+ "18 | layer4.2 | Dropout | 0 \n",
+ "19 | dense1_bn | BatchNorm1d | 1 K \n",
+ "20 | fc2 | Linear | 6 K \n",
+ "21 | dense2_bn | BatchNorm1d | 20 \n"
+ ],
+ "name": "stderr"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "06add6832ae94410861e93402a4407ce",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validation sanity check', layout=Layout…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 2.302561044692993\n",
+ "Number of Correctly identified Validation Images 23 from aset of 256. \n",
+ "Accuracy= 0.08984375 \n",
+ "\r"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "166788b33ec140b9bf6891b3f8797d32",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Training', layout=Layout(flex='2'), max…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "547946b574294a5fac045a78e815c747",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.7407737970352173\n",
+ "Number of Correctly identified Validation Images 4830 from aset of 5000. \n",
+ "Accuracy= 0.966 \n",
+ "Loss train= 1.8832314014434814\n",
+ "Number of Correctly identified Training Set Images 45182 from a set of 55000. \n",
+ "Accuracy= 0.821490909090909 \n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "bc5080cb96a24b2cb5b85813fa77e12e",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.6396793127059937\n",
+ "Number of Correctly identified Validation Images 4899 from aset of 5000. \n",
+ "Accuracy= 0.9798 \n",
+ "Loss train= 1.7029248476028442\n",
+ "Number of Correctly identified Training Set Images 52054 from a set of 55000. \n",
+ "Accuracy= 0.9464363636363636 \n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "117258bc0cdd4e3198e173476200435c",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.5858315229415894\n",
+ "Number of Correctly identified Validation Images 4923 from aset of 5000. \n",
+ "Accuracy= 0.9846 \n",
+ "Loss train= 1.6400469541549683\n",
+ "Number of Correctly identified Training Set Images 52792 from a set of 55000. \n",
+ "Accuracy= 0.9598545454545454 \n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "1b21483222ba416fa8f456a87782af73",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.559800386428833\n",
+ "Number of Correctly identified Validation Images 4930 from aset of 5000. \n",
+ "Accuracy= 0.986 \n",
+ "Loss train= 1.6016995906829834\n",
+ "Number of Correctly identified Training Set Images 53187 from a set of 55000. \n",
+ "Accuracy= 0.9670363636363636 \n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "bc28ca7097de4a2cbc46f0d42ebb5e70",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.5370867252349854\n",
+ "Number of Correctly identified Validation Images 4944 from aset of 5000. \n",
+ "Accuracy= 0.9888 \n",
+ "Loss train= 1.5763448476791382\n",
+ "Number of Correctly identified Training Set Images 53364 from a set of 55000. \n",
+ "Accuracy= 0.9702545454545455 \n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "822ef578aeb4482ca09f2c3884014cf5",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.5241750478744507\n",
+ "Number of Correctly identified Validation Images 4947 from aset of 5000. \n",
+ "Accuracy= 0.9894 \n",
+ "Loss train= 1.5586891174316406\n",
+ "Number of Correctly identified Training Set Images 53491 from a set of 55000. \n",
+ "Accuracy= 0.9725636363636364 \n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "fa7ff58db3644e2fa695ca889534222b",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.5118769407272339\n",
+ "Number of Correctly identified Validation Images 4953 from aset of 5000. \n",
+ "Accuracy= 0.9906 \n",
+ "Loss train= 1.5447603464126587\n",
+ "Number of Correctly identified Training Set Images 53618 from a set of 55000. \n",
+ "Accuracy= 0.9748727272727272 \n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "12272021c2234ace8b0825fc4011a919",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.5051761865615845\n",
+ "Number of Correctly identified Validation Images 4960 from aset of 5000. \n",
+ "Accuracy= 0.992 \n",
+ "Loss train= 1.5337687730789185\n",
+ "Number of Correctly identified Training Set Images 53743 from a set of 55000. \n",
+ "Accuracy= 0.9771454545454545 \n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "1c2da3c953d64f2f8f0d52d53ef9a76e",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.4986270666122437\n",
+ "Number of Correctly identified Validation Images 4956 from aset of 5000. \n",
+ "Accuracy= 0.9912 \n",
+ "Loss train= 1.5260114669799805\n",
+ "Number of Correctly identified Training Set Images 53755 from a set of 55000. \n",
+ "Accuracy= 0.9773636363636363 \n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "444e17ff24bb4034a1687413ce81c706",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.492732286453247\n",
+ "Number of Correctly identified Validation Images 4961 from aset of 5000. \n",
+ "Accuracy= 0.9922 \n",
+ "Loss train= 1.519001841545105\n",
+ "Number of Correctly identified Training Set Images 53878 from a set of 55000. \n",
+ "Accuracy= 0.9796 \n",
+ "\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "execution_count": 5
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "iK1T1xr0TkUf",
+ "colab_type": "text"
+ },
+ "source": [
+ "## View in TensorBoard\n",
+ "While Using Default Logger location for TensorBoard logs is `lightning_logs/`\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "dHxHk0AFTjBY",
+ "colab_type": "code",
+ "colab": {
+ "resources": {
+ "https://localhost:6006/": {
+ "data": "<!doctype html><!--
@license
Copyright 2016 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 lang="en"><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>
  html,
  body {
    margin: 0;
    padding: 0;
    height: 100%;
    font-family: Roboto, sans-serif;
  }
</style>






<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>





















<dom-module id="paper-ripple">

  <template>
    <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>
  </template>
</dom-module>











<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>




<dom-module id="paper-material-styles">
  <template>
    <style>
      :host, 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;
        };
      }
      :host(.paper-material), .paper-material {
        @apply --paper-material;
      }
      :host(.paper-material[elevation="1"]), .paper-material[elevation="1"] {
        @apply --paper-material-elevation-1;
      }
      :host(.paper-material[elevation="2"]), .paper-material[elevation="2"] {
        @apply --paper-material-elevation-2;
      }
      :host(.paper-material[elevation="3"]), .paper-material[elevation="3"] {
        @apply --paper-material-elevation-3;
      }
      :host(.paper-material[elevation="4"]), .paper-material[elevation="4"] {
        @apply --paper-material-elevation-4;
      }
      :host(.paper-material[elevation="5"]), .paper-material[elevation="5"] {
        @apply --paper-material-elevation-5;
      }
    </style>
  </template>
</dom-module>




<dom-module id="paper-button">
  <template strip-whitespace>
    <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: #eaeaea;
        color: #a8a8a8;
        cursor: auto;
        pointer-events: none;

        @apply --paper-button-disabled;
      }

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

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

    <slot></slot>
  </template>

  
</dom-module>





<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>




<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.html 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>
































<dom-module id="paper-checkbox">
  <template strip-whitespace>
    <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;
      }

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

      @-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>
  </template>

  
</dom-module>












<dom-module id="iron-icon">
  <template>
    <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>
  </template>

  

</dom-module>









<dom-module id="iron-a11y-announcer">
  <template>
    <style>
      :host {
        display: inline-block;
        position: fixed;
        clip: rect(0px,0px,0px,0px);
      }
    </style>
    <div aria-live$="[[mode]]">[[_text]]</div>
  </template>

  
</dom-module>





<dom-module id="iron-input">
  <template>
    <style>
      :host {
        display: inline-block;
      }
    </style>
    <slot id="content"></slot>
  </template>
  
</dom-module>












<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>








<dom-module id="paper-input-char-counter">
  <template>
    <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>
  </template>
</dom-module>










<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: bottom;

        @apply --paper-font-subhead;
      };
    }
  </style>
</custom-style>

<dom-module id="paper-input-container">
  <template>
    <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.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>
  </template>
</dom-module>










<dom-module id="paper-input-error">
  <template>
    <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;
      };
    </style>

    <slot></slot>
  </template>
</dom-module>






<dom-module id="paper-input">
  <template>
    <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>

      <span id="template-placeholder"></span>

      <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>
  </template>

  
  <template id="v0">
    <input is="iron-input" slot="input" class="input-element" id$="[[_inputId]]" aria-labelledby$="[[_ariaLabelledBy]]" aria-describedby$="[[_ariaDescribedBy]]" disabled$="[[disabled]]" title$="[[title]]" bind-value="{{value}}" invalid="{{invalid}}" prevent-invalid-input="[[preventInvalidInput]]" allowed-pattern="[[allowedPattern]]" validator="[[validator]]" 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]]">
  </template>

  <template id="v1">
    
    <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]]">
    </iron-input>
  </template>

</dom-module>























<dom-module id="iron-overlay-backdrop">

  <template>
    <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>
  </template>

</dom-module>
































<dom-module id="iron-dropdown">
  <template>
    <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>
  </template>

  
</dom-module>





























<dom-module id="paper-menu-button">
  <template>
    <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">
      <div slot="dropdown-content" class="dropdown-content">
        <slot id="content" name="dropdown-content"></slot>
      </div>
    </iron-dropdown>
  </template>

  
</dom-module>










<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>



<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;
      }

      :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>




<dom-module id="paper-dropdown-menu">
  <template>
    <style include="paper-dropdown-menu-shared-styles"></style>

    
    <span role="button"></span>
    <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]]">
      
      <div class="dropdown-trigger" slot="dropdown-trigger">
        <paper-ripple></paper-ripple>
        
        <paper-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]]">
          
          <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>
  </template>

  
</dom-module>























<dom-module id="paper-listbox">
  <template>
    <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>
  </template>

  
</dom-module>

















<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>




<dom-module id="paper-item">
  <template>
    <style include="paper-item-shared-styles">
      :host {
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-subhead;

        @apply --paper-item;
      }
    </style>
    <slot></slot>
  </template>

  
</dom-module>


















<dom-module id="tf-backend">
  
</dom-module>




















<dom-module id="tf-storage">
  
</dom-module>



<dom-module id="tf-tag-filterer">
  <template>
    <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>
  </template>
  
</dom-module>






<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>


<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>


<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>

<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>









<style is="custom-style">
  :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-graph-faded: #e0d4b3;
  }
</style>


<dom-module id="dashboard-style">
  <template>
    <style include="iron-flex"></style>
    <style>
      :host {
        --sidebar-vertical-padding: 15px;
        --sidebar-left-padding: 30px;
      }

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

      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 rgba(0, 0, 0, 0.12);
        padding: var(--sidebar-vertical-padding) 0
          var(--sidebar-vertical-padding) var(--sidebar-left-padding);
        position: relative;
      }

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

      .sidebar-section:last-of-type {
        flex-grow: 1;
        display: flex;
      }

      .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(--paper-grey-800);
        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;
      }
    </style>
  </template>
</dom-module>





<dom-module id="scrollbar-style">
  <template>
    <style>
      .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;
      }
    </style>
  </template>
</dom-module>




<dom-module id="tf-dashboard-layout">
  <template>
    <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 {
        display: flex;
        flex-direction: row;
        height: 100%;
      }

      #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']) {
        height: 100%;
        overflow-x: hidden;
        overflow-y: auto;
        width: 100%;
        will-change: transform;
      }

      .tf-graph-dashboard #center {
        background: #fff;
      }
    </style>
  </template>
  
</dom-module>





<dom-module id="tf-option-selector">
  <template>
    <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(--paper-grey-800);
        display: block;
        font-size: 14px;
        font-weight: normal;
        margin: 0 0 5px;
        pointer-events: none;
      }
    </style>
  </template>
  
</dom-module>









<dom-module id="iron-collapse">

  <template>

    <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>

  </template>

</dom-module>



















<dom-module id="tf-category-paginated-view">
  <template>
    <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>
      
      <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: white;
        border: none;
        cursor: pointer;
        width: 100%;
        font-size: 15px;
        line-height: 1;
        box-shadow: 0 1px 5px rgba(0, 0, 0, 0.2);
        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: white;
        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;
      }

      #page-input {
        display: inline-block;
        width: var(--tf-category-paginated-view-page-input-width, 100%);
      }
    </style>
  </template>
  
</dom-module>

















<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>



<dom-module id="paper-dialog">
  <template>
    <style include="paper-dialog-shared-styles"></style>
    <slot></slot>
  </template>
</dom-module>











<dom-module id="tf-color-scale">
  
  
</dom-module>




<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" /></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" /></g>
<g id="accessible"><circle cx="12" cy="4" r="2" /><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" /></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" /></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" /></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" /></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" /></g>
<g id="add"><path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="arrow-drop-down"><path d="M7 10l5 5 5-5z" /></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" /></g>
<g id="arrow-drop-up"><path d="M7 14l5-5 5 5z" /></g>
<g id="arrow-forward"><path d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z" /></g>
<g id="arrow-upward"><path d="M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="change-history"><path d="M12 7.77L18.39 18H5.61L12 7.77M12 4L2 20h20L12 4z" /></g>
<g id="check"><path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z" /></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" /></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" /></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" /></g>
<g id="chevron-left"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z" /></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="compare-arrows"><path d="M9.01 14H2v2h7.01v3L13 15l-3.99-4v3zm5.98-1v-3H22V8h-7.01V5L11 9l3.99 4z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="dashboard"><path d="M3 13h8V3H3v10zm0 8h8v-6H3v6zm10 0h8V11h-8v10zm0-18v6h8V3h-8z" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="done"><path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z" /></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" /></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" /></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" /></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" /></g>
<g id="eject"><path d="M5 17h14v2H5zm7-12L5.33 15h13.34z" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="expand-less"><path d="M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z" /></g>
<g id="expand-more"><path d="M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="file-download"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z" /></g>
<g id="file-upload"><path d="M9 16h6v-6h4l-7-7-7 7h4zm-4 2h14v2H5z" /></g>
<g id="filter-list"><path d="M10 18h4v-2h-4v2zM3 6v2h18V6H3zm3 7h12v-2H6v2z" /></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" /></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" /></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" /></g>
<g id="first-page"><path d="M18.41 16.59L13.82 12l4.59-4.59L17 6l-6 6 6 6zM6 6h2v12H6z" /></g>
<g id="flag"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="forward"><path d="M12 8V4l8 8-8 8v-4H4V8z" /></g>
<g id="fullscreen"><path d="M7 14H5v5h5v-2H7v-3zm-2-4h2V7h3V5H5v5zm12 7h-3v2h5v-5h-2v3zM14 5v2h3v3h2V5h-5z" /></g>
<g id="fullscreen-exit"><path d="M5 16h3v3h2v-5H5v2zm3-8H5v2h5V5H8v3zm6 11h2v-3h3v-2h-5v5zm2-11V5h-2v5h5V8h-3z" /></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" /></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" /></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" /></g>
<g id="get-app"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="home"><path d="M10 20v-6h4v6h5v-8h3L12 3 2 12h3v8z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="last-page"><path d="M5.59 7.41L10.18 12l-4.59 4.59L7 18l6-6-6-6zM16 6h2v12h-2z" /></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" /></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" /></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" /></g>
<g id="line-weight"><path d="M3 17h18v-2H3v2zm0 3h18v-1H3v1zm0-7h18v-3H3v3zm0-9v4h18V4H3z" /></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" /></g>
<g id="list"><path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm4 4h14v-2H7v2zm0 4h14v-2H7v2zM7 7v2h14V7H7z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="menu"><path d="M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="pets"><circle cx="4.5" cy="9.5" r="2.5" /><circle cx="9" cy="5.5" r="2.5" /><circle cx="15" cy="5.5" r="2.5" /><circle cx="19.5" cy="9.5" r="2.5" /><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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="record-voice-over"><circle cx="9" cy="9" r="4" /><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" /></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" /></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" /></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" /></g>
<g id="remove"><path d="M19 13H5v-2h14v2z" /></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" /></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" /></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" /></g>
<g id="reorder"><path d="M3 15h18v-2H3v2zm0 4h18v-2H3v2zm0-8h18V9H3v2zm0-6v2h18V5H3z" /></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" /></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" /></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" /></g>
<g id="report-problem"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="send"><path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="sort"><path d="M3 18h6v-2H3v2zM3 6v2h18V6H3zm0 7h12v-2H3v2z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="store"><path d="M20 4H4v2h16V4zm1 10v-2l-1-5H4l-1 5v2h1v6h10v-6h4v6h2v-6h1zm-9 4H6v-4h6v4z" /></g>
<g id="subdirectory-arrow-left"><path d="M11 9l1.42 1.42L8.83 14H18V4h2v12H8.83l3.59 3.58L11 21l-6-6 6-6z" /></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" /></g>
<g id="subject"><path d="M14 17H4v2h10v-2zm6-8H4v2h16V9zM4 15h16v-2H4v2zM4 5v2h16V5H4z" /></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" /></g>
<g id="swap-horiz"><path d="M6.99 11L3 15l3.99 4v-3H14v-2H6.99v-3zM21 9l-3.99-4v3H10v2h7.01v3L21 9z" /></g>
<g id="swap-vert"><path d="M16 17.01V10h-2v7.01h-3L15 21l4-3.99h-3zM9 3L5 6.99h3V14h2V6.99h3L9 3z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="toc"><path d="M3 9h14V7H3v2zm0 4h14v-2H3v2zm0 4h14v-2H3v2zm16 0h2v-2h-2v2zm0-10v2h2V7h-2zm0 6h2v-2h-2v2z" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="trending-flat"><path d="M22 12l-4-4v3H3v2h15v3z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="view-array"><path d="M4 18h3V5H4v13zM18 5v13h3V5h-3zM8 18h9V5H8v13z" /></g>
<g id="view-carousel"><path d="M7 19h10V4H7v15zm-5-2h4V6H2v11zM18 6v11h4V6h-4z" /></g>
<g id="view-column"><path d="M10 18h5V5h-5v13zm-6 0h5V5H4v13zM16 5v13h5V5h-5z" /></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" /></g>
<g id="view-headline"><path d="M4 15h16v-2H4v2zm0 4h16v-2H4v2zm0-8h16V9H4v2zm0-6v2h16V5H4z" /></g>
<g id="view-list"><path d="M4 14h4v-4H4v4zm0 5h4v-4H4v4zM4 9h4V5H4v4zm5 5h12v-4H9v4zm0 5h12v-4H9v4zM9 5v4h12V5H9z" /></g>
<g id="view-module"><path d="M4 11h5V5H4v6zm0 7h5v-6H4v6zm6 0h5v-6h-5v6zm6 0h5v-6h-5v6zm-6-7h5V5h-5v6zm6-6v6h5V5h-5z" /></g>
<g id="view-quilt"><path d="M10 18h5v-6h-5v6zm-6 0h5V5H4v13zm12 0h5v-6h-5v6zM10 5v6h11V5H10z" /></g>
<g id="view-stream"><path d="M4 18h17v-6H4v6zM4 5v6h17V5H4z" /></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" /></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" /></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" /></g>
<g id="warning"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
</defs></svg>
</iron-iconset-svg>









<dom-module id="paper-icon-button">
  <template strip-whitespace>
    <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>
  </template>

  
</dom-module>








<dom-module id="run-color-style">
  <template>
    <style>
      [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);
      }
    </style>
  </template>
</dom-module>




<dom-module id="tf-multi-checkbox">
  <template>
    <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 {
        overflow-y: auto;
        overflow-x: hidden;
        width: 100%;
        flex-grow: 1;
        flex-shrink: 1;
        word-wrap: break-word;
      }
      .name-row {
        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>
  </template>
  
</dom-module>




<dom-module id="tf-wbr-string">
  <template>
    
    <template is="dom-repeat" items="[[_parts]]" as="part">[[part]]<wbr></template>
  </template>
  
</dom-module>



<dom-module id="tf-runs-selector">
  <template>
    <paper-dialog with-backdrop id="data-location-dialog">
      <h2>Data Location</h2>
      <tf-wbr-string value="[[dataLocation]]" />
    </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]]" /><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 {
        width: 100%;
        flex-grow: 0;
        flex-shrink: 0;
        padding-right: 16px;
        box-sizing: border-box;
        color: var(--paper-grey-800);
      }
      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(--paper-grey-800);
        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>
  </template>
  
</dom-module>




















<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 {
        left: 45%;
        width: 10%;
        border-top-style: solid;
      }

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

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

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

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

      .active .gap-patch::after,
      .active .circle-clipper::after {
        -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::after {
        -webkit-animation-name: left-spin;
        animation-name: left-spin;
      }

      .active .circle-clipper.right::after {
        -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>




<dom-module id="paper-spinner-lite">
  <template strip-whitespace>
    <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>
        <div class="circle-clipper right"></div>
      </div>
    </div>
  </template>

  
</dom-module>











<style>
.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 {
  font-family: "Helvetica Neue", sans-serif;
  fill: #32313F;
}

.plottable .bar-label-text-area text {
  font-family: "Helvetica Neue", sans-serif;
  font-size: 12px;
}

.plottable .label-area text {
  fill: #32313F;
  font-family: "Helvetica Neue", sans-serif;
  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-family: "Helvetica Neue", sans-serif;
  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-family: "Helvetica Neue", sans-serif;
  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;
}
</style>

<dom-module id="plottable-style">
  <template>
    <style>
.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 {
  font-family: "Helvetica Neue", sans-serif;
  fill: #32313F;
}

.plottable .bar-label-text-area text {
  font-family: "Helvetica Neue", sans-serif;
  font-size: 12px;
}

.plottable .label-area text {
  fill: #32313F;
  font-family: "Helvetica Neue", sans-serif;
  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-family: "Helvetica Neue", sans-serif;
  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-family: "Helvetica Neue", sans-serif;
  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;
}
</style>
  </template>
</dom-module>













<dom-module id="vz-chart-tooltip">
  
</dom-module>











<dom-module id="vz-pan-zoom-style">
  <template>
    <style>
      .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;
        }
      }
    </style>
  </template>
</dom-module>



<dom-module id="vz-line-chart2">
  <template>
    <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 {
        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 line.guide-line {
        stroke: #999;
        stroke-width: 1.5px;
      }
      #chartdiv:hover {
        will-change: transform;
      }

      .ghost {
        opacity: 0.2;
        stroke-width: 1px;
      }
    </style>
  </template>
  
  
  
  
  
</dom-module>

<dom-module id="vz-line-chart-tooltip">
  <template>
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-line-chart-data-loader">
  <template>
    <div id="chart-and-spinner-container">
      <vz-line-chart2 id="chart" data-loading$="[[dataLoading]]" 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>
  </template>
  
  
</dom-module>










<dom-module id="paper-dialog-scrollable">

  <template>
    <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>
  </template>

</dom-module>







<dom-module id="tf-markdown-view">
  <template>
    <div id="markdown" inner-h-t-m-l="[[html]]"></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 #dfe2e5;
      }
      #markdown table tr {
        background-color: #fff;
        border-top: 1px solid #c6cbd1;
      }
    </style>
  </template>
  
</dom-module>

<dom-module id="tf-card-heading-style">
  <template>
    <style>
      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;
      }
    </style>
  </template>
</dom-module>





<dom-module id="tf-card-heading">
  <template>
    <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]]">
            
            
            <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>
  </template>
  
</dom-module>






<dom-module id="tf-downloader">
  <template>
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-scalar-card">
  <template>
    <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>
  </template>
  
</dom-module>




















<dom-module id="paper-progress">
  <template>
    <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>
  </template>
</dom-module>







<dom-module id="paper-slider">
  <template strip-whitespace>
    <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
       * compatability, 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;
        top: calc(14px + var(--paper-slider-height,2px)/2);
        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>
  </template>

  
</dom-module>





<dom-module id="tf-smoothing-input">
  <template>
    <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(--paper-grey-800);
        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>
  </template>
  
</dom-module>



<dom-module id="tf-scalar-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <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 class="sidebar-section">
          <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:
            <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>
              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.
            
          </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]]"></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>
  </template>

  
</dom-module>
































<dom-module id="tf-custom-scalar-card-style">
  <template>
    <style>
      :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;
        }
      }
    </style>
  </template>
</dom-module>





<dom-module id="tf-custom-scalar-margin-chart-card">
  <template>
    <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]]" get-data-load-url="[[_dataUrl]]" fill-area="[[_fillArea]]" ignore-y-outliers="[[ignoreYOutliers]]" load-key="[[_tagFilter]]" data-to-load="[[runs]]" 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>

    
    <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>
  </template>
  
</dom-module>


















<dom-module id="tf-custom-scalar-multi-line-chart-card">
  <template>
    <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]]" get-data-load-url="[[_dataUrl]]" ignore-y-outliers="[[ignoreYOutliers]]" load-key="[[_tagFilter]]" data-to-load="[[runs]]" 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>
  </template>
  
</dom-module>



<dom-module id="tf-custom-scalar-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <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 class="sidebar-section">
          <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:
            <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,
            
            <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>.
            
          </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>
                <div>
                  <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>
                </div>
              </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>
  </template>

  
</dom-module>





























<dom-module id="tf-image-loader">
  <template>
    <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>

    
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-image-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <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 class="sidebar-section">
          <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:
            <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>
              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.
            
          </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>
  </template>
  
</dom-module>























<dom-module id="tf-audio-loader">
  <template>
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-audio-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section">
          <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:
            <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>
              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.
            
          </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>
  </template>
  
</dom-module>













<dom-module id="iron-autogrow-textarea">
  <template>
    <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>

    
    
    <div id="mirror" class="mirror-text" aria-hidden="true">&nbsp;</div>

    
    <div class="textarea-container fit">
      <textarea id="textarea" name$="[[name]]" aria-label$="[[label]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" inputmode$="[[inputmode]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" required$="[[required]]" disabled$="[[disabled]]" rows$="[[rows]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]"></textarea>
    </div>
  </template>
</dom-module>











<dom-module id="paper-textarea">
  <template>
    <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>
  </template>
</dom-module>













<dom-module id="paper-toast">
  <template>
    <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>
  </template>

  
</dom-module>

















<dom-module id="paper-toggle-button">
  <template strip-whitespace>

    <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>

  </template>

  
</dom-module>








































<dom-module id="tf-graph-minimap">
  <template>
    <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>
    
    <canvas class="second"></canvas>
    <canvas class="download"></canvas>
  </template>
  
</dom-module>



<dom-module id="tf-graph-scene">
  <template>
    <style>
      :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;
      }

      /* --- 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 > 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>
        
        <path id="reference-arrowhead-path" d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0" />
        <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" />
        </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" />
        </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" />
        </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" />
        </marker>

        
        <path id="dataflow-arrowhead-path" d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0" />
        <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" />
        </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" />
        </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" />
        </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" />
        </marker>

        
        <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" />
        </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" />
        </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" />
        </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" />
        </marker>
        
        <ellipse id="op-node-stamp" rx="7.5" ry="3" stroke="inherit" fill="inherit" />
        
        <ellipse id="op-node-annotation-stamp" rx="5" ry="2" stroke="inherit" fill="inherit" />
        
        <g id="op-series-vertical-stamp">
          <use xlink:href="#op-node-stamp" x="8" y="9" />
          <use xlink:href="#op-node-stamp" x="8" y="6" />
          <use xlink:href="#op-node-stamp" x="8" y="3" />
        </g>
        
        <g id="op-series-horizontal-stamp">
          <use xlink:href="#op-node-stamp" x="16" y="4" />
          <use xlink:href="#op-node-stamp" x="12" y="4" />
          <use xlink:href="#op-node-stamp" x="8" y="4" />
        </g>
        
        <g id="op-series-annotation-stamp">
          <use xlink:href="#op-node-annotation-stamp" x="9" y="2" />
          <use xlink:href="#op-node-annotation-stamp" x="7" y="2" />
          <use xlink:href="#op-node-annotation-stamp" x="5" y="2" />
        </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" />
        </svg>

        
        <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" />
        </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" />
        </pattern>

        
        <filter id="health-pill-shadow" x="-40%" y="-40%" width="180%" height="180%">
          <fegaussianblur in="SourceAlpha" stdDeviation="0.8" />
          <feoffset dx="0" dy="0" result="offsetblur" />
          <feflood flood-color="#000000" />
          <fecomposite in2="offsetblur" operator="in" />
          <femerge>
            <femergenode />
            <femergenode in="SourceGraphic" />
          </femerge>
        </filter>
      </defs>
      
      <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>
  </template>
  
</dom-module>


<dom-module id="tf-graph">
  <template>
    <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>
  </template>
</dom-module>




















<dom-module id="tf-debugger-continue-dialog">
  <template>
    <paper-button raised class="continue-button" on-click="_continueButtonCallback">
      <span>[[_continueButtonText]]</span>
    </paper-button>
    <paper-dialog with-backdrop id="continueDialog">
      <h2>Continue...</h2>
      <div class="continue-to-type">
        <div class="continue-to-type-name">
          Over Session Runs:
        </div>
        <paper-input id="continueNum" class="input-box" label="Number of Session Runs (including the current one):" always-float-label type="number" min="1" step="1" value="{{continueNum}}"></paper-input>
        <paper-icon-button class="go-button" icon="arrow-forward" title="Session Runs Go" on-tap="_sessionRunGoButtonCallback">
        </paper-icon-button>
      </div>
      <div class="continue-to-type">
        <div class="continue-to-type-name">
          Till Condition Met by Watched Tensor
        </div>
        <paper-dropdown-menu id="tensorConditionDropdown" class="input-box" no-label-float="true" label="Tensor Condition" selected-item-label="{{_selectedTensorCondition}}">
          
          <paper-listbox id="tensorConditionMenu" class="dropdown-content" slot="dropdown-content">
            <paper-item no-label-float="true">Contains +/-∞ or NaN</paper-item>
            <paper-item no-label-float="true">Contains +/-∞</paper-item>
            <paper-item no-label-float="true">Contains NaN</paper-item>
            <paper-item no-label-float="true">Max &gt;</paper-item>
            <paper-item no-label-float="true">Max &lt;</paper-item>
            <paper-item no-label-float="true">Min &gt;</paper-item>
            <paper-item no-label-float="true">Min &lt;</paper-item>
            <paper-item no-label-float="true">Max - Min &gt;</paper-item>
            <paper-item no-label-float="true">Max - Min &lt;</paper-item>
            <paper-item no-label-float="true">Mean &gt;</paper-item>
            <paper-item no-label-float="true">Mean &lt;</paper-item>
            <paper-item no-label-float="true">Standard deviation &gt;</paper-item>
            <paper-item no-label-float="true">Standard deviation &lt;</paper-item>
          </paper-listbox>
        </paper-dropdown-menu>
        <paper-icon-button class="go-button" icon="arrow-forward" title="Tensor Condition Go" on-tap="_tensorContinueGoButtonCallback">
        </paper-icon-button>
        <paper-input id="ref-value" class="input-box" label="Reference value to compare to" type="number" value="{{_tensorConditionRefValue}}" hidden="[[_isRefValueInputHidden]]">
        </paper-input>
      </div>
    </paper-dialog>
    <style include="dashboard-style"></style>
    <style>
      :host .continue-to-type-name {
        font-weight: bold;
      }
      :host paper-dialog {
        width: 36vw;
      }
      :host .input-box {
        display: inline-block;
        position: relative;
        width: 80%;
        font-size: 110%;
      }
      :host .go-button {
        position: relative;
        width: 15%;
        display: inline-block;
      }
    </style>
  </template>
  
</dom-module>




<dom-module id="tf-debugger-initial-dialog">
  <template>
    
    <template is="dom-if" if="[[_open]]">
      <div id="dashboard-backdrop"></div>
    </template>
    <paper-dialog id="dialog" no-cancel-on-outside-click no-cancel-on-esc-key opened="{{_open}}">
      <h2 id="dialog-title">[[_title]]</h2>
      <template is="dom-if" if="[[_hasCustomMessage]]">
        <div class="custom-message">[[_customMessage]]</div>
      </template>
      <template is="dom-if" if="[[!_hasCustomMessage]]">
        <div class="code-example">
          <div class="code-example-section">
            <div class="code-example-section-title">
              <a href="https://www.tensorflow.org/api_docs/python/tf/Session" target="_blank" rel="noopener noreferrer">tf.Session</a>:
            </div>
            <pre class="code-snippet">import tensorflow as tf
from tensorflow.python import debug as tf_debug

sess = tf.Session()
sess = tf_debug.TensorBoardDebugWrapperSession(sess, "[[_host]]:[[_port]]")
sess.run(my_fetches)
          </pre>
          </div>
          <div class="code-example-section">
            <div class="code-example-section-title">
              <a href="https://www.tensorflow.org/programmers_guide/estimators" target="_blank" rel="noopener noreferrer">Estimator</a>
              |
              <a href="https://www.tensorflow.org/api_docs/python/tf/train/MonitoredSession" target="_blank" rel="noopener noreferrer">MonitoredSession</a>:
            </div>
            <pre class="code-snippet">import tensorflow as tf
from tensorflow.python import debug as tf_debug

hook = tf_debug.TensorBoardDebugHook("[[_host]]:[[_port]]")
my_estimator.fit(x=x_data, y=y_data, steps=1000, monitors=[hook])
            </pre>
          </div>
          <div class="code-example-section">
            <div class="code-example-section-title">
              <a href="https://keras.io/models/model/" target="_blank" rel="noopener noreferrer">Keras Model</a>:
            </div>
            <pre class="code-snippet">import tensorflow as tf
from tensorflow.python import debug as tf_debug
import keras

keras.backend.set_session(
    tf_debug.TensorBoardDebugWrapperSession(tf.Session(), "[[_host]]:[[_port]]"))
# Define your keras model, called "model".
model.fit(...)
            </pre>
          </div>
        </div>
      </template>
    </paper-dialog>
    <style>
      /** We rely on a separate `_hidden` property instead of directly making use
          of the `_open` attribute because this CSS specification may strangely
          affect other elements throughout TensorBoard. See #899. */
      :host([_hidden]) {
        display: none;
      }
      :host,
      #dashboard-backdrop {
        position: absolute;
        top: 0;
        bottom: 0;
        left: 0;
        right: 0;
      }

      #dashboard-backdrop {
        background: rgba(0, 0, 0, 0.6);
      }

      .code-example {
        margin: 10px;
        font-family: monospace;
      }
      .code-example-section {
        padding-bottom: 15px;
      }
      .code-example-section-title {
        font-weight: bold;
      }
      .code-snippet {
        padding-left: 1em;
      }

      #dialog-title {
        padding-bottom: 15px;
      }

      .custom-message {
        margin-top: 0;
        margin-bottom: 15px;
      }
    </style>
  </template>
  
</dom-module>





<dom-module id="tf-debugger-resizer">
  <template>
    <div class="bars">
      <div class="bars-rotator">
        <span class="bars-text">| |</span>
      </div>
    </div>
    <style>
      :host([_resizer-identifier]) {
        position: absolute;
        background: #ccc;
        user-select: none;
      }

      :host([is-horizontal]) {
        cursor: row-resize;
        height: 10px;
        left: 0;
        right: 0;
      }

      :host([_is-vertical]) {
        cursor: col-resize;
        right: -15px;
        top: 0;
        bottom: 0;
        width: 10px;
      }

      .bars {
        width: 80%;
        text-align: center;
        position: absolute;
        top: 50%;
        left: 50%;
        font-size: 5px;
        transform: translate(-50%, -50%);
      }

      /** This block prevents the bars rotator from having a height that is
          the entire viewport, thus occluding it and giving it an undesired cursor
          value. */
      .bars-rotator {
        display: inline-block;
      }

      :host([is-horizontal]) .bars-rotator {
        transform: rotate(90deg);
      }

      .bars-text {
        transform: scaleY(15);
        white-space: nowrap;
        display: block;
        font-weight: 400;
      }
    </style>
  </template>
  
</dom-module>












<dom-module id="tf-op-selector">
  <template>
    <div>
      <paper-dropdown-menu id="filter-mode" no-label-float="true" label="Filter Mode" selected-item-label="{{_filterMode}}">
        <paper-listbox class="dropdown-content" slot="dropdown-content">
          <paper-item no-label-float="true">Node Name</paper-item>
          <paper-item no-label-float="true">Op Type</paper-item>
        </paper-listbox>
      </paper-dropdown-menu>
      <paper-input id="filter-input" label="Filter Regex" always-float-label value="{{_filterInput}}"></paper-input>
    </div>
    <paper-spinner-lite active class="spinner" id="loading-spinner" hidden="[[!_isLoading]]">
    </paper-spinner-lite>
    <div id="selector-hierarchy"></div>
    <style>
      .indented-level-container .content-container {
        margin: 0 0 0 20px;
      }

      .level-container iron-collapse {
        padding: 0 0 0 20px;
      }

      paper-checkbox {
        display: inline-block;
        width: 18px;
        height: 18px;
        margin: 0 8px 0 0;
      }

      .op-type {
        padding-right: 10px;
        color: #444;
      }

      .op-title-leaf {
        text-decoration: underline;
        cursor: pointer;
      }

      .op-title-leaf:hover {
        color: blue;
      }

      .partial-checkbox {
        background: #f57c00;
      }

      .node-expand-button {
        margin: 0 0 0 -13px;
      }

      .level-title-text {
        display: inline-block;
        font-weight: 800;
        margin: 0 0 0 -1px;
      }

      .op-description {
        font-weight: 300;
        margin: 0 0 0 27px;
        padding: 10px 0;
      }

      .spinner {
        width: 20px;
        height: 20px;
        vertical-align: middle;
      }

      #filter-mode {
        width: 150px;
        display: inline-block;
      }

      #filter-input {
        width: 250px;
        display: inline-block;
      }

      .highlighted {
        color: red;
      }
      .highlighted > .op-type {
        color: red;
      }

      #selector-hierarchy {
        width: 100%;
      }

      [hidden] {
        display: none;
      }
    </style>
  </template>
  
  
</dom-module>





<dom-module id="tf-session-runs-view">
  <template>
    <div class="session-runs-div">
      <div class="section-title">Session Runs</div>
      <table id="session-runs-table" align="left" class="session-runs-table">
        <tr align="left">
          <th>Feeds</th>
          <th>Fetches</th>
          <th>Targets</th>
          <th>#(Devices)</th>
          <th>Count</th>
        </tr>
      </table>
    </div>
    <style>
      :host {
        display: block;
        padding: 20px 0;
      }

      .section-title {
        font-size: 110%;
        font-weight: bold;
      }
      :host .indented-level-container .content-container {
        margin: 0 0 0 10px;
      }

      /* TODO(cais): This needs work: the table shouldn't get too wide when
         there are many feeds/fetches/targte names. */
      .session-runs-table {
        align-content: left;
        align-items: left;
        text-align: left;
        font-size: 90%;
        border-style: solid 1px black;
        table-layout: fixed;
        width: 100%;
        word-break: break-all;
        padding-top: 3px;
        padding-left: 3px;
        padding-right: 3px;
        box-shadow: 3px 3px #ddd;
      }
      .active-session-run {
        background-color: #ffffe0;
        font-weight: bold;
      }
      .sole-active-session-run {
        background-color: rgb(172, 232, 188);
        font-weight: bold;
      }

      .node-or-tensor-element {
        text-decoration: underline;
        cursor: pointer;
      }

      .node-or-tensor-element:hover {
        color: blue;
      }
    </style>
  </template>
  
</dom-module>





<dom-module id="tf-source-code-view">
  <template>
    <div id="fullStackDialog" hidden$="[[!_fullStackShown]]">
      <div id="full-stack-title">
        <paper-icon-button icon="filter-list" disabled="true">
        </paper-icon-button>
        Full Stack Trace of Node:
        <div id="full-stack-node-name">"[[_fullStackNodeName]]"</div>
        <paper-icon-button icon="close" id="close-full-stack-button" title="Close Full Stack" on-tap="_closeFullStackDialog">
        </paper-icon-button>
      </div>
      <ul id="full-stack-content"></ul>
    </div>
    <paper-tabs id="source-files-tabs" selected="{{_filePathSelected}}">
      <template is="dom-repeat" items="[[_shortFilePaths]]">
        <paper-tab id="[[item.id]]">[[item.name]]</paper-tab>
      </template>
    </paper-tabs>
    <div id="source-file-content" class="source-content">
      <template is="dom-repeat" items="[[_fileLines]]">
        <div class$="{{item.sourceClass}}" id="source-line-[[item.lineno]]">
          <span class="source-line-number" id="source-lineno-[[item.lineno]]">
            [[item.lineno]]
          </span>
          <span class="source-line-node-toggle" id="source-line-node-toggle-[[item.lineno]]">
            [[item.numNodes]]
          </span>
          <span class="source-line-text" id="source-line-text-[[item.lineno]]">
            [[item.text]]
          </span>
          <div class="source-line-nodes" id="source-line-nodes-[[item.lineno]]"></div>
        </div>
      </template>
    </div>
    <style>
      #source-files-tabs {
        position: relative;
        height: 8%;
      }
      .source-content {
        position: relative;
        height: 90%;
        font-family: monospace;
        font-size: 90%;
        overflow-x: scroll;
        overflow-y: scroll;
      }
      .source-content :hover {
        background-color: #ffff00;
      }
      .highlighted-source-line {
        background-color: #ffffe0;
      }
      .source-line-number {
        display: inline-block;
        color: lightblue;
        width: 2em;
        text-align: right;
        padding-right: 1em;
      }
      .source-line-node-toggle {
        display: inline-block;
        color: blue;
        width: 5em;
        text-align: right;
        padding-right: 1em;
        text-decoration: underline;
        cursor: pointer;
      }
      .source-line-nodes {
        padding-left: 4em;
        text-decoration: underline;
        cursor: pointer;
        color: blue;
        margin-top: 0em;
        margin-bottom: 0em;
        margin-right: 1em;
      }
      .source-line-node-entry {
        margin-right: 1em;
        background-color: yellow;
      }
      .source-line-nodes span {
        text-decoration: none;
        background-color: yellow;
      }
      .source-line-text {
        display: inline;
        word-wrap: break-word;
      }
      #fullStackDialog {
        z-index: 1000;
        position: absolute;
        top: 10%;
        left: 50%;
        width: 45%;
        height: 85%;
        background-color: white;
        border: 1px solid gray;
        font-family: monospace;
        box-shadow: 3px 3px #ddd;
        overflow-y: auto;
      }
      #full-stack-title {
        font-size: 110%;
        position: relative;
        width: 100%;
        background-color: #eee;
        text-align: center;
        font-weight: bold;
      }
      #full-stack-node-name {
        color: blue;
      }
      :host #full-stack-content {
        padding-top: 1em;
        padding-right: 0.5em;
        margin-top: 0.5em;
        font-size: 90%;
        word-wrap: break-word;
        overflow: auto;
      }
      .stack-frame-clickable {
        color: blue;
        text-decoration: underline;
        cursor: pointer;
      }
      .stack-frame-nonclickable {
        color: #555;
      }
      #close-full-stack-button {
        float: right;
      }
    </style>
  </template>
  
</dom-module>





<dom-module id="tf-tensor-data-summary">
  <template>
    <span class="section-title">Tensor Value Overview</span>
    <div id="tensor-data-div" class="tensor-data-div">
      <table id="tensor-data-table" align="left" class="tensor-data-table">
        <thead>
          <tr align="left">
            <th>Tensor</th>
            <th>Count</th>
            <th>DType</th>
            <th>Shape</th>
            <th width="25%">Value</th>
            <th width="25%">
              Health Pill
              <paper-toggle-button id="show-health-pills" checked="{{_healthPillsEnabled}}">
              </paper-toggle-button>
              <paper-card>
                <div class="health-pill-legend" id="health-pill-legend"></div>
              </paper-card>
            </th>
            <th width="5%"></th>
          </tr>
        </thead>
        <tbody></tbody>
      </table>
    </div>
    <style>
      :host #tensor-data-div {
        height: 100%;
        overflow-y: auto;
      }
      .section-title {
        font-size: 110%;
        font-weight: bold;
      }
      :host .indented-level-container .content-container {
        margin: 0 0 0 10px;
      }
      :host .tensor-data-table {
        align-content: left;
        align-items: left;
        display: block;
        text-align: left;
        vertical-align: middle;
        width: 100%;
        padding-top: 3px;
        padding-left: 3px;
        padding-right: 3px;
        box-shadow: 3px 3px #ddd;
      }
      :host #tensor-data-table th {
        vertical-align: top;
      }
      :host .active-tensor {
        background-color: #ffffe0;
        font-weight: bold;
        border: solid 1px #888;
      }
      :host .highlighted {
        color: red;
      }
      :host .health-pill-legend {
        float: right;
        font-weight: normal;
      }
      :host #show-health-pills {
        display: inline-block;
      }
      .value-expansion-link {
        text-decoration: underline;
        cursor: pointer;
      }
      .value-expansion-link :hover {
        color: blue;
      }
      .health-pill :hover {
        cursor: pointer;
      }
      .tensor-name {
        text-decoration: underline;
        cursor: pointer;
      }
      .tensor-name :hover {
        color: blue;
      }
    </style>
  </template>
  
</dom-module>



<style>/* 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.
==============================================================================*/

.tensor-widget {
  font-family: monospace;
  font-size: 14px;
  overflow-x: hidden;
  overflow-y: hidden;
  position: relative;
}

.tensor-widget-dim {
  border: 1px solid rgb(160, 160, 160);
  display: inline-block;
  font-size: 12px;
  height: 14px;
  line-height: 14px;
  margin-left: 15px;
  margin-right: 15px;
  padding: 2px;
}

.tensor-widget-dim-comma {
  color: rgb(128, 128, 128);
  display: inline-block;
  font-size: 12px;
  height: 14px;
  line-height: 14px;
}

.tensor-widget-dim-highlighted {
  border: 1px solid rgb(100, 180, 255);
  font-weight: bold;
}

.tensor-widget-dim-brackets {
  color: rgb(128, 128, 128);
  display: inline-block;
  font-size: 8pt;
}

.tensor-widget-dim-dropdown {
  background-color: rgb(255, 255, 255);
  border: 1px solid rgb(128, 128, 128);
  box-shadow: 2px 2px 2px #b0b0b0;
  cursor: pointer;
  width: 180px;
  z-index: 1000;
}

.tensor-widget-dim-dropdown-menu-item {
  border-bottom: 1px solid rgb(180, 180, 180);
  font-size: 12px;
  padding: 3px;
  user-select: none;
}

.tensor-widget-dim-dropdown-menu-item-active {
  background-color: rgb(100, 180, 255);
}

.tensor-widget-dim-dropdown-menu-item-disabled {
  color: rgb(128, 128, 128);
}

.tensor-widget-dtype {
  align-content: center;
  color: rgb(60, 60, 60);
  display: inline-block;
  font-size: 8pt;
  height: 48px;
  line-height: 22px;
  max-height: 22px;
  padding-left: 14px;
  padding-right: 10px;
  position: relative;
  vertical-align: middle;
}

.tensor-widget-dtype-label {
  color: rgb(128, 128, 128);
}

.tensor-widget-header {
  background-color: rgb(252, 252, 252);
  box-shadow: 2px 2px 2px #b0b0b0;
  height: 40px;
  line-height: 40px;
  max-height: 40px;
  position: relative;
  vertical-align: middle;
  width: 100%;
}

.tensor-widget-info {
  align-content: center;
  color: rgb(0, 0, 255);
  display: inline-block;
  font-size: 8pt;
  height: 22px;
  line-height: 22px;
  margin-left: 8px;
  max-height: 22px;
  position: relative;
  vertical-align: middle;
}

.tensor-widget-menu-thumb {
  color: rgb(32, 33, 36);
  cursor: pointer;
  display: inline-block;
  font-weight: bold;
  font-size: 16px;
  margin-left: 10px;
  margin-right: 5px;
  position: relative;
  user-select: none;
}

.tensor-widget-menu-thumb:hover {
  color: rgb(227, 116, 0);
}

.tensor-widget-shape {
  color: rgb(60, 60, 60);
  display: inline-block;
  margin-left: 12px;
}

.tensor-widget-shape-label {
  color: rgb(128, 128, 128);
  display: inline-block;
}

.tensor-widget-shape-value {
  display: inline-block;
}

.tensor-widget-slicing-group {
  background-color: rgb(250, 250, 250);
  border-bottom: 1px solid rgb(190, 190, 190);
  display: block;
  height: 18px;
  text-align: center;
  padding-bottom: 5px;
  padding-top: 5px;
}

.tensor-widget-tensor-name {
  color: black;
  display: inline-block;
  font-weight: bold;
}

.tensor-widget-left-ruler-tick {
  background-color: var(--ruler-background-color);
  border-bottom: var(--border-style);
  border-top: var(--border-style);
  box-shadow: var(--border-style);
  color: rgb(110, 110, 110);
  cursor: pointer;
  display: inline-block;
  font-size: 12px;
  height: 29px;
  line-height: 29px;
  margin-left: 0px;
  max-width: 45px;
  text-align: center;
  user-select: none;
  vertical-align: middle;
  width: 45px;
}

.tensor-widget-top-ruler {
  height: 24px;
  white-space: nowrap;
}

.tensor-widget-value-tooltip {
  background-color: rgb(240, 240, 240);
  border: 1px solid rgb(160, 160, 160);
  box-shadow: 1px 1px 1px #b0b0b0;
  display: none;
  font-size: 13px;
  padding: 5px;
  position: absolute;
  user-select: none;
  width: 240px;
}

.tensor-widget-value-tooltip-colorbar {
  height: 24px;
  width: 95%;
}

.tensor-widget-value-tooltip-indices {
  font-weight: bold;
}

.tensor-widget-value-tooltip-value {
  margin-top: 20px;
}

.tensor-widget-top-ruler-tick {
  background-color: var(--ruler-background-color);
  border-bottom: var(--border-style);
  border-right: var(--border-style);
  color: rgb(110, 110, 110);
  cursor: pointer;
  display: inline-block;
  font-size: 12px;
  height: 24px;
  line-height: 24px;
  padding-right: 2px;
  text-align: center;
  user-select: none;
  vertical-align: middle;
  width: 45px;
}

.tensor-widget-value-div {
  border-bottom: var(--border-style);
  border-right: var(--border-style);
  cursor: pointer;
  display: inline-block;
  font-size: 80%;
  height: 24px;
  line-height: 24px;
  max-width: 45px;
  padding-right: 2px;
  text-align: right;
  user-select: none;
  vertical-align: middle;
  width: 45px;
}

.tensor-widget-value-div-selection {
  font-weight: bold;
}

.tensor-widget-value-div-selection-bottom {
  border-bottom: 0.5px solid blue;
}

.tensor-widget-value-div-selection-left {
  border-left: 0.5px solid blue;
}

.tensor-widget-value-div-selection-right {
  border-right: 0.5px solid blue;
}

.tensor-widget-value-div-selection-top {
  border-top: 0.5px solid blue;
}

.tensor-widget-value-section {
  --border-style: 1px solid rgb(140, 140, 140);
  --ruler-background-color: rgb(210, 210, 210);
  -moz-user-select: none;
  -ms-user-select: none;
  -khtml-user-select: none;
  -webkit-touch-callout: none;
  -webkit-user-select: none;
}

.tensor-widget-value-row {
  height: 25px;
  line-height: 25px;
  white-space: nowrap;
}
</style>

<dom-module id="tensor-widget-style">
  <template>
    <style>/* 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.
==============================================================================*/

.tensor-widget {
  font-family: monospace;
  font-size: 14px;
  overflow-x: hidden;
  overflow-y: hidden;
  position: relative;
}

.tensor-widget-dim {
  border: 1px solid rgb(160, 160, 160);
  display: inline-block;
  font-size: 12px;
  height: 14px;
  line-height: 14px;
  margin-left: 15px;
  margin-right: 15px;
  padding: 2px;
}

.tensor-widget-dim-comma {
  color: rgb(128, 128, 128);
  display: inline-block;
  font-size: 12px;
  height: 14px;
  line-height: 14px;
}

.tensor-widget-dim-highlighted {
  border: 1px solid rgb(100, 180, 255);
  font-weight: bold;
}

.tensor-widget-dim-brackets {
  color: rgb(128, 128, 128);
  display: inline-block;
  font-size: 8pt;
}

.tensor-widget-dim-dropdown {
  background-color: rgb(255, 255, 255);
  border: 1px solid rgb(128, 128, 128);
  box-shadow: 2px 2px 2px #b0b0b0;
  cursor: pointer;
  width: 180px;
  z-index: 1000;
}

.tensor-widget-dim-dropdown-menu-item {
  border-bottom: 1px solid rgb(180, 180, 180);
  font-size: 12px;
  padding: 3px;
  user-select: none;
}

.tensor-widget-dim-dropdown-menu-item-active {
  background-color: rgb(100, 180, 255);
}

.tensor-widget-dim-dropdown-menu-item-disabled {
  color: rgb(128, 128, 128);
}

.tensor-widget-dtype {
  align-content: center;
  color: rgb(60, 60, 60);
  display: inline-block;
  font-size: 8pt;
  height: 48px;
  line-height: 22px;
  max-height: 22px;
  padding-left: 14px;
  padding-right: 10px;
  position: relative;
  vertical-align: middle;
}

.tensor-widget-dtype-label {
  color: rgb(128, 128, 128);
}

.tensor-widget-header {
  background-color: rgb(252, 252, 252);
  box-shadow: 2px 2px 2px #b0b0b0;
  height: 40px;
  line-height: 40px;
  max-height: 40px;
  position: relative;
  vertical-align: middle;
  width: 100%;
}

.tensor-widget-info {
  align-content: center;
  color: rgb(0, 0, 255);
  display: inline-block;
  font-size: 8pt;
  height: 22px;
  line-height: 22px;
  margin-left: 8px;
  max-height: 22px;
  position: relative;
  vertical-align: middle;
}

.tensor-widget-menu-thumb {
  color: rgb(32, 33, 36);
  cursor: pointer;
  display: inline-block;
  font-weight: bold;
  font-size: 16px;
  margin-left: 10px;
  margin-right: 5px;
  position: relative;
  user-select: none;
}

.tensor-widget-menu-thumb:hover {
  color: rgb(227, 116, 0);
}

.tensor-widget-shape {
  color: rgb(60, 60, 60);
  display: inline-block;
  margin-left: 12px;
}

.tensor-widget-shape-label {
  color: rgb(128, 128, 128);
  display: inline-block;
}

.tensor-widget-shape-value {
  display: inline-block;
}

.tensor-widget-slicing-group {
  background-color: rgb(250, 250, 250);
  border-bottom: 1px solid rgb(190, 190, 190);
  display: block;
  height: 18px;
  text-align: center;
  padding-bottom: 5px;
  padding-top: 5px;
}

.tensor-widget-tensor-name {
  color: black;
  display: inline-block;
  font-weight: bold;
}

.tensor-widget-left-ruler-tick {
  background-color: var(--ruler-background-color);
  border-bottom: var(--border-style);
  border-top: var(--border-style);
  box-shadow: var(--border-style);
  color: rgb(110, 110, 110);
  cursor: pointer;
  display: inline-block;
  font-size: 12px;
  height: 29px;
  line-height: 29px;
  margin-left: 0px;
  max-width: 45px;
  text-align: center;
  user-select: none;
  vertical-align: middle;
  width: 45px;
}

.tensor-widget-top-ruler {
  height: 24px;
  white-space: nowrap;
}

.tensor-widget-value-tooltip {
  background-color: rgb(240, 240, 240);
  border: 1px solid rgb(160, 160, 160);
  box-shadow: 1px 1px 1px #b0b0b0;
  display: none;
  font-size: 13px;
  padding: 5px;
  position: absolute;
  user-select: none;
  width: 240px;
}

.tensor-widget-value-tooltip-colorbar {
  height: 24px;
  width: 95%;
}

.tensor-widget-value-tooltip-indices {
  font-weight: bold;
}

.tensor-widget-value-tooltip-value {
  margin-top: 20px;
}

.tensor-widget-top-ruler-tick {
  background-color: var(--ruler-background-color);
  border-bottom: var(--border-style);
  border-right: var(--border-style);
  color: rgb(110, 110, 110);
  cursor: pointer;
  display: inline-block;
  font-size: 12px;
  height: 24px;
  line-height: 24px;
  padding-right: 2px;
  text-align: center;
  user-select: none;
  vertical-align: middle;
  width: 45px;
}

.tensor-widget-value-div {
  border-bottom: var(--border-style);
  border-right: var(--border-style);
  cursor: pointer;
  display: inline-block;
  font-size: 80%;
  height: 24px;
  line-height: 24px;
  max-width: 45px;
  padding-right: 2px;
  text-align: right;
  user-select: none;
  vertical-align: middle;
  width: 45px;
}

.tensor-widget-value-div-selection {
  font-weight: bold;
}

.tensor-widget-value-div-selection-bottom {
  border-bottom: 0.5px solid blue;
}

.tensor-widget-value-div-selection-left {
  border-left: 0.5px solid blue;
}

.tensor-widget-value-div-selection-right {
  border-right: 0.5px solid blue;
}

.tensor-widget-value-div-selection-top {
  border-top: 0.5px solid blue;
}

.tensor-widget-value-section {
  --border-style: 1px solid rgb(140, 140, 140);
  --ruler-background-color: rgb(210, 210, 210);
  -moz-user-select: none;
  -ms-user-select: none;
  -khtml-user-select: none;
  -webkit-touch-callout: none;
  -webkit-user-select: none;
}

.tensor-widget-value-row {
  height: 25px;
  line-height: 25px;
  white-space: nowrap;
}
</style>
  </template>
</dom-module>








<dom-module id="tf-debugger-line-chart">
  <template>
    <vz-line-chart2 x-components-creation-method="[[_lineChartXComponentsCreationMethod]]" y-value-accessor="[[_lineChartYValueAccessor]]" tooltip-columns="[[_lineChartTooltipColumns]]" smoothing-enabled="[[_lineChartSmoothingEnabled]]"></vz-line-chart2>
    <style>
      vz-line-chart2 {
        height: 300px;
        position: relative;
      }
    </style>
  </template>

  
</dom-module>



<dom-module id="tf-tensor-value-view">
  <template>
    <paper-toast id="tensorValueToast" text="" always-on-top></paper-toast>
    <table class="tensor-value-view-table">
      <tr>
        <td colspan="2">
          <div>
            <paper-item id="tensor-name" on-tap="tensorNameCallback">
              <span class="tensor-name-text">[[tensorName]]</span>
            </paper-item>
            <paper-icon-button icon="close" class="value-view-icon-button" id="value-view-icon-button" title="Close" on-tap="closeButtonCallback"></paper-icon-button>
            <paper-icon-button icon="forward" class="value-view-icon-button" id="value-view-icon-button" title="Continue to" on-tap="continueToButtonCallback"></paper-icon-button>
          </div>
        </td>
      </tr>
      <tr class="tensor-value-value-tr">
        <td>
          <template is="dom-if" if="[[_useTensorWidget]]">
            <div id="tensor-widget"></div>
          </template>

          <template is="dom-if" if="[[!_useTensorWidget]]">
            <paper-item id="debug-op"></paper-item>
            <div>
              <paper-input class="inline value-card-input" label="Slicing" id="slicing" value="{{slicing}}" on-change="refresh">
              </paper-input>
              <div>
                <paper-input class="inline value-card-input" label="Time Indices" id="time-indices" value="{{timeIndices}}" on-change="refresh">
                </paper-input>
                <paper-button raised id="time-indices-toggle-button" class="tensor-value-buttons" on-click="_timeIndicesToggleButtonCallback">Full History</paper-button>
              </div>

              </div></template></td><td class="tensor-value-view-td">
                <template is="dom-if" if="[[_isValueScalar]]">
                  <paper-input class="inline" label="Scalar Value" id="value-scalar" value="[[_dataScalar]]">
                  </paper-input>
                </template>
                <template is="dom-if" if="[[_isValueLineChart]]">
                  <tf-debugger-line-chart data="[[_lineChartData]]"></tf-debugger-line-chart>
                </template>
                <template is="dom-if" if="[[_isValueImage]]">
                  <img class="value-image" height="250px" width="250px" src$="[[_dataImageSrc]]">
                </template>
              </td>
            
          
        
      </tr>
    </table>

    <style include="tensor-widget-style"></style>
    <style>
      .tensor-value-buttons {
        height: 75%;
        font-size: 10px;
      }
      .tensor-value-view-table {
        width: 500px;
        display: inline-table;
        border-spacing: 5px;
        padding-top: 3px;
        padding-bottom: 3px;
        padding-left: 3px;
        padding-right: 3px;
        background-color: #f8f8f8;
        box-shadow: 3px 3px 1px 1px #d8d8d8;
      }
      .tensor-value-view-td {
        width: 350px;
      }
      .value-card-input {
        width: 150px;
      }
      #tensor-name {
        display: inline-block;
        position: relative;
        width: 50%;
        cursor: pointer;
      }
      .tensor-name-text {
        color: blue;
        text-decoration: underline;
      }
      #debug-op {
        font-size: 90%;
      }
      .value-image {
        image-rendering: pixelated;
      }
      .value-view-icon-button {
        display: inline-block;
        float: right;
        text-align: right;
        width: 20%;
        text-decoration: underline;
        cursor: pointer;
        font-size: 90%;
        color: blue;
      }
      #tensor-widget {
        border: 1px solid rgb(160, 160, 160);
        /* box-sizing: content-box;
        -moz-box-sizing: content-box;
        -webkit-box-sizing: content-box; */
        height: 280px;
        width: 484px;
      }
      #slicing,
      #time-indices {
        --paper-input-container-input: {
          font-family: monospace;
        }
      }
    </style>
  </template>
  
</dom-module>


<dom-module id="tf-tensor-value-multi-view">
  <template>
    <div id="multiView">
      <div class="section-title">Tensor Values</div>
      <div id="multi-tensor-view-container"></div>
    </div>
    <style>
      .section-title {
        font-size: 110%;
        font-weight: bold;
      }
      #multiView {
        background-color: #fff;
        padding-top: 3px;
        padding-left: 3px;
        padding-right: 3px;
        box-shadow: 3px 3px #eee;
      }
    </style>
  </template>
  
</dom-module>


<dom-module id="tf-debugger-dashboard">
  <template>
    <paper-toast id="toast" text="" always-on-top></paper-toast>
    <tf-debugger-initial-dialog id="initialDialog"></tf-debugger-initial-dialog>
    
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar" id="left-pane">
        <div id="node-entries" class="node-entries">
          <div class="debugger-section-title">Runtime Node List</div>
          <div class="toggle-source-code">
            Show Code:
            <paper-toggle-button class="toggle-source-code" id="show-source-code" checked="{{_sourceCodeShown}}"></paper-toggle-button>
          </div>
          <tf-op-selector debug-watches="[[_debugWatches]]" debug-watch-change="[[_createDebugWatchChangeHandler()]]" node-clicked="[[_createNodeClickedHandler()]]" force-expand-and-check-node-name="[[_forceExpandAndCheckNodeName]]" force-expand-node-name="[[_forceExpandNodeName]]">
          </tf-op-selector>
        </div>
        <div id="source-code-view-div" class="source-code-view-div" hidden$="{{!_sourceCodeShown}}">
          <div class="debugger-section-title">Source Code</div>
          <tf-source-code-view id="sourceCodeView" request-manager="[[_requestManager]]" debug-watches="[[_debugWatches]]" focus-node-name="[[_sourceFocusNodeName]]" node-clicked="[[_createNodeClickedHandler()]]" continue-to-node="[[_createContinueToNodeHandler()]]"></tf-source-code-view>
        </div>
        <tf-debugger-resizer current-length="{{_leftPaneWidth}}" min-length="[[_minleftPaneWidth]]" max-length="[[_maxleftPaneWidth]]">
        </tf-debugger-resizer>
        <div>
          <tf-session-runs-view id="sessionRunsView" latest-session-run="[[_latestSessionRun]]" session-run-key-to-device-names="[[_sessionRunKey2DeviceNames]]" sole-active="[[_sessionRunSoleActive]]" node-or-tensor-clicked="[[_createFeedFetchTargetClickedHandler()]]">
          </tf-session-runs-view>
        </div>
        <div class="buttons-container">
          <paper-button raised class="continue-button" on-click="_step">
            <span>[[_stepButtonText]]</span>
          </paper-button>
          <tf-debugger-continue-dialog id="continueDialog" session-run-go="[[_createSessionRunGo()]]" tensor-condition-go="[[_createTensorConditionGo()]]" force-continuation-stop="[[_createForceContinuationStop()]]">
          </tf-debugger-continue-dialog>
        </div>
        <div class="container">
          <tf-graph-loader id="loader" out-graph-hierarchy="{{graphHierarchy}}" out-graph="{{graph}}" out-stats="{{stats}}" progress="{{_graphProgress}}"></tf-graph-loader>
        </div>
      </div>
      <div class="center" slot="center" id="center-content">
        <div id="top-right-quadrant">
          <paper-tabs selected="{{_topRightSelected}}">
            <template is="dom-repeat" items="[[_topRightTabs]]">
              <paper-tab id="[[item.id]]">[[item.name]]</paper-tab>
            </template>
          </paper-tabs>
          <div class="runtime-graph-device">
            <span id="runtime-graph-device-name"> </span>
            <paper-dropdown-menu id="active-runtime-graph-device-name" no-label-float="true" label="Device name" selected-item-label="{{_activeRuntimeGraphDeviceName}}">
              <paper-listbox class="dropdown-content" slot="dropdown-content">
                <template is="dom-repeat" items="[[_activeSessionRunDevices]]">
                  <paper-item no-label-float="true">[[item]]</paper-item>
                </template>
              </paper-listbox>
            </paper-dropdown-menu>
            <paper-spinner-lite class="spinner" id="top-right-spinner" hidden="[[!_busy]]" active="[[_busy]]">
            </paper-spinner-lite>
          </div>
          <paper-progress id="top-right-progress-bar" value="0"></paper-progress>
          <template is="dom-if" if="[[_isTopRightRuntimeGraphsActive]]">
            <div id="graph-container">
              <tf-graph id="graph" graph-hierarchy="[[graphHierarchy]]" basic-graph="[[graph]]" stats="[[stats]]" progress="{{_graphProgress}}" color-by="structure" color-by-params="{{colorByParams}}" render-hierarchy="{{_renderHierarchy}}" node-context-menu-items="[[_createNodeContextMenuItems()]]"></tf-graph>
              <div class="context-menu"></div>
            </div>
          </template>
          <template is="dom-if" if="[[_isTopRightTensorValuesActive]]">
            <tf-tensor-value-multi-view id="tensorValueMultiView" continue-to-callback="[[_createContinueToCallback()]]" tensor-name-clicked="[[_createNodeClickedHandler()]]" get-health-pill="[[_createGetHealthPill()]]">
            </tf-tensor-value-multi-view>
          </template>
        </div>

        <tf-debugger-resizer is-horizontal="true" current-length="{{_topRightQuadrantHeight}}" min-length="[[_minTopRightQuadrantHeight]]" max-length="[[_maxTopRightQuadrantHeight]]">
        </tf-debugger-resizer>

        <div id="tensor-data" class="tensor-data">
          <tf-tensor-data-summary id="tensorDataSummary" latest-tensor-data="[[_latestTensorData]]" expand-handler="[[_createTensorDataExpandHandler()]]" continue-to-callback="[[_createContinueToCallback()]]" highlighted-node-name="[[_highlightNodeName]]" tensor-name-clicked="[[_createNodeClickedHandler()]]" get-health-pill="[[_createGetHealthPill()]]">
          </tf-tensor-data-summary>
        </div>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      :host {
        display: block;
        position: absolute;
        left: 0;
        right: 0;
        top: 0;
        bottom: 0;
        overflow: hidden;
      }
      paper-toast {
        text-align: center;
        font-size: 110%;
        width: 40vw;
        margin-left: 30vw;
      }
      tf-dashboard-layout {
        --tf-dashboard-layout-sidebar-basis: auto;
        --tf-dashboard-layout-sidebar-max-width: none;
        --tf-dashboard-layout-sidebar-min-width: none;
      }
      .debugger-section-title {
        font-size: 110%;
        font-weight: bold;
      }
      paper-tabs {
        color: #555;
        font-weight: normal;
      }
      paper-tab.iron-selected {
        color: black;
        font-weight: bold;
      }
      #initialDialog {
        /** This matches the default z-index of paper-dialog backdrops. */
        z-index: 102;
      }
      /** Resize the region for the graph as the user resizes the region. */
      #graph-container {
        height: calc(100% - 120px);
        /** Clip the minimap if the height of the graph container is small. */
        overflow: hidden;
        position: relative;
      }
      #graph {
        position: relative;
        display: block;
        width: 100%;
        height: 100%;
      }
      #tooltip-sorting {
        display: flex;
        font-size: 14px;
        margin-top: 5px;
      }
      #tooltip-sorting-label {
        margin-top: 13px;
      }
      #tooltip-sorting paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }
      #x-type-selector paper-button {
        margin: 5px 3px;
      }
      .runtime-graph-device {
        align-items: center;
        display: flex;
        flex-wrap: wrap;
      }
      #runtime-graph-device-name {
        font-size: 85%;
        word-break: break-all;
        display: inline-block;
      }
      #active-runtime-graph-device-name {
        font-size: 85%;
        width: 350px;
        display: inline-block;
      }
      #top-right-progress-bar {
        width: 100%;
        display: inline-block;
        vertical-align: middle;
      }
      .line-item {
        display: block;
        padding-top: 5px;
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      .sidebar {
        height: 100%;
        overflow-x: visible;
        position: relative;
      }
      .center {
        position: relative;
        height: 100%;
      }
      tf-debugger-resizer {
        right: -10px;
      }
      #center-content {
        position: absolute;
        right: 0;
      }
      /** The resizer should have no space to the left of it. */
      #center-content tf-debugger-resizer[is-horizontal] {
        margin-left: -23px;
      }
      .context-menu {
        position: absolute;
        display: none;
        background-color: #e2e2e2;
        border-radius: 2px;
        font-size: 14px;
        min-width: 150px;
        border: 1px solid #d4d4d4;
      }
      .spinner {
        width: 20px;
        height: 20px;
        vertical-align: middle;
      }
      .node-entries {
        box-shadow: 3px 3px #ddd;
        box-sizing: border-box;
        height: 80%;
        overflow: auto;
        padding-left: 3px;
        padding-right: 3px;
        padding-top: 3px;
        position: relative;
        vertical-align: top;
        width: 100%;
      }
      .source-code-view-div {
        position: relative;
        height: 40%;
        width: 100%;
        vertical-align: top;
        overflow: hidden;
        padding-top: 3px;
        padding-left: 3px;
        padding-right: 3px;
        box-shadow: 3px 3px #ddd;
      }
      #sessionRunsView {
        position: relative;
        width: 100%;
        overflow: auto;
        max-height: 25vh;
      }
      .buttons-container {
        padding: 20px 0;
      }
      #tensor-data {
        position: absolute;
        bottom: 0;
        left: 0;
        right: 0;
        padding: 20px 0;
        margin: 0 0 20px 0;
      }
      #tensorDataSummary {
        position: absolute;
        bottom: 0;
        left: 0;
        right: 0;
        top: 0;
      }
      #top-right-quadrant {
        height: 66%;
        overflow: auto;
      }
      .toggle-source-code {
        margin-right: 1em;
        font-size: 80%;
        float: right;
      }
      .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;
      }

      paper-input {
        width: 200px;
      }
      .inline,
      paper-item {
        display: inline;
      }

      vz-line-chart {
        height: 300px;
        position: relative;
      }
      [hidden] {
        display: none;
      }
    </style>
  </template>
  
  
</dom-module>











<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>




<dom-module id="paper-material">
  <template>
    <style include="paper-material-shared-styles"></style>
    <style>
      :host([animated]) {
        @apply --shadow-transition;
      }
      :host {
        @apply --paper-material;
      }
    </style>

    <slot></slot>
  </template>
</dom-module>













<dom-module id="tf-graph-debugger-data-card">
  <template>
    <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.
        
        <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.
        
      
    
  
  













<dom-module id="iron-list">
  <template>
    <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>

    </template></dom-module><div id="items">
      <slot></slot>
    </div>

  </template>
</paper-material></template></dom-module>













<dom-module id="paper-item-body">
  <template>
    <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>
  </template>

  
</dom-module>








<dom-module id="tf-graph-icon">
  <template>
    <style>
      :host {
        font-size: 0;
      }

      .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 height="0" width="0" id="svgDefs">
      <defs>
        
        <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" />
        </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" />
        </pattern>
        
        <ellipse id="op-node-stamp" rx="7.5" ry="3" stroke="inherit" fill="inherit" />
        
        <ellipse id="op-node-annotation-stamp" rx="5" ry="2" stroke="inherit" fill="inherit" />
        
        <g id="op-series-vertical-stamp">
          <use xlink:href="#op-node-stamp" x="8" y="9" />
          <use xlink:href="#op-node-stamp" x="8" y="6" />
          <use xlink:href="#op-node-stamp" x="8" y="3" />
        </g>
        <g id="op-series-horizontal-stamp">
          <use xlink:href="#op-node-stamp" x="16" y="4" />
          <use xlink:href="#op-node-stamp" x="12" y="4" />
          <use xlink:href="#op-node-stamp" x="8" y="4" />
        </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" />
        </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]]" />
      </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" />
      </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" />
      </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" />
      </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" />
        </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" />
        </svg>
      </template>
    </template>
  </template>

  
</dom-module>


<dom-module id="tf-node-icon">
  <template>
    <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>
  </template>

  
</dom-module>


<dom-module id="tf-graph-op-compat-list-item">
  <template>
    <style>
      #list-item {
        width: 100%;
        color: #565656;
        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>
  </template>

  
</dom-module>


<dom-module id="tf-graph-op-compat-card">
  <template>
    <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: #e9e9e9;
      }

      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 {
        font-size: 12pt;
        color: #5e5e5e;
      }

      .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;
      }

      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');" />
              </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>
  </template>

  
</dom-module>














<dom-module id="tf-node-list-item">
  <template>
    <style>
      #list-item {
        width: 100%;
        color: #565656;
        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>
        <span class="edge-label">[[edgeLabel]]</span>
      </div>
    </div>
  </template>

  
</dom-module>


<dom-module id="tf-node-info">
  <template>
    <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: #565656;
        font-size: 11pt;
        font-weight: 400;
      }

      .attr-right {
        margin-left: 30%;
        word-wrap: break-word;
        color: #565656;
        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: #565656;
        display: table-cell;
        font-size: 11pt;
        font-weight: 400;
        max-width: 200px;
        padding: 0 4px;
      }

      paper-item {
        padding: 0;
        background: #e9e9e9;
      }

      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 {
        font-size: 12pt;
        color: #5e5e5e;
      }

      .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" id="nodetitle"></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>
  </template>

  
</dom-module>


<dom-module id="tf-graph-info">
  <template>
    <style>
      :host {
        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]]" hierarchy-params="[[hierarchyParams]]" 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>
  </template>
  
</dom-module>




<dom-module id="tf-graph-board">
  <template>
    <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]]"></tf-graph>
      </div>
      <div id="info">
        <tf-graph-info id="graph-info" title="selected" graph-hierarchy="[[graphHierarchy]]" hierarchy-params="[[hierarchyParams]]" 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>
  </template>
</dom-module>























<dom-module id="paper-radio-button">
  <template strip-whitespace>
    <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>
  </template>

  
</dom-module>




<dom-module id="paper-radio-group">
  <template>
    <style>
      :host {
        display: inline-block;
      }

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

    <slot></slot>
  </template>
</dom-module>









<dom-module id="paper-tooltip">
  <template>
    <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>
  </template>

  
</dom-module>










<dom-module id="tf-graph-node-search">
  <template>
    <div id="search-container">
      <paper-input id="runs-regex" label="Search nodes. Regexes supported." 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>
  </template>
  
</dom-module>


<dom-module id="tf-graph-controls">
  <template>
    <style>
      :host {
        color: gray;
        display: flex;
        flex-direction: column;
        font-size: 12px;
        width: 100%;
      }

      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: 8px 0 8px 10px;
        }
      }

      .color-dropdown {
        --paper-input-container: {
          padding: 9px 0 0 13px;
        }
      }

      table {
        border-collapse: collapse;
        border-spacing: 0;
      }

      table td {
        padding: 0;
        margin: 0;
      }

      .allcontrols {
        padding: 0 20px 20px;
        flex-grow: 1;
        overflow-y: auto;
      }

      .legend-holder {
        background: #e9e9e9;
        border-top: 1px solid #ccc;
        box-sizing: border-box;
        color: #555;
        padding: 15px 20px;
        width: 100%;
      }

      .toggle-legend-button {
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .toggle-legend-text {
        vertical-align: middle;
      }

      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: 16px;
        margin: 8px 5px 8px 0;
        color: black;
      }
      .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: 14px;
        margin: 0 -5px;
        padding: 5px;
      }

      .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 {
        height: 0px;
        width: 0px;
        overflow: hidden;
      }

      .allcontrols .control-holder {
        clear: both;
        display: flex;
        justify-content: space-between;
      }

      .allcontrols .control-holder paper-radio-group {
        margin-top: 5px;
      }

      span.counter {
        font-size: 13px;
        color: gray;
      }

      .runs 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;
      }

      /** 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>
        <a href="#" id="graphdownload" class="title" download="graph.png"></a>
      </div>
      <div class="control-holder runs">
        <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">
          <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>
      <template is="dom-if" if="[[showUploadButton]]">
        <div class="control-holder">
          <div class="title">Upload</div>
          <paper-button raised class="upload-button" on-click="_getFile" title="Upload a graph pbtxt file to view the graph">
            Choose File
          </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">
        <paper-radio-group selected="{{_selectedGraphType}}">
          
          <paper-radio-button name="op_graph" disabled="[[_getSelectionOpGraphDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]">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="control-holder">
        <div>
          <paper-toggle-button checked="{{traceInputs}}" class="title">
            Trace inputs
          </paper-toggle-button>
        </div>
      </div>
      <template is="dom-if" if="[[healthPillsFeatureEnabled]]">
        <div class="control-holder">
          <paper-toggle-button checked="{{healthPillsToggledOn}}" class="title">Show health pills</paper-toggle-button>
        </div>
      </template>
      <div class="control-holder">
        <div class="title">Color</div>
        <paper-radio-group selected="{{colorBy}}">
          <paper-radio-button name="structure">Structure</paper-radio-button>

          <paper-radio-button name="device">Device</paper-radio-button>

          <paper-radio-button id="xla-cluster-radio-button" name="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="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="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="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>
        <template is="dom-if" if="[[_isGradientColoring(stats, colorBy)]]">
          <svg width="140" height="20" style="margin: 0 5px" class="color-text">
            <defs>
              <lineargradient id="linearGradient" x1="0%" y1="0%" x2="100%" y2="0%">
                <stop class="start" offset="0%" stop-color$="[[_currentGradientParams.startColor]]" />
                <stop class="end" offset="100%" stop-color$="[[_currentGradientParams.endColor]]" />
              </lineargradient>
            </defs>
            <rect x="0" y="0" width="135" height="20" fill="url(#linearGradient)" stroke="black" />
          </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]]" />
                </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" />
              </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>
    </div>
    <div class="legend-holder">
      <paper-icon-button icon="[[_getToggleLegendIcon(_legendOpened)]]" on-click="_toggleLegendOpen" class="toggle-legend-button">
      </paper-icon-button>
      <span class="toggle-legend-text">
        [[_getToggleText(_legendOpened)]]
      </span>
      <iron-collapse opened="[[_legendOpened]]">
        <div>
          <table>
            <tr>
              <td><div class="title">Graph</div></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" />
                </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" />
                    </marker>
                  </defs>
                  <path marker-end="url(#dataflow-arrowhead-legend)" stroke="#bbb" d="M2 9 l 29 0" stroke-linecap="round" />
                </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" />
                </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" />
                    </marker>
                  </defs>
                  <path marker-end="url(#reference-arrowhead-legend)" stroke="#FFB74D" d="M2 9 l 29 0" stroke-linecap="round" />
                </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>
          </table>
        </div>
      </iron-collapse>
    </div>
  </template>
</dom-module>















<dom-module id="tf-graph-dashboard">
  <template>
    <paper-dialog id="error-dialog" with-backdrop></paper-dialog>
    <template is="dom-if" if="[[_datasetsState(_datasetsFetched, _datasets, 'EMPTY')]]">
      <div style="max-width: 540px; margin: 80px auto 0 auto;">
        <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/get_started/graph_viz">graph visualizer tutorial</a>.
        

        <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>
          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.
        
      </div>
    </template>
    <template is="dom-if" if="[[_datasetsState(_datasetsFetched, _datasets, 'PRESENT')]]">
      <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}}"></tf-graph-controls>
        <div class="center" 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>
          <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]]"></tf-graph-board>
        </div>
      </tf-dashboard-layout>
    </template>
    <style>
      :host /deep/ {
        font-family: 'Roboto', sans-serif;
      }

      .sidebar {
        display: flex;
        height: 100%;
      }

      .center {
        position: relative;
        height: 100%;
      }

      paper-dialog {
        padding: 20px;
      }
    </style>
  </template>
</dom-module>



























<dom-module id="vz-distribution-chart">
  <template>
    <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;
      }
    </style>
  </template>
  
</dom-module>



<dom-module id="tf-distribution-loader">
  <template>
    <tf-card-heading tag="[[tag]]" run="[[run]]" display-name="[[tagMetadata.displayName]]" description="[[tagMetadata.description]]" color="[[_runColor]]"></tf-card-heading>
    
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-distribution-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <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 class="sidebar-section">
          <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:
            <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>
              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.
            
          </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>
  </template>

  
</dom-module>

























<dom-module id="vz-histogram-timeseries">
  <template>
    <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 {
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        position: relative;
      }

      svg {
        font-family: roboto, sans-serif;
        overflow: visible;
        display: block;
        width: 100%;
        flex-grow: 1;
        flex-shrink: 1;
      }

      #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: black !important;
      }

      .hover.hover-closest text {
        opacity: 1;
      }

      .baseline {
        stroke: black;
        stroke-opacity: 0.1;
      }

      .outline {
        fill: none;
        stroke: white;
        stroke-opacity: 0.5;
      }

      .outline.outline-hover {
        stroke: black !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: black;
      }

      .x-axis-hover rect,
      .y-axis-hover rect,
      .y-slice-axis-hover rect {
        fill: white;
      }

      .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>
  </template>

  
</dom-module>







<dom-module id="tf-histogram-loader">
  <template>
    <tf-card-heading tag="[[tag]]" run="[[run]]" display-name="[[tagMetadata.displayName]]" description="[[tagMetadata.description]]" color="[[_runColor]]"></tf-card-heading>
    
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-histogram-dashboard">
  <template>
    <tf-dashboard-layout>
      <div slot="sidebar">
        <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 class="sidebar-section">
          <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:
            <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>
              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.
            
          </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>
  </template>

  
</dom-module>























<dom-module id="tf-text-loader">
  <template>
    <tf-card-heading run="[[run]]" tag="[[tag]]" color="[[_runColor]]">
    </tf-card-heading>
    <paper-material elevation="1" id="steps-container" class="container scrollbar" style="border-color: [[_runColor]]">
      <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;
      }
      .text {
        background-color: white;
        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 #ccc;
        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>
  </template>
  
</dom-module>



<dom-module id="tf-text-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section">
          <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:
            <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>
              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.
            
          </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]]"></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>
  </template>
  
</dom-module>

























<dom-module id="tf-pr-curve-card">
  <template>
    <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]]" get-data-load-url="[[_dataUrl]]" 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>
  </template>
  
</dom-module>








<dom-module id="tf-pr-curve-steps-selector">
  <template>
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-pr-curve-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <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 class="sidebar-section">
          <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:
            <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>
              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.
            
          </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]]"></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: 40%;
        overflow-y: auto;
      }
    </style>
  </template>

  
</dom-module>





<dom-module id="tf-profile-redirect-dashboard">
  <template>
    <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:
      
      <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>
      .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>
  </template>

  
</dom-module>













<dom-module id="tf-plugin-dialog">
  <template>
    
    <template is="dom-if" if="[[_open]]">
      <div id="dashboard-backdrop"></div>
    </template>
    <paper-dialog id="dialog" modal opened="{{_open}}" with-backdrop="[[_useNativeBackdrop]]">
      <h2 id="dialog-title">[[_title]]</h2>
      <div class="custom-message">[[_customMessage]]</div>
    </paper-dialog>
    <style>
      /** We rely on a separate `_hidden` property instead of directly making use
          of the `_open` attribute because this CSS specification may strangely
          affect other elements throughout TensorBoard. See #899. */
      #dashboard-backdrop {
        background: rgba(0, 0, 0, 0.6);
        width: 100%;
        height: 100%;
      }

      #dialog-title {
        padding-bottom: 15px;
      }

      .custom-message {
        margin-top: 0;
        margin-bottom: 15px;
      }
    </style>
  </template>
  
</dom-module>





<dom-module id="tf-beholder-video">
  <template>
    <div id="container">
      <img id="video" src$="[[_imageURL]]">
    </div>

    <style>
      img {
        image-rendering: pixelated;
        margin-right: 10px;
      }
    </style>
  </template>

  
</dom-module>




<dom-module id="tf-beholder-info">
  <template>
    <template is="dom-repeat" items="[[_items]]">
      <div class="section-info" style$="height: [[item.height]]px">
        <ul>
          <li>[[item.name]]</li>
          <li>shape: [[item.shape]]</li>
          <li>range: [ [[item.min]], [[item.max]] ]</li>
          <li>mean: [[item.mean]]</li>
        </ul>
      </div>
    </template>

    <style>
      .section-info {
        margin: 0 0 5px 0;
      }
      .section-info ul {
        list-style-type: none;
        margin: 0;
        padding-left: 10px;
      }
    </style>
  </template>

  
</dom-module>


<dom-module id="tf-beholder-dashboard">
  <template>
    <tf-plugin-dialog id="initialDialog"></tf-plugin-dialog>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <template is="dom-if" if="[[_controls_disabled]]">
          <div class="sidebar-section">
            <p class="controls-disabled-message">
              Controls disabled: directory is not writeable.
            
            <p class="disclaimer">
              Beholder requires write access to the log directory in order to
              communicate visualization changes to the <code>Beholder</code>
              instance in your model.
            
          </div>
        </template>
        <div class="sidebar-section">
          <h3>Values</h3>
          <paper-radio-group id="valuesSelector" selected="{{_values}}">
            <paper-radio-button name="trainable_variables" disabled="[[_controls_disabled]]">
              <pre>tf.trainable_variables()</pre>
            </paper-radio-button>
            <paper-radio-button id="option-arrays" name="arrays" disabled="[[_controls_disabled]]">
              <pre>b.update(arrays=[NP_ARRAYS])</pre>
            </paper-radio-button>
            <paper-radio-button id="option-frames" name="frames" disabled="[[_controls_disabled]]">
              <pre>b.update(frame=NP_ARRAY)</pre>
            </paper-radio-button>
          </paper-radio-group>

          <template is="dom-if" if="[[_valuesNotFrame(_values)]]">
            <paper-checkbox checked="{{_showAll}}" disabled="[[_controls_disabled]]">Show all data <i>(can be resource intensive)</i></paper-checkbox>
          </template>
        </div>

        <template is="dom-if" if="[[_valuesNotFrame(_values)]]">
          <div class="sidebar-section">
            <h3>Mode</h3>
            <paper-radio-group id="modeSelector" selected="{{_mode}}">
              <paper-radio-button name="current" disabled="[[_controls_disabled]]">
                current values
              </paper-radio-button>
              <paper-radio-button name="variance" disabled="[[_controls_disabled]]">
                variance over train steps
              </paper-radio-button>
            </paper-radio-group>
            <template is="dom-if" if="[[_varianceSelected(_mode)]]">
              <h4>Variance timesteps: {{_windowSize}}</h4>
              <paper-slider id="windowSlider" value="{{_windowSize}}" type="number" step="1" min="2" max="20" pin="true" disabled="[[_controls_disabled]]">
              </paper-slider>
            </template>
          </div>

          <div class="sidebar-section">
            <h3>Image scaling</h3>
            <paper-radio-group id="scalingSelector" selected="{{_scaling}}">
              <paper-radio-button id="option-layer" name="layer" disabled="[[_controls_disabled]]">
                per section
              </paper-radio-button>
              <paper-tooltip for="option-layer" position="right">
                Black is the lowest value in that section, white is that largest
                value in that section.
              </paper-tooltip>

              <paper-radio-button id="option-network" name="network" disabled="[[_controls_disabled]]">
                all sections
              </paper-radio-button>
              <paper-tooltip for="option-network" position="right">
                Black is the smallest value in all sections, white is the
                largest value in all sections.
              </paper-tooltip>
            </paper-radio-group>

            <div id="colormap-selection">
              <div id="colormap-selection-label">Colormap:</div>
              <paper-dropdown-menu no-label-float selected-item-label="{{_colormap}}" disabled="[[_controls_disabled]]">
                <paper-listbox slot="dropdown-content" selected="0">
                  <paper-item>magma</paper-item>
                  <paper-item>inferno</paper-item>
                  <paper-item>plasma</paper-item>
                  <paper-item>viridis</paper-item>
                  <paper-item>grayscale</paper-item>
                </paper-listbox>
              </paper-dropdown-menu>
            </div>
          </div>
        </template>

        <div class="sidebar-section">
          <h3>Updates per second: {{_FPS}}</h3>
          <paper-slider id="FPSSlider" value="{{_FPS}}" type="number" step="1" min="0" max="30" pin="true" disabled="[[_controls_disabled]]">
          </paper-slider>
        </div>

        <div class="sidebar-section">
          <div>
            <paper-button class="x-button" id="record_button" on-tap="_toggleRecord" disabled="[[_controls_disabled]]">
              [[_recordText]]
            </paper-button>
          </div>
        </div>

        <div class="sidebar-section">
          <p class="disclaimer">
            Note: Beholder currently only works well on local file systems.
          
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[!_is_active]]">
          <div class="no-data-warning">
            <h3>No Beholder data was found.</h3>

            <p>Probable causes:
            <ul>
              <li>Your script isn't running.</li>
              <li>You aren't calling <code>beholder.update()</code>.</li>
            </ul>

            <p>
              To use Beholder, import and instantiate the
              <code>Beholder</code> class, and call its
              <code>update</code> method with a <code>Session</code> argument
              after every train step:
            

            <pre>from tensorboard.plugins.beholder import Beholder
beholder = Beholder(LOG_DIRECTORY)

# inside train loop
beholder.update(
  session=sess,
  arrays=list_of_np_arrays,  # optional argument
  frame=two_dimensional_np_array,  # optional argument
)</pre>
            <p>
              If using <code>tf.train.MonitoredSession</code>, you can use
              <code>BeholderHook</code>:
            

            <pre>from tensorboard.plugins.beholder import BeholderHook
beholder_hook = BeholderHook(LOG_DIRECTORY)
with MonitoredSession(..., hooks=[beholder_hook]) as sess:
  sess.run(train_op)</pre>

            <p>
              If you think everything is set up properly, please see
              <a href="https://github.com/tensorflow/tensorboard/blob/master/tensorboard/plugins/beholder/README.md">the README</a>
              for more information and consider filing an issue on GitHub.
            

            <p class="disclaimer">
              Note: Beholder currently only works well on local file systems.
            
          </div>
        </template>

        <template is="dom-if" if="[[_is_active]]">
          <tf-beholder-video id="video" fps="[[_FPS]]"></tf-beholder-video>

          <template is="dom-if" if="[[_valuesNotFrame(_values)]]">
            <tf-beholder-info id="info" fps="[[_FPS]]"> </tf-beholder-info>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .center {
        height: 100%;
        display: flex;
        padding: 0;
      }

      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0;
      }

      paper-checkbox {
        display: block;
        padding: 4px;
      }

      paper-radio-button {
        display: flex;
        padding: 5px;

        --paper-radio-button-radio-container: {
          flex-grow: 0;
          flex-shrink: 0;
        }

        --paper-radio-button-label: {
          font-size: 13px;
          overflow: hidden;
          text-overflow: ellipsis;
        }
      }

      paper-radio-group {
        margin-top: 5px;
        width: 100%;
      }

      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;
      }

      pre {
        display: inline;
      }

      paper-button#record_button {
        color: #d32f2f;
      }

      paper-button#record_button.is-recording {
        background: #d32f2f;
        color: white;
      }

      .sidebar-section.beholder-dashboard:last-child {
        flex-grow: 0;
      }

      #colormap-selection {
        display: flex;
        margin-top: 5px;
      }

      #colormap-selection-label {
        margin-top: 13px;
      }

      #colormap-selection paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }

      h4 {
        font-size: 14px;
        font-weight: normal;
        margin: 5px 0;
      }

      p.disclaimer {
        color: #999;
        font-style: italic;
      }

      p.controls-disabled-message {
        color: #c00;
        font-weight: bold;
      }

      .sidebar {
        font-size: 14px;
      }
    </style>
  </template>
  
</dom-module>




















<dom-module id="vaadin-split-layout">
  <template>
    <style>
      :host {
        display: flex;
        overflow: hidden !important;
        transform: translateZ(0);
      }

      :host([vertical]) {
        flex-direction: column;
      }

      :host ::slotted(*) {
        flex: 1 1 auto;
        overflow: auto;
      }

      :host > #splitter {
        flex: none;
        position: relative;
        z-index: 1;
        overflow: visible;
        min-width: 8px;
        min-height: 8px;
        background: var(--divider-color, #ccc);
        fill: var(--primary-background-color, #fff);
        @apply --vaadin-split-layout-splitter;
      }

      :host(:not([vertical])) > #splitter {
        cursor: ew-resize;
      }

      :host([vertical]) > #splitter {
        cursor: ns-resize;
      }

      #handle,
      #splitter ::slotted([slot=handle]) {
        position: absolute;
        top: 50%;
        left: 50%;
        transform: translate(-50%, -50%);
      }

      :host([vertical]) > #splitter #handle {
        transform: translate(-50%, -50%) rotate(90deg);
      }
    </style>
    <slot id="primary" name="primary"></slot>
    <div id="splitter" on-track="_onHandleTrack" on-down="_preventDefault">
      <slot name="handle">
        <svg id="handle" width="40" height="40">
          <rect x="19" y="8" width="2" height="24"></rect>
        </svg>
      </slot>
    </div>
    <slot id="secondary" name="secondary"></slot>
  </template>

  
</dom-module>




<dom-module id="tf-hparams-query-pane">
  <template>
    <div class="pane">
      <vaadin-split-layout vertical>
        <vaadin-split-layout vertical id="hyperparameters-metrics-statuses">
          <vaadin-split-layout vertical id="hyperparameters-metrics">
            <div 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>
                  
                  
                  <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>
                  
                  <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>
                  
                  <template is="dom-if" if="[[hparam.filter.regexp]]">
                    <paper-input label="Regular expression" value="{{hparam.filter.regexp}}" on-value-changed="_queryServer">
                    </paper-input>
                  </template>
                </div>
              </template>
            </div>
            <div class="section metrics">
              <div class="section-title">Metrics</div>
              <template is="dom-repeat" items="{{_metrics}}" as="metric">
                <div class="metric">
                  
                  <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>
          </vaadin-split-layout>
          <div 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>
        </vaadin-split-layout>
        <vaadin-split-layout vertical id="sorting-paging">
          <div 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>
          <vaadin-split-layout vertical id="paging-download">
            <div 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 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>
          </vaadin-split-layout>
        </vaadin-split-layout>
      </vaadin-split-layout>
    </div>
    <style>
      .pane {
        display: flex;
        flex-direction: column;
        height: 100%;
      }
      .section {
        margin: 5px 10px 5px 10px;
        overflow-y: auto;
      }
      .section-title {
        display: block;
        font-weight: bold;
        text-decoration: underline;
        margin-bottom: 7px;
      }
      #hyperparameters-metrics-statuses {
        flex-basis: 70%;
        flex-shrink: 1;
        flex-grow: 1;
      }
      #hyperparameters-metrics {
        flex-basis: 90%;
        flex-shrink: 1;
        flex-grow: 1;
      }
      .hyperparameters {
        flex-basis: auto;
        flex-shrink: 1;
        flex-grow: 1;
      }
      .metrics {
        flex-basis: auto;
        flex-shrink: 1;
        flex-grow: 1;
      }
      .statuses {
        flex-basis: auto;
        flex-shrink: 0;
        flex-grow: 0;
      }
      #sorting-paging {
        flex-basis: 30%;
        flex-shrink: 0;
        flex-grow: 0;
      }
      #paging-download {
        flex-basis: 90%;
        flex-shrink: 1;
        flex-grow: 1;
      }
      .sorting {
        flex-basis: auto;
        flex-shrink: 0;
        flex-grow: 0;
      }
      .paging {
        flex-basis: auto;
        flex-shrink: 0;
        flex-grow: 0;
      }
      .download {
        flex-basis: auto;
        flex-shrink: 0;
        flex-grow: 0;
      }
      .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>
  </template>
  
</dom-module>







<dom-module id="iron-pages">

  <template>
    <style>
      :host {
        display: block;
      }

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

    <slot></slot>
  </template>

  
</dom-module>







<dom-module id="paper-header-panel">
  <template>
    <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>
  </template>

  
</dom-module>










<dom-module id="paper-tab">
  <template>
    <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;
      }

      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>
  </template>

  
</dom-module>










<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" /></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z" /></g>
</defs></svg>
</iron-iconset-svg>





<dom-module id="paper-tabs">
  <template>
    <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>

  </template>

  
</dom-module>








<dom-module id="paper-toolbar">
  <template>
    <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>
  </template>

  
</dom-module>











<dom-module id="tf-hparams-scale-and-color-controls">
  <template>
    <div class="control-panel">
      
      <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>

      
      <div class="columns-container">
        
        <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>
                  
                  <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>
  </template>

  
</dom-module>












<dom-module id="vaadin-grid-active-item-themability-styles">
  <template>
    <style>
      vaadin-grid-table .vaadin-grid-row[active] .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        @apply(--vaadin-grid-body-row-active-cell);
      }
    </style>
  </template>
</dom-module>





<dom-module id="vaadin-grid-table-table-scroll-styles">
  <template>
    <style>
      #table {
        position: relative;
        overflow: auto;
        -webkit-overflow-scrolling: touch;
        z-index: -2;
      }

      vaadin-grid-table[ios] #table {
        transform: none;
      }

      vaadin-grid-table[fixed-sections] #table {
        transform: none;
      }
    </style>
  </template>
</dom-module>

<dom-module id="vaadin-grid-table-scroll-styles">
  <template>
    <style>
      vaadin-grid-table {
        transform: translateZ(0);
      }

      vaadin-grid-table-header {
        position: absolute;
        top: 0;
        width: 100%;
      }

      vaadin-grid-table-footer {
        position: absolute;
        bottom: 0;
        width: 100%;
      }

      vaadin-grid-table-body {
        z-index: -1;
      }

      vaadin-grid-table[fixed-sections] {
        /* Any value other than ‘none’ for the transform results in the creation of both a stacking context and
        a containing block. The object acts as a containing block for fixed positioned descendants. */
        transform: translateZ(0);
        overflow: hidden;
      }

      vaadin-grid-table[fixed-sections] vaadin-grid-table-header,
      vaadin-grid-table[fixed-sections] vaadin-grid-table-footer {
        position: fixed;
      }

      vaadin-grid-table[fixed-sections] vaadin-grid-table-body#items {
        position: fixed;
        width: 100%;
        will-change: transform;
      }
    </style>
  </template>
</dom-module>









<dom-module id="vaadin-grid-table-cell"></dom-module>
<dom-module id="vaadin-grid-table-header-cell"></dom-module>
<dom-module id="vaadin-grid-table-footer-cell"></dom-module>
<dom-module id="vaadin-grid-sizer-cell"></dom-module>




<dom-module id="vaadin-grid-sizer">
  <template>
    <style>
      :host {
        display: flex;
        visibility: hidden;
      }

      .cell {
        display: block;
        flex-shrink: 0;
        line-height: 0;
        font-size: 1px;
        margin-top: -1em;
      }

      .cell[hidden] {
        display: none;
      }
    </style>

    <template is="dom-repeat" items="[[_columns]]" as="column">
      <vaadin-grid-sizer-cell class="cell" column="[[column]]">&nbsp;</vaadin-grid-sizer-cell>
    </template>

  </template>
  
</dom-module>


<dom-module id="vaadin-grid-table-outer-scroller">
  <template>
    <style>
      :host {
        display: block;
        height: 100%;
        width: 100%;
        position: absolute;
        top: 0;
        box-sizing: border-box;
        overflow: auto;
      }

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

      :host([ios]) {
        pointer-events: all;
        z-index: -3;
      }

      :host([ios][scrolling]) {
        z-index: 0;
      }
    </style>

    <slot></slot>

  </template>
  
</dom-module>









<dom-module id="vaadin-grid-table-focus-trap">
  <template>
    <style>
     :host {
       position: absolute;
       z-index: -3;
       height: 0;
       overflow: hidden;
     }

     :host(:focus),
     .primary:focus,
     ::slotted(.primary:focus),
     .secondary:focus,
     ::slotted(.secondary:focus) {
       outline: none;
     }
    </style>

    
    <div class="primary" tabindex="0" role="gridcell" on-focus="_onBaitFocus" on-blur="_onBaitBlur"><div aria-hidden="true">&nbsp;</div></div>
    <div class="secondary" tabindex="-1" role="gridcell" on-focus="_onBaitFocus" on-blur="_onBaitBlur"><div aria-hidden="true">&nbsp;</div></div>

    <slot></slot>
  </template>
  
</dom-module>



<dom-module id="vaadin-grid-table-row"></dom-module>
<dom-module id="vaadin-grid-table-header-row"></dom-module>








<dom-module id="vaadin-grid-row-details-styles">
  <template>
    <style>
      [detailscell] {
        position: absolute;
        bottom: 0;
        left: 0;
        width: 100%;
      }
    </style>
  </template>
</dom-module>
<dom-module id="vaadin-grid-row-details-themability-styles">
  <template>
    <style>
      .vaadin-grid-cell[detailscell] ::slotted(vaadin-grid-cell-content) {
        background: #fff;
        @apply(--vaadin-grid-body-row-details-cell);
      }
    </style>
  </template>
</dom-module>




<dom-module id="vaadin-grid-data-provider-themability-styles">
  <template>
    <style>

      /* Anim */
      @keyframes vaadin-grid-spin-360 {
        100% {
          transform: rotate(360deg);
        }
      }
      @-webkit-keyframes vaadin-grid-spin-360 {
        100% {
          -webkit-transform: rotate(360deg);
          transform: rotate(360deg);
        }
      }

      #spinner {
        border: 2px solid var(--primary-color, #03A9F4);
        border-radius: 50%;
        border-right-color: transparent;
        border-top-color: transparent;
        content: "";
        height: 16px;
        left: 50%;
        margin-left: -8px;
        margin-top: -8px;
        position: absolute;
        top: 50%;
        width: 16px;
        pointer-events: none;
        opacity: 0;
        @apply(--vaadin-grid-loading-spinner);
      }

      :host([loading]) #spinner {
        opacity: 1;
        -webkit-animation: vaadin-grid-spin-360 400ms linear infinite;
        animation: vaadin-grid-spin-360 400ms linear infinite;
      }

      :host([loading]) #items {
        opacity: 0.5;
      }

    </style>
  </template>
</dom-module>






<dom-module id="vaadin-grid-selection-themability-styles">
  <template>
    <style>
      vaadin-grid-table .vaadin-grid-row[selected] .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        background-color: var(--paper-grey-100, rgb(243, 243, 243));
        @apply(--vaadin-grid-body-row-selected-cell);
      }
    </style>
  </template>
</dom-module>




<dom-module id="vaadin-grid-navigation-themability-styles">
  <template>
    <style>
      :host(:focus),
      #table:focus {
        outline: none;
      }

      :host([navigating]:not([interacting])) [focused] > .vaadin-grid-row[focused] > [focused] ::slotted(vaadin-grid-cell-content) {
        box-shadow: inset 0 0 0 3px rgba(0, 0, 0, 0.3);
        @apply(--vaadin-grid-focused-cell);
      }
    </style>
  </template>
</dom-module>



<dom-module id="vaadin-grid-column-reordering-themability-styles">
  <template>
    <style>
      vaadin-grid-table[reordering] .vaadin-grid-cell {
        background: #000;
      }

      :host([reordering]) .vaadin-grid-cell[reorder-status="dragging"] {
        background: var(--primary-color, #000);
      }

      vaadin-grid-table[reordering] .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        transition: opacity 300ms;
        transform: translateZ(0);
        opacity: 0.8;
      }

      #scroller .vaadin-grid-cell[reorder-status="allowed"] ::slotted(vaadin-grid-cell-content) {
        opacity: 1;
      }

      #scroller .vaadin-grid-cell[reorder-status="dragging"] {
        background: var(--primary-color, #000);
      }

      #scroller .vaadin-grid-cell[reorder-status="dragging"] ::slotted(vaadin-grid-cell-content) {
        opacity: 0.95;
      }
    </style>
  </template>
</dom-module>









<dom-module id="vaadin-grid-table-styles">
  <template>
    <style>

      @keyframes appear {
        to {
          opacity: 1;
        }
      }

      vaadin-grid-table {
        display: block;
        position: relative;
        animation: 1ms appear;
      }

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

      #items {
        position: relative;
      }

      #items {
        border-top: 0 solid transparent;
        border-bottom: 0 solid transparent;
      }

      #items > .vaadin-grid-row {
        box-sizing: border-box;
        margin: 0;
        position: absolute;
      }

      vaadin-grid-table-body {
        display: block;
      }

      vaadin-grid-table-header .vaadin-grid-cell,
      vaadin-grid-table-footer .vaadin-grid-cell {
        top: 0;
      }

      .vaadin-grid-cell {
        padding: 0;
        flex-shrink: 0;
        flex-grow: 1;
        box-sizing: border-box;
        display: flex;
      }

      .vaadin-grid-cell:not([detailscell]) {
        position: relative;
      }

      .vaadin-grid-cell ::slotted(vaadin-grid-cell-content) {
         width: 100%;
         display: inline-flex;
         justify-content: center;
         flex-direction: column;
         white-space: nowrap;
         overflow: hidden;
      }

      .vaadin-grid-column-resize-handle {
        position: absolute;
        right: 0;
        height: 100%;
        cursor: col-resize;
        z-index: 1;
      }

      .vaadin-grid-column-resize-handle::before {
        position: absolute;
        content: "";
        height: 100%;
        width: 35px;
        transform: translateX(-50%);
      }

      [lastcolumn] .vaadin-grid-column-resize-handle::before,
      [last-frozen] .vaadin-grid-column-resize-handle::before {
        width: 18px;
        transform: translateX(-100%);
      }

      vaadin-grid-table[column-reordering-allowed] #header,
      vaadin-grid-table[column-resizing] {
        -ms-user-select: none;
        -moz-user-select: none;
        -webkit-user-select: none;
        user-select: none;
      }

      vaadin-grid-table[column-resizing] {
        cursor: col-resize;
      }

      .vaadin-grid-row:not([hidden]) {
        display: flex;
        width: 100%;
      }

      [frozen] {
        z-index: 2;
      }

      [hidden] {
        display: none;
      }

      vaadin-grid-table[no-content-pointer-events] .vaadin-grid-cell ::slotted(vaadin-grid-cell-content) {
        pointer-events: none;
      }
    </style>
  </template>
</dom-module>

<dom-module id="vaadin-grid-table-table-styles">
  <template>
    <style>
      :host([ios][column-resizing]) #outerscroller {
        overflow: hidden;
      }

      #fixedsizer,
      #outersizer {
        border-top: 0 solid transparent;
        border-bottom: 0 solid transparent;
      }

      #table {
        height: 100%;
        width: 100%;
        display: block;
        overflow: auto;
        box-sizing: border-box;
      }

      #table[overflow-hidden],
      #outerscroller[overflow-hidden] {
        overflow: hidden;
      }

      vaadin-grid-sizer {
        position: relative;
        width: 100%;
      }

      #sizerwrapper {
        position: absolute;
        width: 100%;
        z-index: -100;
      }

      #reorderghost {
        visibility: hidden;
        position: fixed;
        opacity: 0.5;
        pointer-events: none;
      }

      ::slotted(vaadin-grid-column),
      ::slotted(vaadin-grid-selection-column),
      ::slotted(vaadin-grid-column-group) {
        display: none;
      }

    </style>
  </template>
</dom-module>

<dom-module id="vaadin-grid-table-themability-styles">
  <template>
    <style>

      /* Default borders */
      vaadin-grid-table-header .vaadin-grid-row:last-child .vaadin-grid-cell ::slotted(vaadin-grid-cell-content) {
        border-bottom: 1px solid var(--divider-color, rgba(0, 0, 0, 0.08));
      }

      vaadin-grid-table-footer .vaadin-grid-row:first-child .vaadin-grid-cell ::slotted(vaadin-grid-cell-content) {
        border-top: 1px solid var(--divider-color, rgba(0, 0, 0, 0.08));
      }

      vaadin-grid-table-body .vaadin-grid-row:not([lastrow]) .vaadin-grid-cell ::slotted(vaadin-grid-cell-content) {
        border-bottom: 1px solid var(--divider-color, rgba(0, 0, 0, 0.08));
      }

      [last-frozen] ::slotted(vaadin-grid-cell-content) {
        border-right: 1px solid var(--divider-color, rgba(0, 0, 0, 0.08));
      }

      /* Column resize handle */

      .vaadin-grid-column-resize-handle {
        border-right: 1px solid var(--divider-color, rgba(0, 0, 0, 0.08));
        @apply(--vaadin-grid-column-resize-handle);
      }

      /* Cells */
      vaadin-grid-table .vaadin-grid-row .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        background: #fff;
        text-align: left;
        padding: 8px;
        box-sizing: border-box;
        @apply(--vaadin-grid-cell);
      }

      vaadin-grid-table-header .vaadin-grid-row .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        font-weight: 500;
        @apply(--vaadin-grid-header-cell);
      }

      vaadin-grid-table-footer .vaadin-grid-row .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        font-weight: 500;
        @apply(--vaadin-grid-footer-cell);
      }

      vaadin-grid-table-body .vaadin-grid-row .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        @apply(--vaadin-grid-body-cell);
      }

      vaadin-grid-table-body [odd] .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        @apply(--vaadin-grid-body-row-odd-cell);
      }

      vaadin-grid-table .vaadin-grid-row .vaadin-grid-cell:not([detailscell])[last-frozen] ::slotted(vaadin-grid-cell-content) {
        @apply(--vaadin-grid-cell-last-frozen);
      }

      vaadin-grid-table:not([scrolling]) vaadin-grid-table-body .vaadin-grid-row:hover .vaadin-grid-cell ::slotted(vaadin-grid-cell-content) {
        @apply(--vaadin-grid-body-row-hover-cell);
      }

      vaadin-grid-table .vaadin-grid-row .vaadin-grid-cell.vaadin-grid-cell[lastcolumn] ::slotted(vaadin-grid-cell-content) {
        border-right: none;
      }

    </style>
  </template>
</dom-module>

<dom-module id="vaadin-grid-table">
  <template>
      <style include="vaadin-grid-table-table-scroll-styles"></style>
      <style include="vaadin-grid-table-table-styles"></style>

      <style include="vaadin-grid-data-provider-themability-styles"></style>

      <div id="spinner"></div>
      <div id="table" tabindex="-1" overflow-hidden$="[[_hideTableOverflow(scrollbarWidth, safari)]]">
        <div id="sizerwrapper">
          <vaadin-grid-sizer id="fixedsizer" top="[[_estScrollHeight]]" column-tree="[[columnTree]]"></vaadin-grid-sizer>
        </div>
        <slot name="header"></slot>
        <slot name="items"></slot>
        <slot name="footer"></slot>
      </div>

      <div id="reorderghost"></div>
      <vaadin-grid-table-outer-scroller id="outerscroller" scroll-target="[[scrollTarget]]" overflow-hidden$="[[_hideOuterScroller(scrollbarWidth, safari)]]" ios$="[[ios]]" scrolling$="[[scrolling]]">
      <vaadin-grid-sizer id="outersizer" top="[[_estScrollHeight]]" column-tree="[[columnTree]]"></vaadin-grid-sizer>
    </vaadin-grid-table-outer-scroller>
    <slot></slot>
    <slot name="footerFocusTrap"></slot>
  </template>
</dom-module>








<dom-module id="vaadin-grid-column">
  
</dom-module>















<dom-module id="vaadin-grid">
  <template>
    <style>
      :host {
        display: block;
        height: 400px;
        background: var(--primary-background-color, #fff);
        box-sizing: border-box;
        border: 1px solid var(--divider-color, rgba(0, 0, 0, 0.08));
      }

      :host(:focus) {
        -webkit-tap-highlight-color: transparent;
      }

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

      #scroller {
        height: 100%;
        width: 100%;
      }
    </style>

    <style include="vaadin-grid-table-scroll-styles"></style>
    <style include="vaadin-grid-row-details-styles"></style>
    <style include="vaadin-grid-table-styles"></style>

    <style include="vaadin-grid-table-themability-styles"></style>
    <style include="vaadin-grid-selection-themability-styles"></style>
    <style include="vaadin-grid-navigation-themability-styles"></style>
    <style include="vaadin-grid-active-item-themability-styles"></style>
    <style include="vaadin-grid-row-details-themability-styles"></style>
    <style include="vaadin-grid-column-reordering-themability-styles"></style>

    <vaadin-grid-table id="scroller" loading$="[[_loading]]" bind-data="[[_bindData]]" size="[[size]]" column-tree="[[_columnTree]]" row-details-template="[[_rowDetailsTemplate]]" column-reordering-allowed="[[columnReorderingAllowed]]">
      <vaadin-grid-table-header id="header" slot="header" target="[[_getContentTarget()]]" column-tree="[[_columnTree]]"></vaadin-grid-table-header>
      <vaadin-grid-table-body id="items" slot="items"></vaadin-grid-table-body>
      <vaadin-grid-table-footer id="footer" slot="footer" target="[[_getContentTarget()]]" column-tree="[[_columnTree]]"></vaadin-grid-table-footer>

      
      <slot name="footerFocusTrap"></slot>

      
      
      <slot></slot>

      <vaadin-grid-table-focus-trap id="footerFocusTrap" slot="footerFocusTrap" on-focus-gained="_onFooterFocus" on-focus-lost="_onFocusout">
      </vaadin-grid-table-focus-trap>
    </vaadin-grid-table>
  </template>
</dom-module>












<dom-module id="tf-hparams-session-group-details">
  <template>
    <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.
      </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.
      </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">
          
          <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>
    
    <style include="iron-flex">
      :host {
        display: block;
      }
    </style>
  </template>
  
</dom-module>



<dom-module id="tf-hparams-table-view">
  <template>
    <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" width="5em" resizable>
          <template class="header">
            <div class="table-header table-cell">Show Metrics</div>
          </template>
          <template>
            <paper-checkbox class="table-cell" checked="{{expanded}}">
            </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: block;
      }
      .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>
  </template>

  
</dom-module>


<dom-module id="tf-hparams-session-group-values">
  <template>
    
    <template is="dom-if" if="[[_propertiesArePopulated(visibleSchema, sessionGroup)]]">
      
      <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>
  </template>
  
</dom-module>







<dom-module id="tf-hparams-parallel-coords-plot">
  <template>
    <div id="container">
      <svg id="svg"></svg>
    </div>
    <style>
      :host {
        display: block;
      }
      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: 0 1px 0 #fff, 1px 0 0 #fff, 0 -1px 0 #fff, -1px 0 0 #fff;
        fill: #000;
        cursor: move;
      }
    </style>
  </template>

  
  
  
  
</dom-module>





<dom-module id="tf-hparams-parallel-coords-view">
  <template>
    
    <div class="pane">
      <vaadin-split-layout vertical>
        
        <tf-hparams-scale-and-color-controls id="controls" class="section" configuration="[[configuration]]" session-groups="[[sessionGroups]]" options="{{_options}}">
        </tf-hparams-scale-and-color-controls>
        <vaadin-split-layout vertical>
          
          <tf-hparams-parallel-coords-plot id="plot" class="section" session-groups="[[sessionGroups]]" selected-session-group="{{_selectedGroup}}" closest-session-group="{{_closestGroup}}" options="[[_options]]">
          </tf-hparams-parallel-coords-plot>
          <vaadin-split-layout vertical>
            <tf-hparams-session-group-values id="values" class="section" visible-schema="[[configuration.visibleSchema]]" session-group="[[_closestOrSelected(
                             _closestGroup, _selectedGroup)]]">
            </tf-hparams-session-group-values>
            <tf-hparams-session-group-details id="details" class="section" backend="[[backend]]" experiment-name="[[experimentName]]" session-group="[[_selectedGroup]]" visible-schema="[[configuration.visibleSchema]]">
            </tf-hparams-session-group-details>
          </vaadin-split-layout>
        </vaadin-split-layout>
      </vaadin-split-layout>
    </div>

    <style>
      .pane {
        display: flex;
        flex-direction: column;
        height: 100%;
      }
      .section {
        margin: 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: 100%;
        overflow-y: auto;
      }
      #values {
        flex-grow: 0;
        flex-shrink: 0;
        flex-basis: auto;
        height: 95px;
        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>
  </template>

  
</dom-module>








<dom-module id="tf-hparams-scatter-plot-matrix-plot">
  <template>
    <div id="container">
      <svg id="svg"></svg>
    </div>

    <style>
      :host {
        display: block;
      }
      svg {
        font: 10px sans-serif;
      }

      /* 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>
  </template>

  
</dom-module>





<dom-module id="tf-hparams-scatter-plot-matrix-view">
  <template>
    <div class="pane">
      <vaadin-split-layout vertical>
        
        <tf-hparams-scale-and-color-controls class="section" id="controls" configuration="[[configuration]]" session-groups="[[sessionGroups]]" options="{{_options}}">
        </tf-hparams-scale-and-color-controls>
        <vaadin-split-layout vertical>
          
          <tf-hparams-scatter-plot-matrix-plot 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>
          <vaadin-split-layout vertical>
            <tf-hparams-session-group-values class="section" id="values" visible-schema="[[configuration.visibleSchema]]" session-group="[[_closestOrSelected(
                                 _closestGroup, _selectedGroup)]]">
            </tf-hparams-session-group-values>
            
            <tf-hparams-session-group-details class="section" id="details" backend="[[backend]]" experiment-name="[[experimentName]]" session-group="[[_selectedGroup]]" visible-schema="[[configuration.visibleSchema]]">
            </tf-hparams-session-group-details>
          </vaadin-split-layout>
        </vaadin-split-layout>
      </vaadin-split-layout>
    </div>
    <style>
      .pane {
        display: flex;
        flex-direction: column;
        height: 100%;
      }
      .section {
        margin: 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: 95px;
        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>
  </template>

  
</dom-module>




<dom-module id="tf-hparams-sessions-pane">
  <template>
    <paper-header-panel>
      <paper-toolbar slot="header" class="tab-bar">
        <paper-tabs selected="{{_selectedTab}}" slot="top">
          
          <paper-tab view-id="table-view">
            TABLE VIEW
          </paper-tab>
          <paper-tab view-id="parallel-coords-view">
            PARALLEL COORDINATES VIEW
          </paper-tab>
          <paper-tab 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>
  </template>

  
</dom-module>










<dom-module id="tf-hparams-main">
  <template>
    <vaadin-split-layout>
      <div class="sidebar" slot="sidebar">
        <tf-hparams-query-pane id="query-pane" backend="[[backend]]" experiment-name="[[experimentName]]" configuration="{{_configuration}}" session-groups="{{_sessionGroups}}">
        </tf-hparams-query-pane>
      </div>
      <div class="center" slot="center">
        <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>
      </div>
    </vaadin-split-layout>
    <tf-hparams-google-analytics-tracker id="tracker" tracking-id="[[trackingId]]" name="tf_hparams">
    </tf-hparams-google-analytics-tracker>

    <style>
      vaadin-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%;
      }
    </style>
  </template>

  
</dom-module>







<dom-module id="tf-hparams-dashboard">
  <template>
    
    <tf-hparams-main id="hparams-main" backend="[[_backend]]" experiment-name="">
    </tf-hparams-main>
  </template>
  
</dom-module>

























<dom-module id="tf-mesh-loader">
  <template>
    <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>
  </template>
  
</dom-module>



<dom-module id="mesh-dashboard">
  <template>
    <tf-dashboard-layout>
      <div slot="sidebar" class="all-controls">
        <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 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:
            <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>
              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.
            
          </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.title {
        color: var(--paper-grey-800);
        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>
  </template>

  
</dom-module>































<dom-module id="tf-tensorboard">
  <template>
    <paper-dialog with-backdrop id="settings">
      <h2>Settings</h2>
      <paper-checkbox id="auto-reload-checkbox" checked="{{autoReloadEnabled}}">
        Reload data every <span>[[autoReloadIntervalSecs]]</span>s.
      </paper-checkbox>
      <paper-input id="paginationLimitInput" label="Pagination limit" always-float-label type="number" min="1" step="1" on-change="_paginationLimitChanged" on-value-changed="_paginationLimitValidate"></paper-input>
    </paper-dialog>
    <paper-header-panel>
      <paper-toolbar id="toolbar" slot="header" class="header">
        <div id="toolbar-content" slot="top">
          <template is="dom-if" if="[[!_homePath]]">
            <div class="toolbar-title">[[brand]]</div>
          </template>
          <template is="dom-if" if="[[_homePath]]">
            <a href="[[_homePath]]" rel="noopener noreferrer" class="toolbar-title">[[brand]]</a>
          </template>
          <template is="dom-if" if="[[_activeDashboardsNotLoaded]]">
            <span class="toolbar-message">
              Loading active dashboards…
            </span>
          </template>
          <template is="dom-if" if="[[_activeDashboardsLoaded]]">
            <paper-tabs noink scrollable selected="{{_selectedDashboard}}" attr-for-selected="data-dashboard">
              <template is="dom-repeat" items="[[_dashboardData]]" as="dashboardDatum">
                <template is="dom-if" if="[[_isDashboardActive(disabledDashboards, _activeDashboards, dashboardDatum)]]">
                  <paper-tab data-dashboard$="[[dashboardDatum.plugin]]" title="[[dashboardDatum.tabName]]">
                    [[dashboardDatum.tabName]]
                  </paper-tab>
                </template>
              </template>
            </paper-tabs>
            <template is="dom-if" if="[[_inactiveDashboardsExist(_dashboardData, disabledDashboards, _activeDashboards)]]">
              <paper-dropdown-menu label="INACTIVE" no-label-float noink style="margin-left: 12px">
                <paper-listbox id="inactive-dashboards-menu" slot="dropdown-content" selected="{{_selectedDashboard}}" attr-for-selected="data-dashboard">
                  <template is="dom-repeat" items="[[_dashboardData]]" as="dashboardDatum">
                    <template is="dom-if" if="[[_isDashboardInactive(disabledDashboards, _activeDashboards, dashboardDatum)]]" restamp>
                      <paper-item data-dashboard$="[[dashboardDatum.plugin]]">[[dashboardDatum.tabName]]</paper-item>
                    </template>
                  </template>
                </paper-listbox>
              </paper-dropdown-menu>
            </template>
          </template>
          <div class="global-actions">
            <slot name="injected-header-items"></slot>
            <paper-icon-button id="reload-button" class$="[[_getDataRefreshingClass(_refreshing)]]" disabled$="[[_isReloadDisabled]]" icon="refresh" on-tap="reload" title$="Last updated: [[_lastReloadTimeShort]]"></paper-icon-button>
            <paper-icon-button icon="settings" on-tap="openSettings" id="settings-button"></paper-icon-button>
            <a href="https://github.com/tensorflow/tensorboard/blob/master/README.md" rel="noopener noreferrer" tabindex="-1" target="_blank">
              <paper-icon-button icon="help-outline"></paper-icon-button>
            </a>
          </div>
        </div>
      </paper-toolbar>

      <div id="content-pane" class="fit">
        <slot name="injected-overview"></slot>
        <div id="content">
          <template is="dom-if" if="[[_activeDashboardsFailedToLoad]]">
            <div class="warning-message">
              <h3>Failed to load the set of active dashboards.</h3>
              <p>
                This can occur if the TensorBoard backend is no longer running.
                Perhaps this page is cached?
              

              <p>
                If you think that you’ve fixed the problem, click the reload
                button in the top-right.
                <template is="dom-if" if="[[autoReloadEnabled]]">
                  We’ll try to reload every
                  [[autoReloadIntervalSecs]]&nbsp;seconds as well.
                </template>
              

              <p>
                <i>Last reload: [[_lastReloadTime]]</i>
                <template is="dom-if" if="[[_dataLocation]]">
                  </template><p>
                    <i>Log directory:
                      <span id="data_location">[[_dataLocation]]</span></i>
                  
                
              <p>
            </div>
          </template>
          <template is="dom-if" if="[[_showNoDashboardsMessage]]">
            <div class="warning-message">
              <h3>No dashboards are active for the current data set.</h3>
              <p>Probable causes:
              <ul>
                <li>You haven’t written any data to your event files.</li>
                <li>TensorBoard can’t find your event files.</li>
              </ul>

              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>
                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>
                <i>Last reload: [[_lastReloadTime]]</i>
                <template is="dom-if" if="[[_dataLocation]]">
                  </template><p>
                    <i>Data location:
                      <span id="data_location">[[_dataLocation]]</span></i>
                  
                
              <p>
            </div>
          </template>
          <template is="dom-if" if="[[_showNoSuchDashboardMessage]]">
            <div class="warning-message">
              <h3>
                There’s no dashboard by the name of
                “<tt>[[_selectedDashboard]]</tt>.”
              </h3>
              <template is="dom-if" if="[[_activeDashboardsLoaded]]">
                <p>You can select a dashboard from the list above.

              <p>
                <i>Last reload: [[_lastReloadTime]]</i>
                <template is="dom-if" if="[[_dataLocation]]">
                  </template><p>
                    <i>Data location:
                      <span id="data_location">[[_dataLocation]]</span></i>
                  
                
              <p>
            </template></div>
          </template>
          <template is="dom-repeat" id="dashboards-template" items="[[_dashboardData]]" as="dashboardDatum" on-dom-change="_onTemplateChanged">
            <div class="dashboard-container" data-dashboard$="[[dashboardDatum.plugin]]" data-selected$="[[_selectedStatus(_selectedDashboard, dashboardDatum.plugin)]]">
              
            </div>
          </template>
        </div>
      </div>
    </paper-header-panel>

    <style>
      :host {
        height: 100%;
        display: block;
        background-color: var(--paper-grey-100);
      }

      #toolbar {
        background-color: var(
          --tb-toolbar-background-color,
          var(--tb-orange-strong)
        );
        -webkit-font-smoothing: antialiased;
      }

      .toolbar-title {
        font-size: 20px;
        margin-left: 6px;
        /* Increase clickable area for case where title is an anchor. */
        padding: 4px;
        text-rendering: optimizeLegibility;
        letter-spacing: -0.025em;
        font-weight: 500;
        display: var(--tb-toolbar-title-display, block);
      }

      a.toolbar-title {
        /* Override default anchor color. */
        color: inherit;
        /* Override default anchor text-decoration. */
        text-decoration: none;
      }

      .toolbar-message {
        opacity: 0.7;
        -webkit-font-smoothing: antialiased;
        font-size: 14px;
        font-weight: 500;
      }

      paper-tabs {
        flex-grow: 1;
        width: 100%;
        height: 100%;
        --paper-tabs-selection-bar-color: white;
        --paper-tabs-content: {
          -webkit-font-smoothing: antialiased;
          text-transform: uppercase;
        }
      }

      paper-dropdown-menu {
        --paper-input-container-color: rgba(255, 255, 255, 0.8);
        --paper-input-container-focus-color: white;
        --paper-input-container-input-color: white;
        --paper-dropdown-menu-icon: {
          color: white;
        }
        --paper-dropdown-menu-input: {
          -webkit-font-smoothing: antialiased;
          font-size: 14px;
          font-weight: 500;
        }
        --paper-input-container-label: {
          -webkit-font-smoothing: antialiased;
          font-size: 14px;
          font-weight: 500;
        }
      }

      paper-dropdown-menu paper-item {
        -webkit-font-smoothing: antialiased;
        font-size: 14px;
        font-weight: 500;
        text-transform: uppercase;
      }

      #inactive-dashboards-menu {
        --paper-listbox-background-color: var(
          --tb-toolbar-background-color,
          var(--tb-orange-strong)
        );
        --paper-listbox-color: white;
      }

      .global-actions {
        display: inline-flex; /* Ensure that icons stay aligned */
        justify-content: flex-end;
        align-items: center;
        text-align: right;
        color: white;
      }

      .global-actions a {
        color: white;
      }

      #toolbar-content {
        width: 100%;
        height: 100%;
        display: flex;
        flex-direction: row;
        justify-content: space-between;
        align-items: center;
      }

      #content-pane {
        align-items: stretch;
        display: flex;
        flex-direction: column;
        height: 100%;
        justify-content: stretch;
        width: 100%;
      }

      #content {
        flex: 1 1;
        overflow: hidden;
      }

      .dashboard-container {
        height: 100%;
      }

      /* Hide unselected dashboards. We still display them within a container
         of height 0 since Plottable produces degenerate charts when charts are
         reloaded while not displayed. */
      .dashboard-container:not([data-selected]) {
        max-height: 0;
        overflow: hidden;
        position: relative;
        /** We further make containers invisible. Some elements may anchor to
            the viewport instead of the container, in which case setting the max
            height here to 0 will not hide them. */
        visibility: hidden;
      }

      .dashboard-container iframe {
        border: none;
        height: 100%;
        width: 100%;
      }

      .warning-message {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      [disabled] {
        opacity: 0.2;
        color: white;
      }

      #reload-button.refreshing {
        animation: rotate 2s linear infinite;
      }

      @keyframes rotate {
        0% {
          transform: rotate(0deg);
        }
        50% {
          transform: rotate(180deg);
        }
        100% {
          transform: rotate(360deg);
        }
      }
    </style>
  </template>
  
  
</dom-module>


  <body>
    <tf-tensorboard use-hash brand="TensorBoard"></tf-tensorboard>
  

<script src="index.js"></script>",
+ "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": {
+ "data": "var CLOSURE_NO_DEPS = true;
// Copyright 2006 The Closure Library 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.

/**
 * @fileoverview Bootstrap for the Google JS Library (Closure).
 *
 * In uncompiled mode base.js will attempt to load Closure's deps file, unless
 * the global <code>CLOSURE_NO_DEPS</code> is set to true.  This allows projects
 * to include their own deps file(s) from different locations.
 *
 * Avoid including base.js more than once. This is strictly discouraged and not
 * supported. goog.require(...) won't work properly in that case.
 *
 * @provideGoog
 */


/**
 * @define {boolean} Overridden to true by the compiler.
 */
var COMPILED = false;


/**
 * Base namespace for the Closure library.  Checks to see goog is already
 * defined in the current scope before assigning to prevent clobbering if
 * base.js is loaded more than once.
 *
 * @const
 */
var goog = goog || {};

/**
 * Reference to the global object.
 * https://www.ecma-international.org/ecma-262/9.0/index.html#sec-global-object
 *
 * More info on this implementation here:
 * https://docs.google.com/document/d/1NAeW4Wk7I7FV0Y2tcUFvQdGMc89k2vdgSXInw8_nvCI/edit
 *
 * @const
 * @suppress {undefinedVars} self won't be referenced unless `this` is falsy.
 * @type {!Global}
 */
goog.global =
    // Check `this` first for backwards compatibility.
    // Valid unless running as an ES module or in a function wrapper called
    //   without setting `this` properly.
    // Note that base.js can't usefully be imported as an ES module, but it may
    // be compiled into bundles that are loadable as ES modules.
    this ||
    // https://developer.mozilla.org/en-US/docs/Web/API/Window/self
    // For in-page browser environments and workers.
    self;


/**
 * A hook for overriding the define values in uncompiled mode.
 *
 * In uncompiled mode, `CLOSURE_UNCOMPILED_DEFINES` may be defined before
 * loading base.js.  If a key is defined in `CLOSURE_UNCOMPILED_DEFINES`,
 * `goog.define` will use the value instead of the default value.  This
 * allows flags to be overwritten without compilation (this is normally
 * accomplished with the compiler's "define" flag).
 *
 * Example:
 * <pre>
 *   var CLOSURE_UNCOMPILED_DEFINES = {'goog.DEBUG': false};
 * </pre>
 *
 * @type {Object<string, (string|number|boolean)>|undefined}
 */
goog.global.CLOSURE_UNCOMPILED_DEFINES;


/**
 * A hook for overriding the define values in uncompiled or compiled mode,
 * like CLOSURE_UNCOMPILED_DEFINES but effective in compiled code.  In
 * uncompiled code CLOSURE_UNCOMPILED_DEFINES takes precedence.
 *
 * Also unlike CLOSURE_UNCOMPILED_DEFINES the values must be number, boolean or
 * string literals or the compiler will emit an error.
 *
 * While any @define value may be set, only those set with goog.define will be
 * effective for uncompiled code.
 *
 * Example:
 * <pre>
 *   var CLOSURE_DEFINES = {'goog.DEBUG': false} ;
 * </pre>
 *
 * @type {Object<string, (string|number|boolean)>|undefined}
 */
goog.global.CLOSURE_DEFINES;


/**
 * Returns true if the specified value is not undefined.
 *
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is defined.
 * @deprecated Use `val !== undefined` instead.
 */
goog.isDef = function(val) {
  // void 0 always evaluates to undefined and hence we do not need to depend on
  // the definition of the global variable named 'undefined'.
  return val !== void 0;
};

/**
 * Returns true if the specified value is a string.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a string.
 * @deprecated Use `typeof val === 'string'` instead.
 */
goog.isString = function(val) {
  return typeof val == 'string';
};


/**
 * Returns true if the specified value is a boolean.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is boolean.
 * @deprecated Use `typeof val === 'boolean'` instead.
 */
goog.isBoolean = function(val) {
  return typeof val == 'boolean';
};


/**
 * Returns true if the specified value is a number.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a number.
 * @deprecated Use `typeof val === 'number'` instead.
 */
goog.isNumber = function(val) {
  return typeof val == 'number';
};


/**
 * Builds an object structure for the provided namespace path, ensuring that
 * names that already exist are not overwritten. For example:
 * "a.b.c" -> a = {};a.b={};a.b.c={};
 * Used by goog.provide and goog.exportSymbol.
 * @param {string} name name of the object that this file defines.
 * @param {*=} opt_object the object to expose at the end of the path.
 * @param {Object=} opt_objectToExportTo The object to add the path to; default
 *     is `goog.global`.
 * @private
 */
goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
  var parts = name.split('.');
  var cur = opt_objectToExportTo || goog.global;

  // Internet Explorer exhibits strange behavior when throwing errors from
  // methods externed in this manner.  See the testExportSymbolExceptions in
  // base_test.html for an example.
  if (!(parts[0] in cur) && typeof cur.execScript != 'undefined') {
    cur.execScript('var ' + parts[0]);
  }

  for (var part; parts.length && (part = parts.shift());) {
    if (!parts.length && opt_object !== undefined) {
      // last part and we have an object; use it
      cur[part] = opt_object;
    } else if (cur[part] && cur[part] !== Object.prototype[part]) {
      cur = cur[part];
    } else {
      cur = cur[part] = {};
    }
  }
};


/**
 * Defines a named value. In uncompiled mode, the value is retrieved from
 * CLOSURE_DEFINES or CLOSURE_UNCOMPILED_DEFINES if the object is defined and
 * has the property specified, and otherwise used the defined defaultValue.
 * When compiled the default can be overridden using the compiler options or the
 * value set in the CLOSURE_DEFINES object. Returns the defined value so that it
 * can be used safely in modules. Note that the value type MUST be either
 * boolean, number, or string.
 *
 * @param {string} name The distinguished name to provide.
 * @param {T} defaultValue
 * @return {T} The defined value.
 * @template T
 */
goog.define = function(name, defaultValue) {
  var value = defaultValue;
  if (!COMPILED) {
    var uncompiledDefines = goog.global.CLOSURE_UNCOMPILED_DEFINES;
    var defines = goog.global.CLOSURE_DEFINES;
    if (uncompiledDefines &&
        // Anti DOM-clobbering runtime check (b/37736576).
        /** @type {?} */ (uncompiledDefines).nodeType === undefined &&
        Object.prototype.hasOwnProperty.call(uncompiledDefines, name)) {
      value = uncompiledDefines[name];
    } else if (
        defines &&
        // Anti DOM-clobbering runtime check (b/37736576).
        /** @type {?} */ (defines).nodeType === undefined &&
        Object.prototype.hasOwnProperty.call(defines, name)) {
      value = defines[name];
    }
  }
  return value;
};


/**
 * @define {number} Integer year indicating the set of browser features that are
 * guaranteed to be present.  This is defined to include exactly features that
 * work correctly on all "modern" browsers that are stable on January 1 of the
 * specified year.  For example,
 * ```js
 * if (goog.FEATURESET_YEAR >= 2019) {
 *   // use APIs known to be available on all major stable browsers Jan 1, 2019
 * } else {
 *   // polyfill for older browsers
 * }
 * ```
 * This is intended to be the primary define for removing
 * unnecessary browser compatibility code (such as ponyfills and workarounds),
 * and should inform the default value for most other defines:
 * ```js
 * const ASSUME_NATIVE_PROMISE =
 *     goog.define('ASSUME_NATIVE_PROMISE', goog.FEATURESET_YEAR >= 2016);
 * ```
 *
 * The default assumption is that IE9 is the lowest supported browser, which was
 * first available Jan 1, 2012.
 *
 * TODO(user): Reference more thorough documentation when it's available.
 */
goog.FEATURESET_YEAR = goog.define('goog.FEATURESET_YEAR', 2012);


/**
 * @define {boolean} DEBUG is provided as a convenience so that debugging code
 * that should not be included in a production. It can be easily stripped
 * by specifying --define goog.DEBUG=false to the Closure Compiler aka
 * JSCompiler. For example, most toString() methods should be declared inside an
 * "if (goog.DEBUG)" conditional because they are generally used for debugging
 * purposes and it is difficult for the JSCompiler to statically determine
 * whether they are used.
 */
goog.DEBUG = goog.define('goog.DEBUG', true);


/**
 * @define {string} LOCALE defines the locale being used for compilation. It is
 * used to select locale specific data to be compiled in js binary. BUILD rule
 * can specify this value by "--define goog.LOCALE=<locale_name>" as a compiler
 * option.
 *
 * Take into account that the locale code format is important. You should use
 * the canonical Unicode format with hyphen as a delimiter. Language must be
 * lowercase, Language Script - Capitalized, Region - UPPERCASE.
 * There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.
 *
 * See more info about locale codes here:
 * http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers
 *
 * For language codes you should use values defined by ISO 693-1. See it here
 * http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from
 * this rule: the Hebrew language. For legacy reasons the old code (iw) should
 * be used instead of the new code (he).
 *
 */
goog.LOCALE = goog.define('goog.LOCALE', 'en');  // default to en


/**
 * @define {boolean} Whether this code is running on trusted sites.
 *
 * On untrusted sites, several native functions can be defined or overridden by
 * external libraries like Prototype, Datejs, and JQuery and setting this flag
 * to false forces closure to use its own implementations when possible.
 *
 * If your JavaScript can be loaded by a third party site and you are wary about
 * relying on non-standard implementations, specify
 * "--define goog.TRUSTED_SITE=false" to the compiler.
 */
goog.TRUSTED_SITE = goog.define('goog.TRUSTED_SITE', true);


/**
 * @define {boolean} Whether a project is expected to be running in strict mode.
 *
 * This define can be used to trigger alternate implementations compatible with
 * running in EcmaScript Strict mode or warn about unavailable functionality.
 * @see https://goo.gl/PudQ4y
 *
 */
goog.STRICT_MODE_COMPATIBLE = goog.define('goog.STRICT_MODE_COMPATIBLE', false);


/**
 * @define {boolean} Whether code that calls {@link goog.setTestOnly} should
 *     be disallowed in the compilation unit.
 */
goog.DISALLOW_TEST_ONLY_CODE =
    goog.define('goog.DISALLOW_TEST_ONLY_CODE', COMPILED && !goog.DEBUG);


/**
 * @define {boolean} Whether to use a Chrome app CSP-compliant method for
 *     loading scripts via goog.require. @see appendScriptSrcNode_.
 */
goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING =
    goog.define('goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING', false);


/**
 * Defines a namespace in Closure.
 *
 * A namespace may only be defined once in a codebase. It may be defined using
 * goog.provide() or goog.module().
 *
 * The presence of one or more goog.provide() calls in a file indicates
 * that the file defines the given objects/namespaces.
 * Provided symbols must not be null or undefined.
 *
 * In addition, goog.provide() creates the object stubs for a namespace
 * (for example, goog.provide("goog.foo.bar") will create the object
 * goog.foo.bar if it does not already exist).
 *
 * Build tools also scan for provide/require/module statements
 * to discern dependencies, build dependency files (see deps.js), etc.
 *
 * @see goog.require
 * @see goog.module
 * @param {string} name Namespace provided by this file in the form
 *     "goog.package.part".
 */
goog.provide = function(name) {
  if (goog.isInModuleLoader_()) {
    throw new Error('goog.provide cannot be used within a module.');
  }
  if (!COMPILED) {
    // Ensure that the same namespace isn't provided twice.
    // A goog.module/goog.provide maps a goog.require to a specific file
    if (goog.isProvided_(name)) {
      throw new Error('Namespace "' + name + '" already declared.');
    }
  }

  goog.constructNamespace_(name);
};


/**
 * @param {string} name Namespace provided by this file in the form
 *     "goog.package.part".
 * @param {Object=} opt_obj The object to embed in the namespace.
 * @private
 */
goog.constructNamespace_ = function(name, opt_obj) {
  if (!COMPILED) {
    delete goog.implicitNamespaces_[name];

    var namespace = name;
    while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {
      if (goog.getObjectByName(namespace)) {
        break;
      }
      goog.implicitNamespaces_[namespace] = true;
    }
  }

  goog.exportPath_(name, opt_obj);
};


/**
 * Returns CSP nonce, if set for any script tag.
 * @param {?Window=} opt_window The window context used to retrieve the nonce.
 *     Defaults to global context.
 * @return {string} CSP nonce or empty string if no nonce is present.
 */
goog.getScriptNonce = function(opt_window) {
  if (opt_window && opt_window != goog.global) {
    return goog.getScriptNonce_(opt_window.document);
  }
  if (goog.cspNonce_ === null) {
    goog.cspNonce_ = goog.getScriptNonce_(goog.global.document);
  }
  return goog.cspNonce_;
};


/**
 * According to the CSP3 spec a nonce must be a valid base64 string.
 * @see https://www.w3.org/TR/CSP3/#grammardef-base64-value
 * @private @const
 */
goog.NONCE_PATTERN_ = /^[\w+/_-]+[=]{0,2}$/;


/**
 * @private {?string}
 */
goog.cspNonce_ = null;


/**
 * Returns CSP nonce, if set for any script tag.
 * @param {!Document} doc
 * @return {string} CSP nonce or empty string if no nonce is present.
 * @private
 */
goog.getScriptNonce_ = function(doc) {
  var script = doc.querySelector && doc.querySelector('script[nonce]');
  if (script) {
    // Try to get the nonce from the IDL property first, because browsers that
    // implement additional nonce protection features (currently only Chrome) to
    // prevent nonce stealing via CSS do not expose the nonce via attributes.
    // See https://github.com/whatwg/html/issues/2369
    var nonce = script['nonce'] || script.getAttribute('nonce');
    if (nonce && goog.NONCE_PATTERN_.test(nonce)) {
      return nonce;
    }
  }
  return '';
};


/**
 * Module identifier validation regexp.
 * Note: This is a conservative check, it is very possible to be more lenient,
 *   the primary exclusion here is "/" and "\" and a leading ".", these
 *   restrictions are intended to leave the door open for using goog.require
 *   with relative file paths rather than module identifiers.
 * @private
 */
goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;


/**
 * Defines a module in Closure.
 *
 * Marks that this file must be loaded as a module and claims the namespace.
 *
 * A namespace may only be defined once in a codebase. It may be defined using
 * goog.provide() or goog.module().
 *
 * goog.module() has three requirements:
 * - goog.module may not be used in the same file as goog.provide.
 * - goog.module must be the first statement in the file.
 * - only one goog.module is allowed per file.
 *
 * When a goog.module annotated file is loaded, it is enclosed in
 * a strict function closure. This means that:
 * - any variables declared in a goog.module file are private to the file
 * (not global), though the compiler is expected to inline the module.
 * - The code must obey all the rules of "strict" JavaScript.
 * - the file will be marked as "use strict"
 *
 * NOTE: unlike goog.provide, goog.module does not declare any symbols by
 * itself. If declared symbols are desired, use
 * goog.module.declareLegacyNamespace().
 *
 *
 * See the public goog.module proposal: http://goo.gl/Va1hin
 *
 * @param {string} name Namespace provided by this file in the form
 *     "goog.package.part", is expected but not required.
 * @return {void}
 */
goog.module = function(name) {
  if (typeof name !== 'string' || !name ||
      name.search(goog.VALID_MODULE_RE_) == -1) {
    throw new Error('Invalid module identifier');
  }
  if (!goog.isInGoogModuleLoader_()) {
    throw new Error(
        'Module ' + name + ' has been loaded incorrectly. Note, ' +
        'modules cannot be loaded as normal scripts. They require some kind of ' +
        'pre-processing step. You\'re likely trying to load a module via a ' +
        'script tag or as a part of a concatenated bundle without rewriting the ' +
        'module. For more info see: ' +
        'https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.');
  }
  if (goog.moduleLoaderState_.moduleName) {
    throw new Error('goog.module may only be called once per module.');
  }

  // Store the module name for the loader.
  goog.moduleLoaderState_.moduleName = name;
  if (!COMPILED) {
    // Ensure that the same namespace isn't provided twice.
    // A goog.module/goog.provide maps a goog.require to a specific file
    if (goog.isProvided_(name)) {
      throw new Error('Namespace "' + name + '" already declared.');
    }
    delete goog.implicitNamespaces_[name];
  }
};


/**
 * @param {string} name The module identifier.
 * @return {?} The module exports for an already loaded module or null.
 *
 * Note: This is not an alternative to goog.require, it does not
 * indicate a hard dependency, instead it is used to indicate
 * an optional dependency or to access the exports of a module
 * that has already been loaded.
 * @suppress {missingProvide}
 */
goog.module.get = function(name) {
  return goog.module.getInternal_(name);
};


/**
 * @param {string} name The module identifier.
 * @return {?} The module exports for an already loaded module or null.
 * @private
 */
goog.module.getInternal_ = function(name) {
  if (!COMPILED) {
    if (name in goog.loadedModules_) {
      return goog.loadedModules_[name].exports;
    } else if (!goog.implicitNamespaces_[name]) {
      var ns = goog.getObjectByName(name);
      return ns != null ? ns : null;
    }
  }
  return null;
};


/**
 * Types of modules the debug loader can load.
 * @enum {string}
 */
goog.ModuleType = {
  ES6: 'es6',
  GOOG: 'goog'
};


/**
 * @private {?{
 *   moduleName: (string|undefined),
 *   declareLegacyNamespace:boolean,
 *   type: ?goog.ModuleType
 * }}
 */
goog.moduleLoaderState_ = null;


/**
 * @private
 * @return {boolean} Whether a goog.module or an es6 module is currently being
 *     initialized.
 */
goog.isInModuleLoader_ = function() {
  return goog.isInGoogModuleLoader_() || goog.isInEs6ModuleLoader_();
};


/**
 * @private
 * @return {boolean} Whether a goog.module is currently being initialized.
 */
goog.isInGoogModuleLoader_ = function() {
  return !!goog.moduleLoaderState_ &&
      goog.moduleLoaderState_.type == goog.ModuleType.GOOG;
};


/**
 * @private
 * @return {boolean} Whether an es6 module is currently being initialized.
 */
goog.isInEs6ModuleLoader_ = function() {
  var inLoader = !!goog.moduleLoaderState_ &&
      goog.moduleLoaderState_.type == goog.ModuleType.ES6;

  if (inLoader) {
    return true;
  }

  var jscomp = goog.global['$jscomp'];

  if (jscomp) {
    // jscomp may not have getCurrentModulePath if this is a compiled bundle
    // that has some of the runtime, but not all of it. This can happen if
    // optimizations are turned on so the unused runtime is removed but renaming
    // and Closure pass are off (so $jscomp is still named $jscomp and the
    // goog.provide/require calls still exist).
    if (typeof jscomp.getCurrentModulePath != 'function') {
      return false;
    }

    // Bundled ES6 module.
    return !!jscomp.getCurrentModulePath();
  }

  return false;
};


/**
 * Provide the module's exports as a globally accessible object under the
 * module's declared name.  This is intended to ease migration to goog.module
 * for files that have existing usages.
 * @suppress {missingProvide}
 */
goog.module.declareLegacyNamespace = function() {
  if (!COMPILED && !goog.isInGoogModuleLoader_()) {
    throw new Error(
        'goog.module.declareLegacyNamespace must be called from ' +
        'within a goog.module');
  }
  if (!COMPILED && !goog.moduleLoaderState_.moduleName) {
    throw new Error(
        'goog.module must be called prior to ' +
        'goog.module.declareLegacyNamespace.');
  }
  goog.moduleLoaderState_.declareLegacyNamespace = true;
};


/**
 * Associates an ES6 module with a Closure module ID so that is available via
 * goog.require. The associated ID  acts like a goog.module ID - it does not
 * create any global names, it is merely available via goog.require /
 * goog.module.get / goog.forwardDeclare / goog.requireType. goog.require and
 * goog.module.get will return the entire module as if it was import *'d. This
 * allows Closure files to reference ES6 modules for the sake of migration.
 *
 * @param {string} namespace
 * @suppress {missingProvide}
 */
goog.declareModuleId = function(namespace) {
  if (!COMPILED) {
    if (!goog.isInEs6ModuleLoader_()) {
      throw new Error(
          'goog.declareModuleId may only be called from ' +
          'within an ES6 module');
    }
    if (goog.moduleLoaderState_ && goog.moduleLoaderState_.moduleName) {
      throw new Error(
          'goog.declareModuleId may only be called once per module.');
    }
    if (namespace in goog.loadedModules_) {
      throw new Error(
          'Module with namespace "' + namespace + '" already exists.');
    }
  }
  if (goog.moduleLoaderState_) {
    // Not bundled - debug loading.
    goog.moduleLoaderState_.moduleName = namespace;
  } else {
    // Bundled - not debug loading, no module loader state.
    var jscomp = goog.global['$jscomp'];
    if (!jscomp || typeof jscomp.getCurrentModulePath != 'function') {
      throw new Error(
          'Module with namespace "' + namespace +
          '" has been loaded incorrectly.');
    }
    var exports = jscomp.require(jscomp.getCurrentModulePath());
    goog.loadedModules_[namespace] = {
      exports: exports,
      type: goog.ModuleType.ES6,
      moduleId: namespace
    };
  }
};


/**
 * Marks that the current file should only be used for testing, and never for
 * live code in production.
 *
 * In the case of unit tests, the message may optionally be an exact namespace
 * for the test (e.g. 'goog.stringTest'). The linter will then ignore the extra
 * provide (if not explicitly defined in the code).
 *
 * @param {string=} opt_message Optional message to add to the error that's
 *     raised when used in production code.
 */
goog.setTestOnly = function(opt_message) {
  if (goog.DISALLOW_TEST_ONLY_CODE) {
    opt_message = opt_message || '';
    throw new Error(
        'Importing test-only code into non-debug environment' +
        (opt_message ? ': ' + opt_message : '.'));
  }
};


/**
 * Forward declares a symbol. This is an indication to the compiler that the
 * symbol may be used in the source yet is not required and may not be provided
 * in compilation.
 *
 * The most common usage of forward declaration is code that takes a type as a
 * function parameter but does not need to require it. By forward declaring
 * instead of requiring, no hard dependency is made, and (if not required
 * elsewhere) the namespace may never be required and thus, not be pulled
 * into the JavaScript binary. If it is required elsewhere, it will be type
 * checked as normal.
 *
 * Before using goog.forwardDeclare, please read the documentation at
 * https://github.com/google/closure-compiler/wiki/Bad-Type-Annotation to
 * understand the options and tradeoffs when working with forward declarations.
 *
 * @param {string} name The namespace to forward declare in the form of
 *     "goog.package.part".
 */
goog.forwardDeclare = function(name) {};


/**
 * Forward declare type information. Used to assign types to goog.global
 * referenced object that would otherwise result in unknown type references
 * and thus block property disambiguation.
 */
goog.forwardDeclare('Document');
goog.forwardDeclare('HTMLScriptElement');
goog.forwardDeclare('XMLHttpRequest');


if (!COMPILED) {
  /**
   * Check if the given name has been goog.provided. This will return false for
   * names that are available only as implicit namespaces.
   * @param {string} name name of the object to look for.
   * @return {boolean} Whether the name has been provided.
   * @private
   */
  goog.isProvided_ = function(name) {
    return (name in goog.loadedModules_) ||
        (!goog.implicitNamespaces_[name] && goog.getObjectByName(name) != null);
  };

  /**
   * Namespaces implicitly defined by goog.provide. For example,
   * goog.provide('goog.events.Event') implicitly declares that 'goog' and
   * 'goog.events' must be namespaces.
   *
   * @type {!Object<string, (boolean|undefined)>}
   * @private
   */
  goog.implicitNamespaces_ = {'goog.module': true};

  // NOTE: We add goog.module as an implicit namespace as goog.module is defined
  // here and because the existing module package has not been moved yet out of
  // the goog.module namespace. This satisifies both the debug loader and
  // ahead-of-time dependency management.
}


/**
 * Returns an object based on its fully qualified external name.  The object
 * is not found if null or undefined.  If you are using a compilation pass that
 * renames property names beware that using this function will not find renamed
 * properties.
 *
 * @param {string} name The fully qualified name.
 * @param {Object=} opt_obj The object within which to look; default is
 *     |goog.global|.
 * @return {?} The value (object or primitive) or, if not found, null.
 */
goog.getObjectByName = function(name, opt_obj) {
  var parts = name.split('.');
  var cur = opt_obj || goog.global;
  for (var i = 0; i < parts.length; i++) {
    cur = cur[parts[i]];
    if (cur == null) {
      return null;
    }
  }
  return cur;
};


/**
 * Globalizes a whole namespace, such as goog or goog.lang.
 *
 * @param {!Object} obj The namespace to globalize.
 * @param {Object=} opt_global The object to add the properties to.
 * @deprecated Properties may be explicitly exported to the global scope, but
 *     this should no longer be done in bulk.
 */
goog.globalize = function(obj, opt_global) {
  var global = opt_global || goog.global;
  for (var x in obj) {
    global[x] = obj[x];
  }
};


/**
 * Adds a dependency from a file to the files it requires.
 * @param {string} relPath The path to the js file.
 * @param {!Array<string>} provides An array of strings with
 *     the names of the objects this file provides.
 * @param {!Array<string>} requires An array of strings with
 *     the names of the objects this file requires.
 * @param {boolean|!Object<string>=} opt_loadFlags Parameters indicating
 *     how the file must be loaded.  The boolean 'true' is equivalent
 *     to {'module': 'goog'} for backwards-compatibility.  Valid properties
 *     and values include {'module': 'goog'} and {'lang': 'es6'}.
 */
goog.addDependency = function(relPath, provides, requires, opt_loadFlags) {
  if (!COMPILED && goog.DEPENDENCIES_ENABLED) {
    goog.debugLoader_.addDependency(relPath, provides, requires, opt_loadFlags);
  }
};




// NOTE(nnaze): The debug DOM loader was included in base.js as an original way
// to do "debug-mode" development.  The dependency system can sometimes be
// confusing, as can the debug DOM loader's asynchronous nature.
//
// With the DOM loader, a call to goog.require() is not blocking -- the script
// will not load until some point after the current script.  If a namespace is
// needed at runtime, it needs to be defined in a previous script, or loaded via
// require() with its registered dependencies.
//
// User-defined namespaces may need their own deps file. For a reference on
// creating a deps file, see:
// Externally: https://developers.google.com/closure/library/docs/depswriter
//
// Because of legacy clients, the DOM loader can't be easily removed from
// base.js.  Work was done to make it disableable or replaceable for
// different environments (DOM-less JavaScript interpreters like Rhino or V8,
// for example). See bootstrap/ for more information.


/**
 * @define {boolean} Whether to enable the debug loader.
 *
 * If enabled, a call to goog.require() will attempt to load the namespace by
 * appending a script tag to the DOM (if the namespace has been registered).
 *
 * If disabled, goog.require() will simply assert that the namespace has been
 * provided (and depend on the fact that some outside tool correctly ordered
 * the script).
 */
goog.ENABLE_DEBUG_LOADER = goog.define('goog.ENABLE_DEBUG_LOADER', true);


/**
 * @param {string} msg
 * @private
 */
goog.logToConsole_ = function(msg) {
  if (goog.global.console) {
    goog.global.console['error'](msg);
  }
};


/**
 * Implements a system for the dynamic resolution of dependencies that works in
 * parallel with the BUILD system.
 *
 * Note that all calls to goog.require will be stripped by the compiler.
 *
 * @see goog.provide
 * @param {string} namespace Namespace (as was given in goog.provide,
 *     goog.module, or goog.declareModuleId) in the form
 *     "goog.package.part".
 * @return {?} If called within a goog.module or ES6 module file, the associated
 *     namespace or module otherwise null.
 */
goog.require = function(namespace) {
  if (!COMPILED) {
    // Might need to lazy load on old IE.
    if (goog.ENABLE_DEBUG_LOADER) {
      goog.debugLoader_.requested(namespace);
    }

    // If the object already exists we do not need to do anything.
    if (goog.isProvided_(namespace)) {
      if (goog.isInModuleLoader_()) {
        return goog.module.getInternal_(namespace);
      }
    } else if (goog.ENABLE_DEBUG_LOADER) {
      var moduleLoaderState = goog.moduleLoaderState_;
      goog.moduleLoaderState_ = null;
      try {
        goog.debugLoader_.load_(namespace);
      } finally {
        goog.moduleLoaderState_ = moduleLoaderState;
      }
    }

    return null;
  }
};


/**
 * Requires a symbol for its type information. This is an indication to the
 * compiler that the symbol may appear in type annotations, yet it is not
 * referenced at runtime.
 *
 * When called within a goog.module or ES6 module file, the return value may be
 * assigned to or destructured into a variable, but it may not be otherwise used
 * in code outside of a type annotation.
 *
 * Note that all calls to goog.requireType will be stripped by the compiler.
 *
 * @param {string} namespace Namespace (as was given in goog.provide,
 *     goog.module, or goog.declareModuleId) in the form
 *     "goog.package.part".
 * @return {?}
 */
goog.requireType = function(namespace) {
  // Return an empty object so that single-level destructuring of the return
  // value doesn't crash at runtime when using the debug loader. Multi-level
  // destructuring isn't supported.
  return {};
};


/**
 * Path for included scripts.
 * @type {string}
 */
goog.basePath = '';


/**
 * A hook for overriding the base path.
 * @type {string|undefined}
 */
goog.global.CLOSURE_BASE_PATH;


/**
 * Whether to attempt to load Closure's deps file. By default, when uncompiled,
 * deps files will attempt to be loaded.
 * @type {boolean|undefined}
 */
goog.global.CLOSURE_NO_DEPS;


/**
 * A function to import a single script. This is meant to be overridden when
 * Closure is being run in non-HTML contexts, such as web workers. It's defined
 * in the global scope so that it can be set before base.js is loaded, which
 * allows deps.js to be imported properly.
 *
 * The first parameter the script source, which is a relative URI. The second,
 * optional parameter is the script contents, in the event the script needed
 * transformation. It should return true if the script was imported, false
 * otherwise.
 * @type {(function(string, string=): boolean)|undefined}
 */
goog.global.CLOSURE_IMPORT_SCRIPT;


/**
 * Null function used for default values of callbacks, etc.
 * @return {void} Nothing.
 */
goog.nullFunction = function() {};


/**
 * When defining a class Foo with an abstract method bar(), you can do:
 * Foo.prototype.bar = goog.abstractMethod
 *
 * Now if a subclass of Foo fails to override bar(), an error will be thrown
 * when bar() is invoked.
 *
 * @type {!Function}
 * @throws {Error} when invoked to indicate the method should be overridden.
 * @deprecated Use "@abstract" annotation instead of goog.abstractMethod in new
 *     code. See
 *     https://github.com/google/closure-compiler/wiki/@abstract-classes-and-methods
 */
goog.abstractMethod = function() {
  throw new Error('unimplemented abstract method');
};


/**
 * Adds a `getInstance` static method that always returns the same
 * instance object.
 * @param {!Function} ctor The constructor for the class to add the static
 *     method to.
 * @suppress {missingProperties} 'instance_' isn't a property on 'Function'
 *     but we don't have a better type to use here.
 */
goog.addSingletonGetter = function(ctor) {
  // instance_ is immediately set to prevent issues with sealed constructors
  // such as are encountered when a constructor is returned as the export object
  // of a goog.module in unoptimized code.
  // Delcare type to avoid conformance violations that ctor.instance_ is unknown
  /** @type {undefined|!Object} @suppress {underscore} */
  ctor.instance_ = undefined;
  ctor.getInstance = function() {
    if (ctor.instance_) {
      return ctor.instance_;
    }
    if (goog.DEBUG) {
      // NOTE: JSCompiler can't optimize away Array#push.
      goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;
    }
    // Cast to avoid conformance violations that ctor.instance_ is unknown
    return /** @type {!Object|undefined} */ (ctor.instance_) = new ctor;
  };
};


/**
 * All singleton classes that have been instantiated, for testing. Don't read
 * it directly, use the `goog.testing.singleton` module. The compiler
 * removes this variable if unused.
 * @type {!Array<!Function>}
 * @private
 */
goog.instantiatedSingletons_ = [];


/**
 * @define {boolean} Whether to load goog.modules using `eval` when using
 * the debug loader.  This provides a better debugging experience as the
 * source is unmodified and can be edited using Chrome Workspaces or similar.
 * However in some environments the use of `eval` is banned
 * so we provide an alternative.
 */
goog.LOAD_MODULE_USING_EVAL = goog.define('goog.LOAD_MODULE_USING_EVAL', true);


/**
 * @define {boolean} Whether the exports of goog.modules should be sealed when
 * possible.
 */
goog.SEAL_MODULE_EXPORTS = goog.define('goog.SEAL_MODULE_EXPORTS', goog.DEBUG);


/**
 * The registry of initialized modules:
 * The module identifier or path to module exports map.
 * @private @const {!Object<string, {exports:?,type:string,moduleId:string}>}
 */
goog.loadedModules_ = {};


/**
 * True if the debug loader enabled and used.
 * @const {boolean}
 */
goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;


/**
 * @define {string} How to decide whether to transpile.  Valid values
 * are 'always', 'never', and 'detect'.  The default ('detect') is to
 * use feature detection to determine which language levels need
 * transpilation.
 */
// NOTE(sdh): we could expand this to accept a language level to bypass
// detection: e.g. goog.TRANSPILE == 'es5' would transpile ES6 files but
// would leave ES3 and ES5 files alone.
goog.TRANSPILE = goog.define('goog.TRANSPILE', 'detect');

/**
 * @define {boolean} If true assume that ES modules have already been
 * transpiled by the jscompiler (in the same way that transpile.js would
 * transpile them - to jscomp modules). Useful only for servers that wish to use
 * the debug loader and transpile server side. Thus this is only respected if
 * goog.TRANSPILE is "never".
 */
goog.ASSUME_ES_MODULES_TRANSPILED =
    goog.define('goog.ASSUME_ES_MODULES_TRANSPILED', false);


/**
 * @define {string} If a file needs to be transpiled what the output language
 * should be. By default this is the highest language level this file detects
 * the current environment supports. Generally this flag should not be set, but
 * it could be useful to override. Example: If the current environment supports
 * ES6 then by default ES7+ files will be transpiled to ES6, unless this is
 * overridden.
 *
 * Valid values include: es3, es5, es6, es7, and es8. Anything not recognized
 * is treated as es3.
 *
 * Note that setting this value does not force transpilation. Just if
 * transpilation occurs this will be the output. So this is most useful when
 * goog.TRANSPILE is set to 'always' and then forcing the language level to be
 * something lower than what the environment detects.
 */
goog.TRANSPILE_TO_LANGUAGE = goog.define('goog.TRANSPILE_TO_LANGUAGE', '');


/**
 * @define {string} Path to the transpiler.  Executing the script at this
 * path (relative to base.js) should define a function $jscomp.transpile.
 */
goog.TRANSPILER = goog.define('goog.TRANSPILER', 'transpile.js');


/**
 * @package {?boolean}
 * Visible for testing.
 */
goog.hasBadLetScoping = null;


/**
 * @return {boolean}
 * @package Visible for testing.
 */
goog.useSafari10Workaround = function() {
  if (goog.hasBadLetScoping == null) {
    var hasBadLetScoping;
    try {
      hasBadLetScoping = !eval(
          '"use strict";' +
          'let x = 1; function f() { return typeof x; };' +
          'f() == "number";');
    } catch (e) {
      // Assume that ES6 syntax isn't supported.
      hasBadLetScoping = false;
    }
    goog.hasBadLetScoping = hasBadLetScoping;
  }
  return goog.hasBadLetScoping;
};


/**
 * @param {string} moduleDef
 * @return {string}
 * @package Visible for testing.
 */
goog.workaroundSafari10EvalBug = function(moduleDef) {
  return '(function(){' + moduleDef +
      '\n' +  // Terminate any trailing single line comment.
      ';' +   // Terminate any trailing expression.
      '})();\n';
};


/**
 * @param {function(?):?|string} moduleDef The module definition.
 */
goog.loadModule = function(moduleDef) {
  // NOTE: we allow function definitions to be either in the from
  // of a string to eval (which keeps the original source intact) or
  // in a eval forbidden environment (CSP) we allow a function definition
  // which in its body must call `goog.module`, and return the exports
  // of the module.
  var previousState = goog.moduleLoaderState_;
  try {
    goog.moduleLoaderState_ = {
      moduleName: '',
      declareLegacyNamespace: false,
      type: goog.ModuleType.GOOG
    };
    var exports;
    if (goog.isFunction(moduleDef)) {
      exports = moduleDef.call(undefined, {});
    } else if (typeof moduleDef === 'string') {
      if (goog.useSafari10Workaround()) {
        moduleDef = goog.workaroundSafari10EvalBug(moduleDef);
      }

      exports = goog.loadModuleFromSource_.call(undefined, moduleDef);
    } else {
      throw new Error('Invalid module definition');
    }

    var moduleName = goog.moduleLoaderState_.moduleName;
    if (typeof moduleName === 'string' && moduleName) {
      // Don't seal legacy namespaces as they may be used as a parent of
      // another namespace
      if (goog.moduleLoaderState_.declareLegacyNamespace) {
        goog.constructNamespace_(moduleName, exports);
      } else if (
          goog.SEAL_MODULE_EXPORTS && Object.seal &&
          typeof exports == 'object' && exports != null) {
        Object.seal(exports);
      }

      var data = {
        exports: exports,
        type: goog.ModuleType.GOOG,
        moduleId: goog.moduleLoaderState_.moduleName
      };
      goog.loadedModules_[moduleName] = data;
    } else {
      throw new Error('Invalid module name \"' + moduleName + '\"');
    }
  } finally {
    goog.moduleLoaderState_ = previousState;
  }
};


/**
 * @private @const
 */
goog.loadModuleFromSource_ = /** @type {function(string):?} */ (function() {
  // NOTE: we avoid declaring parameters or local variables here to avoid
  // masking globals or leaking values into the module definition.
  'use strict';
  var exports = {};
  eval(arguments[0]);
  return exports;
});


/**
 * Normalize a file path by removing redundant ".." and extraneous "." file
 * path components.
 * @param {string} path
 * @return {string}
 * @private
 */
goog.normalizePath_ = function(path) {
  var components = path.split('/');
  var i = 0;
  while (i < components.length) {
    if (components[i] == '.') {
      components.splice(i, 1);
    } else if (
        i && components[i] == '..' && components[i - 1] &&
        components[i - 1] != '..') {
      components.splice(--i, 2);
    } else {
      i++;
    }
  }
  return components.join('/');
};


/**
 * Provides a hook for loading a file when using Closure's goog.require() API
 * with goog.modules.  In particular this hook is provided to support Node.js.
 *
 * @type {(function(string):string)|undefined}
 */
goog.global.CLOSURE_LOAD_FILE_SYNC;


/**
 * Loads file by synchronous XHR. Should not be used in production environments.
 * @param {string} src Source URL.
 * @return {?string} File contents, or null if load failed.
 * @private
 */
goog.loadFileSync_ = function(src) {
  if (goog.global.CLOSURE_LOAD_FILE_SYNC) {
    return goog.global.CLOSURE_LOAD_FILE_SYNC(src);
  } else {
    try {
      /** @type {XMLHttpRequest} */
      var xhr = new goog.global['XMLHttpRequest']();
      xhr.open('get', src, false);
      xhr.send();
      // NOTE: Successful http: requests have a status of 200, but successful
      // file: requests may have a status of zero.  Any other status, or a
      // thrown exception (particularly in case of file: requests) indicates
      // some sort of error, which we treat as a missing or unavailable file.
      return xhr.status == 0 || xhr.status == 200 ? xhr.responseText : null;
    } catch (err) {
      // No need to rethrow or log, since errors should show up on their own.
      return null;
    }
  }
};


/**
 * Lazily retrieves the transpiler and applies it to the source.
 * @param {string} code JS code.
 * @param {string} path Path to the code.
 * @param {string} target Language level output.
 * @return {string} The transpiled code.
 * @private
 */
goog.transpile_ = function(code, path, target) {
  var jscomp = goog.global['$jscomp'];
  if (!jscomp) {
    goog.global['$jscomp'] = jscomp = {};
  }
  var transpile = jscomp.transpile;
  if (!transpile) {
    var transpilerPath = goog.basePath + goog.TRANSPILER;
    var transpilerCode = goog.loadFileSync_(transpilerPath);
    if (transpilerCode) {
      // This must be executed synchronously, since by the time we know we
      // need it, we're about to load and write the ES6 code synchronously,
      // so a normal script-tag load will be too slow. Wrapped in a function
      // so that code is eval'd in the global scope.
      (function() {
        (0, eval)(transpilerCode + '\n//# sourceURL=' + transpilerPath);
      }).call(goog.global);
      // Even though the transpiler is optional, if $gwtExport is found, it's
      // a sign the transpiler was loaded and the $jscomp.transpile *should*
      // be there.
      if (goog.global['$gwtExport'] && goog.global['$gwtExport']['$jscomp'] &&
          !goog.global['$gwtExport']['$jscomp']['transpile']) {
        throw new Error(
            'The transpiler did not properly export the "transpile" ' +
            'method. $gwtExport: ' + JSON.stringify(goog.global['$gwtExport']));
      }
      // transpile.js only exports a single $jscomp function, transpile. We
      // grab just that and add it to the existing definition of $jscomp which
      // contains the polyfills.
      goog.global['$jscomp'].transpile =
          goog.global['$gwtExport']['$jscomp']['transpile'];
      jscomp = goog.global['$jscomp'];
      transpile = jscomp.transpile;
    }
  }
  if (!transpile) {
    // The transpiler is an optional component.  If it's not available then
    // replace it with a pass-through function that simply logs.
    var suffix = ' requires transpilation but no transpiler was found.';
    transpile = jscomp.transpile = function(code, path) {
      // TODO(sdh): figure out some way to get this error to show up
      // in test results, noting that the failure may occur in many
      // different ways, including in loadModule() before the test
      // runner even comes up.
      goog.logToConsole_(path + suffix);
      return code;
    };
  }
  // Note: any transpilation errors/warnings will be logged to the console.
  return transpile(code, path, target);
};

//==============================================================================
// Language Enhancements
//==============================================================================


/**
 * This is a "fixed" version of the typeof operator.  It differs from the typeof
 * operator in such a way that null returns 'null' and arrays return 'array'.
 * @param {?} value The value to get the type of.
 * @return {string} The name of the type.
 */
goog.typeOf = function(value) {
  var s = typeof value;
  if (s == 'object') {
    if (value) {
      // Check these first, so we can avoid calling Object.prototype.toString if
      // possible.
      //
      // IE improperly marshals typeof across execution contexts, but a
      // cross-context object will still return false for "instanceof Object".
      if (value instanceof Array) {
        return 'array';
      } else if (value instanceof Object) {
        return s;
      }

      // HACK: In order to use an Object prototype method on the arbitrary
      //   value, the compiler requires the value be cast to type Object,
      //   even though the ECMA spec explicitly allows it.
      var className = Object.prototype.toString.call(
          /** @type {!Object} */ (value));
      // In Firefox 3.6, attempting to access iframe window objects' length
      // property throws an NS_ERROR_FAILURE, so we need to special-case it
      // here.
      if (className == '[object Window]') {
        return 'object';
      }

      // We cannot always use constructor == Array or instanceof Array because
      // different frames have different Array objects. In IE6, if the iframe
      // where the array was created is destroyed, the array loses its
      // prototype. Then dereferencing val.splice here throws an exception, so
      // we can't use goog.isFunction. Calling typeof directly returns 'unknown'
      // so that will work. In this case, this function will return false and
      // most array functions will still work because the array is still
      // array-like (supports length and []) even though it has lost its
      // prototype.
      // Mark Miller noticed that Object.prototype.toString
      // allows access to the unforgeable [[Class]] property.
      //  15.2.4.2 Object.prototype.toString ( )
      //  When the toString method is called, the following steps are taken:
      //      1. Get the [[Class]] property of this object.
      //      2. Compute a string value by concatenating the three strings
      //         "[object ", Result(1), and "]".
      //      3. Return Result(2).
      // and this behavior survives the destruction of the execution context.
      if ((className == '[object Array]' ||
           // In IE all non value types are wrapped as objects across window
           // boundaries (not iframe though) so we have to do object detection
           // for this edge case.
           typeof value.length == 'number' &&
               typeof value.splice != 'undefined' &&
               typeof value.propertyIsEnumerable != 'undefined' &&
               !value.propertyIsEnumerable('splice')

               )) {
        return 'array';
      }
      // HACK: There is still an array case that fails.
      //     function ArrayImpostor() {}
      //     ArrayImpostor.prototype = [];
      //     var impostor = new ArrayImpostor;
      // this can be fixed by getting rid of the fast path
      // (value instanceof Array) and solely relying on
      // (value && Object.prototype.toString.vall(value) === '[object Array]')
      // but that would require many more function calls and is not warranted
      // unless closure code is receiving objects from untrusted sources.

      // IE in cross-window calls does not correctly marshal the function type
      // (it appears just as an object) so we cannot use just typeof val ==
      // 'function'. However, if the object has a call property, it is a
      // function.
      if ((className == '[object Function]' ||
           typeof value.call != 'undefined' &&
               typeof value.propertyIsEnumerable != 'undefined' &&
               !value.propertyIsEnumerable('call'))) {
        return 'function';
      }

    } else {
      return 'null';
    }

  } else if (s == 'function' && typeof value.call == 'undefined') {
    // In Safari typeof nodeList returns 'function', and on Firefox typeof
    // behaves similarly for HTML{Applet,Embed,Object}, Elements and RegExps. We
    // would like to return object for those and we can detect an invalid
    // function by making sure that the function object has a call method.
    return 'object';
  }
  return s;
};


/**
 * Returns true if the specified value is null.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is null.
 * @deprecated Use `val === null` instead.
 */
goog.isNull = function(val) {
  return val === null;
};


/**
 * Returns true if the specified value is defined and not null.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is defined and not null.
 * @deprecated Use `val != null` instead.
 */
goog.isDefAndNotNull = function(val) {
  // Note that undefined == null.
  return val != null;
};


/**
 * Returns true if the specified value is an array.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is an array.
 */
goog.isArray = function(val) {
  return goog.typeOf(val) == 'array';
};


/**
 * Returns true if the object looks like an array. To qualify as array like
 * the value needs to be either a NodeList or an object with a Number length
 * property. Note that for this function neither strings nor functions are
 * considered "array-like".
 *
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is an array.
 */
goog.isArrayLike = function(val) {
  var type = goog.typeOf(val);
  // We do not use goog.isObject here in order to exclude function values.
  return type == 'array' || type == 'object' && typeof val.length == 'number';
};


/**
 * Returns true if the object looks like a Date. To qualify as Date-like the
 * value needs to be an object and have a getFullYear() function.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a like a Date.
 */
goog.isDateLike = function(val) {
  return goog.isObject(val) && typeof val.getFullYear == 'function';
};


/**
 * Returns true if the specified value is a function.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a function.
 */
goog.isFunction = function(val) {
  return goog.typeOf(val) == 'function';
};


/**
 * Returns true if the specified value is an object.  This includes arrays and
 * functions.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is an object.
 */
goog.isObject = function(val) {
  var type = typeof val;
  return type == 'object' && val != null || type == 'function';
  // return Object(val) === val also works, but is slower, especially if val is
  // not an object.
};


/**
 * Gets a unique ID for an object. This mutates the object so that further calls
 * with the same object as a parameter returns the same value. The unique ID is
 * guaranteed to be unique across the current session amongst objects that are
 * passed into `getUid`. There is no guarantee that the ID is unique or
 * consistent across sessions. It is unsafe to generate unique ID for function
 * prototypes.
 *
 * @param {Object} obj The object to get the unique ID for.
 * @return {number} The unique ID for the object.
 */
goog.getUid = function(obj) {
  // TODO(arv): Make the type stricter, do not accept null.

  // In Opera window.hasOwnProperty exists but always returns false so we avoid
  // using it. As a consequence the unique ID generated for BaseClass.prototype
  // and SubClass.prototype will be the same.
  // TODO(b/141512323): UUIDs are broken for ctors with class-side inheritance.
  return obj[goog.UID_PROPERTY_] ||
      (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);
};


/**
 * Whether the given object is already assigned a unique ID.
 *
 * This does not modify the object.
 *
 * @param {!Object} obj The object to check.
 * @return {boolean} Whether there is an assigned unique id for the object.
 */
goog.hasUid = function(obj) {
  return !!obj[goog.UID_PROPERTY_];
};


/**
 * Removes the unique ID from an object. This is useful if the object was
 * previously mutated using `goog.getUid` in which case the mutation is
 * undone.
 * @param {Object} obj The object to remove the unique ID field from.
 */
goog.removeUid = function(obj) {
  // TODO(arv): Make the type stricter, do not accept null.

  // In IE, DOM nodes are not instances of Object and throw an exception if we
  // try to delete.  Instead we try to use removeAttribute.
  if (obj !== null && 'removeAttribute' in obj) {
    obj.removeAttribute(goog.UID_PROPERTY_);
  }

  try {
    delete obj[goog.UID_PROPERTY_];
  } catch (ex) {
  }
};


/**
 * Name for unique ID property. Initialized in a way to help avoid collisions
 * with other closure JavaScript on the same page.
 * @type {string}
 * @private
 */
goog.UID_PROPERTY_ = 'closure_uid_' + ((Math.random() * 1e9) >>> 0);


/**
 * Counter for UID.
 * @type {number}
 * @private
 */
goog.uidCounter_ = 0;


/**
 * Adds a hash code field to an object. The hash code is unique for the
 * given object.
 * @param {Object} obj The object to get the hash code for.
 * @return {number} The hash code for the object.
 * @deprecated Use goog.getUid instead.
 */
goog.getHashCode = goog.getUid;


/**
 * Removes the hash code field from an object.
 * @param {Object} obj The object to remove the field from.
 * @deprecated Use goog.removeUid instead.
 */
goog.removeHashCode = goog.removeUid;


/**
 * Clones a value. The input may be an Object, Array, or basic type. Objects and
 * arrays will be cloned recursively.
 *
 * WARNINGS:
 * <code>goog.cloneObject</code> does not detect reference loops. Objects that
 * refer to themselves will cause infinite recursion.
 *
 * <code>goog.cloneObject</code> is unaware of unique identifiers, and copies
 * UIDs created by <code>getUid</code> into cloned results.
 *
 * @param {*} obj The value to clone.
 * @return {*} A clone of the input value.
 * @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.
 */
goog.cloneObject = function(obj) {
  var type = goog.typeOf(obj);
  if (type == 'object' || type == 'array') {
    if (typeof obj.clone === 'function') {
      return obj.clone();
    }
    var clone = type == 'array' ? [] : {};
    for (var key in obj) {
      clone[key] = goog.cloneObject(obj[key]);
    }
    return clone;
  }

  return obj;
};


/**
 * A native implementation of goog.bind.
 * @param {?function(this:T, ...)} fn A function to partially apply.
 * @param {T} selfObj Specifies the object which this should point to when the
 *     function is run.
 * @param {...*} var_args Additional arguments that are partially applied to the
 *     function.
 * @return {!Function} A partially-applied form of the function goog.bind() was
 *     invoked as a method of.
 * @template T
 * @private
 */
goog.bindNative_ = function(fn, selfObj, var_args) {
  return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));
};


/**
 * A pure-JS implementation of goog.bind.
 * @param {?function(this:T, ...)} fn A function to partially apply.
 * @param {T} selfObj Specifies the object which this should point to when the
 *     function is run.
 * @param {...*} var_args Additional arguments that are partially applied to the
 *     function.
 * @return {!Function} A partially-applied form of the function goog.bind() was
 *     invoked as a method of.
 * @template T
 * @private
 */
goog.bindJs_ = function(fn, selfObj, var_args) {
  if (!fn) {
    throw new Error();
  }

  if (arguments.length > 2) {
    var boundArgs = Array.prototype.slice.call(arguments, 2);
    return function() {
      // Prepend the bound arguments to the current arguments.
      var newArgs = Array.prototype.slice.call(arguments);
      Array.prototype.unshift.apply(newArgs, boundArgs);
      return fn.apply(selfObj, newArgs);
    };

  } else {
    return function() {
      return fn.apply(selfObj, arguments);
    };
  }
};


/**
 * Partially applies this function to a particular 'this object' and zero or
 * more arguments. The result is a new function with some arguments of the first
 * function pre-filled and the value of this 'pre-specified'.
 *
 * Remaining arguments specified at call-time are appended to the pre-specified
 * ones.
 *
 * Also see: {@link #partial}.
 *
 * Usage:
 * <pre>var barMethBound = goog.bind(myFunction, myObj, 'arg1', 'arg2');
 * barMethBound('arg3', 'arg4');</pre>
 *
 * @param {?function(this:T, ...)} fn A function to partially apply.
 * @param {T} selfObj Specifies the object which this should point to when the
 *     function is run.
 * @param {...*} var_args Additional arguments that are partially applied to the
 *     function.
 * @return {!Function} A partially-applied form of the function goog.bind() was
 *     invoked as a method of.
 * @template T
 * @suppress {deprecated} See above.
 */
goog.bind = function(fn, selfObj, var_args) {
  // TODO(nicksantos): narrow the type signature.
  if (Function.prototype.bind &&
      // NOTE(nicksantos): Somebody pulled base.js into the default Chrome
      // extension environment. This means that for Chrome extensions, they get
      // the implementation of Function.prototype.bind that calls goog.bind
      // instead of the native one. Even worse, we don't want to introduce a
      // circular dependency between goog.bind and Function.prototype.bind, so
      // we have to hack this to make sure it works correctly.
      Function.prototype.bind.toString().indexOf('native code') != -1) {
    goog.bind = goog.bindNative_;
  } else {
    goog.bind = goog.bindJs_;
  }
  return goog.bind.apply(null, arguments);
};


/**
 * Like goog.bind(), except that a 'this object' is not required. Useful when
 * the target function is already bound.
 *
 * Usage:
 * var g = goog.partial(f, arg1, arg2);
 * g(arg3, arg4);
 *
 * @param {Function} fn A function to partially apply.
 * @param {...*} var_args Additional arguments that are partially applied to fn.
 * @return {!Function} A partially-applied form of the function goog.partial()
 *     was invoked as a method of.
 */
goog.partial = function(fn, var_args) {
  var args = Array.prototype.slice.call(arguments, 1);
  return function() {
    // Clone the array (with slice()) and append additional arguments
    // to the existing arguments.
    var newArgs = args.slice();
    newArgs.push.apply(newArgs, arguments);
    return fn.apply(/** @type {?} */ (this), newArgs);
  };
};


/**
 * Copies all the members of a source object to a target object. This method
 * does not work on all browsers for all objects that contain keys such as
 * toString or hasOwnProperty. Use goog.object.extend for this purpose.
 *
 * NOTE: Some have advocated for the use of goog.mixin to setup classes
 * with multiple inheritence (traits, mixins, etc).  However, as it simply
 * uses "for in", this is not compatible with ES6 classes whose methods are
 * non-enumerable.  Changing this, would break cases where non-enumerable
 * properties are not expected.
 *
 * @param {Object} target Target.
 * @param {Object} source Source.
 * @deprecated Prefer Object.assign
 */
goog.mixin = function(target, source) {
  for (var x in source) {
    target[x] = source[x];
  }

  // For IE7 or lower, the for-in-loop does not contain any properties that are
  // not enumerable on the prototype object (for example, isPrototypeOf from
  // Object.prototype) but also it will not include 'replace' on objects that
  // extend String and change 'replace' (not that it is common for anyone to
  // extend anything except Object).
};


/**
 * @return {number} An integer value representing the number of milliseconds
 *     between midnight, January 1, 1970 and the current time.
 * @deprecated Use Date.now
 */
goog.now = (goog.TRUSTED_SITE && Date.now) || (function() {
             // Unary plus operator converts its operand to a number which in
             // the case of
             // a date is done by calling getTime().
             return +new Date();
           });


/**
 * Evals JavaScript in the global scope.  In IE this uses execScript, other
 * browsers use goog.global.eval. If goog.global.eval does not evaluate in the
 * global scope (for example, in Safari), appends a script tag instead.
 * Throws an exception if neither execScript or eval is defined.
 * @param {string} script JavaScript string.
 */
goog.globalEval = function(script) {
  if (goog.global.execScript) {
    goog.global.execScript(script, 'JavaScript');
  } else if (goog.global.eval) {
    // Test to see if eval works
    if (goog.evalWorksForGlobals_ == null) {
      try {
        goog.global.eval('var _evalTest_ = 1;');
      } catch (ignore) {
      }
      if (typeof goog.global['_evalTest_'] != 'undefined') {
        try {
          delete goog.global['_evalTest_'];
        } catch (ignore) {
          // Microsoft edge fails the deletion above in strict mode.
        }
        goog.evalWorksForGlobals_ = true;
      } else {
        goog.evalWorksForGlobals_ = false;
      }
    }

    if (goog.evalWorksForGlobals_) {
      goog.global.eval(script);
    } else {
      /** @type {!Document} */
      var doc = goog.global.document;
      var scriptElt =
          /** @type {!HTMLScriptElement} */ (doc.createElement('script'));
      scriptElt.type = 'text/javascript';
      scriptElt.defer = false;
      // Note(user): can't use .innerHTML since "t('<test>')" will fail and
      // .text doesn't work in Safari 2.  Therefore we append a text node.
      scriptElt.appendChild(doc.createTextNode(script));
      doc.head.appendChild(scriptElt);
      doc.head.removeChild(scriptElt);
    }
  } else {
    throw new Error('goog.globalEval not available');
  }
};


/**
 * Indicates whether or not we can call 'eval' directly to eval code in the
 * global scope. Set to a Boolean by the first call to goog.globalEval (which
 * empirically tests whether eval works for globals). @see goog.globalEval
 * @type {?boolean}
 * @private
 */
goog.evalWorksForGlobals_ = null;


/**
 * Optional map of CSS class names to obfuscated names used with
 * goog.getCssName().
 * @private {!Object<string, string>|undefined}
 * @see goog.setCssNameMapping
 */
goog.cssNameMapping_;


/**
 * Optional obfuscation style for CSS class names. Should be set to either
 * 'BY_WHOLE' or 'BY_PART' if defined.
 * @type {string|undefined}
 * @private
 * @see goog.setCssNameMapping
 */
goog.cssNameMappingStyle_;



/**
 * A hook for modifying the default behavior goog.getCssName. The function
 * if present, will receive the standard output of the goog.getCssName as
 * its input.
 *
 * @type {(function(string):string)|undefined}
 */
goog.global.CLOSURE_CSS_NAME_MAP_FN;


/**
 * Handles strings that are intended to be used as CSS class names.
 *
 * This function works in tandem with @see goog.setCssNameMapping.
 *
 * Without any mapping set, the arguments are simple joined with a hyphen and
 * passed through unaltered.
 *
 * When there is a mapping, there are two possible styles in which these
 * mappings are used. In the BY_PART style, each part (i.e. in between hyphens)
 * of the passed in css name is rewritten according to the map. In the BY_WHOLE
 * style, the full css name is looked up in the map directly. If a rewrite is
 * not specified by the map, the compiler will output a warning.
 *
 * When the mapping is passed to the compiler, it will replace calls to
 * goog.getCssName with the strings from the mapping, e.g.
 *     var x = goog.getCssName('foo');
 *     var y = goog.getCssName(this.baseClass, 'active');
 *  becomes:
 *     var x = 'foo';
 *     var y = this.baseClass + '-active';
 *
 * If one argument is passed it will be processed, if two are passed only the
 * modifier will be processed, as it is assumed the first argument was generated
 * as a result of calling goog.getCssName.
 *
 * @param {string} className The class name.
 * @param {string=} opt_modifier A modifier to be appended to the class name.
 * @return {string} The class name or the concatenation of the class name and
 *     the modifier.
 */
goog.getCssName = function(className, opt_modifier) {
  // String() is used for compatibility with compiled soy where the passed
  // className can be non-string objects.
  if (String(className).charAt(0) == '.') {
    throw new Error(
        'className passed in goog.getCssName must not start with ".".' +
        ' You passed: ' + className);
  }

  var getMapping = function(cssName) {
    return goog.cssNameMapping_[cssName] || cssName;
  };

  var renameByParts = function(cssName) {
    // Remap all the parts individually.
    var parts = cssName.split('-');
    var mapped = [];
    for (var i = 0; i < parts.length; i++) {
      mapped.push(getMapping(parts[i]));
    }
    return mapped.join('-');
  };

  var rename;
  if (goog.cssNameMapping_) {
    rename =
        goog.cssNameMappingStyle_ == 'BY_WHOLE' ? getMapping : renameByParts;
  } else {
    rename = function(a) {
      return a;
    };
  }

  var result =
      opt_modifier ? className + '-' + rename(opt_modifier) : rename(className);

  // The special CLOSURE_CSS_NAME_MAP_FN allows users to specify further
  // processing of the class name.
  if (goog.global.CLOSURE_CSS_NAME_MAP_FN) {
    return goog.global.CLOSURE_CSS_NAME_MAP_FN(result);
  }

  return result;
};


/**
 * Sets the map to check when returning a value from goog.getCssName(). Example:
 * <pre>
 * goog.setCssNameMapping({
 *   "goog": "a",
 *   "disabled": "b",
 * });
 *
 * var x = goog.getCssName('goog');
 * // The following evaluates to: "a a-b".
 * goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')
 * </pre>
 * When declared as a map of string literals to string literals, the JSCompiler
 * will replace all calls to goog.getCssName() using the supplied map if the
 * --process_closure_primitives flag is set.
 *
 * @param {!Object} mapping A map of strings to strings where keys are possible
 *     arguments to goog.getCssName() and values are the corresponding values
 *     that should be returned.
 * @param {string=} opt_style The style of css name mapping. There are two valid
 *     options: 'BY_PART', and 'BY_WHOLE'.
 * @see goog.getCssName for a description.
 */
goog.setCssNameMapping = function(mapping, opt_style) {
  goog.cssNameMapping_ = mapping;
  goog.cssNameMappingStyle_ = opt_style;
};


/**
 * To use CSS renaming in compiled mode, one of the input files should have a
 * call to goog.setCssNameMapping() with an object literal that the JSCompiler
 * can extract and use to replace all calls to goog.getCssName(). In uncompiled
 * mode, JavaScript code should be loaded before this base.js file that declares
 * a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is
 * to ensure that the mapping is loaded before any calls to goog.getCssName()
 * are made in uncompiled mode.
 *
 * A hook for overriding the CSS name mapping.
 * @type {!Object<string, string>|undefined}
 */
goog.global.CLOSURE_CSS_NAME_MAPPING;


if (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {
  // This does not call goog.setCssNameMapping() because the JSCompiler
  // requires that goog.setCssNameMapping() be called with an object literal.
  goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;
}


/**
 * Gets a localized message.
 *
 * This function is a compiler primitive. If you give the compiler a localized
 * message bundle, it will replace the string at compile-time with a localized
 * version, and expand goog.getMsg call to a concatenated string.
 *
 * Messages must be initialized in the form:
 * <code>
 * var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});
 * </code>
 *
 * This function produces a string which should be treated as plain text. Use
 * {@link goog.html.SafeHtmlFormatter} in conjunction with goog.getMsg to
 * produce SafeHtml.
 *
 * @param {string} str Translatable string, places holders in the form {$foo}.
 * @param {Object<string, string>=} opt_values Maps place holder name to value.
 * @param {{html: boolean}=} opt_options Options:
 *     html: Escape '<' in str to '&lt;'. Used by Closure Templates where the
 *     generated code size and performance is critical which is why {@link
 *     goog.html.SafeHtmlFormatter} is not used. The value must be literal true
 *     or false.
 * @return {string} message with placeholders filled.
 */
goog.getMsg = function(str, opt_values, opt_options) {
  if (opt_options && opt_options.html) {
    // Note that '&' is not replaced because the translation can contain HTML
    // entities.
    str = str.replace(/</g, '&lt;');
  }
  if (opt_values) {
    str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
      return (opt_values != null && key in opt_values) ? opt_values[key] :
                                                         match;
    });
  }
  return str;
};


/**
 * Gets a localized message. If the message does not have a translation, gives a
 * fallback message.
 *
 * This is useful when introducing a new message that has not yet been
 * translated into all languages.
 *
 * This function is a compiler primitive. Must be used in the form:
 * <code>var x = goog.getMsgWithFallback(MSG_A, MSG_B);</code>
 * where MSG_A and MSG_B were initialized with goog.getMsg.
 *
 * @param {string} a The preferred message.
 * @param {string} b The fallback message.
 * @return {string} The best translated message.
 */
goog.getMsgWithFallback = function(a, b) {
  return a;
};


/**
 * Exposes an unobfuscated global namespace path for the given object.
 * Note that fields of the exported object *will* be obfuscated, unless they are
 * exported in turn via this function or goog.exportProperty.
 *
 * Also handy for making public items that are defined in anonymous closures.
 *
 * ex. goog.exportSymbol('public.path.Foo', Foo);
 *
 * ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);
 *     public.path.Foo.staticFunction();
 *
 * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',
 *                       Foo.prototype.myMethod);
 *     new public.path.Foo().myMethod();
 *
 * @param {string} publicPath Unobfuscated name to export.
 * @param {*} object Object the name should point to.
 * @param {Object=} opt_objectToExportTo The object to add the path to; default
 *     is goog.global.
 */
goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
  goog.exportPath_(publicPath, object, opt_objectToExportTo);
};


/**
 * Exports a property unobfuscated into the object's namespace.
 * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);
 * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);
 * @param {Object} object Object whose static property is being exported.
 * @param {string} publicName Unobfuscated name to export.
 * @param {*} symbol Object the name should point to.
 */
goog.exportProperty = function(object, publicName, symbol) {
  object[publicName] = symbol;
};


/**
 * Inherit the prototype methods from one constructor into another.
 *
 * Usage:
 * <pre>
 * function ParentClass(a, b) { }
 * ParentClass.prototype.foo = function(a) { };
 *
 * function ChildClass(a, b, c) {
 *   ChildClass.base(this, 'constructor', a, b);
 * }
 * goog.inherits(ChildClass, ParentClass);
 *
 * var child = new ChildClass('a', 'b', 'see');
 * child.foo(); // This works.
 * </pre>
 *
 * @param {!Function} childCtor Child class.
 * @param {!Function} parentCtor Parent class.
 * @suppress {strictMissingProperties} superClass_ and base is not defined on
 *    Function.
 */
goog.inherits = function(childCtor, parentCtor) {
  /** @constructor */
  function tempCtor() {}
  tempCtor.prototype = parentCtor.prototype;
  childCtor.superClass_ = parentCtor.prototype;
  childCtor.prototype = new tempCtor();
  /** @override */
  childCtor.prototype.constructor = childCtor;

  /**
   * Calls superclass constructor/method.
   *
   * This function is only available if you use goog.inherits to
   * express inheritance relationships between classes.
   *
   * NOTE: This is a replacement for goog.base and for superClass_
   * property defined in childCtor.
   *
   * @param {!Object} me Should always be "this".
   * @param {string} methodName The method name to call. Calling
   *     superclass constructor can be done with the special string
   *     'constructor'.
   * @param {...*} var_args The arguments to pass to superclass
   *     method/constructor.
   * @return {*} The return value of the superclass method/constructor.
   */
  childCtor.base = function(me, methodName, var_args) {
    // Copying using loop to avoid deop due to passing arguments object to
    // function. This is faster in many JS engines as of late 2014.
    var args = new Array(arguments.length - 2);
    for (var i = 2; i < arguments.length; i++) {
      args[i - 2] = arguments[i];
    }
    return parentCtor.prototype[methodName].apply(me, args);
  };
};


/**
 * Call up to the superclass.
 *
 * If this is called from a constructor, then this calls the superclass
 * constructor with arguments 1-N.
 *
 * If this is called from a prototype method, then you must pass the name of the
 * method as the second argument to this function. If you do not, you will get a
 * runtime error. This calls the superclass' method with arguments 2-N.
 *
 * This function only works if you use goog.inherits to express inheritance
 * relationships between your classes.
 *
 * This function is a compiler primitive. At compile-time, the compiler will do
 * macro expansion to remove a lot of the extra overhead that this function
 * introduces. The compiler will also enforce a lot of the assumptions that this
 * function makes, and treat it as a compiler error if you break them.
 *
 * @param {!Object} me Should always be "this".
 * @param {*=} opt_methodName The method name if calling a super method.
 * @param {...*} var_args The rest of the arguments.
 * @return {*} The return value of the superclass method.
 * @suppress {es5Strict} This method can not be used in strict mode, but
 *     all Closure Library consumers must depend on this file.
 * @deprecated goog.base is not strict mode compatible.  Prefer the static
 *     "base" method added to the constructor by goog.inherits
 *     or ES6 classes and the "super" keyword.
 */
goog.base = function(me, opt_methodName, var_args) {
  var caller = arguments.callee.caller;

  if (goog.STRICT_MODE_COMPATIBLE || (goog.DEBUG && !caller)) {
    throw new Error(
        'arguments.caller not defined.  goog.base() cannot be used ' +
        'with strict mode code. See ' +
        'http://www.ecma-international.org/ecma-262/5.1/#sec-C');
  }

  if (typeof caller.superClass_ !== 'undefined') {
    // Copying using loop to avoid deop due to passing arguments object to
    // function. This is faster in many JS engines as of late 2014.
    var ctorArgs = new Array(arguments.length - 1);
    for (var i = 1; i < arguments.length; i++) {
      ctorArgs[i - 1] = arguments[i];
    }
    // This is a constructor. Call the superclass constructor.
    return /** @type {!Function} */ (caller.superClass_)
        .constructor.apply(me, ctorArgs);
  }

  if (typeof opt_methodName != 'string' && typeof opt_methodName != 'symbol') {
    throw new Error(
        'method names provided to goog.base must be a string or a symbol');
  }

  // Copying using loop to avoid deop due to passing arguments object to
  // function. This is faster in many JS engines as of late 2014.
  var args = new Array(arguments.length - 2);
  for (var i = 2; i < arguments.length; i++) {
    args[i - 2] = arguments[i];
  }
  var foundCaller = false;
  for (var proto = me.constructor.prototype; proto;
       proto = Object.getPrototypeOf(proto)) {
    if (proto[opt_methodName] === caller) {
      foundCaller = true;
    } else if (foundCaller) {
      return proto[opt_methodName].apply(me, args);
    }
  }

  // If we did not find the caller in the prototype chain, then one of two
  // things happened:
  // 1) The caller is an instance method.
  // 2) This method was not called by the right caller.
  if (me[opt_methodName] === caller) {
    return me.constructor.prototype[opt_methodName].apply(me, args);
  } else {
    throw new Error(
        'goog.base called from a method of one name ' +
        'to a method of a different name');
  }
};


/**
 * Allow for aliasing within scope functions.  This function exists for
 * uncompiled code - in compiled code the calls will be inlined and the aliases
 * applied.  In uncompiled code the function is simply run since the aliases as
 * written are valid JavaScript.
 *
 *
 * @param {function()} fn Function to call.  This function can contain aliases
 *     to namespaces (e.g. "var dom = goog.dom") or classes
 *     (e.g. "var Timer = goog.Timer").
 */
goog.scope = function(fn) {
  if (goog.isInModuleLoader_()) {
    throw new Error('goog.scope is not supported within a module.');
  }
  fn.call(goog.global);
};


/*
 * To support uncompiled, strict mode bundles that use eval to divide source
 * like so:
 *    eval('someSource;//# sourceUrl sourcefile.js');
 * We need to export the globally defined symbols "goog" and "COMPILED".
 * Exporting "goog" breaks the compiler optimizations, so we required that
 * be defined externally.
 * NOTE: We don't use goog.exportSymbol here because we don't want to trigger
 * extern generation when that compiler option is enabled.
 */
if (!COMPILED) {
  goog.global['COMPILED'] = COMPILED;
}


//==============================================================================
// goog.defineClass implementation
//==============================================================================


/**
 * Creates a restricted form of a Closure "class":
 *   - from the compiler's perspective, the instance returned from the
 *     constructor is sealed (no new properties may be added).  This enables
 *     better checks.
 *   - the compiler will rewrite this definition to a form that is optimal
 *     for type checking and optimization (initially this will be a more
 *     traditional form).
 *
 * @param {Function} superClass The superclass, Object or null.
 * @param {goog.defineClass.ClassDescriptor} def
 *     An object literal describing
 *     the class.  It may have the following properties:
 *     "constructor": the constructor function
 *     "statics": an object literal containing methods to add to the constructor
 *        as "static" methods or a function that will receive the constructor
 *        function as its only parameter to which static properties can
 *        be added.
 *     all other properties are added to the prototype.
 * @return {!Function} The class constructor.
 * @deprecated Use ES6 class syntax instead.
 */
goog.defineClass = function(superClass, def) {
  // TODO(johnlenz): consider making the superClass an optional parameter.
  var constructor = def.constructor;
  var statics = def.statics;
  // Wrap the constructor prior to setting up the prototype and static methods.
  if (!constructor || constructor == Object.prototype.constructor) {
    constructor = function() {
      throw new Error(
          'cannot instantiate an interface (no constructor defined).');
    };
  }

  var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
  if (superClass) {
    goog.inherits(cls, superClass);
  }

  // Remove all the properties that should not be copied to the prototype.
  delete def.constructor;
  delete def.statics;

  goog.defineClass.applyProperties_(cls.prototype, def);
  if (statics != null) {
    if (statics instanceof Function) {
      statics(cls);
    } else {
      goog.defineClass.applyProperties_(cls, statics);
    }
  }

  return cls;
};


/**
 * @typedef {{
 *   constructor: (!Function|undefined),
 *   statics: (Object|undefined|function(Function):void)
 * }}
 */
goog.defineClass.ClassDescriptor;


/**
 * @define {boolean} Whether the instances returned by goog.defineClass should
 *     be sealed when possible.
 *
 * When sealing is disabled the constructor function will not be wrapped by
 * goog.defineClass, making it incompatible with ES6 class methods.
 */
goog.defineClass.SEAL_CLASS_INSTANCES =
    goog.define('goog.defineClass.SEAL_CLASS_INSTANCES', goog.DEBUG);


/**
 * If goog.defineClass.SEAL_CLASS_INSTANCES is enabled and Object.seal is
 * defined, this function will wrap the constructor in a function that seals the
 * results of the provided constructor function.
 *
 * @param {!Function} ctr The constructor whose results maybe be sealed.
 * @param {Function} superClass The superclass constructor.
 * @return {!Function} The replacement constructor.
 * @private
 */
goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
  if (!goog.defineClass.SEAL_CLASS_INSTANCES) {
    // Do now wrap the constructor when sealing is disabled. Angular code
    // depends on this for injection to work properly.
    return ctr;
  }

  // Compute whether the constructor is sealable at definition time, rather
  // than when the instance is being constructed.
  var superclassSealable = !goog.defineClass.isUnsealable_(superClass);

  /**
   * @this {Object}
   * @return {?}
   */
  var wrappedCtr = function() {
    // Don't seal an instance of a subclass when it calls the constructor of
    // its super class as there is most likely still setup to do.
    var instance = ctr.apply(this, arguments) || this;
    instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];

    if (this.constructor === wrappedCtr && superclassSealable &&
        Object.seal instanceof Function) {
      Object.seal(instance);
    }
    return instance;
  };

  return wrappedCtr;
};


/**
 * @param {Function} ctr The constructor to test.
 * @return {boolean} Whether the constructor has been tagged as unsealable
 *     using goog.tagUnsealableClass.
 * @private
 */
goog.defineClass.isUnsealable_ = function(ctr) {
  return ctr && ctr.prototype &&
      ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_];
};


// TODO(johnlenz): share these values with the goog.object
/**
 * The names of the fields that are defined on Object.prototype.
 * @type {!Array<string>}
 * @private
 * @const
 */
goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [
  'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',
  'toLocaleString', 'toString', 'valueOf'
];


// TODO(johnlenz): share this function with the goog.object
/**
 * @param {!Object} target The object to add properties to.
 * @param {!Object} source The object to copy properties from.
 * @private
 */
goog.defineClass.applyProperties_ = function(target, source) {
  // TODO(johnlenz): update this to support ES5 getters/setters

  var key;
  for (key in source) {
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      target[key] = source[key];
    }
  }

  // For IE the for-in-loop does not contain any properties that are not
  // enumerable on the prototype object (for example isPrototypeOf from
  // Object.prototype) and it will also not include 'replace' on objects that
  // extend String and change 'replace' (not that it is common for anyone to
  // extend anything except Object).
  for (var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {
    key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      target[key] = source[key];
    }
  }
};


/**
 * Sealing classes breaks the older idiom of assigning properties on the
 * prototype rather than in the constructor. As such, goog.defineClass
 * must not seal subclasses of these old-style classes until they are fixed.
 * Until then, this marks a class as "broken", instructing defineClass
 * not to seal subclasses.
 * @param {!Function} ctr The legacy constructor to tag as unsealable.
 */
goog.tagUnsealableClass = function(ctr) {
  if (!COMPILED && goog.defineClass.SEAL_CLASS_INSTANCES) {
    ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_] = true;
  }
};


/**
 * Name for unsealable tag property.
 * @const @private {string}
 */
goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = 'goog_defineClass_legacy_unsealable';


// There's a bug in the compiler where without collapse properties the
// Closure namespace defines do not guard code correctly. To help reduce code
// size also check for !COMPILED even though it redundant until this is fixed.
if (!COMPILED && goog.DEPENDENCIES_ENABLED) {

  /**
   * Tries to detect whether is in the context of an HTML document.
   * @return {boolean} True if it looks like HTML document.
   * @private
   */
  goog.inHtmlDocument_ = function() {
    /** @type {!Document} */
    var doc = goog.global.document;
    return doc != null && 'write' in doc;  // XULDocument misses write.
  };


  /**
   * We'd like to check for if the document readyState is 'loading'; however
   * there are bugs on IE 10 and below where the readyState being anything other
   * than 'complete' is not reliable.
   * @return {boolean}
   * @private
   */
  goog.isDocumentLoading_ = function() {
    // attachEvent is available on IE 6 thru 10 only, and thus can be used to
    // detect those browsers.
    /** @type {!HTMLDocument} */
    var doc = goog.global.document;
    return doc.attachEvent ? doc.readyState != 'complete' :
                             doc.readyState == 'loading';
  };


  /**
   * Tries to detect the base path of base.js script that bootstraps Closure.
   * @private
   */
  goog.findBasePath_ = function() {
    if (goog.global.CLOSURE_BASE_PATH != undefined &&
        // Anti DOM-clobbering runtime check (b/37736576).
        typeof goog.global.CLOSURE_BASE_PATH === 'string') {
      goog.basePath = goog.global.CLOSURE_BASE_PATH;
      return;
    } else if (!goog.inHtmlDocument_()) {
      return;
    }
    /** @type {!Document} */
    var doc = goog.global.document;
    // If we have a currentScript available, use it exclusively.
    var currentScript = doc.currentScript;
    if (currentScript) {
      var scripts = [currentScript];
    } else {
      var scripts = doc.getElementsByTagName('SCRIPT');
    }
    // Search backwards since the current script is in almost all cases the one
    // that has base.js.
    for (var i = scripts.length - 1; i >= 0; --i) {
      var script = /** @type {!HTMLScriptElement} */ (scripts[i]);
      var src = script.src;
      var qmark = src.lastIndexOf('?');
      var l = qmark == -1 ? src.length : qmark;
      if (src.substr(l - 7, 7) == 'base.js') {
        goog.basePath = src.substr(0, l - 7);
        return;
      }
    }
  };

  goog.findBasePath_();

  /** @struct @constructor @final */
  goog.Transpiler = function() {
    /** @private {?Object<string, boolean>} */
    this.requiresTranspilation_ = null;
    /** @private {string} */
    this.transpilationTarget_ = goog.TRANSPILE_TO_LANGUAGE;
  };


  /**
   * Returns a newly created map from language mode string to a boolean
   * indicating whether transpilation should be done for that mode as well as
   * the highest level language that this environment supports.
   *
   * Guaranteed invariant:
   * For any two modes, l1 and l2 where l2 is a newer mode than l1,
   * `map[l1] == true` implies that `map[l2] == true`.
   *
   * Note this method is extracted and used elsewhere, so it cannot rely on
   * anything external (it should easily be able to be transformed into a
   * standalone, top level function).
   *
   * @private
   * @return {{
   *   target: string,
   *   map: !Object<string, boolean>
   * }}
   */
  goog.Transpiler.prototype.createRequiresTranspilation_ = function() {
    var transpilationTarget = 'es3';
    var /** !Object<string, boolean> */ requiresTranspilation = {'es3': false};
    var transpilationRequiredForAllLaterModes = false;

    /**
     * Adds an entry to requiresTranspliation for the given language mode.
     *
     * IMPORTANT: Calls must be made in order from oldest to newest language
     * mode.
     * @param {string} modeName
     * @param {function(): boolean} isSupported Returns true if the JS engine
     *     supports the given mode.
     */
    function addNewerLanguageTranspilationCheck(modeName, isSupported) {
      if (transpilationRequiredForAllLaterModes) {
        requiresTranspilation[modeName] = true;
      } else if (isSupported()) {
        transpilationTarget = modeName;
        requiresTranspilation[modeName] = false;
      } else {
        requiresTranspilation[modeName] = true;
        transpilationRequiredForAllLaterModes = true;
      }
    }

    /**
     * Does the given code evaluate without syntax errors and return a truthy
     * result?
     */
    function /** boolean */ evalCheck(/** string */ code) {
      try {
        return !!eval(code);
      } catch (ignored) {
        return false;
      }
    }

    var userAgent = goog.global.navigator && goog.global.navigator.userAgent ?
        goog.global.navigator.userAgent :
        '';

    // Identify ES3-only browsers by their incorrect treatment of commas.
    addNewerLanguageTranspilationCheck('es5', function() {
      return evalCheck('[1,].length==1');
    });
    addNewerLanguageTranspilationCheck('es6', function() {
      // Edge has a non-deterministic (i.e., not reproducible) bug with ES6:
      // https://github.com/Microsoft/ChakraCore/issues/1496.
      var re = /Edge\/(\d+)(\.\d)*/i;
      var edgeUserAgent = userAgent.match(re);
      if (edgeUserAgent) {
        // The Reflect.construct test below is flaky on Edge. It can sometimes
        // pass or fail on 40 15.15063, so just exit early for Edge and treat
        // it as ES5. Until we're on a more up to date version just always use
        // ES5. See https://github.com/Microsoft/ChakraCore/issues/3217.
        return false;
      }
      // Test es6: [FF50 (?), Edge 14 (?), Chrome 50]
      //   (a) default params (specifically shadowing locals),
      //   (b) destructuring, (c) block-scoped functions,
      //   (d) for-of (const), (e) new.target/Reflect.construct
      var es6fullTest =
          'class X{constructor(){if(new.target!=String)throw 1;this.x=42}}' +
          'let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof ' +
          'String))throw 1;for(const a of[2,3]){if(a==2)continue;function ' +
          'f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()' +
          '==3}';

      return evalCheck('(()=>{"use strict";' + es6fullTest + '})()');
    });
    // ** and **= are the only new features in 'es7'
    addNewerLanguageTranspilationCheck('es7', function() {
      return evalCheck('2 ** 2 == 4');
    });
    // async functions are the only new features in 'es8'
    addNewerLanguageTranspilationCheck('es8', function() {
      return evalCheck('async () => 1, true');
    });
    addNewerLanguageTranspilationCheck('es9', function() {
      return evalCheck('({...rest} = {}), true');
    });
    addNewerLanguageTranspilationCheck('es_next', function() {
      return false;  // assume it always need to transpile
    });
    return {target: transpilationTarget, map: requiresTranspilation};
  };


  /**
   * Determines whether the given language needs to be transpiled.
   * @param {string} lang
   * @param {string|undefined} module
   * @return {boolean}
   */
  goog.Transpiler.prototype.needsTranspile = function(lang, module) {
    if (goog.TRANSPILE == 'always') {
      return true;
    } else if (goog.TRANSPILE == 'never') {
      return false;
    } else if (!this.requiresTranspilation_) {
      var obj = this.createRequiresTranspilation_();
      this.requiresTranspilation_ = obj.map;
      this.transpilationTarget_ = this.transpilationTarget_ || obj.target;
    }
    if (lang in this.requiresTranspilation_) {
      if (this.requiresTranspilation_[lang]) {
        return true;
      } else if (
          goog.inHtmlDocument_() && module == 'es6' &&
          !('noModule' in goog.global.document.createElement('script'))) {
        return true;
      } else {
        return false;
      }
    } else {
      throw new Error('Unknown language mode: ' + lang);
    }
  };


  /**
   * Lazily retrieves the transpiler and applies it to the source.
   * @param {string} code JS code.
   * @param {string} path Path to the code.
   * @return {string} The transpiled code.
   */
  goog.Transpiler.prototype.transpile = function(code, path) {
    // TODO(johnplaisted): We should delete goog.transpile_ and just have this
    // function. But there's some compile error atm where goog.global is being
    // stripped incorrectly without this.
    return goog.transpile_(code, path, this.transpilationTarget_);
  };


  /** @private @final {!goog.Transpiler} */
  goog.transpiler_ = new goog.Transpiler();

  /**
   * Rewrites closing script tags in input to avoid ending an enclosing script
   * tag.
   *
   * @param {string} str
   * @return {string}
   * @private
   */
  goog.protectScriptTag_ = function(str) {
    return str.replace(/<\/(SCRIPT)/ig, '\\x3c/$1');
  };


  /**
   * A debug loader is responsible for downloading and executing javascript
   * files in an unbundled, uncompiled environment.
   *
   * This can be custimized via the setDependencyFactory method, or by
   * CLOSURE_IMPORT_SCRIPT/CLOSURE_LOAD_FILE_SYNC.
   *
   * @struct @constructor @final @private
   */
  goog.DebugLoader_ = function() {
    /** @private @const {!Object<string, !goog.Dependency>} */
    this.dependencies_ = {};
    /** @private @const {!Object<string, string>} */
    this.idToPath_ = {};
    /** @private @const {!Object<string, boolean>} */
    this.written_ = {};
    /** @private @const {!Array<!goog.Dependency>} */
    this.loadingDeps_ = [];
    /** @private {!Array<!goog.Dependency>} */
    this.depsToLoad_ = [];
    /** @private {boolean} */
    this.paused_ = false;
    /** @private {!goog.DependencyFactory} */
    this.factory_ = new goog.DependencyFactory(goog.transpiler_);
    /** @private @const {!Object<string, !Function>} */
    this.deferredCallbacks_ = {};
    /** @private @const {!Array<string>} */
    this.deferredQueue_ = [];
  };

  /**
   * @param {!Array<string>} namespaces
   * @param {function(): undefined} callback Function to call once all the
   *     namespaces have loaded.
   */
  goog.DebugLoader_.prototype.bootstrap = function(namespaces, callback) {
    var cb = callback;
    function resolve() {
      if (cb) {
        goog.global.setTimeout(cb, 0);
        cb = null;
      }
    }

    if (!namespaces.length) {
      resolve();
      return;
    }

    var deps = [];
    for (var i = 0; i < namespaces.length; i++) {
      var path = this.getPathFromDeps_(namespaces[i]);
      if (!path) {
        throw new Error('Unregonized namespace: ' + namespaces[i]);
      }
      deps.push(this.dependencies_[path]);
    }

    var require = goog.require;
    var loaded = 0;
    for (var i = 0; i < namespaces.length; i++) {
      require(namespaces[i]);
      deps[i].onLoad(function() {
        if (++loaded == namespaces.length) {
          resolve();
        }
      });
    }
  };


  /**
   * Loads the Closure Dependency file.
   *
   * Exposed a public function so CLOSURE_NO_DEPS can be set to false, base
   * loaded, setDependencyFactory called, and then this called. i.e. allows
   * custom loading of the deps file.
   */
  goog.DebugLoader_.prototype.loadClosureDeps = function() {
    // Circumvent addDependency, which would try to transpile deps.js if
    // transpile is set to always.
    var relPath = 'deps.js';
    this.depsToLoad_.push(this.factory_.createDependency(
        goog.normalizePath_(goog.basePath + relPath), relPath, [], [], {},
        false));
    this.loadDeps_();
  };


  /**
   * Notifies the debug loader when a dependency has been requested.
   *
   * @param {string} absPathOrId Path of the dependency or goog id.
   * @param {boolean=} opt_force
   */
  goog.DebugLoader_.prototype.requested = function(absPathOrId, opt_force) {
    var path = this.getPathFromDeps_(absPathOrId);
    if (path &&
        (opt_force || this.areDepsLoaded_(this.dependencies_[path].requires))) {
      var callback = this.deferredCallbacks_[path];
      if (callback) {
        delete this.deferredCallbacks_[path];
        callback();
      }
    }
  };


  /**
   * Sets the dependency factory, which can be used to create custom
   * goog.Dependency implementations to control how dependencies are loaded.
   *
   * @param {!goog.DependencyFactory} factory
   */
  goog.DebugLoader_.prototype.setDependencyFactory = function(factory) {
    this.factory_ = factory;
  };


  /**
   * Travserses the dependency graph and queues the given dependency, and all of
   * its transitive dependencies, for loading and then starts loading if not
   * paused.
   *
   * @param {string} namespace
   * @private
   */
  goog.DebugLoader_.prototype.load_ = function(namespace) {
    if (!this.getPathFromDeps_(namespace)) {
      var errorMessage = 'goog.require could not find: ' + namespace;

      goog.logToConsole_(errorMessage);
      throw Error(errorMessage);
    } else {
      var loader = this;

      var deps = [];

      /** @param {string} namespace */
      var visit = function(namespace) {
        var path = loader.getPathFromDeps_(namespace);

        if (!path) {
          throw new Error('Bad dependency path or symbol: ' + namespace);
        }

        if (loader.written_[path]) {
          return;
        }

        loader.written_[path] = true;

        var dep = loader.dependencies_[path];
        for (var i = 0; i < dep.requires.length; i++) {
          if (!goog.isProvided_(dep.requires[i])) {
            visit(dep.requires[i]);
          }
        }

        deps.push(dep);
      };

      visit(namespace);

      var wasLoading = !!this.depsToLoad_.length;
      this.depsToLoad_ = this.depsToLoad_.concat(deps);

      if (!this.paused_ && !wasLoading) {
        this.loadDeps_();
      }
    }
  };


  /**
   * Loads any queued dependencies until they are all loaded or paused.
   *
   * @private
   */
  goog.DebugLoader_.prototype.loadDeps_ = function() {
    var loader = this;
    var paused = this.paused_;

    while (this.depsToLoad_.length && !paused) {
      (function() {
        var loadCallDone = false;
        var dep = loader.depsToLoad_.shift();

        var loaded = false;
        loader.loading_(dep);

        var controller = {
          pause: function() {
            if (loadCallDone) {
              throw new Error('Cannot call pause after the call to load.');
            } else {
              paused = true;
            }
          },
          resume: function() {
            if (loadCallDone) {
              loader.resume_();
            } else {
              // Some dep called pause and then resume in the same load call.
              // Just keep running this same loop.
              paused = false;
            }
          },
          loaded: function() {
            if (loaded) {
              throw new Error('Double call to loaded.');
            }

            loaded = true;
            loader.loaded_(dep);
          },
          pending: function() {
            // Defensive copy.
            var pending = [];
            for (var i = 0; i < loader.loadingDeps_.length; i++) {
              pending.push(loader.loadingDeps_[i]);
            }
            return pending;
          },
          /**
           * @param {goog.ModuleType} type
           */
          setModuleState: function(type) {
            goog.moduleLoaderState_ = {
              type: type,
              moduleName: '',
              declareLegacyNamespace: false
            };
          },
          /** @type {function(string, string, string=)} */
          registerEs6ModuleExports: function(
              path, exports, opt_closureNamespace) {
            if (opt_closureNamespace) {
              goog.loadedModules_[opt_closureNamespace] = {
                exports: exports,
                type: goog.ModuleType.ES6,
                moduleId: opt_closureNamespace || ''
              };
            }
          },
          /** @type {function(string, ?)} */
          registerGoogModuleExports: function(moduleId, exports) {
            goog.loadedModules_[moduleId] = {
              exports: exports,
              type: goog.ModuleType.GOOG,
              moduleId: moduleId
            };
          },
          clearModuleState: function() {
            goog.moduleLoaderState_ = null;
          },
          defer: function(callback) {
            if (loadCallDone) {
              throw new Error(
                  'Cannot register with defer after the call to load.');
            }
            loader.defer_(dep, callback);
          },
          areDepsLoaded: function() {
            return loader.areDepsLoaded_(dep.requires);
          }
        };

        try {
          dep.load(controller);
        } finally {
          loadCallDone = true;
        }
      })();
    }

    if (paused) {
      this.pause_();
    }
  };


  /** @private */
  goog.DebugLoader_.prototype.pause_ = function() {
    this.paused_ = true;
  };


  /** @private */
  goog.DebugLoader_.prototype.resume_ = function() {
    if (this.paused_) {
      this.paused_ = false;
      this.loadDeps_();
    }
  };


  /**
   * Marks the given dependency as loading (load has been called but it has not
   * yet marked itself as finished). Useful for dependencies that want to know
   * what else is loading. Example: goog.modules cannot eval if there are
   * loading dependencies.
   *
   * @param {!goog.Dependency} dep
   * @private
   */
  goog.DebugLoader_.prototype.loading_ = function(dep) {
    this.loadingDeps_.push(dep);
  };


  /**
   * Marks the given dependency as having finished loading and being available
   * for require.
   *
   * @param {!goog.Dependency} dep
   * @private
   */
  goog.DebugLoader_.prototype.loaded_ = function(dep) {
    for (var i = 0; i < this.loadingDeps_.length; i++) {
      if (this.loadingDeps_[i] == dep) {
        this.loadingDeps_.splice(i, 1);
        break;
      }
    }

    for (var i = 0; i < this.deferredQueue_.length; i++) {
      if (this.deferredQueue_[i] == dep.path) {
        this.deferredQueue_.splice(i, 1);
        break;
      }
    }

    if (this.loadingDeps_.length == this.deferredQueue_.length &&
        !this.depsToLoad_.length) {
      // Something has asked to load these, but they may not be directly
      // required again later, so load them now that we know we're done loading
      // everything else. e.g. a goog module entry point.
      while (this.deferredQueue_.length) {
        this.requested(this.deferredQueue_.shift(), true);
      }
    }

    dep.loaded();
  };


  /**
   * @param {!Array<string>} pathsOrIds
   * @return {boolean}
   * @private
   */
  goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {
    for (var i = 0; i < pathsOrIds.length; i++) {
      var path = this.getPathFromDeps_(pathsOrIds[i]);
      if (!path ||
          (!(path in this.deferredCallbacks_) &&
           !goog.isProvided_(pathsOrIds[i]))) {
        return false;
      }
    }

    return true;
  };


  /**
   * @param {string} absPathOrId
   * @return {?string}
   * @private
   */
  goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {
    if (absPathOrId in this.idToPath_) {
      return this.idToPath_[absPathOrId];
    } else if (absPathOrId in this.dependencies_) {
      return absPathOrId;
    } else {
      return null;
    }
  };


  /**
   * @param {!goog.Dependency} dependency
   * @param {!Function} callback
   * @private
   */
  goog.DebugLoader_.prototype.defer_ = function(dependency, callback) {
    this.deferredCallbacks_[dependency.path] = callback;
    this.deferredQueue_.push(dependency.path);
  };


  /**
   * Interface for goog.Dependency implementations to have some control over
   * loading of dependencies.
   *
   * @record
   */
  goog.LoadController = function() {};


  /**
   * Tells the controller to halt loading of more dependencies.
   */
  goog.LoadController.prototype.pause = function() {};


  /**
   * Tells the controller to resume loading of more dependencies if paused.
   */
  goog.LoadController.prototype.resume = function() {};


  /**
   * Tells the controller that this dependency has finished loading.
   *
   * This causes this to be removed from pending() and any load callbacks to
   * fire.
   */
  goog.LoadController.prototype.loaded = function() {};


  /**
   * List of dependencies on which load has been called but which have not
   * called loaded on their controller. This includes the current dependency.
   *
   * @return {!Array<!goog.Dependency>}
   */
  goog.LoadController.prototype.pending = function() {};


  /**
   * Registers an object as an ES6 module's exports so that goog.modules may
   * require it by path.
   *
   * @param {string} path Full path of the module.
   * @param {?} exports
   * @param {string=} opt_closureNamespace Closure namespace to associate with
   *     this module.
   */
  goog.LoadController.prototype.registerEs6ModuleExports = function(
      path, exports, opt_closureNamespace) {};


  /**
   * Sets the current module state.
   *
   * @param {goog.ModuleType} type Type of module.
   */
  goog.LoadController.prototype.setModuleState = function(type) {};


  /**
   * Clears the current module state.
   */
  goog.LoadController.prototype.clearModuleState = function() {};


  /**
   * Registers a callback to call once the dependency is actually requested
   * via goog.require + all of the immediate dependencies have been loaded or
   * all other files have been loaded. Allows for lazy loading until
   * require'd without pausing dependency loading, which is needed on old IE.
   *
   * @param {!Function} callback
   */
  goog.LoadController.prototype.defer = function(callback) {};


  /**
   * @return {boolean}
   */
  goog.LoadController.prototype.areDepsLoaded = function() {};


  /**
   * Basic super class for all dependencies Closure Library can load.
   *
   * This default implementation is designed to load untranspiled, non-module
   * scripts in a web broswer.
   *
   * For transpiled non-goog.module files {@see goog.TranspiledDependency}.
   * For goog.modules see {@see goog.GoogModuleDependency}.
   * For untranspiled ES6 modules {@see goog.Es6ModuleDependency}.
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @struct @constructor
   */
  goog.Dependency = function(
      path, relativePath, provides, requires, loadFlags) {
    /** @const */
    this.path = path;
    /** @const */
    this.relativePath = relativePath;
    /** @const */
    this.provides = provides;
    /** @const */
    this.requires = requires;
    /** @const */
    this.loadFlags = loadFlags;
    /** @private {boolean} */
    this.loaded_ = false;
    /** @private {!Array<function()>} */
    this.loadCallbacks_ = [];
  };


  /**
   * @return {string} The pathname part of this dependency's path if it is a
   *     URI.
   */
  goog.Dependency.prototype.getPathName = function() {
    var pathName = this.path;
    var protocolIndex = pathName.indexOf('://');
    if (protocolIndex >= 0) {
      pathName = pathName.substring(protocolIndex + 3);
      var slashIndex = pathName.indexOf('/');
      if (slashIndex >= 0) {
        pathName = pathName.substring(slashIndex + 1);
      }
    }
    return pathName;
  };


  /**
   * @param {function()} callback Callback to fire as soon as this has loaded.
   * @final
   */
  goog.Dependency.prototype.onLoad = function(callback) {
    if (this.loaded_) {
      callback();
    } else {
      this.loadCallbacks_.push(callback);
    }
  };


  /**
   * Marks this dependency as loaded and fires any callbacks registered with
   * onLoad.
   * @final
   */
  goog.Dependency.prototype.loaded = function() {
    this.loaded_ = true;
    var callbacks = this.loadCallbacks_;
    this.loadCallbacks_ = [];
    for (var i = 0; i < callbacks.length; i++) {
      callbacks[i]();
    }
  };


  /**
   * Whether or not document.written / appended script tags should be deferred.
   *
   * @private {boolean}
   */
  goog.Dependency.defer_ = false;


  /**
   * Map of script ready / state change callbacks. Old IE cannot handle putting
   * these properties on goog.global.
   *
   * @private @const {!Object<string, function(?):undefined>}
   */
  goog.Dependency.callbackMap_ = {};


  /**
   * @param {function(...?):?} callback
   * @return {string}
   * @private
   */
  goog.Dependency.registerCallback_ = function(callback) {
    var key = Math.random().toString(32);
    goog.Dependency.callbackMap_[key] = callback;
    return key;
  };


  /**
   * @param {string} key
   * @private
   */
  goog.Dependency.unregisterCallback_ = function(key) {
    delete goog.Dependency.callbackMap_[key];
  };


  /**
   * @param {string} key
   * @param {...?} var_args
   * @private
   * @suppress {unusedPrivateMembers}
   */
  goog.Dependency.callback_ = function(key, var_args) {
    if (key in goog.Dependency.callbackMap_) {
      var callback = goog.Dependency.callbackMap_[key];
      var args = [];
      for (var i = 1; i < arguments.length; i++) {
        args.push(arguments[i]);
      }
      callback.apply(undefined, args);
    } else {
      var errorMessage = 'Callback key ' + key +
          ' does not exist (was base.js loaded more than once?).';
      throw Error(errorMessage);
    }
  };


  /**
   * Starts loading this dependency. This dependency can pause loading if it
   * needs to and resume it later via the controller interface.
   *
   * When this is loaded it should call controller.loaded(). Note that this will
   * end up calling the loaded method of this dependency; there is no need to
   * call it explicitly.
   *
   * @param {!goog.LoadController} controller
   */
  goog.Dependency.prototype.load = function(controller) {
    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
      if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }

    if (!goog.inHtmlDocument_()) {
      goog.logToConsole_(
          'Cannot use default debug loader outside of HTML documents.');
      if (this.relativePath == 'deps.js') {
        // Some old code is relying on base.js auto loading deps.js failing with
        // no error before later setting CLOSURE_IMPORT_SCRIPT.
        // CLOSURE_IMPORT_SCRIPT should be set *before* base.js is loaded, or
        // CLOSURE_NO_DEPS set to true.
        goog.logToConsole_(
            'Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, ' +
            'or setting CLOSURE_NO_DEPS to true.');
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }

    /** @type {!HTMLDocument} */
    var doc = goog.global.document;

    // If the user tries to require a new symbol after document load,
    // something has gone terribly wrong. Doing a document.write would
    // wipe out the page. This does not apply to the CSP-compliant method
    // of writing script tags.
    if (doc.readyState == 'complete' &&
        !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {
      // Certain test frameworks load base.js multiple times, which tries
      // to write deps.js each time. If that happens, just fail silently.
      // These frameworks wipe the page between each load of base.js, so this
      // is OK.
      var isDeps = /\bdeps.js$/.test(this.path);
      if (isDeps) {
        controller.loaded();
        return;
      } else {
        throw Error('Cannot write "' + this.path + '" after document load');
      }
    }

    if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
        goog.isDocumentLoading_()) {
      var key = goog.Dependency.registerCallback_(function(script) {
        if (!goog.DebugLoader_.IS_OLD_IE_ || script.readyState == 'complete') {
          goog.Dependency.unregisterCallback_(key);
          controller.loaded();
        }
      });
      var nonceAttr = !goog.DebugLoader_.IS_OLD_IE_ && goog.getScriptNonce() ?
          ' nonce="' + goog.getScriptNonce() + '"' :
          '';
      var event =
          goog.DebugLoader_.IS_OLD_IE_ ? 'onreadystatechange' : 'onload';
      var defer = goog.Dependency.defer_ ? 'defer' : '';
      var script = '<script src="' + this.path + '" ' + event +
          '="goog.Dependency.callback_(\'' + key +
          '\', this)" type="text/javascript" ' + defer + nonceAttr + '><' +
          '/script>';
      doc.write(
          goog.TRUSTED_TYPES_POLICY_ ?
              goog.TRUSTED_TYPES_POLICY_.createHTML(script) :
              script);
    } else {
      var scriptEl =
          /** @type {!HTMLScriptElement} */ (doc.createElement('script'));
      scriptEl.defer = goog.Dependency.defer_;
      scriptEl.async = false;
      scriptEl.type = 'text/javascript';

      // If CSP nonces are used, propagate them to dynamically created scripts.
      // This is necessary to allow nonce-based CSPs without 'strict-dynamic'.
      var nonce = goog.getScriptNonce();
      if (nonce) {
        scriptEl.setAttribute('nonce', nonce);
      }

      if (goog.DebugLoader_.IS_OLD_IE_) {
        // Execution order is not guaranteed on old IE, halt loading and write
        // these scripts one at a time, after each loads.
        controller.pause();
        scriptEl.onreadystatechange = function() {
          if (scriptEl.readyState == 'loaded' ||
              scriptEl.readyState == 'complete') {
            controller.loaded();
            controller.resume();
          }
        };
      } else {
        scriptEl.onload = function() {
          scriptEl.onload = null;
          controller.loaded();
        };
      }

      scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ?
          goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path) :
          this.path;
      doc.head.appendChild(scriptEl);
    }
  };


  /**
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides Should be an empty array.
   *     TODO(johnplaisted) add support for adding closure namespaces to ES6
   *     modules for interop purposes.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @struct @constructor
   * @extends {goog.Dependency}
   */
  goog.Es6ModuleDependency = function(
      path, relativePath, provides, requires, loadFlags) {
    goog.Es6ModuleDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
  };
  goog.inherits(goog.Es6ModuleDependency, goog.Dependency);


  /** @override */
  goog.Es6ModuleDependency.prototype.load = function(controller) {
    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
      if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }

    if (!goog.inHtmlDocument_()) {
      goog.logToConsole_(
          'Cannot use default debug loader outside of HTML documents.');
      controller.pause();
      return;
    }

    /** @type {!HTMLDocument} */
    var doc = goog.global.document;

    var dep = this;

    // TODO(johnplaisted): Does document.writing really speed up anything? Any
    // difference between this and just waiting for interactive mode and then
    // appending?
    function write(src, contents) {
      if (contents) {
        var script = '<script type="module" crossorigin>' + contents + '</' +
            'script>';
        doc.write(
            goog.TRUSTED_TYPES_POLICY_ ?
                goog.TRUSTED_TYPES_POLICY_.createHTML(script) :
                script);
      } else {
        var script = '<script type="module" crossorigin src="' + src + '"></' +
            'script>';
        doc.write(
            goog.TRUSTED_TYPES_POLICY_ ?
                goog.TRUSTED_TYPES_POLICY_.createHTML(script) :
                script);
      }
    }

    function append(src, contents) {
      var scriptEl =
          /** @type {!HTMLScriptElement} */ (doc.createElement('script'));
      scriptEl.defer = true;
      scriptEl.async = false;
      scriptEl.type = 'module';
      scriptEl.setAttribute('crossorigin', true);

      // If CSP nonces are used, propagate them to dynamically created scripts.
      // This is necessary to allow nonce-based CSPs without 'strict-dynamic'.
      var nonce = goog.getScriptNonce();
      if (nonce) {
        scriptEl.setAttribute('nonce', nonce);
      }

      if (contents) {
        scriptEl.textContent = goog.TRUSTED_TYPES_POLICY_ ?
            goog.TRUSTED_TYPES_POLICY_.createScript(contents) :
            contents;
      } else {
        scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ?
            goog.TRUSTED_TYPES_POLICY_.createScriptURL(src) :
            src;
      }

      doc.head.appendChild(scriptEl);
    }

    var create;

    if (goog.isDocumentLoading_()) {
      create = write;
      // We can ONLY call document.write if we are guaranteed that any
      // non-module script tags document.written after this are deferred.
      // Small optimization, in theory document.writing is faster.
      goog.Dependency.defer_ = true;
    } else {
      create = append;
    }

    // Write 4 separate tags here:
    // 1) Sets the module state at the correct time (just before execution).
    // 2) A src node for this, which just hopefully lets the browser load it a
    //    little early (no need to parse #3).
    // 3) Import the module and register it.
    // 4) Clear the module state at the correct time. Guaranteed to run even
    //    if there is an error in the module (#3 will not run if there is an
    //    error in the module).
    var beforeKey = goog.Dependency.registerCallback_(function() {
      goog.Dependency.unregisterCallback_(beforeKey);
      controller.setModuleState(goog.ModuleType.ES6);
    });
    create(undefined, 'goog.Dependency.callback_("' + beforeKey + '")');

    // TODO(johnplaisted): Does this really speed up anything?
    create(this.path, undefined);

    var registerKey = goog.Dependency.registerCallback_(function(exports) {
      goog.Dependency.unregisterCallback_(registerKey);
      controller.registerEs6ModuleExports(
          dep.path, exports, goog.moduleLoaderState_.moduleName);
    });
    create(
        undefined,
        'import * as m from "' + this.path + '"; goog.Dependency.callback_("' +
            registerKey + '", m)');

    var afterKey = goog.Dependency.registerCallback_(function() {
      goog.Dependency.unregisterCallback_(afterKey);
      controller.clearModuleState();
      controller.loaded();
    });
    create(undefined, 'goog.Dependency.callback_("' + afterKey + '")');
  };


  /**
   * Superclass of any dependency that needs to be loaded into memory,
   * transformed, and then eval'd (goog.modules and transpiled files).
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @struct @constructor @abstract
   * @extends {goog.Dependency}
   */
  goog.TransformedDependency = function(
      path, relativePath, provides, requires, loadFlags) {
    goog.TransformedDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
    /** @private {?string} */
    this.contents_ = null;

    /**
     * Whether to lazily make the synchronous XHR (when goog.require'd) or make
     * the synchronous XHR when initially loading. On FireFox 61 there is a bug
     * where an ES6 module cannot make a synchronous XHR (rather, it can, but if
     * it does then no other ES6 modules will load after).
     *
     * tl;dr we lazy load due to bugs on older browsers and eager load due to
     * bugs on newer ones.
     *
     * https://bugzilla.mozilla.org/show_bug.cgi?id=1477090
     *
     * @private @const {boolean}
     */
    this.lazyFetch_ = !goog.inHtmlDocument_() ||
        !('noModule' in goog.global.document.createElement('script'));
  };
  goog.inherits(goog.TransformedDependency, goog.Dependency);


  /** @override */
  goog.TransformedDependency.prototype.load = function(controller) {
    var dep = this;

    function fetch() {
      dep.contents_ = goog.loadFileSync_(dep.path);

      if (dep.contents_) {
        dep.contents_ = dep.transform(dep.contents_);
        if (dep.contents_) {
          dep.contents_ += '\n//# sourceURL=' + dep.path;
        }
      }
    }

    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
      fetch();
      if (this.contents_ &&
          goog.global.CLOSURE_IMPORT_SCRIPT('', this.contents_)) {
        this.contents_ = null;
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }


    var isEs6 = this.loadFlags['module'] == goog.ModuleType.ES6;

    if (!this.lazyFetch_) {
      fetch();
    }

    function load() {
      if (dep.lazyFetch_) {
        fetch();
      }

      if (!dep.contents_) {
        // loadFileSync_ or transform are responsible. Assume they logged an
        // error.
        return;
      }

      if (isEs6) {
        controller.setModuleState(goog.ModuleType.ES6);
      }

      var namespace;

      try {
        var contents = dep.contents_;
        dep.contents_ = null;
        goog.globalEval(contents);
        if (isEs6) {
          namespace = goog.moduleLoaderState_.moduleName;
        }
      } finally {
        if (isEs6) {
          controller.clearModuleState();
        }
      }

      if (isEs6) {
        // Due to circular dependencies this may not be available for require
        // right now.
        goog.global['$jscomp']['require']['ensure'](
            [dep.getPathName()], function() {
              controller.registerEs6ModuleExports(
                  dep.path,
                  goog.global['$jscomp']['require'](dep.getPathName()),
                  namespace);
            });
      }

      controller.loaded();
    }

    // Do not fetch now; in FireFox 47 the synchronous XHR doesn't block all
    // events. If we fetched now and then document.write'd the contents the
    // document.write would be an eval and would execute too soon! Instead write
    // a script tag to fetch and eval synchronously at the correct time.
    function fetchInOwnScriptThenLoad() {
      /** @type {!HTMLDocument} */
      var doc = goog.global.document;

      var key = goog.Dependency.registerCallback_(function() {
        goog.Dependency.unregisterCallback_(key);
        load();
      });

      var script = '<script type="text/javascript">' +
          goog.protectScriptTag_('goog.Dependency.callback_("' + key + '");') +
          '</' +
          'script>';
      doc.write(
          goog.TRUSTED_TYPES_POLICY_ ?
              goog.TRUSTED_TYPES_POLICY_.createHTML(script) :
              script);
    }

    // If one thing is pending it is this.
    var anythingElsePending = controller.pending().length > 1;

    // If anything else is loading we need to lazy load due to bugs in old IE.
    // Specifically script tags with src and script tags with contents could
    // execute out of order if document.write is used, so we cannot use
    // document.write. Do not pause here; it breaks old IE as well.
    var useOldIeWorkAround =
        anythingElsePending && goog.DebugLoader_.IS_OLD_IE_;

    // Additionally if we are meant to defer scripts but the page is still
    // loading (e.g. an ES6 module is loading) then also defer. Or if we are
    // meant to defer and anything else is pending then defer (those may be
    // scripts that did not need transformation and are just script tags with
    // defer set to true, and we need to evaluate after that deferred script).
    var needsAsyncLoading = goog.Dependency.defer_ &&
        (anythingElsePending || goog.isDocumentLoading_());

    if (useOldIeWorkAround || needsAsyncLoading) {
      // Note that we only defer when we have to rather than 100% of the time.
      // Always defering would work, but then in theory the order of
      // goog.require calls would then matter. We want to enforce that most of
      // the time the order of the require calls does not matter.
      controller.defer(function() {
        load();
      });
      return;
    }
    // TODO(johnplaisted): Externs are missing onreadystatechange for
    // HTMLDocument.
    /** @type {?} */
    var doc = goog.global.document;

    var isInternetExplorer =
        goog.inHtmlDocument_() && 'ActiveXObject' in goog.global;

    // Don't delay in any version of IE. There's bug around this that will
    // cause out of order script execution. This means that on older IE ES6
    // modules will load too early (while the document is still loading + the
    // dom is not available). The other option is to load too late (when the
    // document is complete and the onload even will never fire). This seems
    // to be the lesser of two evils as scripts already act like the former.
    if (isEs6 && goog.inHtmlDocument_() && goog.isDocumentLoading_() &&
        !isInternetExplorer) {
      goog.Dependency.defer_ = true;
      // Transpiled ES6 modules still need to load like regular ES6 modules,
      // aka only after the document is interactive.
      controller.pause();
      var oldCallback = doc.onreadystatechange;
      doc.onreadystatechange = function() {
        if (doc.readyState == 'interactive') {
          doc.onreadystatechange = oldCallback;
          load();
          controller.resume();
        }
        if (goog.isFunction(oldCallback)) {
          oldCallback.apply(undefined, arguments);
        }
      };
    } else {
      // Always eval on old IE.
      if (goog.DebugLoader_.IS_OLD_IE_ || !goog.inHtmlDocument_() ||
          !goog.isDocumentLoading_()) {
        load();
      } else {
        fetchInOwnScriptThenLoad();
      }
    }
  };


  /**
   * @param {string} contents
   * @return {string}
   * @abstract
   */
  goog.TransformedDependency.prototype.transform = function(contents) {};


  /**
   * Any non-goog.module dependency which needs to be transpiled before eval.
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @param {!goog.Transpiler} transpiler
   * @struct @constructor
   * @extends {goog.TransformedDependency}
   */
  goog.TranspiledDependency = function(
      path, relativePath, provides, requires, loadFlags, transpiler) {
    goog.TranspiledDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
    /** @protected @const*/
    this.transpiler = transpiler;
  };
  goog.inherits(goog.TranspiledDependency, goog.TransformedDependency);


  /** @override */
  goog.TranspiledDependency.prototype.transform = function(contents) {
    // Transpile with the pathname so that ES6 modules are domain agnostic.
    return this.transpiler.transpile(contents, this.getPathName());
  };


  /**
   * An ES6 module dependency that was transpiled to a jscomp module outside
   * of the debug loader, e.g. server side.
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @struct @constructor
   * @extends {goog.TransformedDependency}
   */
  goog.PreTranspiledEs6ModuleDependency = function(
      path, relativePath, provides, requires, loadFlags) {
    goog.PreTranspiledEs6ModuleDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
  };
  goog.inherits(
      goog.PreTranspiledEs6ModuleDependency, goog.TransformedDependency);


  /** @override */
  goog.PreTranspiledEs6ModuleDependency.prototype.transform = function(
      contents) {
    return contents;
  };


  /**
   * A goog.module, transpiled or not. Will always perform some minimal
   * transformation even when not transpiled to wrap in a goog.loadModule
   * statement.
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @param {boolean} needsTranspile
   * @param {!goog.Transpiler} transpiler
   * @struct @constructor
   * @extends {goog.TransformedDependency}
   */
  goog.GoogModuleDependency = function(
      path, relativePath, provides, requires, loadFlags, needsTranspile,
      transpiler) {
    goog.GoogModuleDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
    /** @private @const */
    this.needsTranspile_ = needsTranspile;
    /** @private @const */
    this.transpiler_ = transpiler;
  };
  goog.inherits(goog.GoogModuleDependency, goog.TransformedDependency);


  /** @override */
  goog.GoogModuleDependency.prototype.transform = function(contents) {
    if (this.needsTranspile_) {
      contents = this.transpiler_.transpile(contents, this.getPathName());
    }

    if (!goog.LOAD_MODULE_USING_EVAL || goog.global.JSON === undefined) {
      return '' +
          'goog.loadModule(function(exports) {' +
          '"use strict";' + contents +
          '\n' +  // terminate any trailing single line comment.
          ';return exports' +
          '});' +
          '\n//# sourceURL=' + this.path + '\n';
    } else {
      return '' +
          'goog.loadModule(' +
          goog.global.JSON.stringify(
              contents + '\n//# sourceURL=' + this.path + '\n') +
          ');';
    }
  };


  /**
   * Whether the browser is IE9 or earlier, which needs special handling
   * for deferred modules.
   * @const @private {boolean}
   */
  goog.DebugLoader_.IS_OLD_IE_ = !!(
      !goog.global.atob && goog.global.document && goog.global.document['all']);


  /**
   * @param {string} relPath
   * @param {!Array<string>|undefined} provides
   * @param {!Array<string>} requires
   * @param {boolean|!Object<string>=} opt_loadFlags
   * @see goog.addDependency
   */
  goog.DebugLoader_.prototype.addDependency = function(
      relPath, provides, requires, opt_loadFlags) {
    provides = provides || [];
    relPath = relPath.replace(/\\/g, '/');
    var path = goog.normalizePath_(goog.basePath + relPath);
    if (!opt_loadFlags || typeof opt_loadFlags === 'boolean') {
      opt_loadFlags = opt_loadFlags ? {'module': goog.ModuleType.GOOG} : {};
    }
    var dep = this.factory_.createDependency(
        path, relPath, provides, requires, opt_loadFlags,
        goog.transpiler_.needsTranspile(
            opt_loadFlags['lang'] || 'es3', opt_loadFlags['module']));
    this.dependencies_[path] = dep;
    for (var i = 0; i < provides.length; i++) {
      this.idToPath_[provides[i]] = path;
    }
    this.idToPath_[relPath] = path;
  };


  /**
   * Creates goog.Dependency instances for the debug loader to load.
   *
   * Should be overridden to have the debug loader use custom subclasses of
   * goog.Dependency.
   *
   * @param {!goog.Transpiler} transpiler
   * @struct @constructor
   */
  goog.DependencyFactory = function(transpiler) {
    /** @protected @const */
    this.transpiler = transpiler;
  };


  /**
   * @param {string} path Absolute path of the file.
   * @param {string} relativePath Path relative to closure’s base.js.
   * @param {!Array<string>} provides Array of provided goog.provide/module ids.
   * @param {!Array<string>} requires Array of required goog.provide/module /
   *     relative ES6 module paths.
   * @param {!Object<string, string>} loadFlags
   * @param {boolean} needsTranspile True if the file needs to be transpiled
   *     per the goog.Transpiler.
   * @return {!goog.Dependency}
   */
  goog.DependencyFactory.prototype.createDependency = function(
      path, relativePath, provides, requires, loadFlags, needsTranspile) {

    if (loadFlags['module'] == goog.ModuleType.GOOG) {
      return new goog.GoogModuleDependency(
          path, relativePath, provides, requires, loadFlags, needsTranspile,
          this.transpiler);
    } else if (needsTranspile) {
      return new goog.TranspiledDependency(
          path, relativePath, provides, requires, loadFlags, this.transpiler);
    } else {
      if (loadFlags['module'] == goog.ModuleType.ES6) {
        if (goog.TRANSPILE == 'never' && goog.ASSUME_ES_MODULES_TRANSPILED) {
          return new goog.PreTranspiledEs6ModuleDependency(
              path, relativePath, provides, requires, loadFlags);
        } else {
          return new goog.Es6ModuleDependency(
              path, relativePath, provides, requires, loadFlags);
        }
      } else {
        return new goog.Dependency(
            path, relativePath, provides, requires, loadFlags);
      }
    }
  };


  /** @private @const */
  goog.debugLoader_ = new goog.DebugLoader_();


  /**
   * Loads the Closure Dependency file.
   *
   * Exposed a public function so CLOSURE_NO_DEPS can be set to false, base
   * loaded, setDependencyFactory called, and then this called. i.e. allows
   * custom loading of the deps file.
   */
  goog.loadClosureDeps = function() {
    goog.debugLoader_.loadClosureDeps();
  };


  /**
   * Sets the dependency factory, which can be used to create custom
   * goog.Dependency implementations to control how dependencies are loaded.
   *
   * Note: if you wish to call this function and provide your own implemnetation
   * it is a wise idea to set CLOSURE_NO_DEPS to true, otherwise the dependency
   * file and all of its goog.addDependency calls will use the default factory.
   * You can call goog.loadClosureDeps to load the Closure dependency file
   * later, after your factory is injected.
   *
   * @param {!goog.DependencyFactory} factory
   */
  goog.setDependencyFactory = function(factory) {
    goog.debugLoader_.setDependencyFactory(factory);
  };


  if (!goog.global.CLOSURE_NO_DEPS) {
    goog.debugLoader_.loadClosureDeps();
  }


  /**
   * Bootstraps the given namespaces and calls the callback once they are
   * available either via goog.require. This is a replacement for using
   * `goog.require` to bootstrap Closure JavaScript. Previously a `goog.require`
   * in an HTML file would guarantee that the require'd namespace was available
   * in the next immediate script tag. With ES6 modules this no longer a
   * guarantee.
   *
   * @param {!Array<string>} namespaces
   * @param {function(): ?} callback Function to call once all the namespaces
   *     have loaded. Always called asynchronously.
   */
  goog.bootstrap = function(namespaces, callback) {
    goog.debugLoader_.bootstrap(namespaces, callback);
  };
}


/**
 * @define {string} Trusted Types policy name. If non-empty then Closure will
 * use Trusted Types.
 */
goog.TRUSTED_TYPES_POLICY_NAME =
    goog.define('goog.TRUSTED_TYPES_POLICY_NAME', '');


/**
 * Returns the parameter.
 * @param {string} s
 * @return {string}
 * @private
 */
goog.identity_ = function(s) {
  return s;
};


/**
 * Creates Trusted Types policy if Trusted Types are supported by the browser.
 * The policy just blesses any string as a Trusted Type. It is not visibility
 * restricted because anyone can also call TrustedTypes.createPolicy directly.
 * However, the allowed names should be restricted by a HTTP header and the
 * reference to the created policy should be visibility restricted.
 * @param {string} name
 * @return {?TrustedTypePolicy}
 */
goog.createTrustedTypesPolicy = function(name) {
  var policy = null;
  // TODO(koto): Remove window.TrustedTypes variant when the newer API ships.
  var policyFactory = goog.global.trustedTypes || goog.global.TrustedTypes;
  if (!policyFactory || !policyFactory.createPolicy) {
    return policy;
  }
  // TrustedTypes.createPolicy throws if called with a name that is already
  // registered, even in report-only mode. Until the API changes, catch the
  // error not to break the applications functionally. In such case, the code
  // will fall back to using regular Safe Types.
  // TODO(koto): Remove catching once createPolicy API stops throwing.
  try {
    policy = policyFactory.createPolicy(name, {
      createHTML: goog.identity_,
      createScript: goog.identity_,
      createScriptURL: goog.identity_,
      createURL: goog.identity_
    });
  } catch (e) {
    goog.logToConsole_(e.message);
  }
  return policy;
};


/** @private @const {?TrustedTypePolicy} */
goog.TRUSTED_TYPES_POLICY_ = goog.TRUSTED_TYPES_POLICY_NAME ?
    goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME + '#base') :
    null;

// Copyright 2019 The Closure Library 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.
//
// This file has been auto-generated by GenJsDeps, please do not edit.

// Disable Clang formatter for this file.
// See http://goo.gl/SdiwZH
// clang-format off

goog.addDependency('collections/sets.js', ['goog.collections.sets'], ['goog.labs.collections.iterables'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('collections/sets_test.js', ['goog.collections.setsTest'], ['goog.collections.sets', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferred.js', ['goog.async.Deferred', 'goog.async.Deferred.AlreadyCalledError', 'goog.async.Deferred.CanceledError'], ['goog.Promise', 'goog.Thenable', 'goog.array', 'goog.asserts', 'goog.debug.Error'], {});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferred_async_test.js', ['goog.async.deferredAsyncTest'], ['goog.async.Deferred', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferred_test.js', ['goog.async.deferredTest'], ['goog.Promise', 'goog.Thenable', 'goog.async.Deferred', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferredlist.js', ['goog.async.DeferredList'], ['goog.async.Deferred'], {});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferredlist_test.js', ['goog.async.deferredListTest'], ['goog.array', 'goog.async.Deferred', 'goog.async.DeferredList', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto/proto.js', ['goog.proto'], ['goog.proto.Serializer'], {});
goog.addDependency('proto/serializer.js', ['goog.proto.Serializer'], ['goog.json.Serializer', 'goog.string'], {});
goog.addDependency('proto/serializer_test.js', ['goog.protoTest'], ['goog.proto', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('a11y/aria/announcer.js', ['goog.a11y.aria.Announcer'], ['goog.Disposable', 'goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.LivePriority', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.object'], {});
goog.addDependency('a11y/aria/announcer_test.js', ['goog.a11y.aria.AnnouncerTest'], ['goog.a11y.aria', 'goog.a11y.aria.Announcer', 'goog.a11y.aria.LivePriority', 'goog.a11y.aria.State', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.iframe', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('a11y/aria/aria.js', ['goog.a11y.aria'], ['goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.a11y.aria.datatables', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.object', 'goog.string'], {});
goog.addDependency('a11y/aria/aria_test.js', ['goog.a11y.ariaTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('a11y/aria/attributes.js', ['goog.a11y.aria.AutoCompleteValues', 'goog.a11y.aria.CheckedValues', 'goog.a11y.aria.DropEffectValues', 'goog.a11y.aria.ExpandedValues', 'goog.a11y.aria.GrabbedValues', 'goog.a11y.aria.InvalidValues', 'goog.a11y.aria.LivePriority', 'goog.a11y.aria.OrientationValues', 'goog.a11y.aria.PressedValues', 'goog.a11y.aria.RelevantValues', 'goog.a11y.aria.SelectedValues', 'goog.a11y.aria.SortValues', 'goog.a11y.aria.State'], [], {});
goog.addDependency('a11y/aria/datatables.js', ['goog.a11y.aria.datatables'], ['goog.a11y.aria.State', 'goog.object'], {});
goog.addDependency('a11y/aria/roles.js', ['goog.a11y.aria.Role'], [], {});
goog.addDependency('array/array.js', ['goog.array'], ['goog.asserts'], {});
goog.addDependency('array/array_test.js', ['goog.arrayTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es7', 'module': 'goog'});
goog.addDependency('asserts/asserts.js', ['goog.asserts', 'goog.asserts.AssertionError'], ['goog.debug.Error', 'goog.dom.NodeType'], {});
goog.addDependency('asserts/asserts_test.js', ['goog.assertsTest'], ['goog.asserts', 'goog.asserts.AssertionError', 'goog.dom', 'goog.dom.TagName', 'goog.reflect', 'goog.string', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/animationdelay.js', ['goog.async.AnimationDelay'], ['goog.Disposable', 'goog.events', 'goog.functions'], {});
goog.addDependency('async/animationdelay_test.js', ['goog.async.AnimationDelayTest'], ['goog.Promise', 'goog.Timer', 'goog.async.AnimationDelay', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/conditionaldelay.js', ['goog.async.ConditionalDelay'], ['goog.Disposable', 'goog.async.Delay'], {});
goog.addDependency('async/conditionaldelay_test.js', ['goog.async.ConditionalDelayTest'], ['goog.async.ConditionalDelay', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/debouncer.js', ['goog.async.Debouncer'], ['goog.Disposable', 'goog.Timer'], {});
goog.addDependency('async/debouncer_test.js', ['goog.async.DebouncerTest'], ['goog.array', 'goog.async.Debouncer', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/delay.js', ['goog.Delay', 'goog.async.Delay'], ['goog.Disposable', 'goog.Timer'], {});
goog.addDependency('async/delay_test.js', ['goog.async.DelayTest'], ['goog.async.Delay', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/freelist.js', ['goog.async.FreeList'], [], {'lang': 'es6'});
goog.addDependency('async/freelist_test.js', ['goog.async.FreeListTest'], ['goog.async.FreeList', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/nexttick.js', ['goog.async.nextTick', 'goog.async.throwException'], ['goog.debug.entryPointRegistry', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.labs.userAgent.browser', 'goog.labs.userAgent.engine', 'goog.string.Const'], {});
goog.addDependency('async/nexttick_test.js', ['goog.async.nextTickTest'], ['goog.Promise', 'goog.async.nextTick', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.dom', 'goog.dom.TagName', 'goog.labs.userAgent.browser', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/run.js', ['goog.async.run'], ['goog.async.WorkQueue', 'goog.async.nextTick', 'goog.async.throwException'], {});
goog.addDependency('async/run_next_tick_test.js', ['goog.async.runNextTickTest'], ['goog.async.run', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/run_test.js', ['goog.async.runTest'], ['goog.async.run', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/throttle.js', ['goog.Throttle', 'goog.async.Throttle'], ['goog.Disposable', 'goog.Timer'], {});
goog.addDependency('async/throttle_test.js', ['goog.async.ThrottleTest'], ['goog.async.Throttle', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/workqueue.js', ['goog.async.WorkItem', 'goog.async.WorkQueue'], ['goog.asserts', 'goog.async.FreeList'], {});
goog.addDependency('async/workqueue_test.js', ['goog.async.WorkQueueTest'], ['goog.async.WorkQueue', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('base.js', ['goog'], [], {});
goog.addDependency('base_module_test.js', ['goog.baseModuleTest'], ['goog.Timer', 'goog.test_module', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('base_test.js', ['goog.baseTest'], ['goog.Promise', 'goog.Timer', 'goog.Uri', 'goog.dom', 'goog.dom.TagName', 'goog.object', 'goog.test_module', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit', 'goog.testing.recordFunction', 'goog.userAgent'], {'lang': 'es6'});
goog.addDependency('color/alpha.js', ['goog.color.alpha'], ['goog.color'], {});
goog.addDependency('color/alpha_test.js', ['goog.color.alphaTest'], ['goog.array', 'goog.color.alpha', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('color/color.js', ['goog.color', 'goog.color.Hsl', 'goog.color.Hsv', 'goog.color.Rgb'], ['goog.color.names', 'goog.math'], {});
goog.addDependency('color/color_test.js', ['goog.colorTest'], ['goog.array', 'goog.color', 'goog.color.names', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('color/names.js', ['goog.color.names'], [], {});
goog.addDependency('crypt/aes.js', ['goog.crypt.Aes'], ['goog.asserts', 'goog.crypt.BlockCipher'], {});
goog.addDependency('crypt/aes_test.js', ['goog.crypt.AesTest'], ['goog.crypt', 'goog.crypt.Aes', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/arc4.js', ['goog.crypt.Arc4'], ['goog.asserts'], {});
goog.addDependency('crypt/arc4_test.js', ['goog.crypt.Arc4Test'], ['goog.array', 'goog.crypt.Arc4', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/base64.js', ['goog.crypt.base64'], ['goog.asserts', 'goog.crypt', 'goog.string', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es5'});
goog.addDependency('crypt/base64_test.js', ['goog.crypt.base64Test'], ['goog.crypt', 'goog.crypt.base64', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/basen.js', ['goog.crypt.baseN'], [], {'lang': 'es6'});
goog.addDependency('crypt/basen_test.js', ['goog.crypt.baseNTest'], ['goog.crypt.baseN', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/blobhasher.js', ['goog.crypt.BlobHasher', 'goog.crypt.BlobHasher.EventType'], ['goog.asserts', 'goog.events.EventTarget', 'goog.fs', 'goog.log'], {});
goog.addDependency('crypt/blobhasher_test.js', ['goog.crypt.BlobHasherTest'], ['goog.crypt', 'goog.crypt.BlobHasher', 'goog.crypt.Md5', 'goog.events', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/blockcipher.js', ['goog.crypt.BlockCipher'], [], {});
goog.addDependency('crypt/bytestring_perf.js', ['goog.crypt.byteArrayToStringPerf'], ['goog.array', 'goog.dom', 'goog.testing.PerformanceTable'], {});
goog.addDependency('crypt/cbc.js', ['goog.crypt.Cbc'], ['goog.array', 'goog.asserts', 'goog.crypt', 'goog.crypt.BlockCipher'], {});
goog.addDependency('crypt/cbc_test.js', ['goog.crypt.CbcTest'], ['goog.crypt', 'goog.crypt.Aes', 'goog.crypt.Cbc', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/crypt.js', ['goog.crypt'], ['goog.array', 'goog.asserts'], {});
goog.addDependency('crypt/crypt_test.js', ['goog.cryptTest'], ['goog.crypt', 'goog.string', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/ctr.js', ['goog.crypt.Ctr'], ['goog.array', 'goog.asserts', 'goog.crypt'], {});
goog.addDependency('crypt/ctr_test.js', ['goog.crypt.CtrTest'], ['goog.crypt', 'goog.crypt.Aes', 'goog.crypt.Ctr', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('crypt/hash.js', ['goog.crypt.Hash'], [], {});
goog.addDependency('crypt/hash32.js', ['goog.crypt.hash32'], ['goog.crypt'], {});
goog.addDependency('crypt/hash32_test.js', ['goog.crypt.hash32Test'], ['goog.crypt.hash32', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/hashtester.js', ['goog.crypt.hashTester'], ['goog.array', 'goog.crypt', 'goog.dom', 'goog.dom.TagName', 'goog.reflect', 'goog.testing.PerformanceTable', 'goog.testing.PseudoRandom', 'goog.testing.asserts'], {});
goog.addDependency('crypt/hmac.js', ['goog.crypt.Hmac'], ['goog.crypt.Hash'], {});
goog.addDependency('crypt/hmac_test.js', ['goog.crypt.HmacTest'], ['goog.crypt.Hmac', 'goog.crypt.Sha1', 'goog.crypt.hashTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/md5.js', ['goog.crypt.Md5'], ['goog.crypt.Hash'], {});
goog.addDependency('crypt/md5_test.js', ['goog.crypt.Md5Test'], ['goog.crypt', 'goog.crypt.Md5', 'goog.crypt.hashTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/pbkdf2.js', ['goog.crypt.pbkdf2'], ['goog.array', 'goog.asserts', 'goog.crypt', 'goog.crypt.Hmac', 'goog.crypt.Sha1'], {});
goog.addDependency('crypt/pbkdf2_test.js', ['goog.crypt.pbkdf2Test'], ['goog.crypt', 'goog.crypt.pbkdf2', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha1.js', ['goog.crypt.Sha1'], ['goog.crypt.Hash'], {});
goog.addDependency('crypt/sha1_test.js', ['goog.crypt.Sha1Test'], ['goog.crypt', 'goog.crypt.Sha1', 'goog.crypt.hashTester', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha2.js', ['goog.crypt.Sha2'], ['goog.array', 'goog.asserts', 'goog.crypt.Hash'], {});
goog.addDependency('crypt/sha224.js', ['goog.crypt.Sha224'], ['goog.crypt.Sha2'], {});
goog.addDependency('crypt/sha224_test.js', ['goog.crypt.Sha224Test'], ['goog.crypt', 'goog.crypt.Sha224', 'goog.crypt.hashTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha256.js', ['goog.crypt.Sha256'], ['goog.crypt.Sha2'], {});
goog.addDependency('crypt/sha256_test.js', ['goog.crypt.Sha256Test'], ['goog.crypt', 'goog.crypt.Sha256', 'goog.crypt.hashTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha2_64bit.js', ['goog.crypt.Sha2_64bit'], ['goog.array', 'goog.asserts', 'goog.crypt.Hash', 'goog.math.Long'], {});
goog.addDependency('crypt/sha2_64bit_test.js', ['goog.crypt.Sha2_64bit_test'], ['goog.array', 'goog.crypt', 'goog.crypt.Sha384', 'goog.crypt.Sha512', 'goog.crypt.Sha512_256', 'goog.crypt.hashTester', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha384.js', ['goog.crypt.Sha384'], ['goog.crypt.Sha2_64bit'], {});
goog.addDependency('crypt/sha512.js', ['goog.crypt.Sha512'], ['goog.crypt.Sha2_64bit'], {});
goog.addDependency('crypt/sha512_256.js', ['goog.crypt.Sha512_256'], ['goog.crypt.Sha2_64bit'], {});
goog.addDependency('cssom/cssom.js', ['goog.cssom', 'goog.cssom.CssRuleType'], ['goog.array', 'goog.dom', 'goog.dom.TagName'], {});
goog.addDependency('cssom/cssom_test.js', ['goog.cssomTest'], ['goog.array', 'goog.cssom', 'goog.cssom.CssRuleType', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('cssom/iframe/style.js', ['goog.cssom.iframe.style'], ['goog.asserts', 'goog.cssom', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.string', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('cssom/iframe/style_test.js', ['goog.cssom.iframe.styleTest'], ['goog.cssom', 'goog.cssom.iframe.style', 'goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/datamanager.js', ['goog.ds.DataManager'], ['goog.ds.BasicNodeList', 'goog.ds.DataNode', 'goog.ds.Expr', 'goog.object', 'goog.string', 'goog.structs', 'goog.structs.Map'], {});
goog.addDependency('datasource/datasource.js', ['goog.ds.BaseDataNode', 'goog.ds.BasicNodeList', 'goog.ds.DataNode', 'goog.ds.DataNodeList', 'goog.ds.EmptyNodeList', 'goog.ds.LoadState', 'goog.ds.SortedNodeList', 'goog.ds.Util', 'goog.ds.logger'], ['goog.array', 'goog.log'], {});
goog.addDependency('datasource/datasource_test.js', ['goog.ds.JsDataSourceTest'], ['goog.dom.xml', 'goog.ds.DataManager', 'goog.ds.JsDataSource', 'goog.ds.SortedNodeList', 'goog.ds.XmlDataSource', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/expr.js', ['goog.ds.Expr'], ['goog.ds.BasicNodeList', 'goog.ds.EmptyNodeList', 'goog.string'], {});
goog.addDependency('datasource/expr_test.js', ['goog.ds.ExprTest'], ['goog.ds.DataManager', 'goog.ds.Expr', 'goog.ds.JsDataSource', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/fastdatanode.js', ['goog.ds.AbstractFastDataNode', 'goog.ds.FastDataNode', 'goog.ds.FastListNode', 'goog.ds.PrimitiveFastDataNode'], ['goog.ds.DataManager', 'goog.ds.DataNodeList', 'goog.ds.EmptyNodeList', 'goog.string'], {});
goog.addDependency('datasource/fastdatanode_test.js', ['goog.ds.FastDataNodeTest'], ['goog.array', 'goog.ds.DataManager', 'goog.ds.Expr', 'goog.ds.FastDataNode', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/jsdatasource.js', ['goog.ds.JsDataSource', 'goog.ds.JsPropertyDataSource'], ['goog.ds.BaseDataNode', 'goog.ds.BasicNodeList', 'goog.ds.DataManager', 'goog.ds.DataNode', 'goog.ds.EmptyNodeList', 'goog.ds.LoadState'], {});
goog.addDependency('datasource/jsondatasource.js', ['goog.ds.JsonDataSource'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.ds.DataManager', 'goog.ds.JsDataSource', 'goog.ds.LoadState', 'goog.ds.logger', 'goog.log'], {});
goog.addDependency('datasource/jsxmlhttpdatasource.js', ['goog.ds.JsXmlHttpDataSource'], ['goog.Uri', 'goog.ds.DataManager', 'goog.ds.FastDataNode', 'goog.ds.LoadState', 'goog.ds.logger', 'goog.events', 'goog.log', 'goog.net.EventType', 'goog.net.XhrIo'], {});
goog.addDependency('datasource/jsxmlhttpdatasource_test.js', ['goog.ds.JsXmlHttpDataSourceTest'], ['goog.ds.JsXmlHttpDataSource', 'goog.testing.TestQueue', 'goog.testing.net.XhrIo', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/xmldatasource.js', ['goog.ds.XmlDataSource', 'goog.ds.XmlHttpDataSource'], ['goog.Uri', 'goog.dom.NodeType', 'goog.dom.xml', 'goog.ds.BasicNodeList', 'goog.ds.DataManager', 'goog.ds.DataNode', 'goog.ds.LoadState', 'goog.ds.logger', 'goog.log', 'goog.net.XhrIo', 'goog.string'], {});
goog.addDependency('date/date.js', ['goog.date', 'goog.date.Date', 'goog.date.DateTime', 'goog.date.Interval', 'goog.date.month', 'goog.date.weekDay'], ['goog.asserts', 'goog.date.DateLike', 'goog.i18n.DateTimeSymbols', 'goog.string'], {});
goog.addDependency('date/date_test.js', ['goog.dateTest'], ['goog.array', 'goog.date', 'goog.date.Date', 'goog.date.DateTime', 'goog.date.Interval', 'goog.date.month', 'goog.date.weekDay', 'goog.i18n.DateTimeSymbols', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.platform', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('date/datelike.js', ['goog.date.DateLike'], [], {});
goog.addDependency('date/daterange.js', ['goog.date.DateRange', 'goog.date.DateRange.Iterator', 'goog.date.DateRange.StandardDateRangeKeys'], ['goog.date.Date', 'goog.date.Interval', 'goog.iter.Iterator', 'goog.iter.StopIteration'], {});
goog.addDependency('date/daterange_test.js', ['goog.date.DateRangeTest'], ['goog.date.Date', 'goog.date.DateRange', 'goog.date.Interval', 'goog.i18n.DateTimeSymbols', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('date/duration.js', ['goog.date.duration'], ['goog.i18n.DateTimeFormat', 'goog.i18n.MessageFormat'], {});
goog.addDependency('date/duration_test.js', ['goog.date.durationTest'], ['goog.date.duration', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbols_bn', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_fa', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('date/relative.js', ['goog.date.relative', 'goog.date.relative.TimeDeltaFormatter', 'goog.date.relative.Unit'], ['goog.i18n.DateTimeFormat', 'goog.i18n.DateTimePatterns', 'goog.i18n.RelativeDateTimeFormat'], {});
goog.addDependency('date/relative_test.js', ['goog.date.relativeTest'], ['goog.date.relativeCommonTests'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('date/relativecommontests.js', ['goog.date.relativeCommonTests'], ['goog.date.DateTime', 'goog.date.relative', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimePatterns_ar', 'goog.i18n.DateTimePatterns_bn', 'goog.i18n.DateTimePatterns_es', 'goog.i18n.DateTimePatterns_fa', 'goog.i18n.DateTimePatterns_fr', 'goog.i18n.DateTimePatterns_no', 'goog.i18n.DateTimeSymbols_ar', 'goog.i18n.DateTimeSymbols_bn', 'goog.i18n.DateTimeSymbols_es', 'goog.i18n.DateTimeSymbols_fa', 'goog.i18n.DateTimeSymbols_fr', 'goog.i18n.DateTimeSymbols_no', 'goog.i18n.NumberFormatSymbols_bn', 'goog.i18n.NumberFormatSymbols_en', 'goog.i18n.NumberFormatSymbols_fa', 'goog.i18n.NumberFormatSymbols_no', 'goog.i18n.relativeDateTimeSymbols', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('date/utcdatetime.js', ['goog.date.UtcDateTime'], ['goog.date', 'goog.date.Date', 'goog.date.DateTime', 'goog.date.Interval'], {});
goog.addDependency('date/utcdatetime_test.js', ['goog.date.UtcDateTimeTest'], ['goog.date.Interval', 'goog.date.UtcDateTime', 'goog.date.month', 'goog.date.weekDay', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('db/cursor.js', ['goog.db.Cursor'], ['goog.async.Deferred', 'goog.db.Error', 'goog.db.KeyRange', 'goog.debug', 'goog.events.EventTarget'], {});
goog.addDependency('db/db.js', ['goog.db', 'goog.db.BlockedCallback', 'goog.db.UpgradeNeededCallback'], ['goog.asserts', 'goog.async.Deferred', 'goog.db.Error', 'goog.db.IndexedDb', 'goog.db.Transaction'], {});
goog.addDependency('db/db_test.js', ['goog.dbTest'], ['goog.Promise', 'goog.array', 'goog.db', 'goog.db.Cursor', 'goog.db.Error', 'goog.db.IndexedDb', 'goog.db.KeyRange', 'goog.db.Transaction', 'goog.events', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('db/error.js', ['goog.db.DomErrorLike', 'goog.db.Error', 'goog.db.Error.ErrorCode', 'goog.db.Error.ErrorName', 'goog.db.Error.VersionChangeBlockedError'], ['goog.asserts', 'goog.debug.Error'], {});
goog.addDependency('db/index.js', ['goog.db.Index'], ['goog.async.Deferred', 'goog.db.Cursor', 'goog.db.Error', 'goog.db.KeyRange', 'goog.debug'], {});
goog.addDependency('db/indexeddb.js', ['goog.db.IndexedDb'], ['goog.db.Error', 'goog.db.ObjectStore', 'goog.db.Transaction', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget'], {'lang': 'es6'});
goog.addDependency('db/keyrange.js', ['goog.db.KeyRange'], [], {});
goog.addDependency('db/objectstore.js', ['goog.db.ObjectStore'], ['goog.async.Deferred', 'goog.db.Cursor', 'goog.db.Error', 'goog.db.Index', 'goog.db.KeyRange', 'goog.debug'], {});
goog.addDependency('db/transaction.js', ['goog.db.Transaction', 'goog.db.Transaction.TransactionMode'], ['goog.async.Deferred', 'goog.db.Error', 'goog.db.ObjectStore', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventTarget'], {});
goog.addDependency('debug/console.js', ['goog.debug.Console'], ['goog.debug.LogManager', 'goog.debug.Logger', 'goog.debug.TextFormatter'], {});
goog.addDependency('debug/console_test.js', ['goog.debug.ConsoleTest'], ['goog.debug.Console', 'goog.debug.LogRecord', 'goog.debug.Logger', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/debug.js', ['goog.debug'], ['goog.array', 'goog.debug.errorcontext', 'goog.userAgent'], {});
goog.addDependency('debug/debug_test.js', ['goog.debugTest'], ['goog.debug', 'goog.debug.errorcontext', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/debugwindow.js', ['goog.debug.DebugWindow'], ['goog.debug.HtmlFormatter', 'goog.debug.LogManager', 'goog.debug.Logger', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.string.Const', 'goog.structs.CircularBuffer', 'goog.userAgent'], {});
goog.addDependency('debug/debugwindow_test.js', ['goog.debug.DebugWindowTest'], ['goog.debug.DebugWindow', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/devcss/devcss.js', ['goog.debug.DevCss', 'goog.debug.DevCss.UserAgent'], ['goog.asserts', 'goog.cssom', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('debug/devcss/devcss_test.js', ['goog.debug.DevCssTest'], ['goog.debug.DevCss', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/devcss/devcssrunner.js', ['goog.debug.devCssRunner'], ['goog.debug.DevCss'], {});
goog.addDependency('debug/divconsole.js', ['goog.debug.DivConsole'], ['goog.debug.HtmlFormatter', 'goog.debug.LogManager', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.string.Const', 'goog.style'], {});
goog.addDependency('debug/enhanceerror_test.js', ['goog.debugEnhanceErrorTest'], ['goog.debug', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/entrypointregistry.js', ['goog.debug.EntryPointMonitor', 'goog.debug.entryPointRegistry'], ['goog.asserts'], {});
goog.addDependency('debug/entrypointregistry_test.js', ['goog.debug.entryPointRegistryTest'], ['goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/error.js', ['goog.debug.Error'], [], {'lang': 'es6'});
goog.addDependency('debug/error_test.js', ['goog.debug.ErrorTest'], ['goog.debug.Error', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/errorcontext.js', ['goog.debug.errorcontext'], [], {});
goog.addDependency('debug/errorcontext_test.js', ['goog.debug.errorcontextTest'], ['goog.debug.errorcontext', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/errorhandler.js', ['goog.debug.ErrorHandler', 'goog.debug.ErrorHandler.ProtectedFunctionError'], ['goog.Disposable', 'goog.asserts', 'goog.debug', 'goog.debug.EntryPointMonitor', 'goog.debug.Error', 'goog.debug.Trace'], {'lang': 'es6'});
goog.addDependency('debug/errorhandler_async_test.js', ['goog.debug.ErrorHandlerAsyncTest'], ['goog.Promise', 'goog.debug.ErrorHandler', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('debug/errorhandler_test.js', ['goog.debug.ErrorHandlerTest'], ['goog.debug.ErrorHandler', 'goog.testing.MockControl', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/errorhandlerweakdep.js', ['goog.debug.errorHandlerWeakDep'], [], {});
goog.addDependency('debug/errorreporter.js', ['goog.debug.ErrorReporter', 'goog.debug.ErrorReporter.ExceptionEvent'], ['goog.asserts', 'goog.debug', 'goog.debug.Error', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.debug.errorcontext', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.log', 'goog.net.XhrIo', 'goog.object', 'goog.string', 'goog.uri.utils', 'goog.userAgent'], {});
goog.addDependency('debug/errorreporter_test.js', ['goog.debug.ErrorReporterTest'], ['goog.debug.Error', 'goog.debug.ErrorReporter', 'goog.debug.errorcontext', 'goog.events', 'goog.functions', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/fancywindow.js', ['goog.debug.FancyWindow'], ['goog.array', 'goog.asserts', 'goog.debug.DebugWindow', 'goog.debug.LogManager', 'goog.debug.Logger', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.object', 'goog.string', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('debug/formatter.js', ['goog.debug.Formatter', 'goog.debug.HtmlFormatter', 'goog.debug.TextFormatter'], ['goog.debug', 'goog.debug.Logger', 'goog.debug.RelativeTimeProvider', 'goog.html.SafeHtml', 'goog.html.SafeUrl', 'goog.html.uncheckedconversions', 'goog.string.Const'], {});
goog.addDependency('debug/formatter_test.js', ['goog.debug.FormatterTest'], ['goog.debug.HtmlFormatter', 'goog.debug.LogRecord', 'goog.debug.Logger', 'goog.html.SafeHtml', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/fpsdisplay.js', ['goog.debug.FpsDisplay'], ['goog.asserts', 'goog.async.AnimationDelay', 'goog.dom', 'goog.dom.TagName', 'goog.ui.Component'], {});
goog.addDependency('debug/fpsdisplay_test.js', ['goog.debug.FpsDisplayTest'], ['goog.Timer', 'goog.debug.FpsDisplay', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/logbuffer.js', ['goog.debug.LogBuffer'], ['goog.asserts', 'goog.debug.LogRecord'], {});
goog.addDependency('debug/logbuffer_test.js', ['goog.debug.LogBufferTest'], ['goog.debug.LogBuffer', 'goog.debug.Logger', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/logger.js', ['goog.debug.LogManager', 'goog.debug.Loggable', 'goog.debug.Logger', 'goog.debug.Logger.Level'], ['goog.array', 'goog.asserts', 'goog.debug', 'goog.debug.LogBuffer', 'goog.debug.LogRecord'], {});
goog.addDependency('debug/logger_test.js', ['goog.debug.LoggerTest'], ['goog.debug.LogManager', 'goog.debug.Logger', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/logrecord.js', ['goog.debug.LogRecord'], [], {});
goog.addDependency('debug/logrecordserializer.js', ['goog.debug.logRecordSerializer'], ['goog.debug.LogRecord', 'goog.debug.Logger', 'goog.json', 'goog.object'], {});
goog.addDependency('debug/logrecordserializer_test.js', ['goog.debug.logRecordSerializerTest'], ['goog.debug.LogRecord', 'goog.debug.Logger', 'goog.debug.logRecordSerializer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/relativetimeprovider.js', ['goog.debug.RelativeTimeProvider'], [], {});
goog.addDependency('debug/tracer.js', ['goog.debug.StopTraceDetail', 'goog.debug.Trace'], ['goog.array', 'goog.asserts', 'goog.debug.Logger', 'goog.iter', 'goog.log', 'goog.structs.Map', 'goog.structs.SimplePool'], {});
goog.addDependency('debug/tracer_test.js', ['goog.debug.TraceTest'], ['goog.array', 'goog.debug.Trace', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('defineclass_test.js', ['goog.defineClassTest'], ['goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('delegate/delegateregistry.js', ['goog.delegate.DelegateRegistry'], ['goog.array', 'goog.asserts', 'goog.debug'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('delegate/delegateregistry_test.js', ['goog.delegate.DelegateRegistryTest'], ['goog.array', 'goog.delegate.DelegateRegistry', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('delegate/delegates.js', ['goog.delegate.delegates'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('delegate/delegates_test.js', ['goog.delegate.delegatesTest'], ['goog.delegate.delegates', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('disposable/disposable.js', ['goog.Disposable', 'goog.dispose', 'goog.disposeAll'], ['goog.disposable.IDisposable'], {});
goog.addDependency('disposable/disposable_test.js', ['goog.DisposableTest'], ['goog.Disposable', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('disposable/idisposable.js', ['goog.disposable.IDisposable'], [], {});
goog.addDependency('dom/abstractmultirange.js', ['goog.dom.AbstractMultiRange'], ['goog.array', 'goog.dom', 'goog.dom.AbstractRange', 'goog.dom.TextRange'], {});
goog.addDependency('dom/abstractrange.js', ['goog.dom.AbstractRange', 'goog.dom.RangeIterator', 'goog.dom.RangeType'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.SavedCaretRange', 'goog.dom.TagIterator', 'goog.userAgent'], {});
goog.addDependency('dom/abstractrange_test.js', ['goog.dom.AbstractRangeTest'], ['goog.dom', 'goog.dom.AbstractRange', 'goog.dom.Range', 'goog.dom.TagName', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/animationframe/animationframe.js', ['goog.dom.animationFrame', 'goog.dom.animationFrame.Spec', 'goog.dom.animationFrame.State'], ['goog.dom.animationFrame.polyfill'], {});
goog.addDependency('dom/animationframe/animationframe_test.js', ['goog.dom.AnimationFrameTest'], ['goog.dom.animationFrame', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/animationframe/polyfill.js', ['goog.dom.animationFrame.polyfill'], [], {'lang': 'es6'});
goog.addDependency('dom/annotate.js', ['goog.dom.annotate', 'goog.dom.annotate.AnnotateFn'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.object'], {});
goog.addDependency('dom/annotate_test.js', ['goog.dom.annotateTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.annotate', 'goog.html.SafeHtml', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/asserts.js', ['goog.dom.asserts'], ['goog.asserts'], {});
goog.addDependency('dom/asserts_test.js', ['goog.dom.assertsTest'], ['goog.dom.asserts', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/attr.js', ['goog.dom.Attr'], [], {});
goog.addDependency('dom/browserfeature.js', ['goog.dom.BrowserFeature'], ['goog.userAgent'], {});
goog.addDependency('dom/browserfeature_test.js', ['goog.dom.BrowserFeatureTest'], ['goog.dom', 'goog.dom.BrowserFeature', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/browserrange/abstractrange.js', ['goog.dom.browserrange.AbstractRange'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.RangeEndpoint', 'goog.dom.TagName', 'goog.dom.TextRangeIterator', 'goog.iter', 'goog.math.Coordinate', 'goog.string', 'goog.string.StringBuffer', 'goog.userAgent'], {});
goog.addDependency('dom/browserrange/browserrange.js', ['goog.dom.browserrange', 'goog.dom.browserrange.Error'], ['goog.dom', 'goog.dom.BrowserFeature', 'goog.dom.NodeType', 'goog.dom.browserrange.GeckoRange', 'goog.dom.browserrange.IeRange', 'goog.dom.browserrange.OperaRange', 'goog.dom.browserrange.W3cRange', 'goog.dom.browserrange.WebKitRange', 'goog.userAgent'], {});
goog.addDependency('dom/browserrange/browserrange_test.js', ['goog.dom.browserrangeTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.RangeEndpoint', 'goog.dom.TagName', 'goog.dom.browserrange', 'goog.html.testing', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/browserrange/geckorange.js', ['goog.dom.browserrange.GeckoRange'], ['goog.dom.browserrange.W3cRange'], {});
goog.addDependency('dom/browserrange/ierange.js', ['goog.dom.browserrange.IeRange'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.RangeEndpoint', 'goog.dom.TagName', 'goog.dom.browserrange.AbstractRange', 'goog.dom.safe', 'goog.html.uncheckedconversions', 'goog.log', 'goog.string'], {});
goog.addDependency('dom/browserrange/operarange.js', ['goog.dom.browserrange.OperaRange'], ['goog.dom.browserrange.W3cRange'], {});
goog.addDependency('dom/browserrange/w3crange.js', ['goog.dom.browserrange.W3cRange'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.RangeEndpoint', 'goog.dom.TagName', 'goog.dom.browserrange.AbstractRange', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('dom/browserrange/webkitrange.js', ['goog.dom.browserrange.WebKitRange'], ['goog.dom.RangeEndpoint', 'goog.dom.browserrange.W3cRange', 'goog.userAgent'], {});
goog.addDependency('dom/bufferedviewportsizemonitor.js', ['goog.dom.BufferedViewportSizeMonitor'], ['goog.asserts', 'goog.async.Delay', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType'], {});
goog.addDependency('dom/bufferedviewportsizemonitor_test.js', ['goog.dom.BufferedViewportSizeMonitorTest'], ['goog.dom.BufferedViewportSizeMonitor', 'goog.dom.ViewportSizeMonitor', 'goog.events', 'goog.events.EventType', 'goog.math.Size', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/classes.js', ['goog.dom.classes'], ['goog.array'], {});
goog.addDependency('dom/classes_test.js', ['goog.dom.classes_test'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classes', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/classlist.js', ['goog.dom.classlist'], ['goog.array'], {});
goog.addDependency('dom/classlist_test.js', ['goog.dom.classlist_test'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/controlrange.js', ['goog.dom.ControlRange', 'goog.dom.ControlRangeIterator'], ['goog.array', 'goog.dom', 'goog.dom.AbstractMultiRange', 'goog.dom.AbstractRange', 'goog.dom.RangeIterator', 'goog.dom.RangeType', 'goog.dom.SavedRange', 'goog.dom.TagWalkType', 'goog.dom.TextRange', 'goog.iter.StopIteration', 'goog.userAgent'], {});
goog.addDependency('dom/controlrange_test.js', ['goog.dom.ControlRangeTest'], ['goog.dom', 'goog.dom.ControlRange', 'goog.dom.RangeType', 'goog.dom.TagName', 'goog.dom.TextRange', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/dataset.js', ['goog.dom.dataset'], ['goog.labs.userAgent.browser', 'goog.string', 'goog.userAgent.product'], {});
goog.addDependency('dom/dataset_test.js', ['goog.dom.datasetTest'], ['goog.dom', 'goog.dom.dataset', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/dom.js', ['goog.dom', 'goog.dom.Appendable', 'goog.dom.DomHelper'], ['goog.array', 'goog.asserts', 'goog.dom.BrowserFeature', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.uncheckedconversions', 'goog.math.Coordinate', 'goog.math.Size', 'goog.object', 'goog.string', 'goog.string.Unicode', 'goog.userAgent'], {});
goog.addDependency('dom/dom_compile_test.js', ['goog.dom.DomCompileTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/dom_test.js', ['goog.dom.dom_test'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.BrowserFeature', 'goog.dom.DomHelper', 'goog.dom.InputType', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.functions', 'goog.html.SafeUrl', 'goog.html.testing', 'goog.object', 'goog.string.Const', 'goog.string.Unicode', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/fontsizemonitor.js', ['goog.dom.FontSizeMonitor', 'goog.dom.FontSizeMonitor.EventType'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.userAgent'], {});
goog.addDependency('dom/fontsizemonitor_test.js', ['goog.dom.FontSizeMonitorTest'], ['goog.dom', 'goog.dom.FontSizeMonitor', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/forms.js', ['goog.dom.forms'], ['goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.structs.Map', 'goog.window'], {});
goog.addDependency('dom/forms_test.js', ['goog.dom.formsTest'], ['goog.dom', 'goog.dom.forms', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/fullscreen.js', ['goog.dom.fullscreen', 'goog.dom.fullscreen.EventType'], ['goog.dom'], {});
goog.addDependency('dom/fullscreen_test.js', ['goog.dom.fullscreen_test'], ['goog.dom.DomHelper', 'goog.dom.fullscreen', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/htmlelement.js', ['goog.dom.HtmlElement'], [], {});
goog.addDependency('dom/iframe.js', ['goog.dom.iframe'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyle', 'goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('dom/iframe_test.js', ['goog.dom.iframeTest'], ['goog.dom', 'goog.dom.iframe', 'goog.html.SafeHtml', 'goog.html.SafeStyle', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/inputtype.js', ['goog.dom.InputType'], [], {});
goog.addDependency('dom/inputtype_test.js', ['goog.dom.InputTypeTest'], ['goog.dom.InputType', 'goog.object', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/iter.js', ['goog.dom.iter.AncestorIterator', 'goog.dom.iter.ChildIterator', 'goog.dom.iter.SiblingIterator'], ['goog.iter.Iterator', 'goog.iter.StopIteration'], {});
goog.addDependency('dom/iter_test.js', ['goog.dom.iterTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.iter.AncestorIterator', 'goog.dom.iter.ChildIterator', 'goog.dom.iter.SiblingIterator', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/multirange.js', ['goog.dom.MultiRange', 'goog.dom.MultiRangeIterator'], ['goog.array', 'goog.dom', 'goog.dom.AbstractMultiRange', 'goog.dom.AbstractRange', 'goog.dom.RangeIterator', 'goog.dom.RangeType', 'goog.dom.SavedRange', 'goog.dom.TextRange', 'goog.iter', 'goog.iter.StopIteration', 'goog.log'], {});
goog.addDependency('dom/multirange_test.js', ['goog.dom.MultiRangeTest'], ['goog.dom', 'goog.dom.MultiRange', 'goog.dom.Range', 'goog.iter', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/nodeiterator.js', ['goog.dom.NodeIterator'], ['goog.dom.TagIterator'], {});
goog.addDependency('dom/nodeiterator_test.js', ['goog.dom.NodeIteratorTest'], ['goog.dom', 'goog.dom.NodeIterator', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/nodeoffset.js', ['goog.dom.NodeOffset'], ['goog.Disposable', 'goog.dom.TagName'], {});
goog.addDependency('dom/nodeoffset_test.js', ['goog.dom.NodeOffsetTest'], ['goog.dom', 'goog.dom.NodeOffset', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/nodetype.js', ['goog.dom.NodeType'], [], {});
goog.addDependency('dom/pattern/abstractpattern.js', ['goog.dom.pattern.AbstractPattern'], ['goog.dom.TagWalkType', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/allchildren.js', ['goog.dom.pattern.AllChildren'], ['goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/callback/callback.js', ['goog.dom.pattern.callback'], ['goog.dom', 'goog.dom.TagWalkType', 'goog.iter'], {});
goog.addDependency('dom/pattern/callback/counter.js', ['goog.dom.pattern.callback.Counter'], [], {});
goog.addDependency('dom/pattern/callback/test.js', ['goog.dom.pattern.callback.Test'], ['goog.iter.StopIteration'], {});
goog.addDependency('dom/pattern/childmatches.js', ['goog.dom.pattern.ChildMatches'], ['goog.dom.pattern.AllChildren', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/endtag.js', ['goog.dom.pattern.EndTag'], ['goog.dom.TagWalkType', 'goog.dom.pattern.Tag'], {});
goog.addDependency('dom/pattern/fulltag.js', ['goog.dom.pattern.FullTag'], ['goog.dom.pattern.MatchType', 'goog.dom.pattern.StartTag', 'goog.dom.pattern.Tag'], {});
goog.addDependency('dom/pattern/matcher.js', ['goog.dom.pattern.Matcher'], ['goog.dom.TagIterator', 'goog.dom.pattern.MatchType', 'goog.iter'], {});
goog.addDependency('dom/pattern/matcher_test.js', ['goog.dom.pattern.matcherTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.pattern.EndTag', 'goog.dom.pattern.FullTag', 'goog.dom.pattern.Matcher', 'goog.dom.pattern.Repeat', 'goog.dom.pattern.Sequence', 'goog.dom.pattern.StartTag', 'goog.dom.pattern.callback.Counter', 'goog.dom.pattern.callback.Test', 'goog.iter.StopIteration', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/pattern/nodetype.js', ['goog.dom.pattern.NodeType'], ['goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/pattern.js', ['goog.dom.pattern', 'goog.dom.pattern.MatchType'], [], {});
goog.addDependency('dom/pattern/pattern_test.js', ['goog.dom.patternTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagWalkType', 'goog.dom.pattern.AllChildren', 'goog.dom.pattern.ChildMatches', 'goog.dom.pattern.EndTag', 'goog.dom.pattern.FullTag', 'goog.dom.pattern.MatchType', 'goog.dom.pattern.NodeType', 'goog.dom.pattern.Repeat', 'goog.dom.pattern.Sequence', 'goog.dom.pattern.StartTag', 'goog.dom.pattern.Text', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/pattern/repeat.js', ['goog.dom.pattern.Repeat'], ['goog.dom.NodeType', 'goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/sequence.js', ['goog.dom.pattern.Sequence'], ['goog.dom.NodeType', 'goog.dom.pattern', 'goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/starttag.js', ['goog.dom.pattern.StartTag'], ['goog.dom.TagWalkType', 'goog.dom.pattern.Tag'], {});
goog.addDependency('dom/pattern/tag.js', ['goog.dom.pattern.Tag'], ['goog.dom.pattern', 'goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType', 'goog.object'], {});
goog.addDependency('dom/pattern/text.js', ['goog.dom.pattern.Text'], ['goog.dom.NodeType', 'goog.dom.pattern', 'goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/range.js', ['goog.dom.Range'], ['goog.dom', 'goog.dom.AbstractRange', 'goog.dom.BrowserFeature', 'goog.dom.ControlRange', 'goog.dom.MultiRange', 'goog.dom.NodeType', 'goog.dom.TextRange'], {});
goog.addDependency('dom/range_test.js', ['goog.dom.RangeTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.RangeType', 'goog.dom.TagName', 'goog.dom.TextRange', 'goog.dom.browserrange', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/rangeendpoint.js', ['goog.dom.RangeEndpoint'], [], {});
goog.addDependency('dom/safe.js', ['goog.dom.safe', 'goog.dom.safe.InsertAdjacentHtmlPosition'], ['goog.asserts', 'goog.dom.asserts', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.uncheckedconversions', 'goog.string.Const', 'goog.string.internal'], {});
goog.addDependency('dom/safe_test.js', ['goog.dom.safeTest'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.dom.safe.InsertAdjacentHtmlPosition', 'goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.testing', 'goog.string', 'goog.string.Const', 'goog.testing', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/savedcaretrange.js', ['goog.dom.SavedCaretRange'], ['goog.array', 'goog.dom', 'goog.dom.SavedRange', 'goog.dom.TagName', 'goog.string'], {});
goog.addDependency('dom/savedcaretrange_test.js', ['goog.dom.SavedCaretRangeTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.SavedCaretRange', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/savedrange.js', ['goog.dom.SavedRange'], ['goog.Disposable', 'goog.log'], {});
goog.addDependency('dom/savedrange_test.js', ['goog.dom.SavedRangeTest'], ['goog.dom', 'goog.dom.Range', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/selection.js', ['goog.dom.selection'], ['goog.dom.InputType', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('dom/selection_test.js', ['goog.dom.selectionTest'], ['goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.selection', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/tagiterator.js', ['goog.dom.TagIterator', 'goog.dom.TagWalkType'], ['goog.dom', 'goog.dom.NodeType', 'goog.iter.Iterator', 'goog.iter.StopIteration'], {});
goog.addDependency('dom/tagiterator_test.js', ['goog.dom.TagIteratorTest'], ['goog.dom', 'goog.dom.TagIterator', 'goog.dom.TagName', 'goog.dom.TagWalkType', 'goog.iter', 'goog.iter.StopIteration', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/tagname.js', ['goog.dom.TagName'], ['goog.dom.HtmlElement'], {});
goog.addDependency('dom/tagname_test.js', ['goog.dom.TagNameTest'], ['goog.dom.TagName', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/tags.js', ['goog.dom.tags'], ['goog.object'], {});
goog.addDependency('dom/tags_test.js', ['goog.dom.tagsTest'], ['goog.dom.tags', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/textassert.js', ['goog.dom.textAssert'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName'], {});
goog.addDependency('dom/textassert_test.js', ['goog.dom.textassert_test'], ['goog.dom.textAssert', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/textrange.js', ['goog.dom.TextRange'], ['goog.array', 'goog.dom', 'goog.dom.AbstractRange', 'goog.dom.RangeType', 'goog.dom.SavedRange', 'goog.dom.TagName', 'goog.dom.TextRangeIterator', 'goog.dom.browserrange', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('dom/textrange_test.js', ['goog.dom.TextRangeTest'], ['goog.dom', 'goog.dom.ControlRange', 'goog.dom.Range', 'goog.dom.TextRange', 'goog.math.Coordinate', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/textrangeiterator.js', ['goog.dom.TextRangeIterator'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.RangeIterator', 'goog.dom.TagName', 'goog.iter.StopIteration'], {});
goog.addDependency('dom/textrangeiterator_test.js', ['goog.dom.TextRangeIteratorTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.TextRangeIterator', 'goog.iter.StopIteration', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/uri.js', ['goog.dom.uri'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.uncheckedconversions', 'goog.string.Const'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/uri_test.js', ['goog.dom.uriTest'], ['goog.dom.uri', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/vendor.js', ['goog.dom.vendor'], ['goog.string', 'goog.userAgent'], {});
goog.addDependency('dom/vendor_test.js', ['goog.dom.vendorTest'], ['goog.array', 'goog.dom.vendor', 'goog.labs.userAgent.util', 'goog.testing.MockUserAgent', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/viewportsizemonitor.js', ['goog.dom.ViewportSizeMonitor'], ['goog.dom', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.math.Size'], {});
goog.addDependency('dom/viewportsizemonitor_test.js', ['goog.dom.ViewportSizeMonitorTest'], ['goog.dom.ViewportSizeMonitor', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.math.Size', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/xml.js', ['goog.dom.xml'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.safe', 'goog.html.legacyconversions', 'goog.userAgent'], {});
goog.addDependency('dom/xml_test.js', ['goog.dom.xmlTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.xml', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/browserfeature.js', ['goog.editor.BrowserFeature'], ['goog.editor.defines', 'goog.labs.userAgent.browser', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('editor/browserfeature_test.js', ['goog.editor.BrowserFeatureTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/clicktoeditwrapper.js', ['goog.editor.ClickToEditWrapper'], ['goog.Disposable', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.range', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventType'], {});
goog.addDependency('editor/clicktoeditwrapper_test.js', ['goog.editor.ClickToEditWrapperTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.ClickToEditWrapper', 'goog.editor.SeamlessField', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/command.js', ['goog.editor.Command'], [], {});
goog.addDependency('editor/contenteditablefield.js', ['goog.editor.ContentEditableField'], ['goog.asserts', 'goog.editor.Field', 'goog.log'], {});
goog.addDependency('editor/contenteditablefield_test.js', ['goog.editor.ContentEditableFieldTest'], ['goog.dom', 'goog.editor.ContentEditableField', 'goog.html.SafeHtml', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/defines.js', ['goog.editor.defines'], [], {});
goog.addDependency('editor/field.js', ['goog.editor.Field', 'goog.editor.Field.EventType'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.array', 'goog.asserts', 'goog.async.Delay', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.safe', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.PluginImpl', 'goog.editor.icontent', 'goog.editor.icontent.FieldFormatInfo', 'goog.editor.icontent.FieldStyleInfo', 'goog.editor.node', 'goog.editor.range', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.log', 'goog.log.Level', 'goog.string', 'goog.string.Unicode', 'goog.style', 'goog.userAgent', 'goog.userAgent.product'], {});
goog.addDependency('editor/field_test.js', ['goog.editor.field_test'], ['goog.array', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.range', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.functions', 'goog.html.SafeHtml', 'goog.testing.LooseMock', 'goog.testing.MockClock', 'goog.testing.dom', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/focus.js', ['goog.editor.focus'], ['goog.dom.selection'], {});
goog.addDependency('editor/focus_test.js', ['goog.editor.focusTest'], ['goog.dom.selection', 'goog.editor.BrowserFeature', 'goog.editor.focus', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/icontent.js', ['goog.editor.icontent', 'goog.editor.icontent.FieldFormatInfo', 'goog.editor.icontent.FieldStyleInfo'], ['goog.dom', 'goog.editor.BrowserFeature', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('editor/icontent_test.js', ['goog.editor.icontentTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.icontent', 'goog.editor.icontent.FieldFormatInfo', 'goog.editor.icontent.FieldStyleInfo', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/link.js', ['goog.editor.Link'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.node', 'goog.editor.range', 'goog.string', 'goog.string.Unicode', 'goog.uri.utils', 'goog.uri.utils.ComponentIndex'], {});
goog.addDependency('editor/link_test.js', ['goog.editor.LinkTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Link', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/node.js', ['goog.editor.node'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.iter.ChildIterator', 'goog.dom.iter.SiblingIterator', 'goog.iter', 'goog.object', 'goog.string', 'goog.string.Unicode', 'goog.userAgent'], {});
goog.addDependency('editor/node_test.js', ['goog.editor.nodeTest'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.editor.node', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugin.js', ['goog.editor.Plugin'], ['goog.editor.Field', 'goog.editor.PluginImpl'], {});
goog.addDependency('editor/plugin_impl.js', ['goog.editor.PluginImpl'], ['goog.events.EventTarget', 'goog.functions', 'goog.log', 'goog.object', 'goog.reflect', 'goog.userAgent'], {});
goog.addDependency('editor/plugin_test.js', ['goog.editor.PluginTest'], ['goog.editor.Field', 'goog.editor.Plugin', 'goog.functions', 'goog.testing.StrictMock', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/abstractbubbleplugin.js', ['goog.editor.plugins.AbstractBubblePlugin'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.editor.Plugin', 'goog.editor.style', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.actionEventWrapper', 'goog.functions', 'goog.string.Unicode', 'goog.ui.Component', 'goog.ui.editor.Bubble', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/abstractbubbleplugin_test.js', ['goog.editor.plugins.AbstractBubblePluginTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.plugins.AbstractBubblePlugin', 'goog.events.BrowserEvent', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.functions', 'goog.style', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.editor.Bubble', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/abstractdialogplugin.js', ['goog.editor.plugins.AbstractDialogPlugin', 'goog.editor.plugins.AbstractDialogPlugin.EventType'], ['goog.dom', 'goog.dom.Range', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.range', 'goog.events', 'goog.ui.editor.AbstractDialog'], {});
goog.addDependency('editor/plugins/abstractdialogplugin_test.js', ['goog.editor.plugins.AbstractDialogPluginTest'], ['goog.dom', 'goog.dom.SavedRange', 'goog.dom.TagName', 'goog.editor.Field', 'goog.editor.plugins.AbstractDialogPlugin', 'goog.events.Event', 'goog.events.EventHandler', 'goog.functions', 'goog.html.SafeHtml', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.testSuite', 'goog.ui.editor.AbstractDialog', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/abstracttabhandler.js', ['goog.editor.plugins.AbstractTabHandler'], ['goog.editor.Plugin', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/abstracttabhandler_test.js', ['goog.editor.plugins.AbstractTabHandlerTest'], ['goog.editor.Field', 'goog.editor.plugins.AbstractTabHandler', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.testing.StrictMock', 'goog.testing.editor.FieldMock', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/basictextformatter.js', ['goog.editor.plugins.BasicTextFormatter', 'goog.editor.plugins.BasicTextFormatter.COMMAND'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Link', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.range', 'goog.editor.style', 'goog.iter', 'goog.iter.StopIteration', 'goog.log', 'goog.object', 'goog.string', 'goog.string.Unicode', 'goog.style', 'goog.ui.editor.messages', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/basictextformatter_test.js', ['goog.editor.plugins.BasicTextFormatterTest'], ['goog.array', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.plugins.BasicTextFormatter', 'goog.html.SafeHtml', 'goog.object', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.LooseMock', 'goog.testing.PropertyReplacer', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/blockquote.js', ['goog.editor.plugins.Blockquote'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Plugin', 'goog.editor.node', 'goog.functions', 'goog.log'], {});
goog.addDependency('editor/plugins/blockquote_test.js', ['goog.editor.plugins.BlockquoteTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.plugins.Blockquote', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/emoticons.js', ['goog.editor.plugins.Emoticons'], ['goog.dom.TagName', 'goog.editor.Plugin', 'goog.editor.range', 'goog.functions', 'goog.ui.emoji.Emoji', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/emoticons_test.js', ['goog.editor.plugins.EmoticonsTest'], ['goog.Uri', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.editor.Field', 'goog.editor.plugins.Emoticons', 'goog.testing.testSuite', 'goog.ui.emoji.Emoji', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/enterhandler.js', ['goog.editor.plugins.EnterHandler'], ['goog.dom', 'goog.dom.NodeOffset', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.plugins.Blockquote', 'goog.editor.range', 'goog.editor.style', 'goog.events.KeyCodes', 'goog.functions', 'goog.object', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/enterhandler_test.js', ['goog.editor.plugins.EnterHandlerTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.plugins.Blockquote', 'goog.editor.plugins.EnterHandler', 'goog.editor.range', 'goog.events', 'goog.events.KeyCodes', 'goog.html.testing', 'goog.testing.ExpectedFailures', 'goog.testing.MockClock', 'goog.testing.dom', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/firststrong.js', ['goog.editor.plugins.FirstStrong'], ['goog.dom.NodeType', 'goog.dom.TagIterator', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.range', 'goog.i18n.bidi', 'goog.i18n.uChar', 'goog.iter', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/firststrong_test.js', ['goog.editor.plugins.FirstStrongTest'], ['goog.dom.Range', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.plugins.FirstStrong', 'goog.editor.range', 'goog.events.KeyCodes', 'goog.html.testing', 'goog.testing.MockClock', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/headerformatter.js', ['goog.editor.plugins.HeaderFormatter'], ['goog.editor.Command', 'goog.editor.Plugin', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/headerformatter_test.js', ['goog.editor.plugins.HeaderFormatterTest'], ['goog.dom', 'goog.editor.Command', 'goog.editor.plugins.BasicTextFormatter', 'goog.editor.plugins.HeaderFormatter', 'goog.events.BrowserEvent', 'goog.testing.LooseMock', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/linkbubble.js', ['goog.editor.plugins.LinkBubble', 'goog.editor.plugins.LinkBubble.Action'], ['goog.array', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.Link', 'goog.editor.plugins.AbstractBubblePlugin', 'goog.functions', 'goog.string', 'goog.style', 'goog.ui.editor.messages', 'goog.uri.utils', 'goog.window'], {});
goog.addDependency('editor/plugins/linkbubble_test.js', ['goog.editor.plugins.LinkBubbleTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.Link', 'goog.editor.plugins.LinkBubble', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.string', 'goog.style', 'goog.testing.FunctionMock', 'goog.testing.PropertyReplacer', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/linkdialogplugin.js', ['goog.editor.plugins.LinkDialogPlugin'], ['goog.array', 'goog.dom', 'goog.editor.Command', 'goog.editor.plugins.AbstractDialogPlugin', 'goog.events.EventHandler', 'goog.functions', 'goog.ui.editor.AbstractDialog', 'goog.ui.editor.LinkDialog', 'goog.uri.utils'], {});
goog.addDependency('editor/plugins/linkdialogplugin_test.js', ['goog.ui.editor.plugins.LinkDialogTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Link', 'goog.editor.plugins.LinkDialogPlugin', 'goog.html.SafeHtml', 'goog.string', 'goog.string.Unicode', 'goog.testing.MockControl', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.editor.dom', 'goog.testing.events', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.ui.editor.AbstractDialog', 'goog.ui.editor.LinkDialog', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/linkshortcutplugin.js', ['goog.editor.plugins.LinkShortcutPlugin'], ['goog.editor.Command', 'goog.editor.Plugin'], {});
goog.addDependency('editor/plugins/linkshortcutplugin_test.js', ['goog.editor.plugins.LinkShortcutPluginTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.Field', 'goog.editor.plugins.BasicTextFormatter', 'goog.editor.plugins.LinkBubble', 'goog.editor.plugins.LinkShortcutPlugin', 'goog.events.KeyCodes', 'goog.testing.PropertyReplacer', 'goog.testing.dom', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/listtabhandler.js', ['goog.editor.plugins.ListTabHandler'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.plugins.AbstractTabHandler', 'goog.iter'], {});
goog.addDependency('editor/plugins/listtabhandler_test.js', ['goog.editor.plugins.ListTabHandlerTest'], ['goog.dom', 'goog.editor.Command', 'goog.editor.plugins.ListTabHandler', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.functions', 'goog.testing.StrictMock', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/loremipsum.js', ['goog.editor.plugins.LoremIpsum'], ['goog.asserts', 'goog.dom', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.node', 'goog.functions', 'goog.html.SafeHtml', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/loremipsum_test.js', ['goog.editor.plugins.LoremIpsumTest'], ['goog.dom', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.plugins.LoremIpsum', 'goog.html.SafeHtml', 'goog.string.Unicode', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/removeformatting.js', ['goog.editor.plugins.RemoveFormatting'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.range', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/removeformatting_test.js', ['goog.editor.plugins.RemoveFormattingTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.plugins.RemoveFormatting', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.dom', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/spacestabhandler.js', ['goog.editor.plugins.SpacesTabHandler'], ['goog.dom.TagName', 'goog.editor.plugins.AbstractTabHandler', 'goog.editor.range'], {});
goog.addDependency('editor/plugins/spacestabhandler_test.js', ['goog.editor.plugins.SpacesTabHandlerTest'], ['goog.dom', 'goog.dom.Range', 'goog.editor.plugins.SpacesTabHandler', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.functions', 'goog.testing.StrictMock', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/tableeditor.js', ['goog.editor.plugins.TableEditor'], ['goog.array', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Plugin', 'goog.editor.Table', 'goog.editor.node', 'goog.editor.range', 'goog.object', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/tableeditor_test.js', ['goog.editor.plugins.TableEditorTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.plugins.TableEditor', 'goog.object', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.TestCase', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/tagonenterhandler.js', ['goog.editor.plugins.TagOnEnterHandler'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.node', 'goog.editor.plugins.EnterHandler', 'goog.editor.range', 'goog.editor.style', 'goog.events.KeyCodes', 'goog.functions', 'goog.string.Unicode', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/tagonenterhandler_test.js', ['goog.editor.plugins.TagOnEnterHandlerTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.plugins.TagOnEnterHandler', 'goog.events.KeyCodes', 'goog.html.SafeHtml', 'goog.string.Unicode', 'goog.testing.dom', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/undoredo.js', ['goog.editor.plugins.UndoRedo'], ['goog.dom', 'goog.dom.NodeOffset', 'goog.dom.Range', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.plugins.UndoRedoManager', 'goog.editor.plugins.UndoRedoState', 'goog.events', 'goog.events.EventHandler', 'goog.log', 'goog.object'], {});
goog.addDependency('editor/plugins/undoredo_test.js', ['goog.editor.plugins.UndoRedoTest'], ['goog.array', 'goog.dom', 'goog.dom.browserrange', 'goog.editor.Field', 'goog.editor.plugins.LoremIpsum', 'goog.editor.plugins.UndoRedo', 'goog.events', 'goog.functions', 'goog.html.SafeHtml', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/undoredomanager.js', ['goog.editor.plugins.UndoRedoManager', 'goog.editor.plugins.UndoRedoManager.EventType'], ['goog.editor.plugins.UndoRedoState', 'goog.events', 'goog.events.EventTarget'], {});
goog.addDependency('editor/plugins/undoredomanager_test.js', ['goog.editor.plugins.UndoRedoManagerTest'], ['goog.editor.plugins.UndoRedoManager', 'goog.editor.plugins.UndoRedoState', 'goog.events', 'goog.testing.StrictMock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/undoredostate.js', ['goog.editor.plugins.UndoRedoState'], ['goog.events.EventTarget'], {});
goog.addDependency('editor/plugins/undoredostate_test.js', ['goog.editor.plugins.UndoRedoStateTest'], ['goog.editor.plugins.UndoRedoState', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/range.js', ['goog.editor.range', 'goog.editor.range.Point'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.RangeEndpoint', 'goog.dom.SavedCaretRange', 'goog.editor.node', 'goog.editor.style', 'goog.iter', 'goog.userAgent'], {});
goog.addDependency('editor/range_test.js', ['goog.editor.rangeTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.range', 'goog.editor.range.Point', 'goog.string', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/seamlessfield.js', ['goog.editor.SeamlessField'], ['goog.cssom.iframe.style', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.dom.safe', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.icontent', 'goog.editor.icontent.FieldFormatInfo', 'goog.editor.icontent.FieldStyleInfo', 'goog.editor.node', 'goog.events', 'goog.events.EventType', 'goog.html.SafeHtml', 'goog.log', 'goog.style'], {});
goog.addDependency('editor/seamlessfield_test.js', ['goog.editor.seamlessfield_test'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.SeamlessField', 'goog.events', 'goog.functions', 'goog.html.SafeHtml', 'goog.style', 'goog.testing.MockClock', 'goog.testing.MockRange', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/style.js', ['goog.editor.style'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.object', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('editor/style_test.js', ['goog.editor.styleTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.style', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.style', 'goog.testing.LooseMock', 'goog.testing.mockmatchers', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/table.js', ['goog.editor.Table', 'goog.editor.TableCell', 'goog.editor.TableRow'], ['goog.asserts', 'goog.dom', 'goog.dom.DomHelper', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.log', 'goog.string.Unicode', 'goog.style'], {});
goog.addDependency('editor/table_test.js', ['goog.editor.TableTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.Table', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/actioneventwrapper.js', ['goog.events.actionEventWrapper'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.dom', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.EventWrapper', 'goog.events.KeyCodes'], {});
goog.addDependency('events/actioneventwrapper_test.js', ['goog.events.actionEventWrapperTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.events', 'goog.events.EventHandler', 'goog.events.KeyCodes', 'goog.events.actionEventWrapper', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/actionhandler.js', ['goog.events.ActionEvent', 'goog.events.ActionHandler', 'goog.events.ActionHandler.EventType', 'goog.events.BeforeActionEvent'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('events/actionhandler_test.js', ['goog.events.ActionHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.ActionHandler', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/browserevent.js', ['goog.events.BrowserEvent', 'goog.events.BrowserEvent.MouseButton', 'goog.events.BrowserEvent.PointerType'], ['goog.debug', 'goog.events.BrowserFeature', 'goog.events.Event', 'goog.events.EventType', 'goog.reflect', 'goog.userAgent'], {});
goog.addDependency('events/browserevent_test.js', ['goog.events.BrowserEventTest'], ['goog.events.BrowserEvent', 'goog.events.BrowserFeature', 'goog.math.Coordinate', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/browserfeature.js', ['goog.events.BrowserFeature'], ['goog.userAgent'], {});
goog.addDependency('events/event.js', ['goog.events.Event', 'goog.events.EventLike'], ['goog.Disposable', 'goog.events.EventId'], {});
goog.addDependency('events/event_test.js', ['goog.events.EventTest'], ['goog.events.Event', 'goog.events.EventId', 'goog.events.EventTarget', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventhandler.js', ['goog.events.EventHandler'], ['goog.Disposable', 'goog.events', 'goog.object'], {});
goog.addDependency('events/eventhandler_test.js', ['goog.events.EventHandlerTest'], ['goog.events', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventid.js', ['goog.events.EventId'], [], {});
goog.addDependency('events/events.js', ['goog.events', 'goog.events.CaptureSimulationMode', 'goog.events.Key', 'goog.events.ListenableType'], ['goog.asserts', 'goog.debug.entryPointRegistry', 'goog.events.BrowserEvent', 'goog.events.BrowserFeature', 'goog.events.Listenable', 'goog.events.ListenerMap'], {});
goog.addDependency('events/events_test.js', ['goog.eventsTest'], ['goog.asserts.AssertionError', 'goog.debug.EntryPointMonitor', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.BrowserFeature', 'goog.events.CaptureSimulationMode', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.Listener', 'goog.functions', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtarget.js', ['goog.events.EventTarget'], ['goog.Disposable', 'goog.asserts', 'goog.events', 'goog.events.Event', 'goog.events.Listenable', 'goog.events.ListenerMap', 'goog.object'], {});
goog.addDependency('events/eventtarget_test.js', ['goog.events.EventTargetTest'], ['goog.events.EventTarget', 'goog.events.Listenable', 'goog.events.eventTargetTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtarget_via_googevents_test.js', ['goog.events.EventTargetGoogEventsTest'], ['goog.events', 'goog.events.EventTarget', 'goog.events.eventTargetTester', 'goog.testing', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtarget_via_w3cinterface_test.js', ['goog.events.EventTargetW3CTest'], ['goog.events.EventTarget', 'goog.events.eventTargetTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtargettester.js', ['goog.events.eventTargetTester'], ['goog.array', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.Listenable', 'goog.testing.asserts', 'goog.testing.recordFunction'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtype.js', ['goog.events.EventType', 'goog.events.MouseAsMouseEventType', 'goog.events.MouseEvents', 'goog.events.PointerAsMouseEventType', 'goog.events.PointerAsTouchEventType', 'goog.events.PointerFallbackEventType', 'goog.events.PointerTouchFallbackEventType'], ['goog.events.BrowserFeature', 'goog.userAgent'], {});
goog.addDependency('events/eventtype_test.js', ['goog.events.EventTypeTest'], ['goog.events.BrowserFeature', 'goog.events.EventType', 'goog.events.PointerFallbackEventType', 'goog.events.PointerTouchFallbackEventType', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventwrapper.js', ['goog.events.EventWrapper'], [], {});
goog.addDependency('events/filedrophandler.js', ['goog.events.FileDropHandler', 'goog.events.FileDropHandler.EventType'], ['goog.array', 'goog.dom', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.log', 'goog.log.Level'], {});
goog.addDependency('events/filedrophandler_test.js', ['goog.events.FileDropHandlerTest'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.FileDropHandler', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/focushandler.js', ['goog.events.FocusHandler', 'goog.events.FocusHandler.EventType'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.userAgent'], {});
goog.addDependency('events/imehandler.js', ['goog.events.ImeHandler', 'goog.events.ImeHandler.Event', 'goog.events.ImeHandler.EventType'], ['goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('events/imehandler_test.js', ['goog.events.ImeHandlerTest'], ['goog.array', 'goog.dom', 'goog.events', 'goog.events.ImeHandler', 'goog.events.KeyCodes', 'goog.object', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/inputhandler.js', ['goog.events.InputHandler', 'goog.events.InputHandler.EventType'], ['goog.Timer', 'goog.dom.TagName', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('events/inputhandler_test.js', ['goog.events.InputHandlerTest'], ['goog.dom', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/keycodes.js', ['goog.events.KeyCodes'], ['goog.userAgent'], {});
goog.addDependency('events/keycodes_test.js', ['goog.events.KeyCodesTest'], ['goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.object', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/keyhandler.js', ['goog.events.KeyEvent', 'goog.events.KeyHandler', 'goog.events.KeyHandler.EventType'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('events/keyhandler_test.js', ['goog.events.KeyEventTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/keynames.js', ['goog.events.KeyNames'], [], {});
goog.addDependency('events/keys.js', ['goog.events.Keys'], [], {'lang': 'es5'});
goog.addDependency('events/listenable.js', ['goog.events.Listenable', 'goog.events.ListenableKey'], ['goog.events.EventId'], {});
goog.addDependency('events/listenable_test.js', ['goog.events.ListenableTest'], ['goog.events.Listenable', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/listener.js', ['goog.events.Listener'], ['goog.events.ListenableKey'], {});
goog.addDependency('events/listenermap.js', ['goog.events.ListenerMap'], ['goog.array', 'goog.events.Listener', 'goog.object'], {});
goog.addDependency('events/listenermap_test.js', ['goog.events.ListenerMapTest'], ['goog.dispose', 'goog.events', 'goog.events.EventId', 'goog.events.EventTarget', 'goog.events.ListenerMap', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/mousewheelhandler.js', ['goog.events.MouseWheelEvent', 'goog.events.MouseWheelHandler', 'goog.events.MouseWheelHandler.EventType'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.math', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('events/mousewheelhandler_test.js', ['goog.events.MouseWheelHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.MouseWheelEvent', 'goog.events.MouseWheelHandler', 'goog.functions', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/onlinehandler.js', ['goog.events.OnlineHandler', 'goog.events.OnlineHandler.EventType'], ['goog.Timer', 'goog.events.BrowserFeature', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.net.NetworkStatusMonitor'], {});
goog.addDependency('events/onlinelistener_test.js', ['goog.events.OnlineHandlerTest'], ['goog.events', 'goog.events.BrowserFeature', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.OnlineHandler', 'goog.net.NetworkStatusMonitor', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/pastehandler.js', ['goog.events.PasteHandler', 'goog.events.PasteHandler.EventType', 'goog.events.PasteHandler.State'], ['goog.Timer', 'goog.async.ConditionalDelay', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.log', 'goog.userAgent'], {});
goog.addDependency('events/pastehandler_test.js', ['goog.events.PasteHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.PasteHandler', 'goog.testing.MockClock', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/wheelevent.js', ['goog.events.WheelEvent'], ['goog.asserts', 'goog.events.BrowserEvent'], {});
goog.addDependency('events/wheelhandler.js', ['goog.events.WheelHandler'], ['goog.dom', 'goog.events', 'goog.events.EventTarget', 'goog.events.WheelEvent', 'goog.style', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('events/wheelhandler_test.js', ['goog.events.WheelHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.WheelEvent', 'goog.events.WheelHandler', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/emailaddress.js', ['goog.format.EmailAddress'], ['goog.string'], {});
goog.addDependency('format/emailaddress_test.js', ['goog.format.EmailAddressTest'], ['goog.array', 'goog.format.EmailAddress', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/format.js', ['goog.format'], ['goog.i18n.GraphemeBreak', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('format/format_test.js', ['goog.formatTest'], ['goog.dom', 'goog.dom.TagName', 'goog.format', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/htmlprettyprinter.js', ['goog.format.HtmlPrettyPrinter', 'goog.format.HtmlPrettyPrinter.Buffer'], ['goog.dom.TagName', 'goog.object', 'goog.string.StringBuffer'], {});
goog.addDependency('format/htmlprettyprinter_test.js', ['goog.format.HtmlPrettyPrinterTest'], ['goog.format.HtmlPrettyPrinter', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/internationalizedemailaddress.js', ['goog.format.InternationalizedEmailAddress'], ['goog.format.EmailAddress', 'goog.string'], {});
goog.addDependency('format/internationalizedemailaddress_test.js', ['goog.format.InternationalizedEmailAddressTest'], ['goog.array', 'goog.format.InternationalizedEmailAddress', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/jsonprettyprinter.js', ['goog.format.JsonPrettyPrinter', 'goog.format.JsonPrettyPrinter.SafeHtmlDelimiters', 'goog.format.JsonPrettyPrinter.TextDelimiters'], ['goog.html.SafeHtml', 'goog.json', 'goog.json.Serializer', 'goog.string', 'goog.string.format'], {});
goog.addDependency('format/jsonprettyprinter_test.js', ['goog.format.JsonPrettyPrinterTest'], ['goog.format.JsonPrettyPrinter', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fs/entry.js', ['goog.fs.DirectoryEntry', 'goog.fs.DirectoryEntry.Behavior', 'goog.fs.Entry', 'goog.fs.FileEntry'], [], {});
goog.addDependency('fs/entryimpl.js', ['goog.fs.DirectoryEntryImpl', 'goog.fs.EntryImpl', 'goog.fs.FileEntryImpl'], ['goog.array', 'goog.async.Deferred', 'goog.fs.DirectoryEntry', 'goog.fs.Entry', 'goog.fs.Error', 'goog.fs.FileEntry', 'goog.fs.FileWriter', 'goog.functions', 'goog.string'], {});
goog.addDependency('fs/error.js', ['goog.fs.DOMErrorLike', 'goog.fs.Error', 'goog.fs.Error.ErrorCode'], ['goog.asserts', 'goog.debug.Error', 'goog.object', 'goog.string'], {});
goog.addDependency('fs/filereader.js', ['goog.fs.FileReader', 'goog.fs.FileReader.EventType', 'goog.fs.FileReader.ReadyState'], ['goog.async.Deferred', 'goog.events.EventTarget', 'goog.fs.Error', 'goog.fs.ProgressEvent'], {});
goog.addDependency('fs/filesaver.js', ['goog.fs.FileSaver', 'goog.fs.FileSaver.EventType', 'goog.fs.FileSaver.ReadyState'], ['goog.events.EventTarget', 'goog.fs.Error', 'goog.fs.ProgressEvent'], {});
goog.addDependency('fs/filesystem.js', ['goog.fs.FileSystem'], [], {});
goog.addDependency('fs/filesystemimpl.js', ['goog.fs.FileSystemImpl'], ['goog.fs.DirectoryEntryImpl', 'goog.fs.FileSystem'], {});
goog.addDependency('fs/filewriter.js', ['goog.fs.FileWriter'], ['goog.fs.Error', 'goog.fs.FileSaver'], {});
goog.addDependency('fs/fs.js', ['goog.fs'], ['goog.array', 'goog.async.Deferred', 'goog.fs.Error', 'goog.fs.FileReader', 'goog.fs.FileSystemImpl', 'goog.fs.url', 'goog.userAgent'], {});
goog.addDependency('fs/fs_test.js', ['goog.fsTest'], ['goog.Promise', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.fs', 'goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.fs.FileReader', 'goog.fs.FileSaver', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fs/progressevent.js', ['goog.fs.ProgressEvent'], ['goog.events.Event'], {});
goog.addDependency('fs/url.js', ['goog.fs.url'], [], {'lang': 'es6'});
goog.addDependency('fs/url_test.js', ['goog.urlTest'], ['goog.fs.url', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('functions/functions.js', ['goog.functions'], [], {'lang': 'es6'});
goog.addDependency('functions/functions_test.js', ['goog.functionsTest'], ['goog.array', 'goog.functions', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/abstractdragdrop.js', ['goog.fx.AbstractDragDrop', 'goog.fx.AbstractDragDrop.EventType', 'goog.fx.DragDropEvent', 'goog.fx.DragDropItem'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.fx.Dragger', 'goog.math.Box', 'goog.math.Coordinate', 'goog.style'], {});
goog.addDependency('fx/abstractdragdrop_test.js', ['goog.fx.AbstractDragDropTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.functions', 'goog.fx.AbstractDragDrop', 'goog.fx.DragDropItem', 'goog.math.Box', 'goog.math.Coordinate', 'goog.style', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('fx/anim/anim.js', ['goog.fx.anim', 'goog.fx.anim.Animated'], ['goog.async.AnimationDelay', 'goog.async.Delay', 'goog.object'], {});
goog.addDependency('fx/anim/anim_test.js', ['goog.fx.animTest'], ['goog.async.AnimationDelay', 'goog.async.Delay', 'goog.events', 'goog.functions', 'goog.fx.Animation', 'goog.fx.anim', 'goog.object', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/animation.js', ['goog.fx.Animation', 'goog.fx.Animation.EventType', 'goog.fx.Animation.State', 'goog.fx.AnimationEvent'], ['goog.array', 'goog.asserts', 'goog.events.Event', 'goog.fx.Transition', 'goog.fx.TransitionBase', 'goog.fx.anim', 'goog.fx.anim.Animated'], {});
goog.addDependency('fx/animation_test.js', ['goog.fx.AnimationTest'], ['goog.events', 'goog.fx.Animation', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/animationqueue.js', ['goog.fx.AnimationParallelQueue', 'goog.fx.AnimationQueue', 'goog.fx.AnimationSerialQueue'], ['goog.array', 'goog.asserts', 'goog.events', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.fx.TransitionBase'], {});
goog.addDependency('fx/animationqueue_test.js', ['goog.fx.AnimationQueueTest'], ['goog.events', 'goog.fx.Animation', 'goog.fx.AnimationParallelQueue', 'goog.fx.AnimationSerialQueue', 'goog.fx.Transition', 'goog.fx.anim', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/css3/fx.js', ['goog.fx.css3'], ['goog.fx.css3.Transition'], {});
goog.addDependency('fx/css3/transition.js', ['goog.fx.css3.Transition'], ['goog.Timer', 'goog.asserts', 'goog.fx.TransitionBase', 'goog.style', 'goog.style.transition'], {});
goog.addDependency('fx/css3/transition_test.js', ['goog.fx.css3.TransitionTest'], ['goog.dispose', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.fx.Transition', 'goog.fx.css3.Transition', 'goog.style.transition', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/cssspriteanimation.js', ['goog.fx.CssSpriteAnimation'], ['goog.fx.Animation'], {});
goog.addDependency('fx/cssspriteanimation_test.js', ['goog.fx.CssSpriteAnimationTest'], ['goog.fx.CssSpriteAnimation', 'goog.math.Box', 'goog.math.Size', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/dom.js', ['goog.fx.dom', 'goog.fx.dom.BgColorTransform', 'goog.fx.dom.ColorTransform', 'goog.fx.dom.Fade', 'goog.fx.dom.FadeIn', 'goog.fx.dom.FadeInAndShow', 'goog.fx.dom.FadeOut', 'goog.fx.dom.FadeOutAndHide', 'goog.fx.dom.PredefinedEffect', 'goog.fx.dom.Resize', 'goog.fx.dom.ResizeHeight', 'goog.fx.dom.ResizeWidth', 'goog.fx.dom.Scroll', 'goog.fx.dom.Slide', 'goog.fx.dom.SlideFrom', 'goog.fx.dom.Swipe'], ['goog.color', 'goog.events', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.style', 'goog.style.bidi'], {});
goog.addDependency('fx/dragdrop.js', ['goog.fx.DragDrop'], ['goog.fx.AbstractDragDrop', 'goog.fx.DragDropItem'], {});
goog.addDependency('fx/dragdropgroup.js', ['goog.fx.DragDropGroup'], ['goog.dom', 'goog.fx.AbstractDragDrop', 'goog.fx.DragDropItem'], {});
goog.addDependency('fx/dragdropgroup_test.js', ['goog.fx.DragDropGroupTest'], ['goog.events', 'goog.fx.DragDropGroup', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/dragger.js', ['goog.fx.DragEvent', 'goog.fx.Dragger', 'goog.fx.Dragger.EventType'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.style', 'goog.style.bidi', 'goog.userAgent'], {});
goog.addDependency('fx/dragger_test.js', ['goog.fx.DraggerTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventType', 'goog.fx.Dragger', 'goog.math.Rect', 'goog.style.bidi', 'goog.testing.StrictMock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/draglistgroup.js', ['goog.fx.DragListDirection', 'goog.fx.DragListGroup', 'goog.fx.DragListGroup.EventType', 'goog.fx.DragListGroupEvent', 'goog.fx.DragListPermission'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventId', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.fx.Dragger', 'goog.math.Coordinate', 'goog.string', 'goog.style'], {});
goog.addDependency('fx/draglistgroup_test.js', ['goog.fx.DragListGroupTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.BrowserFeature', 'goog.events.Event', 'goog.events.EventType', 'goog.fx.DragEvent', 'goog.fx.DragListDirection', 'goog.fx.DragListGroup', 'goog.fx.DragListPermission', 'goog.fx.Dragger', 'goog.math.Coordinate', 'goog.object', 'goog.style', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/dragscrollsupport.js', ['goog.fx.DragScrollSupport'], ['goog.Disposable', 'goog.Timer', 'goog.dom', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.math.Coordinate', 'goog.style'], {});
goog.addDependency('fx/dragscrollsupport_test.js', ['goog.fx.DragScrollSupportTest'], ['goog.fx.DragScrollSupport', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/easing.js', ['goog.fx.easing'], [], {});
goog.addDependency('fx/easing_test.js', ['goog.fx.easingTest'], ['goog.fx.easing', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/fx.js', ['goog.fx'], ['goog.asserts', 'goog.fx.Animation', 'goog.fx.Animation.EventType', 'goog.fx.Animation.State', 'goog.fx.AnimationEvent', 'goog.fx.Transition.EventType', 'goog.fx.easing'], {});
goog.addDependency('fx/fx_test.js', ['goog.fxTest'], ['goog.fx.Animation', 'goog.object', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/transition.js', ['goog.fx.Transition', 'goog.fx.Transition.EventType'], [], {});
goog.addDependency('fx/transitionbase.js', ['goog.fx.TransitionBase', 'goog.fx.TransitionBase.State'], ['goog.events.EventTarget', 'goog.fx.Transition'], {});
goog.addDependency('goog.js', [], [], {'lang': 'es6', 'module': 'es6'});
goog.addDependency('graphics/abstractgraphics.js', ['goog.graphics.AbstractGraphics'], ['goog.dom', 'goog.graphics.AffineTransform', 'goog.graphics.Element', 'goog.graphics.EllipseElement', 'goog.graphics.Fill', 'goog.graphics.Font', 'goog.graphics.GroupElement', 'goog.graphics.Path', 'goog.graphics.PathElement', 'goog.graphics.RectElement', 'goog.graphics.Stroke', 'goog.graphics.StrokeAndFillElement', 'goog.graphics.TextElement', 'goog.math.Coordinate', 'goog.math.Size', 'goog.style', 'goog.ui.Component'], {});
goog.addDependency('graphics/affinetransform.js', ['goog.graphics.AffineTransform'], [], {'lang': 'es6'});
goog.addDependency('graphics/affinetransform_test.js', ['goog.graphics.AffineTransformTest'], ['goog.array', 'goog.graphics', 'goog.graphics.AffineTransform', 'goog.math', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/canvaselement.js', ['goog.graphics.CanvasEllipseElement', 'goog.graphics.CanvasGroupElement', 'goog.graphics.CanvasImageElement', 'goog.graphics.CanvasPathElement', 'goog.graphics.CanvasRectElement', 'goog.graphics.CanvasTextElement'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.graphics.EllipseElement', 'goog.graphics.Font', 'goog.graphics.GroupElement', 'goog.graphics.ImageElement', 'goog.graphics.Path', 'goog.graphics.PathElement', 'goog.graphics.RectElement', 'goog.graphics.TextElement', 'goog.html.SafeHtml', 'goog.html.uncheckedconversions', 'goog.math', 'goog.string', 'goog.string.Const'], {});
goog.addDependency('graphics/canvasgraphics.js', ['goog.graphics.CanvasGraphics'], ['goog.dom.TagName', 'goog.events.EventType', 'goog.graphics.AbstractGraphics', 'goog.graphics.CanvasEllipseElement', 'goog.graphics.CanvasGroupElement', 'goog.graphics.CanvasImageElement', 'goog.graphics.CanvasPathElement', 'goog.graphics.CanvasRectElement', 'goog.graphics.CanvasTextElement', 'goog.graphics.Font', 'goog.graphics.SolidFill', 'goog.math.Size', 'goog.style'], {});
goog.addDependency('graphics/canvasgraphics_test.js', ['goog.graphics.CanvasGraphicsTest'], ['goog.dom', 'goog.graphics.CanvasGraphics', 'goog.graphics.SolidFill', 'goog.graphics.Stroke', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/element.js', ['goog.graphics.Element'], ['goog.asserts', 'goog.events', 'goog.events.EventTarget', 'goog.events.Listenable', 'goog.graphics.AffineTransform', 'goog.math'], {});
goog.addDependency('graphics/ellipseelement.js', ['goog.graphics.EllipseElement'], ['goog.graphics.StrokeAndFillElement'], {});
goog.addDependency('graphics/ext/coordinates.js', ['goog.graphics.ext.coordinates'], ['goog.string'], {});
goog.addDependency('graphics/ext/coordinates_test.js', ['goog.graphics.ext.coordinatesTest'], ['goog.graphics', 'goog.graphics.ext.coordinates', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/ext/element.js', ['goog.graphics.ext.Element'], ['goog.events.EventTarget', 'goog.functions', 'goog.graphics.ext.coordinates'], {});
goog.addDependency('graphics/ext/element_test.js', ['goog.graphics.ext.ElementTest'], ['goog.graphics', 'goog.graphics.ext', 'goog.testing.StrictMock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/ext/ellipse.js', ['goog.graphics.ext.Ellipse'], ['goog.graphics.ext.StrokeAndFillElement'], {});
goog.addDependency('graphics/ext/ext.js', ['goog.graphics.ext'], ['goog.graphics.ext.Ellipse', 'goog.graphics.ext.Graphics', 'goog.graphics.ext.Group', 'goog.graphics.ext.Image', 'goog.graphics.ext.Rectangle', 'goog.graphics.ext.Shape', 'goog.graphics.ext.coordinates'], {});
goog.addDependency('graphics/ext/graphics.js', ['goog.graphics.ext.Graphics'], ['goog.events', 'goog.events.EventType', 'goog.graphics', 'goog.graphics.ext.Group'], {});
goog.addDependency('graphics/ext/group.js', ['goog.graphics.ext.Group'], ['goog.array', 'goog.graphics.ext.Element'], {});
goog.addDependency('graphics/ext/image.js', ['goog.graphics.ext.Image'], ['goog.graphics.ext.Element'], {});
goog.addDependency('graphics/ext/path.js', ['goog.graphics.ext.Path'], ['goog.graphics.AffineTransform', 'goog.graphics.Path', 'goog.math.Rect'], {});
goog.addDependency('graphics/ext/path_test.js', ['goog.graphics.ext.PathTest'], ['goog.graphics', 'goog.graphics.ext.Path', 'goog.math.Rect', 'goog.testing.graphics', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/ext/rectangle.js', ['goog.graphics.ext.Rectangle'], ['goog.graphics.ext.StrokeAndFillElement'], {});
goog.addDependency('graphics/ext/shape.js', ['goog.graphics.ext.Shape'], ['goog.graphics.ext.StrokeAndFillElement'], {});
goog.addDependency('graphics/ext/strokeandfillelement.js', ['goog.graphics.ext.StrokeAndFillElement'], ['goog.graphics.ext.Element'], {});
goog.addDependency('graphics/fill.js', ['goog.graphics.Fill'], [], {});
goog.addDependency('graphics/font.js', ['goog.graphics.Font'], [], {});
goog.addDependency('graphics/graphics.js', ['goog.graphics'], ['goog.dom', 'goog.graphics.CanvasGraphics', 'goog.graphics.SvgGraphics', 'goog.graphics.VmlGraphics', 'goog.userAgent'], {});
goog.addDependency('graphics/groupelement.js', ['goog.graphics.GroupElement'], ['goog.graphics.Element'], {});
goog.addDependency('graphics/imageelement.js', ['goog.graphics.ImageElement'], ['goog.graphics.Element'], {});
goog.addDependency('graphics/lineargradient.js', ['goog.graphics.LinearGradient'], ['goog.asserts', 'goog.graphics.Fill'], {});
goog.addDependency('graphics/path.js', ['goog.graphics.Path', 'goog.graphics.Path.Segment'], ['goog.array', 'goog.graphics.AffineTransform', 'goog.math'], {});
goog.addDependency('graphics/path_test.js', ['goog.graphics.PathTest'], ['goog.array', 'goog.graphics.AffineTransform', 'goog.graphics.Path', 'goog.testing.graphics', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/pathelement.js', ['goog.graphics.PathElement'], ['goog.graphics.StrokeAndFillElement'], {});
goog.addDependency('graphics/paths.js', ['goog.graphics.paths'], ['goog.graphics.Path', 'goog.math.Coordinate'], {});
goog.addDependency('graphics/paths_test.js', ['goog.graphics.pathsTest'], ['goog.dom', 'goog.graphics', 'goog.graphics.paths', 'goog.math.Coordinate', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/rectelement.js', ['goog.graphics.RectElement'], ['goog.graphics.StrokeAndFillElement'], {});
goog.addDependency('graphics/solidfill.js', ['goog.graphics.SolidFill'], ['goog.graphics.Fill'], {});
goog.addDependency('graphics/solidfill_test.js', ['goog.graphics.SolidFillTest'], ['goog.graphics.SolidFill', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/stroke.js', ['goog.graphics.Stroke'], [], {});
goog.addDependency('graphics/strokeandfillelement.js', ['goog.graphics.StrokeAndFillElement'], ['goog.graphics.Element'], {});
goog.addDependency('graphics/svgelement.js', ['goog.graphics.SvgEllipseElement', 'goog.graphics.SvgGroupElement', 'goog.graphics.SvgImageElement', 'goog.graphics.SvgPathElement', 'goog.graphics.SvgRectElement', 'goog.graphics.SvgTextElement'], ['goog.dom', 'goog.graphics.EllipseElement', 'goog.graphics.GroupElement', 'goog.graphics.ImageElement', 'goog.graphics.PathElement', 'goog.graphics.RectElement', 'goog.graphics.TextElement'], {});
goog.addDependency('graphics/svggraphics.js', ['goog.graphics.SvgGraphics'], ['goog.Timer', 'goog.dom', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.graphics.AbstractGraphics', 'goog.graphics.Font', 'goog.graphics.LinearGradient', 'goog.graphics.Path', 'goog.graphics.SolidFill', 'goog.graphics.Stroke', 'goog.graphics.SvgEllipseElement', 'goog.graphics.SvgGroupElement', 'goog.graphics.SvgImageElement', 'goog.graphics.SvgPathElement', 'goog.graphics.SvgRectElement', 'goog.graphics.SvgTextElement', 'goog.math', 'goog.math.Size', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('graphics/svggraphics_test.js', ['goog.graphics.SvgGraphicsTest'], ['goog.dom', 'goog.graphics.AffineTransform', 'goog.graphics.SolidFill', 'goog.graphics.SvgGraphics', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/textelement.js', ['goog.graphics.TextElement'], ['goog.graphics.StrokeAndFillElement'], {});
goog.addDependency('graphics/vmlelement.js', ['goog.graphics.VmlEllipseElement', 'goog.graphics.VmlGroupElement', 'goog.graphics.VmlImageElement', 'goog.graphics.VmlPathElement', 'goog.graphics.VmlRectElement', 'goog.graphics.VmlTextElement'], ['goog.dom', 'goog.graphics.EllipseElement', 'goog.graphics.GroupElement', 'goog.graphics.ImageElement', 'goog.graphics.PathElement', 'goog.graphics.RectElement', 'goog.graphics.TextElement'], {});
goog.addDependency('graphics/vmlgraphics.js', ['goog.graphics.VmlGraphics'], ['goog.array', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.graphics.AbstractGraphics', 'goog.graphics.Font', 'goog.graphics.LinearGradient', 'goog.graphics.Path', 'goog.graphics.SolidFill', 'goog.graphics.VmlEllipseElement', 'goog.graphics.VmlGroupElement', 'goog.graphics.VmlImageElement', 'goog.graphics.VmlPathElement', 'goog.graphics.VmlRectElement', 'goog.graphics.VmlTextElement', 'goog.html.uncheckedconversions', 'goog.math', 'goog.math.Size', 'goog.reflect', 'goog.string', 'goog.string.Const', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('history/event.js', ['goog.history.Event'], ['goog.events.Event', 'goog.history.EventType'], {});
goog.addDependency('history/eventtype.js', ['goog.history.EventType'], [], {});
goog.addDependency('history/history.js', ['goog.History', 'goog.History.Event', 'goog.History.EventType'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.safe', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.history.Event', 'goog.history.EventType', 'goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.uncheckedconversions', 'goog.labs.userAgent.device', 'goog.memoize', 'goog.string', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('history/history_test.js', ['goog.HistoryTest'], ['goog.History', 'goog.dispose', 'goog.dom', 'goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('history/html5history.js', ['goog.history.Html5History', 'goog.history.Html5History.TokenTransformer'], ['goog.asserts', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.history.Event'], {});
goog.addDependency('history/html5history_test.js', ['goog.history.Html5HistoryTest'], ['goog.Timer', 'goog.events', 'goog.events.EventType', 'goog.history.EventType', 'goog.history.Html5History', 'goog.testing.MockControl', 'goog.testing.mockmatchers', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/cssspecificity.js', ['goog.html.CssSpecificity'], ['goog.userAgent', 'goog.userAgent.product'], {'module': 'goog'});
goog.addDependency('html/cssspecificity_test.js', ['goog.html.CssSpecificityTest'], ['goog.html.CssSpecificity', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/flash.js', ['goog.html.flash'], ['goog.asserts', 'goog.html.SafeHtml'], {});
goog.addDependency('html/flash_test.js', ['goog.html.flashTest'], ['goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.flash', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/legacyconversions.js', ['goog.html.legacyconversions'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl'], {});
goog.addDependency('html/legacyconversions_test.js', ['goog.html.legacyconversionsTest'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.legacyconversions', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safehtml.js', ['goog.html.SafeHtml'], ['goog.array', 'goog.asserts', 'goog.dom.TagName', 'goog.dom.tags', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.trustedtypes', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.labs.userAgent.browser', 'goog.object', 'goog.string.Const', 'goog.string.TypedString', 'goog.string.internal'], {});
goog.addDependency('html/safehtml_test.js', ['goog.html.safeHtmlTest'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.testing', 'goog.html.trustedtypes', 'goog.i18n.bidi.Dir', 'goog.labs.userAgent.browser', 'goog.object', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safehtmlformatter.js', ['goog.html.SafeHtmlFormatter'], ['goog.asserts', 'goog.dom.tags', 'goog.html.SafeHtml', 'goog.string'], {});
goog.addDependency('html/safehtmlformatter_test.js', ['goog.html.safeHtmlFormatterTest'], ['goog.html.SafeHtml', 'goog.html.SafeHtmlFormatter', 'goog.html.SafeUrl', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safescript.js', ['goog.html.SafeScript'], ['goog.asserts', 'goog.html.trustedtypes', 'goog.string.Const', 'goog.string.TypedString'], {});
goog.addDependency('html/safescript_test.js', ['goog.html.safeScriptTest'], ['goog.html.SafeScript', 'goog.html.trustedtypes', 'goog.object', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safestyle.js', ['goog.html.SafeStyle'], ['goog.array', 'goog.asserts', 'goog.html.SafeUrl', 'goog.string.Const', 'goog.string.TypedString', 'goog.string.internal'], {'lang': 'es5'});
goog.addDependency('html/safestyle_test.js', ['goog.html.safeStyleTest'], ['goog.html.SafeStyle', 'goog.html.SafeUrl', 'goog.object', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safestylesheet.js', ['goog.html.SafeStyleSheet'], ['goog.array', 'goog.asserts', 'goog.html.SafeStyle', 'goog.object', 'goog.string.Const', 'goog.string.TypedString', 'goog.string.internal'], {});
goog.addDependency('html/safestylesheet_test.js', ['goog.html.safeStyleSheetTest'], ['goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.object', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safeurl.js', ['goog.html.SafeUrl'], ['goog.asserts', 'goog.fs.url', 'goog.html.TrustedResourceUrl', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.string.Const', 'goog.string.TypedString', 'goog.string.internal'], {});
goog.addDependency('html/safeurl_test.js', ['goog.html.safeUrlTest'], ['goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.safeUrlTestVectors', 'goog.i18n.bidi.Dir', 'goog.object', 'goog.string.Const', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safeurl_test_vectors.js', ['goog.html.safeUrlTestVectors'], [], {});
goog.addDependency('html/sanitizer/attributewhitelist.js', ['goog.html.sanitizer.AttributeSanitizedWhitelist', 'goog.html.sanitizer.AttributeWhitelist'], [], {});
goog.addDependency('html/sanitizer/csspropertysanitizer.js', ['goog.html.sanitizer.CssPropertySanitizer'], ['goog.asserts', 'goog.html.SafeUrl', 'goog.object', 'goog.string'], {'module': 'goog'});
goog.addDependency('html/sanitizer/csspropertysanitizer_test.js', ['goog.html.sanitizer.CssPropertySanitizerTest'], ['goog.functions', 'goog.html.SafeUrl', 'goog.html.sanitizer.CssPropertySanitizer', 'goog.html.sanitizer.noclobber', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/csssanitizer.js', ['goog.html.sanitizer.CssSanitizer'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.CssSpecificity', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.sanitizer.CssPropertySanitizer', 'goog.html.sanitizer.noclobber', 'goog.html.uncheckedconversions', 'goog.object', 'goog.string', 'goog.string.Const', 'goog.userAgent', 'goog.userAgent.product'], {});
goog.addDependency('html/sanitizer/csssanitizer_test.js', ['goog.html.CssSanitizerTest'], ['goog.array', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.sanitizer.CssSanitizer', 'goog.html.testing', 'goog.string', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/elementweakmap.js', ['goog.html.sanitizer.ElementWeakMap'], ['goog.html.sanitizer.noclobber'], {'module': 'goog'});
goog.addDependency('html/sanitizer/elementweakmap_test.js', ['goog.html.sanitizer.ElementWeakMapTest'], ['goog.html.sanitizer.ElementWeakMap', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/html_test_vectors.js', ['goog.html.htmlTestVectors'], [], {'lang': 'es5'});
goog.addDependency('html/sanitizer/htmlsanitizer.js', ['goog.html.sanitizer.HtmlSanitizer', 'goog.html.sanitizer.HtmlSanitizer.Builder', 'goog.html.sanitizer.HtmlSanitizerAttributePolicy', 'goog.html.sanitizer.HtmlSanitizerPolicy', 'goog.html.sanitizer.HtmlSanitizerPolicyContext', 'goog.html.sanitizer.HtmlSanitizerPolicyHints', 'goog.html.sanitizer.HtmlSanitizerUrlPolicy'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.sanitizer.AttributeSanitizedWhitelist', 'goog.html.sanitizer.AttributeWhitelist', 'goog.html.sanitizer.CssSanitizer', 'goog.html.sanitizer.SafeDomTreeProcessor', 'goog.html.sanitizer.TagBlacklist', 'goog.html.sanitizer.TagWhitelist', 'goog.html.sanitizer.noclobber', 'goog.html.uncheckedconversions', 'goog.object', 'goog.string', 'goog.string.Const'], {'lang': 'es5'});
goog.addDependency('html/sanitizer/htmlsanitizer_test.js', ['goog.html.HtmlSanitizerTest'], ['goog.array', 'goog.dom', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.SafeUrl', 'goog.html.sanitizer.HtmlSanitizer', 'goog.html.sanitizer.HtmlSanitizer.Builder', 'goog.html.sanitizer.TagWhitelist', 'goog.html.testing', 'goog.object', 'goog.string.Const', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/htmlsanitizer_unified_test.js', ['goog.html.HtmlSanitizerUnifiedTest'], ['goog.html.SafeHtml', 'goog.html.htmlTestVectors', 'goog.html.sanitizer.HtmlSanitizer.Builder', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/noclobber.js', ['goog.html.sanitizer.noclobber'], ['goog.asserts', 'goog.dom.NodeType', 'goog.userAgent.product'], {'lang': 'es5', 'module': 'goog'});
goog.addDependency('html/sanitizer/noclobber_test.js', ['goog.html.sanitizer.noclobberTest'], ['goog.dom.NodeType', 'goog.html.sanitizer.noclobber', 'goog.testing.PropertyReplacer', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/safedomtreeprocessor.js', ['goog.html.sanitizer.SafeDomTreeProcessor'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.sanitizer.ElementWeakMap', 'goog.html.sanitizer.noclobber', 'goog.html.uncheckedconversions', 'goog.log', 'goog.string.Const', 'goog.userAgent'], {'module': 'goog'});
goog.addDependency('html/sanitizer/safedomtreeprocessor_test.js', ['goog.html.sanitizer.SafeDomTreeProcessorTest'], ['goog.html.sanitizer.SafeDomTreeProcessor', 'goog.html.sanitizer.noclobber', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/tagblacklist.js', ['goog.html.sanitizer.TagBlacklist'], [], {});
goog.addDependency('html/sanitizer/tagwhitelist.js', ['goog.html.sanitizer.TagWhitelist'], [], {});
goog.addDependency('html/sanitizer/unsafe.js', ['goog.html.sanitizer.unsafe'], ['goog.asserts', 'goog.html.sanitizer.HtmlSanitizer.Builder', 'goog.string', 'goog.string.Const'], {});
goog.addDependency('html/sanitizer/unsafe_test.js', ['goog.html.UnsafeTest'], ['goog.html.SafeHtml', 'goog.html.sanitizer.AttributeWhitelist', 'goog.html.sanitizer.HtmlSanitizer', 'goog.html.sanitizer.TagWhitelist', 'goog.html.sanitizer.unsafe', 'goog.string.Const', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/silverlight.js', ['goog.html.silverlight'], ['goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.flash', 'goog.string.Const'], {});
goog.addDependency('html/silverlight_test.js', ['goog.html.silverlightTest'], ['goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.silverlight', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/testing.js', ['goog.html.testing'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.testing.mockmatchers.ArgumentMatcher'], {});
goog.addDependency('html/textextractor.js', ['goog.html.textExtractor'], ['goog.array', 'goog.dom.TagName', 'goog.html.sanitizer.HtmlSanitizer', 'goog.object', 'goog.userAgent'], {});
goog.addDependency('html/textextractor_test.js', ['goog.html.textExtractorTest'], ['goog.html.textExtractor', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/trustedresourceurl.js', ['goog.html.TrustedResourceUrl'], ['goog.asserts', 'goog.html.trustedtypes', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.string.Const', 'goog.string.TypedString'], {});
goog.addDependency('html/trustedresourceurl_test.js', ['goog.html.trustedResourceUrlTest'], ['goog.html.TrustedResourceUrl', 'goog.html.trustedtypes', 'goog.i18n.bidi.Dir', 'goog.object', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/trustedtypes.js', ['goog.html.trustedtypes'], [], {});
goog.addDependency('html/uncheckedconversions.js', ['goog.html.uncheckedconversions'], ['goog.asserts', 'goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.string.internal'], {});
goog.addDependency('html/uncheckedconversions_test.js', ['goog.html.uncheckedconversionsTest'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.uncheckedconversions', 'goog.i18n.bidi.Dir', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/utils.js', ['goog.html.utils'], ['goog.string'], {});
goog.addDependency('html/utils_test.js', ['goog.html.UtilsTest'], ['goog.array', 'goog.dom.TagName', 'goog.html.utils', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/bidi.js', ['goog.i18n.bidi', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.i18n.bidi.Format'], [], {'lang': 'es6'});
goog.addDependency('i18n/bidi_test.js', ['goog.i18n.bidiTest'], ['goog.i18n.bidi', 'goog.i18n.bidi.Dir', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/bidiformatter.js', ['goog.i18n.BidiFormatter'], ['goog.html.SafeHtml', 'goog.i18n.bidi', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.Format'], {});
goog.addDependency('i18n/bidiformatter_test.js', ['goog.i18n.BidiFormatterTest'], ['goog.html.SafeHtml', 'goog.html.testing', 'goog.i18n.BidiFormatter', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.Format', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/charlistdecompressor.js', ['goog.i18n.CharListDecompressor'], ['goog.array', 'goog.i18n.uChar'], {});
goog.addDependency('i18n/charlistdecompressor_test.js', ['goog.i18n.CharListDecompressorTest'], ['goog.i18n.CharListDecompressor', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/charpickerdata.js', ['goog.i18n.CharPickerData'], [], {});
goog.addDependency('i18n/collation.js', ['goog.i18n.collation'], [], {'lang': 'es6'});
goog.addDependency('i18n/collation_test.js', ['goog.i18n.collationTest'], ['goog.i18n.collation', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/compactnumberformatsymbols.js', ['goog.i18n.CompactNumberFormatSymbols', 'goog.i18n.CompactNumberFormatSymbols_af', 'goog.i18n.CompactNumberFormatSymbols_am', 'goog.i18n.CompactNumberFormatSymbols_ar', 'goog.i18n.CompactNumberFormatSymbols_ar_DZ', 'goog.i18n.CompactNumberFormatSymbols_ar_EG', 'goog.i18n.CompactNumberFormatSymbols_az', 'goog.i18n.CompactNumberFormatSymbols_be', 'goog.i18n.CompactNumberFormatSymbols_bg', 'goog.i18n.CompactNumberFormatSymbols_bn', 'goog.i18n.CompactNumberFormatSymbols_br', 'goog.i18n.CompactNumberFormatSymbols_bs', 'goog.i18n.CompactNumberFormatSymbols_ca', 'goog.i18n.CompactNumberFormatSymbols_chr', 'goog.i18n.CompactNumberFormatSymbols_cs', 'goog.i18n.CompactNumberFormatSymbols_cy', 'goog.i18n.CompactNumberFormatSymbols_da', 'goog.i18n.CompactNumberFormatSymbols_de', 'goog.i18n.CompactNumberFormatSymbols_de_AT', 'goog.i18n.CompactNumberFormatSymbols_de_CH', 'goog.i18n.CompactNumberFormatSymbols_el', 'goog.i18n.CompactNumberFormatSymbols_en', 'goog.i18n.CompactNumberFormatSymbols_en_AU', 'goog.i18n.CompactNumberFormatSymbols_en_CA', 'goog.i18n.CompactNumberFormatSymbols_en_GB', 'goog.i18n.CompactNumberFormatSymbols_en_IE', 'goog.i18n.CompactNumberFormatSymbols_en_IN', 'goog.i18n.CompactNumberFormatSymbols_en_SG', 'goog.i18n.CompactNumberFormatSymbols_en_US', 'goog.i18n.CompactNumberFormatSymbols_en_ZA', 'goog.i18n.CompactNumberFormatSymbols_es', 'goog.i18n.CompactNumberFormatSymbols_es_419', 'goog.i18n.CompactNumberFormatSymbols_es_ES', 'goog.i18n.CompactNumberFormatSymbols_es_MX', 'goog.i18n.CompactNumberFormatSymbols_es_US', 'goog.i18n.CompactNumberFormatSymbols_et', 'goog.i18n.CompactNumberFormatSymbols_eu', 'goog.i18n.CompactNumberFormatSymbols_fa', 'goog.i18n.CompactNumberFormatSymbols_fi', 'goog.i18n.CompactNumberFormatSymbols_fil', 'goog.i18n.CompactNumberFormatSymbols_fr', 'goog.i18n.CompactNumberFormatSymbols_fr_CA', 'goog.i18n.CompactNumberFormatSymbols_ga', 'goog.i18n.CompactNumberFormatSymbols_gl', 'goog.i18n.CompactNumberFormatSymbols_gsw', 'goog.i18n.CompactNumberFormatSymbols_gu', 'goog.i18n.CompactNumberFormatSymbols_haw', 'goog.i18n.CompactNumberFormatSymbols_he', 'goog.i18n.CompactNumberFormatSymbols_hi', 'goog.i18n.CompactNumberFormatSymbols_hr', 'goog.i18n.CompactNumberFormatSymbols_hu', 'goog.i18n.CompactNumberFormatSymbols_hy', 'goog.i18n.CompactNumberFormatSymbols_id', 'goog.i18n.CompactNumberFormatSymbols_in', 'goog.i18n.CompactNumberFormatSymbols_is', 'goog.i18n.CompactNumberFormatSymbols_it', 'goog.i18n.CompactNumberFormatSymbols_iw', 'goog.i18n.CompactNumberFormatSymbols_ja', 'goog.i18n.CompactNumberFormatSymbols_ka', 'goog.i18n.CompactNumberFormatSymbols_kk', 'goog.i18n.CompactNumberFormatSymbols_km', 'goog.i18n.CompactNumberFormatSymbols_kn', 'goog.i18n.CompactNumberFormatSymbols_ko', 'goog.i18n.CompactNumberFormatSymbols_ky', 'goog.i18n.CompactNumberFormatSymbols_ln', 'goog.i18n.CompactNumberFormatSymbols_lo', 'goog.i18n.CompactNumberFormatSymbols_lt', 'goog.i18n.CompactNumberFormatSymbols_lv', 'goog.i18n.CompactNumberFormatSymbols_mk', 'goog.i18n.CompactNumberFormatSymbols_ml', 'goog.i18n.CompactNumberFormatSymbols_mn', 'goog.i18n.CompactNumberFormatSymbols_mo', 'goog.i18n.CompactNumberFormatSymbols_mr', 'goog.i18n.CompactNumberFormatSymbols_ms', 'goog.i18n.CompactNumberFormatSymbols_mt', 'goog.i18n.CompactNumberFormatSymbols_my', 'goog.i18n.CompactNumberFormatSymbols_nb', 'goog.i18n.CompactNumberFormatSymbols_ne', 'goog.i18n.CompactNumberFormatSymbols_nl', 'goog.i18n.CompactNumberFormatSymbols_no', 'goog.i18n.CompactNumberFormatSymbols_no_NO', 'goog.i18n.CompactNumberFormatSymbols_or', 'goog.i18n.CompactNumberFormatSymbols_pa', 'goog.i18n.CompactNumberFormatSymbols_pl', 'goog.i18n.CompactNumberFormatSymbols_pt', 'goog.i18n.CompactNumberFormatSymbols_pt_BR', 'goog.i18n.CompactNumberFormatSymbols_pt_PT', 'goog.i18n.CompactNumberFormatSymbols_ro', 'goog.i18n.CompactNumberFormatSymbols_ru', 'goog.i18n.CompactNumberFormatSymbols_sh', 'goog.i18n.CompactNumberFormatSymbols_si', 'goog.i18n.CompactNumberFormatSymbols_sk', 'goog.i18n.CompactNumberFormatSymbols_sl', 'goog.i18n.CompactNumberFormatSymbols_sq', 'goog.i18n.CompactNumberFormatSymbols_sr', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn', 'goog.i18n.CompactNumberFormatSymbols_sv', 'goog.i18n.CompactNumberFormatSymbols_sw', 'goog.i18n.CompactNumberFormatSymbols_ta', 'goog.i18n.CompactNumberFormatSymbols_te', 'goog.i18n.CompactNumberFormatSymbols_th', 'goog.i18n.CompactNumberFormatSymbols_tl', 'goog.i18n.CompactNumberFormatSymbols_tr', 'goog.i18n.CompactNumberFormatSymbols_uk', 'goog.i18n.CompactNumberFormatSymbols_ur', 'goog.i18n.CompactNumberFormatSymbols_uz', 'goog.i18n.CompactNumberFormatSymbols_vi', 'goog.i18n.CompactNumberFormatSymbols_zh', 'goog.i18n.CompactNumberFormatSymbols_zh_CN', 'goog.i18n.CompactNumberFormatSymbols_zh_HK', 'goog.i18n.CompactNumberFormatSymbols_zh_TW', 'goog.i18n.CompactNumberFormatSymbols_zu'], [], {});
goog.addDependency('i18n/compactnumberformatsymbolsext.js', ['goog.i18n.CompactNumberFormatSymbolsExt', 'goog.i18n.CompactNumberFormatSymbols_af_NA', 'goog.i18n.CompactNumberFormatSymbols_af_ZA', 'goog.i18n.CompactNumberFormatSymbols_agq', 'goog.i18n.CompactNumberFormatSymbols_agq_CM', 'goog.i18n.CompactNumberFormatSymbols_ak', 'goog.i18n.CompactNumberFormatSymbols_ak_GH', 'goog.i18n.CompactNumberFormatSymbols_am_ET', 'goog.i18n.CompactNumberFormatSymbols_ar_001', 'goog.i18n.CompactNumberFormatSymbols_ar_AE', 'goog.i18n.CompactNumberFormatSymbols_ar_BH', 'goog.i18n.CompactNumberFormatSymbols_ar_DJ', 'goog.i18n.CompactNumberFormatSymbols_ar_EH', 'goog.i18n.CompactNumberFormatSymbols_ar_ER', 'goog.i18n.CompactNumberFormatSymbols_ar_IL', 'goog.i18n.CompactNumberFormatSymbols_ar_IQ', 'goog.i18n.CompactNumberFormatSymbols_ar_JO', 'goog.i18n.CompactNumberFormatSymbols_ar_KM', 'goog.i18n.CompactNumberFormatSymbols_ar_KW', 'goog.i18n.CompactNumberFormatSymbols_ar_LB', 'goog.i18n.CompactNumberFormatSymbols_ar_LY', 'goog.i18n.CompactNumberFormatSymbols_ar_MA', 'goog.i18n.CompactNumberFormatSymbols_ar_MR', 'goog.i18n.CompactNumberFormatSymbols_ar_OM', 'goog.i18n.CompactNumberFormatSymbols_ar_PS', 'goog.i18n.CompactNumberFormatSymbols_ar_QA', 'goog.i18n.CompactNumberFormatSymbols_ar_SA', 'goog.i18n.CompactNumberFormatSymbols_ar_SD', 'goog.i18n.CompactNumberFormatSymbols_ar_SO', 'goog.i18n.CompactNumberFormatSymbols_ar_SS', 'goog.i18n.CompactNumberFormatSymbols_ar_SY', 'goog.i18n.CompactNumberFormatSymbols_ar_TD', 'goog.i18n.CompactNumberFormatSymbols_ar_TN', 'goog.i18n.CompactNumberFormatSymbols_ar_XB', 'goog.i18n.CompactNumberFormatSymbols_ar_YE', 'goog.i18n.CompactNumberFormatSymbols_as', 'goog.i18n.CompactNumberFormatSymbols_as_IN', 'goog.i18n.CompactNumberFormatSymbols_asa', 'goog.i18n.CompactNumberFormatSymbols_asa_TZ', 'goog.i18n.CompactNumberFormatSymbols_ast', 'goog.i18n.CompactNumberFormatSymbols_ast_ES', 'goog.i18n.CompactNumberFormatSymbols_az_Cyrl', 'goog.i18n.CompactNumberFormatSymbols_az_Cyrl_AZ', 'goog.i18n.CompactNumberFormatSymbols_az_Latn', 'goog.i18n.CompactNumberFormatSymbols_az_Latn_AZ', 'goog.i18n.CompactNumberFormatSymbols_bas', 'goog.i18n.CompactNumberFormatSymbols_bas_CM', 'goog.i18n.CompactNumberFormatSymbols_be_BY', 'goog.i18n.CompactNumberFormatSymbols_bem', 'goog.i18n.CompactNumberFormatSymbols_bem_ZM', 'goog.i18n.CompactNumberFormatSymbols_bez', 'goog.i18n.CompactNumberFormatSymbols_bez_TZ', 'goog.i18n.CompactNumberFormatSymbols_bg_BG', 'goog.i18n.CompactNumberFormatSymbols_bm', 'goog.i18n.CompactNumberFormatSymbols_bm_ML', 'goog.i18n.CompactNumberFormatSymbols_bn_BD', 'goog.i18n.CompactNumberFormatSymbols_bn_IN', 'goog.i18n.CompactNumberFormatSymbols_bo', 'goog.i18n.CompactNumberFormatSymbols_bo_CN', 'goog.i18n.CompactNumberFormatSymbols_bo_IN', 'goog.i18n.CompactNumberFormatSymbols_br_FR', 'goog.i18n.CompactNumberFormatSymbols_brx', 'goog.i18n.CompactNumberFormatSymbols_brx_IN', 'goog.i18n.CompactNumberFormatSymbols_bs_Cyrl', 'goog.i18n.CompactNumberFormatSymbols_bs_Cyrl_BA', 'goog.i18n.CompactNumberFormatSymbols_bs_Latn', 'goog.i18n.CompactNumberFormatSymbols_bs_Latn_BA', 'goog.i18n.CompactNumberFormatSymbols_ca_AD', 'goog.i18n.CompactNumberFormatSymbols_ca_ES', 'goog.i18n.CompactNumberFormatSymbols_ca_FR', 'goog.i18n.CompactNumberFormatSymbols_ca_IT', 'goog.i18n.CompactNumberFormatSymbols_ccp', 'goog.i18n.CompactNumberFormatSymbols_ccp_BD', 'goog.i18n.CompactNumberFormatSymbols_ccp_IN', 'goog.i18n.CompactNumberFormatSymbols_ce', 'goog.i18n.CompactNumberFormatSymbols_ce_RU', 'goog.i18n.CompactNumberFormatSymbols_ceb', 'goog.i18n.CompactNumberFormatSymbols_ceb_PH', 'goog.i18n.CompactNumberFormatSymbols_cgg', 'goog.i18n.CompactNumberFormatSymbols_cgg_UG', 'goog.i18n.CompactNumberFormatSymbols_chr_US', 'goog.i18n.CompactNumberFormatSymbols_ckb', 'goog.i18n.CompactNumberFormatSymbols_ckb_IQ', 'goog.i18n.CompactNumberFormatSymbols_ckb_IR', 'goog.i18n.CompactNumberFormatSymbols_cs_CZ', 'goog.i18n.CompactNumberFormatSymbols_cy_GB', 'goog.i18n.CompactNumberFormatSymbols_da_DK', 'goog.i18n.CompactNumberFormatSymbols_da_GL', 'goog.i18n.CompactNumberFormatSymbols_dav', 'goog.i18n.CompactNumberFormatSymbols_dav_KE', 'goog.i18n.CompactNumberFormatSymbols_de_BE', 'goog.i18n.CompactNumberFormatSymbols_de_DE', 'goog.i18n.CompactNumberFormatSymbols_de_IT', 'goog.i18n.CompactNumberFormatSymbols_de_LI', 'goog.i18n.CompactNumberFormatSymbols_de_LU', 'goog.i18n.CompactNumberFormatSymbols_dje', 'goog.i18n.CompactNumberFormatSymbols_dje_NE', 'goog.i18n.CompactNumberFormatSymbols_dsb', 'goog.i18n.CompactNumberFormatSymbols_dsb_DE', 'goog.i18n.CompactNumberFormatSymbols_dua', 'goog.i18n.CompactNumberFormatSymbols_dua_CM', 'goog.i18n.CompactNumberFormatSymbols_dyo', 'goog.i18n.CompactNumberFormatSymbols_dyo_SN', 'goog.i18n.CompactNumberFormatSymbols_dz', 'goog.i18n.CompactNumberFormatSymbols_dz_BT', 'goog.i18n.CompactNumberFormatSymbols_ebu', 'goog.i18n.CompactNumberFormatSymbols_ebu_KE', 'goog.i18n.CompactNumberFormatSymbols_ee', 'goog.i18n.CompactNumberFormatSymbols_ee_GH', 'goog.i18n.CompactNumberFormatSymbols_ee_TG', 'goog.i18n.CompactNumberFormatSymbols_el_CY', 'goog.i18n.CompactNumberFormatSymbols_el_GR', 'goog.i18n.CompactNumberFormatSymbols_en_001', 'goog.i18n.CompactNumberFormatSymbols_en_150', 'goog.i18n.CompactNumberFormatSymbols_en_AE', 'goog.i18n.CompactNumberFormatSymbols_en_AG', 'goog.i18n.CompactNumberFormatSymbols_en_AI', 'goog.i18n.CompactNumberFormatSymbols_en_AS', 'goog.i18n.CompactNumberFormatSymbols_en_AT', 'goog.i18n.CompactNumberFormatSymbols_en_BB', 'goog.i18n.CompactNumberFormatSymbols_en_BE', 'goog.i18n.CompactNumberFormatSymbols_en_BI', 'goog.i18n.CompactNumberFormatSymbols_en_BM', 'goog.i18n.CompactNumberFormatSymbols_en_BS', 'goog.i18n.CompactNumberFormatSymbols_en_BW', 'goog.i18n.CompactNumberFormatSymbols_en_BZ', 'goog.i18n.CompactNumberFormatSymbols_en_CC', 'goog.i18n.CompactNumberFormatSymbols_en_CH', 'goog.i18n.CompactNumberFormatSymbols_en_CK', 'goog.i18n.CompactNumberFormatSymbols_en_CM', 'goog.i18n.CompactNumberFormatSymbols_en_CX', 'goog.i18n.CompactNumberFormatSymbols_en_CY', 'goog.i18n.CompactNumberFormatSymbols_en_DE', 'goog.i18n.CompactNumberFormatSymbols_en_DG', 'goog.i18n.CompactNumberFormatSymbols_en_DK', 'goog.i18n.CompactNumberFormatSymbols_en_DM', 'goog.i18n.CompactNumberFormatSymbols_en_ER', 'goog.i18n.CompactNumberFormatSymbols_en_FI', 'goog.i18n.CompactNumberFormatSymbols_en_FJ', 'goog.i18n.CompactNumberFormatSymbols_en_FK', 'goog.i18n.CompactNumberFormatSymbols_en_FM', 'goog.i18n.CompactNumberFormatSymbols_en_GD', 'goog.i18n.CompactNumberFormatSymbols_en_GG', 'goog.i18n.CompactNumberFormatSymbols_en_GH', 'goog.i18n.CompactNumberFormatSymbols_en_GI', 'goog.i18n.CompactNumberFormatSymbols_en_GM', 'goog.i18n.CompactNumberFormatSymbols_en_GU', 'goog.i18n.CompactNumberFormatSymbols_en_GY', 'goog.i18n.CompactNumberFormatSymbols_en_HK', 'goog.i18n.CompactNumberFormatSymbols_en_IL', 'goog.i18n.CompactNumberFormatSymbols_en_IM', 'goog.i18n.CompactNumberFormatSymbols_en_IO', 'goog.i18n.CompactNumberFormatSymbols_en_JE', 'goog.i18n.CompactNumberFormatSymbols_en_JM', 'goog.i18n.CompactNumberFormatSymbols_en_KE', 'goog.i18n.CompactNumberFormatSymbols_en_KI', 'goog.i18n.CompactNumberFormatSymbols_en_KN', 'goog.i18n.CompactNumberFormatSymbols_en_KY', 'goog.i18n.CompactNumberFormatSymbols_en_LC', 'goog.i18n.CompactNumberFormatSymbols_en_LR', 'goog.i18n.CompactNumberFormatSymbols_en_LS', 'goog.i18n.CompactNumberFormatSymbols_en_MG', 'goog.i18n.CompactNumberFormatSymbols_en_MH', 'goog.i18n.CompactNumberFormatSymbols_en_MO', 'goog.i18n.CompactNumberFormatSymbols_en_MP', 'goog.i18n.CompactNumberFormatSymbols_en_MS', 'goog.i18n.CompactNumberFormatSymbols_en_MT', 'goog.i18n.CompactNumberFormatSymbols_en_MU', 'goog.i18n.CompactNumberFormatSymbols_en_MW', 'goog.i18n.CompactNumberFormatSymbols_en_MY', 'goog.i18n.CompactNumberFormatSymbols_en_NA', 'goog.i18n.CompactNumberFormatSymbols_en_NF', 'goog.i18n.CompactNumberFormatSymbols_en_NG', 'goog.i18n.CompactNumberFormatSymbols_en_NL', 'goog.i18n.CompactNumberFormatSymbols_en_NR', 'goog.i18n.CompactNumberFormatSymbols_en_NU', 'goog.i18n.CompactNumberFormatSymbols_en_NZ', 'goog.i18n.CompactNumberFormatSymbols_en_PG', 'goog.i18n.CompactNumberFormatSymbols_en_PH', 'goog.i18n.CompactNumberFormatSymbols_en_PK', 'goog.i18n.CompactNumberFormatSymbols_en_PN', 'goog.i18n.CompactNumberFormatSymbols_en_PR', 'goog.i18n.CompactNumberFormatSymbols_en_PW', 'goog.i18n.CompactNumberFormatSymbols_en_RW', 'goog.i18n.CompactNumberFormatSymbols_en_SB', 'goog.i18n.CompactNumberFormatSymbols_en_SC', 'goog.i18n.CompactNumberFormatSymbols_en_SD', 'goog.i18n.CompactNumberFormatSymbols_en_SE', 'goog.i18n.CompactNumberFormatSymbols_en_SH', 'goog.i18n.CompactNumberFormatSymbols_en_SI', 'goog.i18n.CompactNumberFormatSymbols_en_SL', 'goog.i18n.CompactNumberFormatSymbols_en_SS', 'goog.i18n.CompactNumberFormatSymbols_en_SX', 'goog.i18n.CompactNumberFormatSymbols_en_SZ', 'goog.i18n.CompactNumberFormatSymbols_en_TC', 'goog.i18n.CompactNumberFormatSymbols_en_TK', 'goog.i18n.CompactNumberFormatSymbols_en_TO', 'goog.i18n.CompactNumberFormatSymbols_en_TT', 'goog.i18n.CompactNumberFormatSymbols_en_TV', 'goog.i18n.CompactNumberFormatSymbols_en_TZ', 'goog.i18n.CompactNumberFormatSymbols_en_UG', 'goog.i18n.CompactNumberFormatSymbols_en_UM', 'goog.i18n.CompactNumberFormatSymbols_en_US_POSIX', 'goog.i18n.CompactNumberFormatSymbols_en_VC', 'goog.i18n.CompactNumberFormatSymbols_en_VG', 'goog.i18n.CompactNumberFormatSymbols_en_VI', 'goog.i18n.CompactNumberFormatSymbols_en_VU', 'goog.i18n.CompactNumberFormatSymbols_en_WS', 'goog.i18n.CompactNumberFormatSymbols_en_XA', 'goog.i18n.CompactNumberFormatSymbols_en_ZM', 'goog.i18n.CompactNumberFormatSymbols_en_ZW', 'goog.i18n.CompactNumberFormatSymbols_eo', 'goog.i18n.CompactNumberFormatSymbols_eo_001', 'goog.i18n.CompactNumberFormatSymbols_es_AR', 'goog.i18n.CompactNumberFormatSymbols_es_BO', 'goog.i18n.CompactNumberFormatSymbols_es_BR', 'goog.i18n.CompactNumberFormatSymbols_es_BZ', 'goog.i18n.CompactNumberFormatSymbols_es_CL', 'goog.i18n.CompactNumberFormatSymbols_es_CO', 'goog.i18n.CompactNumberFormatSymbols_es_CR', 'goog.i18n.CompactNumberFormatSymbols_es_CU', 'goog.i18n.CompactNumberFormatSymbols_es_DO', 'goog.i18n.CompactNumberFormatSymbols_es_EA', 'goog.i18n.CompactNumberFormatSymbols_es_EC', 'goog.i18n.CompactNumberFormatSymbols_es_GQ', 'goog.i18n.CompactNumberFormatSymbols_es_GT', 'goog.i18n.CompactNumberFormatSymbols_es_HN', 'goog.i18n.CompactNumberFormatSymbols_es_IC', 'goog.i18n.CompactNumberFormatSymbols_es_NI', 'goog.i18n.CompactNumberFormatSymbols_es_PA', 'goog.i18n.CompactNumberFormatSymbols_es_PE', 'goog.i18n.CompactNumberFormatSymbols_es_PH', 'goog.i18n.CompactNumberFormatSymbols_es_PR', 'goog.i18n.CompactNumberFormatSymbols_es_PY', 'goog.i18n.CompactNumberFormatSymbols_es_SV', 'goog.i18n.CompactNumberFormatSymbols_es_UY', 'goog.i18n.CompactNumberFormatSymbols_es_VE', 'goog.i18n.CompactNumberFormatSymbols_et_EE', 'goog.i18n.CompactNumberFormatSymbols_eu_ES', 'goog.i18n.CompactNumberFormatSymbols_ewo', 'goog.i18n.CompactNumberFormatSymbols_ewo_CM', 'goog.i18n.CompactNumberFormatSymbols_fa_AF', 'goog.i18n.CompactNumberFormatSymbols_fa_IR', 'goog.i18n.CompactNumberFormatSymbols_ff', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_BF', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_CM', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_GH', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_GM', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_GN', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_GW', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_LR', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_MR', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_NE', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_NG', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_SL', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_SN', 'goog.i18n.CompactNumberFormatSymbols_fi_FI', 'goog.i18n.CompactNumberFormatSymbols_fil_PH', 'goog.i18n.CompactNumberFormatSymbols_fo', 'goog.i18n.CompactNumberFormatSymbols_fo_DK', 'goog.i18n.CompactNumberFormatSymbols_fo_FO', 'goog.i18n.CompactNumberFormatSymbols_fr_BE', 'goog.i18n.CompactNumberFormatSymbols_fr_BF', 'goog.i18n.CompactNumberFormatSymbols_fr_BI', 'goog.i18n.CompactNumberFormatSymbols_fr_BJ', 'goog.i18n.CompactNumberFormatSymbols_fr_BL', 'goog.i18n.CompactNumberFormatSymbols_fr_CD', 'goog.i18n.CompactNumberFormatSymbols_fr_CF', 'goog.i18n.CompactNumberFormatSymbols_fr_CG', 'goog.i18n.CompactNumberFormatSymbols_fr_CH', 'goog.i18n.CompactNumberFormatSymbols_fr_CI', 'goog.i18n.CompactNumberFormatSymbols_fr_CM', 'goog.i18n.CompactNumberFormatSymbols_fr_DJ', 'goog.i18n.CompactNumberFormatSymbols_fr_DZ', 'goog.i18n.CompactNumberFormatSymbols_fr_FR', 'goog.i18n.CompactNumberFormatSymbols_fr_GA', 'goog.i18n.CompactNumberFormatSymbols_fr_GF', 'goog.i18n.CompactNumberFormatSymbols_fr_GN', 'goog.i18n.CompactNumberFormatSymbols_fr_GP', 'goog.i18n.CompactNumberFormatSymbols_fr_GQ', 'goog.i18n.CompactNumberFormatSymbols_fr_HT', 'goog.i18n.CompactNumberFormatSymbols_fr_KM', 'goog.i18n.CompactNumberFormatSymbols_fr_LU', 'goog.i18n.CompactNumberFormatSymbols_fr_MA', 'goog.i18n.CompactNumberFormatSymbols_fr_MC', 'goog.i18n.CompactNumberFormatSymbols_fr_MF', 'goog.i18n.CompactNumberFormatSymbols_fr_MG', 'goog.i18n.CompactNumberFormatSymbols_fr_ML', 'goog.i18n.CompactNumberFormatSymbols_fr_MQ', 'goog.i18n.CompactNumberFormatSymbols_fr_MR', 'goog.i18n.CompactNumberFormatSymbols_fr_MU', 'goog.i18n.CompactNumberFormatSymbols_fr_NC', 'goog.i18n.CompactNumberFormatSymbols_fr_NE', 'goog.i18n.CompactNumberFormatSymbols_fr_PF', 'goog.i18n.CompactNumberFormatSymbols_fr_PM', 'goog.i18n.CompactNumberFormatSymbols_fr_RE', 'goog.i18n.CompactNumberFormatSymbols_fr_RW', 'goog.i18n.CompactNumberFormatSymbols_fr_SC', 'goog.i18n.CompactNumberFormatSymbols_fr_SN', 'goog.i18n.CompactNumberFormatSymbols_fr_SY', 'goog.i18n.CompactNumberFormatSymbols_fr_TD', 'goog.i18n.CompactNumberFormatSymbols_fr_TG', 'goog.i18n.CompactNumberFormatSymbols_fr_TN', 'goog.i18n.CompactNumberFormatSymbols_fr_VU', 'goog.i18n.CompactNumberFormatSymbols_fr_WF', 'goog.i18n.CompactNumberFormatSymbols_fr_YT', 'goog.i18n.CompactNumberFormatSymbols_fur', 'goog.i18n.CompactNumberFormatSymbols_fur_IT', 'goog.i18n.CompactNumberFormatSymbols_fy', 'goog.i18n.CompactNumberFormatSymbols_fy_NL', 'goog.i18n.CompactNumberFormatSymbols_ga_IE', 'goog.i18n.CompactNumberFormatSymbols_gd', 'goog.i18n.CompactNumberFormatSymbols_gd_GB', 'goog.i18n.CompactNumberFormatSymbols_gl_ES', 'goog.i18n.CompactNumberFormatSymbols_gsw_CH', 'goog.i18n.CompactNumberFormatSymbols_gsw_FR', 'goog.i18n.CompactNumberFormatSymbols_gsw_LI', 'goog.i18n.CompactNumberFormatSymbols_gu_IN', 'goog.i18n.CompactNumberFormatSymbols_guz', 'goog.i18n.CompactNumberFormatSymbols_guz_KE', 'goog.i18n.CompactNumberFormatSymbols_gv', 'goog.i18n.CompactNumberFormatSymbols_gv_IM', 'goog.i18n.CompactNumberFormatSymbols_ha', 'goog.i18n.CompactNumberFormatSymbols_ha_GH', 'goog.i18n.CompactNumberFormatSymbols_ha_NE', 'goog.i18n.CompactNumberFormatSymbols_ha_NG', 'goog.i18n.CompactNumberFormatSymbols_haw_US', 'goog.i18n.CompactNumberFormatSymbols_he_IL', 'goog.i18n.CompactNumberFormatSymbols_hi_IN', 'goog.i18n.CompactNumberFormatSymbols_hr_BA', 'goog.i18n.CompactNumberFormatSymbols_hr_HR', 'goog.i18n.CompactNumberFormatSymbols_hsb', 'goog.i18n.CompactNumberFormatSymbols_hsb_DE', 'goog.i18n.CompactNumberFormatSymbols_hu_HU', 'goog.i18n.CompactNumberFormatSymbols_hy_AM', 'goog.i18n.CompactNumberFormatSymbols_ia', 'goog.i18n.CompactNumberFormatSymbols_ia_001', 'goog.i18n.CompactNumberFormatSymbols_id_ID', 'goog.i18n.CompactNumberFormatSymbols_ig', 'goog.i18n.CompactNumberFormatSymbols_ig_NG', 'goog.i18n.CompactNumberFormatSymbols_ii', 'goog.i18n.CompactNumberFormatSymbols_ii_CN', 'goog.i18n.CompactNumberFormatSymbols_is_IS', 'goog.i18n.CompactNumberFormatSymbols_it_CH', 'goog.i18n.CompactNumberFormatSymbols_it_IT', 'goog.i18n.CompactNumberFormatSymbols_it_SM', 'goog.i18n.CompactNumberFormatSymbols_it_VA', 'goog.i18n.CompactNumberFormatSymbols_ja_JP', 'goog.i18n.CompactNumberFormatSymbols_jgo', 'goog.i18n.CompactNumberFormatSymbols_jgo_CM', 'goog.i18n.CompactNumberFormatSymbols_jmc', 'goog.i18n.CompactNumberFormatSymbols_jmc_TZ', 'goog.i18n.CompactNumberFormatSymbols_jv', 'goog.i18n.CompactNumberFormatSymbols_jv_ID', 'goog.i18n.CompactNumberFormatSymbols_ka_GE', 'goog.i18n.CompactNumberFormatSymbols_kab', 'goog.i18n.CompactNumberFormatSymbols_kab_DZ', 'goog.i18n.CompactNumberFormatSymbols_kam', 'goog.i18n.CompactNumberFormatSymbols_kam_KE', 'goog.i18n.CompactNumberFormatSymbols_kde', 'goog.i18n.CompactNumberFormatSymbols_kde_TZ', 'goog.i18n.CompactNumberFormatSymbols_kea', 'goog.i18n.CompactNumberFormatSymbols_kea_CV', 'goog.i18n.CompactNumberFormatSymbols_khq', 'goog.i18n.CompactNumberFormatSymbols_khq_ML', 'goog.i18n.CompactNumberFormatSymbols_ki', 'goog.i18n.CompactNumberFormatSymbols_ki_KE', 'goog.i18n.CompactNumberFormatSymbols_kk_KZ', 'goog.i18n.CompactNumberFormatSymbols_kkj', 'goog.i18n.CompactNumberFormatSymbols_kkj_CM', 'goog.i18n.CompactNumberFormatSymbols_kl', 'goog.i18n.CompactNumberFormatSymbols_kl_GL', 'goog.i18n.CompactNumberFormatSymbols_kln', 'goog.i18n.CompactNumberFormatSymbols_kln_KE', 'goog.i18n.CompactNumberFormatSymbols_km_KH', 'goog.i18n.CompactNumberFormatSymbols_kn_IN', 'goog.i18n.CompactNumberFormatSymbols_ko_KP', 'goog.i18n.CompactNumberFormatSymbols_ko_KR', 'goog.i18n.CompactNumberFormatSymbols_kok', 'goog.i18n.CompactNumberFormatSymbols_kok_IN', 'goog.i18n.CompactNumberFormatSymbols_ks', 'goog.i18n.CompactNumberFormatSymbols_ks_IN', 'goog.i18n.CompactNumberFormatSymbols_ksb', 'goog.i18n.CompactNumberFormatSymbols_ksb_TZ', 'goog.i18n.CompactNumberFormatSymbols_ksf', 'goog.i18n.CompactNumberFormatSymbols_ksf_CM', 'goog.i18n.CompactNumberFormatSymbols_ksh', 'goog.i18n.CompactNumberFormatSymbols_ksh_DE', 'goog.i18n.CompactNumberFormatSymbols_ku', 'goog.i18n.CompactNumberFormatSymbols_ku_TR', 'goog.i18n.CompactNumberFormatSymbols_kw', 'goog.i18n.CompactNumberFormatSymbols_kw_GB', 'goog.i18n.CompactNumberFormatSymbols_ky_KG', 'goog.i18n.CompactNumberFormatSymbols_lag', 'goog.i18n.CompactNumberFormatSymbols_lag_TZ', 'goog.i18n.CompactNumberFormatSymbols_lb', 'goog.i18n.CompactNumberFormatSymbols_lb_LU', 'goog.i18n.CompactNumberFormatSymbols_lg', 'goog.i18n.CompactNumberFormatSymbols_lg_UG', 'goog.i18n.CompactNumberFormatSymbols_lkt', 'goog.i18n.CompactNumberFormatSymbols_lkt_US', 'goog.i18n.CompactNumberFormatSymbols_ln_AO', 'goog.i18n.CompactNumberFormatSymbols_ln_CD', 'goog.i18n.CompactNumberFormatSymbols_ln_CF', 'goog.i18n.CompactNumberFormatSymbols_ln_CG', 'goog.i18n.CompactNumberFormatSymbols_lo_LA', 'goog.i18n.CompactNumberFormatSymbols_lrc', 'goog.i18n.CompactNumberFormatSymbols_lrc_IQ', 'goog.i18n.CompactNumberFormatSymbols_lrc_IR', 'goog.i18n.CompactNumberFormatSymbols_lt_LT', 'goog.i18n.CompactNumberFormatSymbols_lu', 'goog.i18n.CompactNumberFormatSymbols_lu_CD', 'goog.i18n.CompactNumberFormatSymbols_luo', 'goog.i18n.CompactNumberFormatSymbols_luo_KE', 'goog.i18n.CompactNumberFormatSymbols_luy', 'goog.i18n.CompactNumberFormatSymbols_luy_KE', 'goog.i18n.CompactNumberFormatSymbols_lv_LV', 'goog.i18n.CompactNumberFormatSymbols_mas', 'goog.i18n.CompactNumberFormatSymbols_mas_KE', 'goog.i18n.CompactNumberFormatSymbols_mas_TZ', 'goog.i18n.CompactNumberFormatSymbols_mer', 'goog.i18n.CompactNumberFormatSymbols_mer_KE', 'goog.i18n.CompactNumberFormatSymbols_mfe', 'goog.i18n.CompactNumberFormatSymbols_mfe_MU', 'goog.i18n.CompactNumberFormatSymbols_mg', 'goog.i18n.CompactNumberFormatSymbols_mg_MG', 'goog.i18n.CompactNumberFormatSymbols_mgh', 'goog.i18n.CompactNumberFormatSymbols_mgh_MZ', 'goog.i18n.CompactNumberFormatSymbols_mgo', 'goog.i18n.CompactNumberFormatSymbols_mgo_CM', 'goog.i18n.CompactNumberFormatSymbols_mi', 'goog.i18n.CompactNumberFormatSymbols_mi_NZ', 'goog.i18n.CompactNumberFormatSymbols_mk_MK', 'goog.i18n.CompactNumberFormatSymbols_ml_IN', 'goog.i18n.CompactNumberFormatSymbols_mn_MN', 'goog.i18n.CompactNumberFormatSymbols_mr_IN', 'goog.i18n.CompactNumberFormatSymbols_ms_BN', 'goog.i18n.CompactNumberFormatSymbols_ms_MY', 'goog.i18n.CompactNumberFormatSymbols_ms_SG', 'goog.i18n.CompactNumberFormatSymbols_mt_MT', 'goog.i18n.CompactNumberFormatSymbols_mua', 'goog.i18n.CompactNumberFormatSymbols_mua_CM', 'goog.i18n.CompactNumberFormatSymbols_my_MM', 'goog.i18n.CompactNumberFormatSymbols_mzn', 'goog.i18n.CompactNumberFormatSymbols_mzn_IR', 'goog.i18n.CompactNumberFormatSymbols_naq', 'goog.i18n.CompactNumberFormatSymbols_naq_NA', 'goog.i18n.CompactNumberFormatSymbols_nb_NO', 'goog.i18n.CompactNumberFormatSymbols_nb_SJ', 'goog.i18n.CompactNumberFormatSymbols_nd', 'goog.i18n.CompactNumberFormatSymbols_nd_ZW', 'goog.i18n.CompactNumberFormatSymbols_nds', 'goog.i18n.CompactNumberFormatSymbols_nds_DE', 'goog.i18n.CompactNumberFormatSymbols_nds_NL', 'goog.i18n.CompactNumberFormatSymbols_ne_IN', 'goog.i18n.CompactNumberFormatSymbols_ne_NP', 'goog.i18n.CompactNumberFormatSymbols_nl_AW', 'goog.i18n.CompactNumberFormatSymbols_nl_BE', 'goog.i18n.CompactNumberFormatSymbols_nl_BQ', 'goog.i18n.CompactNumberFormatSymbols_nl_CW', 'goog.i18n.CompactNumberFormatSymbols_nl_NL', 'goog.i18n.CompactNumberFormatSymbols_nl_SR', 'goog.i18n.CompactNumberFormatSymbols_nl_SX', 'goog.i18n.CompactNumberFormatSymbols_nmg', 'goog.i18n.CompactNumberFormatSymbols_nmg_CM', 'goog.i18n.CompactNumberFormatSymbols_nn', 'goog.i18n.CompactNumberFormatSymbols_nn_NO', 'goog.i18n.CompactNumberFormatSymbols_nnh', 'goog.i18n.CompactNumberFormatSymbols_nnh_CM', 'goog.i18n.CompactNumberFormatSymbols_nus', 'goog.i18n.CompactNumberFormatSymbols_nus_SS', 'goog.i18n.CompactNumberFormatSymbols_nyn', 'goog.i18n.CompactNumberFormatSymbols_nyn_UG', 'goog.i18n.CompactNumberFormatSymbols_om', 'goog.i18n.CompactNumberFormatSymbols_om_ET', 'goog.i18n.CompactNumberFormatSymbols_om_KE', 'goog.i18n.CompactNumberFormatSymbols_or_IN', 'goog.i18n.CompactNumberFormatSymbols_os', 'goog.i18n.CompactNumberFormatSymbols_os_GE', 'goog.i18n.CompactNumberFormatSymbols_os_RU', 'goog.i18n.CompactNumberFormatSymbols_pa_Arab', 'goog.i18n.CompactNumberFormatSymbols_pa_Arab_PK', 'goog.i18n.CompactNumberFormatSymbols_pa_Guru', 'goog.i18n.CompactNumberFormatSymbols_pa_Guru_IN', 'goog.i18n.CompactNumberFormatSymbols_pl_PL', 'goog.i18n.CompactNumberFormatSymbols_ps', 'goog.i18n.CompactNumberFormatSymbols_ps_AF', 'goog.i18n.CompactNumberFormatSymbols_ps_PK', 'goog.i18n.CompactNumberFormatSymbols_pt_AO', 'goog.i18n.CompactNumberFormatSymbols_pt_CH', 'goog.i18n.CompactNumberFormatSymbols_pt_CV', 'goog.i18n.CompactNumberFormatSymbols_pt_GQ', 'goog.i18n.CompactNumberFormatSymbols_pt_GW', 'goog.i18n.CompactNumberFormatSymbols_pt_LU', 'goog.i18n.CompactNumberFormatSymbols_pt_MO', 'goog.i18n.CompactNumberFormatSymbols_pt_MZ', 'goog.i18n.CompactNumberFormatSymbols_pt_ST', 'goog.i18n.CompactNumberFormatSymbols_pt_TL', 'goog.i18n.CompactNumberFormatSymbols_qu', 'goog.i18n.CompactNumberFormatSymbols_qu_BO', 'goog.i18n.CompactNumberFormatSymbols_qu_EC', 'goog.i18n.CompactNumberFormatSymbols_qu_PE', 'goog.i18n.CompactNumberFormatSymbols_rm', 'goog.i18n.CompactNumberFormatSymbols_rm_CH', 'goog.i18n.CompactNumberFormatSymbols_rn', 'goog.i18n.CompactNumberFormatSymbols_rn_BI', 'goog.i18n.CompactNumberFormatSymbols_ro_MD', 'goog.i18n.CompactNumberFormatSymbols_ro_RO', 'goog.i18n.CompactNumberFormatSymbols_rof', 'goog.i18n.CompactNumberFormatSymbols_rof_TZ', 'goog.i18n.CompactNumberFormatSymbols_ru_BY', 'goog.i18n.CompactNumberFormatSymbols_ru_KG', 'goog.i18n.CompactNumberFormatSymbols_ru_KZ', 'goog.i18n.CompactNumberFormatSymbols_ru_MD', 'goog.i18n.CompactNumberFormatSymbols_ru_RU', 'goog.i18n.CompactNumberFormatSymbols_ru_UA', 'goog.i18n.CompactNumberFormatSymbols_rw', 'goog.i18n.CompactNumberFormatSymbols_rw_RW', 'goog.i18n.CompactNumberFormatSymbols_rwk', 'goog.i18n.CompactNumberFormatSymbols_rwk_TZ', 'goog.i18n.CompactNumberFormatSymbols_sah', 'goog.i18n.CompactNumberFormatSymbols_sah_RU', 'goog.i18n.CompactNumberFormatSymbols_saq', 'goog.i18n.CompactNumberFormatSymbols_saq_KE', 'goog.i18n.CompactNumberFormatSymbols_sbp', 'goog.i18n.CompactNumberFormatSymbols_sbp_TZ', 'goog.i18n.CompactNumberFormatSymbols_sd', 'goog.i18n.CompactNumberFormatSymbols_sd_PK', 'goog.i18n.CompactNumberFormatSymbols_se', 'goog.i18n.CompactNumberFormatSymbols_se_FI', 'goog.i18n.CompactNumberFormatSymbols_se_NO', 'goog.i18n.CompactNumberFormatSymbols_se_SE', 'goog.i18n.CompactNumberFormatSymbols_seh', 'goog.i18n.CompactNumberFormatSymbols_seh_MZ', 'goog.i18n.CompactNumberFormatSymbols_ses', 'goog.i18n.CompactNumberFormatSymbols_ses_ML', 'goog.i18n.CompactNumberFormatSymbols_sg', 'goog.i18n.CompactNumberFormatSymbols_sg_CF', 'goog.i18n.CompactNumberFormatSymbols_shi', 'goog.i18n.CompactNumberFormatSymbols_shi_Latn', 'goog.i18n.CompactNumberFormatSymbols_shi_Latn_MA', 'goog.i18n.CompactNumberFormatSymbols_shi_Tfng', 'goog.i18n.CompactNumberFormatSymbols_shi_Tfng_MA', 'goog.i18n.CompactNumberFormatSymbols_si_LK', 'goog.i18n.CompactNumberFormatSymbols_sk_SK', 'goog.i18n.CompactNumberFormatSymbols_sl_SI', 'goog.i18n.CompactNumberFormatSymbols_smn', 'goog.i18n.CompactNumberFormatSymbols_smn_FI', 'goog.i18n.CompactNumberFormatSymbols_sn', 'goog.i18n.CompactNumberFormatSymbols_sn_ZW', 'goog.i18n.CompactNumberFormatSymbols_so', 'goog.i18n.CompactNumberFormatSymbols_so_DJ', 'goog.i18n.CompactNumberFormatSymbols_so_ET', 'goog.i18n.CompactNumberFormatSymbols_so_KE', 'goog.i18n.CompactNumberFormatSymbols_so_SO', 'goog.i18n.CompactNumberFormatSymbols_sq_AL', 'goog.i18n.CompactNumberFormatSymbols_sq_MK', 'goog.i18n.CompactNumberFormatSymbols_sq_XK', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl_BA', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl_ME', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl_RS', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl_XK', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn_BA', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn_ME', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn_RS', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn_XK', 'goog.i18n.CompactNumberFormatSymbols_sv_AX', 'goog.i18n.CompactNumberFormatSymbols_sv_FI', 'goog.i18n.CompactNumberFormatSymbols_sv_SE', 'goog.i18n.CompactNumberFormatSymbols_sw_CD', 'goog.i18n.CompactNumberFormatSymbols_sw_KE', 'goog.i18n.CompactNumberFormatSymbols_sw_TZ', 'goog.i18n.CompactNumberFormatSymbols_sw_UG', 'goog.i18n.CompactNumberFormatSymbols_ta_IN', 'goog.i18n.CompactNumberFormatSymbols_ta_LK', 'goog.i18n.CompactNumberFormatSymbols_ta_MY', 'goog.i18n.CompactNumberFormatSymbols_ta_SG', 'goog.i18n.CompactNumberFormatSymbols_te_IN', 'goog.i18n.CompactNumberFormatSymbols_teo', 'goog.i18n.CompactNumberFormatSymbols_teo_KE', 'goog.i18n.CompactNumberFormatSymbols_teo_UG', 'goog.i18n.CompactNumberFormatSymbols_tg', 'goog.i18n.CompactNumberFormatSymbols_tg_TJ', 'goog.i18n.CompactNumberFormatSymbols_th_TH', 'goog.i18n.CompactNumberFormatSymbols_ti', 'goog.i18n.CompactNumberFormatSymbols_ti_ER', 'goog.i18n.CompactNumberFormatSymbols_ti_ET', 'goog.i18n.CompactNumberFormatSymbols_tk', 'goog.i18n.CompactNumberFormatSymbols_tk_TM', 'goog.i18n.CompactNumberFormatSymbols_to', 'goog.i18n.CompactNumberFormatSymbols_to_TO', 'goog.i18n.CompactNumberFormatSymbols_tr_CY', 'goog.i18n.CompactNumberFormatSymbols_tr_TR', 'goog.i18n.CompactNumberFormatSymbols_tt', 'goog.i18n.CompactNumberFormatSymbols_tt_RU', 'goog.i18n.CompactNumberFormatSymbols_twq', 'goog.i18n.CompactNumberFormatSymbols_twq_NE', 'goog.i18n.CompactNumberFormatSymbols_tzm', 'goog.i18n.CompactNumberFormatSymbols_tzm_MA', 'goog.i18n.CompactNumberFormatSymbols_ug', 'goog.i18n.CompactNumberFormatSymbols_ug_CN', 'goog.i18n.CompactNumberFormatSymbols_uk_UA', 'goog.i18n.CompactNumberFormatSymbols_ur_IN', 'goog.i18n.CompactNumberFormatSymbols_ur_PK', 'goog.i18n.CompactNumberFormatSymbols_uz_Arab', 'goog.i18n.CompactNumberFormatSymbols_uz_Arab_AF', 'goog.i18n.CompactNumberFormatSymbols_uz_Cyrl', 'goog.i18n.CompactNumberFormatSymbols_uz_Cyrl_UZ', 'goog.i18n.CompactNumberFormatSymbols_uz_Latn', 'goog.i18n.CompactNumberFormatSymbols_uz_Latn_UZ', 'goog.i18n.CompactNumberFormatSymbols_vai', 'goog.i18n.CompactNumberFormatSymbols_vai_Latn', 'goog.i18n.CompactNumberFormatSymbols_vai_Latn_LR', 'goog.i18n.CompactNumberFormatSymbols_vai_Vaii', 'goog.i18n.CompactNumberFormatSymbols_vai_Vaii_LR', 'goog.i18n.CompactNumberFormatSymbols_vi_VN', 'goog.i18n.CompactNumberFormatSymbols_vun', 'goog.i18n.CompactNumberFormatSymbols_vun_TZ', 'goog.i18n.CompactNumberFormatSymbols_wae', 'goog.i18n.CompactNumberFormatSymbols_wae_CH', 'goog.i18n.CompactNumberFormatSymbols_wo', 'goog.i18n.CompactNumberFormatSymbols_wo_SN', 'goog.i18n.CompactNumberFormatSymbols_xh', 'goog.i18n.CompactNumberFormatSymbols_xh_ZA', 'goog.i18n.CompactNumberFormatSymbols_xog', 'goog.i18n.CompactNumberFormatSymbols_xog_UG', 'goog.i18n.CompactNumberFormatSymbols_yav', 'goog.i18n.CompactNumberFormatSymbols_yav_CM', 'goog.i18n.CompactNumberFormatSymbols_yi', 'goog.i18n.CompactNumberFormatSymbols_yi_001', 'goog.i18n.CompactNumberFormatSymbols_yo', 'goog.i18n.CompactNumberFormatSymbols_yo_BJ', 'goog.i18n.CompactNumberFormatSymbols_yo_NG', 'goog.i18n.CompactNumberFormatSymbols_yue', 'goog.i18n.CompactNumberFormatSymbols_yue_Hans', 'goog.i18n.CompactNumberFormatSymbols_yue_Hans_CN', 'goog.i18n.CompactNumberFormatSymbols_yue_Hant', 'goog.i18n.CompactNumberFormatSymbols_yue_Hant_HK', 'goog.i18n.CompactNumberFormatSymbols_zgh', 'goog.i18n.CompactNumberFormatSymbols_zgh_MA', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans_CN', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans_HK', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans_MO', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans_SG', 'goog.i18n.CompactNumberFormatSymbols_zh_Hant', 'goog.i18n.CompactNumberFormatSymbols_zh_Hant_HK', 'goog.i18n.CompactNumberFormatSymbols_zh_Hant_MO', 'goog.i18n.CompactNumberFormatSymbols_zh_Hant_TW', 'goog.i18n.CompactNumberFormatSymbols_zu_ZA'], ['goog.i18n.CompactNumberFormatSymbols'], {});
goog.addDependency('i18n/currency.js', ['goog.i18n.currency', 'goog.i18n.currency.CurrencyInfo', 'goog.i18n.currency.CurrencyInfoTier2'], [], {'lang': 'es6'});
goog.addDependency('i18n/currency_test.js', ['goog.i18n.currencyTest'], ['goog.i18n.NumberFormat', 'goog.i18n.currency', 'goog.i18n.currency.CurrencyInfo', 'goog.object', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/currencycodemap.js', ['goog.i18n.currencyCodeMap', 'goog.i18n.currencyCodeMapTier2'], [], {});
goog.addDependency('i18n/dateintervalformat.js', ['goog.i18n.DateIntervalFormat'], ['goog.array', 'goog.asserts', 'goog.date.DateLike', 'goog.date.DateRange', 'goog.date.DateTime', 'goog.date.Interval', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbolsType', 'goog.i18n.TimeZone', 'goog.i18n.dateIntervalSymbols', 'goog.object'], {'lang': 'es5', 'module': 'goog'});
goog.addDependency('i18n/dateintervalformat_test.js', ['goog.i18n.DateIntervalFormatTest'], ['goog.date.Date', 'goog.date.DateRange', 'goog.date.DateTime', 'goog.date.Interval', 'goog.i18n.DateIntervalFormat', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeSymbols_ar_EG', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_fr_CA', 'goog.i18n.DateTimeSymbols_gl', 'goog.i18n.DateTimeSymbols_hi', 'goog.i18n.DateTimeSymbols_zh', 'goog.i18n.TimeZone', 'goog.i18n.dateIntervalPatterns', 'goog.i18n.dateIntervalSymbols', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/dateintervalpatterns.js', ['goog.i18n.dateIntervalPatterns'], ['goog.i18n.dateIntervalSymbols'], {'module': 'goog'});
goog.addDependency('i18n/dateintervalpatternsext.js', ['goog.i18n.dateIntervalPatternsExt'], ['goog.i18n.dateIntervalPatterns'], {'module': 'goog'});
goog.addDependency('i18n/dateintervalsymbols.js', ['goog.i18n.dateIntervalSymbols'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/dateintervalsymbolsext.js', ['goog.i18n.dateIntervalSymbolsExt'], ['goog.i18n.dateIntervalSymbols'], {'module': 'goog'});
goog.addDependency('i18n/datetimeformat.js', ['goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeFormat.Format'], ['goog.asserts', 'goog.date', 'goog.i18n.DateTimeSymbols', 'goog.i18n.TimeZone', 'goog.string'], {});
goog.addDependency('i18n/datetimeformat_test.js', ['goog.i18n.DateTimeFormatTest'], ['goog.date.Date', 'goog.date.DateTime', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimePatterns', 'goog.i18n.DateTimePatterns_ar_EG', 'goog.i18n.DateTimePatterns_bg', 'goog.i18n.DateTimePatterns_de', 'goog.i18n.DateTimePatterns_en', 'goog.i18n.DateTimePatterns_en_XA', 'goog.i18n.DateTimePatterns_fa', 'goog.i18n.DateTimePatterns_fr', 'goog.i18n.DateTimePatterns_ja', 'goog.i18n.DateTimePatterns_sv', 'goog.i18n.DateTimePatterns_zh_HK', 'goog.i18n.DateTimePatterns_zh_Hant_TW', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbols_ar_AE', 'goog.i18n.DateTimeSymbols_ar_EG', 'goog.i18n.DateTimeSymbols_ar_SA', 'goog.i18n.DateTimeSymbols_bn_BD', 'goog.i18n.DateTimeSymbols_de', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_en_GB', 'goog.i18n.DateTimeSymbols_en_IE', 'goog.i18n.DateTimeSymbols_en_IN', 'goog.i18n.DateTimeSymbols_en_US', 'goog.i18n.DateTimeSymbols_fa', 'goog.i18n.DateTimeSymbols_fr', 'goog.i18n.DateTimeSymbols_fr_DJ', 'goog.i18n.DateTimeSymbols_he_IL', 'goog.i18n.DateTimeSymbols_ja', 'goog.i18n.DateTimeSymbols_ro_RO', 'goog.i18n.DateTimeSymbols_sv', 'goog.i18n.TimeZone', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/datetimeparse.js', ['goog.i18n.DateTimeParse'], ['goog.asserts', 'goog.date', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeSymbols'], {});
goog.addDependency('i18n/datetimeparse_test.js', ['goog.i18n.DateTimeParseTest'], ['goog.date.Date', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeParse', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_fa', 'goog.i18n.DateTimeSymbols_fr', 'goog.i18n.DateTimeSymbols_pl', 'goog.i18n.DateTimeSymbols_zh', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/datetimepatterns.js', ['goog.i18n.DateTimePatterns', 'goog.i18n.DateTimePatterns_af', 'goog.i18n.DateTimePatterns_am', 'goog.i18n.DateTimePatterns_ar', 'goog.i18n.DateTimePatterns_ar_DZ', 'goog.i18n.DateTimePatterns_ar_EG', 'goog.i18n.DateTimePatterns_az', 'goog.i18n.DateTimePatterns_be', 'goog.i18n.DateTimePatterns_bg', 'goog.i18n.DateTimePatterns_bn', 'goog.i18n.DateTimePatterns_br', 'goog.i18n.DateTimePatterns_bs', 'goog.i18n.DateTimePatterns_ca', 'goog.i18n.DateTimePatterns_chr', 'goog.i18n.DateTimePatterns_cs', 'goog.i18n.DateTimePatterns_cy', 'goog.i18n.DateTimePatterns_da', 'goog.i18n.DateTimePatterns_de', 'goog.i18n.DateTimePatterns_de_AT', 'goog.i18n.DateTimePatterns_de_CH', 'goog.i18n.DateTimePatterns_el', 'goog.i18n.DateTimePatterns_en', 'goog.i18n.DateTimePatterns_en_AU', 'goog.i18n.DateTimePatterns_en_CA', 'goog.i18n.DateTimePatterns_en_GB', 'goog.i18n.DateTimePatterns_en_IE', 'goog.i18n.DateTimePatterns_en_IN', 'goog.i18n.DateTimePatterns_en_SG', 'goog.i18n.DateTimePatterns_en_US', 'goog.i18n.DateTimePatterns_en_ZA', 'goog.i18n.DateTimePatterns_es', 'goog.i18n.DateTimePatterns_es_419', 'goog.i18n.DateTimePatterns_es_ES', 'goog.i18n.DateTimePatterns_es_MX', 'goog.i18n.DateTimePatterns_es_US', 'goog.i18n.DateTimePatterns_et', 'goog.i18n.DateTimePatterns_eu', 'goog.i18n.DateTimePatterns_fa', 'goog.i18n.DateTimePatterns_fi', 'goog.i18n.DateTimePatterns_fil', 'goog.i18n.DateTimePatterns_fr', 'goog.i18n.DateTimePatterns_fr_CA', 'goog.i18n.DateTimePatterns_ga', 'goog.i18n.DateTimePatterns_gl', 'goog.i18n.DateTimePatterns_gsw', 'goog.i18n.DateTimePatterns_gu', 'goog.i18n.DateTimePatterns_haw', 'goog.i18n.DateTimePatterns_he', 'goog.i18n.DateTimePatterns_hi', 'goog.i18n.DateTimePatterns_hr', 'goog.i18n.DateTimePatterns_hu', 'goog.i18n.DateTimePatterns_hy', 'goog.i18n.DateTimePatterns_id', 'goog.i18n.DateTimePatterns_in', 'goog.i18n.DateTimePatterns_is', 'goog.i18n.DateTimePatterns_it', 'goog.i18n.DateTimePatterns_iw', 'goog.i18n.DateTimePatterns_ja', 'goog.i18n.DateTimePatterns_ka', 'goog.i18n.DateTimePatterns_kk', 'goog.i18n.DateTimePatterns_km', 'goog.i18n.DateTimePatterns_kn', 'goog.i18n.DateTimePatterns_ko', 'goog.i18n.DateTimePatterns_ky', 'goog.i18n.DateTimePatterns_ln', 'goog.i18n.DateTimePatterns_lo', 'goog.i18n.DateTimePatterns_lt', 'goog.i18n.DateTimePatterns_lv', 'goog.i18n.DateTimePatterns_mk', 'goog.i18n.DateTimePatterns_ml', 'goog.i18n.DateTimePatterns_mn', 'goog.i18n.DateTimePatterns_mo', 'goog.i18n.DateTimePatterns_mr', 'goog.i18n.DateTimePatterns_ms', 'goog.i18n.DateTimePatterns_mt', 'goog.i18n.DateTimePatterns_my', 'goog.i18n.DateTimePatterns_nb', 'goog.i18n.DateTimePatterns_ne', 'goog.i18n.DateTimePatterns_nl', 'goog.i18n.DateTimePatterns_no', 'goog.i18n.DateTimePatterns_no_NO', 'goog.i18n.DateTimePatterns_or', 'goog.i18n.DateTimePatterns_pa', 'goog.i18n.DateTimePatterns_pl', 'goog.i18n.DateTimePatterns_pt', 'goog.i18n.DateTimePatterns_pt_BR', 'goog.i18n.DateTimePatterns_pt_PT', 'goog.i18n.DateTimePatterns_ro', 'goog.i18n.DateTimePatterns_ru', 'goog.i18n.DateTimePatterns_sh', 'goog.i18n.DateTimePatterns_si', 'goog.i18n.DateTimePatterns_sk', 'goog.i18n.DateTimePatterns_sl', 'goog.i18n.DateTimePatterns_sq', 'goog.i18n.DateTimePatterns_sr', 'goog.i18n.DateTimePatterns_sr_Latn', 'goog.i18n.DateTimePatterns_sv', 'goog.i18n.DateTimePatterns_sw', 'goog.i18n.DateTimePatterns_ta', 'goog.i18n.DateTimePatterns_te', 'goog.i18n.DateTimePatterns_th', 'goog.i18n.DateTimePatterns_tl', 'goog.i18n.DateTimePatterns_tr', 'goog.i18n.DateTimePatterns_uk', 'goog.i18n.DateTimePatterns_ur', 'goog.i18n.DateTimePatterns_uz', 'goog.i18n.DateTimePatterns_vi', 'goog.i18n.DateTimePatterns_zh', 'goog.i18n.DateTimePatterns_zh_CN', 'goog.i18n.DateTimePatterns_zh_HK', 'goog.i18n.DateTimePatterns_zh_TW', 'goog.i18n.DateTimePatterns_zu'], [], {});
goog.addDependency('i18n/datetimepatternsext.js', ['goog.i18n.DateTimePatternsExt', 'goog.i18n.DateTimePatterns_af_NA', 'goog.i18n.DateTimePatterns_af_ZA', 'goog.i18n.DateTimePatterns_agq', 'goog.i18n.DateTimePatterns_agq_CM', 'goog.i18n.DateTimePatterns_ak', 'goog.i18n.DateTimePatterns_ak_GH', 'goog.i18n.DateTimePatterns_am_ET', 'goog.i18n.DateTimePatterns_ar_001', 'goog.i18n.DateTimePatterns_ar_AE', 'goog.i18n.DateTimePatterns_ar_BH', 'goog.i18n.DateTimePatterns_ar_DJ', 'goog.i18n.DateTimePatterns_ar_EH', 'goog.i18n.DateTimePatterns_ar_ER', 'goog.i18n.DateTimePatterns_ar_IL', 'goog.i18n.DateTimePatterns_ar_IQ', 'goog.i18n.DateTimePatterns_ar_JO', 'goog.i18n.DateTimePatterns_ar_KM', 'goog.i18n.DateTimePatterns_ar_KW', 'goog.i18n.DateTimePatterns_ar_LB', 'goog.i18n.DateTimePatterns_ar_LY', 'goog.i18n.DateTimePatterns_ar_MA', 'goog.i18n.DateTimePatterns_ar_MR', 'goog.i18n.DateTimePatterns_ar_OM', 'goog.i18n.DateTimePatterns_ar_PS', 'goog.i18n.DateTimePatterns_ar_QA', 'goog.i18n.DateTimePatterns_ar_SA', 'goog.i18n.DateTimePatterns_ar_SD', 'goog.i18n.DateTimePatterns_ar_SO', 'goog.i18n.DateTimePatterns_ar_SS', 'goog.i18n.DateTimePatterns_ar_SY', 'goog.i18n.DateTimePatterns_ar_TD', 'goog.i18n.DateTimePatterns_ar_TN', 'goog.i18n.DateTimePatterns_ar_XB', 'goog.i18n.DateTimePatterns_ar_YE', 'goog.i18n.DateTimePatterns_as', 'goog.i18n.DateTimePatterns_as_IN', 'goog.i18n.DateTimePatterns_asa', 'goog.i18n.DateTimePatterns_asa_TZ', 'goog.i18n.DateTimePatterns_ast', 'goog.i18n.DateTimePatterns_ast_ES', 'goog.i18n.DateTimePatterns_az_Cyrl', 'goog.i18n.DateTimePatterns_az_Cyrl_AZ', 'goog.i18n.DateTimePatterns_az_Latn', 'goog.i18n.DateTimePatterns_az_Latn_AZ', 'goog.i18n.DateTimePatterns_bas', 'goog.i18n.DateTimePatterns_bas_CM', 'goog.i18n.DateTimePatterns_be_BY', 'goog.i18n.DateTimePatterns_bem', 'goog.i18n.DateTimePatterns_bem_ZM', 'goog.i18n.DateTimePatterns_bez', 'goog.i18n.DateTimePatterns_bez_TZ', 'goog.i18n.DateTimePatterns_bg_BG', 'goog.i18n.DateTimePatterns_bm', 'goog.i18n.DateTimePatterns_bm_ML', 'goog.i18n.DateTimePatterns_bn_BD', 'goog.i18n.DateTimePatterns_bn_IN', 'goog.i18n.DateTimePatterns_bo', 'goog.i18n.DateTimePatterns_bo_CN', 'goog.i18n.DateTimePatterns_bo_IN', 'goog.i18n.DateTimePatterns_br_FR', 'goog.i18n.DateTimePatterns_brx', 'goog.i18n.DateTimePatterns_brx_IN', 'goog.i18n.DateTimePatterns_bs_Cyrl', 'goog.i18n.DateTimePatterns_bs_Cyrl_BA', 'goog.i18n.DateTimePatterns_bs_Latn', 'goog.i18n.DateTimePatterns_bs_Latn_BA', 'goog.i18n.DateTimePatterns_ca_AD', 'goog.i18n.DateTimePatterns_ca_ES', 'goog.i18n.DateTimePatterns_ca_FR', 'goog.i18n.DateTimePatterns_ca_IT', 'goog.i18n.DateTimePatterns_ccp', 'goog.i18n.DateTimePatterns_ccp_BD', 'goog.i18n.DateTimePatterns_ccp_IN', 'goog.i18n.DateTimePatterns_ce', 'goog.i18n.DateTimePatterns_ce_RU', 'goog.i18n.DateTimePatterns_ceb', 'goog.i18n.DateTimePatterns_ceb_PH', 'goog.i18n.DateTimePatterns_cgg', 'goog.i18n.DateTimePatterns_cgg_UG', 'goog.i18n.DateTimePatterns_chr_US', 'goog.i18n.DateTimePatterns_ckb', 'goog.i18n.DateTimePatterns_ckb_IQ', 'goog.i18n.DateTimePatterns_ckb_IR', 'goog.i18n.DateTimePatterns_cs_CZ', 'goog.i18n.DateTimePatterns_cy_GB', 'goog.i18n.DateTimePatterns_da_DK', 'goog.i18n.DateTimePatterns_da_GL', 'goog.i18n.DateTimePatterns_dav', 'goog.i18n.DateTimePatterns_dav_KE', 'goog.i18n.DateTimePatterns_de_BE', 'goog.i18n.DateTimePatterns_de_DE', 'goog.i18n.DateTimePatterns_de_IT', 'goog.i18n.DateTimePatterns_de_LI', 'goog.i18n.DateTimePatterns_de_LU', 'goog.i18n.DateTimePatterns_dje', 'goog.i18n.DateTimePatterns_dje_NE', 'goog.i18n.DateTimePatterns_dsb', 'goog.i18n.DateTimePatterns_dsb_DE', 'goog.i18n.DateTimePatterns_dua', 'goog.i18n.DateTimePatterns_dua_CM', 'goog.i18n.DateTimePatterns_dyo', 'goog.i18n.DateTimePatterns_dyo_SN', 'goog.i18n.DateTimePatterns_dz', 'goog.i18n.DateTimePatterns_dz_BT', 'goog.i18n.DateTimePatterns_ebu', 'goog.i18n.DateTimePatterns_ebu_KE', 'goog.i18n.DateTimePatterns_ee', 'goog.i18n.DateTimePatterns_ee_GH', 'goog.i18n.DateTimePatterns_ee_TG', 'goog.i18n.DateTimePatterns_el_CY', 'goog.i18n.DateTimePatterns_el_GR', 'goog.i18n.DateTimePatterns_en_001', 'goog.i18n.DateTimePatterns_en_150', 'goog.i18n.DateTimePatterns_en_AE', 'goog.i18n.DateTimePatterns_en_AG', 'goog.i18n.DateTimePatterns_en_AI', 'goog.i18n.DateTimePatterns_en_AS', 'goog.i18n.DateTimePatterns_en_AT', 'goog.i18n.DateTimePatterns_en_BB', 'goog.i18n.DateTimePatterns_en_BE', 'goog.i18n.DateTimePatterns_en_BI', 'goog.i18n.DateTimePatterns_en_BM', 'goog.i18n.DateTimePatterns_en_BS', 'goog.i18n.DateTimePatterns_en_BW', 'goog.i18n.DateTimePatterns_en_BZ', 'goog.i18n.DateTimePatterns_en_CC', 'goog.i18n.DateTimePatterns_en_CH', 'goog.i18n.DateTimePatterns_en_CK', 'goog.i18n.DateTimePatterns_en_CM', 'goog.i18n.DateTimePatterns_en_CX', 'goog.i18n.DateTimePatterns_en_CY', 'goog.i18n.DateTimePatterns_en_DE', 'goog.i18n.DateTimePatterns_en_DG', 'goog.i18n.DateTimePatterns_en_DK', 'goog.i18n.DateTimePatterns_en_DM', 'goog.i18n.DateTimePatterns_en_ER', 'goog.i18n.DateTimePatterns_en_FI', 'goog.i18n.DateTimePatterns_en_FJ', 'goog.i18n.DateTimePatterns_en_FK', 'goog.i18n.DateTimePatterns_en_FM', 'goog.i18n.DateTimePatterns_en_GD', 'goog.i18n.DateTimePatterns_en_GG', 'goog.i18n.DateTimePatterns_en_GH', 'goog.i18n.DateTimePatterns_en_GI', 'goog.i18n.DateTimePatterns_en_GM', 'goog.i18n.DateTimePatterns_en_GU', 'goog.i18n.DateTimePatterns_en_GY', 'goog.i18n.DateTimePatterns_en_HK', 'goog.i18n.DateTimePatterns_en_IL', 'goog.i18n.DateTimePatterns_en_IM', 'goog.i18n.DateTimePatterns_en_IO', 'goog.i18n.DateTimePatterns_en_JE', 'goog.i18n.DateTimePatterns_en_JM', 'goog.i18n.DateTimePatterns_en_KE', 'goog.i18n.DateTimePatterns_en_KI', 'goog.i18n.DateTimePatterns_en_KN', 'goog.i18n.DateTimePatterns_en_KY', 'goog.i18n.DateTimePatterns_en_LC', 'goog.i18n.DateTimePatterns_en_LR', 'goog.i18n.DateTimePatterns_en_LS', 'goog.i18n.DateTimePatterns_en_MG', 'goog.i18n.DateTimePatterns_en_MH', 'goog.i18n.DateTimePatterns_en_MO', 'goog.i18n.DateTimePatterns_en_MP', 'goog.i18n.DateTimePatterns_en_MS', 'goog.i18n.DateTimePatterns_en_MT', 'goog.i18n.DateTimePatterns_en_MU', 'goog.i18n.DateTimePatterns_en_MW', 'goog.i18n.DateTimePatterns_en_MY', 'goog.i18n.DateTimePatterns_en_NA', 'goog.i18n.DateTimePatterns_en_NF', 'goog.i18n.DateTimePatterns_en_NG', 'goog.i18n.DateTimePatterns_en_NL', 'goog.i18n.DateTimePatterns_en_NR', 'goog.i18n.DateTimePatterns_en_NU', 'goog.i18n.DateTimePatterns_en_NZ', 'goog.i18n.DateTimePatterns_en_PG', 'goog.i18n.DateTimePatterns_en_PH', 'goog.i18n.DateTimePatterns_en_PK', 'goog.i18n.DateTimePatterns_en_PN', 'goog.i18n.DateTimePatterns_en_PR', 'goog.i18n.DateTimePatterns_en_PW', 'goog.i18n.DateTimePatterns_en_RW', 'goog.i18n.DateTimePatterns_en_SB', 'goog.i18n.DateTimePatterns_en_SC', 'goog.i18n.DateTimePatterns_en_SD', 'goog.i18n.DateTimePatterns_en_SE', 'goog.i18n.DateTimePatterns_en_SH', 'goog.i18n.DateTimePatterns_en_SI', 'goog.i18n.DateTimePatterns_en_SL', 'goog.i18n.DateTimePatterns_en_SS', 'goog.i18n.DateTimePatterns_en_SX', 'goog.i18n.DateTimePatterns_en_SZ', 'goog.i18n.DateTimePatterns_en_TC', 'goog.i18n.DateTimePatterns_en_TK', 'goog.i18n.DateTimePatterns_en_TO', 'goog.i18n.DateTimePatterns_en_TT', 'goog.i18n.DateTimePatterns_en_TV', 'goog.i18n.DateTimePatterns_en_TZ', 'goog.i18n.DateTimePatterns_en_UG', 'goog.i18n.DateTimePatterns_en_UM', 'goog.i18n.DateTimePatterns_en_US_POSIX', 'goog.i18n.DateTimePatterns_en_VC', 'goog.i18n.DateTimePatterns_en_VG', 'goog.i18n.DateTimePatterns_en_VI', 'goog.i18n.DateTimePatterns_en_VU', 'goog.i18n.DateTimePatterns_en_WS', 'goog.i18n.DateTimePatterns_en_XA', 'goog.i18n.DateTimePatterns_en_ZM', 'goog.i18n.DateTimePatterns_en_ZW', 'goog.i18n.DateTimePatterns_eo', 'goog.i18n.DateTimePatterns_eo_001', 'goog.i18n.DateTimePatterns_es_AR', 'goog.i18n.DateTimePatterns_es_BO', 'goog.i18n.DateTimePatterns_es_BR', 'goog.i18n.DateTimePatterns_es_BZ', 'goog.i18n.DateTimePatterns_es_CL', 'goog.i18n.DateTimePatterns_es_CO', 'goog.i18n.DateTimePatterns_es_CR', 'goog.i18n.DateTimePatterns_es_CU', 'goog.i18n.DateTimePatterns_es_DO', 'goog.i18n.DateTimePatterns_es_EA', 'goog.i18n.DateTimePatterns_es_EC', 'goog.i18n.DateTimePatterns_es_GQ', 'goog.i18n.DateTimePatterns_es_GT', 'goog.i18n.DateTimePatterns_es_HN', 'goog.i18n.DateTimePatterns_es_IC', 'goog.i18n.DateTimePatterns_es_NI', 'goog.i18n.DateTimePatterns_es_PA', 'goog.i18n.DateTimePatterns_es_PE', 'goog.i18n.DateTimePatterns_es_PH', 'goog.i18n.DateTimePatterns_es_PR', 'goog.i18n.DateTimePatterns_es_PY', 'goog.i18n.DateTimePatterns_es_SV', 'goog.i18n.DateTimePatterns_es_UY', 'goog.i18n.DateTimePatterns_es_VE', 'goog.i18n.DateTimePatterns_et_EE', 'goog.i18n.DateTimePatterns_eu_ES', 'goog.i18n.DateTimePatterns_ewo', 'goog.i18n.DateTimePatterns_ewo_CM', 'goog.i18n.DateTimePatterns_fa_AF', 'goog.i18n.DateTimePatterns_fa_IR', 'goog.i18n.DateTimePatterns_ff', 'goog.i18n.DateTimePatterns_ff_Latn', 'goog.i18n.DateTimePatterns_ff_Latn_BF', 'goog.i18n.DateTimePatterns_ff_Latn_CM', 'goog.i18n.DateTimePatterns_ff_Latn_GH', 'goog.i18n.DateTimePatterns_ff_Latn_GM', 'goog.i18n.DateTimePatterns_ff_Latn_GN', 'goog.i18n.DateTimePatterns_ff_Latn_GW', 'goog.i18n.DateTimePatterns_ff_Latn_LR', 'goog.i18n.DateTimePatterns_ff_Latn_MR', 'goog.i18n.DateTimePatterns_ff_Latn_NE', 'goog.i18n.DateTimePatterns_ff_Latn_NG', 'goog.i18n.DateTimePatterns_ff_Latn_SL', 'goog.i18n.DateTimePatterns_ff_Latn_SN', 'goog.i18n.DateTimePatterns_fi_FI', 'goog.i18n.DateTimePatterns_fil_PH', 'goog.i18n.DateTimePatterns_fo', 'goog.i18n.DateTimePatterns_fo_DK', 'goog.i18n.DateTimePatterns_fo_FO', 'goog.i18n.DateTimePatterns_fr_BE', 'goog.i18n.DateTimePatterns_fr_BF', 'goog.i18n.DateTimePatterns_fr_BI', 'goog.i18n.DateTimePatterns_fr_BJ', 'goog.i18n.DateTimePatterns_fr_BL', 'goog.i18n.DateTimePatterns_fr_CD', 'goog.i18n.DateTimePatterns_fr_CF', 'goog.i18n.DateTimePatterns_fr_CG', 'goog.i18n.DateTimePatterns_fr_CH', 'goog.i18n.DateTimePatterns_fr_CI', 'goog.i18n.DateTimePatterns_fr_CM', 'goog.i18n.DateTimePatterns_fr_DJ', 'goog.i18n.DateTimePatterns_fr_DZ', 'goog.i18n.DateTimePatterns_fr_FR', 'goog.i18n.DateTimePatterns_fr_GA', 'goog.i18n.DateTimePatterns_fr_GF', 'goog.i18n.DateTimePatterns_fr_GN', 'goog.i18n.DateTimePatterns_fr_GP', 'goog.i18n.DateTimePatterns_fr_GQ', 'goog.i18n.DateTimePatterns_fr_HT', 'goog.i18n.DateTimePatterns_fr_KM', 'goog.i18n.DateTimePatterns_fr_LU', 'goog.i18n.DateTimePatterns_fr_MA', 'goog.i18n.DateTimePatterns_fr_MC', 'goog.i18n.DateTimePatterns_fr_MF', 'goog.i18n.DateTimePatterns_fr_MG', 'goog.i18n.DateTimePatterns_fr_ML', 'goog.i18n.DateTimePatterns_fr_MQ', 'goog.i18n.DateTimePatterns_fr_MR', 'goog.i18n.DateTimePatterns_fr_MU', 'goog.i18n.DateTimePatterns_fr_NC', 'goog.i18n.DateTimePatterns_fr_NE', 'goog.i18n.DateTimePatterns_fr_PF', 'goog.i18n.DateTimePatterns_fr_PM', 'goog.i18n.DateTimePatterns_fr_RE', 'goog.i18n.DateTimePatterns_fr_RW', 'goog.i18n.DateTimePatterns_fr_SC', 'goog.i18n.DateTimePatterns_fr_SN', 'goog.i18n.DateTimePatterns_fr_SY', 'goog.i18n.DateTimePatterns_fr_TD', 'goog.i18n.DateTimePatterns_fr_TG', 'goog.i18n.DateTimePatterns_fr_TN', 'goog.i18n.DateTimePatterns_fr_VU', 'goog.i18n.DateTimePatterns_fr_WF', 'goog.i18n.DateTimePatterns_fr_YT', 'goog.i18n.DateTimePatterns_fur', 'goog.i18n.DateTimePatterns_fur_IT', 'goog.i18n.DateTimePatterns_fy', 'goog.i18n.DateTimePatterns_fy_NL', 'goog.i18n.DateTimePatterns_ga_IE', 'goog.i18n.DateTimePatterns_gd', 'goog.i18n.DateTimePatterns_gd_GB', 'goog.i18n.DateTimePatterns_gl_ES', 'goog.i18n.DateTimePatterns_gsw_CH', 'goog.i18n.DateTimePatterns_gsw_FR', 'goog.i18n.DateTimePatterns_gsw_LI', 'goog.i18n.DateTimePatterns_gu_IN', 'goog.i18n.DateTimePatterns_guz', 'goog.i18n.DateTimePatterns_guz_KE', 'goog.i18n.DateTimePatterns_gv', 'goog.i18n.DateTimePatterns_gv_IM', 'goog.i18n.DateTimePatterns_ha', 'goog.i18n.DateTimePatterns_ha_GH', 'goog.i18n.DateTimePatterns_ha_NE', 'goog.i18n.DateTimePatterns_ha_NG', 'goog.i18n.DateTimePatterns_haw_US', 'goog.i18n.DateTimePatterns_he_IL', 'goog.i18n.DateTimePatterns_hi_IN', 'goog.i18n.DateTimePatterns_hr_BA', 'goog.i18n.DateTimePatterns_hr_HR', 'goog.i18n.DateTimePatterns_hsb', 'goog.i18n.DateTimePatterns_hsb_DE', 'goog.i18n.DateTimePatterns_hu_HU', 'goog.i18n.DateTimePatterns_hy_AM', 'goog.i18n.DateTimePatterns_ia', 'goog.i18n.DateTimePatterns_ia_001', 'goog.i18n.DateTimePatterns_id_ID', 'goog.i18n.DateTimePatterns_ig', 'goog.i18n.DateTimePatterns_ig_NG', 'goog.i18n.DateTimePatterns_ii', 'goog.i18n.DateTimePatterns_ii_CN', 'goog.i18n.DateTimePatterns_is_IS', 'goog.i18n.DateTimePatterns_it_CH', 'goog.i18n.DateTimePatterns_it_IT', 'goog.i18n.DateTimePatterns_it_SM', 'goog.i18n.DateTimePatterns_it_VA', 'goog.i18n.DateTimePatterns_ja_JP', 'goog.i18n.DateTimePatterns_jgo', 'goog.i18n.DateTimePatterns_jgo_CM', 'goog.i18n.DateTimePatterns_jmc', 'goog.i18n.DateTimePatterns_jmc_TZ', 'goog.i18n.DateTimePatterns_jv', 'goog.i18n.DateTimePatterns_jv_ID', 'goog.i18n.DateTimePatterns_ka_GE', 'goog.i18n.DateTimePatterns_kab', 'goog.i18n.DateTimePatterns_kab_DZ', 'goog.i18n.DateTimePatterns_kam', 'goog.i18n.DateTimePatterns_kam_KE', 'goog.i18n.DateTimePatterns_kde', 'goog.i18n.DateTimePatterns_kde_TZ', 'goog.i18n.DateTimePatterns_kea', 'goog.i18n.DateTimePatterns_kea_CV', 'goog.i18n.DateTimePatterns_khq', 'goog.i18n.DateTimePatterns_khq_ML', 'goog.i18n.DateTimePatterns_ki', 'goog.i18n.DateTimePatterns_ki_KE', 'goog.i18n.DateTimePatterns_kk_KZ', 'goog.i18n.DateTimePatterns_kkj', 'goog.i18n.DateTimePatterns_kkj_CM', 'goog.i18n.DateTimePatterns_kl', 'goog.i18n.DateTimePatterns_kl_GL', 'goog.i18n.DateTimePatterns_kln', 'goog.i18n.DateTimePatterns_kln_KE', 'goog.i18n.DateTimePatterns_km_KH', 'goog.i18n.DateTimePatterns_kn_IN', 'goog.i18n.DateTimePatterns_ko_KP', 'goog.i18n.DateTimePatterns_ko_KR', 'goog.i18n.DateTimePatterns_kok', 'goog.i18n.DateTimePatterns_kok_IN', 'goog.i18n.DateTimePatterns_ks', 'goog.i18n.DateTimePatterns_ks_IN', 'goog.i18n.DateTimePatterns_ksb', 'goog.i18n.DateTimePatterns_ksb_TZ', 'goog.i18n.DateTimePatterns_ksf', 'goog.i18n.DateTimePatterns_ksf_CM', 'goog.i18n.DateTimePatterns_ksh', 'goog.i18n.DateTimePatterns_ksh_DE', 'goog.i18n.DateTimePatterns_ku', 'goog.i18n.DateTimePatterns_ku_TR', 'goog.i18n.DateTimePatterns_kw', 'goog.i18n.DateTimePatterns_kw_GB', 'goog.i18n.DateTimePatterns_ky_KG', 'goog.i18n.DateTimePatterns_lag', 'goog.i18n.DateTimePatterns_lag_TZ', 'goog.i18n.DateTimePatterns_lb', 'goog.i18n.DateTimePatterns_lb_LU', 'goog.i18n.DateTimePatterns_lg', 'goog.i18n.DateTimePatterns_lg_UG', 'goog.i18n.DateTimePatterns_lkt', 'goog.i18n.DateTimePatterns_lkt_US', 'goog.i18n.DateTimePatterns_ln_AO', 'goog.i18n.DateTimePatterns_ln_CD', 'goog.i18n.DateTimePatterns_ln_CF', 'goog.i18n.DateTimePatterns_ln_CG', 'goog.i18n.DateTimePatterns_lo_LA', 'goog.i18n.DateTimePatterns_lrc', 'goog.i18n.DateTimePatterns_lrc_IQ', 'goog.i18n.DateTimePatterns_lrc_IR', 'goog.i18n.DateTimePatterns_lt_LT', 'goog.i18n.DateTimePatterns_lu', 'goog.i18n.DateTimePatterns_lu_CD', 'goog.i18n.DateTimePatterns_luo', 'goog.i18n.DateTimePatterns_luo_KE', 'goog.i18n.DateTimePatterns_luy', 'goog.i18n.DateTimePatterns_luy_KE', 'goog.i18n.DateTimePatterns_lv_LV', 'goog.i18n.DateTimePatterns_mas', 'goog.i18n.DateTimePatterns_mas_KE', 'goog.i18n.DateTimePatterns_mas_TZ', 'goog.i18n.DateTimePatterns_mer', 'goog.i18n.DateTimePatterns_mer_KE', 'goog.i18n.DateTimePatterns_mfe', 'goog.i18n.DateTimePatterns_mfe_MU', 'goog.i18n.DateTimePatterns_mg', 'goog.i18n.DateTimePatterns_mg_MG', 'goog.i18n.DateTimePatterns_mgh', 'goog.i18n.DateTimePatterns_mgh_MZ', 'goog.i18n.DateTimePatterns_mgo', 'goog.i18n.DateTimePatterns_mgo_CM', 'goog.i18n.DateTimePatterns_mi', 'goog.i18n.DateTimePatterns_mi_NZ', 'goog.i18n.DateTimePatterns_mk_MK', 'goog.i18n.DateTimePatterns_ml_IN', 'goog.i18n.DateTimePatterns_mn_MN', 'goog.i18n.DateTimePatterns_mr_IN', 'goog.i18n.DateTimePatterns_ms_BN', 'goog.i18n.DateTimePatterns_ms_MY', 'goog.i18n.DateTimePatterns_ms_SG', 'goog.i18n.DateTimePatterns_mt_MT', 'goog.i18n.DateTimePatterns_mua', 'goog.i18n.DateTimePatterns_mua_CM', 'goog.i18n.DateTimePatterns_my_MM', 'goog.i18n.DateTimePatterns_mzn', 'goog.i18n.DateTimePatterns_mzn_IR', 'goog.i18n.DateTimePatterns_naq', 'goog.i18n.DateTimePatterns_naq_NA', 'goog.i18n.DateTimePatterns_nb_NO', 'goog.i18n.DateTimePatterns_nb_SJ', 'goog.i18n.DateTimePatterns_nd', 'goog.i18n.DateTimePatterns_nd_ZW', 'goog.i18n.DateTimePatterns_nds', 'goog.i18n.DateTimePatterns_nds_DE', 'goog.i18n.DateTimePatterns_nds_NL', 'goog.i18n.DateTimePatterns_ne_IN', 'goog.i18n.DateTimePatterns_ne_NP', 'goog.i18n.DateTimePatterns_nl_AW', 'goog.i18n.DateTimePatterns_nl_BE', 'goog.i18n.DateTimePatterns_nl_BQ', 'goog.i18n.DateTimePatterns_nl_CW', 'goog.i18n.DateTimePatterns_nl_NL', 'goog.i18n.DateTimePatterns_nl_SR', 'goog.i18n.DateTimePatterns_nl_SX', 'goog.i18n.DateTimePatterns_nmg', 'goog.i18n.DateTimePatterns_nmg_CM', 'goog.i18n.DateTimePatterns_nn', 'goog.i18n.DateTimePatterns_nn_NO', 'goog.i18n.DateTimePatterns_nnh', 'goog.i18n.DateTimePatterns_nnh_CM', 'goog.i18n.DateTimePatterns_nus', 'goog.i18n.DateTimePatterns_nus_SS', 'goog.i18n.DateTimePatterns_nyn', 'goog.i18n.DateTimePatterns_nyn_UG', 'goog.i18n.DateTimePatterns_om', 'goog.i18n.DateTimePatterns_om_ET', 'goog.i18n.DateTimePatterns_om_KE', 'goog.i18n.DateTimePatterns_or_IN', 'goog.i18n.DateTimePatterns_os', 'goog.i18n.DateTimePatterns_os_GE', 'goog.i18n.DateTimePatterns_os_RU', 'goog.i18n.DateTimePatterns_pa_Arab', 'goog.i18n.DateTimePatterns_pa_Arab_PK', 'goog.i18n.DateTimePatterns_pa_Guru', 'goog.i18n.DateTimePatterns_pa_Guru_IN', 'goog.i18n.DateTimePatterns_pl_PL', 'goog.i18n.DateTimePatterns_ps', 'goog.i18n.DateTimePatterns_ps_AF', 'goog.i18n.DateTimePatterns_ps_PK', 'goog.i18n.DateTimePatterns_pt_AO', 'goog.i18n.DateTimePatterns_pt_CH', 'goog.i18n.DateTimePatterns_pt_CV', 'goog.i18n.DateTimePatterns_pt_GQ', 'goog.i18n.DateTimePatterns_pt_GW', 'goog.i18n.DateTimePatterns_pt_LU', 'goog.i18n.DateTimePatterns_pt_MO', 'goog.i18n.DateTimePatterns_pt_MZ', 'goog.i18n.DateTimePatterns_pt_ST', 'goog.i18n.DateTimePatterns_pt_TL', 'goog.i18n.DateTimePatterns_qu', 'goog.i18n.DateTimePatterns_qu_BO', 'goog.i18n.DateTimePatterns_qu_EC', 'goog.i18n.DateTimePatterns_qu_PE', 'goog.i18n.DateTimePatterns_rm', 'goog.i18n.DateTimePatterns_rm_CH', 'goog.i18n.DateTimePatterns_rn', 'goog.i18n.DateTimePatterns_rn_BI', 'goog.i18n.DateTimePatterns_ro_MD', 'goog.i18n.DateTimePatterns_ro_RO', 'goog.i18n.DateTimePatterns_rof', 'goog.i18n.DateTimePatterns_rof_TZ', 'goog.i18n.DateTimePatterns_ru_BY', 'goog.i18n.DateTimePatterns_ru_KG', 'goog.i18n.DateTimePatterns_ru_KZ', 'goog.i18n.DateTimePatterns_ru_MD', 'goog.i18n.DateTimePatterns_ru_RU', 'goog.i18n.DateTimePatterns_ru_UA', 'goog.i18n.DateTimePatterns_rw', 'goog.i18n.DateTimePatterns_rw_RW', 'goog.i18n.DateTimePatterns_rwk', 'goog.i18n.DateTimePatterns_rwk_TZ', 'goog.i18n.DateTimePatterns_sah', 'goog.i18n.DateTimePatterns_sah_RU', 'goog.i18n.DateTimePatterns_saq', 'goog.i18n.DateTimePatterns_saq_KE', 'goog.i18n.DateTimePatterns_sbp', 'goog.i18n.DateTimePatterns_sbp_TZ', 'goog.i18n.DateTimePatterns_sd', 'goog.i18n.DateTimePatterns_sd_PK', 'goog.i18n.DateTimePatterns_se', 'goog.i18n.DateTimePatterns_se_FI', 'goog.i18n.DateTimePatterns_se_NO', 'goog.i18n.DateTimePatterns_se_SE', 'goog.i18n.DateTimePatterns_seh', 'goog.i18n.DateTimePatterns_seh_MZ', 'goog.i18n.DateTimePatterns_ses', 'goog.i18n.DateTimePatterns_ses_ML', 'goog.i18n.DateTimePatterns_sg', 'goog.i18n.DateTimePatterns_sg_CF', 'goog.i18n.DateTimePatterns_shi', 'goog.i18n.DateTimePatterns_shi_Latn', 'goog.i18n.DateTimePatterns_shi_Latn_MA', 'goog.i18n.DateTimePatterns_shi_Tfng', 'goog.i18n.DateTimePatterns_shi_Tfng_MA', 'goog.i18n.DateTimePatterns_si_LK', 'goog.i18n.DateTimePatterns_sk_SK', 'goog.i18n.DateTimePatterns_sl_SI', 'goog.i18n.DateTimePatterns_smn', 'goog.i18n.DateTimePatterns_smn_FI', 'goog.i18n.DateTimePatterns_sn', 'goog.i18n.DateTimePatterns_sn_ZW', 'goog.i18n.DateTimePatterns_so', 'goog.i18n.DateTimePatterns_so_DJ', 'goog.i18n.DateTimePatterns_so_ET', 'goog.i18n.DateTimePatterns_so_KE', 'goog.i18n.DateTimePatterns_so_SO', 'goog.i18n.DateTimePatterns_sq_AL', 'goog.i18n.DateTimePatterns_sq_MK', 'goog.i18n.DateTimePatterns_sq_XK', 'goog.i18n.DateTimePatterns_sr_Cyrl', 'goog.i18n.DateTimePatterns_sr_Cyrl_BA', 'goog.i18n.DateTimePatterns_sr_Cyrl_ME', 'goog.i18n.DateTimePatterns_sr_Cyrl_RS', 'goog.i18n.DateTimePatterns_sr_Cyrl_XK', 'goog.i18n.DateTimePatterns_sr_Latn_BA', 'goog.i18n.DateTimePatterns_sr_Latn_ME', 'goog.i18n.DateTimePatterns_sr_Latn_RS', 'goog.i18n.DateTimePatterns_sr_Latn_XK', 'goog.i18n.DateTimePatterns_sv_AX', 'goog.i18n.DateTimePatterns_sv_FI', 'goog.i18n.DateTimePatterns_sv_SE', 'goog.i18n.DateTimePatterns_sw_CD', 'goog.i18n.DateTimePatterns_sw_KE', 'goog.i18n.DateTimePatterns_sw_TZ', 'goog.i18n.DateTimePatterns_sw_UG', 'goog.i18n.DateTimePatterns_ta_IN', 'goog.i18n.DateTimePatterns_ta_LK', 'goog.i18n.DateTimePatterns_ta_MY', 'goog.i18n.DateTimePatterns_ta_SG', 'goog.i18n.DateTimePatterns_te_IN', 'goog.i18n.DateTimePatterns_teo', 'goog.i18n.DateTimePatterns_teo_KE', 'goog.i18n.DateTimePatterns_teo_UG', 'goog.i18n.DateTimePatterns_tg', 'goog.i18n.DateTimePatterns_tg_TJ', 'goog.i18n.DateTimePatterns_th_TH', 'goog.i18n.DateTimePatterns_ti', 'goog.i18n.DateTimePatterns_ti_ER', 'goog.i18n.DateTimePatterns_ti_ET', 'goog.i18n.DateTimePatterns_tk', 'goog.i18n.DateTimePatterns_tk_TM', 'goog.i18n.DateTimePatterns_to', 'goog.i18n.DateTimePatterns_to_TO', 'goog.i18n.DateTimePatterns_tr_CY', 'goog.i18n.DateTimePatterns_tr_TR', 'goog.i18n.DateTimePatterns_tt', 'goog.i18n.DateTimePatterns_tt_RU', 'goog.i18n.DateTimePatterns_twq', 'goog.i18n.DateTimePatterns_twq_NE', 'goog.i18n.DateTimePatterns_tzm', 'goog.i18n.DateTimePatterns_tzm_MA', 'goog.i18n.DateTimePatterns_ug', 'goog.i18n.DateTimePatterns_ug_CN', 'goog.i18n.DateTimePatterns_uk_UA', 'goog.i18n.DateTimePatterns_ur_IN', 'goog.i18n.DateTimePatterns_ur_PK', 'goog.i18n.DateTimePatterns_uz_Arab', 'goog.i18n.DateTimePatterns_uz_Arab_AF', 'goog.i18n.DateTimePatterns_uz_Cyrl', 'goog.i18n.DateTimePatterns_uz_Cyrl_UZ', 'goog.i18n.DateTimePatterns_uz_Latn', 'goog.i18n.DateTimePatterns_uz_Latn_UZ', 'goog.i18n.DateTimePatterns_vai', 'goog.i18n.DateTimePatterns_vai_Latn', 'goog.i18n.DateTimePatterns_vai_Latn_LR', 'goog.i18n.DateTimePatterns_vai_Vaii', 'goog.i18n.DateTimePatterns_vai_Vaii_LR', 'goog.i18n.DateTimePatterns_vi_VN', 'goog.i18n.DateTimePatterns_vun', 'goog.i18n.DateTimePatterns_vun_TZ', 'goog.i18n.DateTimePatterns_wae', 'goog.i18n.DateTimePatterns_wae_CH', 'goog.i18n.DateTimePatterns_wo', 'goog.i18n.DateTimePatterns_wo_SN', 'goog.i18n.DateTimePatterns_xh', 'goog.i18n.DateTimePatterns_xh_ZA', 'goog.i18n.DateTimePatterns_xog', 'goog.i18n.DateTimePatterns_xog_UG', 'goog.i18n.DateTimePatterns_yav', 'goog.i18n.DateTimePatterns_yav_CM', 'goog.i18n.DateTimePatterns_yi', 'goog.i18n.DateTimePatterns_yi_001', 'goog.i18n.DateTimePatterns_yo', 'goog.i18n.DateTimePatterns_yo_BJ', 'goog.i18n.DateTimePatterns_yo_NG', 'goog.i18n.DateTimePatterns_yue', 'goog.i18n.DateTimePatterns_yue_Hans', 'goog.i18n.DateTimePatterns_yue_Hans_CN', 'goog.i18n.DateTimePatterns_yue_Hant', 'goog.i18n.DateTimePatterns_yue_Hant_HK', 'goog.i18n.DateTimePatterns_zgh', 'goog.i18n.DateTimePatterns_zgh_MA', 'goog.i18n.DateTimePatterns_zh_Hans', 'goog.i18n.DateTimePatterns_zh_Hans_CN', 'goog.i18n.DateTimePatterns_zh_Hans_HK', 'goog.i18n.DateTimePatterns_zh_Hans_MO', 'goog.i18n.DateTimePatterns_zh_Hans_SG', 'goog.i18n.DateTimePatterns_zh_Hant', 'goog.i18n.DateTimePatterns_zh_Hant_HK', 'goog.i18n.DateTimePatterns_zh_Hant_MO', 'goog.i18n.DateTimePatterns_zh_Hant_TW', 'goog.i18n.DateTimePatterns_zu_ZA'], ['goog.i18n.DateTimePatterns'], {});
goog.addDependency('i18n/datetimesymbols.js', ['goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbolsType', 'goog.i18n.DateTimeSymbols_af', 'goog.i18n.DateTimeSymbols_am', 'goog.i18n.DateTimeSymbols_ar', 'goog.i18n.DateTimeSymbols_ar_DZ', 'goog.i18n.DateTimeSymbols_ar_EG', 'goog.i18n.DateTimeSymbols_az', 'goog.i18n.DateTimeSymbols_be', 'goog.i18n.DateTimeSymbols_bg', 'goog.i18n.DateTimeSymbols_bn', 'goog.i18n.DateTimeSymbols_br', 'goog.i18n.DateTimeSymbols_bs', 'goog.i18n.DateTimeSymbols_ca', 'goog.i18n.DateTimeSymbols_chr', 'goog.i18n.DateTimeSymbols_cs', 'goog.i18n.DateTimeSymbols_cy', 'goog.i18n.DateTimeSymbols_da', 'goog.i18n.DateTimeSymbols_de', 'goog.i18n.DateTimeSymbols_de_AT', 'goog.i18n.DateTimeSymbols_de_CH', 'goog.i18n.DateTimeSymbols_el', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_en_AU', 'goog.i18n.DateTimeSymbols_en_CA', 'goog.i18n.DateTimeSymbols_en_GB', 'goog.i18n.DateTimeSymbols_en_IE', 'goog.i18n.DateTimeSymbols_en_IN', 'goog.i18n.DateTimeSymbols_en_ISO', 'goog.i18n.DateTimeSymbols_en_SG', 'goog.i18n.DateTimeSymbols_en_US', 'goog.i18n.DateTimeSymbols_en_ZA', 'goog.i18n.DateTimeSymbols_es', 'goog.i18n.DateTimeSymbols_es_419', 'goog.i18n.DateTimeSymbols_es_ES', 'goog.i18n.DateTimeSymbols_es_MX', 'goog.i18n.DateTimeSymbols_es_US', 'goog.i18n.DateTimeSymbols_et', 'goog.i18n.DateTimeSymbols_eu', 'goog.i18n.DateTimeSymbols_fa', 'goog.i18n.DateTimeSymbols_fi', 'goog.i18n.DateTimeSymbols_fil', 'goog.i18n.DateTimeSymbols_fr', 'goog.i18n.DateTimeSymbols_fr_CA', 'goog.i18n.DateTimeSymbols_ga', 'goog.i18n.DateTimeSymbols_gl', 'goog.i18n.DateTimeSymbols_gsw', 'goog.i18n.DateTimeSymbols_gu', 'goog.i18n.DateTimeSymbols_haw', 'goog.i18n.DateTimeSymbols_he', 'goog.i18n.DateTimeSymbols_hi', 'goog.i18n.DateTimeSymbols_hr', 'goog.i18n.DateTimeSymbols_hu', 'goog.i18n.DateTimeSymbols_hy', 'goog.i18n.DateTimeSymbols_id', 'goog.i18n.DateTimeSymbols_in', 'goog.i18n.DateTimeSymbols_is', 'goog.i18n.DateTimeSymbols_it', 'goog.i18n.DateTimeSymbols_iw', 'goog.i18n.DateTimeSymbols_ja', 'goog.i18n.DateTimeSymbols_ka', 'goog.i18n.DateTimeSymbols_kk', 'goog.i18n.DateTimeSymbols_km', 'goog.i18n.DateTimeSymbols_kn', 'goog.i18n.DateTimeSymbols_ko', 'goog.i18n.DateTimeSymbols_ky', 'goog.i18n.DateTimeSymbols_ln', 'goog.i18n.DateTimeSymbols_lo', 'goog.i18n.DateTimeSymbols_lt', 'goog.i18n.DateTimeSymbols_lv', 'goog.i18n.DateTimeSymbols_mk', 'goog.i18n.DateTimeSymbols_ml', 'goog.i18n.DateTimeSymbols_mn', 'goog.i18n.DateTimeSymbols_mo', 'goog.i18n.DateTimeSymbols_mr', 'goog.i18n.DateTimeSymbols_ms', 'goog.i18n.DateTimeSymbols_mt', 'goog.i18n.DateTimeSymbols_my', 'goog.i18n.DateTimeSymbols_nb', 'goog.i18n.DateTimeSymbols_ne', 'goog.i18n.DateTimeSymbols_nl', 'goog.i18n.DateTimeSymbols_no', 'goog.i18n.DateTimeSymbols_no_NO', 'goog.i18n.DateTimeSymbols_or', 'goog.i18n.DateTimeSymbols_pa', 'goog.i18n.DateTimeSymbols_pl', 'goog.i18n.DateTimeSymbols_pt', 'goog.i18n.DateTimeSymbols_pt_BR', 'goog.i18n.DateTimeSymbols_pt_PT', 'goog.i18n.DateTimeSymbols_ro', 'goog.i18n.DateTimeSymbols_ru', 'goog.i18n.DateTimeSymbols_sh', 'goog.i18n.DateTimeSymbols_si', 'goog.i18n.DateTimeSymbols_sk', 'goog.i18n.DateTimeSymbols_sl', 'goog.i18n.DateTimeSymbols_sq', 'goog.i18n.DateTimeSymbols_sr', 'goog.i18n.DateTimeSymbols_sr_Latn', 'goog.i18n.DateTimeSymbols_sv', 'goog.i18n.DateTimeSymbols_sw', 'goog.i18n.DateTimeSymbols_ta', 'goog.i18n.DateTimeSymbols_te', 'goog.i18n.DateTimeSymbols_th', 'goog.i18n.DateTimeSymbols_tl', 'goog.i18n.DateTimeSymbols_tr', 'goog.i18n.DateTimeSymbols_uk', 'goog.i18n.DateTimeSymbols_ur', 'goog.i18n.DateTimeSymbols_uz', 'goog.i18n.DateTimeSymbols_vi', 'goog.i18n.DateTimeSymbols_zh', 'goog.i18n.DateTimeSymbols_zh_CN', 'goog.i18n.DateTimeSymbols_zh_HK', 'goog.i18n.DateTimeSymbols_zh_TW', 'goog.i18n.DateTimeSymbols_zu'], [], {});
goog.addDependency('i18n/datetimesymbolsext.js', ['goog.i18n.DateTimeSymbolsExt', 'goog.i18n.DateTimeSymbols_af_NA', 'goog.i18n.DateTimeSymbols_af_ZA', 'goog.i18n.DateTimeSymbols_agq', 'goog.i18n.DateTimeSymbols_agq_CM', 'goog.i18n.DateTimeSymbols_ak', 'goog.i18n.DateTimeSymbols_ak_GH', 'goog.i18n.DateTimeSymbols_am_ET', 'goog.i18n.DateTimeSymbols_ar_001', 'goog.i18n.DateTimeSymbols_ar_AE', 'goog.i18n.DateTimeSymbols_ar_BH', 'goog.i18n.DateTimeSymbols_ar_DJ', 'goog.i18n.DateTimeSymbols_ar_EH', 'goog.i18n.DateTimeSymbols_ar_ER', 'goog.i18n.DateTimeSymbols_ar_IL', 'goog.i18n.DateTimeSymbols_ar_IQ', 'goog.i18n.DateTimeSymbols_ar_JO', 'goog.i18n.DateTimeSymbols_ar_KM', 'goog.i18n.DateTimeSymbols_ar_KW', 'goog.i18n.DateTimeSymbols_ar_LB', 'goog.i18n.DateTimeSymbols_ar_LY', 'goog.i18n.DateTimeSymbols_ar_MA', 'goog.i18n.DateTimeSymbols_ar_MR', 'goog.i18n.DateTimeSymbols_ar_OM', 'goog.i18n.DateTimeSymbols_ar_PS', 'goog.i18n.DateTimeSymbols_ar_QA', 'goog.i18n.DateTimeSymbols_ar_SA', 'goog.i18n.DateTimeSymbols_ar_SD', 'goog.i18n.DateTimeSymbols_ar_SO', 'goog.i18n.DateTimeSymbols_ar_SS', 'goog.i18n.DateTimeSymbols_ar_SY', 'goog.i18n.DateTimeSymbols_ar_TD', 'goog.i18n.DateTimeSymbols_ar_TN', 'goog.i18n.DateTimeSymbols_ar_XB', 'goog.i18n.DateTimeSymbols_ar_YE', 'goog.i18n.DateTimeSymbols_as', 'goog.i18n.DateTimeSymbols_as_IN', 'goog.i18n.DateTimeSymbols_asa', 'goog.i18n.DateTimeSymbols_asa_TZ', 'goog.i18n.DateTimeSymbols_ast', 'goog.i18n.DateTimeSymbols_ast_ES', 'goog.i18n.DateTimeSymbols_az_Cyrl', 'goog.i18n.DateTimeSymbols_az_Cyrl_AZ', 'goog.i18n.DateTimeSymbols_az_Latn', 'goog.i18n.DateTimeSymbols_az_Latn_AZ', 'goog.i18n.DateTimeSymbols_bas', 'goog.i18n.DateTimeSymbols_bas_CM', 'goog.i18n.DateTimeSymbols_be_BY', 'goog.i18n.DateTimeSymbols_bem', 'goog.i18n.DateTimeSymbols_bem_ZM', 'goog.i18n.DateTimeSymbols_bez', 'goog.i18n.DateTimeSymbols_bez_TZ', 'goog.i18n.DateTimeSymbols_bg_BG', 'goog.i18n.DateTimeSymbols_bm', 'goog.i18n.DateTimeSymbols_bm_ML', 'goog.i18n.DateTimeSymbols_bn_BD', 'goog.i18n.DateTimeSymbols_bn_IN', 'goog.i18n.DateTimeSymbols_bo', 'goog.i18n.DateTimeSymbols_bo_CN', 'goog.i18n.DateTimeSymbols_bo_IN', 'goog.i18n.DateTimeSymbols_br_FR', 'goog.i18n.DateTimeSymbols_brx', 'goog.i18n.DateTimeSymbols_brx_IN', 'goog.i18n.DateTimeSymbols_bs_Cyrl', 'goog.i18n.DateTimeSymbols_bs_Cyrl_BA', 'goog.i18n.DateTimeSymbols_bs_Latn', 'goog.i18n.DateTimeSymbols_bs_Latn_BA', 'goog.i18n.DateTimeSymbols_ca_AD', 'goog.i18n.DateTimeSymbols_ca_ES', 'goog.i18n.DateTimeSymbols_ca_FR', 'goog.i18n.DateTimeSymbols_ca_IT', 'goog.i18n.DateTimeSymbols_ccp', 'goog.i18n.DateTimeSymbols_ccp_BD', 'goog.i18n.DateTimeSymbols_ccp_IN', 'goog.i18n.DateTimeSymbols_ce', 'goog.i18n.DateTimeSymbols_ce_RU', 'goog.i18n.DateTimeSymbols_ceb', 'goog.i18n.DateTimeSymbols_ceb_PH', 'goog.i18n.DateTimeSymbols_cgg', 'goog.i18n.DateTimeSymbols_cgg_UG', 'goog.i18n.DateTimeSymbols_chr_US', 'goog.i18n.DateTimeSymbols_ckb', 'goog.i18n.DateTimeSymbols_ckb_IQ', 'goog.i18n.DateTimeSymbols_ckb_IR', 'goog.i18n.DateTimeSymbols_cs_CZ', 'goog.i18n.DateTimeSymbols_cy_GB', 'goog.i18n.DateTimeSymbols_da_DK', 'goog.i18n.DateTimeSymbols_da_GL', 'goog.i18n.DateTimeSymbols_dav', 'goog.i18n.DateTimeSymbols_dav_KE', 'goog.i18n.DateTimeSymbols_de_BE', 'goog.i18n.DateTimeSymbols_de_DE', 'goog.i18n.DateTimeSymbols_de_IT', 'goog.i18n.DateTimeSymbols_de_LI', 'goog.i18n.DateTimeSymbols_de_LU', 'goog.i18n.DateTimeSymbols_dje', 'goog.i18n.DateTimeSymbols_dje_NE', 'goog.i18n.DateTimeSymbols_dsb', 'goog.i18n.DateTimeSymbols_dsb_DE', 'goog.i18n.DateTimeSymbols_dua', 'goog.i18n.DateTimeSymbols_dua_CM', 'goog.i18n.DateTimeSymbols_dyo', 'goog.i18n.DateTimeSymbols_dyo_SN', 'goog.i18n.DateTimeSymbols_dz', 'goog.i18n.DateTimeSymbols_dz_BT', 'goog.i18n.DateTimeSymbols_ebu', 'goog.i18n.DateTimeSymbols_ebu_KE', 'goog.i18n.DateTimeSymbols_ee', 'goog.i18n.DateTimeSymbols_ee_GH', 'goog.i18n.DateTimeSymbols_ee_TG', 'goog.i18n.DateTimeSymbols_el_CY', 'goog.i18n.DateTimeSymbols_el_GR', 'goog.i18n.DateTimeSymbols_en_001', 'goog.i18n.DateTimeSymbols_en_150', 'goog.i18n.DateTimeSymbols_en_AE', 'goog.i18n.DateTimeSymbols_en_AG', 'goog.i18n.DateTimeSymbols_en_AI', 'goog.i18n.DateTimeSymbols_en_AS', 'goog.i18n.DateTimeSymbols_en_AT', 'goog.i18n.DateTimeSymbols_en_BB', 'goog.i18n.DateTimeSymbols_en_BE', 'goog.i18n.DateTimeSymbols_en_BI', 'goog.i18n.DateTimeSymbols_en_BM', 'goog.i18n.DateTimeSymbols_en_BS', 'goog.i18n.DateTimeSymbols_en_BW', 'goog.i18n.DateTimeSymbols_en_BZ', 'goog.i18n.DateTimeSymbols_en_CC', 'goog.i18n.DateTimeSymbols_en_CH', 'goog.i18n.DateTimeSymbols_en_CK', 'goog.i18n.DateTimeSymbols_en_CM', 'goog.i18n.DateTimeSymbols_en_CX', 'goog.i18n.DateTimeSymbols_en_CY', 'goog.i18n.DateTimeSymbols_en_DE', 'goog.i18n.DateTimeSymbols_en_DG', 'goog.i18n.DateTimeSymbols_en_DK', 'goog.i18n.DateTimeSymbols_en_DM', 'goog.i18n.DateTimeSymbols_en_ER', 'goog.i18n.DateTimeSymbols_en_FI', 'goog.i18n.DateTimeSymbols_en_FJ', 'goog.i18n.DateTimeSymbols_en_FK', 'goog.i18n.DateTimeSymbols_en_FM', 'goog.i18n.DateTimeSymbols_en_GD', 'goog.i18n.DateTimeSymbols_en_GG', 'goog.i18n.DateTimeSymbols_en_GH', 'goog.i18n.DateTimeSymbols_en_GI', 'goog.i18n.DateTimeSymbols_en_GM', 'goog.i18n.DateTimeSymbols_en_GU', 'goog.i18n.DateTimeSymbols_en_GY', 'goog.i18n.DateTimeSymbols_en_HK', 'goog.i18n.DateTimeSymbols_en_IL', 'goog.i18n.DateTimeSymbols_en_IM', 'goog.i18n.DateTimeSymbols_en_IO', 'goog.i18n.DateTimeSymbols_en_JE', 'goog.i18n.DateTimeSymbols_en_JM', 'goog.i18n.DateTimeSymbols_en_KE', 'goog.i18n.DateTimeSymbols_en_KI', 'goog.i18n.DateTimeSymbols_en_KN', 'goog.i18n.DateTimeSymbols_en_KY', 'goog.i18n.DateTimeSymbols_en_LC', 'goog.i18n.DateTimeSymbols_en_LR', 'goog.i18n.DateTimeSymbols_en_LS', 'goog.i18n.DateTimeSymbols_en_MG', 'goog.i18n.DateTimeSymbols_en_MH', 'goog.i18n.DateTimeSymbols_en_MO', 'goog.i18n.DateTimeSymbols_en_MP', 'goog.i18n.DateTimeSymbols_en_MS', 'goog.i18n.DateTimeSymbols_en_MT', 'goog.i18n.DateTimeSymbols_en_MU', 'goog.i18n.DateTimeSymbols_en_MW', 'goog.i18n.DateTimeSymbols_en_MY', 'goog.i18n.DateTimeSymbols_en_NA', 'goog.i18n.DateTimeSymbols_en_NF', 'goog.i18n.DateTimeSymbols_en_NG', 'goog.i18n.DateTimeSymbols_en_NL', 'goog.i18n.DateTimeSymbols_en_NR', 'goog.i18n.DateTimeSymbols_en_NU', 'goog.i18n.DateTimeSymbols_en_NZ', 'goog.i18n.DateTimeSymbols_en_PG', 'goog.i18n.DateTimeSymbols_en_PH', 'goog.i18n.DateTimeSymbols_en_PK', 'goog.i18n.DateTimeSymbols_en_PN', 'goog.i18n.DateTimeSymbols_en_PR', 'goog.i18n.DateTimeSymbols_en_PW', 'goog.i18n.DateTimeSymbols_en_RW', 'goog.i18n.DateTimeSymbols_en_SB', 'goog.i18n.DateTimeSymbols_en_SC', 'goog.i18n.DateTimeSymbols_en_SD', 'goog.i18n.DateTimeSymbols_en_SE', 'goog.i18n.DateTimeSymbols_en_SH', 'goog.i18n.DateTimeSymbols_en_SI', 'goog.i18n.DateTimeSymbols_en_SL', 'goog.i18n.DateTimeSymbols_en_SS', 'goog.i18n.DateTimeSymbols_en_SX', 'goog.i18n.DateTimeSymbols_en_SZ', 'goog.i18n.DateTimeSymbols_en_TC', 'goog.i18n.DateTimeSymbols_en_TK', 'goog.i18n.DateTimeSymbols_en_TO', 'goog.i18n.DateTimeSymbols_en_TT', 'goog.i18n.DateTimeSymbols_en_TV', 'goog.i18n.DateTimeSymbols_en_TZ', 'goog.i18n.DateTimeSymbols_en_UG', 'goog.i18n.DateTimeSymbols_en_UM', 'goog.i18n.DateTimeSymbols_en_US_POSIX', 'goog.i18n.DateTimeSymbols_en_VC', 'goog.i18n.DateTimeSymbols_en_VG', 'goog.i18n.DateTimeSymbols_en_VI', 'goog.i18n.DateTimeSymbols_en_VU', 'goog.i18n.DateTimeSymbols_en_WS', 'goog.i18n.DateTimeSymbols_en_XA', 'goog.i18n.DateTimeSymbols_en_ZM', 'goog.i18n.DateTimeSymbols_en_ZW', 'goog.i18n.DateTimeSymbols_eo', 'goog.i18n.DateTimeSymbols_eo_001', 'goog.i18n.DateTimeSymbols_es_AR', 'goog.i18n.DateTimeSymbols_es_BO', 'goog.i18n.DateTimeSymbols_es_BR', 'goog.i18n.DateTimeSymbols_es_BZ', 'goog.i18n.DateTimeSymbols_es_CL', 'goog.i18n.DateTimeSymbols_es_CO', 'goog.i18n.DateTimeSymbols_es_CR', 'goog.i18n.DateTimeSymbols_es_CU', 'goog.i18n.DateTimeSymbols_es_DO', 'goog.i18n.DateTimeSymbols_es_EA', 'goog.i18n.DateTimeSymbols_es_EC', 'goog.i18n.DateTimeSymbols_es_GQ', 'goog.i18n.DateTimeSymbols_es_GT', 'goog.i18n.DateTimeSymbols_es_HN', 'goog.i18n.DateTimeSymbols_es_IC', 'goog.i18n.DateTimeSymbols_es_NI', 'goog.i18n.DateTimeSymbols_es_PA', 'goog.i18n.DateTimeSymbols_es_PE', 'goog.i18n.DateTimeSymbols_es_PH', 'goog.i18n.DateTimeSymbols_es_PR', 'goog.i18n.DateTimeSymbols_es_PY', 'goog.i18n.DateTimeSymbols_es_SV', 'goog.i18n.DateTimeSymbols_es_UY', 'goog.i18n.DateTimeSymbols_es_VE', 'goog.i18n.DateTimeSymbols_et_EE', 'goog.i18n.DateTimeSymbols_eu_ES', 'goog.i18n.DateTimeSymbols_ewo', 'goog.i18n.DateTimeSymbols_ewo_CM', 'goog.i18n.DateTimeSymbols_fa_AF', 'goog.i18n.DateTimeSymbols_fa_IR', 'goog.i18n.DateTimeSymbols_ff', 'goog.i18n.DateTimeSymbols_ff_Latn', 'goog.i18n.DateTimeSymbols_ff_Latn_BF', 'goog.i18n.DateTimeSymbols_ff_Latn_CM', 'goog.i18n.DateTimeSymbols_ff_Latn_GH', 'goog.i18n.DateTimeSymbols_ff_Latn_GM', 'goog.i18n.DateTimeSymbols_ff_Latn_GN', 'goog.i18n.DateTimeSymbols_ff_Latn_GW', 'goog.i18n.DateTimeSymbols_ff_Latn_LR', 'goog.i18n.DateTimeSymbols_ff_Latn_MR', 'goog.i18n.DateTimeSymbols_ff_Latn_NE', 'goog.i18n.DateTimeSymbols_ff_Latn_NG', 'goog.i18n.DateTimeSymbols_ff_Latn_SL', 'goog.i18n.DateTimeSymbols_ff_Latn_SN', 'goog.i18n.DateTimeSymbols_fi_FI', 'goog.i18n.DateTimeSymbols_fil_PH', 'goog.i18n.DateTimeSymbols_fo', 'goog.i18n.DateTimeSymbols_fo_DK', 'goog.i18n.DateTimeSymbols_fo_FO', 'goog.i18n.DateTimeSymbols_fr_BE', 'goog.i18n.DateTimeSymbols_fr_BF', 'goog.i18n.DateTimeSymbols_fr_BI', 'goog.i18n.DateTimeSymbols_fr_BJ', 'goog.i18n.DateTimeSymbols_fr_BL', 'goog.i18n.DateTimeSymbols_fr_CD', 'goog.i18n.DateTimeSymbols_fr_CF', 'goog.i18n.DateTimeSymbols_fr_CG', 'goog.i18n.DateTimeSymbols_fr_CH', 'goog.i18n.DateTimeSymbols_fr_CI', 'goog.i18n.DateTimeSymbols_fr_CM', 'goog.i18n.DateTimeSymbols_fr_DJ', 'goog.i18n.DateTimeSymbols_fr_DZ', 'goog.i18n.DateTimeSymbols_fr_FR', 'goog.i18n.DateTimeSymbols_fr_GA', 'goog.i18n.DateTimeSymbols_fr_GF', 'goog.i18n.DateTimeSymbols_fr_GN', 'goog.i18n.DateTimeSymbols_fr_GP', 'goog.i18n.DateTimeSymbols_fr_GQ', 'goog.i18n.DateTimeSymbols_fr_HT', 'goog.i18n.DateTimeSymbols_fr_KM', 'goog.i18n.DateTimeSymbols_fr_LU', 'goog.i18n.DateTimeSymbols_fr_MA', 'goog.i18n.DateTimeSymbols_fr_MC', 'goog.i18n.DateTimeSymbols_fr_MF', 'goog.i18n.DateTimeSymbols_fr_MG', 'goog.i18n.DateTimeSymbols_fr_ML', 'goog.i18n.DateTimeSymbols_fr_MQ', 'goog.i18n.DateTimeSymbols_fr_MR', 'goog.i18n.DateTimeSymbols_fr_MU', 'goog.i18n.DateTimeSymbols_fr_NC', 'goog.i18n.DateTimeSymbols_fr_NE', 'goog.i18n.DateTimeSymbols_fr_PF', 'goog.i18n.DateTimeSymbols_fr_PM', 'goog.i18n.DateTimeSymbols_fr_RE', 'goog.i18n.DateTimeSymbols_fr_RW', 'goog.i18n.DateTimeSymbols_fr_SC', 'goog.i18n.DateTimeSymbols_fr_SN', 'goog.i18n.DateTimeSymbols_fr_SY', 'goog.i18n.DateTimeSymbols_fr_TD', 'goog.i18n.DateTimeSymbols_fr_TG', 'goog.i18n.DateTimeSymbols_fr_TN', 'goog.i18n.DateTimeSymbols_fr_VU', 'goog.i18n.DateTimeSymbols_fr_WF', 'goog.i18n.DateTimeSymbols_fr_YT', 'goog.i18n.DateTimeSymbols_fur', 'goog.i18n.DateTimeSymbols_fur_IT', 'goog.i18n.DateTimeSymbols_fy', 'goog.i18n.DateTimeSymbols_fy_NL', 'goog.i18n.DateTimeSymbols_ga_IE', 'goog.i18n.DateTimeSymbols_gd', 'goog.i18n.DateTimeSymbols_gd_GB', 'goog.i18n.DateTimeSymbols_gl_ES', 'goog.i18n.DateTimeSymbols_gsw_CH', 'goog.i18n.DateTimeSymbols_gsw_FR', 'goog.i18n.DateTimeSymbols_gsw_LI', 'goog.i18n.DateTimeSymbols_gu_IN', 'goog.i18n.DateTimeSymbols_guz', 'goog.i18n.DateTimeSymbols_guz_KE', 'goog.i18n.DateTimeSymbols_gv', 'goog.i18n.DateTimeSymbols_gv_IM', 'goog.i18n.DateTimeSymbols_ha', 'goog.i18n.DateTimeSymbols_ha_GH', 'goog.i18n.DateTimeSymbols_ha_NE', 'goog.i18n.DateTimeSymbols_ha_NG', 'goog.i18n.DateTimeSymbols_haw_US', 'goog.i18n.DateTimeSymbols_he_IL', 'goog.i18n.DateTimeSymbols_hi_IN', 'goog.i18n.DateTimeSymbols_hr_BA', 'goog.i18n.DateTimeSymbols_hr_HR', 'goog.i18n.DateTimeSymbols_hsb', 'goog.i18n.DateTimeSymbols_hsb_DE', 'goog.i18n.DateTimeSymbols_hu_HU', 'goog.i18n.DateTimeSymbols_hy_AM', 'goog.i18n.DateTimeSymbols_ia', 'goog.i18n.DateTimeSymbols_ia_001', 'goog.i18n.DateTimeSymbols_id_ID', 'goog.i18n.DateTimeSymbols_ig', 'goog.i18n.DateTimeSymbols_ig_NG', 'goog.i18n.DateTimeSymbols_ii', 'goog.i18n.DateTimeSymbols_ii_CN', 'goog.i18n.DateTimeSymbols_is_IS', 'goog.i18n.DateTimeSymbols_it_CH', 'goog.i18n.DateTimeSymbols_it_IT', 'goog.i18n.DateTimeSymbols_it_SM', 'goog.i18n.DateTimeSymbols_it_VA', 'goog.i18n.DateTimeSymbols_ja_JP', 'goog.i18n.DateTimeSymbols_jgo', 'goog.i18n.DateTimeSymbols_jgo_CM', 'goog.i18n.DateTimeSymbols_jmc', 'goog.i18n.DateTimeSymbols_jmc_TZ', 'goog.i18n.DateTimeSymbols_jv', 'goog.i18n.DateTimeSymbols_jv_ID', 'goog.i18n.DateTimeSymbols_ka_GE', 'goog.i18n.DateTimeSymbols_kab', 'goog.i18n.DateTimeSymbols_kab_DZ', 'goog.i18n.DateTimeSymbols_kam', 'goog.i18n.DateTimeSymbols_kam_KE', 'goog.i18n.DateTimeSymbols_kde', 'goog.i18n.DateTimeSymbols_kde_TZ', 'goog.i18n.DateTimeSymbols_kea', 'goog.i18n.DateTimeSymbols_kea_CV', 'goog.i18n.DateTimeSymbols_khq', 'goog.i18n.DateTimeSymbols_khq_ML', 'goog.i18n.DateTimeSymbols_ki', 'goog.i18n.DateTimeSymbols_ki_KE', 'goog.i18n.DateTimeSymbols_kk_KZ', 'goog.i18n.DateTimeSymbols_kkj', 'goog.i18n.DateTimeSymbols_kkj_CM', 'goog.i18n.DateTimeSymbols_kl', 'goog.i18n.DateTimeSymbols_kl_GL', 'goog.i18n.DateTimeSymbols_kln', 'goog.i18n.DateTimeSymbols_kln_KE', 'goog.i18n.DateTimeSymbols_km_KH', 'goog.i18n.DateTimeSymbols_kn_IN', 'goog.i18n.DateTimeSymbols_ko_KP', 'goog.i18n.DateTimeSymbols_ko_KR', 'goog.i18n.DateTimeSymbols_kok', 'goog.i18n.DateTimeSymbols_kok_IN', 'goog.i18n.DateTimeSymbols_ks', 'goog.i18n.DateTimeSymbols_ks_IN', 'goog.i18n.DateTimeSymbols_ksb', 'goog.i18n.DateTimeSymbols_ksb_TZ', 'goog.i18n.DateTimeSymbols_ksf', 'goog.i18n.DateTimeSymbols_ksf_CM', 'goog.i18n.DateTimeSymbols_ksh', 'goog.i18n.DateTimeSymbols_ksh_DE', 'goog.i18n.DateTimeSymbols_ku', 'goog.i18n.DateTimeSymbols_ku_TR', 'goog.i18n.DateTimeSymbols_kw', 'goog.i18n.DateTimeSymbols_kw_GB', 'goog.i18n.DateTimeSymbols_ky_KG', 'goog.i18n.DateTimeSymbols_lag', 'goog.i18n.DateTimeSymbols_lag_TZ', 'goog.i18n.DateTimeSymbols_lb', 'goog.i18n.DateTimeSymbols_lb_LU', 'goog.i18n.DateTimeSymbols_lg', 'goog.i18n.DateTimeSymbols_lg_UG', 'goog.i18n.DateTimeSymbols_lkt', 'goog.i18n.DateTimeSymbols_lkt_US', 'goog.i18n.DateTimeSymbols_ln_AO', 'goog.i18n.DateTimeSymbols_ln_CD', 'goog.i18n.DateTimeSymbols_ln_CF', 'goog.i18n.DateTimeSymbols_ln_CG', 'goog.i18n.DateTimeSymbols_lo_LA', 'goog.i18n.DateTimeSymbols_lrc', 'goog.i18n.DateTimeSymbols_lrc_IQ', 'goog.i18n.DateTimeSymbols_lrc_IR', 'goog.i18n.DateTimeSymbols_lt_LT', 'goog.i18n.DateTimeSymbols_lu', 'goog.i18n.DateTimeSymbols_lu_CD', 'goog.i18n.DateTimeSymbols_luo', 'goog.i18n.DateTimeSymbols_luo_KE', 'goog.i18n.DateTimeSymbols_luy', 'goog.i18n.DateTimeSymbols_luy_KE', 'goog.i18n.DateTimeSymbols_lv_LV', 'goog.i18n.DateTimeSymbols_mas', 'goog.i18n.DateTimeSymbols_mas_KE', 'goog.i18n.DateTimeSymbols_mas_TZ', 'goog.i18n.DateTimeSymbols_mer', 'goog.i18n.DateTimeSymbols_mer_KE', 'goog.i18n.DateTimeSymbols_mfe', 'goog.i18n.DateTimeSymbols_mfe_MU', 'goog.i18n.DateTimeSymbols_mg', 'goog.i18n.DateTimeSymbols_mg_MG', 'goog.i18n.DateTimeSymbols_mgh', 'goog.i18n.DateTimeSymbols_mgh_MZ', 'goog.i18n.DateTimeSymbols_mgo', 'goog.i18n.DateTimeSymbols_mgo_CM', 'goog.i18n.DateTimeSymbols_mi', 'goog.i18n.DateTimeSymbols_mi_NZ', 'goog.i18n.DateTimeSymbols_mk_MK', 'goog.i18n.DateTimeSymbols_ml_IN', 'goog.i18n.DateTimeSymbols_mn_MN', 'goog.i18n.DateTimeSymbols_mr_IN', 'goog.i18n.DateTimeSymbols_ms_BN', 'goog.i18n.DateTimeSymbols_ms_MY', 'goog.i18n.DateTimeSymbols_ms_SG', 'goog.i18n.DateTimeSymbols_mt_MT', 'goog.i18n.DateTimeSymbols_mua', 'goog.i18n.DateTimeSymbols_mua_CM', 'goog.i18n.DateTimeSymbols_my_MM', 'goog.i18n.DateTimeSymbols_mzn', 'goog.i18n.DateTimeSymbols_mzn_IR', 'goog.i18n.DateTimeSymbols_naq', 'goog.i18n.DateTimeSymbols_naq_NA', 'goog.i18n.DateTimeSymbols_nb_NO', 'goog.i18n.DateTimeSymbols_nb_SJ', 'goog.i18n.DateTimeSymbols_nd', 'goog.i18n.DateTimeSymbols_nd_ZW', 'goog.i18n.DateTimeSymbols_nds', 'goog.i18n.DateTimeSymbols_nds_DE', 'goog.i18n.DateTimeSymbols_nds_NL', 'goog.i18n.DateTimeSymbols_ne_IN', 'goog.i18n.DateTimeSymbols_ne_NP', 'goog.i18n.DateTimeSymbols_nl_AW', 'goog.i18n.DateTimeSymbols_nl_BE', 'goog.i18n.DateTimeSymbols_nl_BQ', 'goog.i18n.DateTimeSymbols_nl_CW', 'goog.i18n.DateTimeSymbols_nl_NL', 'goog.i18n.DateTimeSymbols_nl_SR', 'goog.i18n.DateTimeSymbols_nl_SX', 'goog.i18n.DateTimeSymbols_nmg', 'goog.i18n.DateTimeSymbols_nmg_CM', 'goog.i18n.DateTimeSymbols_nn', 'goog.i18n.DateTimeSymbols_nn_NO', 'goog.i18n.DateTimeSymbols_nnh', 'goog.i18n.DateTimeSymbols_nnh_CM', 'goog.i18n.DateTimeSymbols_nus', 'goog.i18n.DateTimeSymbols_nus_SS', 'goog.i18n.DateTimeSymbols_nyn', 'goog.i18n.DateTimeSymbols_nyn_UG', 'goog.i18n.DateTimeSymbols_om', 'goog.i18n.DateTimeSymbols_om_ET', 'goog.i18n.DateTimeSymbols_om_KE', 'goog.i18n.DateTimeSymbols_or_IN', 'goog.i18n.DateTimeSymbols_os', 'goog.i18n.DateTimeSymbols_os_GE', 'goog.i18n.DateTimeSymbols_os_RU', 'goog.i18n.DateTimeSymbols_pa_Arab', 'goog.i18n.DateTimeSymbols_pa_Arab_PK', 'goog.i18n.DateTimeSymbols_pa_Guru', 'goog.i18n.DateTimeSymbols_pa_Guru_IN', 'goog.i18n.DateTimeSymbols_pl_PL', 'goog.i18n.DateTimeSymbols_ps', 'goog.i18n.DateTimeSymbols_ps_AF', 'goog.i18n.DateTimeSymbols_ps_PK', 'goog.i18n.DateTimeSymbols_pt_AO', 'goog.i18n.DateTimeSymbols_pt_CH', 'goog.i18n.DateTimeSymbols_pt_CV', 'goog.i18n.DateTimeSymbols_pt_GQ', 'goog.i18n.DateTimeSymbols_pt_GW', 'goog.i18n.DateTimeSymbols_pt_LU', 'goog.i18n.DateTimeSymbols_pt_MO', 'goog.i18n.DateTimeSymbols_pt_MZ', 'goog.i18n.DateTimeSymbols_pt_ST', 'goog.i18n.DateTimeSymbols_pt_TL', 'goog.i18n.DateTimeSymbols_qu', 'goog.i18n.DateTimeSymbols_qu_BO', 'goog.i18n.DateTimeSymbols_qu_EC', 'goog.i18n.DateTimeSymbols_qu_PE', 'goog.i18n.DateTimeSymbols_rm', 'goog.i18n.DateTimeSymbols_rm_CH', 'goog.i18n.DateTimeSymbols_rn', 'goog.i18n.DateTimeSymbols_rn_BI', 'goog.i18n.DateTimeSymbols_ro_MD', 'goog.i18n.DateTimeSymbols_ro_RO', 'goog.i18n.DateTimeSymbols_rof', 'goog.i18n.DateTimeSymbols_rof_TZ', 'goog.i18n.DateTimeSymbols_ru_BY', 'goog.i18n.DateTimeSymbols_ru_KG', 'goog.i18n.DateTimeSymbols_ru_KZ', 'goog.i18n.DateTimeSymbols_ru_MD', 'goog.i18n.DateTimeSymbols_ru_RU', 'goog.i18n.DateTimeSymbols_ru_UA', 'goog.i18n.DateTimeSymbols_rw', 'goog.i18n.DateTimeSymbols_rw_RW', 'goog.i18n.DateTimeSymbols_rwk', 'goog.i18n.DateTimeSymbols_rwk_TZ', 'goog.i18n.DateTimeSymbols_sah', 'goog.i18n.DateTimeSymbols_sah_RU', 'goog.i18n.DateTimeSymbols_saq', 'goog.i18n.DateTimeSymbols_saq_KE', 'goog.i18n.DateTimeSymbols_sbp', 'goog.i18n.DateTimeSymbols_sbp_TZ', 'goog.i18n.DateTimeSymbols_sd', 'goog.i18n.DateTimeSymbols_sd_PK', 'goog.i18n.DateTimeSymbols_se', 'goog.i18n.DateTimeSymbols_se_FI', 'goog.i18n.DateTimeSymbols_se_NO', 'goog.i18n.DateTimeSymbols_se_SE', 'goog.i18n.DateTimeSymbols_seh', 'goog.i18n.DateTimeSymbols_seh_MZ', 'goog.i18n.DateTimeSymbols_ses', 'goog.i18n.DateTimeSymbols_ses_ML', 'goog.i18n.DateTimeSymbols_sg', 'goog.i18n.DateTimeSymbols_sg_CF', 'goog.i18n.DateTimeSymbols_shi', 'goog.i18n.DateTimeSymbols_shi_Latn', 'goog.i18n.DateTimeSymbols_shi_Latn_MA', 'goog.i18n.DateTimeSymbols_shi_Tfng', 'goog.i18n.DateTimeSymbols_shi_Tfng_MA', 'goog.i18n.DateTimeSymbols_si_LK', 'goog.i18n.DateTimeSymbols_sk_SK', 'goog.i18n.DateTimeSymbols_sl_SI', 'goog.i18n.DateTimeSymbols_smn', 'goog.i18n.DateTimeSymbols_smn_FI', 'goog.i18n.DateTimeSymbols_sn', 'goog.i18n.DateTimeSymbols_sn_ZW', 'goog.i18n.DateTimeSymbols_so', 'goog.i18n.DateTimeSymbols_so_DJ', 'goog.i18n.DateTimeSymbols_so_ET', 'goog.i18n.DateTimeSymbols_so_KE', 'goog.i18n.DateTimeSymbols_so_SO', 'goog.i18n.DateTimeSymbols_sq_AL', 'goog.i18n.DateTimeSymbols_sq_MK', 'goog.i18n.DateTimeSymbols_sq_XK', 'goog.i18n.DateTimeSymbols_sr_Cyrl', 'goog.i18n.DateTimeSymbols_sr_Cyrl_BA', 'goog.i18n.DateTimeSymbols_sr_Cyrl_ME', 'goog.i18n.DateTimeSymbols_sr_Cyrl_RS', 'goog.i18n.DateTimeSymbols_sr_Cyrl_XK', 'goog.i18n.DateTimeSymbols_sr_Latn_BA', 'goog.i18n.DateTimeSymbols_sr_Latn_ME', 'goog.i18n.DateTimeSymbols_sr_Latn_RS', 'goog.i18n.DateTimeSymbols_sr_Latn_XK', 'goog.i18n.DateTimeSymbols_sv_AX', 'goog.i18n.DateTimeSymbols_sv_FI', 'goog.i18n.DateTimeSymbols_sv_SE', 'goog.i18n.DateTimeSymbols_sw_CD', 'goog.i18n.DateTimeSymbols_sw_KE', 'goog.i18n.DateTimeSymbols_sw_TZ', 'goog.i18n.DateTimeSymbols_sw_UG', 'goog.i18n.DateTimeSymbols_ta_IN', 'goog.i18n.DateTimeSymbols_ta_LK', 'goog.i18n.DateTimeSymbols_ta_MY', 'goog.i18n.DateTimeSymbols_ta_SG', 'goog.i18n.DateTimeSymbols_te_IN', 'goog.i18n.DateTimeSymbols_teo', 'goog.i18n.DateTimeSymbols_teo_KE', 'goog.i18n.DateTimeSymbols_teo_UG', 'goog.i18n.DateTimeSymbols_tg', 'goog.i18n.DateTimeSymbols_tg_TJ', 'goog.i18n.DateTimeSymbols_th_TH', 'goog.i18n.DateTimeSymbols_ti', 'goog.i18n.DateTimeSymbols_ti_ER', 'goog.i18n.DateTimeSymbols_ti_ET', 'goog.i18n.DateTimeSymbols_tk', 'goog.i18n.DateTimeSymbols_tk_TM', 'goog.i18n.DateTimeSymbols_to', 'goog.i18n.DateTimeSymbols_to_TO', 'goog.i18n.DateTimeSymbols_tr_CY', 'goog.i18n.DateTimeSymbols_tr_TR', 'goog.i18n.DateTimeSymbols_tt', 'goog.i18n.DateTimeSymbols_tt_RU', 'goog.i18n.DateTimeSymbols_twq', 'goog.i18n.DateTimeSymbols_twq_NE', 'goog.i18n.DateTimeSymbols_tzm', 'goog.i18n.DateTimeSymbols_tzm_MA', 'goog.i18n.DateTimeSymbols_ug', 'goog.i18n.DateTimeSymbols_ug_CN', 'goog.i18n.DateTimeSymbols_uk_UA', 'goog.i18n.DateTimeSymbols_ur_IN', 'goog.i18n.DateTimeSymbols_ur_PK', 'goog.i18n.DateTimeSymbols_uz_Arab', 'goog.i18n.DateTimeSymbols_uz_Arab_AF', 'goog.i18n.DateTimeSymbols_uz_Cyrl', 'goog.i18n.DateTimeSymbols_uz_Cyrl_UZ', 'goog.i18n.DateTimeSymbols_uz_Latn', 'goog.i18n.DateTimeSymbols_uz_Latn_UZ', 'goog.i18n.DateTimeSymbols_vai', 'goog.i18n.DateTimeSymbols_vai_Latn', 'goog.i18n.DateTimeSymbols_vai_Latn_LR', 'goog.i18n.DateTimeSymbols_vai_Vaii', 'goog.i18n.DateTimeSymbols_vai_Vaii_LR', 'goog.i18n.DateTimeSymbols_vi_VN', 'goog.i18n.DateTimeSymbols_vun', 'goog.i18n.DateTimeSymbols_vun_TZ', 'goog.i18n.DateTimeSymbols_wae', 'goog.i18n.DateTimeSymbols_wae_CH', 'goog.i18n.DateTimeSymbols_wo', 'goog.i18n.DateTimeSymbols_wo_SN', 'goog.i18n.DateTimeSymbols_xh', 'goog.i18n.DateTimeSymbols_xh_ZA', 'goog.i18n.DateTimeSymbols_xog', 'goog.i18n.DateTimeSymbols_xog_UG', 'goog.i18n.DateTimeSymbols_yav', 'goog.i18n.DateTimeSymbols_yav_CM', 'goog.i18n.DateTimeSymbols_yi', 'goog.i18n.DateTimeSymbols_yi_001', 'goog.i18n.DateTimeSymbols_yo', 'goog.i18n.DateTimeSymbols_yo_BJ', 'goog.i18n.DateTimeSymbols_yo_NG', 'goog.i18n.DateTimeSymbols_yue', 'goog.i18n.DateTimeSymbols_yue_Hans', 'goog.i18n.DateTimeSymbols_yue_Hans_CN', 'goog.i18n.DateTimeSymbols_yue_Hant', 'goog.i18n.DateTimeSymbols_yue_Hant_HK', 'goog.i18n.DateTimeSymbols_zgh', 'goog.i18n.DateTimeSymbols_zgh_MA', 'goog.i18n.DateTimeSymbols_zh_Hans', 'goog.i18n.DateTimeSymbols_zh_Hans_CN', 'goog.i18n.DateTimeSymbols_zh_Hans_HK', 'goog.i18n.DateTimeSymbols_zh_Hans_MO', 'goog.i18n.DateTimeSymbols_zh_Hans_SG', 'goog.i18n.DateTimeSymbols_zh_Hant', 'goog.i18n.DateTimeSymbols_zh_Hant_HK', 'goog.i18n.DateTimeSymbols_zh_Hant_MO', 'goog.i18n.DateTimeSymbols_zh_Hant_TW', 'goog.i18n.DateTimeSymbols_zu_ZA'], ['goog.i18n.DateTimeSymbols'], {});
goog.addDependency('i18n/graphemebreak.js', ['goog.i18n.GraphemeBreak'], ['goog.asserts', 'goog.i18n.uChar', 'goog.structs.InversionMap'], {});
goog.addDependency('i18n/graphemebreak_test.js', ['goog.i18n.GraphemeBreakTest'], ['goog.i18n.GraphemeBreak', 'goog.i18n.uChar', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/localefeature.js', ['goog.i18n.LocaleFeature'], [], {'module': 'goog'});
goog.addDependency('i18n/localefeature_test.js', ['goog.i18n.LocaleFeatureTest'], ['goog.i18n.LocaleFeature', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/messageformat.js', ['goog.i18n.MessageFormat'], ['goog.array', 'goog.asserts', 'goog.i18n.CompactNumberFormatSymbols', 'goog.i18n.NumberFormat', 'goog.i18n.NumberFormatSymbols', 'goog.i18n.ordinalRules', 'goog.i18n.pluralRules'], {});
goog.addDependency('i18n/messageformat_test.js', ['goog.i18n.MessageFormatTest'], ['goog.i18n.MessageFormat', 'goog.i18n.NumberFormatSymbols_hr', 'goog.i18n.pluralRules', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/mime.js', ['goog.i18n.mime', 'goog.i18n.mime.encode'], ['goog.array', 'goog.i18n.uChar'], {});
goog.addDependency('i18n/mime_test.js', ['goog.i18n.mime.encodeTest'], ['goog.i18n.mime.encode', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/numberformat.js', ['goog.i18n.NumberFormat', 'goog.i18n.NumberFormat.CurrencyStyle', 'goog.i18n.NumberFormat.Format'], ['goog.asserts', 'goog.i18n.CompactNumberFormatSymbols', 'goog.i18n.NumberFormatSymbols', 'goog.i18n.NumberFormatSymbols_u_nu_latn', 'goog.i18n.currency', 'goog.math', 'goog.string'], {});
goog.addDependency('i18n/numberformat_test.js', ['goog.i18n.NumberFormatTest'], ['goog.i18n.CompactNumberFormatSymbols', 'goog.i18n.CompactNumberFormatSymbols_de', 'goog.i18n.CompactNumberFormatSymbols_en', 'goog.i18n.CompactNumberFormatSymbols_fr', 'goog.i18n.NumberFormat', 'goog.i18n.NumberFormatSymbols', 'goog.i18n.NumberFormatSymbols_ar_EG', 'goog.i18n.NumberFormatSymbols_ar_EG_u_nu_latn', 'goog.i18n.NumberFormatSymbols_de', 'goog.i18n.NumberFormatSymbols_en', 'goog.i18n.NumberFormatSymbols_en_AU', 'goog.i18n.NumberFormatSymbols_en_US', 'goog.i18n.NumberFormatSymbols_fi', 'goog.i18n.NumberFormatSymbols_fr', 'goog.i18n.NumberFormatSymbols_pl', 'goog.i18n.NumberFormatSymbols_ro', 'goog.i18n.NumberFormatSymbols_u_nu_latn', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/numberformatsymbols.js', ['goog.i18n.NumberFormatSymbols', 'goog.i18n.NumberFormatSymbols_af', 'goog.i18n.NumberFormatSymbols_am', 'goog.i18n.NumberFormatSymbols_ar', 'goog.i18n.NumberFormatSymbols_ar_DZ', 'goog.i18n.NumberFormatSymbols_ar_EG', 'goog.i18n.NumberFormatSymbols_ar_EG_u_nu_latn', 'goog.i18n.NumberFormatSymbols_az', 'goog.i18n.NumberFormatSymbols_be', 'goog.i18n.NumberFormatSymbols_bg', 'goog.i18n.NumberFormatSymbols_bn', 'goog.i18n.NumberFormatSymbols_bn_u_nu_latn', 'goog.i18n.NumberFormatSymbols_br', 'goog.i18n.NumberFormatSymbols_bs', 'goog.i18n.NumberFormatSymbols_ca', 'goog.i18n.NumberFormatSymbols_chr', 'goog.i18n.NumberFormatSymbols_cs', 'goog.i18n.NumberFormatSymbols_cy', 'goog.i18n.NumberFormatSymbols_da', 'goog.i18n.NumberFormatSymbols_de', 'goog.i18n.NumberFormatSymbols_de_AT', 'goog.i18n.NumberFormatSymbols_de_CH', 'goog.i18n.NumberFormatSymbols_el', 'goog.i18n.NumberFormatSymbols_en', 'goog.i18n.NumberFormatSymbols_en_AU', 'goog.i18n.NumberFormatSymbols_en_CA', 'goog.i18n.NumberFormatSymbols_en_GB', 'goog.i18n.NumberFormatSymbols_en_IE', 'goog.i18n.NumberFormatSymbols_en_IN', 'goog.i18n.NumberFormatSymbols_en_SG', 'goog.i18n.NumberFormatSymbols_en_US', 'goog.i18n.NumberFormatSymbols_en_ZA', 'goog.i18n.NumberFormatSymbols_es', 'goog.i18n.NumberFormatSymbols_es_419', 'goog.i18n.NumberFormatSymbols_es_ES', 'goog.i18n.NumberFormatSymbols_es_MX', 'goog.i18n.NumberFormatSymbols_es_US', 'goog.i18n.NumberFormatSymbols_et', 'goog.i18n.NumberFormatSymbols_eu', 'goog.i18n.NumberFormatSymbols_fa', 'goog.i18n.NumberFormatSymbols_fa_u_nu_latn', 'goog.i18n.NumberFormatSymbols_fi', 'goog.i18n.NumberFormatSymbols_fil', 'goog.i18n.NumberFormatSymbols_fr', 'goog.i18n.NumberFormatSymbols_fr_CA', 'goog.i18n.NumberFormatSymbols_ga', 'goog.i18n.NumberFormatSymbols_gl', 'goog.i18n.NumberFormatSymbols_gsw', 'goog.i18n.NumberFormatSymbols_gu', 'goog.i18n.NumberFormatSymbols_haw', 'goog.i18n.NumberFormatSymbols_he', 'goog.i18n.NumberFormatSymbols_hi', 'goog.i18n.NumberFormatSymbols_hr', 'goog.i18n.NumberFormatSymbols_hu', 'goog.i18n.NumberFormatSymbols_hy', 'goog.i18n.NumberFormatSymbols_id', 'goog.i18n.NumberFormatSymbols_in', 'goog.i18n.NumberFormatSymbols_is', 'goog.i18n.NumberFormatSymbols_it', 'goog.i18n.NumberFormatSymbols_iw', 'goog.i18n.NumberFormatSymbols_ja', 'goog.i18n.NumberFormatSymbols_ka', 'goog.i18n.NumberFormatSymbols_kk', 'goog.i18n.NumberFormatSymbols_km', 'goog.i18n.NumberFormatSymbols_kn', 'goog.i18n.NumberFormatSymbols_ko', 'goog.i18n.NumberFormatSymbols_ky', 'goog.i18n.NumberFormatSymbols_ln', 'goog.i18n.NumberFormatSymbols_lo', 'goog.i18n.NumberFormatSymbols_lt', 'goog.i18n.NumberFormatSymbols_lv', 'goog.i18n.NumberFormatSymbols_mk', 'goog.i18n.NumberFormatSymbols_ml', 'goog.i18n.NumberFormatSymbols_mn', 'goog.i18n.NumberFormatSymbols_mo', 'goog.i18n.NumberFormatSymbols_mr', 'goog.i18n.NumberFormatSymbols_mr_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ms', 'goog.i18n.NumberFormatSymbols_mt', 'goog.i18n.NumberFormatSymbols_my', 'goog.i18n.NumberFormatSymbols_my_u_nu_latn', 'goog.i18n.NumberFormatSymbols_nb', 'goog.i18n.NumberFormatSymbols_ne', 'goog.i18n.NumberFormatSymbols_ne_u_nu_latn', 'goog.i18n.NumberFormatSymbols_nl', 'goog.i18n.NumberFormatSymbols_no', 'goog.i18n.NumberFormatSymbols_no_NO', 'goog.i18n.NumberFormatSymbols_or', 'goog.i18n.NumberFormatSymbols_pa', 'goog.i18n.NumberFormatSymbols_pl', 'goog.i18n.NumberFormatSymbols_pt', 'goog.i18n.NumberFormatSymbols_pt_BR', 'goog.i18n.NumberFormatSymbols_pt_PT', 'goog.i18n.NumberFormatSymbols_ro', 'goog.i18n.NumberFormatSymbols_ru', 'goog.i18n.NumberFormatSymbols_sh', 'goog.i18n.NumberFormatSymbols_si', 'goog.i18n.NumberFormatSymbols_sk', 'goog.i18n.NumberFormatSymbols_sl', 'goog.i18n.NumberFormatSymbols_sq', 'goog.i18n.NumberFormatSymbols_sr', 'goog.i18n.NumberFormatSymbols_sr_Latn', 'goog.i18n.NumberFormatSymbols_sv', 'goog.i18n.NumberFormatSymbols_sw', 'goog.i18n.NumberFormatSymbols_ta', 'goog.i18n.NumberFormatSymbols_te', 'goog.i18n.NumberFormatSymbols_th', 'goog.i18n.NumberFormatSymbols_tl', 'goog.i18n.NumberFormatSymbols_tr', 'goog.i18n.NumberFormatSymbols_u_nu_latn', 'goog.i18n.NumberFormatSymbols_uk', 'goog.i18n.NumberFormatSymbols_ur', 'goog.i18n.NumberFormatSymbols_uz', 'goog.i18n.NumberFormatSymbols_vi', 'goog.i18n.NumberFormatSymbols_zh', 'goog.i18n.NumberFormatSymbols_zh_CN', 'goog.i18n.NumberFormatSymbols_zh_HK', 'goog.i18n.NumberFormatSymbols_zh_TW', 'goog.i18n.NumberFormatSymbols_zu'], [], {});
goog.addDependency('i18n/numberformatsymbolsext.js', ['goog.i18n.NumberFormatSymbolsExt', 'goog.i18n.NumberFormatSymbols_af_NA', 'goog.i18n.NumberFormatSymbols_af_ZA', 'goog.i18n.NumberFormatSymbols_agq', 'goog.i18n.NumberFormatSymbols_agq_CM', 'goog.i18n.NumberFormatSymbols_ak', 'goog.i18n.NumberFormatSymbols_ak_GH', 'goog.i18n.NumberFormatSymbols_am_ET', 'goog.i18n.NumberFormatSymbols_ar_001', 'goog.i18n.NumberFormatSymbols_ar_AE', 'goog.i18n.NumberFormatSymbols_ar_AE_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_BH', 'goog.i18n.NumberFormatSymbols_ar_BH_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_DJ', 'goog.i18n.NumberFormatSymbols_ar_DJ_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_EH', 'goog.i18n.NumberFormatSymbols_ar_ER', 'goog.i18n.NumberFormatSymbols_ar_ER_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_IL', 'goog.i18n.NumberFormatSymbols_ar_IL_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_IQ', 'goog.i18n.NumberFormatSymbols_ar_IQ_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_JO', 'goog.i18n.NumberFormatSymbols_ar_JO_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_KM', 'goog.i18n.NumberFormatSymbols_ar_KM_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_KW', 'goog.i18n.NumberFormatSymbols_ar_KW_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_LB', 'goog.i18n.NumberFormatSymbols_ar_LB_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_LY', 'goog.i18n.NumberFormatSymbols_ar_MA', 'goog.i18n.NumberFormatSymbols_ar_MR', 'goog.i18n.NumberFormatSymbols_ar_MR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_OM', 'goog.i18n.NumberFormatSymbols_ar_OM_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_PS', 'goog.i18n.NumberFormatSymbols_ar_PS_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_QA', 'goog.i18n.NumberFormatSymbols_ar_QA_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SA', 'goog.i18n.NumberFormatSymbols_ar_SA_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SD', 'goog.i18n.NumberFormatSymbols_ar_SD_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SO', 'goog.i18n.NumberFormatSymbols_ar_SO_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SS', 'goog.i18n.NumberFormatSymbols_ar_SS_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SY', 'goog.i18n.NumberFormatSymbols_ar_SY_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_TD', 'goog.i18n.NumberFormatSymbols_ar_TD_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_TN', 'goog.i18n.NumberFormatSymbols_ar_XB', 'goog.i18n.NumberFormatSymbols_ar_YE', 'goog.i18n.NumberFormatSymbols_ar_YE_u_nu_latn', 'goog.i18n.NumberFormatSymbols_as', 'goog.i18n.NumberFormatSymbols_as_IN', 'goog.i18n.NumberFormatSymbols_as_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_as_u_nu_latn', 'goog.i18n.NumberFormatSymbols_asa', 'goog.i18n.NumberFormatSymbols_asa_TZ', 'goog.i18n.NumberFormatSymbols_ast', 'goog.i18n.NumberFormatSymbols_ast_ES', 'goog.i18n.NumberFormatSymbols_az_Cyrl', 'goog.i18n.NumberFormatSymbols_az_Cyrl_AZ', 'goog.i18n.NumberFormatSymbols_az_Latn', 'goog.i18n.NumberFormatSymbols_az_Latn_AZ', 'goog.i18n.NumberFormatSymbols_bas', 'goog.i18n.NumberFormatSymbols_bas_CM', 'goog.i18n.NumberFormatSymbols_be_BY', 'goog.i18n.NumberFormatSymbols_bem', 'goog.i18n.NumberFormatSymbols_bem_ZM', 'goog.i18n.NumberFormatSymbols_bez', 'goog.i18n.NumberFormatSymbols_bez_TZ', 'goog.i18n.NumberFormatSymbols_bg_BG', 'goog.i18n.NumberFormatSymbols_bm', 'goog.i18n.NumberFormatSymbols_bm_ML', 'goog.i18n.NumberFormatSymbols_bn_BD', 'goog.i18n.NumberFormatSymbols_bn_BD_u_nu_latn', 'goog.i18n.NumberFormatSymbols_bn_IN', 'goog.i18n.NumberFormatSymbols_bn_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_bo', 'goog.i18n.NumberFormatSymbols_bo_CN', 'goog.i18n.NumberFormatSymbols_bo_IN', 'goog.i18n.NumberFormatSymbols_br_FR', 'goog.i18n.NumberFormatSymbols_brx', 'goog.i18n.NumberFormatSymbols_brx_IN', 'goog.i18n.NumberFormatSymbols_bs_Cyrl', 'goog.i18n.NumberFormatSymbols_bs_Cyrl_BA', 'goog.i18n.NumberFormatSymbols_bs_Latn', 'goog.i18n.NumberFormatSymbols_bs_Latn_BA', 'goog.i18n.NumberFormatSymbols_ca_AD', 'goog.i18n.NumberFormatSymbols_ca_ES', 'goog.i18n.NumberFormatSymbols_ca_FR', 'goog.i18n.NumberFormatSymbols_ca_IT', 'goog.i18n.NumberFormatSymbols_ccp', 'goog.i18n.NumberFormatSymbols_ccp_BD', 'goog.i18n.NumberFormatSymbols_ccp_BD_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ccp_IN', 'goog.i18n.NumberFormatSymbols_ccp_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ccp_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ce', 'goog.i18n.NumberFormatSymbols_ce_RU', 'goog.i18n.NumberFormatSymbols_ceb', 'goog.i18n.NumberFormatSymbols_ceb_PH', 'goog.i18n.NumberFormatSymbols_cgg', 'goog.i18n.NumberFormatSymbols_cgg_UG', 'goog.i18n.NumberFormatSymbols_chr_US', 'goog.i18n.NumberFormatSymbols_ckb', 'goog.i18n.NumberFormatSymbols_ckb_IQ', 'goog.i18n.NumberFormatSymbols_ckb_IQ_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ckb_IR', 'goog.i18n.NumberFormatSymbols_ckb_IR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ckb_u_nu_latn', 'goog.i18n.NumberFormatSymbols_cs_CZ', 'goog.i18n.NumberFormatSymbols_cy_GB', 'goog.i18n.NumberFormatSymbols_da_DK', 'goog.i18n.NumberFormatSymbols_da_GL', 'goog.i18n.NumberFormatSymbols_dav', 'goog.i18n.NumberFormatSymbols_dav_KE', 'goog.i18n.NumberFormatSymbols_de_BE', 'goog.i18n.NumberFormatSymbols_de_DE', 'goog.i18n.NumberFormatSymbols_de_IT', 'goog.i18n.NumberFormatSymbols_de_LI', 'goog.i18n.NumberFormatSymbols_de_LU', 'goog.i18n.NumberFormatSymbols_dje', 'goog.i18n.NumberFormatSymbols_dje_NE', 'goog.i18n.NumberFormatSymbols_dsb', 'goog.i18n.NumberFormatSymbols_dsb_DE', 'goog.i18n.NumberFormatSymbols_dua', 'goog.i18n.NumberFormatSymbols_dua_CM', 'goog.i18n.NumberFormatSymbols_dyo', 'goog.i18n.NumberFormatSymbols_dyo_SN', 'goog.i18n.NumberFormatSymbols_dz', 'goog.i18n.NumberFormatSymbols_dz_BT', 'goog.i18n.NumberFormatSymbols_dz_BT_u_nu_latn', 'goog.i18n.NumberFormatSymbols_dz_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ebu', 'goog.i18n.NumberFormatSymbols_ebu_KE', 'goog.i18n.NumberFormatSymbols_ee', 'goog.i18n.NumberFormatSymbols_ee_GH', 'goog.i18n.NumberFormatSymbols_ee_TG', 'goog.i18n.NumberFormatSymbols_el_CY', 'goog.i18n.NumberFormatSymbols_el_GR', 'goog.i18n.NumberFormatSymbols_en_001', 'goog.i18n.NumberFormatSymbols_en_150', 'goog.i18n.NumberFormatSymbols_en_AE', 'goog.i18n.NumberFormatSymbols_en_AG', 'goog.i18n.NumberFormatSymbols_en_AI', 'goog.i18n.NumberFormatSymbols_en_AS', 'goog.i18n.NumberFormatSymbols_en_AT', 'goog.i18n.NumberFormatSymbols_en_BB', 'goog.i18n.NumberFormatSymbols_en_BE', 'goog.i18n.NumberFormatSymbols_en_BI', 'goog.i18n.NumberFormatSymbols_en_BM', 'goog.i18n.NumberFormatSymbols_en_BS', 'goog.i18n.NumberFormatSymbols_en_BW', 'goog.i18n.NumberFormatSymbols_en_BZ', 'goog.i18n.NumberFormatSymbols_en_CC', 'goog.i18n.NumberFormatSymbols_en_CH', 'goog.i18n.NumberFormatSymbols_en_CK', 'goog.i18n.NumberFormatSymbols_en_CM', 'goog.i18n.NumberFormatSymbols_en_CX', 'goog.i18n.NumberFormatSymbols_en_CY', 'goog.i18n.NumberFormatSymbols_en_DE', 'goog.i18n.NumberFormatSymbols_en_DG', 'goog.i18n.NumberFormatSymbols_en_DK', 'goog.i18n.NumberFormatSymbols_en_DM', 'goog.i18n.NumberFormatSymbols_en_ER', 'goog.i18n.NumberFormatSymbols_en_FI', 'goog.i18n.NumberFormatSymbols_en_FJ', 'goog.i18n.NumberFormatSymbols_en_FK', 'goog.i18n.NumberFormatSymbols_en_FM', 'goog.i18n.NumberFormatSymbols_en_GD', 'goog.i18n.NumberFormatSymbols_en_GG', 'goog.i18n.NumberFormatSymbols_en_GH', 'goog.i18n.NumberFormatSymbols_en_GI', 'goog.i18n.NumberFormatSymbols_en_GM', 'goog.i18n.NumberFormatSymbols_en_GU', 'goog.i18n.NumberFormatSymbols_en_GY', 'goog.i18n.NumberFormatSymbols_en_HK', 'goog.i18n.NumberFormatSymbols_en_IL', 'goog.i18n.NumberFormatSymbols_en_IM', 'goog.i18n.NumberFormatSymbols_en_IO', 'goog.i18n.NumberFormatSymbols_en_JE', 'goog.i18n.NumberFormatSymbols_en_JM', 'goog.i18n.NumberFormatSymbols_en_KE', 'goog.i18n.NumberFormatSymbols_en_KI', 'goog.i18n.NumberFormatSymbols_en_KN', 'goog.i18n.NumberFormatSymbols_en_KY', 'goog.i18n.NumberFormatSymbols_en_LC', 'goog.i18n.NumberFormatSymbols_en_LR', 'goog.i18n.NumberFormatSymbols_en_LS', 'goog.i18n.NumberFormatSymbols_en_MG', 'goog.i18n.NumberFormatSymbols_en_MH', 'goog.i18n.NumberFormatSymbols_en_MO', 'goog.i18n.NumberFormatSymbols_en_MP', 'goog.i18n.NumberFormatSymbols_en_MS', 'goog.i18n.NumberFormatSymbols_en_MT', 'goog.i18n.NumberFormatSymbols_en_MU', 'goog.i18n.NumberFormatSymbols_en_MW', 'goog.i18n.NumberFormatSymbols_en_MY', 'goog.i18n.NumberFormatSymbols_en_NA', 'goog.i18n.NumberFormatSymbols_en_NF', 'goog.i18n.NumberFormatSymbols_en_NG', 'goog.i18n.NumberFormatSymbols_en_NL', 'goog.i18n.NumberFormatSymbols_en_NR', 'goog.i18n.NumberFormatSymbols_en_NU', 'goog.i18n.NumberFormatSymbols_en_NZ', 'goog.i18n.NumberFormatSymbols_en_PG', 'goog.i18n.NumberFormatSymbols_en_PH', 'goog.i18n.NumberFormatSymbols_en_PK', 'goog.i18n.NumberFormatSymbols_en_PN', 'goog.i18n.NumberFormatSymbols_en_PR', 'goog.i18n.NumberFormatSymbols_en_PW', 'goog.i18n.NumberFormatSymbols_en_RW', 'goog.i18n.NumberFormatSymbols_en_SB', 'goog.i18n.NumberFormatSymbols_en_SC', 'goog.i18n.NumberFormatSymbols_en_SD', 'goog.i18n.NumberFormatSymbols_en_SE', 'goog.i18n.NumberFormatSymbols_en_SH', 'goog.i18n.NumberFormatSymbols_en_SI', 'goog.i18n.NumberFormatSymbols_en_SL', 'goog.i18n.NumberFormatSymbols_en_SS', 'goog.i18n.NumberFormatSymbols_en_SX', 'goog.i18n.NumberFormatSymbols_en_SZ', 'goog.i18n.NumberFormatSymbols_en_TC', 'goog.i18n.NumberFormatSymbols_en_TK', 'goog.i18n.NumberFormatSymbols_en_TO', 'goog.i18n.NumberFormatSymbols_en_TT', 'goog.i18n.NumberFormatSymbols_en_TV', 'goog.i18n.NumberFormatSymbols_en_TZ', 'goog.i18n.NumberFormatSymbols_en_UG', 'goog.i18n.NumberFormatSymbols_en_UM', 'goog.i18n.NumberFormatSymbols_en_US_POSIX', 'goog.i18n.NumberFormatSymbols_en_VC', 'goog.i18n.NumberFormatSymbols_en_VG', 'goog.i18n.NumberFormatSymbols_en_VI', 'goog.i18n.NumberFormatSymbols_en_VU', 'goog.i18n.NumberFormatSymbols_en_WS', 'goog.i18n.NumberFormatSymbols_en_XA', 'goog.i18n.NumberFormatSymbols_en_ZM', 'goog.i18n.NumberFormatSymbols_en_ZW', 'goog.i18n.NumberFormatSymbols_eo', 'goog.i18n.NumberFormatSymbols_eo_001', 'goog.i18n.NumberFormatSymbols_es_AR', 'goog.i18n.NumberFormatSymbols_es_BO', 'goog.i18n.NumberFormatSymbols_es_BR', 'goog.i18n.NumberFormatSymbols_es_BZ', 'goog.i18n.NumberFormatSymbols_es_CL', 'goog.i18n.NumberFormatSymbols_es_CO', 'goog.i18n.NumberFormatSymbols_es_CR', 'goog.i18n.NumberFormatSymbols_es_CU', 'goog.i18n.NumberFormatSymbols_es_DO', 'goog.i18n.NumberFormatSymbols_es_EA', 'goog.i18n.NumberFormatSymbols_es_EC', 'goog.i18n.NumberFormatSymbols_es_GQ', 'goog.i18n.NumberFormatSymbols_es_GT', 'goog.i18n.NumberFormatSymbols_es_HN', 'goog.i18n.NumberFormatSymbols_es_IC', 'goog.i18n.NumberFormatSymbols_es_NI', 'goog.i18n.NumberFormatSymbols_es_PA', 'goog.i18n.NumberFormatSymbols_es_PE', 'goog.i18n.NumberFormatSymbols_es_PH', 'goog.i18n.NumberFormatSymbols_es_PR', 'goog.i18n.NumberFormatSymbols_es_PY', 'goog.i18n.NumberFormatSymbols_es_SV', 'goog.i18n.NumberFormatSymbols_es_UY', 'goog.i18n.NumberFormatSymbols_es_VE', 'goog.i18n.NumberFormatSymbols_et_EE', 'goog.i18n.NumberFormatSymbols_eu_ES', 'goog.i18n.NumberFormatSymbols_ewo', 'goog.i18n.NumberFormatSymbols_ewo_CM', 'goog.i18n.NumberFormatSymbols_fa_AF', 'goog.i18n.NumberFormatSymbols_fa_AF_u_nu_latn', 'goog.i18n.NumberFormatSymbols_fa_IR', 'goog.i18n.NumberFormatSymbols_fa_IR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ff', 'goog.i18n.NumberFormatSymbols_ff_Latn', 'goog.i18n.NumberFormatSymbols_ff_Latn_BF', 'goog.i18n.NumberFormatSymbols_ff_Latn_CM', 'goog.i18n.NumberFormatSymbols_ff_Latn_GH', 'goog.i18n.NumberFormatSymbols_ff_Latn_GM', 'goog.i18n.NumberFormatSymbols_ff_Latn_GN', 'goog.i18n.NumberFormatSymbols_ff_Latn_GW', 'goog.i18n.NumberFormatSymbols_ff_Latn_LR', 'goog.i18n.NumberFormatSymbols_ff_Latn_MR', 'goog.i18n.NumberFormatSymbols_ff_Latn_NE', 'goog.i18n.NumberFormatSymbols_ff_Latn_NG', 'goog.i18n.NumberFormatSymbols_ff_Latn_SL', 'goog.i18n.NumberFormatSymbols_ff_Latn_SN', 'goog.i18n.NumberFormatSymbols_fi_FI', 'goog.i18n.NumberFormatSymbols_fil_PH', 'goog.i18n.NumberFormatSymbols_fo', 'goog.i18n.NumberFormatSymbols_fo_DK', 'goog.i18n.NumberFormatSymbols_fo_FO', 'goog.i18n.NumberFormatSymbols_fr_BE', 'goog.i18n.NumberFormatSymbols_fr_BF', 'goog.i18n.NumberFormatSymbols_fr_BI', 'goog.i18n.NumberFormatSymbols_fr_BJ', 'goog.i18n.NumberFormatSymbols_fr_BL', 'goog.i18n.NumberFormatSymbols_fr_CD', 'goog.i18n.NumberFormatSymbols_fr_CF', 'goog.i18n.NumberFormatSymbols_fr_CG', 'goog.i18n.NumberFormatSymbols_fr_CH', 'goog.i18n.NumberFormatSymbols_fr_CI', 'goog.i18n.NumberFormatSymbols_fr_CM', 'goog.i18n.NumberFormatSymbols_fr_DJ', 'goog.i18n.NumberFormatSymbols_fr_DZ', 'goog.i18n.NumberFormatSymbols_fr_FR', 'goog.i18n.NumberFormatSymbols_fr_GA', 'goog.i18n.NumberFormatSymbols_fr_GF', 'goog.i18n.NumberFormatSymbols_fr_GN', 'goog.i18n.NumberFormatSymbols_fr_GP', 'goog.i18n.NumberFormatSymbols_fr_GQ', 'goog.i18n.NumberFormatSymbols_fr_HT', 'goog.i18n.NumberFormatSymbols_fr_KM', 'goog.i18n.NumberFormatSymbols_fr_LU', 'goog.i18n.NumberFormatSymbols_fr_MA', 'goog.i18n.NumberFormatSymbols_fr_MC', 'goog.i18n.NumberFormatSymbols_fr_MF', 'goog.i18n.NumberFormatSymbols_fr_MG', 'goog.i18n.NumberFormatSymbols_fr_ML', 'goog.i18n.NumberFormatSymbols_fr_MQ', 'goog.i18n.NumberFormatSymbols_fr_MR', 'goog.i18n.NumberFormatSymbols_fr_MU', 'goog.i18n.NumberFormatSymbols_fr_NC', 'goog.i18n.NumberFormatSymbols_fr_NE', 'goog.i18n.NumberFormatSymbols_fr_PF', 'goog.i18n.NumberFormatSymbols_fr_PM', 'goog.i18n.NumberFormatSymbols_fr_RE', 'goog.i18n.NumberFormatSymbols_fr_RW', 'goog.i18n.NumberFormatSymbols_fr_SC', 'goog.i18n.NumberFormatSymbols_fr_SN', 'goog.i18n.NumberFormatSymbols_fr_SY', 'goog.i18n.NumberFormatSymbols_fr_TD', 'goog.i18n.NumberFormatSymbols_fr_TG', 'goog.i18n.NumberFormatSymbols_fr_TN', 'goog.i18n.NumberFormatSymbols_fr_VU', 'goog.i18n.NumberFormatSymbols_fr_WF', 'goog.i18n.NumberFormatSymbols_fr_YT', 'goog.i18n.NumberFormatSymbols_fur', 'goog.i18n.NumberFormatSymbols_fur_IT', 'goog.i18n.NumberFormatSymbols_fy', 'goog.i18n.NumberFormatSymbols_fy_NL', 'goog.i18n.NumberFormatSymbols_ga_IE', 'goog.i18n.NumberFormatSymbols_gd', 'goog.i18n.NumberFormatSymbols_gd_GB', 'goog.i18n.NumberFormatSymbols_gl_ES', 'goog.i18n.NumberFormatSymbols_gsw_CH', 'goog.i18n.NumberFormatSymbols_gsw_FR', 'goog.i18n.NumberFormatSymbols_gsw_LI', 'goog.i18n.NumberFormatSymbols_gu_IN', 'goog.i18n.NumberFormatSymbols_guz', 'goog.i18n.NumberFormatSymbols_guz_KE', 'goog.i18n.NumberFormatSymbols_gv', 'goog.i18n.NumberFormatSymbols_gv_IM', 'goog.i18n.NumberFormatSymbols_ha', 'goog.i18n.NumberFormatSymbols_ha_GH', 'goog.i18n.NumberFormatSymbols_ha_NE', 'goog.i18n.NumberFormatSymbols_ha_NG', 'goog.i18n.NumberFormatSymbols_haw_US', 'goog.i18n.NumberFormatSymbols_he_IL', 'goog.i18n.NumberFormatSymbols_hi_IN', 'goog.i18n.NumberFormatSymbols_hr_BA', 'goog.i18n.NumberFormatSymbols_hr_HR', 'goog.i18n.NumberFormatSymbols_hsb', 'goog.i18n.NumberFormatSymbols_hsb_DE', 'goog.i18n.NumberFormatSymbols_hu_HU', 'goog.i18n.NumberFormatSymbols_hy_AM', 'goog.i18n.NumberFormatSymbols_ia', 'goog.i18n.NumberFormatSymbols_ia_001', 'goog.i18n.NumberFormatSymbols_id_ID', 'goog.i18n.NumberFormatSymbols_ig', 'goog.i18n.NumberFormatSymbols_ig_NG', 'goog.i18n.NumberFormatSymbols_ii', 'goog.i18n.NumberFormatSymbols_ii_CN', 'goog.i18n.NumberFormatSymbols_is_IS', 'goog.i18n.NumberFormatSymbols_it_CH', 'goog.i18n.NumberFormatSymbols_it_IT', 'goog.i18n.NumberFormatSymbols_it_SM', 'goog.i18n.NumberFormatSymbols_it_VA', 'goog.i18n.NumberFormatSymbols_ja_JP', 'goog.i18n.NumberFormatSymbols_jgo', 'goog.i18n.NumberFormatSymbols_jgo_CM', 'goog.i18n.NumberFormatSymbols_jmc', 'goog.i18n.NumberFormatSymbols_jmc_TZ', 'goog.i18n.NumberFormatSymbols_jv', 'goog.i18n.NumberFormatSymbols_jv_ID', 'goog.i18n.NumberFormatSymbols_ka_GE', 'goog.i18n.NumberFormatSymbols_kab', 'goog.i18n.NumberFormatSymbols_kab_DZ', 'goog.i18n.NumberFormatSymbols_kam', 'goog.i18n.NumberFormatSymbols_kam_KE', 'goog.i18n.NumberFormatSymbols_kde', 'goog.i18n.NumberFormatSymbols_kde_TZ', 'goog.i18n.NumberFormatSymbols_kea', 'goog.i18n.NumberFormatSymbols_kea_CV', 'goog.i18n.NumberFormatSymbols_khq', 'goog.i18n.NumberFormatSymbols_khq_ML', 'goog.i18n.NumberFormatSymbols_ki', 'goog.i18n.NumberFormatSymbols_ki_KE', 'goog.i18n.NumberFormatSymbols_kk_KZ', 'goog.i18n.NumberFormatSymbols_kkj', 'goog.i18n.NumberFormatSymbols_kkj_CM', 'goog.i18n.NumberFormatSymbols_kl', 'goog.i18n.NumberFormatSymbols_kl_GL', 'goog.i18n.NumberFormatSymbols_kln', 'goog.i18n.NumberFormatSymbols_kln_KE', 'goog.i18n.NumberFormatSymbols_km_KH', 'goog.i18n.NumberFormatSymbols_kn_IN', 'goog.i18n.NumberFormatSymbols_ko_KP', 'goog.i18n.NumberFormatSymbols_ko_KR', 'goog.i18n.NumberFormatSymbols_kok', 'goog.i18n.NumberFormatSymbols_kok_IN', 'goog.i18n.NumberFormatSymbols_ks', 'goog.i18n.NumberFormatSymbols_ks_IN', 'goog.i18n.NumberFormatSymbols_ks_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ks_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ksb', 'goog.i18n.NumberFormatSymbols_ksb_TZ', 'goog.i18n.NumberFormatSymbols_ksf', 'goog.i18n.NumberFormatSymbols_ksf_CM', 'goog.i18n.NumberFormatSymbols_ksh', 'goog.i18n.NumberFormatSymbols_ksh_DE', 'goog.i18n.NumberFormatSymbols_ku', 'goog.i18n.NumberFormatSymbols_ku_TR', 'goog.i18n.NumberFormatSymbols_kw', 'goog.i18n.NumberFormatSymbols_kw_GB', 'goog.i18n.NumberFormatSymbols_ky_KG', 'goog.i18n.NumberFormatSymbols_lag', 'goog.i18n.NumberFormatSymbols_lag_TZ', 'goog.i18n.NumberFormatSymbols_lb', 'goog.i18n.NumberFormatSymbols_lb_LU', 'goog.i18n.NumberFormatSymbols_lg', 'goog.i18n.NumberFormatSymbols_lg_UG', 'goog.i18n.NumberFormatSymbols_lkt', 'goog.i18n.NumberFormatSymbols_lkt_US', 'goog.i18n.NumberFormatSymbols_ln_AO', 'goog.i18n.NumberFormatSymbols_ln_CD', 'goog.i18n.NumberFormatSymbols_ln_CF', 'goog.i18n.NumberFormatSymbols_ln_CG', 'goog.i18n.NumberFormatSymbols_lo_LA', 'goog.i18n.NumberFormatSymbols_lrc', 'goog.i18n.NumberFormatSymbols_lrc_IQ', 'goog.i18n.NumberFormatSymbols_lrc_IQ_u_nu_latn', 'goog.i18n.NumberFormatSymbols_lrc_IR', 'goog.i18n.NumberFormatSymbols_lrc_IR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_lrc_u_nu_latn', 'goog.i18n.NumberFormatSymbols_lt_LT', 'goog.i18n.NumberFormatSymbols_lu', 'goog.i18n.NumberFormatSymbols_lu_CD', 'goog.i18n.NumberFormatSymbols_luo', 'goog.i18n.NumberFormatSymbols_luo_KE', 'goog.i18n.NumberFormatSymbols_luy', 'goog.i18n.NumberFormatSymbols_luy_KE', 'goog.i18n.NumberFormatSymbols_lv_LV', 'goog.i18n.NumberFormatSymbols_mas', 'goog.i18n.NumberFormatSymbols_mas_KE', 'goog.i18n.NumberFormatSymbols_mas_TZ', 'goog.i18n.NumberFormatSymbols_mer', 'goog.i18n.NumberFormatSymbols_mer_KE', 'goog.i18n.NumberFormatSymbols_mfe', 'goog.i18n.NumberFormatSymbols_mfe_MU', 'goog.i18n.NumberFormatSymbols_mg', 'goog.i18n.NumberFormatSymbols_mg_MG', 'goog.i18n.NumberFormatSymbols_mgh', 'goog.i18n.NumberFormatSymbols_mgh_MZ', 'goog.i18n.NumberFormatSymbols_mgo', 'goog.i18n.NumberFormatSymbols_mgo_CM', 'goog.i18n.NumberFormatSymbols_mi', 'goog.i18n.NumberFormatSymbols_mi_NZ', 'goog.i18n.NumberFormatSymbols_mk_MK', 'goog.i18n.NumberFormatSymbols_ml_IN', 'goog.i18n.NumberFormatSymbols_mn_MN', 'goog.i18n.NumberFormatSymbols_mr_IN', 'goog.i18n.NumberFormatSymbols_mr_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ms_BN', 'goog.i18n.NumberFormatSymbols_ms_MY', 'goog.i18n.NumberFormatSymbols_ms_SG', 'goog.i18n.NumberFormatSymbols_mt_MT', 'goog.i18n.NumberFormatSymbols_mua', 'goog.i18n.NumberFormatSymbols_mua_CM', 'goog.i18n.NumberFormatSymbols_my_MM', 'goog.i18n.NumberFormatSymbols_my_MM_u_nu_latn', 'goog.i18n.NumberFormatSymbols_mzn', 'goog.i18n.NumberFormatSymbols_mzn_IR', 'goog.i18n.NumberFormatSymbols_mzn_IR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_mzn_u_nu_latn', 'goog.i18n.NumberFormatSymbols_naq', 'goog.i18n.NumberFormatSymbols_naq_NA', 'goog.i18n.NumberFormatSymbols_nb_NO', 'goog.i18n.NumberFormatSymbols_nb_SJ', 'goog.i18n.NumberFormatSymbols_nd', 'goog.i18n.NumberFormatSymbols_nd_ZW', 'goog.i18n.NumberFormatSymbols_nds', 'goog.i18n.NumberFormatSymbols_nds_DE', 'goog.i18n.NumberFormatSymbols_nds_NL', 'goog.i18n.NumberFormatSymbols_ne_IN', 'goog.i18n.NumberFormatSymbols_ne_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ne_NP', 'goog.i18n.NumberFormatSymbols_ne_NP_u_nu_latn', 'goog.i18n.NumberFormatSymbols_nl_AW', 'goog.i18n.NumberFormatSymbols_nl_BE', 'goog.i18n.NumberFormatSymbols_nl_BQ', 'goog.i18n.NumberFormatSymbols_nl_CW', 'goog.i18n.NumberFormatSymbols_nl_NL', 'goog.i18n.NumberFormatSymbols_nl_SR', 'goog.i18n.NumberFormatSymbols_nl_SX', 'goog.i18n.NumberFormatSymbols_nmg', 'goog.i18n.NumberFormatSymbols_nmg_CM', 'goog.i18n.NumberFormatSymbols_nn', 'goog.i18n.NumberFormatSymbols_nn_NO', 'goog.i18n.NumberFormatSymbols_nnh', 'goog.i18n.NumberFormatSymbols_nnh_CM', 'goog.i18n.NumberFormatSymbols_nus', 'goog.i18n.NumberFormatSymbols_nus_SS', 'goog.i18n.NumberFormatSymbols_nyn', 'goog.i18n.NumberFormatSymbols_nyn_UG', 'goog.i18n.NumberFormatSymbols_om', 'goog.i18n.NumberFormatSymbols_om_ET', 'goog.i18n.NumberFormatSymbols_om_KE', 'goog.i18n.NumberFormatSymbols_or_IN', 'goog.i18n.NumberFormatSymbols_os', 'goog.i18n.NumberFormatSymbols_os_GE', 'goog.i18n.NumberFormatSymbols_os_RU', 'goog.i18n.NumberFormatSymbols_pa_Arab', 'goog.i18n.NumberFormatSymbols_pa_Arab_PK', 'goog.i18n.NumberFormatSymbols_pa_Arab_PK_u_nu_latn', 'goog.i18n.NumberFormatSymbols_pa_Arab_u_nu_latn', 'goog.i18n.NumberFormatSymbols_pa_Guru', 'goog.i18n.NumberFormatSymbols_pa_Guru_IN', 'goog.i18n.NumberFormatSymbols_pl_PL', 'goog.i18n.NumberFormatSymbols_ps', 'goog.i18n.NumberFormatSymbols_ps_AF', 'goog.i18n.NumberFormatSymbols_ps_AF_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ps_PK', 'goog.i18n.NumberFormatSymbols_ps_PK_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ps_u_nu_latn', 'goog.i18n.NumberFormatSymbols_pt_AO', 'goog.i18n.NumberFormatSymbols_pt_CH', 'goog.i18n.NumberFormatSymbols_pt_CV', 'goog.i18n.NumberFormatSymbols_pt_GQ', 'goog.i18n.NumberFormatSymbols_pt_GW', 'goog.i18n.NumberFormatSymbols_pt_LU', 'goog.i18n.NumberFormatSymbols_pt_MO', 'goog.i18n.NumberFormatSymbols_pt_MZ', 'goog.i18n.NumberFormatSymbols_pt_ST', 'goog.i18n.NumberFormatSymbols_pt_TL', 'goog.i18n.NumberFormatSymbols_qu', 'goog.i18n.NumberFormatSymbols_qu_BO', 'goog.i18n.NumberFormatSymbols_qu_EC', 'goog.i18n.NumberFormatSymbols_qu_PE', 'goog.i18n.NumberFormatSymbols_rm', 'goog.i18n.NumberFormatSymbols_rm_CH', 'goog.i18n.NumberFormatSymbols_rn', 'goog.i18n.NumberFormatSymbols_rn_BI', 'goog.i18n.NumberFormatSymbols_ro_MD', 'goog.i18n.NumberFormatSymbols_ro_RO', 'goog.i18n.NumberFormatSymbols_rof', 'goog.i18n.NumberFormatSymbols_rof_TZ', 'goog.i18n.NumberFormatSymbols_ru_BY', 'goog.i18n.NumberFormatSymbols_ru_KG', 'goog.i18n.NumberFormatSymbols_ru_KZ', 'goog.i18n.NumberFormatSymbols_ru_MD', 'goog.i18n.NumberFormatSymbols_ru_RU', 'goog.i18n.NumberFormatSymbols_ru_UA', 'goog.i18n.NumberFormatSymbols_rw', 'goog.i18n.NumberFormatSymbols_rw_RW', 'goog.i18n.NumberFormatSymbols_rwk', 'goog.i18n.NumberFormatSymbols_rwk_TZ', 'goog.i18n.NumberFormatSymbols_sah', 'goog.i18n.NumberFormatSymbols_sah_RU', 'goog.i18n.NumberFormatSymbols_saq', 'goog.i18n.NumberFormatSymbols_saq_KE', 'goog.i18n.NumberFormatSymbols_sbp', 'goog.i18n.NumberFormatSymbols_sbp_TZ', 'goog.i18n.NumberFormatSymbols_sd', 'goog.i18n.NumberFormatSymbols_sd_PK', 'goog.i18n.NumberFormatSymbols_sd_PK_u_nu_latn', 'goog.i18n.NumberFormatSymbols_sd_u_nu_latn', 'goog.i18n.NumberFormatSymbols_se', 'goog.i18n.NumberFormatSymbols_se_FI', 'goog.i18n.NumberFormatSymbols_se_NO', 'goog.i18n.NumberFormatSymbols_se_SE', 'goog.i18n.NumberFormatSymbols_seh', 'goog.i18n.NumberFormatSymbols_seh_MZ', 'goog.i18n.NumberFormatSymbols_ses', 'goog.i18n.NumberFormatSymbols_ses_ML', 'goog.i18n.NumberFormatSymbols_sg', 'goog.i18n.NumberFormatSymbols_sg_CF', 'goog.i18n.NumberFormatSymbols_shi', 'goog.i18n.NumberFormatSymbols_shi_Latn', 'goog.i18n.NumberFormatSymbols_shi_Latn_MA', 'goog.i18n.NumberFormatSymbols_shi_Tfng', 'goog.i18n.NumberFormatSymbols_shi_Tfng_MA', 'goog.i18n.NumberFormatSymbols_si_LK', 'goog.i18n.NumberFormatSymbols_sk_SK', 'goog.i18n.NumberFormatSymbols_sl_SI', 'goog.i18n.NumberFormatSymbols_smn', 'goog.i18n.NumberFormatSymbols_smn_FI', 'goog.i18n.NumberFormatSymbols_sn', 'goog.i18n.NumberFormatSymbols_sn_ZW', 'goog.i18n.NumberFormatSymbols_so', 'goog.i18n.NumberFormatSymbols_so_DJ', 'goog.i18n.NumberFormatSymbols_so_ET', 'goog.i18n.NumberFormatSymbols_so_KE', 'goog.i18n.NumberFormatSymbols_so_SO', 'goog.i18n.NumberFormatSymbols_sq_AL', 'goog.i18n.NumberFormatSymbols_sq_MK', 'goog.i18n.NumberFormatSymbols_sq_XK', 'goog.i18n.NumberFormatSymbols_sr_Cyrl', 'goog.i18n.NumberFormatSymbols_sr_Cyrl_BA', 'goog.i18n.NumberFormatSymbols_sr_Cyrl_ME', 'goog.i18n.NumberFormatSymbols_sr_Cyrl_RS', 'goog.i18n.NumberFormatSymbols_sr_Cyrl_XK', 'goog.i18n.NumberFormatSymbols_sr_Latn_BA', 'goog.i18n.NumberFormatSymbols_sr_Latn_ME', 'goog.i18n.NumberFormatSymbols_sr_Latn_RS', 'goog.i18n.NumberFormatSymbols_sr_Latn_XK', 'goog.i18n.NumberFormatSymbols_sv_AX', 'goog.i18n.NumberFormatSymbols_sv_FI', 'goog.i18n.NumberFormatSymbols_sv_SE', 'goog.i18n.NumberFormatSymbols_sw_CD', 'goog.i18n.NumberFormatSymbols_sw_KE', 'goog.i18n.NumberFormatSymbols_sw_TZ', 'goog.i18n.NumberFormatSymbols_sw_UG', 'goog.i18n.NumberFormatSymbols_ta_IN', 'goog.i18n.NumberFormatSymbols_ta_LK', 'goog.i18n.NumberFormatSymbols_ta_MY', 'goog.i18n.NumberFormatSymbols_ta_SG', 'goog.i18n.NumberFormatSymbols_te_IN', 'goog.i18n.NumberFormatSymbols_teo', 'goog.i18n.NumberFormatSymbols_teo_KE', 'goog.i18n.NumberFormatSymbols_teo_UG', 'goog.i18n.NumberFormatSymbols_tg', 'goog.i18n.NumberFormatSymbols_tg_TJ', 'goog.i18n.NumberFormatSymbols_th_TH', 'goog.i18n.NumberFormatSymbols_ti', 'goog.i18n.NumberFormatSymbols_ti_ER', 'goog.i18n.NumberFormatSymbols_ti_ET', 'goog.i18n.NumberFormatSymbols_tk', 'goog.i18n.NumberFormatSymbols_tk_TM', 'goog.i18n.NumberFormatSymbols_to', 'goog.i18n.NumberFormatSymbols_to_TO', 'goog.i18n.NumberFormatSymbols_tr_CY', 'goog.i18n.NumberFormatSymbols_tr_TR', 'goog.i18n.NumberFormatSymbols_tt', 'goog.i18n.NumberFormatSymbols_tt_RU', 'goog.i18n.NumberFormatSymbols_twq', 'goog.i18n.NumberFormatSymbols_twq_NE', 'goog.i18n.NumberFormatSymbols_tzm', 'goog.i18n.NumberFormatSymbols_tzm_MA', 'goog.i18n.NumberFormatSymbols_ug', 'goog.i18n.NumberFormatSymbols_ug_CN', 'goog.i18n.NumberFormatSymbols_uk_UA', 'goog.i18n.NumberFormatSymbols_ur_IN', 'goog.i18n.NumberFormatSymbols_ur_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ur_PK', 'goog.i18n.NumberFormatSymbols_uz_Arab', 'goog.i18n.NumberFormatSymbols_uz_Arab_AF', 'goog.i18n.NumberFormatSymbols_uz_Arab_AF_u_nu_latn', 'goog.i18n.NumberFormatSymbols_uz_Arab_u_nu_latn', 'goog.i18n.NumberFormatSymbols_uz_Cyrl', 'goog.i18n.NumberFormatSymbols_uz_Cyrl_UZ', 'goog.i18n.NumberFormatSymbols_uz_Latn', 'goog.i18n.NumberFormatSymbols_uz_Latn_UZ', 'goog.i18n.NumberFormatSymbols_vai', 'goog.i18n.NumberFormatSymbols_vai_Latn', 'goog.i18n.NumberFormatSymbols_vai_Latn_LR', 'goog.i18n.NumberFormatSymbols_vai_Vaii', 'goog.i18n.NumberFormatSymbols_vai_Vaii_LR', 'goog.i18n.NumberFormatSymbols_vi_VN', 'goog.i18n.NumberFormatSymbols_vun', 'goog.i18n.NumberFormatSymbols_vun_TZ', 'goog.i18n.NumberFormatSymbols_wae', 'goog.i18n.NumberFormatSymbols_wae_CH', 'goog.i18n.NumberFormatSymbols_wo', 'goog.i18n.NumberFormatSymbols_wo_SN', 'goog.i18n.NumberFormatSymbols_xh', 'goog.i18n.NumberFormatSymbols_xh_ZA', 'goog.i18n.NumberFormatSymbols_xog', 'goog.i18n.NumberFormatSymbols_xog_UG', 'goog.i18n.NumberFormatSymbols_yav', 'goog.i18n.NumberFormatSymbols_yav_CM', 'goog.i18n.NumberFormatSymbols_yi', 'goog.i18n.NumberFormatSymbols_yi_001', 'goog.i18n.NumberFormatSymbols_yo', 'goog.i18n.NumberFormatSymbols_yo_BJ', 'goog.i18n.NumberFormatSymbols_yo_NG', 'goog.i18n.NumberFormatSymbols_yue', 'goog.i18n.NumberFormatSymbols_yue_Hans', 'goog.i18n.NumberFormatSymbols_yue_Hans_CN', 'goog.i18n.NumberFormatSymbols_yue_Hant', 'goog.i18n.NumberFormatSymbols_yue_Hant_HK', 'goog.i18n.NumberFormatSymbols_zgh', 'goog.i18n.NumberFormatSymbols_zgh_MA', 'goog.i18n.NumberFormatSymbols_zh_Hans', 'goog.i18n.NumberFormatSymbols_zh_Hans_CN', 'goog.i18n.NumberFormatSymbols_zh_Hans_HK', 'goog.i18n.NumberFormatSymbols_zh_Hans_MO', 'goog.i18n.NumberFormatSymbols_zh_Hans_SG', 'goog.i18n.NumberFormatSymbols_zh_Hant', 'goog.i18n.NumberFormatSymbols_zh_Hant_HK', 'goog.i18n.NumberFormatSymbols_zh_Hant_MO', 'goog.i18n.NumberFormatSymbols_zh_Hant_TW', 'goog.i18n.NumberFormatSymbols_zu_ZA'], ['goog.i18n.NumberFormatSymbols', 'goog.i18n.NumberFormatSymbols_u_nu_latn'], {});
goog.addDependency('i18n/ordinalrules.js', ['goog.i18n.ordinalRules'], [], {'lang': 'es6'});
goog.addDependency('i18n/pluralrules.js', ['goog.i18n.pluralRules'], [], {'lang': 'es6'});
goog.addDependency('i18n/pluralrules_test.js', ['goog.i18n.pluralRulesTest'], ['goog.i18n.pluralRules', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/relativedatetimeformat.js', ['goog.i18n.RelativeDateTimeFormat'], ['goog.asserts', 'goog.i18n.LocaleFeature', 'goog.i18n.MessageFormat', 'goog.i18n.relativeDateTimeSymbols'], {'lang': 'es5', 'module': 'goog'});
goog.addDependency('i18n/relativedatetimeformat_test.js', ['goog.i18n.RelativeDateTimeFormatTest'], ['goog.i18n.LocaleFeature', 'goog.i18n.NumberFormatSymbols_ar_EG', 'goog.i18n.NumberFormatSymbols_en', 'goog.i18n.NumberFormatSymbols_es', 'goog.i18n.NumberFormatSymbols_fa', 'goog.i18n.RelativeDateTimeFormat', 'goog.i18n.relativeDateTimeSymbols', 'goog.i18n.relativeDateTimeSymbolsExt', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/relativedatetimesymbols.js', ['goog.i18n.relativeDateTimeSymbols'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/relativedatetimesymbolsext.js', ['goog.i18n.relativeDateTimeSymbolsExt'], ['goog.i18n.relativeDateTimeSymbols'], {'lang': 'es5', 'module': 'goog'});
goog.addDependency('i18n/timezone.js', ['goog.i18n.TimeZone'], ['goog.array', 'goog.date.DateLike', 'goog.object', 'goog.string'], {});
goog.addDependency('i18n/timezone_test.js', ['goog.i18n.TimeZoneTest'], ['goog.i18n.TimeZone', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/uchar.js', ['goog.i18n.uChar'], [], {'lang': 'es6'});
goog.addDependency('i18n/uchar/localnamefetcher.js', ['goog.i18n.uChar.LocalNameFetcher'], ['goog.i18n.uChar.NameFetcher', 'goog.i18n.uCharNames', 'goog.log'], {});
goog.addDependency('i18n/uchar/localnamefetcher_test.js', ['goog.i18n.uChar.LocalNameFetcherTest'], ['goog.i18n.uChar.LocalNameFetcher', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/uchar/namefetcher.js', ['goog.i18n.uChar.NameFetcher'], [], {});
goog.addDependency('i18n/uchar/remotenamefetcher.js', ['goog.i18n.uChar.RemoteNameFetcher'], ['goog.Disposable', 'goog.Uri', 'goog.events', 'goog.i18n.uChar', 'goog.i18n.uChar.NameFetcher', 'goog.log', 'goog.net.EventType', 'goog.net.XhrIo'], {});
goog.addDependency('i18n/uchar/remotenamefetcher_test.js', ['goog.i18n.uChar.RemoteNameFetcherTest'], ['goog.i18n.uChar.RemoteNameFetcher', 'goog.net.XhrIo', 'goog.testing.net.XhrIo', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/uchar_test.js', ['goog.i18n.uCharTest'], ['goog.i18n.uChar', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/ucharnames.js', ['goog.i18n.uCharNames'], ['goog.i18n.uChar'], {});
goog.addDependency('i18n/ucharnames_test.js', ['goog.i18n.uCharNamesTest'], ['goog.i18n.uCharNames', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('iter/es6.js', ['goog.iter.es6'], ['goog.iter.Iterable', 'goog.iter.Iterator', 'goog.iter.StopIteration'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('iter/es6_test.js', ['goog.iter.es6Test'], ['goog.iter', 'goog.iter.es6', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('iter/iter.js', ['goog.iter', 'goog.iter.Iterable', 'goog.iter.Iterator', 'goog.iter.StopIteration'], ['goog.array', 'goog.asserts', 'goog.functions', 'goog.math'], {});
goog.addDependency('iter/iter_test.js', ['goog.iterTest'], ['goog.iter', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('json/hybrid.js', ['goog.json.hybrid'], ['goog.asserts', 'goog.json'], {});
goog.addDependency('json/hybrid_test.js', ['goog.json.hybridTest'], ['goog.json', 'goog.json.hybrid', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('json/json.js', ['goog.json', 'goog.json.Replacer', 'goog.json.Reviver', 'goog.json.Serializer'], [], {'lang': 'es6'});
goog.addDependency('json/json_perf.js', ['goog.jsonPerf'], ['goog.dom', 'goog.json', 'goog.math', 'goog.string', 'goog.testing.PerformanceTable', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit'], {});
goog.addDependency('json/json_test.js', ['goog.jsonTest'], ['goog.functions', 'goog.json', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('json/jsonable.js', ['goog.json.Jsonable'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('json/nativejsonprocessor.js', ['goog.json.NativeJsonProcessor'], ['goog.asserts', 'goog.json.Processor'], {});
goog.addDependency('json/processor.js', ['goog.json.Processor'], ['goog.string.Parser', 'goog.string.Stringifier'], {});
goog.addDependency('json/processor_test.js', ['goog.json.processorTest'], ['goog.json.NativeJsonProcessor', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/collections/iterables.js', ['goog.labs.collections.iterables'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/collections/iterables_test.js', ['goog.labs.iterableTest'], ['goog.labs.collections.iterables', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/dom/pagevisibilitymonitor.js', ['goog.labs.dom.PageVisibilityEvent', 'goog.labs.dom.PageVisibilityMonitor', 'goog.labs.dom.PageVisibilityState'], ['goog.dom', 'goog.dom.vendor', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.memoize'], {});
goog.addDependency('labs/dom/pagevisibilitymonitor_test.js', ['goog.labs.dom.PageVisibilityMonitorTest'], ['goog.events', 'goog.functions', 'goog.labs.dom.PageVisibilityMonitor', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/events/nondisposableeventtarget.js', ['goog.labs.events.NonDisposableEventTarget'], ['goog.array', 'goog.asserts', 'goog.events.Event', 'goog.events.Listenable', 'goog.events.ListenerMap', 'goog.object'], {});
goog.addDependency('labs/events/nondisposableeventtarget_test.js', ['goog.labs.events.NonDisposableEventTargetTest'], ['goog.events.Listenable', 'goog.events.eventTargetTester', 'goog.labs.events.NonDisposableEventTarget', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/events/nondisposableeventtarget_via_googevents_test.js', ['goog.labs.events.NonDisposableEventTargetGoogEventsTest'], ['goog.events', 'goog.events.eventTargetTester', 'goog.labs.events.NonDisposableEventTarget', 'goog.testing', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/events/touch.js', ['goog.labs.events.touch', 'goog.labs.events.touch.TouchData'], ['goog.array', 'goog.asserts', 'goog.events.EventType', 'goog.string'], {});
goog.addDependency('labs/events/touch_test.js', ['goog.labs.events.touchTest'], ['goog.labs.events.touch', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/format/csv.js', ['goog.labs.format.csv', 'goog.labs.format.csv.ParseError', 'goog.labs.format.csv.Token'], ['goog.array', 'goog.asserts', 'goog.debug.Error', 'goog.object', 'goog.string', 'goog.string.newlines'], {});
goog.addDependency('labs/format/csv_test.js', ['goog.labs.format.csvTest'], ['goog.labs.format.csv', 'goog.labs.format.csv.ParseError', 'goog.object', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/i18n/listformat.js', ['goog.labs.i18n.GenderInfo', 'goog.labs.i18n.GenderInfo.Gender', 'goog.labs.i18n.ListFormat'], ['goog.asserts', 'goog.labs.i18n.ListFormatSymbols'], {});
goog.addDependency('labs/i18n/listformat_test.js', ['goog.labs.i18n.ListFormatTest'], ['goog.labs.i18n.GenderInfo', 'goog.labs.i18n.ListFormat', 'goog.labs.i18n.ListFormatSymbols', 'goog.labs.i18n.ListFormatSymbols_el', 'goog.labs.i18n.ListFormatSymbols_en', 'goog.labs.i18n.ListFormatSymbols_fr', 'goog.labs.i18n.ListFormatSymbols_ml', 'goog.labs.i18n.ListFormatSymbols_zu', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/i18n/listsymbols.js', ['goog.labs.i18n.ListFormatSymbols', 'goog.labs.i18n.ListFormatSymbols_af', 'goog.labs.i18n.ListFormatSymbols_am', 'goog.labs.i18n.ListFormatSymbols_ar', 'goog.labs.i18n.ListFormatSymbols_ar_DZ', 'goog.labs.i18n.ListFormatSymbols_ar_EG', 'goog.labs.i18n.ListFormatSymbols_az', 'goog.labs.i18n.ListFormatSymbols_be', 'goog.labs.i18n.ListFormatSymbols_bg', 'goog.labs.i18n.ListFormatSymbols_bn', 'goog.labs.i18n.ListFormatSymbols_br', 'goog.labs.i18n.ListFormatSymbols_bs', 'goog.labs.i18n.ListFormatSymbols_ca', 'goog.labs.i18n.ListFormatSymbols_chr', 'goog.labs.i18n.ListFormatSymbols_cs', 'goog.labs.i18n.ListFormatSymbols_cy', 'goog.labs.i18n.ListFormatSymbols_da', 'goog.labs.i18n.ListFormatSymbols_de', 'goog.labs.i18n.ListFormatSymbols_de_AT', 'goog.labs.i18n.ListFormatSymbols_de_CH', 'goog.labs.i18n.ListFormatSymbols_el', 'goog.labs.i18n.ListFormatSymbols_en', 'goog.labs.i18n.ListFormatSymbols_en_AU', 'goog.labs.i18n.ListFormatSymbols_en_CA', 'goog.labs.i18n.ListFormatSymbols_en_GB', 'goog.labs.i18n.ListFormatSymbols_en_IE', 'goog.labs.i18n.ListFormatSymbols_en_IN', 'goog.labs.i18n.ListFormatSymbols_en_SG', 'goog.labs.i18n.ListFormatSymbols_en_US', 'goog.labs.i18n.ListFormatSymbols_en_ZA', 'goog.labs.i18n.ListFormatSymbols_es', 'goog.labs.i18n.ListFormatSymbols_es_419', 'goog.labs.i18n.ListFormatSymbols_es_ES', 'goog.labs.i18n.ListFormatSymbols_es_MX', 'goog.labs.i18n.ListFormatSymbols_es_US', 'goog.labs.i18n.ListFormatSymbols_et', 'goog.labs.i18n.ListFormatSymbols_eu', 'goog.labs.i18n.ListFormatSymbols_fa', 'goog.labs.i18n.ListFormatSymbols_fi', 'goog.labs.i18n.ListFormatSymbols_fil', 'goog.labs.i18n.ListFormatSymbols_fr', 'goog.labs.i18n.ListFormatSymbols_fr_CA', 'goog.labs.i18n.ListFormatSymbols_ga', 'goog.labs.i18n.ListFormatSymbols_gl', 'goog.labs.i18n.ListFormatSymbols_gsw', 'goog.labs.i18n.ListFormatSymbols_gu', 'goog.labs.i18n.ListFormatSymbols_haw', 'goog.labs.i18n.ListFormatSymbols_he', 'goog.labs.i18n.ListFormatSymbols_hi', 'goog.labs.i18n.ListFormatSymbols_hr', 'goog.labs.i18n.ListFormatSymbols_hu', 'goog.labs.i18n.ListFormatSymbols_hy', 'goog.labs.i18n.ListFormatSymbols_id', 'goog.labs.i18n.ListFormatSymbols_in', 'goog.labs.i18n.ListFormatSymbols_is', 'goog.labs.i18n.ListFormatSymbols_it', 'goog.labs.i18n.ListFormatSymbols_iw', 'goog.labs.i18n.ListFormatSymbols_ja', 'goog.labs.i18n.ListFormatSymbols_ka', 'goog.labs.i18n.ListFormatSymbols_kk', 'goog.labs.i18n.ListFormatSymbols_km', 'goog.labs.i18n.ListFormatSymbols_kn', 'goog.labs.i18n.ListFormatSymbols_ko', 'goog.labs.i18n.ListFormatSymbols_ky', 'goog.labs.i18n.ListFormatSymbols_ln', 'goog.labs.i18n.ListFormatSymbols_lo', 'goog.labs.i18n.ListFormatSymbols_lt', 'goog.labs.i18n.ListFormatSymbols_lv', 'goog.labs.i18n.ListFormatSymbols_mk', 'goog.labs.i18n.ListFormatSymbols_ml', 'goog.labs.i18n.ListFormatSymbols_mn', 'goog.labs.i18n.ListFormatSymbols_mo', 'goog.labs.i18n.ListFormatSymbols_mr', 'goog.labs.i18n.ListFormatSymbols_ms', 'goog.labs.i18n.ListFormatSymbols_mt', 'goog.labs.i18n.ListFormatSymbols_my', 'goog.labs.i18n.ListFormatSymbols_nb', 'goog.labs.i18n.ListFormatSymbols_ne', 'goog.labs.i18n.ListFormatSymbols_nl', 'goog.labs.i18n.ListFormatSymbols_no', 'goog.labs.i18n.ListFormatSymbols_no_NO', 'goog.labs.i18n.ListFormatSymbols_or', 'goog.labs.i18n.ListFormatSymbols_pa', 'goog.labs.i18n.ListFormatSymbols_pl', 'goog.labs.i18n.ListFormatSymbols_pt', 'goog.labs.i18n.ListFormatSymbols_pt_BR', 'goog.labs.i18n.ListFormatSymbols_pt_PT', 'goog.labs.i18n.ListFormatSymbols_ro', 'goog.labs.i18n.ListFormatSymbols_ru', 'goog.labs.i18n.ListFormatSymbols_sh', 'goog.labs.i18n.ListFormatSymbols_si', 'goog.labs.i18n.ListFormatSymbols_sk', 'goog.labs.i18n.ListFormatSymbols_sl', 'goog.labs.i18n.ListFormatSymbols_sq', 'goog.labs.i18n.ListFormatSymbols_sr', 'goog.labs.i18n.ListFormatSymbols_sr_Latn', 'goog.labs.i18n.ListFormatSymbols_sv', 'goog.labs.i18n.ListFormatSymbols_sw', 'goog.labs.i18n.ListFormatSymbols_ta', 'goog.labs.i18n.ListFormatSymbols_te', 'goog.labs.i18n.ListFormatSymbols_th', 'goog.labs.i18n.ListFormatSymbols_tl', 'goog.labs.i18n.ListFormatSymbols_tr', 'goog.labs.i18n.ListFormatSymbols_uk', 'goog.labs.i18n.ListFormatSymbols_ur', 'goog.labs.i18n.ListFormatSymbols_uz', 'goog.labs.i18n.ListFormatSymbols_vi', 'goog.labs.i18n.ListFormatSymbols_zh', 'goog.labs.i18n.ListFormatSymbols_zh_CN', 'goog.labs.i18n.ListFormatSymbols_zh_HK', 'goog.labs.i18n.ListFormatSymbols_zh_TW', 'goog.labs.i18n.ListFormatSymbols_zu'], [], {});
goog.addDependency('labs/i18n/listsymbolsext.js', ['goog.labs.i18n.ListFormatSymbolsExt', 'goog.labs.i18n.ListFormatSymbols_af_NA', 'goog.labs.i18n.ListFormatSymbols_af_ZA', 'goog.labs.i18n.ListFormatSymbols_agq', 'goog.labs.i18n.ListFormatSymbols_agq_CM', 'goog.labs.i18n.ListFormatSymbols_ak', 'goog.labs.i18n.ListFormatSymbols_ak_GH', 'goog.labs.i18n.ListFormatSymbols_am_ET', 'goog.labs.i18n.ListFormatSymbols_ar_001', 'goog.labs.i18n.ListFormatSymbols_ar_AE', 'goog.labs.i18n.ListFormatSymbols_ar_BH', 'goog.labs.i18n.ListFormatSymbols_ar_DJ', 'goog.labs.i18n.ListFormatSymbols_ar_EH', 'goog.labs.i18n.ListFormatSymbols_ar_ER', 'goog.labs.i18n.ListFormatSymbols_ar_IL', 'goog.labs.i18n.ListFormatSymbols_ar_IQ', 'goog.labs.i18n.ListFormatSymbols_ar_JO', 'goog.labs.i18n.ListFormatSymbols_ar_KM', 'goog.labs.i18n.ListFormatSymbols_ar_KW', 'goog.labs.i18n.ListFormatSymbols_ar_LB', 'goog.labs.i18n.ListFormatSymbols_ar_LY', 'goog.labs.i18n.ListFormatSymbols_ar_MA', 'goog.labs.i18n.ListFormatSymbols_ar_MR', 'goog.labs.i18n.ListFormatSymbols_ar_OM', 'goog.labs.i18n.ListFormatSymbols_ar_PS', 'goog.labs.i18n.ListFormatSymbols_ar_QA', 'goog.labs.i18n.ListFormatSymbols_ar_SA', 'goog.labs.i18n.ListFormatSymbols_ar_SD', 'goog.labs.i18n.ListFormatSymbols_ar_SO', 'goog.labs.i18n.ListFormatSymbols_ar_SS', 'goog.labs.i18n.ListFormatSymbols_ar_SY', 'goog.labs.i18n.ListFormatSymbols_ar_TD', 'goog.labs.i18n.ListFormatSymbols_ar_TN', 'goog.labs.i18n.ListFormatSymbols_ar_XB', 'goog.labs.i18n.ListFormatSymbols_ar_YE', 'goog.labs.i18n.ListFormatSymbols_as', 'goog.labs.i18n.ListFormatSymbols_as_IN', 'goog.labs.i18n.ListFormatSymbols_asa', 'goog.labs.i18n.ListFormatSymbols_asa_TZ', 'goog.labs.i18n.ListFormatSymbols_ast', 'goog.labs.i18n.ListFormatSymbols_ast_ES', 'goog.labs.i18n.ListFormatSymbols_az_Cyrl', 'goog.labs.i18n.ListFormatSymbols_az_Cyrl_AZ', 'goog.labs.i18n.ListFormatSymbols_az_Latn', 'goog.labs.i18n.ListFormatSymbols_az_Latn_AZ', 'goog.labs.i18n.ListFormatSymbols_bas', 'goog.labs.i18n.ListFormatSymbols_bas_CM', 'goog.labs.i18n.ListFormatSymbols_be_BY', 'goog.labs.i18n.ListFormatSymbols_bem', 'goog.labs.i18n.ListFormatSymbols_bem_ZM', 'goog.labs.i18n.ListFormatSymbols_bez', 'goog.labs.i18n.ListFormatSymbols_bez_TZ', 'goog.labs.i18n.ListFormatSymbols_bg_BG', 'goog.labs.i18n.ListFormatSymbols_bm', 'goog.labs.i18n.ListFormatSymbols_bm_ML', 'goog.labs.i18n.ListFormatSymbols_bn_BD', 'goog.labs.i18n.ListFormatSymbols_bn_IN', 'goog.labs.i18n.ListFormatSymbols_bo', 'goog.labs.i18n.ListFormatSymbols_bo_CN', 'goog.labs.i18n.ListFormatSymbols_bo_IN', 'goog.labs.i18n.ListFormatSymbols_br_FR', 'goog.labs.i18n.ListFormatSymbols_brx', 'goog.labs.i18n.ListFormatSymbols_brx_IN', 'goog.labs.i18n.ListFormatSymbols_bs_Cyrl', 'goog.labs.i18n.ListFormatSymbols_bs_Cyrl_BA', 'goog.labs.i18n.ListFormatSymbols_bs_Latn', 'goog.labs.i18n.ListFormatSymbols_bs_Latn_BA', 'goog.labs.i18n.ListFormatSymbols_ca_AD', 'goog.labs.i18n.ListFormatSymbols_ca_ES', 'goog.labs.i18n.ListFormatSymbols_ca_FR', 'goog.labs.i18n.ListFormatSymbols_ca_IT', 'goog.labs.i18n.ListFormatSymbols_ccp', 'goog.labs.i18n.ListFormatSymbols_ccp_BD', 'goog.labs.i18n.ListFormatSymbols_ccp_IN', 'goog.labs.i18n.ListFormatSymbols_ce', 'goog.labs.i18n.ListFormatSymbols_ce_RU', 'goog.labs.i18n.ListFormatSymbols_ceb', 'goog.labs.i18n.ListFormatSymbols_ceb_PH', 'goog.labs.i18n.ListFormatSymbols_cgg', 'goog.labs.i18n.ListFormatSymbols_cgg_UG', 'goog.labs.i18n.ListFormatSymbols_chr_US', 'goog.labs.i18n.ListFormatSymbols_ckb', 'goog.labs.i18n.ListFormatSymbols_ckb_IQ', 'goog.labs.i18n.ListFormatSymbols_ckb_IR', 'goog.labs.i18n.ListFormatSymbols_cs_CZ', 'goog.labs.i18n.ListFormatSymbols_cy_GB', 'goog.labs.i18n.ListFormatSymbols_da_DK', 'goog.labs.i18n.ListFormatSymbols_da_GL', 'goog.labs.i18n.ListFormatSymbols_dav', 'goog.labs.i18n.ListFormatSymbols_dav_KE', 'goog.labs.i18n.ListFormatSymbols_de_BE', 'goog.labs.i18n.ListFormatSymbols_de_DE', 'goog.labs.i18n.ListFormatSymbols_de_IT', 'goog.labs.i18n.ListFormatSymbols_de_LI', 'goog.labs.i18n.ListFormatSymbols_de_LU', 'goog.labs.i18n.ListFormatSymbols_dje', 'goog.labs.i18n.ListFormatSymbols_dje_NE', 'goog.labs.i18n.ListFormatSymbols_dsb', 'goog.labs.i18n.ListFormatSymbols_dsb_DE', 'goog.labs.i18n.ListFormatSymbols_dua', 'goog.labs.i18n.ListFormatSymbols_dua_CM', 'goog.labs.i18n.ListFormatSymbols_dyo', 'goog.labs.i18n.ListFormatSymbols_dyo_SN', 'goog.labs.i18n.ListFormatSymbols_dz', 'goog.labs.i18n.ListFormatSymbols_dz_BT', 'goog.labs.i18n.ListFormatSymbols_ebu', 'goog.labs.i18n.ListFormatSymbols_ebu_KE', 'goog.labs.i18n.ListFormatSymbols_ee', 'goog.labs.i18n.ListFormatSymbols_ee_GH', 'goog.labs.i18n.ListFormatSymbols_ee_TG', 'goog.labs.i18n.ListFormatSymbols_el_CY', 'goog.labs.i18n.ListFormatSymbols_el_GR', 'goog.labs.i18n.ListFormatSymbols_en_001', 'goog.labs.i18n.ListFormatSymbols_en_150', 'goog.labs.i18n.ListFormatSymbols_en_AE', 'goog.labs.i18n.ListFormatSymbols_en_AG', 'goog.labs.i18n.ListFormatSymbols_en_AI', 'goog.labs.i18n.ListFormatSymbols_en_AS', 'goog.labs.i18n.ListFormatSymbols_en_AT', 'goog.labs.i18n.ListFormatSymbols_en_BB', 'goog.labs.i18n.ListFormatSymbols_en_BE', 'goog.labs.i18n.ListFormatSymbols_en_BI', 'goog.labs.i18n.ListFormatSymbols_en_BM', 'goog.labs.i18n.ListFormatSymbols_en_BS', 'goog.labs.i18n.ListFormatSymbols_en_BW', 'goog.labs.i18n.ListFormatSymbols_en_BZ', 'goog.labs.i18n.ListFormatSymbols_en_CC', 'goog.labs.i18n.ListFormatSymbols_en_CH', 'goog.labs.i18n.ListFormatSymbols_en_CK', 'goog.labs.i18n.ListFormatSymbols_en_CM', 'goog.labs.i18n.ListFormatSymbols_en_CX', 'goog.labs.i18n.ListFormatSymbols_en_CY', 'goog.labs.i18n.ListFormatSymbols_en_DE', 'goog.labs.i18n.ListFormatSymbols_en_DG', 'goog.labs.i18n.ListFormatSymbols_en_DK', 'goog.labs.i18n.ListFormatSymbols_en_DM', 'goog.labs.i18n.ListFormatSymbols_en_ER', 'goog.labs.i18n.ListFormatSymbols_en_FI', 'goog.labs.i18n.ListFormatSymbols_en_FJ', 'goog.labs.i18n.ListFormatSymbols_en_FK', 'goog.labs.i18n.ListFormatSymbols_en_FM', 'goog.labs.i18n.ListFormatSymbols_en_GD', 'goog.labs.i18n.ListFormatSymbols_en_GG', 'goog.labs.i18n.ListFormatSymbols_en_GH', 'goog.labs.i18n.ListFormatSymbols_en_GI', 'goog.labs.i18n.ListFormatSymbols_en_GM', 'goog.labs.i18n.ListFormatSymbols_en_GU', 'goog.labs.i18n.ListFormatSymbols_en_GY', 'goog.labs.i18n.ListFormatSymbols_en_HK', 'goog.labs.i18n.ListFormatSymbols_en_IL', 'goog.labs.i18n.ListFormatSymbols_en_IM', 'goog.labs.i18n.ListFormatSymbols_en_IO', 'goog.labs.i18n.ListFormatSymbols_en_JE', 'goog.labs.i18n.ListFormatSymbols_en_JM', 'goog.labs.i18n.ListFormatSymbols_en_KE', 'goog.labs.i18n.ListFormatSymbols_en_KI', 'goog.labs.i18n.ListFormatSymbols_en_KN', 'goog.labs.i18n.ListFormatSymbols_en_KY', 'goog.labs.i18n.ListFormatSymbols_en_LC', 'goog.labs.i18n.ListFormatSymbols_en_LR', 'goog.labs.i18n.ListFormatSymbols_en_LS', 'goog.labs.i18n.ListFormatSymbols_en_MG', 'goog.labs.i18n.ListFormatSymbols_en_MH', 'goog.labs.i18n.ListFormatSymbols_en_MO', 'goog.labs.i18n.ListFormatSymbols_en_MP', 'goog.labs.i18n.ListFormatSymbols_en_MS', 'goog.labs.i18n.ListFormatSymbols_en_MT', 'goog.labs.i18n.ListFormatSymbols_en_MU', 'goog.labs.i18n.ListFormatSymbols_en_MW', 'goog.labs.i18n.ListFormatSymbols_en_MY', 'goog.labs.i18n.ListFormatSymbols_en_NA', 'goog.labs.i18n.ListFormatSymbols_en_NF', 'goog.labs.i18n.ListFormatSymbols_en_NG', 'goog.labs.i18n.ListFormatSymbols_en_NL', 'goog.labs.i18n.ListFormatSymbols_en_NR', 'goog.labs.i18n.ListFormatSymbols_en_NU', 'goog.labs.i18n.ListFormatSymbols_en_NZ', 'goog.labs.i18n.ListFormatSymbols_en_PG', 'goog.labs.i18n.ListFormatSymbols_en_PH', 'goog.labs.i18n.ListFormatSymbols_en_PK', 'goog.labs.i18n.ListFormatSymbols_en_PN', 'goog.labs.i18n.ListFormatSymbols_en_PR', 'goog.labs.i18n.ListFormatSymbols_en_PW', 'goog.labs.i18n.ListFormatSymbols_en_RW', 'goog.labs.i18n.ListFormatSymbols_en_SB', 'goog.labs.i18n.ListFormatSymbols_en_SC', 'goog.labs.i18n.ListFormatSymbols_en_SD', 'goog.labs.i18n.ListFormatSymbols_en_SE', 'goog.labs.i18n.ListFormatSymbols_en_SH', 'goog.labs.i18n.ListFormatSymbols_en_SI', 'goog.labs.i18n.ListFormatSymbols_en_SL', 'goog.labs.i18n.ListFormatSymbols_en_SS', 'goog.labs.i18n.ListFormatSymbols_en_SX', 'goog.labs.i18n.ListFormatSymbols_en_SZ', 'goog.labs.i18n.ListFormatSymbols_en_TC', 'goog.labs.i18n.ListFormatSymbols_en_TK', 'goog.labs.i18n.ListFormatSymbols_en_TO', 'goog.labs.i18n.ListFormatSymbols_en_TT', 'goog.labs.i18n.ListFormatSymbols_en_TV', 'goog.labs.i18n.ListFormatSymbols_en_TZ', 'goog.labs.i18n.ListFormatSymbols_en_UG', 'goog.labs.i18n.ListFormatSymbols_en_UM', 'goog.labs.i18n.ListFormatSymbols_en_US_POSIX', 'goog.labs.i18n.ListFormatSymbols_en_VC', 'goog.labs.i18n.ListFormatSymbols_en_VG', 'goog.labs.i18n.ListFormatSymbols_en_VI', 'goog.labs.i18n.ListFormatSymbols_en_VU', 'goog.labs.i18n.ListFormatSymbols_en_WS', 'goog.labs.i18n.ListFormatSymbols_en_XA', 'goog.labs.i18n.ListFormatSymbols_en_ZM', 'goog.labs.i18n.ListFormatSymbols_en_ZW', 'goog.labs.i18n.ListFormatSymbols_eo', 'goog.labs.i18n.ListFormatSymbols_eo_001', 'goog.labs.i18n.ListFormatSymbols_es_AR', 'goog.labs.i18n.ListFormatSymbols_es_BO', 'goog.labs.i18n.ListFormatSymbols_es_BR', 'goog.labs.i18n.ListFormatSymbols_es_BZ', 'goog.labs.i18n.ListFormatSymbols_es_CL', 'goog.labs.i18n.ListFormatSymbols_es_CO', 'goog.labs.i18n.ListFormatSymbols_es_CR', 'goog.labs.i18n.ListFormatSymbols_es_CU', 'goog.labs.i18n.ListFormatSymbols_es_DO', 'goog.labs.i18n.ListFormatSymbols_es_EA', 'goog.labs.i18n.ListFormatSymbols_es_EC', 'goog.labs.i18n.ListFormatSymbols_es_GQ', 'goog.labs.i18n.ListFormatSymbols_es_GT', 'goog.labs.i18n.ListFormatSymbols_es_HN', 'goog.labs.i18n.ListFormatSymbols_es_IC', 'goog.labs.i18n.ListFormatSymbols_es_NI', 'goog.labs.i18n.ListFormatSymbols_es_PA', 'goog.labs.i18n.ListFormatSymbols_es_PE', 'goog.labs.i18n.ListFormatSymbols_es_PH', 'goog.labs.i18n.ListFormatSymbols_es_PR', 'goog.labs.i18n.ListFormatSymbols_es_PY', 'goog.labs.i18n.ListFormatSymbols_es_SV', 'goog.labs.i18n.ListFormatSymbols_es_UY', 'goog.labs.i18n.ListFormatSymbols_es_VE', 'goog.labs.i18n.ListFormatSymbols_et_EE', 'goog.labs.i18n.ListFormatSymbols_eu_ES', 'goog.labs.i18n.ListFormatSymbols_ewo', 'goog.labs.i18n.ListFormatSymbols_ewo_CM', 'goog.labs.i18n.ListFormatSymbols_fa_AF', 'goog.labs.i18n.ListFormatSymbols_fa_IR', 'goog.labs.i18n.ListFormatSymbols_ff', 'goog.labs.i18n.ListFormatSymbols_ff_Latn', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_BF', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_CM', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_GH', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_GM', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_GN', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_GW', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_LR', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_MR', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_NE', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_NG', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_SL', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_SN', 'goog.labs.i18n.ListFormatSymbols_fi_FI', 'goog.labs.i18n.ListFormatSymbols_fil_PH', 'goog.labs.i18n.ListFormatSymbols_fo', 'goog.labs.i18n.ListFormatSymbols_fo_DK', 'goog.labs.i18n.ListFormatSymbols_fo_FO', 'goog.labs.i18n.ListFormatSymbols_fr_BE', 'goog.labs.i18n.ListFormatSymbols_fr_BF', 'goog.labs.i18n.ListFormatSymbols_fr_BI', 'goog.labs.i18n.ListFormatSymbols_fr_BJ', 'goog.labs.i18n.ListFormatSymbols_fr_BL', 'goog.labs.i18n.ListFormatSymbols_fr_CD', 'goog.labs.i18n.ListFormatSymbols_fr_CF', 'goog.labs.i18n.ListFormatSymbols_fr_CG', 'goog.labs.i18n.ListFormatSymbols_fr_CH', 'goog.labs.i18n.ListFormatSymbols_fr_CI', 'goog.labs.i18n.ListFormatSymbols_fr_CM', 'goog.labs.i18n.ListFormatSymbols_fr_DJ', 'goog.labs.i18n.ListFormatSymbols_fr_DZ', 'goog.labs.i18n.ListFormatSymbols_fr_FR', 'goog.labs.i18n.ListFormatSymbols_fr_GA', 'goog.labs.i18n.ListFormatSymbols_fr_GF', 'goog.labs.i18n.ListFormatSymbols_fr_GN', 'goog.labs.i18n.ListFormatSymbols_fr_GP', 'goog.labs.i18n.ListFormatSymbols_fr_GQ', 'goog.labs.i18n.ListFormatSymbols_fr_HT', 'goog.labs.i18n.ListFormatSymbols_fr_KM', 'goog.labs.i18n.ListFormatSymbols_fr_LU', 'goog.labs.i18n.ListFormatSymbols_fr_MA', 'goog.labs.i18n.ListFormatSymbols_fr_MC', 'goog.labs.i18n.ListFormatSymbols_fr_MF', 'goog.labs.i18n.ListFormatSymbols_fr_MG', 'goog.labs.i18n.ListFormatSymbols_fr_ML', 'goog.labs.i18n.ListFormatSymbols_fr_MQ', 'goog.labs.i18n.ListFormatSymbols_fr_MR', 'goog.labs.i18n.ListFormatSymbols_fr_MU', 'goog.labs.i18n.ListFormatSymbols_fr_NC', 'goog.labs.i18n.ListFormatSymbols_fr_NE', 'goog.labs.i18n.ListFormatSymbols_fr_PF', 'goog.labs.i18n.ListFormatSymbols_fr_PM', 'goog.labs.i18n.ListFormatSymbols_fr_RE', 'goog.labs.i18n.ListFormatSymbols_fr_RW', 'goog.labs.i18n.ListFormatSymbols_fr_SC', 'goog.labs.i18n.ListFormatSymbols_fr_SN', 'goog.labs.i18n.ListFormatSymbols_fr_SY', 'goog.labs.i18n.ListFormatSymbols_fr_TD', 'goog.labs.i18n.ListFormatSymbols_fr_TG', 'goog.labs.i18n.ListFormatSymbols_fr_TN', 'goog.labs.i18n.ListFormatSymbols_fr_VU', 'goog.labs.i18n.ListFormatSymbols_fr_WF', 'goog.labs.i18n.ListFormatSymbols_fr_YT', 'goog.labs.i18n.ListFormatSymbols_fur', 'goog.labs.i18n.ListFormatSymbols_fur_IT', 'goog.labs.i18n.ListFormatSymbols_fy', 'goog.labs.i18n.ListFormatSymbols_fy_NL', 'goog.labs.i18n.ListFormatSymbols_ga_IE', 'goog.labs.i18n.ListFormatSymbols_gd', 'goog.labs.i18n.ListFormatSymbols_gd_GB', 'goog.labs.i18n.ListFormatSymbols_gl_ES', 'goog.labs.i18n.ListFormatSymbols_gsw_CH', 'goog.labs.i18n.ListFormatSymbols_gsw_FR', 'goog.labs.i18n.ListFormatSymbols_gsw_LI', 'goog.labs.i18n.ListFormatSymbols_gu_IN', 'goog.labs.i18n.ListFormatSymbols_guz', 'goog.labs.i18n.ListFormatSymbols_guz_KE', 'goog.labs.i18n.ListFormatSymbols_gv', 'goog.labs.i18n.ListFormatSymbols_gv_IM', 'goog.labs.i18n.ListFormatSymbols_ha', 'goog.labs.i18n.ListFormatSymbols_ha_GH', 'goog.labs.i18n.ListFormatSymbols_ha_NE', 'goog.labs.i18n.ListFormatSymbols_ha_NG', 'goog.labs.i18n.ListFormatSymbols_haw_US', 'goog.labs.i18n.ListFormatSymbols_he_IL', 'goog.labs.i18n.ListFormatSymbols_hi_IN', 'goog.labs.i18n.ListFormatSymbols_hr_BA', 'goog.labs.i18n.ListFormatSymbols_hr_HR', 'goog.labs.i18n.ListFormatSymbols_hsb', 'goog.labs.i18n.ListFormatSymbols_hsb_DE', 'goog.labs.i18n.ListFormatSymbols_hu_HU', 'goog.labs.i18n.ListFormatSymbols_hy_AM', 'goog.labs.i18n.ListFormatSymbols_ia', 'goog.labs.i18n.ListFormatSymbols_ia_001', 'goog.labs.i18n.ListFormatSymbols_id_ID', 'goog.labs.i18n.ListFormatSymbols_ig', 'goog.labs.i18n.ListFormatSymbols_ig_NG', 'goog.labs.i18n.ListFormatSymbols_ii', 'goog.labs.i18n.ListFormatSymbols_ii_CN', 'goog.labs.i18n.ListFormatSymbols_is_IS', 'goog.labs.i18n.ListFormatSymbols_it_CH', 'goog.labs.i18n.ListFormatSymbols_it_IT', 'goog.labs.i18n.ListFormatSymbols_it_SM', 'goog.labs.i18n.ListFormatSymbols_it_VA', 'goog.labs.i18n.ListFormatSymbols_ja_JP', 'goog.labs.i18n.ListFormatSymbols_jgo', 'goog.labs.i18n.ListFormatSymbols_jgo_CM', 'goog.labs.i18n.ListFormatSymbols_jmc', 'goog.labs.i18n.ListFormatSymbols_jmc_TZ', 'goog.labs.i18n.ListFormatSymbols_jv', 'goog.labs.i18n.ListFormatSymbols_jv_ID', 'goog.labs.i18n.ListFormatSymbols_ka_GE', 'goog.labs.i18n.ListFormatSymbols_kab', 'goog.labs.i18n.ListFormatSymbols_kab_DZ', 'goog.labs.i18n.ListFormatSymbols_kam', 'goog.labs.i18n.ListFormatSymbols_kam_KE', 'goog.labs.i18n.ListFormatSymbols_kde', 'goog.labs.i18n.ListFormatSymbols_kde_TZ', 'goog.labs.i18n.ListFormatSymbols_kea', 'goog.labs.i18n.ListFormatSymbols_kea_CV', 'goog.labs.i18n.ListFormatSymbols_khq', 'goog.labs.i18n.ListFormatSymbols_khq_ML', 'goog.labs.i18n.ListFormatSymbols_ki', 'goog.labs.i18n.ListFormatSymbols_ki_KE', 'goog.labs.i18n.ListFormatSymbols_kk_KZ', 'goog.labs.i18n.ListFormatSymbols_kkj', 'goog.labs.i18n.ListFormatSymbols_kkj_CM', 'goog.labs.i18n.ListFormatSymbols_kl', 'goog.labs.i18n.ListFormatSymbols_kl_GL', 'goog.labs.i18n.ListFormatSymbols_kln', 'goog.labs.i18n.ListFormatSymbols_kln_KE', 'goog.labs.i18n.ListFormatSymbols_km_KH', 'goog.labs.i18n.ListFormatSymbols_kn_IN', 'goog.labs.i18n.ListFormatSymbols_ko_KP', 'goog.labs.i18n.ListFormatSymbols_ko_KR', 'goog.labs.i18n.ListFormatSymbols_kok', 'goog.labs.i18n.ListFormatSymbols_kok_IN', 'goog.labs.i18n.ListFormatSymbols_ks', 'goog.labs.i18n.ListFormatSymbols_ks_IN', 'goog.labs.i18n.ListFormatSymbols_ksb', 'goog.labs.i18n.ListFormatSymbols_ksb_TZ', 'goog.labs.i18n.ListFormatSymbols_ksf', 'goog.labs.i18n.ListFormatSymbols_ksf_CM', 'goog.labs.i18n.ListFormatSymbols_ksh', 'goog.labs.i18n.ListFormatSymbols_ksh_DE', 'goog.labs.i18n.ListFormatSymbols_ku', 'goog.labs.i18n.ListFormatSymbols_ku_TR', 'goog.labs.i18n.ListFormatSymbols_kw', 'goog.labs.i18n.ListFormatSymbols_kw_GB', 'goog.labs.i18n.ListFormatSymbols_ky_KG', 'goog.labs.i18n.ListFormatSymbols_lag', 'goog.labs.i18n.ListFormatSymbols_lag_TZ', 'goog.labs.i18n.ListFormatSymbols_lb', 'goog.labs.i18n.ListFormatSymbols_lb_LU', 'goog.labs.i18n.ListFormatSymbols_lg', 'goog.labs.i18n.ListFormatSymbols_lg_UG', 'goog.labs.i18n.ListFormatSymbols_lkt', 'goog.labs.i18n.ListFormatSymbols_lkt_US', 'goog.labs.i18n.ListFormatSymbols_ln_AO', 'goog.labs.i18n.ListFormatSymbols_ln_CD', 'goog.labs.i18n.ListFormatSymbols_ln_CF', 'goog.labs.i18n.ListFormatSymbols_ln_CG', 'goog.labs.i18n.ListFormatSymbols_lo_LA', 'goog.labs.i18n.ListFormatSymbols_lrc', 'goog.labs.i18n.ListFormatSymbols_lrc_IQ', 'goog.labs.i18n.ListFormatSymbols_lrc_IR', 'goog.labs.i18n.ListFormatSymbols_lt_LT', 'goog.labs.i18n.ListFormatSymbols_lu', 'goog.labs.i18n.ListFormatSymbols_lu_CD', 'goog.labs.i18n.ListFormatSymbols_luo', 'goog.labs.i18n.ListFormatSymbols_luo_KE', 'goog.labs.i18n.ListFormatSymbols_luy', 'goog.labs.i18n.ListFormatSymbols_luy_KE', 'goog.labs.i18n.ListFormatSymbols_lv_LV', 'goog.labs.i18n.ListFormatSymbols_mas', 'goog.labs.i18n.ListFormatSymbols_mas_KE', 'goog.labs.i18n.ListFormatSymbols_mas_TZ', 'goog.labs.i18n.ListFormatSymbols_mer', 'goog.labs.i18n.ListFormatSymbols_mer_KE', 'goog.labs.i18n.ListFormatSymbols_mfe', 'goog.labs.i18n.ListFormatSymbols_mfe_MU', 'goog.labs.i18n.ListFormatSymbols_mg', 'goog.labs.i18n.ListFormatSymbols_mg_MG', 'goog.labs.i18n.ListFormatSymbols_mgh', 'goog.labs.i18n.ListFormatSymbols_mgh_MZ', 'goog.labs.i18n.ListFormatSymbols_mgo', 'goog.labs.i18n.ListFormatSymbols_mgo_CM', 'goog.labs.i18n.ListFormatSymbols_mi', 'goog.labs.i18n.ListFormatSymbols_mi_NZ', 'goog.labs.i18n.ListFormatSymbols_mk_MK', 'goog.labs.i18n.ListFormatSymbols_ml_IN', 'goog.labs.i18n.ListFormatSymbols_mn_MN', 'goog.labs.i18n.ListFormatSymbols_mr_IN', 'goog.labs.i18n.ListFormatSymbols_ms_BN', 'goog.labs.i18n.ListFormatSymbols_ms_MY', 'goog.labs.i18n.ListFormatSymbols_ms_SG', 'goog.labs.i18n.ListFormatSymbols_mt_MT', 'goog.labs.i18n.ListFormatSymbols_mua', 'goog.labs.i18n.ListFormatSymbols_mua_CM', 'goog.labs.i18n.ListFormatSymbols_my_MM', 'goog.labs.i18n.ListFormatSymbols_mzn', 'goog.labs.i18n.ListFormatSymbols_mzn_IR', 'goog.labs.i18n.ListFormatSymbols_naq', 'goog.labs.i18n.ListFormatSymbols_naq_NA', 'goog.labs.i18n.ListFormatSymbols_nb_NO', 'goog.labs.i18n.ListFormatSymbols_nb_SJ', 'goog.labs.i18n.ListFormatSymbols_nd', 'goog.labs.i18n.ListFormatSymbols_nd_ZW', 'goog.labs.i18n.ListFormatSymbols_nds', 'goog.labs.i18n.ListFormatSymbols_nds_DE', 'goog.labs.i18n.ListFormatSymbols_nds_NL', 'goog.labs.i18n.ListFormatSymbols_ne_IN', 'goog.labs.i18n.ListFormatSymbols_ne_NP', 'goog.labs.i18n.ListFormatSymbols_nl_AW', 'goog.labs.i18n.ListFormatSymbols_nl_BE', 'goog.labs.i18n.ListFormatSymbols_nl_BQ', 'goog.labs.i18n.ListFormatSymbols_nl_CW', 'goog.labs.i18n.ListFormatSymbols_nl_NL', 'goog.labs.i18n.ListFormatSymbols_nl_SR', 'goog.labs.i18n.ListFormatSymbols_nl_SX', 'goog.labs.i18n.ListFormatSymbols_nmg', 'goog.labs.i18n.ListFormatSymbols_nmg_CM', 'goog.labs.i18n.ListFormatSymbols_nn', 'goog.labs.i18n.ListFormatSymbols_nn_NO', 'goog.labs.i18n.ListFormatSymbols_nnh', 'goog.labs.i18n.ListFormatSymbols_nnh_CM', 'goog.labs.i18n.ListFormatSymbols_nus', 'goog.labs.i18n.ListFormatSymbols_nus_SS', 'goog.labs.i18n.ListFormatSymbols_nyn', 'goog.labs.i18n.ListFormatSymbols_nyn_UG', 'goog.labs.i18n.ListFormatSymbols_om', 'goog.labs.i18n.ListFormatSymbols_om_ET', 'goog.labs.i18n.ListFormatSymbols_om_KE', 'goog.labs.i18n.ListFormatSymbols_or_IN', 'goog.labs.i18n.ListFormatSymbols_os', 'goog.labs.i18n.ListFormatSymbols_os_GE', 'goog.labs.i18n.ListFormatSymbols_os_RU', 'goog.labs.i18n.ListFormatSymbols_pa_Arab', 'goog.labs.i18n.ListFormatSymbols_pa_Arab_PK', 'goog.labs.i18n.ListFormatSymbols_pa_Guru', 'goog.labs.i18n.ListFormatSymbols_pa_Guru_IN', 'goog.labs.i18n.ListFormatSymbols_pl_PL', 'goog.labs.i18n.ListFormatSymbols_ps', 'goog.labs.i18n.ListFormatSymbols_ps_AF', 'goog.labs.i18n.ListFormatSymbols_ps_PK', 'goog.labs.i18n.ListFormatSymbols_pt_AO', 'goog.labs.i18n.ListFormatSymbols_pt_CH', 'goog.labs.i18n.ListFormatSymbols_pt_CV', 'goog.labs.i18n.ListFormatSymbols_pt_GQ', 'goog.labs.i18n.ListFormatSymbols_pt_GW', 'goog.labs.i18n.ListFormatSymbols_pt_LU', 'goog.labs.i18n.ListFormatSymbols_pt_MO', 'goog.labs.i18n.ListFormatSymbols_pt_MZ', 'goog.labs.i18n.ListFormatSymbols_pt_ST', 'goog.labs.i18n.ListFormatSymbols_pt_TL', 'goog.labs.i18n.ListFormatSymbols_qu', 'goog.labs.i18n.ListFormatSymbols_qu_BO', 'goog.labs.i18n.ListFormatSymbols_qu_EC', 'goog.labs.i18n.ListFormatSymbols_qu_PE', 'goog.labs.i18n.ListFormatSymbols_rm', 'goog.labs.i18n.ListFormatSymbols_rm_CH', 'goog.labs.i18n.ListFormatSymbols_rn', 'goog.labs.i18n.ListFormatSymbols_rn_BI', 'goog.labs.i18n.ListFormatSymbols_ro_MD', 'goog.labs.i18n.ListFormatSymbols_ro_RO', 'goog.labs.i18n.ListFormatSymbols_rof', 'goog.labs.i18n.ListFormatSymbols_rof_TZ', 'goog.labs.i18n.ListFormatSymbols_ru_BY', 'goog.labs.i18n.ListFormatSymbols_ru_KG', 'goog.labs.i18n.ListFormatSymbols_ru_KZ', 'goog.labs.i18n.ListFormatSymbols_ru_MD', 'goog.labs.i18n.ListFormatSymbols_ru_RU', 'goog.labs.i18n.ListFormatSymbols_ru_UA', 'goog.labs.i18n.ListFormatSymbols_rw', 'goog.labs.i18n.ListFormatSymbols_rw_RW', 'goog.labs.i18n.ListFormatSymbols_rwk', 'goog.labs.i18n.ListFormatSymbols_rwk_TZ', 'goog.labs.i18n.ListFormatSymbols_sah', 'goog.labs.i18n.ListFormatSymbols_sah_RU', 'goog.labs.i18n.ListFormatSymbols_saq', 'goog.labs.i18n.ListFormatSymbols_saq_KE', 'goog.labs.i18n.ListFormatSymbols_sbp', 'goog.labs.i18n.ListFormatSymbols_sbp_TZ', 'goog.labs.i18n.ListFormatSymbols_sd', 'goog.labs.i18n.ListFormatSymbols_sd_PK', 'goog.labs.i18n.ListFormatSymbols_se', 'goog.labs.i18n.ListFormatSymbols_se_FI', 'goog.labs.i18n.ListFormatSymbols_se_NO', 'goog.labs.i18n.ListFormatSymbols_se_SE', 'goog.labs.i18n.ListFormatSymbols_seh', 'goog.labs.i18n.ListFormatSymbols_seh_MZ', 'goog.labs.i18n.ListFormatSymbols_ses', 'goog.labs.i18n.ListFormatSymbols_ses_ML', 'goog.labs.i18n.ListFormatSymbols_sg', 'goog.labs.i18n.ListFormatSymbols_sg_CF', 'goog.labs.i18n.ListFormatSymbols_shi', 'goog.labs.i18n.ListFormatSymbols_shi_Latn', 'goog.labs.i18n.ListFormatSymbols_shi_Latn_MA', 'goog.labs.i18n.ListFormatSymbols_shi_Tfng', 'goog.labs.i18n.ListFormatSymbols_shi_Tfng_MA', 'goog.labs.i18n.ListFormatSymbols_si_LK', 'goog.labs.i18n.ListFormatSymbols_sk_SK', 'goog.labs.i18n.ListFormatSymbols_sl_SI', 'goog.labs.i18n.ListFormatSymbols_smn', 'goog.labs.i18n.ListFormatSymbols_smn_FI', 'goog.labs.i18n.ListFormatSymbols_sn', 'goog.labs.i18n.ListFormatSymbols_sn_ZW', 'goog.labs.i18n.ListFormatSymbols_so', 'goog.labs.i18n.ListFormatSymbols_so_DJ', 'goog.labs.i18n.ListFormatSymbols_so_ET', 'goog.labs.i18n.ListFormatSymbols_so_KE', 'goog.labs.i18n.ListFormatSymbols_so_SO', 'goog.labs.i18n.ListFormatSymbols_sq_AL', 'goog.labs.i18n.ListFormatSymbols_sq_MK', 'goog.labs.i18n.ListFormatSymbols_sq_XK', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl_BA', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl_ME', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl_RS', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl_XK', 'goog.labs.i18n.ListFormatSymbols_sr_Latn_BA', 'goog.labs.i18n.ListFormatSymbols_sr_Latn_ME', 'goog.labs.i18n.ListFormatSymbols_sr_Latn_RS', 'goog.labs.i18n.ListFormatSymbols_sr_Latn_XK', 'goog.labs.i18n.ListFormatSymbols_sv_AX', 'goog.labs.i18n.ListFormatSymbols_sv_FI', 'goog.labs.i18n.ListFormatSymbols_sv_SE', 'goog.labs.i18n.ListFormatSymbols_sw_CD', 'goog.labs.i18n.ListFormatSymbols_sw_KE', 'goog.labs.i18n.ListFormatSymbols_sw_TZ', 'goog.labs.i18n.ListFormatSymbols_sw_UG', 'goog.labs.i18n.ListFormatSymbols_ta_IN', 'goog.labs.i18n.ListFormatSymbols_ta_LK', 'goog.labs.i18n.ListFormatSymbols_ta_MY', 'goog.labs.i18n.ListFormatSymbols_ta_SG', 'goog.labs.i18n.ListFormatSymbols_te_IN', 'goog.labs.i18n.ListFormatSymbols_teo', 'goog.labs.i18n.ListFormatSymbols_teo_KE', 'goog.labs.i18n.ListFormatSymbols_teo_UG', 'goog.labs.i18n.ListFormatSymbols_tg', 'goog.labs.i18n.ListFormatSymbols_tg_TJ', 'goog.labs.i18n.ListFormatSymbols_th_TH', 'goog.labs.i18n.ListFormatSymbols_ti', 'goog.labs.i18n.ListFormatSymbols_ti_ER', 'goog.labs.i18n.ListFormatSymbols_ti_ET', 'goog.labs.i18n.ListFormatSymbols_tk', 'goog.labs.i18n.ListFormatSymbols_tk_TM', 'goog.labs.i18n.ListFormatSymbols_to', 'goog.labs.i18n.ListFormatSymbols_to_TO', 'goog.labs.i18n.ListFormatSymbols_tr_CY', 'goog.labs.i18n.ListFormatSymbols_tr_TR', 'goog.labs.i18n.ListFormatSymbols_tt', 'goog.labs.i18n.ListFormatSymbols_tt_RU', 'goog.labs.i18n.ListFormatSymbols_twq', 'goog.labs.i18n.ListFormatSymbols_twq_NE', 'goog.labs.i18n.ListFormatSymbols_tzm', 'goog.labs.i18n.ListFormatSymbols_tzm_MA', 'goog.labs.i18n.ListFormatSymbols_ug', 'goog.labs.i18n.ListFormatSymbols_ug_CN', 'goog.labs.i18n.ListFormatSymbols_uk_UA', 'goog.labs.i18n.ListFormatSymbols_ur_IN', 'goog.labs.i18n.ListFormatSymbols_ur_PK', 'goog.labs.i18n.ListFormatSymbols_uz_Arab', 'goog.labs.i18n.ListFormatSymbols_uz_Arab_AF', 'goog.labs.i18n.ListFormatSymbols_uz_Cyrl', 'goog.labs.i18n.ListFormatSymbols_uz_Cyrl_UZ', 'goog.labs.i18n.ListFormatSymbols_uz_Latn', 'goog.labs.i18n.ListFormatSymbols_uz_Latn_UZ', 'goog.labs.i18n.ListFormatSymbols_vai', 'goog.labs.i18n.ListFormatSymbols_vai_Latn', 'goog.labs.i18n.ListFormatSymbols_vai_Latn_LR', 'goog.labs.i18n.ListFormatSymbols_vai_Vaii', 'goog.labs.i18n.ListFormatSymbols_vai_Vaii_LR', 'goog.labs.i18n.ListFormatSymbols_vi_VN', 'goog.labs.i18n.ListFormatSymbols_vun', 'goog.labs.i18n.ListFormatSymbols_vun_TZ', 'goog.labs.i18n.ListFormatSymbols_wae', 'goog.labs.i18n.ListFormatSymbols_wae_CH', 'goog.labs.i18n.ListFormatSymbols_wo', 'goog.labs.i18n.ListFormatSymbols_wo_SN', 'goog.labs.i18n.ListFormatSymbols_xh', 'goog.labs.i18n.ListFormatSymbols_xh_ZA', 'goog.labs.i18n.ListFormatSymbols_xog', 'goog.labs.i18n.ListFormatSymbols_xog_UG', 'goog.labs.i18n.ListFormatSymbols_yav', 'goog.labs.i18n.ListFormatSymbols_yav_CM', 'goog.labs.i18n.ListFormatSymbols_yi', 'goog.labs.i18n.ListFormatSymbols_yi_001', 'goog.labs.i18n.ListFormatSymbols_yo', 'goog.labs.i18n.ListFormatSymbols_yo_BJ', 'goog.labs.i18n.ListFormatSymbols_yo_NG', 'goog.labs.i18n.ListFormatSymbols_yue', 'goog.labs.i18n.ListFormatSymbols_yue_Hans', 'goog.labs.i18n.ListFormatSymbols_yue_Hans_CN', 'goog.labs.i18n.ListFormatSymbols_yue_Hant', 'goog.labs.i18n.ListFormatSymbols_yue_Hant_HK', 'goog.labs.i18n.ListFormatSymbols_zgh', 'goog.labs.i18n.ListFormatSymbols_zgh_MA', 'goog.labs.i18n.ListFormatSymbols_zh_Hans', 'goog.labs.i18n.ListFormatSymbols_zh_Hans_CN', 'goog.labs.i18n.ListFormatSymbols_zh_Hans_HK', 'goog.labs.i18n.ListFormatSymbols_zh_Hans_MO', 'goog.labs.i18n.ListFormatSymbols_zh_Hans_SG', 'goog.labs.i18n.ListFormatSymbols_zh_Hant', 'goog.labs.i18n.ListFormatSymbols_zh_Hant_HK', 'goog.labs.i18n.ListFormatSymbols_zh_Hant_MO', 'goog.labs.i18n.ListFormatSymbols_zh_Hant_TW', 'goog.labs.i18n.ListFormatSymbols_zu_ZA'], ['goog.labs.i18n.ListFormatSymbols'], {});
goog.addDependency('labs/mock/mock.js', ['goog.labs.mock', 'goog.labs.mock.TimeoutError', 'goog.labs.mock.VerificationError'], ['goog.array', 'goog.asserts', 'goog.debug', 'goog.debug.Error', 'goog.functions', 'goog.labs.mock.timeout', 'goog.labs.mock.timeout.TimeoutMode', 'goog.labs.mock.verification', 'goog.labs.mock.verification.BaseVerificationMode', 'goog.labs.mock.verification.VerificationMode', 'goog.object'], {'lang': 'es6'});
goog.addDependency('labs/mock/mock_test.js', ['goog.labs.mockTest'], ['goog.array', 'goog.labs.mock', 'goog.labs.mock.TimeoutError', 'goog.labs.mock.VerificationError', 'goog.labs.mock.timeout', 'goog.labs.mock.verification', 'goog.labs.testing.AnythingMatcher', 'goog.labs.testing.GreaterThanMatcher', 'goog.string', 'goog.testing.jsunit'], {'lang': 'es8'});
goog.addDependency('labs/mock/timeoutmode.js', ['goog.labs.mock.timeout', 'goog.labs.mock.timeout.TimeoutMode'], [], {'lang': 'es6'});
goog.addDependency('labs/mock/verificationmode.js', ['goog.labs.mock.verification', 'goog.labs.mock.verification.BaseVerificationMode', 'goog.labs.mock.verification.VerificationMode'], [], {'lang': 'es6'});
goog.addDependency('labs/mock/verificationmode_test.js', ['goog.labs.mock.VerificationModeTest'], ['goog.labs.mock.verification', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/image.js', ['goog.labs.net.image'], ['goog.Promise', 'goog.dom.safe', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.html.SafeUrl', 'goog.net.EventType', 'goog.userAgent'], {});
goog.addDependency('labs/net/image_test.js', ['goog.labs.net.imageTest'], ['goog.labs.net.image', 'goog.string', 'goog.testing.TestCase', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel.js', ['goog.net.WebChannel'], ['goog.events', 'goog.events.Event', 'goog.events.Listenable', 'goog.net.XmlHttpFactory'], {});
goog.addDependency('labs/net/webchannel/basetestchannel.js', ['goog.labs.net.webChannel.BaseTestChannel'], ['goog.labs.net.webChannel.Channel', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.requestStats', 'goog.net.WebChannel'], {});
goog.addDependency('labs/net/webchannel/channel.js', ['goog.labs.net.webChannel.Channel'], [], {'lang': 'es6'});
goog.addDependency('labs/net/webchannel/channelrequest.js', ['goog.labs.net.webChannel.ChannelRequest'], ['goog.Timer', 'goog.async.Throttle', 'goog.events.EventHandler', 'goog.labs.net.webChannel.Channel', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.environment', 'goog.labs.net.webChannel.requestStats', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.WebChannel', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('labs/net/webchannel/channelrequest_test.js', ['goog.labs.net.webChannel.channelRequestTest'], ['goog.Uri', 'goog.functions', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.requestStats', 'goog.labs.net.webChannel.requestStats.ServerReachability', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.net.XhrIo', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/connectionstate.js', ['goog.labs.net.webChannel.ConnectionState'], [], {});
goog.addDependency('labs/net/webchannel/environment.js', ['goog.labs.net.webChannel.environment'], ['goog.userAgent'], {'module': 'goog'});
goog.addDependency('labs/net/webchannel/environment_test.js', ['goog.labs.net.webChannel.EnvironmentTest'], ['goog.labs.net.webChannel.environment', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/forwardchannelrequestpool.js', ['goog.labs.net.webChannel.ForwardChannelRequestPool'], ['goog.array', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.Wire', 'goog.string', 'goog.structs.Set'], {'module': 'goog'});
goog.addDependency('labs/net/webchannel/forwardchannelrequestpool_test.js', ['goog.labs.net.webChannel.ForwardChannelRequestPoolTest'], ['goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.ForwardChannelRequestPool', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/netutils.js', ['goog.labs.net.webChannel.netUtils'], ['goog.Uri', 'goog.labs.net.webChannel.WebChannelDebug'], {});
goog.addDependency('labs/net/webchannel/requeststats.js', ['goog.labs.net.webChannel.requestStats', 'goog.labs.net.webChannel.requestStats.Event', 'goog.labs.net.webChannel.requestStats.ServerReachability', 'goog.labs.net.webChannel.requestStats.ServerReachabilityEvent', 'goog.labs.net.webChannel.requestStats.Stat', 'goog.labs.net.webChannel.requestStats.StatEvent', 'goog.labs.net.webChannel.requestStats.TimingEvent'], ['goog.events.Event', 'goog.events.EventTarget'], {});
goog.addDependency('labs/net/webchannel/webchannelbase.js', ['goog.labs.net.webChannel.WebChannelBase'], ['goog.Uri', 'goog.array', 'goog.asserts', 'goog.async.run', 'goog.json', 'goog.labs.net.webChannel.BaseTestChannel', 'goog.labs.net.webChannel.Channel', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.ConnectionState', 'goog.labs.net.webChannel.ForwardChannelRequestPool', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.Wire', 'goog.labs.net.webChannel.WireV8', 'goog.labs.net.webChannel.netUtils', 'goog.labs.net.webChannel.requestStats', 'goog.net.WebChannel', 'goog.net.XhrIo', 'goog.net.XmlHttpFactory', 'goog.net.rpc.HttpCors', 'goog.object', 'goog.string', 'goog.structs'], {});
goog.addDependency('labs/net/webchannel/webchannelbase_test.js', ['goog.labs.net.webChannel.webChannelBaseTest'], ['goog.Timer', 'goog.array', 'goog.dom', 'goog.functions', 'goog.json', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.ForwardChannelRequestPool', 'goog.labs.net.webChannel.WebChannelBase', 'goog.labs.net.webChannel.WebChannelBaseTransport', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.Wire', 'goog.labs.net.webChannel.netUtils', 'goog.labs.net.webChannel.requestStats', 'goog.labs.net.webChannel.requestStats.Stat', 'goog.structs.Map', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/webchannelbasetransport.js', ['goog.labs.net.webChannel.WebChannelBaseTransport'], ['goog.asserts', 'goog.events.EventTarget', 'goog.json', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.WebChannelBase', 'goog.labs.net.webChannel.Wire', 'goog.log', 'goog.net.WebChannel', 'goog.net.WebChannelTransport', 'goog.object', 'goog.string', 'goog.string.path'], {});
goog.addDependency('labs/net/webchannel/webchannelbasetransport_test.js', ['goog.labs.net.webChannel.webChannelBaseTransportTest'], ['goog.events', 'goog.functions', 'goog.json', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.WebChannelBase', 'goog.labs.net.webChannel.WebChannelBaseTransport', 'goog.labs.net.webChannel.Wire', 'goog.net.WebChannel', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/webchanneldebug.js', ['goog.labs.net.webChannel.WebChannelDebug'], ['goog.json', 'goog.log'], {});
goog.addDependency('labs/net/webchannel/wire.js', ['goog.labs.net.webChannel.Wire'], [], {'lang': 'es6'});
goog.addDependency('labs/net/webchannel/wirev8.js', ['goog.labs.net.webChannel.WireV8'], ['goog.asserts', 'goog.json', 'goog.json.NativeJsonProcessor', 'goog.labs.net.webChannel.Wire', 'goog.structs'], {});
goog.addDependency('labs/net/webchannel/wirev8_test.js', ['goog.labs.net.webChannel.WireV8Test'], ['goog.labs.net.webChannel.WireV8', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchanneltransport.js', ['goog.net.WebChannelTransport'], [], {});
goog.addDependency('labs/net/webchanneltransportfactory.js', ['goog.net.createWebChannelTransport'], ['goog.functions', 'goog.labs.net.webChannel.WebChannelBaseTransport'], {});
goog.addDependency('labs/net/xhr.js', ['goog.labs.net.xhr', 'goog.labs.net.xhr.Error', 'goog.labs.net.xhr.HttpError', 'goog.labs.net.xhr.Options', 'goog.labs.net.xhr.PostData', 'goog.labs.net.xhr.ResponseType', 'goog.labs.net.xhr.TimeoutError'], ['goog.Promise', 'goog.asserts', 'goog.debug.Error', 'goog.net.HttpStatus', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.uri.utils', 'goog.userAgent'], {});
goog.addDependency('labs/net/xhr_test.js', ['goog.labs.net.xhrTest'], ['goog.Promise', 'goog.events', 'goog.events.EventType', 'goog.labs.net.xhr', 'goog.net.WrapperXmlHttpFactory', 'goog.net.XhrLike', 'goog.net.XmlHttp', 'goog.testing.MockClock', 'goog.testing.TestCase', 'goog.testing.jsunit', 'goog.userAgent'], {'lang': 'es6'});
goog.addDependency('labs/pubsub/broadcastpubsub.js', ['goog.labs.pubsub.BroadcastPubSub'], ['goog.Disposable', 'goog.Timer', 'goog.array', 'goog.async.run', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.log', 'goog.math', 'goog.pubsub.PubSub', 'goog.storage.Storage', 'goog.storage.mechanism.HTML5LocalStorage', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('labs/pubsub/broadcastpubsub_test.js', ['goog.labs.pubsub.BroadcastPubSubTest'], ['goog.array', 'goog.debug.Logger', 'goog.json', 'goog.labs.pubsub.BroadcastPubSub', 'goog.storage.Storage', 'goog.structs.Map', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/storage/boundedcollectablestorage.js', ['goog.labs.storage.BoundedCollectableStorage'], ['goog.array', 'goog.asserts', 'goog.iter', 'goog.storage.CollectableStorage', 'goog.storage.ErrorCode', 'goog.storage.ExpiringStorage'], {});
goog.addDependency('labs/storage/boundedcollectablestorage_test.js', ['goog.labs.storage.BoundedCollectableStorageTest'], ['goog.labs.storage.BoundedCollectableStorage', 'goog.storage.collectableStorageTester', 'goog.storage.storageTester', 'goog.testing.MockClock', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/structs/multimap.js', ['goog.labs.structs.Multimap'], ['goog.array', 'goog.object'], {'lang': 'es6'});
goog.addDependency('labs/structs/multimap_test.js', ['goog.labs.structs.MultimapTest'], ['goog.labs.structs.Multimap', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/style/pixeldensitymonitor.js', ['goog.labs.style.PixelDensityMonitor', 'goog.labs.style.PixelDensityMonitor.Density', 'goog.labs.style.PixelDensityMonitor.EventType'], ['goog.events', 'goog.events.EventTarget'], {});
goog.addDependency('labs/style/pixeldensitymonitor_test.js', ['goog.labs.style.PixelDensityMonitorTest'], ['goog.array', 'goog.dom.DomHelper', 'goog.events', 'goog.labs.style.PixelDensityMonitor', 'goog.testing.MockControl', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/assertthat.js', ['goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat'], ['goog.debug.Error'], {});
goog.addDependency('labs/testing/assertthat_test.js', ['goog.labs.testing.assertThatTest'], ['goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/decoratormatcher.js', ['goog.labs.testing.AnythingMatcher'], ['goog.labs.testing.Matcher'], {});
goog.addDependency('labs/testing/decoratormatcher_test.js', ['goog.labs.testing.decoratorMatcherTest'], ['goog.labs.testing.AnythingMatcher', 'goog.labs.testing.GreaterThanMatcher', 'goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/dictionarymatcher.js', ['goog.labs.testing.HasEntriesMatcher', 'goog.labs.testing.HasEntryMatcher', 'goog.labs.testing.HasKeyMatcher', 'goog.labs.testing.HasValueMatcher'], ['goog.asserts', 'goog.labs.testing.Matcher', 'goog.object'], {});
goog.addDependency('labs/testing/dictionarymatcher_test.js', ['goog.labs.testing.dictionaryMatcherTest'], ['goog.labs.testing.HasEntryMatcher', 'goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/environment.js', ['goog.labs.testing.Environment'], ['goog.Thenable', 'goog.array', 'goog.asserts', 'goog.debug.Console', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('labs/testing/environment_test.js', ['goog.labs.testing.environmentTest'], ['goog.asserts', 'goog.labs.testing.Environment', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('labs/testing/environment_usage_test.js', ['goog.labs.testing.environmentUsageTest'], ['goog.labs.testing.Environment', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/json_fuzzing.js', ['goog.labs.testing.JsonFuzzing'], ['goog.string', 'goog.testing.PseudoRandom'], {});
goog.addDependency('labs/testing/json_fuzzing_test.js', ['goog.labs.testing.JsonFuzzingTest'], ['goog.json', 'goog.labs.testing.JsonFuzzing', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/logicmatcher.js', ['goog.labs.testing.AllOfMatcher', 'goog.labs.testing.AnyOfMatcher', 'goog.labs.testing.IsNotMatcher', 'goog.labs.testing.logicMatchers'], ['goog.array', 'goog.labs.testing.Matcher'], {});
goog.addDependency('labs/testing/logicmatcher_test.js', ['goog.labs.testing.logicMatcherTest'], ['goog.labs.testing.AllOfMatcher', 'goog.labs.testing.GreaterThanMatcher', 'goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/matcher.js', ['goog.labs.testing.Matcher'], [], {'lang': 'es6'});
goog.addDependency('labs/testing/numbermatcher.js', ['goog.labs.testing.AnyNumberMatcher', 'goog.labs.testing.CloseToMatcher', 'goog.labs.testing.EqualToMatcher', 'goog.labs.testing.GreaterThanEqualToMatcher', 'goog.labs.testing.GreaterThanMatcher', 'goog.labs.testing.LessThanEqualToMatcher', 'goog.labs.testing.LessThanMatcher'], ['goog.asserts', 'goog.labs.testing.Matcher'], {});
goog.addDependency('labs/testing/numbermatcher_test.js', ['goog.labs.testing.numberMatcherTest'], ['goog.labs.testing.LessThanMatcher', 'goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/objectmatcher.js', ['goog.labs.testing.AnyObjectMatcher', 'goog.labs.testing.HasPropertyMatcher', 'goog.labs.testing.InstanceOfMatcher', 'goog.labs.testing.IsNullMatcher', 'goog.labs.testing.IsNullOrUndefinedMatcher', 'goog.labs.testing.IsUndefinedMatcher', 'goog.labs.testing.ObjectEqualsMatcher'], ['goog.labs.testing.Matcher'], {});
goog.addDependency('labs/testing/objectmatcher_test.js', ['goog.labs.testing.objectMatcherTest'], ['goog.labs.testing.MatcherError', 'goog.labs.testing.ObjectEqualsMatcher', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/stringmatcher.js', ['goog.labs.testing.AnyStringMatcher', 'goog.labs.testing.ContainsStringMatcher', 'goog.labs.testing.EndsWithMatcher', 'goog.labs.testing.EqualToIgnoringWhitespaceMatcher', 'goog.labs.testing.EqualsMatcher', 'goog.labs.testing.RegexMatcher', 'goog.labs.testing.StartsWithMatcher', 'goog.labs.testing.StringContainsInOrderMatcher'], ['goog.asserts', 'goog.labs.testing.Matcher', 'goog.string'], {});
goog.addDependency('labs/testing/stringmatcher_test.js', ['goog.labs.testing.stringMatcherTest'], ['goog.labs.testing.MatcherError', 'goog.labs.testing.StringContainsInOrderMatcher', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/browser.js', ['goog.labs.userAgent.browser'], ['goog.array', 'goog.labs.userAgent.util', 'goog.object', 'goog.string.internal'], {});
goog.addDependency('labs/useragent/browser_test.js', ['goog.labs.userAgent.browserTest'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/device.js', ['goog.labs.userAgent.device'], ['goog.labs.userAgent.util'], {});
goog.addDependency('labs/useragent/device_test.js', ['goog.labs.userAgent.deviceTest'], ['goog.labs.userAgent.device', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/engine.js', ['goog.labs.userAgent.engine'], ['goog.array', 'goog.labs.userAgent.util', 'goog.string'], {});
goog.addDependency('labs/useragent/engine_test.js', ['goog.labs.userAgent.engineTest'], ['goog.labs.userAgent.engine', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/extra.js', ['goog.labs.userAgent.extra'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.platform'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/extra_test.js', ['goog.labs.userAgent.extraTest'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.extra', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/platform.js', ['goog.labs.userAgent.platform'], ['goog.labs.userAgent.util', 'goog.string'], {});
goog.addDependency('labs/useragent/platform_test.js', ['goog.labs.userAgent.platformTest'], ['goog.labs.userAgent.platform', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/test_agents.js', ['goog.labs.userAgent.testAgents'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/util.js', ['goog.labs.userAgent.util'], ['goog.string.internal'], {});
goog.addDependency('labs/useragent/util_test.js', ['goog.labs.userAgent.utilTest'], ['goog.functions', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/verifier.js', ['goog.labs.useragent.verifier'], [], {'lang': 'es6'});
goog.addDependency('labs/useragent/verifier_test.js', ['goog.labs.useragent.verifierTest'], ['goog.labs.userAgent.browser', 'goog.labs.useragent.verifier', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('loader/abstractmodulemanager.js', ['goog.loader.AbstractModuleManager', 'goog.loader.AbstractModuleManager.CallbackType', 'goog.loader.AbstractModuleManager.FailureType'], ['goog.module.AbstractModuleLoader', 'goog.module.ModuleInfo', 'goog.module.ModuleLoadCallback'], {});
goog.addDependency('loader/activemodulemanager.js', ['goog.loader.activeModuleManager'], ['goog.asserts', 'goog.loader.AbstractModuleManager'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('locale/countries.js', ['goog.locale.countries'], [], {});
goog.addDependency('locale/countrylanguagenames_test.js', ['goog.locale.countryLanguageNamesTest'], ['goog.locale', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('locale/defaultlocalenameconstants.js', ['goog.locale.defaultLocaleNameConstants'], [], {});
goog.addDependency('locale/genericfontnames.js', ['goog.locale.genericFontNames'], [], {});
goog.addDependency('locale/genericfontnames_test.js', ['goog.locale.genericFontNamesTest'], ['goog.locale.genericFontNames', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('locale/genericfontnamesdata.js', ['goog.locale.genericFontNamesData'], [], {});
goog.addDependency('locale/locale.js', ['goog.locale'], ['goog.locale.nativeNameConstants'], {});
goog.addDependency('locale/nativenameconstants.js', ['goog.locale.nativeNameConstants'], [], {});
goog.addDependency('locale/scriptToLanguages.js', ['goog.locale.scriptToLanguages'], ['goog.locale'], {});
goog.addDependency('locale/timezonedetection.js', ['goog.locale.timeZoneDetection'], ['goog.locale.TimeZoneFingerprint'], {});
goog.addDependency('locale/timezonedetection_test.js', ['goog.locale.timeZoneDetectionTest'], ['goog.locale.timeZoneDetection', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('locale/timezonefingerprint.js', ['goog.locale.TimeZoneFingerprint'], [], {});
goog.addDependency('locale/timezonelist.js', ['goog.locale.TimeZoneList', 'goog.locale.getTimeZoneAllLongNames', 'goog.locale.getTimeZoneSelectedLongNames', 'goog.locale.getTimeZoneSelectedShortNames'], ['goog.locale'], {});
goog.addDependency('locale/timezonelist_test.js', ['goog.locale.TimeZoneListTest'], ['goog.locale', 'goog.locale.TimeZoneList', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('log/log.js', ['goog.log', 'goog.log.Level', 'goog.log.LogRecord', 'goog.log.Logger'], ['goog.debug', 'goog.debug.LogManager', 'goog.debug.LogRecord', 'goog.debug.Logger'], {});
goog.addDependency('log/log_test.js', ['goog.logTest'], ['goog.debug.LogManager', 'goog.log', 'goog.log.Level', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/affinetransform.js', ['goog.math.AffineTransform'], [], {'lang': 'es6'});
goog.addDependency('math/affinetransform_test.js', ['goog.math.AffineTransformTest'], ['goog.array', 'goog.math', 'goog.math.AffineTransform', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/bezier.js', ['goog.math.Bezier'], ['goog.math', 'goog.math.Coordinate'], {});
goog.addDependency('math/bezier_test.js', ['goog.math.BezierTest'], ['goog.math', 'goog.math.Bezier', 'goog.math.Coordinate', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/box.js', ['goog.math.Box'], ['goog.asserts', 'goog.math.Coordinate'], {});
goog.addDependency('math/box_test.js', ['goog.math.BoxTest'], ['goog.math.Box', 'goog.math.Coordinate', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/coordinate.js', ['goog.math.Coordinate'], ['goog.math'], {});
goog.addDependency('math/coordinate3.js', ['goog.math.Coordinate3'], [], {'lang': 'es6'});
goog.addDependency('math/coordinate3_test.js', ['goog.math.Coordinate3Test'], ['goog.math.Coordinate3', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/coordinate_test.js', ['goog.math.CoordinateTest'], ['goog.math.Coordinate', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/exponentialbackoff.js', ['goog.math.ExponentialBackoff'], ['goog.asserts'], {});
goog.addDependency('math/exponentialbackoff_test.js', ['goog.math.ExponentialBackoffTest'], ['goog.math.ExponentialBackoff', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/integer.js', ['goog.math.Integer'], ['goog.reflect'], {});
goog.addDependency('math/integer_test.js', ['goog.math.IntegerTest'], ['goog.math.Integer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/interpolator/interpolator1.js', ['goog.math.interpolator.Interpolator1'], [], {});
goog.addDependency('math/interpolator/linear1.js', ['goog.math.interpolator.Linear1'], ['goog.array', 'goog.asserts', 'goog.math', 'goog.math.interpolator.Interpolator1'], {});
goog.addDependency('math/interpolator/linear1_test.js', ['goog.math.interpolator.Linear1Test'], ['goog.math.interpolator.Linear1', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/interpolator/pchip1.js', ['goog.math.interpolator.Pchip1'], ['goog.math', 'goog.math.interpolator.Spline1'], {});
goog.addDependency('math/interpolator/pchip1_test.js', ['goog.math.interpolator.Pchip1Test'], ['goog.math.interpolator.Pchip1', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/interpolator/spline1.js', ['goog.math.interpolator.Spline1'], ['goog.array', 'goog.asserts', 'goog.math', 'goog.math.interpolator.Interpolator1', 'goog.math.tdma'], {});
goog.addDependency('math/interpolator/spline1_test.js', ['goog.math.interpolator.Spline1Test'], ['goog.math.interpolator.Spline1', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/irect.js', ['goog.math.IRect'], [], {});
goog.addDependency('math/line.js', ['goog.math.Line'], ['goog.math', 'goog.math.Coordinate'], {});
goog.addDependency('math/line_test.js', ['goog.math.LineTest'], ['goog.math.Coordinate', 'goog.math.Line', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/long.js', ['goog.math.Long'], ['goog.asserts', 'goog.reflect'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/long_test.js', ['goog.math.LongTest'], ['goog.asserts', 'goog.math.Long', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/math.js', ['goog.math'], ['goog.array', 'goog.asserts'], {});
goog.addDependency('math/math_test.js', ['goog.mathTest'], ['goog.math', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/matrix.js', ['goog.math.Matrix'], ['goog.array', 'goog.asserts', 'goog.math', 'goog.math.Size', 'goog.string'], {});
goog.addDependency('math/matrix_test.js', ['goog.math.MatrixTest'], ['goog.math.Matrix', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/path.js', ['goog.math.Path', 'goog.math.Path.Segment'], ['goog.array', 'goog.math', 'goog.math.AffineTransform'], {});
goog.addDependency('math/path_test.js', ['goog.math.PathTest'], ['goog.array', 'goog.math.AffineTransform', 'goog.math.Path', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/paths.js', ['goog.math.paths'], ['goog.math.Coordinate', 'goog.math.Path'], {});
goog.addDependency('math/paths_test.js', ['goog.math.pathsTest'], ['goog.math.Coordinate', 'goog.math.paths', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/range.js', ['goog.math.Range'], ['goog.asserts'], {});
goog.addDependency('math/range_test.js', ['goog.math.RangeTest'], ['goog.math.Range', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/rangeset.js', ['goog.math.RangeSet'], ['goog.array', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.math.Range'], {});
goog.addDependency('math/rangeset_test.js', ['goog.math.RangeSetTest'], ['goog.iter', 'goog.math.Range', 'goog.math.RangeSet', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/rect.js', ['goog.math.Rect'], ['goog.asserts', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.IRect', 'goog.math.Size'], {});
goog.addDependency('math/rect_test.js', ['goog.math.RectTest'], ['goog.math.Box', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.math.Size', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/size.js', ['goog.math.Size'], [], {'lang': 'es6'});
goog.addDependency('math/size_test.js', ['goog.math.SizeTest'], ['goog.math.Size', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/tdma.js', ['goog.math.tdma'], [], {'lang': 'es6'});
goog.addDependency('math/tdma_test.js', ['goog.math.tdmaTest'], ['goog.math.tdma', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/vec2.js', ['goog.math.Vec2'], ['goog.math', 'goog.math.Coordinate'], {'lang': 'es6'});
goog.addDependency('math/vec2_test.js', ['goog.math.Vec2Test'], ['goog.math.Vec2', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/vec3.js', ['goog.math.Vec3'], ['goog.math', 'goog.math.Coordinate3'], {});
goog.addDependency('math/vec3_test.js', ['goog.math.Vec3Test'], ['goog.math.Coordinate3', 'goog.math.Vec3', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('memoize/memoize.js', ['goog.memoize'], [], {'lang': 'es6'});
goog.addDependency('memoize/memoize_test.js', ['goog.memoizeTest'], ['goog.memoize', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/abstractchannel.js', ['goog.messaging.AbstractChannel'], ['goog.Disposable', 'goog.json', 'goog.log', 'goog.messaging.MessageChannel'], {});
goog.addDependency('messaging/abstractchannel_test.js', ['goog.messaging.AbstractChannelTest'], ['goog.messaging.AbstractChannel', 'goog.testing.MockControl', 'goog.testing.async.MockControl', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/bufferedchannel.js', ['goog.messaging.BufferedChannel'], ['goog.Disposable', 'goog.Timer', 'goog.events', 'goog.log', 'goog.messaging.MessageChannel', 'goog.messaging.MultiChannel'], {});
goog.addDependency('messaging/bufferedchannel_test.js', ['goog.messaging.BufferedChannelTest'], ['goog.debug.Console', 'goog.dom', 'goog.dom.TagName', 'goog.log', 'goog.log.Level', 'goog.messaging.BufferedChannel', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.async.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/deferredchannel.js', ['goog.messaging.DeferredChannel'], ['goog.Disposable', 'goog.messaging.MessageChannel'], {});
goog.addDependency('messaging/deferredchannel_test.js', ['goog.messaging.DeferredChannelTest'], ['goog.async.Deferred', 'goog.messaging.DeferredChannel', 'goog.testing.MockControl', 'goog.testing.async.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/loggerclient.js', ['goog.messaging.LoggerClient'], ['goog.Disposable', 'goog.debug', 'goog.debug.LogManager', 'goog.debug.Logger'], {});
goog.addDependency('messaging/loggerclient_test.js', ['goog.messaging.LoggerClientTest'], ['goog.debug', 'goog.debug.Logger', 'goog.messaging.LoggerClient', 'goog.testing.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/loggerserver.js', ['goog.messaging.LoggerServer'], ['goog.Disposable', 'goog.log', 'goog.log.Level'], {});
goog.addDependency('messaging/loggerserver_test.js', ['goog.messaging.LoggerServerTest'], ['goog.debug.LogManager', 'goog.debug.Logger', 'goog.log', 'goog.log.Level', 'goog.messaging.LoggerServer', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/messagechannel.js', ['goog.messaging.MessageChannel'], [], {});
goog.addDependency('messaging/messaging.js', ['goog.messaging'], [], {});
goog.addDependency('messaging/messaging_test.js', ['goog.testing.messaging.MockMessageChannelTest'], ['goog.messaging', 'goog.testing.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/multichannel.js', ['goog.messaging.MultiChannel', 'goog.messaging.MultiChannel.VirtualChannel'], ['goog.Disposable', 'goog.log', 'goog.messaging.MessageChannel', 'goog.object'], {});
goog.addDependency('messaging/multichannel_test.js', ['goog.messaging.MultiChannelTest'], ['goog.messaging.MultiChannel', 'goog.testing.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.mockmatchers.IgnoreArgument', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/portcaller.js', ['goog.messaging.PortCaller'], ['goog.Disposable', 'goog.async.Deferred', 'goog.messaging.DeferredChannel', 'goog.messaging.PortChannel', 'goog.messaging.PortNetwork', 'goog.object'], {});
goog.addDependency('messaging/portcaller_test.js', ['goog.messaging.PortCallerTest'], ['goog.events.EventTarget', 'goog.messaging.PortCaller', 'goog.messaging.PortNetwork', 'goog.testing.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/portchannel.js', ['goog.messaging.PortChannel'], ['goog.Timer', 'goog.array', 'goog.async.Deferred', 'goog.debug', 'goog.events', 'goog.events.EventType', 'goog.json', 'goog.log', 'goog.messaging.AbstractChannel', 'goog.messaging.DeferredChannel', 'goog.object', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('messaging/portchannel_test.js', ['goog.messaging.PortChannelTest'], ['goog.Promise', 'goog.Timer', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.json', 'goog.messaging.PortChannel', 'goog.testing.MockControl', 'goog.testing.TestCase', 'goog.testing.messaging.MockMessageEvent', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/portnetwork.js', ['goog.messaging.PortNetwork'], [], {});
goog.addDependency('messaging/portnetwork_test.js', ['goog.messaging.PortNetworkTest'], ['goog.Promise', 'goog.Timer', 'goog.labs.userAgent.browser', 'goog.messaging.PortChannel', 'goog.messaging.PortOperator', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/portoperator.js', ['goog.messaging.PortOperator'], ['goog.Disposable', 'goog.asserts', 'goog.log', 'goog.messaging.PortChannel', 'goog.messaging.PortNetwork', 'goog.object'], {});
goog.addDependency('messaging/portoperator_test.js', ['goog.messaging.PortOperatorTest'], ['goog.messaging.PortNetwork', 'goog.messaging.PortOperator', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.messaging.MockMessagePort', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/respondingchannel.js', ['goog.messaging.RespondingChannel'], ['goog.Disposable', 'goog.Promise', 'goog.log', 'goog.messaging.MultiChannel'], {});
goog.addDependency('messaging/respondingchannel_test.js', ['goog.messaging.RespondingChannelTest'], ['goog.Promise', 'goog.messaging.RespondingChannel', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/testdata/portchannel_worker.js', ['goog.messaging.testdata.portchannel_worker'], ['goog.messaging.PortChannel'], {});
goog.addDependency('messaging/testdata/portnetwork_worker1.js', ['goog.messaging.testdata.portnetwork_worker1'], ['goog.messaging.PortCaller', 'goog.messaging.PortChannel'], {});
goog.addDependency('messaging/testdata/portnetwork_worker2.js', ['goog.messaging.testdata.portnetwork_worker2'], ['goog.messaging.PortCaller', 'goog.messaging.PortChannel'], {});
goog.addDependency('module/abstractmoduleloader.js', ['goog.module.AbstractModuleLoader'], ['goog.module', 'goog.module.ModuleInfo'], {});
goog.addDependency('module/basemodule.js', ['goog.module.BaseModule'], ['goog.Disposable', 'goog.module'], {});
goog.addDependency('module/loader.js', ['goog.module.Loader'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.legacyconversions', 'goog.module', 'goog.object'], {});
goog.addDependency('module/module.js', ['goog.module'], [], {});
goog.addDependency('module/moduleinfo.js', ['goog.module.ModuleInfo'], ['goog.Disposable', 'goog.async.throwException', 'goog.functions', 'goog.html.TrustedResourceUrl', 'goog.module', 'goog.module.BaseModule', 'goog.module.ModuleLoadCallback'], {});
goog.addDependency('module/moduleinfo_test.js', ['goog.module.ModuleInfoTest'], ['goog.module.BaseModule', 'goog.module.ModuleInfo', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('module/moduleloadcallback.js', ['goog.module.ModuleLoadCallback'], ['goog.debug.entryPointRegistry', 'goog.module'], {});
goog.addDependency('module/moduleloadcallback_test.js', ['goog.module.ModuleLoadCallbackTest'], ['goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.functions', 'goog.module.ModuleLoadCallback', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('module/moduleloader.js', ['goog.module.ModuleLoader'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.safe', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventId', 'goog.events.EventTarget', 'goog.functions', 'goog.html.TrustedResourceUrl', 'goog.labs.userAgent.browser', 'goog.log', 'goog.module.AbstractModuleLoader', 'goog.net.BulkLoader', 'goog.net.EventType', 'goog.net.jsloader', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6'});
goog.addDependency('module/moduleloader_test.js', ['goog.module.ModuleLoaderTest'], ['goog.Promise', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.functions', 'goog.html.TrustedResourceUrl', 'goog.loader.activeModuleManager', 'goog.module.ModuleLoader', 'goog.module.ModuleManager', 'goog.net.BulkLoader', 'goog.net.XmlHttp', 'goog.object', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.events.EventObserver', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('module/modulemanager.js', ['goog.module.ModuleManager', 'goog.module.ModuleManager.CallbackType', 'goog.module.ModuleManager.FailureType'], ['goog.array', 'goog.asserts', 'goog.async.Deferred', 'goog.debug.Trace', 'goog.disposable.IDisposable', 'goog.disposeAll', 'goog.loader.AbstractModuleManager', 'goog.loader.activeModuleManager', 'goog.log', 'goog.module', 'goog.module.ModuleInfo', 'goog.module.ModuleLoadCallback', 'goog.object'], {'lang': 'es6'});
goog.addDependency('module/modulemanager_test.js', ['goog.module.ModuleManagerTest'], ['goog.array', 'goog.functions', 'goog.module.BaseModule', 'goog.module.ModuleManager', 'goog.testing', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('module/testdata/modA_1.js', ['goog.module.testdata.modA_1'], [], {});
goog.addDependency('module/testdata/modA_2.js', ['goog.module.testdata.modA_2'], ['goog.module.ModuleManager'], {});
goog.addDependency('module/testdata/modB_1.js', ['goog.module.testdata.modB_1'], ['goog.module.ModuleManager'], {});
goog.addDependency('net/browserchannel.js', ['goog.net.BrowserChannel', 'goog.net.BrowserChannel.Error', 'goog.net.BrowserChannel.Event', 'goog.net.BrowserChannel.Handler', 'goog.net.BrowserChannel.LogSaver', 'goog.net.BrowserChannel.QueuedMap', 'goog.net.BrowserChannel.ServerReachability', 'goog.net.BrowserChannel.ServerReachabilityEvent', 'goog.net.BrowserChannel.Stat', 'goog.net.BrowserChannel.StatEvent', 'goog.net.BrowserChannel.State', 'goog.net.BrowserChannel.TimingEvent'], ['goog.Uri', 'goog.array', 'goog.asserts', 'goog.debug.TextFormatter', 'goog.events.Event', 'goog.events.EventTarget', 'goog.json', 'goog.json.NativeJsonProcessor', 'goog.log', 'goog.net.BrowserTestChannel', 'goog.net.ChannelDebug', 'goog.net.ChannelRequest', 'goog.net.XhrIo', 'goog.net.tmpnetwork', 'goog.object', 'goog.string', 'goog.structs', 'goog.structs.CircularBuffer'], {});
goog.addDependency('net/browserchannel_test.js', ['goog.net.BrowserChannelTest'], ['goog.Timer', 'goog.array', 'goog.dom', 'goog.functions', 'goog.json', 'goog.net.BrowserChannel', 'goog.net.ChannelDebug', 'goog.net.ChannelRequest', 'goog.net.tmpnetwork', 'goog.structs.Map', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/browsertestchannel.js', ['goog.net.BrowserTestChannel'], ['goog.json.NativeJsonProcessor', 'goog.net.ChannelRequest', 'goog.net.ChannelRequest.Error', 'goog.net.tmpnetwork', 'goog.string.Parser'], {});
goog.addDependency('net/bulkloader.js', ['goog.net.BulkLoader'], ['goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.log', 'goog.net.BulkLoaderHelper', 'goog.net.EventType', 'goog.net.XhrIo'], {});
goog.addDependency('net/bulkloader_test.js', ['goog.net.BulkLoaderTest'], ['goog.events.Event', 'goog.events.EventHandler', 'goog.net.BulkLoader', 'goog.net.EventType', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/bulkloaderhelper.js', ['goog.net.BulkLoaderHelper'], ['goog.Disposable'], {});
goog.addDependency('net/channeldebug.js', ['goog.net.ChannelDebug'], ['goog.json', 'goog.log'], {'lang': 'es6'});
goog.addDependency('net/channelrequest.js', ['goog.net.ChannelRequest', 'goog.net.ChannelRequest.Error'], ['goog.Timer', 'goog.async.Throttle', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events.EventHandler', 'goog.html.SafeUrl', 'goog.html.uncheckedconversions', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('net/channelrequest_test.js', ['goog.net.ChannelRequestTest'], ['goog.Uri', 'goog.functions', 'goog.net.BrowserChannel', 'goog.net.ChannelDebug', 'goog.net.ChannelRequest', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.net.XhrIo', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/cookies.js', ['goog.net.Cookies', 'goog.net.cookies'], ['goog.asserts', 'goog.string'], {'lang': 'es5'});
goog.addDependency('net/cookies_test.js', ['goog.net.cookiesTest'], ['goog.array', 'goog.net.Cookies', 'goog.net.cookies', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/corsxmlhttpfactory.js', ['goog.net.CorsXmlHttpFactory', 'goog.net.IeCorsXhrAdapter'], ['goog.net.HttpStatus', 'goog.net.XhrLike', 'goog.net.XmlHttp', 'goog.net.XmlHttpFactory'], {});
goog.addDependency('net/corsxmlhttpfactory_test.js', ['goog.net.CorsXmlHttpFactoryTest'], ['goog.net.CorsXmlHttpFactory', 'goog.net.IeCorsXhrAdapter', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/crossdomainrpc.js', ['goog.net.CrossDomainRpc'], ['goog.Uri', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.html.SafeHtml', 'goog.log', 'goog.net.EventType', 'goog.net.HttpStatus', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('net/crossdomainrpc_test.js', ['goog.net.CrossDomainRpcTest'], ['goog.Promise', 'goog.log', 'goog.net.CrossDomainRpc', 'goog.testing.TestCase', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/errorcode.js', ['goog.net.ErrorCode'], [], {});
goog.addDependency('net/eventtype.js', ['goog.net.EventType'], [], {});
goog.addDependency('net/fetchxmlhttpfactory.js', ['goog.net.FetchXmlHttp', 'goog.net.FetchXmlHttpFactory'], ['goog.asserts', 'goog.events.EventTarget', 'goog.functions', 'goog.log', 'goog.net.XhrLike', 'goog.net.XmlHttpFactory'], {'lang': 'es5'});
goog.addDependency('net/fetchxmlhttpfactory_test.js', ['goog.net.FetchXmlHttpFactoryTest'], ['goog.net.FetchXmlHttp', 'goog.net.FetchXmlHttpFactory', 'goog.testing.MockControl', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/filedownloader.js', ['goog.net.FileDownloader', 'goog.net.FileDownloader.Error'], ['goog.Disposable', 'goog.asserts', 'goog.async.Deferred', 'goog.crypt.hash32', 'goog.debug.Error', 'goog.events', 'goog.events.EventHandler', 'goog.fs', 'goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.fs.FileSaver', 'goog.net.EventType', 'goog.net.XhrIo', 'goog.net.XhrIoPool', 'goog.object'], {});
goog.addDependency('net/filedownloader_test.js', ['goog.net.FileDownloaderTest'], ['goog.fs.Error', 'goog.net.ErrorCode', 'goog.net.FileDownloader', 'goog.net.XhrIo', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.fs', 'goog.testing.fs.FileSystem', 'goog.testing.net.XhrIoPool', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/httpstatus.js', ['goog.net.HttpStatus'], [], {});
goog.addDependency('net/httpstatusname.js', ['goog.net.HttpStatusName'], [], {});
goog.addDependency('net/iframeio.js', ['goog.net.IframeIo', 'goog.net.IframeIo.IncrementalDataEvent'], ['goog.Timer', 'goog.Uri', 'goog.array', 'goog.asserts', 'goog.debug.HtmlFormatter', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.html.SafeUrl', 'goog.html.legacyconversions', 'goog.html.uncheckedconversions', 'goog.json', 'goog.log', 'goog.log.Level', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.reflect', 'goog.string', 'goog.string.Const', 'goog.structs', 'goog.userAgent'], {});
goog.addDependency('net/iframeio_test.js', ['goog.net.IframeIoTest'], ['goog.debug', 'goog.debug.DivConsole', 'goog.debug.LogManager', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.log', 'goog.log.Level', 'goog.net.IframeIo', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.jsunit', 'goog.userAgent'], {'lang': 'es6'});
goog.addDependency('net/iframeloadmonitor.js', ['goog.net.IframeLoadMonitor'], ['goog.dom', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.userAgent'], {});
goog.addDependency('net/iframeloadmonitor_test.js', ['goog.net.IframeLoadMonitorTest'], ['goog.Promise', 'goog.Timer', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.net.IframeLoadMonitor', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/imageloader.js', ['goog.net.ImageLoader'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.net.EventType', 'goog.object', 'goog.userAgent'], {});
goog.addDependency('net/imageloader_test.js', ['goog.net.ImageLoaderTest'], ['goog.Promise', 'goog.Timer', 'goog.array', 'goog.dispose', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.net.EventType', 'goog.net.ImageLoader', 'goog.object', 'goog.string', 'goog.testing.TestCase', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/ipaddress.js', ['goog.net.IpAddress', 'goog.net.Ipv4Address', 'goog.net.Ipv6Address'], ['goog.array', 'goog.math.Integer', 'goog.object', 'goog.string'], {});
goog.addDependency('net/ipaddress_test.js', ['goog.net.IpAddressTest'], ['goog.array', 'goog.math.Integer', 'goog.net.IpAddress', 'goog.net.Ipv4Address', 'goog.net.Ipv6Address', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/jsloader.js', ['goog.net.jsloader', 'goog.net.jsloader.Error', 'goog.net.jsloader.ErrorCode', 'goog.net.jsloader.Options'], ['goog.array', 'goog.async.Deferred', 'goog.debug.Error', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.TrustedResourceUrl', 'goog.object'], {});
goog.addDependency('net/jsloader_test.js', ['goog.net.jsloaderTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.html.TrustedResourceUrl', 'goog.net.jsloader', 'goog.net.jsloader.ErrorCode', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/jsonp.js', ['goog.net.Jsonp'], ['goog.html.TrustedResourceUrl', 'goog.net.jsloader', 'goog.object'], {});
goog.addDependency('net/jsonp_test.js', ['goog.net.JsonpTest'], ['goog.html.TrustedResourceUrl', 'goog.net.Jsonp', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/mockiframeio.js', ['goog.net.MockIFrameIo'], ['goog.events.EventTarget', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.IframeIo'], {});
goog.addDependency('net/multiiframeloadmonitor.js', ['goog.net.MultiIframeLoadMonitor'], ['goog.events', 'goog.net.IframeLoadMonitor'], {});
goog.addDependency('net/multiiframeloadmonitor_test.js', ['goog.net.MultiIframeLoadMonitorTest'], ['goog.Promise', 'goog.Timer', 'goog.dom', 'goog.dom.TagName', 'goog.net.MultiIframeLoadMonitor', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/networkstatusmonitor.js', ['goog.net.NetworkStatusMonitor'], ['goog.events.Listenable'], {});
goog.addDependency('net/networktester.js', ['goog.net.NetworkTester'], ['goog.Timer', 'goog.Uri', 'goog.dom.safe', 'goog.log'], {});
goog.addDependency('net/networktester_test.js', ['goog.net.NetworkTesterTest'], ['goog.Uri', 'goog.net.NetworkTester', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/rpc/httpcors.js', ['goog.net.rpc.HttpCors'], ['goog.Uri', 'goog.object', 'goog.string', 'goog.uri.utils'], {'module': 'goog'});
goog.addDependency('net/rpc/httpcors_test.js', ['goog.net.rpc.HttpCorsTest'], ['goog.Uri', 'goog.net.rpc.HttpCors', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/base64pbstreamparser.js', ['goog.net.streams.Base64PbStreamParser'], ['goog.asserts', 'goog.net.streams.Base64StreamDecoder', 'goog.net.streams.PbStreamParser', 'goog.net.streams.StreamParser'], {'module': 'goog'});
goog.addDependency('net/streams/base64pbstreamparser_test.js', ['goog.net.streams.Base64PbStreamParserTest'], ['goog.crypt.base64', 'goog.net.streams.Base64PbStreamParser', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/base64streamdecoder.js', ['goog.net.streams.Base64StreamDecoder'], ['goog.asserts', 'goog.crypt.base64'], {});
goog.addDependency('net/streams/base64streamdecoder_test.js', ['goog.net.streams.Base64StreamDecoderTest'], ['goog.net.streams.Base64StreamDecoder', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/jsonstreamparser.js', ['goog.net.streams.JsonStreamParser', 'goog.net.streams.JsonStreamParser.Options'], ['goog.asserts', 'goog.net.streams.StreamParser', 'goog.net.streams.utils'], {});
goog.addDependency('net/streams/jsonstreamparser_test.js', ['goog.net.streams.JsonStreamParserTest'], ['goog.array', 'goog.json', 'goog.labs.testing.JsonFuzzing', 'goog.net.streams.JsonStreamParser', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.uri.utils'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/nodereadablestream.js', ['goog.net.streams.NodeReadableStream'], [], {});
goog.addDependency('net/streams/pbjsonstreamparser.js', ['goog.net.streams.PbJsonStreamParser'], ['goog.asserts', 'goog.net.streams.JsonStreamParser', 'goog.net.streams.StreamParser', 'goog.net.streams.utils'], {'module': 'goog'});
goog.addDependency('net/streams/pbjsonstreamparser_test.js', ['goog.net.streams.PbJsonStreamParserTest'], ['goog.net.streams.PbJsonStreamParser', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/pbstreamparser.js', ['goog.net.streams.PbStreamParser'], ['goog.asserts', 'goog.net.streams.StreamParser'], {});
goog.addDependency('net/streams/pbstreamparser_test.js', ['goog.net.streams.PbStreamParserTest'], ['goog.net.streams.PbStreamParser', 'goog.object', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/streamfactory.js', ['goog.net.streams.createXhrNodeReadableStream'], ['goog.asserts', 'goog.net.streams.XhrNodeReadableStream', 'goog.net.streams.XhrStreamReader'], {});
goog.addDependency('net/streams/streamparser.js', ['goog.net.streams.StreamParser'], [], {});
goog.addDependency('net/streams/utils.js', ['goog.net.streams.utils'], [], {'module': 'goog'});
goog.addDependency('net/streams/xhrnodereadablestream.js', ['goog.net.streams.XhrNodeReadableStream'], ['goog.array', 'goog.log', 'goog.net.streams.NodeReadableStream', 'goog.net.streams.XhrStreamReader'], {});
goog.addDependency('net/streams/xhrnodereadablestream_test.js', ['goog.net.streams.XhrNodeReadableStreamTest'], ['goog.net.streams.NodeReadableStream', 'goog.net.streams.XhrNodeReadableStream', 'goog.net.streams.XhrStreamReader', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/xhrstreamreader.js', ['goog.net.streams.XhrStreamReader'], ['goog.events.EventHandler', 'goog.log', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.HttpStatus', 'goog.net.XhrIo', 'goog.net.XmlHttp', 'goog.net.streams.Base64PbStreamParser', 'goog.net.streams.JsonStreamParser', 'goog.net.streams.PbJsonStreamParser', 'goog.net.streams.PbStreamParser', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('net/streams/xhrstreamreader_test.js', ['goog.net.streams.XhrStreamReaderTest'], ['goog.net.ErrorCode', 'goog.net.HttpStatus', 'goog.net.XhrIo', 'goog.net.XmlHttp', 'goog.net.streams.Base64PbStreamParser', 'goog.net.streams.JsonStreamParser', 'goog.net.streams.PbJsonStreamParser', 'goog.net.streams.PbStreamParser', 'goog.net.streams.XhrStreamReader', 'goog.object', 'goog.testing.net.XhrIo', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/testdata/jsloader_test1.js', ['goog.net.testdata.jsloader_test1'], [], {});
goog.addDependency('net/testdata/jsloader_test2.js', ['goog.net.testdata.jsloader_test2'], [], {});
goog.addDependency('net/testdata/jsloader_test3.js', ['goog.net.testdata.jsloader_test3'], [], {});
goog.addDependency('net/testdata/jsloader_test4.js', ['goog.net.testdata.jsloader_test4'], [], {});
goog.addDependency('net/tmpnetwork.js', ['goog.net.tmpnetwork'], ['goog.Uri', 'goog.dom.safe', 'goog.net.ChannelDebug'], {});
goog.addDependency('net/websocket.js', ['goog.net.WebSocket', 'goog.net.WebSocket.ErrorEvent', 'goog.net.WebSocket.EventType', 'goog.net.WebSocket.MessageEvent'], ['goog.Timer', 'goog.asserts', 'goog.debug.entryPointRegistry', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.log'], {'lang': 'es5'});
goog.addDependency('net/websocket_test.js', ['goog.net.WebSocketTest'], ['goog.debug.EntryPointMonitor', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.events', 'goog.functions', 'goog.net.WebSocket', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/wrapperxmlhttpfactory.js', ['goog.net.WrapperXmlHttpFactory'], ['goog.net.XhrLike', 'goog.net.XmlHttpFactory'], {});
goog.addDependency('net/xhrio.js', ['goog.net.XhrIo', 'goog.net.XhrIo.ResponseType'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.debug.entryPointRegistry', 'goog.events.EventTarget', 'goog.json.hybrid', 'goog.log', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.HttpStatus', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.structs', 'goog.structs.Map', 'goog.uri.utils', 'goog.userAgent'], {});
goog.addDependency('net/xhrio_test.js', ['goog.net.XhrIoTest'], ['goog.Uri', 'goog.debug.EntryPointMonitor', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.events', 'goog.functions', 'goog.net.EventType', 'goog.net.WrapperXmlHttpFactory', 'goog.net.XhrIo', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit', 'goog.testing.net.XhrIo', 'goog.testing.recordFunction', 'goog.userAgent.product'], {'lang': 'es6'});
goog.addDependency('net/xhriopool.js', ['goog.net.XhrIoPool'], ['goog.net.XhrIo', 'goog.structs.PriorityPool'], {});
goog.addDependency('net/xhriopool_test.js', ['goog.net.XhrIoPoolTest'], ['goog.net.XhrIoPool', 'goog.structs.Map', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xhrlike.js', ['goog.net.XhrLike'], [], {});
goog.addDependency('net/xhrmanager.js', ['goog.net.XhrManager', 'goog.net.XhrManager.Event', 'goog.net.XhrManager.Request'], ['goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.XhrIo', 'goog.net.XhrIoPool', 'goog.structs.Map'], {});
goog.addDependency('net/xhrmanager_test.js', ['goog.net.XhrManagerTest'], ['goog.events', 'goog.net.EventType', 'goog.net.XhrIo', 'goog.net.XhrManager', 'goog.testing.net.XhrIoPool', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xmlhttp.js', ['goog.net.DefaultXmlHttpFactory', 'goog.net.XmlHttp', 'goog.net.XmlHttp.OptionType', 'goog.net.XmlHttp.ReadyState', 'goog.net.XmlHttpDefines'], ['goog.asserts', 'goog.net.WrapperXmlHttpFactory', 'goog.net.XmlHttpFactory'], {});
goog.addDependency('net/xmlhttpfactory.js', ['goog.net.XmlHttpFactory'], ['goog.net.XhrLike'], {});
goog.addDependency('net/xpc/crosspagechannel.js', ['goog.net.xpc.CrossPageChannel'], ['goog.Uri', 'goog.async.Deferred', 'goog.async.Delay', 'goog.dispose', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.html.legacyconversions', 'goog.json', 'goog.log', 'goog.messaging.AbstractChannel', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.ChannelStates', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.DirectTransport', 'goog.net.xpc.NativeMessagingTransport', 'goog.net.xpc.TransportTypes', 'goog.net.xpc.UriCfgFields', 'goog.string', 'goog.uri.utils', 'goog.userAgent'], {});
goog.addDependency('net/xpc/crosspagechannel_test.js', ['goog.net.xpc.CrossPageChannelTest'], ['goog.Disposable', 'goog.Promise', 'goog.Timer', 'goog.Uri', 'goog.dom', 'goog.dom.TagName', 'goog.labs.userAgent.browser', 'goog.log', 'goog.log.Level', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannel', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.TransportTypes', 'goog.object', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.jsunit'], {'lang': 'es8'});
goog.addDependency('net/xpc/crosspagechannelrole.js', ['goog.net.xpc.CrossPageChannelRole'], [], {});
goog.addDependency('net/xpc/directtransport.js', ['goog.net.xpc.DirectTransport'], ['goog.Timer', 'goog.async.Deferred', 'goog.events.EventHandler', 'goog.log', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.Transport', 'goog.net.xpc.TransportTypes', 'goog.object'], {});
goog.addDependency('net/xpc/directtransport_test.js', ['goog.net.xpc.DirectTransportTest'], ['goog.Promise', 'goog.dom', 'goog.dom.TagName', 'goog.labs.userAgent.browser', 'goog.log', 'goog.log.Level', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannel', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.TransportTypes', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xpc/iframepollingtransport.js', ['goog.net.xpc.IframePollingTransport', 'goog.net.xpc.IframePollingTransport.Receiver', 'goog.net.xpc.IframePollingTransport.Sender'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.log', 'goog.log.Level', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.Transport', 'goog.net.xpc.TransportTypes', 'goog.userAgent'], {});
goog.addDependency('net/xpc/iframepollingtransport_test.js', ['goog.net.xpc.IframePollingTransportTest'], ['goog.Timer', 'goog.dom', 'goog.dom.TagName', 'goog.functions', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannel', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.IframePollingTransport', 'goog.object', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xpc/nativemessagingtransport.js', ['goog.net.xpc.NativeMessagingTransport'], ['goog.Timer', 'goog.asserts', 'goog.async.Deferred', 'goog.events', 'goog.events.EventHandler', 'goog.log', 'goog.net.xpc', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.Transport', 'goog.net.xpc.TransportTypes'], {});
goog.addDependency('net/xpc/nativemessagingtransport_test.js', ['goog.net.xpc.NativeMessagingTransportTest'], ['goog.dom', 'goog.events', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannel', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.NativeMessagingTransport', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xpc/relay.js', ['goog.net.xpc.relay'], [], {'lang': 'es6'});
goog.addDependency('net/xpc/transport.js', ['goog.net.xpc.Transport'], ['goog.Disposable', 'goog.dom', 'goog.net.xpc.TransportNames'], {});
goog.addDependency('net/xpc/xpc.js', ['goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.ChannelStates', 'goog.net.xpc.TransportNames', 'goog.net.xpc.TransportTypes', 'goog.net.xpc.UriCfgFields'], ['goog.log'], {});
goog.addDependency('object/object.js', ['goog.object'], [], {'lang': 'es6'});
goog.addDependency('object/object_test.js', ['goog.objectTest'], ['goog.array', 'goog.functions', 'goog.object', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/absoluteposition.js', ['goog.positioning.AbsolutePosition'], ['goog.math.Coordinate', 'goog.positioning', 'goog.positioning.AbstractPosition'], {});
goog.addDependency('positioning/abstractposition.js', ['goog.positioning.AbstractPosition'], [], {});
goog.addDependency('positioning/anchoredposition.js', ['goog.positioning.AnchoredPosition'], ['goog.positioning', 'goog.positioning.AbstractPosition'], {});
goog.addDependency('positioning/anchoredposition_test.js', ['goog.positioning.AnchoredPositionTest'], ['goog.dom', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/anchoredviewportposition.js', ['goog.positioning.AnchoredViewportPosition'], ['goog.positioning', 'goog.positioning.AnchoredPosition', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus'], {});
goog.addDependency('positioning/anchoredviewportposition_test.js', ['goog.positioning.AnchoredViewportPositionTest'], ['goog.dom', 'goog.math.Box', 'goog.positioning.AnchoredViewportPosition', 'goog.positioning.Corner', 'goog.positioning.OverflowStatus', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/clientposition.js', ['goog.positioning.ClientPosition'], ['goog.asserts', 'goog.dom', 'goog.math.Coordinate', 'goog.positioning', 'goog.positioning.AbstractPosition', 'goog.style'], {});
goog.addDependency('positioning/clientposition_test.js', ['goog.positioning.clientPositionTest'], ['goog.dom', 'goog.dom.TagName', 'goog.positioning.ClientPosition', 'goog.positioning.Corner', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/menuanchoredposition.js', ['goog.positioning.MenuAnchoredPosition'], ['goog.positioning.AnchoredViewportPosition', 'goog.positioning.Overflow'], {});
goog.addDependency('positioning/menuanchoredposition_test.js', ['goog.positioning.MenuAnchoredPositionTest'], ['goog.dom', 'goog.dom.TagName', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/positioning.js', ['goog.positioning', 'goog.positioning.Corner', 'goog.positioning.CornerBit', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.math.Size', 'goog.style', 'goog.style.bidi'], {});
goog.addDependency('positioning/positioning_test.js', ['goog.positioningTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.labs.userAgent.browser', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.Size', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/viewportclientposition.js', ['goog.positioning.ViewportClientPosition'], ['goog.dom', 'goog.math.Coordinate', 'goog.positioning', 'goog.positioning.ClientPosition', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus', 'goog.style'], {});
goog.addDependency('positioning/viewportclientposition_test.js', ['goog.positioning.ViewportClientPositionTest'], ['goog.dom', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.positioning.ViewportClientPosition', 'goog.style', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/viewportposition.js', ['goog.positioning.ViewportPosition'], ['goog.math.Coordinate', 'goog.positioning', 'goog.positioning.AbstractPosition', 'goog.positioning.Corner', 'goog.style'], {});
goog.addDependency('promise/nativeresolver.js', ['goog.promise.NativeResolver'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('promise/nativeresolver_test.js', ['goog.promise.nativeResolverTest'], ['goog.promise.NativeResolver', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('promise/promise.js', ['goog.Promise'], ['goog.Thenable', 'goog.asserts', 'goog.async.FreeList', 'goog.async.run', 'goog.async.throwException', 'goog.debug.Error', 'goog.promise.Resolver'], {});
goog.addDependency('promise/promise_test.js', ['goog.PromiseTest'], ['goog.Promise', 'goog.Thenable', 'goog.Timer', 'goog.functions', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('promise/resolver.js', ['goog.promise.Resolver'], [], {});
goog.addDependency('promise/testsuiteadapter.js', ['goog.promise.testSuiteAdapter'], ['goog.Promise'], {});
goog.addDependency('promise/thenable.js', ['goog.Thenable'], [], {});
goog.addDependency('proto2/descriptor.js', ['goog.proto2.Descriptor', 'goog.proto2.Metadata'], ['goog.array', 'goog.asserts', 'goog.object', 'goog.string'], {});
goog.addDependency('proto2/descriptor_test.js', ['goog.proto2.DescriptorTest'], ['goog.proto2.Descriptor', 'goog.proto2.Message', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/fielddescriptor.js', ['goog.proto2.FieldDescriptor'], ['goog.asserts', 'goog.string'], {});
goog.addDependency('proto2/fielddescriptor_test.js', ['goog.proto2.FieldDescriptorTest'], ['goog.proto2.FieldDescriptor', 'goog.proto2.Message', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/lazydeserializer.js', ['goog.proto2.LazyDeserializer'], ['goog.asserts', 'goog.proto2.Message', 'goog.proto2.Serializer'], {});
goog.addDependency('proto2/message.js', ['goog.proto2.Message'], ['goog.asserts', 'goog.proto2.Descriptor', 'goog.proto2.FieldDescriptor'], {});
goog.addDependency('proto2/message_test.js', ['goog.proto2.MessageTest'], ['goog.testing.testSuite', 'proto2.TestAllTypes', 'proto2.TestAllTypes.NestedEnum', 'proto2.TestAllTypes.NestedMessage', 'proto2.TestAllTypes.OptionalGroup', 'proto2.TestAllTypes.RepeatedGroup'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/objectserializer.js', ['goog.proto2.ObjectSerializer'], ['goog.asserts', 'goog.proto2.FieldDescriptor', 'goog.proto2.Serializer', 'goog.string'], {});
goog.addDependency('proto2/objectserializer_test.js', ['goog.proto2.ObjectSerializerTest'], ['goog.proto2.ObjectSerializer', 'goog.proto2.Serializer', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'proto2.TestAllTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/package_test.pb.js', ['someprotopackage.TestPackageTypes'], ['goog.proto2.Message', 'proto2.TestAllTypes'], {'lang': 'es6'});
goog.addDependency('proto2/pbliteserializer.js', ['goog.proto2.PbLiteSerializer'], ['goog.asserts', 'goog.proto2.FieldDescriptor', 'goog.proto2.LazyDeserializer', 'goog.proto2.Serializer'], {});
goog.addDependency('proto2/pbliteserializer_test.js', ['goog.proto2.PbLiteSerializerTest'], ['goog.proto2.PbLiteSerializer', 'goog.testing.testSuite', 'proto2.TestAllTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/proto_test.js', ['goog.proto2.messageTest'], ['goog.proto2.FieldDescriptor', 'goog.testing.testSuite', 'proto2.TestAllTypes', 'proto2.TestDefaultParent', 'someprotopackage.TestPackageTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/serializer.js', ['goog.proto2.Serializer'], ['goog.asserts', 'goog.proto2.FieldDescriptor', 'goog.proto2.Message'], {});
goog.addDependency('proto2/test.pb.js', ['proto2.TestAllTypes', 'proto2.TestAllTypes.NestedEnum', 'proto2.TestAllTypes.NestedMessage', 'proto2.TestAllTypes.OptionalGroup', 'proto2.TestAllTypes.RepeatedGroup', 'proto2.TestDefaultChild', 'proto2.TestDefaultParent'], ['goog.proto2.Message'], {});
goog.addDependency('proto2/textformatserializer.js', ['goog.proto2.TextFormatSerializer'], ['goog.array', 'goog.asserts', 'goog.math', 'goog.object', 'goog.proto2.FieldDescriptor', 'goog.proto2.Message', 'goog.proto2.Serializer', 'goog.string'], {});
goog.addDependency('proto2/textformatserializer_test.js', ['goog.proto2.TextFormatSerializerTest'], ['goog.proto2.ObjectSerializer', 'goog.proto2.TextFormatSerializer', 'goog.testing.testSuite', 'proto2.TestAllTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/util.js', ['goog.proto2.Util'], ['goog.asserts'], {});
goog.addDependency('pubsub/pubsub.js', ['goog.pubsub.PubSub'], ['goog.Disposable', 'goog.array', 'goog.async.run'], {});
goog.addDependency('pubsub/pubsub_test.js', ['goog.pubsub.PubSubTest'], ['goog.array', 'goog.pubsub.PubSub', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('pubsub/topicid.js', ['goog.pubsub.TopicId'], [], {});
goog.addDependency('pubsub/typedpubsub.js', ['goog.pubsub.TypedPubSub'], ['goog.Disposable', 'goog.pubsub.PubSub'], {});
goog.addDependency('pubsub/typedpubsub_test.js', ['goog.pubsub.TypedPubSubTest'], ['goog.array', 'goog.pubsub.TopicId', 'goog.pubsub.TypedPubSub', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('reflect/reflect.js', ['goog.reflect'], [], {'lang': 'es6'});
goog.addDependency('reflect/reflect_test.js', ['goog.reflectTest'], ['goog.object', 'goog.reflect', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/chain_test.js', ['goog.result.chainTest'], ['goog.Timer', 'goog.result', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/combine_test.js', ['goog.result.combineTest'], ['goog.Timer', 'goog.array', 'goog.result', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/deferredadaptor.js', ['goog.result.DeferredAdaptor'], ['goog.async.Deferred', 'goog.result', 'goog.result.Result'], {});
goog.addDependency('result/deferredadaptor_test.js', ['goog.result.DeferredAdaptorTest'], ['goog.async.Deferred', 'goog.result', 'goog.result.DeferredAdaptor', 'goog.result.SimpleResult', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/dependentresult.js', ['goog.result.DependentResult'], ['goog.result.Result'], {});
goog.addDependency('result/result_interface.js', ['goog.result.Result'], ['goog.Thenable'], {});
goog.addDependency('result/resultutil.js', ['goog.result'], ['goog.array', 'goog.result.DependentResult', 'goog.result.Result', 'goog.result.SimpleResult'], {});
goog.addDependency('result/resultutil_test.js', ['goog.resultTest'], ['goog.result', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/simpleresult.js', ['goog.result.SimpleResult', 'goog.result.SimpleResult.StateError'], ['goog.Promise', 'goog.Thenable', 'goog.debug.Error', 'goog.result.Result'], {});
goog.addDependency('result/simpleresult_test.js', ['goog.result.SimpleResultTest'], ['goog.Promise', 'goog.Thenable', 'goog.Timer', 'goog.result', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/transform_test.js', ['goog.result.transformTest'], ['goog.Timer', 'goog.result', 'goog.result.SimpleResult', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/wait_test.js', ['goog.result.waitTest'], ['goog.Timer', 'goog.result', 'goog.result.SimpleResult', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('soy/data.js', ['goog.soy.data.SanitizedContent', 'goog.soy.data.SanitizedContentKind', 'goog.soy.data.SanitizedCss', 'goog.soy.data.SanitizedHtml', 'goog.soy.data.SanitizedHtmlAttribute', 'goog.soy.data.SanitizedJs', 'goog.soy.data.SanitizedTrustedResourceUri', 'goog.soy.data.SanitizedUri'], ['goog.Uri', 'goog.asserts', 'goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.uncheckedconversions', 'goog.i18n.bidi.Dir', 'goog.string.Const'], {});
goog.addDependency('soy/data_test.js', ['goog.soy.dataTest'], ['goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.soy.testHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('soy/renderer.js', ['goog.soy.InjectedDataSupplier', 'goog.soy.Renderer'], ['goog.asserts', 'goog.dom', 'goog.soy', 'goog.soy.data.SanitizedContent', 'goog.soy.data.SanitizedContentKind'], {});
goog.addDependency('soy/renderer_test.js', ['goog.soy.RendererTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.html.SafeHtml', 'goog.i18n.bidi.Dir', 'goog.soy.Renderer', 'goog.soy.data.SanitizedContentKind', 'goog.soy.testHelper', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('soy/soy.js', ['goog.soy'], ['goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.soy.data.SanitizedContent'], {});
goog.addDependency('soy/soy_test.js', ['goog.soyTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.functions', 'goog.soy', 'goog.soy.testHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('soy/soy_testhelper.js', ['goog.soy.testHelper'], ['goog.dom', 'goog.dom.TagName', 'goog.i18n.bidi.Dir', 'goog.soy.data.SanitizedContent', 'goog.soy.data.SanitizedContentKind', 'goog.soy.data.SanitizedCss', 'goog.soy.data.SanitizedTrustedResourceUri', 'goog.string', 'goog.userAgent'], {'lang': 'es6'});
goog.addDependency('spell/spellcheck.js', ['goog.spell.SpellCheck', 'goog.spell.SpellCheck.WordChangedEvent'], ['goog.Timer', 'goog.events.Event', 'goog.events.EventTarget', 'goog.structs.Set'], {});
goog.addDependency('spell/spellcheck_test.js', ['goog.spell.SpellCheckTest'], ['goog.spell.SpellCheck', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('stats/basicstat.js', ['goog.stats.BasicStat'], ['goog.asserts', 'goog.log', 'goog.string.format', 'goog.structs.CircularBuffer'], {});
goog.addDependency('stats/basicstat_test.js', ['goog.stats.BasicStatTest'], ['goog.array', 'goog.stats.BasicStat', 'goog.string.format', 'goog.testing.PseudoRandom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/collectablestorage.js', ['goog.storage.CollectableStorage'], ['goog.array', 'goog.iter', 'goog.storage.ErrorCode', 'goog.storage.ExpiringStorage', 'goog.storage.RichStorage'], {});
goog.addDependency('storage/collectablestorage_test.js', ['goog.storage.CollectableStorageTest'], ['goog.storage.CollectableStorage', 'goog.storage.collectableStorageTester', 'goog.storage.storageTester', 'goog.testing.MockClock', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/collectablestoragetester.js', ['goog.storage.collectableStorageTester'], ['goog.testing.asserts'], {});
goog.addDependency('storage/encryptedstorage.js', ['goog.storage.EncryptedStorage'], ['goog.crypt', 'goog.crypt.Arc4', 'goog.crypt.Sha1', 'goog.crypt.base64', 'goog.json', 'goog.json.Serializer', 'goog.storage.CollectableStorage', 'goog.storage.ErrorCode', 'goog.storage.RichStorage'], {});
goog.addDependency('storage/encryptedstorage_test.js', ['goog.storage.EncryptedStorageTest'], ['goog.json', 'goog.storage.EncryptedStorage', 'goog.storage.ErrorCode', 'goog.storage.RichStorage', 'goog.storage.collectableStorageTester', 'goog.storage.storageTester', 'goog.testing.MockClock', 'goog.testing.PseudoRandom', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/errorcode.js', ['goog.storage.ErrorCode'], [], {});
goog.addDependency('storage/expiringstorage.js', ['goog.storage.ExpiringStorage'], ['goog.storage.RichStorage'], {});
goog.addDependency('storage/expiringstorage_test.js', ['goog.storage.ExpiringStorageTest'], ['goog.storage.ExpiringStorage', 'goog.storage.storageTester', 'goog.testing.MockClock', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/errorcode.js', ['goog.storage.mechanism.ErrorCode'], [], {});
goog.addDependency('storage/mechanism/errorhandlingmechanism.js', ['goog.storage.mechanism.ErrorHandlingMechanism'], ['goog.storage.mechanism.Mechanism'], {});
goog.addDependency('storage/mechanism/errorhandlingmechanism_test.js', ['goog.storage.mechanism.ErrorHandlingMechanismTest'], ['goog.storage.mechanism.ErrorHandlingMechanism', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/html5localstorage.js', ['goog.storage.mechanism.HTML5LocalStorage'], ['goog.storage.mechanism.HTML5WebStorage'], {});
goog.addDependency('storage/mechanism/html5localstorage_test.js', ['goog.storage.mechanism.HTML5LocalStorageTest'], ['goog.storage.mechanism.HTML5LocalStorage', 'goog.storage.mechanism.mechanismSeparationTester', 'goog.storage.mechanism.mechanismSharingTester', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/html5sessionstorage.js', ['goog.storage.mechanism.HTML5SessionStorage'], ['goog.storage.mechanism.HTML5WebStorage'], {});
goog.addDependency('storage/mechanism/html5sessionstorage_test.js', ['goog.storage.mechanism.HTML5SessionStorageTest'], ['goog.storage.mechanism.HTML5SessionStorage', 'goog.storage.mechanism.mechanismSeparationTester', 'goog.storage.mechanism.mechanismSharingTester', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/html5webstorage.js', ['goog.storage.mechanism.HTML5WebStorage'], ['goog.asserts', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.storage.mechanism.ErrorCode', 'goog.storage.mechanism.IterableMechanism'], {});
goog.addDependency('storage/mechanism/html5webstorage_test.js', ['goog.storage.mechanism.HTML5WebStorageTest'], ['goog.storage.mechanism.ErrorCode', 'goog.storage.mechanism.HTML5WebStorage', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/ieuserdata.js', ['goog.storage.mechanism.IEUserData'], ['goog.asserts', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.storage.mechanism.ErrorCode', 'goog.storage.mechanism.IterableMechanism', 'goog.structs.Map', 'goog.userAgent'], {});
goog.addDependency('storage/mechanism/ieuserdata_test.js', ['goog.storage.mechanism.IEUserDataTest'], ['goog.storage.mechanism.IEUserData', 'goog.storage.mechanism.mechanismSeparationTester', 'goog.storage.mechanism.mechanismSharingTester', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/iterablemechanism.js', ['goog.storage.mechanism.IterableMechanism'], ['goog.array', 'goog.asserts', 'goog.iter', 'goog.storage.mechanism.Mechanism'], {});
goog.addDependency('storage/mechanism/iterablemechanismtester.js', ['goog.storage.mechanism.iterableMechanismTester'], ['goog.iter', 'goog.iter.StopIteration', 'goog.testing.asserts'], {});
goog.addDependency('storage/mechanism/mechanism.js', ['goog.storage.mechanism.Mechanism'], [], {});
goog.addDependency('storage/mechanism/mechanismfactory.js', ['goog.storage.mechanism.mechanismfactory'], ['goog.storage.mechanism.HTML5LocalStorage', 'goog.storage.mechanism.HTML5SessionStorage', 'goog.storage.mechanism.IEUserData', 'goog.storage.mechanism.PrefixedMechanism'], {});
goog.addDependency('storage/mechanism/mechanismfactory_test.js', ['goog.storage.mechanism.mechanismfactoryTest'], ['goog.storage.mechanism.mechanismfactory', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/mechanismseparationtester.js', ['goog.storage.mechanism.mechanismSeparationTester'], ['goog.iter.StopIteration', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.asserts'], {});
goog.addDependency('storage/mechanism/mechanismsharingtester.js', ['goog.storage.mechanism.mechanismSharingTester'], ['goog.iter.StopIteration', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.asserts'], {});
goog.addDependency('storage/mechanism/mechanismtestdefinition.js', ['goog.storage.mechanism.mechanismTestDefinition'], [], {});
goog.addDependency('storage/mechanism/mechanismtester.js', ['goog.storage.mechanism.mechanismTester'], ['goog.storage.mechanism.ErrorCode', 'goog.testing.asserts', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('storage/mechanism/prefixedmechanism.js', ['goog.storage.mechanism.PrefixedMechanism'], ['goog.iter.Iterator', 'goog.storage.mechanism.IterableMechanism'], {});
goog.addDependency('storage/mechanism/prefixedmechanism_test.js', ['goog.storage.mechanism.PrefixedMechanismTest'], ['goog.storage.mechanism.HTML5LocalStorage', 'goog.storage.mechanism.PrefixedMechanism', 'goog.storage.mechanism.mechanismSeparationTester', 'goog.storage.mechanism.mechanismSharingTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/richstorage.js', ['goog.storage.RichStorage', 'goog.storage.RichStorage.Wrapper'], ['goog.storage.ErrorCode', 'goog.storage.Storage'], {});
goog.addDependency('storage/richstorage_test.js', ['goog.storage.RichStorageTest'], ['goog.storage.ErrorCode', 'goog.storage.RichStorage', 'goog.storage.storageTester', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/storage.js', ['goog.storage.Storage'], ['goog.json', 'goog.storage.ErrorCode'], {});
goog.addDependency('storage/storage_test.js', ['goog.storage.storage_test'], ['goog.functions', 'goog.storage.ErrorCode', 'goog.storage.Storage', 'goog.storage.storageTester', 'goog.testing.asserts', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/storagetester.js', ['goog.storage.storageTester'], ['goog.storage.Storage', 'goog.structs.Map', 'goog.testing.asserts'], {});
goog.addDependency('streams/defines.js', ['goog.streams.defines'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full.js', ['goog.streams.full'], ['goog.streams.defines', 'goog.streams.fullImpl', 'goog.streams.fullNativeImpl', 'goog.streams.fullTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_impl.js', ['goog.streams.fullImpl'], ['goog.asserts', 'goog.promise.NativeResolver', 'goog.streams.fullTypes', 'goog.streams.liteImpl'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_impl_test.js', ['goog.streams.fullImplTest'], ['goog.streams.fullImpl', 'goog.streams.fullTestCases', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_native_impl.js', ['goog.streams.fullNativeImpl'], ['goog.streams.fullTypes', 'goog.streams.liteNativeImpl'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_native_impl_test.js', ['goog.streams.fullNativeImplTest'], ['goog.streams.fullNativeImpl', 'goog.streams.fullTestCases', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_test_cases.js', ['goog.streams.fullTestCases'], ['goog.streams.fullTypes', 'goog.streams.liteTestCases', 'goog.testing.recordFunction'], {'lang': 'es9', 'module': 'goog'});
goog.addDependency('streams/full_types.js', ['goog.streams.fullTypes'], ['goog.streams.liteTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite.js', ['goog.streams.lite'], ['goog.streams.defines', 'goog.streams.liteImpl', 'goog.streams.liteNativeImpl', 'goog.streams.liteTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_impl.js', ['goog.streams.liteImpl'], ['goog.asserts', 'goog.promise.NativeResolver', 'goog.streams.liteTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_impl_test.js', ['goog.streams.liteImplTest'], ['goog.streams.liteImpl', 'goog.streams.liteTestCases', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_native_impl.js', ['goog.streams.liteNativeImpl'], ['goog.streams.liteTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_native_impl_test.js', ['goog.streams.liteNativeImplTest'], ['goog.streams.liteNativeImpl', 'goog.streams.liteTestCases', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_test_cases.js', ['goog.streams.liteTestCases'], ['goog.streams.liteTypes', 'goog.testing.jsunit'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('streams/lite_types.js', ['goog.streams.liteTypes'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/const.js', ['goog.string.Const'], ['goog.asserts', 'goog.string.TypedString'], {});
goog.addDependency('string/const_test.js', ['goog.string.constTest'], ['goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/internal.js', ['goog.string.internal'], [], {'lang': 'es6'});
goog.addDependency('string/linkify.js', ['goog.string.linkify'], ['goog.html.SafeHtml', 'goog.string'], {});
goog.addDependency('string/linkify_test.js', ['goog.string.linkifyTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.string', 'goog.string.linkify', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/newlines.js', ['goog.string.newlines', 'goog.string.newlines.Line'], ['goog.array'], {});
goog.addDependency('string/newlines_test.js', ['goog.string.newlinesTest'], ['goog.string.newlines', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/parser.js', ['goog.string.Parser'], [], {});
goog.addDependency('string/path.js', ['goog.string.path'], ['goog.array', 'goog.string'], {});
goog.addDependency('string/path_test.js', ['goog.string.pathTest'], ['goog.string.path', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/string.js', ['goog.string', 'goog.string.Unicode'], ['goog.dom.safe', 'goog.html.uncheckedconversions', 'goog.string.Const', 'goog.string.internal'], {});
goog.addDependency('string/string_test.js', ['goog.stringTest'], ['goog.dom', 'goog.dom.TagName', 'goog.functions', 'goog.object', 'goog.string', 'goog.string.Unicode', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/stringbuffer.js', ['goog.string.StringBuffer'], [], {'lang': 'es6'});
goog.addDependency('string/stringbuffer_test.js', ['goog.string.StringBufferTest'], ['goog.string.StringBuffer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/stringformat.js', ['goog.string.format'], ['goog.string'], {});
goog.addDependency('string/stringformat_test.js', ['goog.string.formatTest'], ['goog.string.format', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/stringifier.js', ['goog.string.Stringifier'], [], {});
goog.addDependency('string/typedstring.js', ['goog.string.TypedString'], [], {});
goog.addDependency('structs/avltree.js', ['goog.structs.AvlTree'], ['goog.asserts', 'goog.structs.Collection'], {'module': 'goog'});
goog.addDependency('structs/avltree_test.js', ['goog.structs.AvlTreeTest'], ['goog.array', 'goog.structs.AvlTree', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/circularbuffer.js', ['goog.structs.CircularBuffer'], [], {'lang': 'es6'});
goog.addDependency('structs/circularbuffer_test.js', ['goog.structs.CircularBufferTest'], ['goog.structs.CircularBuffer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/collection.js', ['goog.structs.Collection'], [], {});
goog.addDependency('structs/collection_test.js', ['goog.structs.CollectionTest'], ['goog.structs.AvlTree', 'goog.structs.Set', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/heap.js', ['goog.structs.Heap'], ['goog.array', 'goog.object', 'goog.structs.Node'], {});
goog.addDependency('structs/heap_test.js', ['goog.structs.HeapTest'], ['goog.structs', 'goog.structs.Heap', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/inversionmap.js', ['goog.structs.InversionMap'], ['goog.array', 'goog.asserts'], {});
goog.addDependency('structs/inversionmap_test.js', ['goog.structs.InversionMapTest'], ['goog.structs.InversionMap', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/linkedmap.js', ['goog.structs.LinkedMap'], ['goog.structs.Map'], {});
goog.addDependency('structs/linkedmap_test.js', ['goog.structs.LinkedMapTest'], ['goog.structs.LinkedMap', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/map.js', ['goog.structs.Map'], ['goog.iter.Iterator', 'goog.iter.StopIteration'], {});
goog.addDependency('structs/map_test.js', ['goog.structs.MapTest'], ['goog.iter', 'goog.structs', 'goog.structs.Map', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/node.js', ['goog.structs.Node'], [], {});
goog.addDependency('structs/pool.js', ['goog.structs.Pool'], ['goog.Disposable', 'goog.structs.Queue', 'goog.structs.Set'], {});
goog.addDependency('structs/pool_test.js', ['goog.structs.PoolTest'], ['goog.structs.Pool', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/prioritypool.js', ['goog.structs.PriorityPool'], ['goog.structs.Pool', 'goog.structs.PriorityQueue'], {});
goog.addDependency('structs/prioritypool_test.js', ['goog.structs.PriorityPoolTest'], ['goog.structs.PriorityPool', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/priorityqueue.js', ['goog.structs.PriorityQueue'], ['goog.structs.Heap'], {});
goog.addDependency('structs/priorityqueue_test.js', ['goog.structs.PriorityQueueTest'], ['goog.structs', 'goog.structs.PriorityQueue', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/quadtree.js', ['goog.structs.QuadTree', 'goog.structs.QuadTree.Node', 'goog.structs.QuadTree.Point'], ['goog.math.Coordinate'], {});
goog.addDependency('structs/quadtree_test.js', ['goog.structs.QuadTreeTest'], ['goog.structs', 'goog.structs.QuadTree', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/queue.js', ['goog.structs.Queue'], ['goog.array'], {});
goog.addDependency('structs/queue_test.js', ['goog.structs.QueueTest'], ['goog.structs.Queue', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/set.js', ['goog.structs.Set'], ['goog.structs', 'goog.structs.Collection', 'goog.structs.Map'], {});
goog.addDependency('structs/set_test.js', ['goog.structs.SetTest'], ['goog.iter', 'goog.structs', 'goog.structs.Set', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/simplepool.js', ['goog.structs.SimplePool'], ['goog.Disposable'], {});
goog.addDependency('structs/stringset.js', ['goog.structs.StringSet'], ['goog.asserts', 'goog.iter'], {});
goog.addDependency('structs/stringset_test.js', ['goog.structs.StringSetTest'], ['goog.array', 'goog.iter', 'goog.structs.StringSet', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/structs.js', ['goog.structs'], ['goog.array', 'goog.object'], {});
goog.addDependency('structs/structs_test.js', ['goog.structsTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.structs', 'goog.structs.Map', 'goog.structs.Set', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/treenode.js', ['goog.structs.TreeNode'], ['goog.array', 'goog.asserts', 'goog.structs.Node'], {});
goog.addDependency('structs/treenode_test.js', ['goog.structs.TreeNodeTest'], ['goog.structs.TreeNode', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/trie.js', ['goog.structs.Trie'], ['goog.object', 'goog.structs'], {});
goog.addDependency('structs/trie_test.js', ['goog.structs.TrieTest'], ['goog.object', 'goog.structs', 'goog.structs.Trie', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/bidi.js', ['goog.style.bidi'], ['goog.dom', 'goog.style', 'goog.userAgent', 'goog.userAgent.platform', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('style/bidi_test.js', ['goog.style.bidiTest'], ['goog.dom', 'goog.style', 'goog.style.bidi', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/cursor.js', ['goog.style.cursor'], ['goog.userAgent'], {});
goog.addDependency('style/cursor_test.js', ['goog.style.cursorTest'], ['goog.style.cursor', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/style.js', ['goog.style'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.vendor', 'goog.html.SafeStyleSheet', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.math.Size', 'goog.object', 'goog.reflect', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('style/style_document_scroll_test.js', ['goog.style.style_document_scroll_test'], ['goog.dom', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/style_test.js', ['goog.style_test'], ['goog.array', 'goog.color', 'goog.dom', 'goog.dom.TagName', 'goog.events.BrowserEvent', 'goog.html.testing', 'goog.labs.userAgent.util', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.math.Size', 'goog.object', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.MockUserAgent', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgentTestUtil', 'goog.userAgentTestUtil.UserAgents'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/style_webkit_scrollbars_test.js', ['goog.style.webkitScrollbarsTest'], ['goog.asserts', 'goog.style', 'goog.styleScrollbarTester', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/stylescrollbartester.js', ['goog.styleScrollbarTester'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.testing.asserts'], {});
goog.addDependency('style/transform.js', ['goog.style.transform'], ['goog.functions', 'goog.math.Coordinate', 'goog.math.Coordinate3', 'goog.style', 'goog.userAgent', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('style/transform_test.js', ['goog.style.transformTest'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.style.transform', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/transition.js', ['goog.style.transition', 'goog.style.transition.Css3Property'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.dom.vendor', 'goog.functions', 'goog.html.SafeHtml', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('style/transition_test.js', ['goog.style.transitionTest'], ['goog.style', 'goog.style.transition', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('test_module.js', ['goog.test_module'], ['goog.test_module_dep'], {'module': 'goog'});
goog.addDependency('test_module_dep.js', ['goog.test_module_dep'], [], {'module': 'goog'});
goog.addDependency('testing/assertionfailure.js', ['goog.testing.safe.assertionFailure'], ['goog.asserts', 'goog.testing.asserts'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/asserts.js', ['goog.testing.asserts'], ['goog.testing.JsUnitException'], {});
goog.addDependency('testing/asserts_test.js', ['goog.testing.assertsTest'], ['goog.Promise', 'goog.array', 'goog.async.Deferred', 'goog.dom', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.structs.Map', 'goog.structs.Set', 'goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/async/mockcontrol.js', ['goog.testing.async.MockControl'], ['goog.asserts', 'goog.async.Deferred', 'goog.debug', 'goog.testing.MockControl', 'goog.testing.asserts', 'goog.testing.mockmatchers.IgnoreArgument'], {});
goog.addDependency('testing/async/mockcontrol_test.js', ['goog.testing.async.MockControlTest'], ['goog.async.Deferred', 'goog.testing.MockControl', 'goog.testing.asserts', 'goog.testing.async.MockControl', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/asynctestcase.js', ['goog.testing.AsyncTestCase', 'goog.testing.AsyncTestCase.ControlBreakingException'], ['goog.asserts', 'goog.testing.TestCase', 'goog.testing.asserts'], {});
goog.addDependency('testing/asynctestcase_async_test.js', ['goog.testing.AsyncTestCaseAsyncTest'], ['goog.testing.AsyncTestCase', 'goog.testing.TestCase', 'goog.testing.jsunit'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/asynctestcase_noasync_test.js', ['goog.testing.AsyncTestCaseSyncTest'], ['goog.testing.AsyncTestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/asynctestcase_test.js', ['goog.testing.AsyncTestCaseTest'], ['goog.debug.Error', 'goog.testing.AsyncTestCase', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/benchmark.js', ['goog.testing.benchmark'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.PerformanceTable', 'goog.testing.PerformanceTimer', 'goog.testing.TestCase'], {});
goog.addDependency('testing/continuationtestcase.js', ['goog.testing.ContinuationTestCase', 'goog.testing.ContinuationTestCase.ContinuationTest', 'goog.testing.ContinuationTestCase.Step'], ['goog.array', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.testing.TestCase', 'goog.testing.asserts'], {});
goog.addDependency('testing/continuationtestcase_test.js', ['goog.testing.ContinuationTestCaseTest'], ['goog.events', 'goog.events.EventTarget', 'goog.testing.ContinuationTestCase', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.jsunit'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/deferredtestcase.js', ['goog.testing.DeferredTestCase'], ['goog.async.Deferred', 'goog.testing.AsyncTestCase', 'goog.testing.TestCase'], {});
goog.addDependency('testing/deferredtestcase_test.js', ['goog.testing.DeferredTestCaseTest'], ['goog.async.Deferred', 'goog.testing.DeferredTestCase', 'goog.testing.TestCase', 'goog.testing.TestRunner', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/dom.js', ['goog.testing.dom'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.AbstractRange', 'goog.dom.InputType', 'goog.dom.NodeIterator', 'goog.dom.NodeType', 'goog.dom.TagIterator', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.iter', 'goog.object', 'goog.string', 'goog.style', 'goog.testing.asserts', 'goog.userAgent'], {});
goog.addDependency('testing/dom_test.js', ['goog.testing.domTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/editor/dom.js', ['goog.testing.editor.dom'], ['goog.dom.AbstractRange', 'goog.dom.NodeType', 'goog.dom.TagIterator', 'goog.dom.TagWalkType', 'goog.iter', 'goog.string', 'goog.testing.asserts'], {});
goog.addDependency('testing/editor/dom_test.js', ['goog.testing.editor.domTest'], ['goog.dom', 'goog.dom.TagName', 'goog.functions', 'goog.testing.editor.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/editor/fieldmock.js', ['goog.testing.editor.FieldMock'], ['goog.dom', 'goog.dom.Range', 'goog.editor.Field', 'goog.testing.LooseMock', 'goog.testing.mockmatchers'], {});
goog.addDependency('testing/editor/testhelper.js', ['goog.testing.editor.TestHelper'], ['goog.Disposable', 'goog.dom', 'goog.dom.Range', 'goog.editor.BrowserFeature', 'goog.editor.node', 'goog.editor.plugins.AbstractBubblePlugin', 'goog.testing.dom'], {});
goog.addDependency('testing/editor/testhelper_test.js', ['goog.testing.editor.TestHelperTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.node', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/events/eventobserver.js', ['goog.testing.events.EventObserver'], ['goog.array', 'goog.events.Event'], {});
goog.addDependency('testing/events/eventobserver_test.js', ['goog.testing.events.EventObserverTest'], ['goog.array', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.testing.events.EventObserver', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/events/events.js', ['goog.testing.events', 'goog.testing.events.Event'], ['goog.Disposable', 'goog.asserts', 'goog.dom.NodeType', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.BrowserFeature', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.object', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('testing/events/events_test.js', ['goog.testing.eventsTest'], ['goog.array', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Coordinate', 'goog.string', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/events/matchers.js', ['goog.testing.events.EventMatcher'], ['goog.events.Event', 'goog.testing.mockmatchers.ArgumentMatcher'], {});
goog.addDependency('testing/events/matchers_test.js', ['goog.testing.events.EventMatcherTest'], ['goog.events.Event', 'goog.testing.events.EventMatcher', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/events/onlinehandler.js', ['goog.testing.events.OnlineHandler'], ['goog.events.EventTarget', 'goog.net.NetworkStatusMonitor'], {});
goog.addDependency('testing/events/onlinehandler_test.js', ['goog.testing.events.OnlineHandlerTest'], ['goog.events', 'goog.net.NetworkStatusMonitor', 'goog.testing.events.EventObserver', 'goog.testing.events.OnlineHandler', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/expectedfailures.js', ['goog.testing.ExpectedFailures'], ['goog.asserts', 'goog.debug.DivConsole', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.log', 'goog.style', 'goog.testing.JsUnitException', 'goog.testing.TestCase', 'goog.testing.asserts'], {});
goog.addDependency('testing/expectedfailures_test.js', ['goog.testing.ExpectedFailuresTest'], ['goog.debug.Logger', 'goog.testing.ExpectedFailures', 'goog.testing.JsUnitException', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/blob.js', ['goog.testing.fs.Blob'], ['goog.crypt', 'goog.crypt.base64'], {});
goog.addDependency('testing/fs/blob_test.js', ['goog.testing.fs.BlobTest'], ['goog.dom', 'goog.testing.fs.Blob', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/directoryentry_test.js', ['goog.testing.fs.DirectoryEntryTest'], ['goog.array', 'goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.testing.MockClock', 'goog.testing.TestCase', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/entry.js', ['goog.testing.fs.DirectoryEntry', 'goog.testing.fs.Entry', 'goog.testing.fs.FileEntry'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.async.Deferred', 'goog.fs.DirectoryEntry', 'goog.fs.DirectoryEntryImpl', 'goog.fs.Entry', 'goog.fs.Error', 'goog.fs.FileEntry', 'goog.functions', 'goog.object', 'goog.string', 'goog.testing.fs.File', 'goog.testing.fs.FileWriter'], {});
goog.addDependency('testing/fs/entry_test.js', ['goog.testing.fs.EntryTest'], ['goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.testing.MockClock', 'goog.testing.TestCase', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/file.js', ['goog.testing.fs.File'], ['goog.testing.fs.Blob'], {});
goog.addDependency('testing/fs/fileentry_test.js', ['goog.testing.fs.FileEntryTest'], ['goog.testing.MockClock', 'goog.testing.fs.FileEntry', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/filereader.js', ['goog.testing.fs.FileReader'], ['goog.Timer', 'goog.events.EventTarget', 'goog.fs.Error', 'goog.fs.FileReader', 'goog.testing.fs.Blob', 'goog.testing.fs.ProgressEvent'], {});
goog.addDependency('testing/fs/filereader_test.js', ['goog.testing.fs.FileReaderTest'], ['goog.Promise', 'goog.array', 'goog.events', 'goog.fs.Error', 'goog.fs.FileReader', 'goog.object', 'goog.testing.events.EventObserver', 'goog.testing.fs.FileReader', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/filesystem.js', ['goog.testing.fs.FileSystem'], ['goog.fs.FileSystem', 'goog.testing.fs.DirectoryEntry'], {});
goog.addDependency('testing/fs/filewriter.js', ['goog.testing.fs.FileWriter'], ['goog.Timer', 'goog.events.EventTarget', 'goog.fs.Error', 'goog.fs.FileSaver', 'goog.string', 'goog.testing.fs.Blob', 'goog.testing.fs.File', 'goog.testing.fs.ProgressEvent'], {});
goog.addDependency('testing/fs/filewriter_test.js', ['goog.testing.fs.FileWriterTest'], ['goog.Promise', 'goog.array', 'goog.events', 'goog.fs.Error', 'goog.fs.FileSaver', 'goog.object', 'goog.testing.MockClock', 'goog.testing.events.EventObserver', 'goog.testing.fs.Blob', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/fs.js', ['goog.testing.fs'], ['goog.Timer', 'goog.array', 'goog.async.Deferred', 'goog.fs', 'goog.testing.PropertyReplacer', 'goog.testing.fs.Blob', 'goog.testing.fs.FileSystem'], {});
goog.addDependency('testing/fs/fs_test.js', ['goog.testing.fsTest'], ['goog.testing.fs', 'goog.testing.fs.Blob', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/integration_test.js', ['goog.testing.fs.integrationTest'], ['goog.Promise', 'goog.events', 'goog.fs', 'goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.fs.FileSaver', 'goog.testing.PropertyReplacer', 'goog.testing.fs', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/progressevent.js', ['goog.testing.fs.ProgressEvent'], ['goog.events.Event'], {});
goog.addDependency('testing/functionmock.js', ['goog.testing', 'goog.testing.FunctionMock', 'goog.testing.GlobalFunctionMock', 'goog.testing.MethodMock'], ['goog.object', 'goog.testing.LooseMock', 'goog.testing.Mock', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock'], {});
goog.addDependency('testing/functionmock_test.js', ['goog.testing.FunctionMockTest'], ['goog.array', 'goog.string', 'goog.testing', 'goog.testing.FunctionMock', 'goog.testing.Mock', 'goog.testing.StrictMock', 'goog.testing.asserts', 'goog.testing.mockmatchers', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/graphics.js', ['goog.testing.graphics'], ['goog.graphics.Path', 'goog.testing.asserts'], {});
goog.addDependency('testing/i18n/asserts.js', ['goog.testing.i18n.asserts'], ['goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('testing/i18n/asserts_test.js', ['goog.testing.i18n.assertsTest'], ['goog.testing.ExpectedFailures', 'goog.testing.i18n.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/jstdasyncwrapper.js', ['goog.testing.JsTdAsyncWrapper'], ['goog.Promise'], {});
goog.addDependency('testing/jstdtestcaseadapter.js', ['goog.testing.JsTdTestCaseAdapter'], ['goog.async.run', 'goog.functions', 'goog.testing.JsTdAsyncWrapper', 'goog.testing.TestCase', 'goog.testing.jsunit'], {});
goog.addDependency('testing/jsunit.js', ['goog.testing.jsunit'], ['goog.dom.TagName', 'goog.testing.TestCase', 'goog.testing.TestRunner', 'goog.userAgent'], {});
goog.addDependency('testing/jsunitexception.js', ['goog.testing.JsUnitException'], ['goog.testing.stacktrace'], {});
goog.addDependency('testing/loosemock.js', ['goog.testing.LooseExpectationCollection', 'goog.testing.LooseMock'], ['goog.array', 'goog.asserts', 'goog.structs.Map', 'goog.structs.Set', 'goog.testing.Mock'], {});
goog.addDependency('testing/loosemock_test.js', ['goog.testing.LooseMockTest'], ['goog.testing.LooseMock', 'goog.testing.mockmatchers', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/messaging/mockmessagechannel.js', ['goog.testing.messaging.MockMessageChannel'], ['goog.messaging.AbstractChannel', 'goog.testing.MockControl', 'goog.testing.asserts'], {});
goog.addDependency('testing/messaging/mockmessageevent.js', ['goog.testing.messaging.MockMessageEvent'], ['goog.events.BrowserEvent', 'goog.events.EventType', 'goog.testing.events.Event'], {});
goog.addDependency('testing/messaging/mockmessageport.js', ['goog.testing.messaging.MockMessagePort'], ['goog.events.EventTarget', 'goog.testing.MockControl'], {});
goog.addDependency('testing/messaging/mockportnetwork.js', ['goog.testing.messaging.MockPortNetwork'], ['goog.messaging.PortNetwork', 'goog.testing.messaging.MockMessageChannel'], {});
goog.addDependency('testing/mock.js', ['goog.testing.Mock', 'goog.testing.MockExpectation'], ['goog.Promise', 'goog.array', 'goog.asserts', 'goog.object', 'goog.promise.Resolver', 'goog.testing.JsUnitException', 'goog.testing.MockInterface', 'goog.testing.mockmatchers'], {});
goog.addDependency('testing/mock_test.js', ['goog.testing.MockTest'], ['goog.array', 'goog.testing', 'goog.testing.Mock', 'goog.testing.MockControl', 'goog.testing.MockExpectation', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/mockclassfactory.js', ['goog.testing.MockClassFactory', 'goog.testing.MockClassRecord'], ['goog.array', 'goog.object', 'goog.testing.LooseMock', 'goog.testing.StrictMock', 'goog.testing.TestCase', 'goog.testing.mockmatchers'], {});
goog.addDependency('testing/mockclassfactory_test.js', ['fake.BaseClass', 'fake.ChildClass', 'goog.testing.MockClassFactoryTest'], ['goog.testing', 'goog.testing.MockClassFactory', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('testing/mockclock.js', ['goog.testing.MockClock'], ['goog.Disposable', 'goog.Promise', 'goog.Thenable', 'goog.async.run', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.events.Event'], {});
goog.addDependency('testing/mockclock_test.js', ['goog.testing.MockClockTest'], ['goog.Promise', 'goog.Timer', 'goog.events', 'goog.functions', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockcontrol.js', ['goog.testing.MockControl'], ['goog.Promise', 'goog.array', 'goog.testing', 'goog.testing.LooseMock', 'goog.testing.StrictMock'], {});
goog.addDependency('testing/mockcontrol_test.js', ['goog.testing.MockControlTest'], ['goog.testing.Mock', 'goog.testing.MockControl', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockinterface.js', ['goog.testing.MockInterface'], ['goog.Promise'], {});
goog.addDependency('testing/mockmatchers.js', ['goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.mockmatchers.IgnoreArgument', 'goog.testing.mockmatchers.InstanceOf', 'goog.testing.mockmatchers.ObjectEquals', 'goog.testing.mockmatchers.RegexpMatch', 'goog.testing.mockmatchers.SaveArgument', 'goog.testing.mockmatchers.TypeOf'], ['goog.array', 'goog.dom', 'goog.testing.asserts'], {});
goog.addDependency('testing/mockmatchers_test.js', ['goog.testing.mockmatchersTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.jsunit', 'goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher'], {'lang': 'es6'});
goog.addDependency('testing/mockrandom.js', ['goog.testing.MockRandom'], ['goog.Disposable'], {});
goog.addDependency('testing/mockrandom_test.js', ['goog.testing.MockRandomTest'], ['goog.testing.MockRandom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockrange.js', ['goog.testing.MockRange'], ['goog.dom.AbstractRange', 'goog.testing.LooseMock'], {});
goog.addDependency('testing/mockrange_test.js', ['goog.testing.MockRangeTest'], ['goog.testing.MockRange', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockstorage.js', ['goog.testing.MockStorage'], ['goog.structs.Map'], {});
goog.addDependency('testing/mockstorage_test.js', ['goog.testing.MockStorageTest'], ['goog.testing.MockStorage', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockuseragent.js', ['goog.testing.MockUserAgent'], ['goog.Disposable', 'goog.labs.userAgent.util', 'goog.testing.PropertyReplacer', 'goog.userAgent'], {});
goog.addDependency('testing/mockuseragent_test.js', ['goog.testing.MockUserAgentTest'], ['goog.dispose', 'goog.testing.MockUserAgent', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/multitestrunner.js', ['goog.testing.MultiTestRunner', 'goog.testing.MultiTestRunner.TestFrame'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventHandler', 'goog.functions', 'goog.object', 'goog.string', 'goog.testing.TestCase', 'goog.ui.Component', 'goog.ui.ServerChart', 'goog.ui.TableSorter'], {});
goog.addDependency('testing/multitestrunner_test.js', ['goog.testing.MultiTestRunnerTest'], ['goog.Promise', 'goog.array', 'goog.events', 'goog.testing.MockControl', 'goog.testing.MultiTestRunner', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/net/mockiframeio.js', ['goog.testing.net.MockIFrameIo'], ['goog.events.EventTarget', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.IframeIo', 'goog.testing.TestQueue'], {});
goog.addDependency('testing/net/xhrio.js', ['goog.testing.net.XhrIo'], ['goog.Uri', 'goog.array', 'goog.dom.xml', 'goog.events', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.HttpStatus', 'goog.net.XhrIo', 'goog.net.XmlHttp', 'goog.object', 'goog.structs', 'goog.structs.Map', 'goog.testing.TestQueue', 'goog.uri.utils'], {});
goog.addDependency('testing/net/xhrio_test.js', ['goog.testing.net.XhrIoTest'], ['goog.dom.xml', 'goog.events', 'goog.events.Event', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.XmlHttp', 'goog.object', 'goog.testing.MockControl', 'goog.testing.asserts', 'goog.testing.mockmatchers.InstanceOf', 'goog.testing.net.XhrIo', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/net/xhriopool.js', ['goog.testing.net.XhrIoPool'], ['goog.net.XhrIoPool', 'goog.testing.net.XhrIo'], {});
goog.addDependency('testing/objectpropertystring.js', ['goog.testing.ObjectPropertyString'], [], {});
goog.addDependency('testing/parallel_closure_test_suite.js', ['goog.testing.parallelClosureTestSuite'], ['goog.Promise', 'goog.asserts', 'goog.events', 'goog.json', 'goog.testing.MultiTestRunner', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/parallel_closure_test_suite_test.js', ['goog.testing.parallelClosureTestSuiteTest'], ['goog.dom', 'goog.testing.MockControl', 'goog.testing.MultiTestRunner', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.parallelClosureTestSuite', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/performancetable.js', ['goog.testing.PerformanceTable'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.testing.PerformanceTimer'], {});
goog.addDependency('testing/performancetimer.js', ['goog.testing.PerformanceTimer', 'goog.testing.PerformanceTimer.Task'], ['goog.array', 'goog.async.Deferred', 'goog.math'], {'lang': 'es6'});
goog.addDependency('testing/performancetimer_test.js', ['goog.testing.PerformanceTimerTest'], ['goog.async.Deferred', 'goog.dom', 'goog.math', 'goog.testing.MockClock', 'goog.testing.PerformanceTimer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/propertyreplacer.js', ['goog.testing.PropertyReplacer'], ['goog.asserts', 'goog.userAgent'], {});
goog.addDependency('testing/propertyreplacer_test.js', ['goog.testing.PropertyReplacerTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/proto2/proto2.js', ['goog.testing.proto2'], ['goog.proto2.Message', 'goog.proto2.ObjectSerializer', 'goog.testing.asserts'], {});
goog.addDependency('testing/proto2/proto2_test.js', ['goog.testing.proto2Test'], ['goog.testing.proto2', 'goog.testing.testSuite', 'proto2.TestAllTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/pseudorandom.js', ['goog.testing.PseudoRandom'], ['goog.Disposable'], {});
goog.addDependency('testing/pseudorandom_test.js', ['goog.testing.PseudoRandomTest'], ['goog.testing.PseudoRandom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/recordfunction.js', ['goog.testing.FunctionCall', 'goog.testing.recordConstructor', 'goog.testing.recordFunction'], ['goog.Promise', 'goog.promise.Resolver', 'goog.testing.asserts'], {});
goog.addDependency('testing/recordfunction_test.js', ['goog.testing.recordFunctionTest'], ['goog.functions', 'goog.testing.PropertyReplacer', 'goog.testing.recordConstructor', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/shardingtestcase.js', ['goog.testing.ShardingTestCase'], ['goog.asserts', 'goog.testing.TestCase'], {});
goog.addDependency('testing/shardingtestcase_test.js', ['goog.testing.ShardingTestCaseTest'], ['goog.testing.ShardingTestCase', 'goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.jsunit'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/singleton.js', ['goog.testing.singleton'], [], {'lang': 'es6'});
goog.addDependency('testing/singleton_test.js', ['goog.testing.singletonTest'], ['goog.testing.asserts', 'goog.testing.singleton', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/stacktrace.js', ['goog.testing.stacktrace', 'goog.testing.stacktrace.Frame'], [], {'lang': 'es6'});
goog.addDependency('testing/stacktrace_test.js', ['goog.testing.stacktraceTest'], ['goog.functions', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock', 'goog.testing.asserts', 'goog.testing.stacktrace', 'goog.testing.stacktrace.Frame', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/storage/fakemechanism.js', ['goog.testing.storage.FakeMechanism'], ['goog.storage.mechanism.IterableMechanism', 'goog.structs.Map'], {});
goog.addDependency('testing/strictmock.js', ['goog.testing.StrictMock'], ['goog.array', 'goog.asserts', 'goog.structs.Set', 'goog.testing.Mock'], {});
goog.addDependency('testing/strictmock_test.js', ['goog.testing.StrictMockTest'], ['goog.testing.StrictMock', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/style/layoutasserts.js', ['goog.testing.style.layoutasserts'], ['goog.style', 'goog.testing.asserts', 'goog.testing.style'], {});
goog.addDependency('testing/style/layoutasserts_test.js', ['goog.testing.style.layoutassertsTest'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.testing.style.layoutasserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/style/style.js', ['goog.testing.style'], ['goog.dom', 'goog.math.Rect', 'goog.style'], {});
goog.addDependency('testing/style/style_test.js', ['goog.testing.styleTest'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.testing.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/testcase.js', ['goog.testing.TestCase', 'goog.testing.TestCase.Error', 'goog.testing.TestCase.Order', 'goog.testing.TestCase.Result', 'goog.testing.TestCase.Test'], ['goog.Promise', 'goog.Thenable', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.object', 'goog.testing.JsUnitException', 'goog.testing.asserts'], {});
goog.addDependency('testing/testcase_test.js', ['goog.testing.TestCaseTest'], ['goog.Promise', 'goog.Timer', 'goog.functions', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.FunctionMock', 'goog.testing.JsUnitException', 'goog.testing.MethodMock', 'goog.testing.MockRandom', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/testqueue.js', ['goog.testing.TestQueue'], [], {});
goog.addDependency('testing/testrunner.js', ['goog.testing.TestRunner'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.json', 'goog.testing.TestCase', 'goog.userAgent'], {});
goog.addDependency('testing/testrunner_test.js', ['goog.testing.TestRunnerTest'], ['goog.testing.TestCase', 'goog.testing.TestRunner', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/testsuite.js', ['goog.testing.testSuite'], ['goog.labs.testing.Environment', 'goog.testing.TestCase'], {});
goog.addDependency('testing/testsuite_test.js', ['goog.testing.testSuiteTest'], ['goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/ui/rendererasserts.js', ['goog.testing.ui.rendererasserts'], ['goog.testing.asserts', 'goog.ui.ControlRenderer'], {});
goog.addDependency('testing/ui/rendererasserts_test.js', ['goog.testing.ui.rendererassertsTest'], ['goog.testing.asserts', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.ControlRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/ui/rendererharness.js', ['goog.testing.ui.RendererHarness'], ['goog.Disposable', 'goog.dom.NodeType', 'goog.testing.asserts', 'goog.testing.dom', 'goog.ui.Control', 'goog.ui.ControlRenderer'], {});
goog.addDependency('testing/ui/style.js', ['goog.testing.ui.style'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.testing.asserts'], {});
goog.addDependency('testing/ui/style_test.js', ['goog.testing.ui.styleTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.style'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('timer/timer.js', ['goog.Timer'], ['goog.Promise', 'goog.events.EventTarget'], {});
goog.addDependency('timer/timer_test.js', ['goog.TimerTest'], ['goog.Promise', 'goog.Timer', 'goog.events', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('tweak/entries.js', ['goog.tweak.BaseEntry', 'goog.tweak.BasePrimitiveSetting', 'goog.tweak.BaseSetting', 'goog.tweak.BooleanGroup', 'goog.tweak.BooleanInGroupSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.ButtonAction', 'goog.tweak.NumericSetting', 'goog.tweak.StringSetting'], ['goog.array', 'goog.asserts', 'goog.log', 'goog.object'], {});
goog.addDependency('tweak/entries_test.js', ['goog.tweak.BaseEntryTest'], ['goog.testing.MockControl', 'goog.testing.testSuite', 'goog.tweak.testhelpers'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('tweak/registry.js', ['goog.tweak.Registry'], ['goog.array', 'goog.asserts', 'goog.log', 'goog.string', 'goog.tweak.BasePrimitiveSetting', 'goog.tweak.BaseSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.NumericSetting', 'goog.tweak.StringSetting', 'goog.uri.utils'], {});
goog.addDependency('tweak/registry_test.js', ['goog.tweak.RegistryTest'], ['goog.asserts.AssertionError', 'goog.testing.testSuite', 'goog.tweak', 'goog.tweak.testhelpers'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('tweak/testhelpers.js', ['goog.tweak.testhelpers'], ['goog.tweak', 'goog.tweak.BooleanGroup', 'goog.tweak.BooleanInGroupSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.ButtonAction', 'goog.tweak.NumericSetting', 'goog.tweak.Registry', 'goog.tweak.StringSetting'], {});
goog.addDependency('tweak/tweak.js', ['goog.tweak', 'goog.tweak.ConfigParams'], ['goog.asserts', 'goog.tweak.BaseSetting', 'goog.tweak.BooleanGroup', 'goog.tweak.BooleanInGroupSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.ButtonAction', 'goog.tweak.NumericSetting', 'goog.tweak.Registry', 'goog.tweak.StringSetting'], {});
goog.addDependency('tweak/tweakui.js', ['goog.tweak.EntriesPanel', 'goog.tweak.TweakUi'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.object', 'goog.string.Const', 'goog.style', 'goog.tweak', 'goog.tweak.BaseEntry', 'goog.tweak.BooleanGroup', 'goog.tweak.BooleanInGroupSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.ButtonAction', 'goog.tweak.NumericSetting', 'goog.tweak.StringSetting', 'goog.ui.Zippy', 'goog.userAgent'], {});
goog.addDependency('tweak/tweakui_test.js', ['goog.tweak.TweakUiTest'], ['goog.dom', 'goog.dom.TagName', 'goog.string', 'goog.testing.testSuite', 'goog.tweak', 'goog.tweak.TweakUi', 'goog.tweak.testhelpers'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/abstractspellchecker.js', ['goog.ui.AbstractSpellChecker', 'goog.ui.AbstractSpellChecker.AsyncResult'], ['goog.a11y.aria', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.selection', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.math.Coordinate', 'goog.spell.SpellCheck', 'goog.structs.Set', 'goog.style', 'goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.MenuSeparator', 'goog.ui.PopupMenu'], {});
goog.addDependency('ui/ac/ac.js', ['goog.ui.ac'], ['goog.ui.ac.ArrayMatcher', 'goog.ui.ac.AutoComplete', 'goog.ui.ac.InputHandler', 'goog.ui.ac.Renderer'], {});
goog.addDependency('ui/ac/ac_test.js', ['goog.ui.acTest'], ['goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.classlist', 'goog.dom.selection', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.ac', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/arraymatcher.js', ['goog.ui.ac.ArrayMatcher'], ['goog.string'], {});
goog.addDependency('ui/ac/arraymatcher_test.js', ['goog.ui.ac.ArrayMatcherTest'], ['goog.testing.testSuite', 'goog.ui.ac.ArrayMatcher'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/autocomplete.js', ['goog.ui.ac.AutoComplete', 'goog.ui.ac.AutoComplete.EventType'], ['goog.array', 'goog.asserts', 'goog.events', 'goog.events.EventTarget', 'goog.object', 'goog.ui.ac.RenderOptions'], {});
goog.addDependency('ui/ac/autocomplete_test.js', ['goog.ui.ac.AutoCompleteTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.string', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.ui.ac.AutoComplete', 'goog.ui.ac.InputHandler', 'goog.ui.ac.RenderOptions', 'goog.ui.ac.Renderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/cachingmatcher.js', ['goog.ui.ac.CachingMatcher'], ['goog.array', 'goog.async.Throttle', 'goog.ui.ac.ArrayMatcher', 'goog.ui.ac.RenderOptions'], {});
goog.addDependency('ui/ac/cachingmatcher_test.js', ['goog.ui.ac.CachingMatcherTest'], ['goog.testing.MockControl', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.ui.ac.CachingMatcher'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/inputhandler.js', ['goog.ui.ac.InputHandler'], ['goog.Disposable', 'goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.selection', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.string', 'goog.userAgent', 'goog.userAgent.product'], {});
goog.addDependency('ui/ac/inputhandler_test.js', ['goog.ui.ac.InputHandlerTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.selection', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.functions', 'goog.object', 'goog.testing.MockClock', 'goog.testing.testSuite', 'goog.ui.ac.InputHandler', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/remote.js', ['goog.ui.ac.Remote'], ['goog.ui.ac.AutoComplete', 'goog.ui.ac.InputHandler', 'goog.ui.ac.RemoteArrayMatcher', 'goog.ui.ac.Renderer'], {});
goog.addDependency('ui/ac/remotearraymatcher.js', ['goog.ui.ac.RemoteArrayMatcher'], ['goog.Disposable', 'goog.Uri', 'goog.events', 'goog.net.EventType', 'goog.net.XhrIo'], {});
goog.addDependency('ui/ac/remotearraymatcher_test.js', ['goog.ui.ac.RemoteArrayMatcherTest'], ['goog.net.XhrIo', 'goog.testing.MockControl', 'goog.testing.net.XhrIo', 'goog.testing.testSuite', 'goog.ui.ac.RemoteArrayMatcher'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/renderer.js', ['goog.ui.ac.Renderer', 'goog.ui.ac.Renderer.CustomRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dispose', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.fx.dom.FadeInAndShow', 'goog.fx.dom.FadeOutAndHide', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.string', 'goog.style', 'goog.ui.IdGenerator', 'goog.ui.ac.AutoComplete'], {'lang': 'es6'});
goog.addDependency('ui/ac/renderer_test.js', ['goog.ui.ac.RendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.fx.dom.FadeInAndShow', 'goog.fx.dom.FadeOutAndHide', 'goog.string', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.ac.AutoComplete', 'goog.ui.ac.Renderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/renderoptions.js', ['goog.ui.ac.RenderOptions'], [], {});
goog.addDependency('ui/ac/richinputhandler.js', ['goog.ui.ac.RichInputHandler'], ['goog.ui.ac.InputHandler'], {});
goog.addDependency('ui/ac/richremote.js', ['goog.ui.ac.RichRemote'], ['goog.ui.ac.AutoComplete', 'goog.ui.ac.Remote', 'goog.ui.ac.Renderer', 'goog.ui.ac.RichInputHandler', 'goog.ui.ac.RichRemoteArrayMatcher'], {});
goog.addDependency('ui/ac/richremotearraymatcher.js', ['goog.ui.ac.RichRemoteArrayMatcher'], ['goog.dom', 'goog.ui.ac.RemoteArrayMatcher'], {});
goog.addDependency('ui/ac/richremotearraymatcher_test.js', ['goog.ui.ac.RichRemoteArrayMatcherTest'], ['goog.net.XhrIo', 'goog.testing.MockControl', 'goog.testing.net.XhrIo', 'goog.testing.testSuite', 'goog.ui.ac.RichRemoteArrayMatcher'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/activitymonitor.js', ['goog.ui.ActivityMonitor'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType'], {});
goog.addDependency('ui/activitymonitor_test.js', ['goog.ui.ActivityMonitorTest'], ['goog.dom', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.ActivityMonitor'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/advancedtooltip.js', ['goog.ui.AdvancedTooltip'], ['goog.events', 'goog.events.EventType', 'goog.math.Box', 'goog.math.Coordinate', 'goog.style', 'goog.ui.Tooltip', 'goog.userAgent'], {});
goog.addDependency('ui/advancedtooltip_test.js', ['goog.ui.AdvancedTooltipTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events.Event', 'goog.events.EventType', 'goog.math.Box', 'goog.math.Coordinate', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.AdvancedTooltip', 'goog.ui.Tooltip', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/animatedzippy.js', ['goog.ui.AnimatedZippy'], ['goog.a11y.aria.Role', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.fx.easing', 'goog.ui.Zippy', 'goog.ui.ZippyEvent'], {});
goog.addDependency('ui/animatedzippy_test.js', ['goog.ui.AnimatedZippyTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.events', 'goog.functions', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.ui.AnimatedZippy', 'goog.ui.Zippy'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/attachablemenu.js', ['goog.ui.AttachableMenu'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events.Event', 'goog.events.KeyCodes', 'goog.string', 'goog.style', 'goog.ui.ItemEvent', 'goog.ui.MenuBase', 'goog.ui.PopupBase', 'goog.userAgent'], {});
goog.addDependency('ui/bidiinput.js', ['goog.ui.BidiInput'], ['goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.InputHandler', 'goog.i18n.bidi', 'goog.ui.Component'], {});
goog.addDependency('ui/bidiinput_test.js', ['goog.ui.BidiInputTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.BidiInput'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/bubble.js', ['goog.ui.Bubble'], ['goog.Timer', 'goog.dom.safe', 'goog.events', 'goog.events.EventType', 'goog.html.SafeHtml', 'goog.math.Box', 'goog.positioning', 'goog.positioning.AbsolutePosition', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.positioning.CornerBit', 'goog.string.Const', 'goog.style', 'goog.ui.Component', 'goog.ui.Popup'], {});
goog.addDependency('ui/button.js', ['goog.ui.Button', 'goog.ui.Button.Side'], ['goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.ui.ButtonRenderer', 'goog.ui.ButtonSide', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.NativeButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/button_test.js', ['goog.ui.ButtonTest'], ['goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Button', 'goog.ui.ButtonRenderer', 'goog.ui.ButtonSide', 'goog.ui.Component', 'goog.ui.NativeButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/buttonrenderer.js', ['goog.ui.ButtonRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.ui.ButtonSide', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/buttonrenderer_test.js', ['goog.ui.ButtonRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Button', 'goog.ui.ButtonRenderer', 'goog.ui.ButtonSide', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/buttonside.js', ['goog.ui.ButtonSide'], [], {});
goog.addDependency('ui/charcounter.js', ['goog.ui.CharCounter', 'goog.ui.CharCounter.Display'], ['goog.dom', 'goog.events', 'goog.events.EventTarget', 'goog.events.InputHandler'], {});
goog.addDependency('ui/charcounter_test.js', ['goog.ui.CharCounterTest'], ['goog.dom', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.ui.CharCounter', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/charpicker.js', ['goog.ui.CharPicker'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.i18n.CharListDecompressor', 'goog.i18n.CharPickerData', 'goog.i18n.uChar', 'goog.i18n.uChar.NameFetcher', 'goog.structs.Set', 'goog.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.ContainerScroller', 'goog.ui.FlatButtonRenderer', 'goog.ui.HoverCard', 'goog.ui.LabelInput', 'goog.ui.Menu', 'goog.ui.MenuButton', 'goog.ui.MenuItem', 'goog.ui.Tooltip'], {});
goog.addDependency('ui/charpicker_test.js', ['goog.ui.CharPickerTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dispose', 'goog.dom', 'goog.events.Event', 'goog.events.EventType', 'goog.i18n.CharPickerData', 'goog.i18n.uChar.NameFetcher', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.ui.CharPicker', 'goog.ui.FlatButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/checkbox.js', ['goog.ui.Checkbox', 'goog.ui.Checkbox.State'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.string', 'goog.ui.CheckboxRenderer', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.registry'], {});
goog.addDependency('ui/checkbox_test.js', ['goog.ui.CheckboxTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.KeyCodes', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Checkbox', 'goog.ui.CheckboxRenderer', 'goog.ui.Component', 'goog.ui.ControlRenderer', 'goog.ui.decorate'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/checkboxmenuitem.js', ['goog.ui.CheckBoxMenuItem'], ['goog.ui.MenuItem', 'goog.ui.registry'], {});
goog.addDependency('ui/checkboxrenderer.js', ['goog.ui.CheckboxRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.object', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/colormenubutton.js', ['goog.ui.ColorMenuButton'], ['goog.array', 'goog.object', 'goog.ui.ColorMenuButtonRenderer', 'goog.ui.ColorPalette', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.MenuButton', 'goog.ui.registry'], {});
goog.addDependency('ui/colormenubuttonrenderer.js', ['goog.ui.ColorMenuButtonRenderer'], ['goog.asserts', 'goog.color', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.MenuButtonRenderer', 'goog.userAgent'], {});
goog.addDependency('ui/colormenubuttonrenderer_test.js', ['goog.ui.ColorMenuButtonTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.testing.ui.RendererHarness', 'goog.testing.ui.rendererasserts', 'goog.ui.ColorMenuButton', 'goog.ui.ColorMenuButtonRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/colorpalette.js', ['goog.ui.ColorPalette'], ['goog.array', 'goog.color', 'goog.dom.TagName', 'goog.style', 'goog.ui.Palette', 'goog.ui.PaletteRenderer'], {});
goog.addDependency('ui/colorpalette_test.js', ['goog.ui.ColorPaletteTest'], ['goog.color', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.ColorPalette'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/colorpicker.js', ['goog.ui.ColorPicker', 'goog.ui.ColorPicker.EventType'], ['goog.ui.ColorPalette', 'goog.ui.Component'], {});
goog.addDependency('ui/combobox.js', ['goog.ui.ComboBox', 'goog.ui.ComboBoxItem'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.log', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.ItemEvent', 'goog.ui.LabelInput', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.MenuSeparator', 'goog.ui.registry', 'goog.userAgent'], {});
goog.addDependency('ui/combobox_test.js', ['goog.ui.ComboBoxTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.KeyCodes', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.ComboBox', 'goog.ui.ComboBoxItem', 'goog.ui.Component', 'goog.ui.ControlRenderer', 'goog.ui.LabelInput', 'goog.ui.Menu', 'goog.ui.MenuItem'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/component.js', ['goog.ui.Component', 'goog.ui.Component.Error', 'goog.ui.Component.EventType', 'goog.ui.Component.State'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.object', 'goog.style', 'goog.ui.IdGenerator'], {});
goog.addDependency('ui/component_test.js', ['goog.ui.ComponentTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.events.EventTarget', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.Component'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/componentutil.js', ['goog.ui.ComponentUtil'], ['goog.events.MouseAsMouseEventType', 'goog.events.MouseEvents', 'goog.events.PointerAsMouseEventType'], {});
goog.addDependency('ui/componentutil_test.js', ['goog.ui.ComponentUtilTest'], ['goog.events.MouseAsMouseEventType', 'goog.events.PointerAsMouseEventType', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.ComponentUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/container.js', ['goog.ui.Container', 'goog.ui.Container.EventType', 'goog.ui.Container.Orientation'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.object', 'goog.style', 'goog.ui.Component', 'goog.ui.ComponentUtil', 'goog.ui.ContainerRenderer', 'goog.ui.Control'], {});
goog.addDependency('ui/container_test.js', ['goog.ui.ContainerTest'], ['goog.a11y.aria', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.KeyCodes', 'goog.events.KeyEvent', 'goog.events.PointerFallbackEventType', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Container', 'goog.ui.Control'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/containerrenderer.js', ['goog.ui.ContainerRenderer'], ['goog.a11y.aria', 'goog.array', 'goog.asserts', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.string', 'goog.style', 'goog.ui.registry', 'goog.userAgent'], {});
goog.addDependency('ui/containerrenderer_test.js', ['goog.ui.ContainerRendererTest'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Container', 'goog.ui.ContainerRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/containerscroller.js', ['goog.ui.ContainerScroller'], ['goog.Disposable', 'goog.Timer', 'goog.events.EventHandler', 'goog.style', 'goog.ui.Component', 'goog.ui.Container'], {});
goog.addDependency('ui/containerscroller_test.js', ['goog.ui.ContainerScrollerTest'], ['goog.dom', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Container', 'goog.ui.ContainerScroller'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/control.js', ['goog.ui.Control'], ['goog.Disposable', 'goog.array', 'goog.dom', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.string', 'goog.ui.Component', 'goog.ui.ComponentUtil', 'goog.ui.ControlContent', 'goog.ui.ControlRenderer', 'goog.ui.registry', 'goog.userAgent'], {});
goog.addDependency('ui/control_test.js', ['goog.ui.ControlTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.events.PointerFallbackEventType', 'goog.html.testing', 'goog.object', 'goog.string', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.ControlRenderer', 'goog.ui.registry', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/controlcontent.js', ['goog.ui.ControlContent'], [], {});
goog.addDependency('ui/controlrenderer.js', ['goog.ui.ControlRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.object', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.ControlContent', 'goog.userAgent'], {});
goog.addDependency('ui/controlrenderer_test.js', ['goog.ui.ControlRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.object', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.ControlRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/cookieeditor.js', ['goog.ui.CookieEditor'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.events.EventType', 'goog.net.cookies', 'goog.string', 'goog.style', 'goog.ui.Component'], {});
goog.addDependency('ui/cookieeditor_test.js', ['goog.ui.CookieEditorTest'], ['goog.dom', 'goog.events.Event', 'goog.events.EventType', 'goog.net.cookies', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.CookieEditor'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/css3buttonrenderer.js', ['goog.ui.Css3ButtonRenderer'], ['goog.asserts', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Button', 'goog.ui.ButtonRenderer', 'goog.ui.Component', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.registry'], {});
goog.addDependency('ui/css3menubuttonrenderer.js', ['goog.ui.Css3MenuButtonRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.MenuButton', 'goog.ui.MenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/cssnames.js', ['goog.ui.INLINE_BLOCK_CLASSNAME'], [], {});
goog.addDependency('ui/custombutton.js', ['goog.ui.CustomButton'], ['goog.ui.Button', 'goog.ui.CustomButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/custombuttonrenderer.js', ['goog.ui.CustomButtonRenderer'], ['goog.a11y.aria.Role', 'goog.asserts', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.string', 'goog.ui.ButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME'], {});
goog.addDependency('ui/customcolorpalette.js', ['goog.ui.CustomColorPalette'], ['goog.color', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.ColorPalette', 'goog.ui.Component'], {});
goog.addDependency('ui/customcolorpalette_test.js', ['goog.ui.CustomColorPaletteTest'], ['goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.ui.CustomColorPalette'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/datepicker.js', ['goog.ui.DatePicker', 'goog.ui.DatePicker.Events', 'goog.ui.DatePickerEvent'], ['goog.a11y.aria', 'goog.asserts', 'goog.date.Date', 'goog.date.DateRange', 'goog.date.Interval', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyHandler', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimePatterns', 'goog.i18n.DateTimeSymbols', 'goog.style', 'goog.ui.Component', 'goog.ui.DefaultDatePickerRenderer', 'goog.ui.IdGenerator'], {});
goog.addDependency('ui/datepicker_test.js', ['goog.ui.DatePickerTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.date.Date', 'goog.date.DateRange', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.KeyCodes', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbols_en_US', 'goog.i18n.DateTimeSymbols_zh_HK', 'goog.style', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.DatePicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/datepickerrenderer.js', ['goog.ui.DatePickerRenderer'], [], {});
goog.addDependency('ui/decorate.js', ['goog.ui.decorate'], ['goog.ui.registry'], {});
goog.addDependency('ui/decorate_test.js', ['goog.ui.decorateTest'], ['goog.testing.testSuite', 'goog.ui.decorate', 'goog.ui.registry'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/defaultdatepickerrenderer.js', ['goog.ui.DefaultDatePickerRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.ui.DatePickerRenderer'], {});
goog.addDependency('ui/dialog.js', ['goog.ui.Dialog', 'goog.ui.Dialog.ButtonSet', 'goog.ui.Dialog.ButtonSet.DefaultButtons', 'goog.ui.Dialog.DefaultButtonCaptions', 'goog.ui.Dialog.DefaultButtonKeys', 'goog.ui.Dialog.Event', 'goog.ui.Dialog.EventType'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.safe', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.Keys', 'goog.fx.Dragger', 'goog.html.SafeHtml', 'goog.math.Rect', 'goog.string', 'goog.structs.Map', 'goog.style', 'goog.ui.ModalPopup'], {});
goog.addDependency('ui/dialog_test.js', ['goog.ui.DialogTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.fx.css3', 'goog.html.SafeHtml', 'goog.html.testing', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Dialog', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/dimensionpicker.js', ['goog.ui.DimensionPicker'], ['goog.events.BrowserEvent.PointerType', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Size', 'goog.ui.Component', 'goog.ui.ComponentUtil', 'goog.ui.Control', 'goog.ui.DimensionPickerRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/dimensionpicker_test.js', ['goog.ui.DimensionPickerTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.math.Size', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.DimensionPicker', 'goog.ui.DimensionPickerRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/dimensionpickerrenderer.js', ['goog.ui.DimensionPickerRenderer'], ['goog.a11y.aria.Announcer', 'goog.a11y.aria.LivePriority', 'goog.dom', 'goog.dom.TagName', 'goog.i18n.bidi', 'goog.style', 'goog.ui.ControlRenderer', 'goog.userAgent'], {});
goog.addDependency('ui/dimensionpickerrenderer_test.js', ['goog.ui.DimensionPickerRendererTest'], ['goog.a11y.aria.LivePriority', 'goog.array', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.DimensionPicker', 'goog.ui.DimensionPickerRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/dragdropdetector.js', ['goog.ui.DragDropDetector', 'goog.ui.DragDropDetector.EventType', 'goog.ui.DragDropDetector.ImageDropEvent', 'goog.ui.DragDropDetector.LinkDropEvent'], ['goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.math.Coordinate', 'goog.string', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('ui/drilldownrow.js', ['goog.ui.DrilldownRow'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.string.Unicode', 'goog.ui.Component'], {});
goog.addDependency('ui/drilldownrow_test.js', ['goog.ui.DrilldownRowTest'], ['goog.dom', 'goog.dom.TagName', 'goog.html.SafeHtml', 'goog.testing.testSuite', 'goog.ui.DrilldownRow'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/editor/abstractdialog.js', ['goog.ui.editor.AbstractDialog', 'goog.ui.editor.AbstractDialog.Builder', 'goog.ui.editor.AbstractDialog.EventType'], ['goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events.EventTarget', 'goog.string', 'goog.ui.Dialog', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/editor/abstractdialog_test.js', ['goog.ui.editor.AbstractDialogTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.KeyCodes', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.testSuite', 'goog.ui.editor.AbstractDialog', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/editor/bubble.js', ['goog.ui.editor.Bubble'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.ViewportSizeMonitor', 'goog.dom.classlist', 'goog.editor.style', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.functions', 'goog.log', 'goog.math.Box', 'goog.object', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.PopupBase', 'goog.userAgent'], {});
goog.addDependency('ui/editor/bubble_test.js', ['goog.ui.editor.BubbleTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.positioning.Corner', 'goog.positioning.OverflowStatus', 'goog.string', 'goog.style', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.editor.Bubble', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/editor/defaulttoolbar.js', ['goog.ui.editor.ButtonDescriptor', 'goog.ui.editor.DefaultToolbar'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.editor.Command', 'goog.style', 'goog.ui.editor.ToolbarFactory', 'goog.ui.editor.messages', 'goog.userAgent'], {});
goog.addDependency('ui/editor/linkdialog.js', ['goog.ui.editor.LinkDialog', 'goog.ui.editor.LinkDialog.BeforeTestLinkEvent', 'goog.ui.editor.LinkDialog.EventType', 'goog.ui.editor.LinkDialog.OkEvent'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.editor.BrowserFeature', 'goog.editor.Link', 'goog.editor.focus', 'goog.editor.node', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.InputHandler', 'goog.html.SafeHtml', 'goog.html.SafeHtmlFormatter', 'goog.string', 'goog.string.Unicode', 'goog.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.LinkButtonRenderer', 'goog.ui.editor.AbstractDialog', 'goog.ui.editor.TabPane', 'goog.ui.editor.messages', 'goog.userAgent', 'goog.window'], {});
goog.addDependency('ui/editor/linkdialog_test.js', ['goog.ui.editor.LinkDialogTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Link', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.style', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.dom', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.testSuite', 'goog.ui.editor.AbstractDialog', 'goog.ui.editor.LinkDialog', 'goog.ui.editor.messages', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/editor/messages.js', ['goog.ui.editor.messages'], ['goog.html.SafeHtmlFormatter'], {});
goog.addDependency('ui/editor/tabpane.js', ['goog.ui.editor.TabPane'], ['goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.style', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.Tab', 'goog.ui.TabBar'], {});
goog.addDependency('ui/editor/toolbarcontroller.js', ['goog.ui.editor.ToolbarController'], ['goog.editor.Field', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.ui.Component'], {});
goog.addDependency('ui/editor/toolbarfactory.js', ['goog.ui.editor.ToolbarFactory'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.string', 'goog.string.Unicode', 'goog.style', 'goog.ui.Component', 'goog.ui.Container', 'goog.ui.Option', 'goog.ui.Toolbar', 'goog.ui.ToolbarButton', 'goog.ui.ToolbarColorMenuButton', 'goog.ui.ToolbarMenuButton', 'goog.ui.ToolbarRenderer', 'goog.ui.ToolbarSelect', 'goog.userAgent'], {});
goog.addDependency('ui/editor/toolbarfactory_test.js', ['goog.ui.editor.ToolbarFactoryTest'], ['goog.dom', 'goog.testing.ExpectedFailures', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.ui.editor.ToolbarFactory', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/emoji.js', ['goog.ui.emoji.Emoji'], [], {});
goog.addDependency('ui/emoji/emojipalette.js', ['goog.ui.emoji.EmojiPalette'], ['goog.events.EventType', 'goog.net.ImageLoader', 'goog.ui.Palette', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPaletteRenderer'], {});
goog.addDependency('ui/emoji/emojipaletterenderer.js', ['goog.ui.emoji.EmojiPaletteRenderer'], ['goog.a11y.aria', 'goog.asserts', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.style', 'goog.ui.PaletteRenderer', 'goog.ui.emoji.Emoji'], {});
goog.addDependency('ui/emoji/emojipicker.js', ['goog.ui.emoji.EmojiPicker'], ['goog.dom.TagName', 'goog.style', 'goog.ui.Component', 'goog.ui.TabPane', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPalette', 'goog.ui.emoji.EmojiPaletteRenderer', 'goog.ui.emoji.ProgressiveEmojiPaletteRenderer'], {});
goog.addDependency('ui/emoji/emojipicker_test.js', ['goog.ui.emoji.EmojiPickerTest'], ['goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventHandler', 'goog.style', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPicker', 'goog.ui.emoji.SpriteInfo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/fast_nonprogressive_emojipicker_test.js', ['goog.ui.emoji.FastNonProgressiveEmojiPickerTest'], ['goog.Promise', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.net.EventType', 'goog.style', 'goog.testing.TestCase', 'goog.testing.testSuite', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPicker', 'goog.ui.emoji.SpriteInfo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/fast_progressive_emojipicker_test.js', ['goog.ui.emoji.FastProgressiveEmojiPickerTest'], ['goog.Promise', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.net.EventType', 'goog.style', 'goog.testing.testSuite', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPicker', 'goog.ui.emoji.SpriteInfo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/popupemojipicker.js', ['goog.ui.emoji.PopupEmojiPicker'], ['goog.events.EventType', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.ui.Component', 'goog.ui.Popup', 'goog.ui.emoji.EmojiPicker'], {});
goog.addDependency('ui/emoji/popupemojipicker_test.js', ['goog.ui.emoji.PopupEmojiPickerTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.emoji.PopupEmojiPicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/progressiveemojipaletterenderer.js', ['goog.ui.emoji.ProgressiveEmojiPaletteRenderer'], ['goog.dom.TagName', 'goog.style', 'goog.ui.emoji.EmojiPaletteRenderer'], {});
goog.addDependency('ui/emoji/spriteinfo.js', ['goog.ui.emoji.SpriteInfo'], [], {'lang': 'es6'});
goog.addDependency('ui/emoji/spriteinfo_test.js', ['goog.ui.emoji.SpriteInfoTest'], ['goog.testing.testSuite', 'goog.ui.emoji.SpriteInfo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/filteredmenu.js', ['goog.ui.FilteredMenu'], ['goog.a11y.aria', 'goog.a11y.aria.AutoCompleteValues', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.FilterObservingMenuItem', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.userAgent'], {});
goog.addDependency('ui/filteredmenu_test.js', ['goog.ui.FilteredMenuTest'], ['goog.a11y.aria', 'goog.a11y.aria.AutoCompleteValues', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Rect', 'goog.style', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.FilteredMenu', 'goog.ui.MenuItem'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/filterobservingmenuitem.js', ['goog.ui.FilterObservingMenuItem'], ['goog.ui.FilterObservingMenuItemRenderer', 'goog.ui.MenuItem', 'goog.ui.registry'], {});
goog.addDependency('ui/filterobservingmenuitemrenderer.js', ['goog.ui.FilterObservingMenuItemRenderer'], ['goog.ui.MenuItemRenderer'], {});
goog.addDependency('ui/flatbuttonrenderer.js', ['goog.ui.FlatButtonRenderer'], ['goog.a11y.aria.Role', 'goog.asserts', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Button', 'goog.ui.ButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.registry'], {});
goog.addDependency('ui/flatmenubuttonrenderer.js', ['goog.ui.FlatMenuButtonRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.ui.FlatButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.Menu', 'goog.ui.MenuButton', 'goog.ui.MenuRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/formpost.js', ['goog.ui.FormPost'], ['goog.array', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.ui.Component'], {});
goog.addDependency('ui/formpost_test.js', ['goog.ui.FormPostTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.object', 'goog.testing.testSuite', 'goog.ui.FormPost', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/gauge.js', ['goog.ui.Gauge', 'goog.ui.GaugeColoredRange'], ['goog.a11y.aria', 'goog.asserts', 'goog.dom.TagName', 'goog.events', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.fx.easing', 'goog.graphics', 'goog.graphics.Font', 'goog.graphics.Path', 'goog.graphics.SolidFill', 'goog.math', 'goog.ui.Component', 'goog.ui.GaugeTheme'], {});
goog.addDependency('ui/gaugetheme.js', ['goog.ui.GaugeTheme'], ['goog.graphics.LinearGradient', 'goog.graphics.SolidFill', 'goog.graphics.Stroke'], {});
goog.addDependency('ui/hovercard.js', ['goog.ui.HoverCard', 'goog.ui.HoverCard.EventType', 'goog.ui.HoverCard.TriggerEvent'], ['goog.array', 'goog.dom', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.ui.AdvancedTooltip', 'goog.ui.PopupBase', 'goog.ui.Tooltip'], {});
goog.addDependency('ui/hovercard_test.js', ['goog.ui.HoverCardTest'], ['goog.dom', 'goog.events', 'goog.math.Coordinate', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.HoverCard'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/hsvapalette.js', ['goog.ui.HsvaPalette'], ['goog.array', 'goog.color.alpha', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.style', 'goog.ui.Component', 'goog.ui.HsvPalette'], {});
goog.addDependency('ui/hsvapalette_test.js', ['goog.ui.HsvaPaletteTest'], ['goog.color.alpha', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.Event', 'goog.math.Coordinate', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.HsvaPalette', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/hsvpalette.js', ['goog.ui.HsvPalette'], ['goog.color', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.style', 'goog.style.bidi', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/hsvpalette_test.js', ['goog.ui.HsvPaletteTest'], ['goog.color', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.math.Coordinate', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.HsvPalette', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/idgenerator.js', ['goog.ui.IdGenerator'], [], {});
goog.addDependency('ui/idletimer.js', ['goog.ui.IdleTimer'], ['goog.Timer', 'goog.events', 'goog.events.EventTarget', 'goog.structs.Set', 'goog.ui.ActivityMonitor'], {});
goog.addDependency('ui/idletimer_test.js', ['goog.ui.IdleTimerTest'], ['goog.events', 'goog.testing.MockClock', 'goog.testing.testSuite', 'goog.ui.IdleTimer', 'goog.ui.MockActivityMonitor'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/iframemask.js', ['goog.ui.IframeMask'], ['goog.Disposable', 'goog.Timer', 'goog.dom', 'goog.dom.iframe', 'goog.events.EventHandler', 'goog.structs.Pool', 'goog.style'], {});
goog.addDependency('ui/iframemask_test.js', ['goog.ui.IframeMaskTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.iframe', 'goog.structs.Pool', 'goog.style', 'goog.testing.MockClock', 'goog.testing.StrictMock', 'goog.testing.testSuite', 'goog.ui.IframeMask', 'goog.ui.Popup', 'goog.ui.PopupBase', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/imagelessbuttonrenderer.js', ['goog.ui.ImagelessButtonRenderer'], ['goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.CustomButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.registry'], {});
goog.addDependency('ui/imagelessmenubuttonrenderer.js', ['goog.ui.ImagelessMenuButtonRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.MenuButton', 'goog.ui.MenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/inputdatepicker.js', ['goog.ui.InputDatePicker'], ['goog.date.DateTime', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.i18n.DateTimeParse', 'goog.string', 'goog.ui.Component', 'goog.ui.DatePicker', 'goog.ui.LabelInput', 'goog.ui.PopupBase', 'goog.ui.PopupDatePicker'], {});
goog.addDependency('ui/inputdatepicker_test.js', ['goog.ui.InputDatePickerTest'], ['goog.dom', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeParse', 'goog.testing.testSuite', 'goog.ui.InputDatePicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/itemevent.js', ['goog.ui.ItemEvent'], ['goog.events.Event'], {});
goog.addDependency('ui/keyboardeventdata.js', ['goog.ui.KeyboardEventData'], ['goog.asserts', 'goog.events.BrowserEvent'], {'lang': 'es6'});
goog.addDependency('ui/keyboardshortcuthandler.js', ['goog.ui.KeyboardShortcutEvent', 'goog.ui.KeyboardShortcutHandler', 'goog.ui.KeyboardShortcutHandler.EventType', 'goog.ui.KeyboardShortcutHandler.Modifiers'], ['goog.array', 'goog.asserts', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyNames', 'goog.events.Keys', 'goog.object', 'goog.ui.KeyboardEventData', 'goog.ui.SyntheticKeyboardEvent', 'goog.userAgent'], {});
goog.addDependency('ui/keyboardshortcuthandler_test.js', ['goog.ui.KeyboardShortcutHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.KeyboardShortcutHandler', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/labelinput.js', ['goog.ui.LabelInput'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/labelinput_test.js', ['goog.ui.LabelInputTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.classlist', 'goog.events.EventType', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.LabelInput', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/linkbuttonrenderer.js', ['goog.ui.LinkButtonRenderer'], ['goog.ui.Button', 'goog.ui.FlatButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/media/flashobject.js', ['goog.ui.media.FlashObject', 'goog.ui.media.FlashObject.ScriptAccessLevel', 'goog.ui.media.FlashObject.Wmodes'], ['goog.asserts', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.html.TrustedResourceUrl', 'goog.html.flash', 'goog.log', 'goog.object', 'goog.string', 'goog.structs.Map', 'goog.style', 'goog.ui.Component', 'goog.userAgent', 'goog.userAgent.flash'], {});
goog.addDependency('ui/media/flashobject_test.js', ['goog.ui.media.FlashObjectTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.html.testing', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/flickr.js', ['goog.ui.media.FlickrSet', 'goog.ui.media.FlickrSetModel'], ['goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/flickr_test.js', ['goog.ui.media.FlickrSetTest'], ['goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.FlickrSet', 'goog.ui.media.FlickrSetModel', 'goog.ui.media.Media'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/googlevideo.js', ['goog.ui.media.GoogleVideo', 'goog.ui.media.GoogleVideoModel'], ['goog.html.TrustedResourceUrl', 'goog.string', 'goog.string.Const', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/googlevideo_test.js', ['goog.ui.media.GoogleVideoTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.GoogleVideo', 'goog.ui.media.GoogleVideoModel', 'goog.ui.media.Media'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/media.js', ['goog.ui.media.Media', 'goog.ui.media.MediaRenderer'], ['goog.asserts', 'goog.dom.TagName', 'goog.style', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/media/media_test.js', ['goog.ui.media.MediaTest'], ['goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.math.Size', 'goog.testing.testSuite', 'goog.ui.ControlRenderer', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/mediamodel.js', ['goog.ui.media.MediaModel', 'goog.ui.media.MediaModel.Category', 'goog.ui.media.MediaModel.Credit', 'goog.ui.media.MediaModel.Credit.Role', 'goog.ui.media.MediaModel.Credit.Scheme', 'goog.ui.media.MediaModel.Medium', 'goog.ui.media.MediaModel.MimeType', 'goog.ui.media.MediaModel.Player', 'goog.ui.media.MediaModel.SubTitle', 'goog.ui.media.MediaModel.Thumbnail'], ['goog.array', 'goog.html.TrustedResourceUrl'], {});
goog.addDependency('ui/media/mediamodel_test.js', ['goog.ui.media.MediaModelTest'], ['goog.testing.testSuite', 'goog.ui.media.MediaModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/mp3.js', ['goog.ui.media.Mp3'], ['goog.string', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/mp3_test.js', ['goog.ui.media.Mp3Test'], ['goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.Mp3'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/photo.js', ['goog.ui.media.Photo'], ['goog.dom.TagName', 'goog.ui.media.Media', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/photo_test.js', ['goog.ui.media.PhotoTest'], ['goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.media.MediaModel', 'goog.ui.media.Photo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/picasa.js', ['goog.ui.media.PicasaAlbum', 'goog.ui.media.PicasaAlbumModel'], ['goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/picasa_test.js', ['goog.ui.media.PicasaTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.PicasaAlbum', 'goog.ui.media.PicasaAlbumModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/vimeo.js', ['goog.ui.media.Vimeo', 'goog.ui.media.VimeoModel'], ['goog.html.TrustedResourceUrl', 'goog.string', 'goog.string.Const', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/vimeo_test.js', ['goog.ui.media.VimeoTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.Vimeo', 'goog.ui.media.VimeoModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/youtube.js', ['goog.ui.media.Youtube', 'goog.ui.media.YoutubeModel'], ['goog.dom.TagName', 'goog.html.TrustedResourceUrl', 'goog.string', 'goog.string.Const', 'goog.ui.Component', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/youtube_test.js', ['goog.ui.media.YoutubeTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.Youtube', 'goog.ui.media.YoutubeModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menu.js', ['goog.ui.Menu', 'goog.ui.Menu.EventType'], ['goog.dom.TagName', 'goog.math.Coordinate', 'goog.string', 'goog.style', 'goog.ui.Component.EventType', 'goog.ui.Component.State', 'goog.ui.Container', 'goog.ui.Container.Orientation', 'goog.ui.MenuHeader', 'goog.ui.MenuItem', 'goog.ui.MenuRenderer', 'goog.ui.MenuSeparator'], {});
goog.addDependency('ui/menu_test.js', ['goog.ui.MenuTest'], ['goog.dom', 'goog.events', 'goog.math.Coordinate', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Menu'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menubar.js', ['goog.ui.menuBar'], ['goog.ui.Container', 'goog.ui.MenuBarRenderer'], {});
goog.addDependency('ui/menubardecorator.js', ['goog.ui.menuBarDecorator'], ['goog.ui.MenuBarRenderer', 'goog.ui.menuBar', 'goog.ui.registry'], {});
goog.addDependency('ui/menubarrenderer.js', ['goog.ui.MenuBarRenderer'], ['goog.a11y.aria.Role', 'goog.ui.Container', 'goog.ui.ContainerRenderer'], {});
goog.addDependency('ui/menubase.js', ['goog.ui.MenuBase'], ['goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyHandler', 'goog.ui.Popup'], {});
goog.addDependency('ui/menubutton.js', ['goog.ui.MenuButton'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.positioning.Overflow', 'goog.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.IdGenerator', 'goog.ui.Menu', 'goog.ui.MenuButtonRenderer', 'goog.ui.MenuItem', 'goog.ui.MenuRenderer', 'goog.ui.SubMenu', 'goog.ui.registry', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6'});
goog.addDependency('ui/menubutton_test.js', ['goog.ui.MenuButtonTest'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.positioning.Overflow', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.MenuButton', 'goog.ui.MenuItem', 'goog.ui.SubMenu', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menubuttonrenderer.js', ['goog.ui.MenuButtonRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.ui.CustomButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.Menu', 'goog.ui.MenuRenderer'], {});
goog.addDependency('ui/menubuttonrenderer_test.js', ['goog.ui.MenuButtonRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.MenuButton', 'goog.ui.MenuButtonRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menuheader.js', ['goog.ui.MenuHeader'], ['goog.ui.Component', 'goog.ui.Control', 'goog.ui.MenuHeaderRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/menuheaderrenderer.js', ['goog.ui.MenuHeaderRenderer'], ['goog.ui.ControlRenderer'], {});
goog.addDependency('ui/menuitem.js', ['goog.ui.MenuItem'], ['goog.a11y.aria.Role', 'goog.array', 'goog.dom', 'goog.dom.classlist', 'goog.math.Coordinate', 'goog.string', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.MenuItemRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/menuitem_test.js', ['goog.ui.MenuItemTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.KeyCodes', 'goog.html.testing', 'goog.math.Coordinate', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.MenuItemRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menuitemrenderer.js', ['goog.ui.MenuItemRenderer'], ['goog.a11y.aria.Role', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/menuitemrenderer_test.js', ['goog.ui.MenuItemRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.MenuItemRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menurenderer.js', ['goog.ui.MenuRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.ui.ContainerRenderer', 'goog.ui.Separator'], {});
goog.addDependency('ui/menuseparator.js', ['goog.ui.MenuSeparator'], ['goog.ui.MenuSeparatorRenderer', 'goog.ui.Separator', 'goog.ui.registry'], {});
goog.addDependency('ui/menuseparatorrenderer.js', ['goog.ui.MenuSeparatorRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/menuseparatorrenderer_test.js', ['goog.ui.MenuSeparatorRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.MenuSeparator', 'goog.ui.MenuSeparatorRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/mockactivitymonitor.js', ['goog.ui.MockActivityMonitor'], ['goog.events.EventType', 'goog.ui.ActivityMonitor'], {});
goog.addDependency('ui/mockactivitymonitor_test.js', ['goog.ui.MockActivityMonitorTest'], ['goog.events', 'goog.functions', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.ActivityMonitor', 'goog.ui.MockActivityMonitor'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/modalariavisibilityhelper.js', ['goog.ui.ModalAriaVisibilityHelper'], ['goog.a11y.aria', 'goog.a11y.aria.State'], {});
goog.addDependency('ui/modalariavisibilityhelper_test.js', ['goog.ui.ModalAriaVisibilityHelperTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.string', 'goog.testing.testSuite', 'goog.ui.ModalAriaVisibilityHelper'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/modalpopup.js', ['goog.ui.ModalPopup'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.animationFrame', 'goog.dom.classlist', 'goog.dom.iframe', 'goog.events', 'goog.events.EventType', 'goog.events.FocusHandler', 'goog.fx.Transition', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.ModalAriaVisibilityHelper', 'goog.ui.PopupBase', 'goog.userAgent'], {});
goog.addDependency('ui/modalpopup_test.js', ['goog.ui.ModalPopupTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dispose', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.fx.Transition', 'goog.fx.css3', 'goog.string', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.ModalPopup', 'goog.ui.PopupBase'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/nativebuttonrenderer.js', ['goog.ui.NativeButtonRenderer'], ['goog.asserts', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.ui.ButtonRenderer', 'goog.ui.Component'], {});
goog.addDependency('ui/nativebuttonrenderer_test.js', ['goog.ui.NativeButtonRendererTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.testing.ExpectedFailures', 'goog.testing.events', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.NativeButtonRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/option.js', ['goog.ui.Option'], ['goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.registry'], {});
goog.addDependency('ui/palette.js', ['goog.ui.Palette'], ['goog.array', 'goog.dom', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Size', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.PaletteRenderer', 'goog.ui.SelectionModel'], {});
goog.addDependency('ui/palette_test.js', ['goog.ui.PaletteTest'], ['goog.a11y.aria', 'goog.dom', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyEvent', 'goog.testing.events.Event', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Container', 'goog.ui.Palette'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/paletterenderer.js', ['goog.ui.PaletteRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeIterator', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.dataset', 'goog.iter', 'goog.style', 'goog.ui.ControlRenderer', 'goog.userAgent'], {});
goog.addDependency('ui/paletterenderer_test.js', ['goog.ui.PaletteRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.Palette', 'goog.ui.PaletteRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/plaintextspellchecker.js', ['goog.ui.PlainTextSpellChecker'], ['goog.Timer', 'goog.a11y.aria', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.spell.SpellCheck', 'goog.style', 'goog.ui.AbstractSpellChecker', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/plaintextspellchecker_test.js', ['goog.ui.PlainTextSpellCheckerTest'], ['goog.Timer', 'goog.dom', 'goog.events.KeyCodes', 'goog.spell.SpellCheck', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.AbstractSpellChecker', 'goog.ui.PlainTextSpellChecker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popup.js', ['goog.ui.Popup'], ['goog.math.Box', 'goog.positioning.AbstractPosition', 'goog.positioning.Corner', 'goog.style', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/popup_test.js', ['goog.ui.PopupTest'], ['goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.style', 'goog.testing.testSuite', 'goog.ui.Popup', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popupbase.js', ['goog.ui.PopupBase', 'goog.ui.PopupBase.EventType', 'goog.ui.PopupBase.Type'], ['goog.Timer', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.fx.Transition', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('ui/popupbase_test.js', ['goog.ui.PopupBaseTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.fx.Transition', 'goog.fx.css3', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.PopupBase'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popupcolorpicker.js', ['goog.ui.PopupColorPicker'], ['goog.asserts', 'goog.dom.classlist', 'goog.events.EventType', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.ui.ColorPicker', 'goog.ui.Component', 'goog.ui.Popup'], {});
goog.addDependency('ui/popupcolorpicker_test.js', ['goog.ui.PopupColorPickerTest'], ['goog.dom', 'goog.events', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.ColorPicker', 'goog.ui.PopupColorPicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popupdatepicker.js', ['goog.ui.PopupDatePicker'], ['goog.events.EventType', 'goog.positioning.AnchoredViewportPosition', 'goog.positioning.Corner', 'goog.style', 'goog.ui.Component', 'goog.ui.DatePicker', 'goog.ui.Popup', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/popupdatepicker_test.js', ['goog.ui.PopupDatePickerTest'], ['goog.date.Date', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.style', 'goog.testing.MockControl', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.DatePicker', 'goog.ui.PopupBase', 'goog.ui.PopupDatePicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popupmenu.js', ['goog.ui.PopupMenu'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.BrowserEvent.MouseButton', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.positioning.AnchoredViewportPosition', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.positioning.Overflow', 'goog.positioning.ViewportClientPosition', 'goog.structs.Map', 'goog.style', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/popupmenu_test.js', ['goog.ui.PopupMenuTest'], ['goog.dom', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Box', 'goog.math.Coordinate', 'goog.positioning.Corner', 'goog.style', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.PopupMenu'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/progressbar.js', ['goog.ui.ProgressBar', 'goog.ui.ProgressBar.Orientation'], ['goog.a11y.aria', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.ui.Component', 'goog.ui.RangeModel', 'goog.userAgent'], {});
goog.addDependency('ui/prompt.js', ['goog.ui.Prompt'], ['goog.Timer', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.functions', 'goog.html.SafeHtml', 'goog.ui.Component', 'goog.ui.Dialog', 'goog.userAgent'], {});
goog.addDependency('ui/prompt_test.js', ['goog.ui.PromptTest'], ['goog.dom.selection', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.functions', 'goog.string', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.BidiInput', 'goog.ui.Dialog', 'goog.ui.Prompt', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/rangemodel.js', ['goog.ui.RangeModel'], ['goog.events.EventTarget', 'goog.ui.Component'], {});
goog.addDependency('ui/rangemodel_test.js', ['goog.ui.RangeModelTest'], ['goog.testing.testSuite', 'goog.ui.RangeModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ratings.js', ['goog.ui.Ratings', 'goog.ui.Ratings.EventType'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.ui.Component'], {});
goog.addDependency('ui/registry.js', ['goog.ui.registry'], ['goog.asserts', 'goog.dom.classlist'], {});
goog.addDependency('ui/registry_test.js', ['goog.ui.registryTest'], ['goog.object', 'goog.testing.testSuite', 'goog.ui.registry'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/richtextspellchecker.js', ['goog.ui.RichTextSpellChecker'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.math.Coordinate', 'goog.spell.SpellCheck', 'goog.string.StringBuffer', 'goog.style', 'goog.ui.AbstractSpellChecker', 'goog.ui.Component', 'goog.ui.PopupMenu'], {});
goog.addDependency('ui/richtextspellchecker_test.js', ['goog.ui.RichTextSpellCheckerTest'], ['goog.dom.Range', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.KeyCodes', 'goog.object', 'goog.spell.SpellCheck', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.RichTextSpellChecker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/roundedpanel.js', ['goog.ui.BaseRoundedPanel', 'goog.ui.CssRoundedPanel', 'goog.ui.GraphicsRoundedPanel', 'goog.ui.RoundedPanel', 'goog.ui.RoundedPanel.Corner'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.graphics', 'goog.graphics.Path', 'goog.graphics.SolidFill', 'goog.graphics.Stroke', 'goog.math', 'goog.math.Coordinate', 'goog.style', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/roundedpanel_test.js', ['goog.ui.RoundedPanelTest'], ['goog.testing.testSuite', 'goog.ui.CssRoundedPanel', 'goog.ui.GraphicsRoundedPanel', 'goog.ui.RoundedPanel', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/roundedtabrenderer.js', ['goog.ui.RoundedTabRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.ui.Tab', 'goog.ui.TabBar', 'goog.ui.TabRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/scrollfloater.js', ['goog.ui.ScrollFloater', 'goog.ui.ScrollFloater.EventType'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.style', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/scrollfloater_test.js', ['goog.ui.ScrollFloaterTest'], ['goog.dom', 'goog.events', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.ScrollFloater'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/select.js', ['goog.ui.Select'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.events.EventType', 'goog.ui.Component', 'goog.ui.IdGenerator', 'goog.ui.MenuButton', 'goog.ui.MenuItem', 'goog.ui.MenuRenderer', 'goog.ui.SelectionModel', 'goog.ui.registry'], {});
goog.addDependency('ui/select_test.js', ['goog.ui.SelectTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.CustomButtonRenderer', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.Select', 'goog.ui.Separator'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/selectionmenubutton.js', ['goog.ui.SelectionMenuButton', 'goog.ui.SelectionMenuButton.SelectionState'], ['goog.dom.InputType', 'goog.dom.TagName', 'goog.events.EventType', 'goog.style', 'goog.ui.Component', 'goog.ui.MenuButton', 'goog.ui.MenuItem', 'goog.ui.registry'], {});
goog.addDependency('ui/selectionmenubutton_test.js', ['goog.ui.SelectionMenuButtonTest'], ['goog.dom', 'goog.events', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.SelectionMenuButton'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/selectionmodel.js', ['goog.ui.SelectionModel'], ['goog.array', 'goog.events.EventTarget', 'goog.events.EventType'], {});
goog.addDependency('ui/selectionmodel_test.js', ['goog.ui.SelectionModelTest'], ['goog.array', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.SelectionModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/separator.js', ['goog.ui.Separator'], ['goog.a11y.aria', 'goog.asserts', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.MenuSeparatorRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/serverchart.js', ['goog.ui.ServerChart', 'goog.ui.ServerChart.AxisDisplayType', 'goog.ui.ServerChart.ChartType', 'goog.ui.ServerChart.EncodingType', 'goog.ui.ServerChart.Event', 'goog.ui.ServerChart.LegendPosition', 'goog.ui.ServerChart.MaximumValue', 'goog.ui.ServerChart.MultiAxisAlignment', 'goog.ui.ServerChart.MultiAxisType', 'goog.ui.ServerChart.UriParam', 'goog.ui.ServerChart.UriTooLongEvent'], ['goog.Uri', 'goog.array', 'goog.asserts', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events.Event', 'goog.string', 'goog.ui.Component'], {});
goog.addDependency('ui/serverchart_test.js', ['goog.ui.ServerChartTest'], ['goog.Uri', 'goog.events', 'goog.testing.testSuite', 'goog.ui.ServerChart'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/slider.js', ['goog.ui.Slider', 'goog.ui.Slider.Orientation'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.dom', 'goog.dom.TagName', 'goog.ui.SliderBase'], {});
goog.addDependency('ui/sliderbase.js', ['goog.ui.SliderBase', 'goog.ui.SliderBase.AnimationFactory', 'goog.ui.SliderBase.Orientation'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.events.MouseWheelHandler', 'goog.functions', 'goog.fx.AnimationParallelQueue', 'goog.fx.Dragger', 'goog.fx.Transition', 'goog.fx.dom.ResizeHeight', 'goog.fx.dom.ResizeWidth', 'goog.fx.dom.Slide', 'goog.math', 'goog.math.Coordinate', 'goog.style', 'goog.style.bidi', 'goog.ui.Component', 'goog.ui.RangeModel'], {});
goog.addDependency('ui/sliderbase_test.js', ['goog.ui.SliderBaseTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.fx.Animation', 'goog.math.Coordinate', 'goog.style', 'goog.style.bidi', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.mockmatchers', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.SliderBase', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/splitpane.js', ['goog.ui.SplitPane', 'goog.ui.SplitPane.Orientation'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.fx.Dragger', 'goog.math.Rect', 'goog.math.Size', 'goog.style', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/splitpane_test.js', ['goog.ui.SplitPaneTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.math.Size', 'goog.style', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.SplitPane'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/style/app/buttonrenderer.js', ['goog.ui.style.app.ButtonRenderer'], ['goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Button', 'goog.ui.CustomButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.registry'], {});
goog.addDependency('ui/style/app/buttonrenderer_test.js', ['goog.ui.style.app.ButtonRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.style.app.ButtonRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/style/app/menubuttonrenderer.js', ['goog.ui.style.app.MenuButtonRenderer'], ['goog.a11y.aria.Role', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.ui.Menu', 'goog.ui.MenuRenderer', 'goog.ui.style.app.ButtonRenderer'], {});
goog.addDependency('ui/style/app/menubuttonrenderer_test.js', ['goog.ui.style.app.MenuButtonRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.style', 'goog.ui.Component', 'goog.ui.MenuButton', 'goog.ui.style.app.MenuButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/style/app/primaryactionbuttonrenderer.js', ['goog.ui.style.app.PrimaryActionButtonRenderer'], ['goog.ui.Button', 'goog.ui.registry', 'goog.ui.style.app.ButtonRenderer'], {});
goog.addDependency('ui/style/app/primaryactionbuttonrenderer_test.js', ['goog.ui.style.app.PrimaryActionButtonRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.style.app.PrimaryActionButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/submenu.js', ['goog.ui.SubMenu'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events.KeyCodes', 'goog.positioning.AnchoredViewportPosition', 'goog.positioning.Corner', 'goog.style', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.SubMenuRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/submenu_test.js', ['goog.ui.SubMenuTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.functions', 'goog.positioning', 'goog.positioning.Overflow', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.SubMenu', 'goog.ui.SubMenuRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/submenurenderer.js', ['goog.ui.SubMenuRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.style', 'goog.ui.Menu', 'goog.ui.MenuItemRenderer'], {});
goog.addDependency('ui/synthetickeyboardevent.js', ['goog.ui.SyntheticKeyboardEvent'], ['goog.events.Event', 'goog.ui.KeyboardEventData'], {});
goog.addDependency('ui/tab.js', ['goog.ui.Tab'], ['goog.ui.Component', 'goog.ui.Control', 'goog.ui.TabRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/tab_test.js', ['goog.ui.TabTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Tab', 'goog.ui.TabRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tabbar.js', ['goog.ui.TabBar', 'goog.ui.TabBar.Location'], ['goog.ui.Component.EventType', 'goog.ui.Container', 'goog.ui.Container.Orientation', 'goog.ui.Tab', 'goog.ui.TabBarRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/tabbar_test.js', ['goog.ui.TabBarTest'], ['goog.dom', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Container', 'goog.ui.Tab', 'goog.ui.TabBar', 'goog.ui.TabBarRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tabbarrenderer.js', ['goog.ui.TabBarRenderer'], ['goog.a11y.aria.Role', 'goog.object', 'goog.ui.ContainerRenderer'], {});
goog.addDependency('ui/tabbarrenderer_test.js', ['goog.ui.TabBarRendererTest'], ['goog.a11y.aria.Role', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Container', 'goog.ui.TabBar', 'goog.ui.TabBarRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tablesorter.js', ['goog.ui.TableSorter', 'goog.ui.TableSorter.EventType'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.functions', 'goog.ui.Component'], {});
goog.addDependency('ui/tablesorter_test.js', ['goog.ui.TableSorterTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.TableSorter'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tabpane.js', ['goog.ui.TabPane', 'goog.ui.TabPane.Events', 'goog.ui.TabPane.TabLocation', 'goog.ui.TabPane.TabPage', 'goog.ui.TabPaneEvent'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.html.SafeStyleSheet', 'goog.style'], {});
goog.addDependency('ui/tabpane_test.js', ['goog.ui.TabPaneTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.TabPane'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tabrenderer.js', ['goog.ui.TabRenderer'], ['goog.a11y.aria.Role', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/tabrenderer_test.js', ['goog.ui.TabRendererTest'], ['goog.a11y.aria.Role', 'goog.dom', 'goog.dom.classlist', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Tab', 'goog.ui.TabRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/textarea.js', ['goog.ui.Textarea', 'goog.ui.Textarea.EventType'], ['goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events.EventType', 'goog.style', 'goog.ui.Control', 'goog.ui.TextareaRenderer', 'goog.userAgent'], {});
goog.addDependency('ui/textarea_test.js', ['goog.ui.TextareaTest'], ['goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.events.EventObserver', 'goog.testing.testSuite', 'goog.ui.Textarea', 'goog.ui.TextareaRenderer', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/textarearenderer.js', ['goog.ui.TextareaRenderer'], ['goog.dom.TagName', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/togglebutton.js', ['goog.ui.ToggleButton'], ['goog.ui.Button', 'goog.ui.Component', 'goog.ui.CustomButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbar.js', ['goog.ui.Toolbar'], ['goog.ui.Container', 'goog.ui.ToolbarRenderer'], {});
goog.addDependency('ui/toolbar_test.js', ['goog.ui.ToolbarTest'], ['goog.a11y.aria', 'goog.dom', 'goog.events.EventType', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.Toolbar', 'goog.ui.ToolbarMenuButton'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/toolbarbutton.js', ['goog.ui.ToolbarButton'], ['goog.ui.Button', 'goog.ui.ToolbarButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarbuttonrenderer.js', ['goog.ui.ToolbarButtonRenderer'], ['goog.ui.CustomButtonRenderer'], {});
goog.addDependency('ui/toolbarcolormenubutton.js', ['goog.ui.ToolbarColorMenuButton'], ['goog.ui.ColorMenuButton', 'goog.ui.ToolbarColorMenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarcolormenubuttonrenderer.js', ['goog.ui.ToolbarColorMenuButtonRenderer'], ['goog.asserts', 'goog.dom.classlist', 'goog.ui.ColorMenuButtonRenderer', 'goog.ui.MenuButtonRenderer', 'goog.ui.ToolbarMenuButtonRenderer'], {});
goog.addDependency('ui/toolbarcolormenubuttonrenderer_test.js', ['goog.ui.ToolbarColorMenuButtonRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.RendererHarness', 'goog.testing.ui.rendererasserts', 'goog.ui.ToolbarColorMenuButton', 'goog.ui.ToolbarColorMenuButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/toolbarmenubutton.js', ['goog.ui.ToolbarMenuButton'], ['goog.ui.MenuButton', 'goog.ui.ToolbarMenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarmenubuttonrenderer.js', ['goog.ui.ToolbarMenuButtonRenderer'], ['goog.ui.MenuButtonRenderer'], {});
goog.addDependency('ui/toolbarrenderer.js', ['goog.ui.ToolbarRenderer'], ['goog.a11y.aria.Role', 'goog.dom.TagName', 'goog.ui.Container', 'goog.ui.ContainerRenderer', 'goog.ui.Separator', 'goog.ui.ToolbarSeparatorRenderer'], {});
goog.addDependency('ui/toolbarselect.js', ['goog.ui.ToolbarSelect'], ['goog.ui.Select', 'goog.ui.ToolbarMenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarseparator.js', ['goog.ui.ToolbarSeparator'], ['goog.ui.Separator', 'goog.ui.ToolbarSeparatorRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarseparatorrenderer.js', ['goog.ui.ToolbarSeparatorRenderer'], ['goog.asserts', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.MenuSeparatorRenderer'], {});
goog.addDependency('ui/toolbarseparatorrenderer_test.js', ['goog.ui.ToolbarSeparatorRendererTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.ToolbarSeparator', 'goog.ui.ToolbarSeparatorRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/toolbartogglebutton.js', ['goog.ui.ToolbarToggleButton'], ['goog.ui.ToggleButton', 'goog.ui.ToolbarButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/tooltip.js', ['goog.ui.Tooltip', 'goog.ui.Tooltip.CursorTooltipPosition', 'goog.ui.Tooltip.ElementTooltipPosition', 'goog.ui.Tooltip.State'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.EventType', 'goog.events.FocusHandler', 'goog.math.Box', 'goog.math.Coordinate', 'goog.positioning', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus', 'goog.positioning.ViewportPosition', 'goog.structs.Set', 'goog.style', 'goog.ui.Popup', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/tooltip_test.js', ['goog.ui.TooltipTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.FocusHandler', 'goog.html.testing', 'goog.math.Coordinate', 'goog.positioning.AbsolutePosition', 'goog.style', 'goog.testing.MockClock', 'goog.testing.TestQueue', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.PopupBase', 'goog.ui.Tooltip', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tree/basenode.js', ['goog.ui.tree.BaseNode', 'goog.ui.tree.BaseNode.EventType'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom.safe', 'goog.events.Event', 'goog.events.KeyCodes', 'goog.html.SafeHtml', 'goog.html.SafeStyle', 'goog.string', 'goog.string.StringBuffer', 'goog.style', 'goog.ui.Component'], {});
goog.addDependency('ui/tree/basenode_test.js', ['goog.ui.tree.BaseNodeTest'], ['goog.a11y.aria', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.tree.BaseNode', 'goog.ui.tree.TreeControl', 'goog.ui.tree.TreeNode'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tree/treecontrol.js', ['goog.ui.tree.TreeControl'], ['goog.a11y.aria', 'goog.asserts', 'goog.dom.classlist', 'goog.events.EventType', 'goog.events.FocusHandler', 'goog.events.KeyHandler', 'goog.html.SafeHtml', 'goog.log', 'goog.ui.tree.BaseNode', 'goog.ui.tree.TreeNode', 'goog.ui.tree.TypeAhead', 'goog.userAgent'], {});
goog.addDependency('ui/tree/treecontrol_test.js', ['goog.ui.tree.TreeControlTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.tree.TreeControl'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tree/treenode.js', ['goog.ui.tree.TreeNode'], ['goog.ui.tree.BaseNode'], {});
goog.addDependency('ui/tree/typeahead.js', ['goog.ui.tree.TypeAhead', 'goog.ui.tree.TypeAhead.Offset'], ['goog.array', 'goog.events.KeyCodes', 'goog.string', 'goog.structs.Trie'], {});
goog.addDependency('ui/tree/typeahead_test.js', ['goog.ui.tree.TypeAheadTest'], ['goog.dom', 'goog.events.KeyCodes', 'goog.testing.testSuite', 'goog.ui.tree.TreeControl', 'goog.ui.tree.TypeAhead'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tristatemenuitem.js', ['goog.ui.TriStateMenuItem', 'goog.ui.TriStateMenuItem.State'], ['goog.dom.classlist', 'goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.TriStateMenuItemRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/tristatemenuitemrenderer.js', ['goog.ui.TriStateMenuItemRenderer'], ['goog.asserts', 'goog.dom.classlist', 'goog.ui.MenuItemRenderer'], {});
goog.addDependency('ui/twothumbslider.js', ['goog.ui.TwoThumbSlider'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.dom', 'goog.dom.TagName', 'goog.ui.SliderBase'], {});
goog.addDependency('ui/twothumbslider_test.js', ['goog.ui.TwoThumbSliderTest'], ['goog.testing.testSuite', 'goog.ui.SliderBase', 'goog.ui.TwoThumbSlider'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/zippy.js', ['goog.ui.Zippy', 'goog.ui.Zippy.Events', 'goog.ui.ZippyEvent'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.classlist', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.style'], {});
goog.addDependency('ui/zippy_test.js', ['goog.ui.ZippyTest'], ['goog.a11y.aria', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.KeyCodes', 'goog.object', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Zippy'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('uri/uri.js', ['goog.Uri', 'goog.Uri.QueryData'], ['goog.array', 'goog.asserts', 'goog.string', 'goog.structs', 'goog.structs.Map', 'goog.uri.utils', 'goog.uri.utils.ComponentIndex', 'goog.uri.utils.StandardQueryParam'], {});
goog.addDependency('uri/uri_test.js', ['goog.UriTest'], ['goog.Uri', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('uri/utils.js', ['goog.uri.utils', 'goog.uri.utils.ComponentIndex', 'goog.uri.utils.QueryArray', 'goog.uri.utils.QueryValue', 'goog.uri.utils.StandardQueryParam'], ['goog.array', 'goog.asserts', 'goog.string'], {});
goog.addDependency('uri/utils_test.js', ['goog.uri.utilsTest'], ['goog.functions', 'goog.string', 'goog.testing.testSuite', 'goog.uri.utils'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/adobereader.js', ['goog.userAgent.adobeReader'], ['goog.string', 'goog.userAgent'], {'module': 'goog'});
goog.addDependency('useragent/adobereader_test.js', ['goog.userAgent.adobeReaderTest'], ['goog.testing.testSuite', 'goog.userAgent.adobeReader'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/flash.js', ['goog.userAgent.flash'], ['goog.string'], {});
goog.addDependency('useragent/flash_test.js', ['goog.userAgent.flashTest'], ['goog.testing.testSuite', 'goog.userAgent.flash'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/iphoto.js', ['goog.userAgent.iphoto'], ['goog.string', 'goog.userAgent'], {});
goog.addDependency('useragent/jscript.js', ['goog.userAgent.jscript'], ['goog.string'], {});
goog.addDependency('useragent/jscript_test.js', ['goog.userAgent.jscriptTest'], ['goog.testing.testSuite', 'goog.userAgent.jscript'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/keyboard.js', ['goog.userAgent.keyboard'], ['goog.labs.userAgent.platform'], {});
goog.addDependency('useragent/keyboard_test.js', ['goog.userAgent.keyboardTest'], ['goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.MockUserAgent', 'goog.testing.testSuite', 'goog.userAgent.keyboard', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/platform.js', ['goog.userAgent.platform'], ['goog.string', 'goog.userAgent'], {});
goog.addDependency('useragent/platform_test.js', ['goog.userAgent.platformTest'], ['goog.testing.MockUserAgent', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.platform', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/product.js', ['goog.userAgent.product'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.platform', 'goog.userAgent'], {});
goog.addDependency('useragent/product_isversion.js', ['goog.userAgent.product.isVersion'], ['goog.labs.userAgent.platform', 'goog.string', 'goog.userAgent', 'goog.userAgent.product'], {});
goog.addDependency('useragent/product_test.js', ['goog.userAgent.productTest'], ['goog.array', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.MockUserAgent', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/useragent.js', ['goog.userAgent'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.engine', 'goog.labs.userAgent.platform', 'goog.labs.userAgent.util', 'goog.reflect', 'goog.string'], {});
goog.addDependency('useragent/useragent_quirks_test.js', ['goog.userAgentQuirksTest'], ['goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/useragent_test.js', ['goog.userAgentTest'], ['goog.array', 'goog.labs.userAgent.platform', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/useragenttestutil.js', ['goog.userAgentTestUtil', 'goog.userAgentTestUtil.UserAgents'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.engine', 'goog.labs.userAgent.platform', 'goog.object', 'goog.userAgent', 'goog.userAgent.keyboard', 'goog.userAgent.platform', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('vec/float32array.js', ['goog.vec.Float32Array'], [], {'lang': 'es6'});
goog.addDependency('vec/float32array_test.js', ['goog.vec.Float32ArrayTest'], ['goog.testing.testSuite', 'goog.vec.Float32Array'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/float64array.js', ['goog.vec.Float64Array'], [], {'lang': 'es6'});
goog.addDependency('vec/float64array_test.js', ['goog.vec.Float64ArrayTest'], ['goog.testing.testSuite', 'goog.vec.Float64Array'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat3.js', ['goog.vec.Mat3'], ['goog.vec'], {});
goog.addDependency('vec/mat3_test.js', ['goog.vec.Mat3Test'], ['goog.testing.testSuite', 'goog.vec.Mat3'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat3d.js', ['goog.vec.mat3d', 'goog.vec.mat3d.Type'], ['goog.vec', 'goog.vec.vec3d.Type'], {});
goog.addDependency('vec/mat3d_test.js', ['goog.vec.mat3dTest'], ['goog.testing.testSuite', 'goog.vec.mat3d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat3f.js', ['goog.vec.mat3f', 'goog.vec.mat3f.Type'], ['goog.vec', 'goog.vec.vec3f.Type'], {});
goog.addDependency('vec/mat3f_test.js', ['goog.vec.mat3fTest'], ['goog.testing.testSuite', 'goog.vec.mat3f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat4.js', ['goog.vec.Mat4'], ['goog.vec', 'goog.vec.Vec3', 'goog.vec.Vec4'], {});
goog.addDependency('vec/mat4_test.js', ['goog.vec.Mat4Test'], ['goog.testing.testSuite', 'goog.vec.Mat4', 'goog.vec.Vec3', 'goog.vec.Vec4'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat4d.js', ['goog.vec.mat4d', 'goog.vec.mat4d.Type'], ['goog.vec', 'goog.vec.Quaternion', 'goog.vec.vec3d', 'goog.vec.vec4d'], {});
goog.addDependency('vec/mat4d_test.js', ['goog.vec.mat4dTest'], ['goog.testing.testSuite', 'goog.vec.Quaternion', 'goog.vec.mat4d', 'goog.vec.vec3d', 'goog.vec.vec4d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat4f.js', ['goog.vec.mat4f', 'goog.vec.mat4f.Type'], ['goog.vec', 'goog.vec.Quaternion', 'goog.vec.vec3f', 'goog.vec.vec4f'], {});
goog.addDependency('vec/mat4f_test.js', ['goog.vec.mat4fTest'], ['goog.testing.testSuite', 'goog.vec.Quaternion', 'goog.vec.mat4f', 'goog.vec.vec3f', 'goog.vec.vec4f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/quaternion.js', ['goog.vec.Quaternion', 'goog.vec.Quaternion.AnyType'], ['goog.vec', 'goog.vec.Vec3', 'goog.vec.Vec4'], {});
goog.addDependency('vec/quaternion_test.js', ['goog.vec.QuaternionTest'], ['goog.testing.testSuite', 'goog.vec.Mat3', 'goog.vec.Mat4', 'goog.vec.Quaternion', 'goog.vec.Vec3', 'goog.vec.vec3f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/ray.js', ['goog.vec.Ray'], ['goog.vec.Vec3'], {});
goog.addDependency('vec/ray_test.js', ['goog.vec.RayTest'], ['goog.testing.testSuite', 'goog.vec.Ray'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec.js', ['goog.vec', 'goog.vec.AnyType', 'goog.vec.ArrayType', 'goog.vec.Float32', 'goog.vec.Float64', 'goog.vec.Number'], ['goog.vec.Float32Array', 'goog.vec.Float64Array'], {});
goog.addDependency('vec/vec2.js', ['goog.vec.Vec2'], ['goog.vec'], {});
goog.addDependency('vec/vec2_test.js', ['goog.vec.Vec2Test'], ['goog.testing.testSuite', 'goog.vec.Vec2'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec2d.js', ['goog.vec.vec2d', 'goog.vec.vec2d.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec2d_test.js', ['goog.vec.vec2dTest'], ['goog.testing.testSuite', 'goog.vec.vec2d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec2f.js', ['goog.vec.vec2f', 'goog.vec.vec2f.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec2f_test.js', ['goog.vec.vec2fTest'], ['goog.testing.testSuite', 'goog.vec.vec2f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec3.js', ['goog.vec.Vec3'], ['goog.vec'], {});
goog.addDependency('vec/vec3_test.js', ['goog.vec.Vec3Test'], ['goog.testing.testSuite', 'goog.vec.Vec3'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec3d.js', ['goog.vec.vec3d', 'goog.vec.vec3d.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec3d_test.js', ['goog.vec.vec3dTest'], ['goog.testing.testSuite', 'goog.vec.vec3d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec3f.js', ['goog.vec.vec3f', 'goog.vec.vec3f.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec3f_test.js', ['goog.vec.vec3fTest'], ['goog.testing.testSuite', 'goog.vec.vec3f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec4.js', ['goog.vec.Vec4'], ['goog.vec'], {});
goog.addDependency('vec/vec4_test.js', ['goog.vec.Vec4Test'], ['goog.testing.testSuite', 'goog.vec.Vec4'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec4d.js', ['goog.vec.vec4d', 'goog.vec.vec4d.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec4d_test.js', ['goog.vec.vec4dTest'], ['goog.testing.testSuite', 'goog.vec.vec4d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec4f.js', ['goog.vec.vec4f', 'goog.vec.vec4f.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec4f_test.js', ['goog.vec.vec4fTest'], ['goog.testing.testSuite', 'goog.vec.vec4f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('webgl/webgl.js', ['goog.webgl'], [], {});
goog.addDependency('window/window.js', ['goog.window'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeUrl', 'goog.html.uncheckedconversions', 'goog.labs.userAgent.platform', 'goog.string', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('window/window_test.js', ['goog.windowTest'], ['goog.Promise', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.functions', 'goog.html.SafeUrl', 'goog.labs.userAgent.browser', 'goog.labs.userAgent.engine', 'goog.labs.userAgent.platform', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.testSuite', 'goog.window'], {'lang': 'es6', 'module': 'goog'});

//# sourceURL=build:/external/com_google_javascript_closure_library/closure/goog/base.js
function wa(b){var d=0;return function(){return d<b.length?{done:!1,value:b[d++]}:{done:!0}}}function gb(b){return{next:wa(b)}}function lb(b){var d="undefined"!=typeof Symbol&&Symbol.iterator&&b[Symbol.iterator];return d?d.call(b):gb(b)}var wb=function(b){return"undefined"!=typeof window&&window===b?b:"undefined"!=typeof global&&null!=global?global:b}(this),Rb="function"==typeof Object.defineProperties?Object.defineProperty:function(b,d,f){b!=Array.prototype&&b!=Object.prototype&&(b[d]=f.value)};
function Ub(b,d){if(d){var f=wb;b=b.split(".");for(var h=0;h<b.length-1;h++){var k=b[h];k in f||(f[k]={});f=f[k]}b=b[b.length-1];h=f[b];d=d(h);d!=h&&null!=d&&Rb(f,b,{configurable:!0,writable:!0,value:d})}}
Ub("Promise",function(b){function d(p){this.state_=0;this.result_=void 0;this.onSettledCallbacks_=[];var m=this.createResolveAndReject_();try{p(m.resolve,m.reject)}catch(n){m.reject(n)}}function f(){this.batch_=null}function h(p){switch(typeof p){case "object":return null!=p;case "function":return!0;default:return!1}}function k(p){return p instanceof d?p:new d(function(m){m(p)})}if(b)return b;f.prototype.asyncExecute=function(p){if(null==this.batch_){this.batch_=[];var m=this;this.asyncExecuteFunction(function(){m.executeBatch_()})}this.batch_.push(p)};
var t=wb.setTimeout;f.prototype.asyncExecuteFunction=function(p){t(p,0)};f.prototype.executeBatch_=function(){for(;this.batch_&&this.batch_.length;){var p=this.batch_;this.batch_=[];for(var m=0;m<p.length;++m){var n=p[m];p[m]=null;try{n()}catch(q){this.asyncThrow_(q)}}}this.batch_=null};f.prototype.asyncThrow_=function(p){this.asyncExecuteFunction(function(){throw p;})};d.prototype.createResolveAndReject_=function(){function p(q){return function(u){n||(n=!0,q.call(m,u))}}var m=this,n=!1;return{resolve:p(this.resolveTo_),
reject:p(this.reject_)}};d.prototype.resolveTo_=function(p){p===this?this.reject_(new TypeError("A Promise cannot resolve to itself")):p instanceof d?this.settleSameAsPromise_(p):h(p)?this.resolveToNonPromiseObj_(p):this.fulfill_(p)};d.prototype.resolveToNonPromiseObj_=function(p){var m=void 0;try{m=p.then}catch(n){this.reject_(n);return}"function"==typeof m?this.settleSameAsThenable_(m,p):this.fulfill_(p)};d.prototype.reject_=function(p){this.settle_(2,p)};d.prototype.fulfill_=function(p){this.settle_(1,
p)};d.prototype.settle_=function(p,m){if(0!=this.state_)throw Error("Cannot settle("+p+", "+m+"): Promise already settled in state"+this.state_);this.state_=p;this.result_=m;this.executeOnSettledCallbacks_()};d.prototype.executeOnSettledCallbacks_=function(){if(null!=this.onSettledCallbacks_){for(var p=0;p<this.onSettledCallbacks_.length;++p)l.asyncExecute(this.onSettledCallbacks_[p]);this.onSettledCallbacks_=null}};var l=new f;d.prototype.settleSameAsPromise_=function(p){var m=this.createResolveAndReject_();
p.callWhenSettled_(m.resolve,m.reject)};d.prototype.settleSameAsThenable_=function(p,m){var n=this.createResolveAndReject_();try{p.call(m,n.resolve,n.reject)}catch(q){n.reject(q)}};d.prototype.then=function(p,m){function n(A,y){return"function"==typeof A?function(w){try{q(A(w))}catch(C){u(C)}}:y}var q,u,x=new d(function(A,y){q=A;u=y});this.callWhenSettled_(n(p,q),n(m,u));return x};d.prototype.catch=function(p){return this.then(void 0,p)};d.prototype.callWhenSettled_=function(p,m){function n(){switch(q.state_){case 1:p(q.result_);
break;case 2:m(q.result_);break;default:throw Error("Unexpected state: "+q.state_);}}var q=this;null==this.onSettledCallbacks_?l.asyncExecute(n):this.onSettledCallbacks_.push(n)};d.resolve=k;d.reject=function(p){return new d(function(m,n){n(p)})};d.race=function(p){return new d(function(m,n){for(var q=lb(p),u=q.next();!u.done;u=q.next())k(u.value).callWhenSettled_(m,n)})};d.all=function(p){var m=lb(p),n=m.next();return n.done?k([]):new d(function(q,u){function x(w){return function(C){A[w]=C;y--;0==
y&&q(A)}}var A=[],y=0;do A.push(void 0),y++,k(n.value).callWhenSettled_(x(A.length-1),u),n=m.next();while(!n.done)})};return d});function ac(b){function d(h){return b.next(h)}function f(h){return b.throw(h)}return new Promise(function(h,k){function t(l){l.done?h(l.value):Promise.resolve(l.value).then(d,f).then(t,k)}t(b.next())})}function hc(b){return ac(b())};
//# sourceURL=build:/external/com_google_javascript_closure_library/closure/goog/deps.js
//# sourceURL=build://analytics.html.js
window.ga=function(){};

// 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(a,b){var c={},d={},e={},f=null;!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=w}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==u.indexOf(b[c]))return;if("direction"==c&&-1==v.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 0>a||a>1||0>c||c>1?w: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(0==e||1==e)return e;for(var g=0,h=1;;){var i=(g+h)/2,j=f(a,c,i);if(Math.abs(e-j)<1e-4)return f(b,d,i);e>j?g=i:h=i}}}function j(a,b){return function(c){if(c>=1)return 1;var d=1/a;return c+=b*d,c-c%d}}function k(a){B||(B=document.createElement("div").style),B.animationTimingFunction="",B.animationTimingFunction=a;var b=B.animationTimingFunction;if(""==b&&e())throw new TypeError(a+" is not a valid value for easing");var c=D.exec(b);if(c)return i.apply(this,c.slice(1).map(Number));var d=E.exec(b);if(d)return j(Number(d[1]),{start:x,middle:y,end:z}[d[2]]);var f=A[b];return f?f:w}function l(a){return Math.abs(m(a)/a.playbackRate)}function m(a){return a.duration*a.iterations}function n(a,b,c){return null==b?F:b<c.delay?G:b>=c.delay+a?H:I}function o(a,b,c,d,e){switch(d){case G:return"backwards"==b||"both"==b?0:null;case I:return c-e;case H:return"forwards"==b||"both"==b?a:null;case F:return null}}function p(a,b,c,d){return(d.playbackRate<0?b-a:b)*d.playbackRate+c}function q(a,b,c,d,e){return c===1/0||c===-(1/0)||c-d==b&&e.iterations&&(e.iterations+e.iterationStart)%1==0?a:c%a}function r(a,b,c,d){return 0===c?0:b==a?d.iterationStart+d.iterations-1:Math.floor(c/a)}function s(a,b,c,d){var e=a%2>=1,f="normal"==d.direction||d.direction==(e?"alternate-reverse":"alternate"),g=f?c:b-c,h=g/b;return b*d._easingFunction(h)}function t(a,b,c){var d=n(a,b,c),e=o(a,c.fill,b,d,c.delay);if(null===e)return null;if(0===a)return d===G?0:1;var f=c.iterationStart*c.duration,g=p(a,e,f,c),h=q(c.duration,m(c),g,f,c),i=r(c.duration,h,g,c);return s(i,c.duration,h,c)/c.duration}var u="backwards|forwards|both|none".split("|"),v="reverse|alternate|alternate-reverse".split("|"),w=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)||0>a)&&e())throw new TypeError("iterationStart must be a non-negative number, received: "+timing.iterationStart);this._setMember("iterationStart",a)},get iterationStart(){return this._iterationStart},set duration(a){if("auto"!=a&&(isNaN(a)||0>a)&&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=k(a),this._setMember("easing",a)},get easing(){return this._easing},set iterations(a){if((isNaN(a)||0>a)&&e())throw new TypeError("iterations must be non-negative, received: "+a);this._setMember("iterations",a)},get iterations(){return this._iterations}};var x=1,y=.5,z=0,A={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,x),"step-middle":j(1,y),"step-end":j(1,z)},B=null,C="\\s*(-?\\d+\\.?\\d*|-?\\.\\d+)\\s*",D=new RegExp("cubic-bezier\\("+C+","+C+","+C+","+C+"\\)"),E=/steps\(\s*(\d+)\s*,\s*(start|middle|end)\s*\)/,F=0,G=1,H=2,I=3;a.cloneTimingInput=c,a.makeTiming=f,a.numericTimingToObject=g,a.normalizeTimingInput=h,a.calculateActiveDuration=l,a.calculateTimeFraction=t,a.calculatePhase=n,a.toTimingFunction=k}(c,f),function(a,b){function c(a,b){return a in j?j[a][b]||b:b}function d(a,b,d){var e=g[a];if(e){h.style[a]=b;for(var f in e){var i=e[f],j=h.style[i];d[i]=c(i,j)}}else d[a]=c(a,b)}function e(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;f>g;g++)e={},"offset"in a?e.offset=a.offset:1==f?e.offset=1:e.offset=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 f(a){function b(){var a=c.length;null==c[a-1].offset&&(c[a-1].offset=1),a>1&&null==c[0].offset&&(c[0].offset=0);for(var b=0,d=c[0].offset,e=1;a>e;e++){var f=c[e].offset;if(null!=f){for(var g=1;e-b>g;g++)c[b+g].offset=d+(f-d)*g/(e-b);b=e,d=f}}}if(null==a)return[];window.Symbol&&Symbol.iterator&&Array.prototype.from&&a[Symbol.iterator]&&(a=Array.from(a)),Array.isArray(a)||(a=e(a));for(var c=a.map(function(a){var b={};for(var c in a){var e=a[c];if("offset"==c){if(null!=e&&(e=Number(e),!isFinite(e)))throw new TypeError("keyframe offsets must be numbers.")}else{if("composite"==c)throw{type:DOMException.NOT_SUPPORTED_ERR,name:"NotSupportedError",message:"add compositing is not supported"};e=""+e}d(c,e,b)}return void 0==b.offset&&(b.offset=null),b}),f=!0,g=-(1/0),h=0;h<c.length;h++){var i=c[h].offset;if(null!=i){if(g>i)throw{code:DOMException.INVALID_MODIFICATION_ERR,name:"InvalidModificationError",message:"Keyframes are not loosely sorted by offset. Sort or specify offsets."};g=i}else f=!1}return c=c.filter(function(a){return a.offset>=0&&a.offset<=1}),f||b(),c}var g={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"]},h=document.createElementNS("http://www.w3.org/1999/xhtml","div"),i={thin:"1px",medium:"3px",thick:"5px"},j={borderBottomWidth:i,borderLeftWidth:i,borderRightWidth:i,borderTopWidth:i,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:i,textShadow:{none:"0px 0px 0px transparent"},boxShadow:{none:"0px 0px 0px 0px transparent"}};a.convertToArrayForm=e,a.normalizeKeyframes=f}(c,f),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),h>g?(a in b||console.warn("Web Animations: "+a+" "+f+" deprecated and will stop working on "+h.toDateString()+". "+d),b[a]=!0,!1):!0},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)}}(c),function(){if(document.documentElement.animate){var a=document.documentElement.animate([],0),b=!0;if(a&&(b=!1,"play|currentTime|pause|reverse|playbackRate|cancel|finish|startTime|playState".split("|").forEach(function(c){void 0===a[c]&&(b=!0)})),!b)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=f[g].offset,i=f[g+1].offset,j=f[g].value,k=f[g+1].value,l=f[g].easing;h==i&&(1==i?j=k:k=j),d.push({startTime:h,endTime:i,easing:a.toTimingFunction(l?l:"linear"),property:e,interpolation:b.propertyInterpolation(e,j,k)})}return d.sort(function(a,b){return a.startTime-b.startTime}),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 0>=c&&0==a.startTime||c>=1&&1==a.endTime||c>=a.startTime&&c<=a.endTime}).forEach(function(d){var e=c-d.startTime,f=d.endTime-d.startTime,g=0==f?0:d.easing(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)}}}(c,d,f),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++){var g=c[f];e(a,b,d(g))}}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",textIndent:"0px",textShadow:"0px 0px 0px transparent",top:"auto",transform:"",verticalAlign:"0px",visibility:"visible",width:"auto",wordSpacing:"normal",zIndex:"auto"};b.propertyInterpolation=g}(c,d,f),function(a,b,c){function d(b){var c=a.calculateActiveDuration(b),d=function(d){return a.calculateTimeFraction(c,d,b)};return d._totalDuration=b.delay+c+b.endDelay,d._isCurrent=function(d){var e=a.calculatePhase(c,d,b);return e===PhaseActive||e===PhaseBefore},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 h=i(a),null!==h},k._clear=function(){j(c,null)},k._hasSameTarget=function(a){return c===a},k._isCurrent=i._isCurrent,k._totalDuration=i._totalDuration,k._id=g,k},b.NullEffect=function(a){var b=function(){a&&(a(),a=null)};return b._update=function(){return null},b._totalDuration=0,b._isCurrent=function(){return!1},b._hasSameTarget=function(){return!1},b}}(c,d,f),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)]=""}}(d,f),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))}}(d),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.5>d?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))}}}(d,f),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._tickCurrentTime(a,!0),b.invalidateEffects()))},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.invalidateEffects())},get playbackRate(){return this._playbackRate},set playbackRate(a){if(a!=this._playbackRate){var b=this.currentTime;this._playbackRate=a,this._startTime=null,"paused"!=this.playState&&"idle"!=this.playState&&this.play(),null!=b&&(this.currentTime=b)}},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"},play:function(){this._paused=!1,(this._isFinished||this._idle)&&(this._currentTime=this._playbackRate>0?0:this._totalDuration,this._startTime=null),this._finishedFlag=!1,this._idle=!1,this._ensureAlive(),b.invalidateEffects()},pause:function(){this._isFinished||this._paused||this._idle||(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.invalidateEffects())},cancel:function(){this._inEffect&&(this._inEffect=!1,this._idle=!0,this._finishedFlag=!0,this.currentTime=0,this._startTime=null,this._effect._update(null),b.invalidateEffects())},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}}}(c,d,f),function(a,b,c){function d(a){var b=j;j=[],a<p.currentTime&&(a=p.currentTime),h(a,!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){n=!1;var d=b.timeline;d.currentTime=a,d._animations.sort(e),m=!1;var f=d._animations;d._animations=[];var g=[],h=[];f=f.filter(function(b){b._tick(a,c),b._inEffect?h.push(b._effect):g.push(b._effect),b._needsTick&&(m=!0);var d=b._inEffect||b._needsTick;return b._inTimeline=d,d}),o.push.apply(o,g),o.push.apply(o,h),d._animations.push.apply(d._animations,f),m&&requestAnimationFrame(function(){})}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.invalidateEffects(),d}};var l=void 0,m=!1,n=!1;b.restart=function(){return m||(m=!0,requestAnimationFrame(function(){}),n=!0),n},b.invalidateEffects=function(){h(b.timeline.currentTime,!1),g()};var o=[],p=new f;b.timeline=p}(c,d,f),function(a){function b(a,b){var c=a.exec(b);return c?(c=a.ignoreCase?c[0].toLowerCase():c[0],[c,b.substr(c.length)]):void 0}function c(a,b){b=b.replace(/^\s*/,"");var c=a(b);return c?[c[0],c[1].replace(/^\s*/,"")]:void 0}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||""==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++,0>=c))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){var d=a(c);return d?d:[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]}return""==c?d:void 0}function j(a,b,c,d,e){for(var g=[],h=[],i=[],j=f(d.length,e.length),k=0;j>k;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}(d),function(a){function b(b){function c(b){var c=a.consumeToken(/^inset/i,b);if(c)return d.inset=!0,c;var c=a.consumeLengthOrPercent(b);if(c)return d.lengths.push(c[0]),c;var c=a.consumeColor(b);return c?(d.color=c[0],c):void 0}var d={inset:!1,lengths:[],color:null},e=a.consumeRepeated(c,/^/,b);return e&&e[0].length?[d,e[1]]:void 0}function c(c){var d=a.consumeRepeated(b,/^,/,c);return d&&""==d[1]?d[0]:void 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"])}(d),function(a,b){function c(a){return a.toFixed(3).replace(".000","")}function d(a,b,c){return Math.min(b,Math.max(a,c))}function e(a){return/^\s*[-+]?(\d*\.)?\d+\s*$/.test(a)?Number(a):void 0}function f(a,b){return[a,b,c]}function g(a,b){return 0!=a?i(0,1/0)(a,b):void 0}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,b){return[a,b,Math.round]}a.clamp=d,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,j,["z-index"]),a.parseNumber=e,a.mergeNumbers=f,a.numberToString=c}(d,f),function(a,b){function c(a,b){return"visible"==a||"visible"==b?[0,1,function(c){return 0>=c?a:c>=1?b:"visible"}]:void 0}a.addPropertiesHandler(String,c,["visibility"])}(d),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;3>d;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","outline-color","text-decoration-color"]),a.consumeColor=a.consumeParenthesised.bind(null,c),a.mergeColors=d}(d,f),function(a,b){function c(a,b){if(b=b.trim().toLowerCase(),"0"==b&&"px".search(a)>=0)return{px:0};if(/^[^(]*$|^calc/.test(b)){b=b.replace(/calc\(/g,"(");var c={};b=b.replace(a,function(a){return c[a]=null,"U"+a});for(var d="U("+a.source+")",e=b.replace(/[-+]?(\d*\.)?\d+/g,"N").replace(new RegExp("N"+d,"g"),"D").replace(/\s[+-]\s/g,"O").replace(/\s/g,""),f=[/N\*(D)/g,/(N|D)[*\/]N/g,/(N|D)O\1/g,/\((N|D)\)/g],g=0;g<f.length;)f[g].test(e)?(e=e.replace(f[g],"$1"),g=0):g++;if("D"==e){for(var h in c){var i=eval(b.replace(new RegExp("U"+h,"g"),"").replace(new RegExp(d,"g"),"*0"));if(!isFinite(i))return;c[h]=i}return c}}}function d(a,b){return e(a,b,!0)}function e(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 f="px|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc",g=c.bind(null,new RegExp(f,"g")),h=c.bind(null,new RegExp(f+"|%","g")),i=c.bind(null,/deg|rad|grad|turn/g);a.parseLength=g,a.parseLengthOrPercent=h,a.consumeLengthOrPercent=a.consumeParenthesised.bind(null,h),a.parseAngle=i,a.mergeDimensions=e;var j=a.consumeParenthesised.bind(null,g),k=a.consumeRepeated.bind(void 0,j,/^/),l=a.consumeRepeated.bind(void 0,k,/^,/);a.consumeSizePairList=l;var m=function(a){var b=l(a);return b&&""==b[1]?b[0]:void 0},n=a.mergeNestedRepeated.bind(void 0,d," "),o=a.mergeNestedRepeated.bind(void 0,n,",");a.mergeNonNegativeSizePair=n,a.addPropertiesHandler(m,o,["background-size"]),a.addPropertiesHandler(h,d,["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(h,e,["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","text-indent","top","vertical-align","word-spacing"])}(d,f),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);return d&&4==d[0].length?d[0]:void 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"])}(d,f),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(b=b.toLowerCase().trim(),"none"==b)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(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],void 0===p)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]),g=a.composeMatrix(b[0],b[1],b[2],c,b[4]),h=g.map(f).join(",");return h}])}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"])}(d,f),function(a,b){function c(a,b){b.concat([a]).forEach(function(b){b in document.documentElement.style&&(d[a]=b)})}var d={};c("transform",["webkitTransform","msTransform"]),c("transformOrigin",["webkitTransformOrigin"]),c("perspective",["webkitPerspective"]),c("perspectiveOrigin",["webkitPerspectiveOrigin"]),a.propertyName=function(a){return d[a]||a}}(d,f)}(),!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(g){}finally{c&&c.cancel()}if(!d){var h=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)),h.call(this,b,c)}}}(c),!function(a,b,c){function d(a){var b=window.document.timeline;b.currentTime=a,b._discardAnimations(),0==b._animations.length?f=!1:requestAnimationFrame(d);
}var e=window.requestAnimationFrame;window.requestAnimationFrame=function(a){return e(function(b){window.document.timeline._updateAnimationsPromises(),a(b),window.document.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(h){}try{window.document.timeline=g}catch(h){}}(c,e,f),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=window.document.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){"function"==typeof a?this._animation.onfinish=function(b){b.target=this,a.call(this,b)}.bind(this):this._animation.onfinish=a},get oncancel(){return this._animation.oncancel},set oncancel(a){"function"==typeof a?this._animation.oncancel=function(b){b.target=this,a.call(this,b)}.bind(this):this._animation.oncancel=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}),"paused"!=this.playState&&"idle"!=this.playState&&this.play(),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.calculateTimeFraction(a.calculateActiveDuration(d),e,d)),(null==e||isNaN(e))&&this._removeChildAnimations()}}},window.Animation=b.Animation}(c,e,f),function(a,b,c){function d(b){this._frames=a.normalizeKeyframes(b)}function e(){for(var a=!1;i.length;){var b=i.shift();b._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(){window.document.timeline._updateAnimationsPromises();var a=j.apply(this,arguments);return e()&&(a=j.apply(this,arguments)),window.document.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))}}(c,e,f),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.calculateTimeFraction(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)}}(c,e,f),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;return c&&"pending"!=c.playState&&c.effect?null==b?void c._removeChildAnimations():0==b&&c.playbackRate<0&&(e||(e=a.normalizeTimingInput(c.effect.timing)),b=a.calculateTimeFraction(a.calculateActiveDuration(e),-1,e),isNaN(b)||null==b)?(c._forEachChild(function(a){a.currentTime=-1}),void c._removeChildAnimations()):void 0: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}(c,e,f),b["true"]=a}({},function(){return this}());

/**
@license @nocompile
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
*/
(function(){/*

 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
*/
'use strict';var n,p="undefined"!=typeof window&&window===this?this:"undefined"!=typeof global&&null!=global?global:this,aa="function"==typeof Object.defineProperties?Object.defineProperty:function(a,b,c){a!=Array.prototype&&a!=Object.prototype&&(a[b]=c.value)};function ba(){ba=function(){};p.Symbol||(p.Symbol=ca)}var ca=function(){var a=0;return function(b){return"jscomp_symbol_"+(b||"")+a++}}();
function da(){ba();var a=p.Symbol.iterator;a||(a=p.Symbol.iterator=p.Symbol("iterator"));"function"!=typeof Array.prototype[a]&&aa(Array.prototype,a,{configurable:!0,writable:!0,value:function(){return ea(this)}});da=function(){}}function ea(a){var b=0;return fa(function(){return b<a.length?{done:!1,value:a[b++]}:{done:!0}})}function fa(a){da();a={next:a};a[p.Symbol.iterator]=function(){return this};return a}function ia(a){da();var b=a[Symbol.iterator];return b?b.call(a):ea(a)}
function ja(a){for(var b,c=[];!(b=a.next()).done;)c.push(b.value);return c}
(function(){if(!function(){var a=document.createEvent("Event");a.initEvent("foo",!0,!0);a.preventDefault();return a.defaultPrevented}()){var a=Event.prototype.preventDefault;Event.prototype.preventDefault=function(){this.cancelable&&(a.call(this),Object.defineProperty(this,"defaultPrevented",{get:function(){return!0},configurable:!0}))}}var b=/Trident/.test(navigator.userAgent);if(!window.CustomEvent||b&&"function"!==typeof window.CustomEvent)window.CustomEvent=function(a,b){b=b||{};var c=document.createEvent("CustomEvent");
c.initCustomEvent(a,!!b.bubbles,!!b.cancelable,b.detail);return c},window.CustomEvent.prototype=window.Event.prototype;if(!window.Event||b&&"function"!==typeof window.Event){var c=window.Event;window.Event=function(a,b){b=b||{};var c=document.createEvent("Event");c.initEvent(a,!!b.bubbles,!!b.cancelable);return c};if(c)for(var d in c)window.Event[d]=c[d];window.Event.prototype=c.prototype}if(!window.MouseEvent||b&&"function"!==typeof window.MouseEvent){b=window.MouseEvent;window.MouseEvent=function(a,
b){b=b||{};var c=document.createEvent("MouseEvent");c.initMouseEvent(a,!!b.bubbles,!!b.cancelable,b.view||window,b.detail,b.screenX,b.screenY,b.clientX,b.clientY,b.ctrlKey,b.altKey,b.shiftKey,b.metaKey,b.button,b.relatedTarget);return c};if(b)for(d in b)window.MouseEvent[d]=b[d];window.MouseEvent.prototype=b.prototype}Array.from||(Array.from=function(a){return[].slice.call(a)});Object.assign||(Object.assign=function(a,b){for(var c=[].slice.call(arguments,1),d=0,e;d<c.length;d++)if(e=c[d])for(var f=
a,m=e,q=Object.getOwnPropertyNames(m),x=0;x<q.length;x++)e=q[x],f[e]=m[e];return a})})(window.WebComponents);(function(){function a(){}function b(a,b){if(!a.childNodes.length)return[];switch(a.nodeType){case Node.DOCUMENT_NODE:return ua.call(a,b);case Node.DOCUMENT_FRAGMENT_NODE:return lb.call(a,b);default:return U.call(a,b)}}var c="undefined"===typeof HTMLTemplateElement,d=!(document.createDocumentFragment().cloneNode()instanceof DocumentFragment),e=!1;/Trident/.test(navigator.userAgent)&&function(){function a(a,b){if(a instanceof DocumentFragment)for(var d;d=a.firstChild;)c.call(this,d,b);else c.call(this,
a,b);return a}e=!0;var b=Node.prototype.cloneNode;Node.prototype.cloneNode=function(a){a=b.call(this,a);this instanceof DocumentFragment&&(a.__proto__=DocumentFragment.prototype);return a};DocumentFragment.prototype.querySelectorAll=HTMLElement.prototype.querySelectorAll;DocumentFragment.prototype.querySelector=HTMLElement.prototype.querySelector;Object.defineProperties(DocumentFragment.prototype,{nodeType:{get:function(){return Node.DOCUMENT_FRAGMENT_NODE},configurable:!0},localName:{get:function(){},
configurable:!0},nodeName:{get:function(){return"#document-fragment"},configurable:!0}});var c=Node.prototype.insertBefore;Node.prototype.insertBefore=a;var d=Node.prototype.appendChild;Node.prototype.appendChild=function(b){b instanceof DocumentFragment?a.call(this,b,null):d.call(this,b);return b};var f=Node.prototype.removeChild,g=Node.prototype.replaceChild;Node.prototype.replaceChild=function(b,c){b instanceof DocumentFragment?(a.call(this,b,c),f.call(this,c)):g.call(this,b,c);return c};Document.prototype.createDocumentFragment=
function(){var a=this.createElement("df");a.__proto__=DocumentFragment.prototype;return a};var h=Document.prototype.importNode;Document.prototype.importNode=function(a,b){b=h.call(this,a,b||!1);a instanceof DocumentFragment&&(b.__proto__=DocumentFragment.prototype);return b}}();var f=Node.prototype.cloneNode,g=Document.prototype.createElement,h=Document.prototype.importNode,k=Node.prototype.removeChild,l=Node.prototype.appendChild,m=Node.prototype.replaceChild,q=DOMParser.prototype.parseFromString,
x=Object.getOwnPropertyDescriptor(window.HTMLElement.prototype,"innerHTML")||{get:function(){return this.innerHTML},set:function(a){this.innerHTML=a}},M=Object.getOwnPropertyDescriptor(window.Node.prototype,"childNodes")||{get:function(){return this.childNodes}},U=Element.prototype.querySelectorAll,ua=Document.prototype.querySelectorAll,lb=DocumentFragment.prototype.querySelectorAll,mb=function(){if(!c){var a=document.createElement("template"),b=document.createElement("template");b.content.appendChild(document.createElement("div"));
a.content.appendChild(b);a=a.cloneNode(!0);return 0===a.content.childNodes.length||0===a.content.firstChild.content.childNodes.length||d}}();if(c){var S=document.implementation.createHTMLDocument("template"),C=!0,V=document.createElement("style");V.textContent="template{display:none;}";var ha=document.head;ha.insertBefore(V,ha.firstElementChild);a.prototype=Object.create(HTMLElement.prototype);var va=!document.createElement("div").hasOwnProperty("innerHTML");a.G=function(b){if(!b.content&&b.namespaceURI===
document.documentElement.namespaceURI){b.content=S.createDocumentFragment();for(var c;c=b.firstChild;)l.call(b.content,c);if(va)b.__proto__=a.prototype;else if(b.cloneNode=function(b){return a.a(this,b)},C)try{P(b),W(b)}catch(Tg){C=!1}a.C(b.content)}};var X={option:["select"],thead:["table"],col:["colgroup","table"],tr:["tbody","table"],th:["tr","tbody","table"],td:["tr","tbody","table"]},P=function(b){Object.defineProperty(b,"innerHTML",{get:function(){return nb(this)},set:function(b){var c=X[(/<([a-z][^/\0>\x20\t\r\n\f]+)/i.exec(b)||
["",""])[1].toLowerCase()];if(c)for(var d=0;d<c.length;d++)b="<"+c[d]+">"+b+"</"+c[d]+">";S.body.innerHTML=b;for(a.C(S);this.content.firstChild;)k.call(this.content,this.content.firstChild);b=S.body;if(c)for(d=0;d<c.length;d++)b=b.lastChild;for(;b.firstChild;)l.call(this.content,b.firstChild)},configurable:!0})},W=function(a){Object.defineProperty(a,"outerHTML",{get:function(){return"<template>"+this.innerHTML+"</template>"},set:function(a){if(this.parentNode){S.body.innerHTML=a;for(a=this.ownerDocument.createDocumentFragment();S.body.firstChild;)l.call(a,
S.body.firstChild);m.call(this.parentNode,a,this)}else throw Error("Failed to set the 'outerHTML' property on 'Element': This element has no parent node.");},configurable:!0})};P(a.prototype);W(a.prototype);a.C=function(c){c=b(c,"template");for(var d=0,e=c.length,f;d<e&&(f=c[d]);d++)a.G(f)};document.addEventListener("DOMContentLoaded",function(){a.C(document)});Document.prototype.createElement=function(){var b=g.apply(this,arguments);"template"===b.localName&&a.G(b);return b};DOMParser.prototype.parseFromString=
function(){var b=q.apply(this,arguments);a.C(b);return b};Object.defineProperty(HTMLElement.prototype,"innerHTML",{get:function(){return nb(this)},set:function(b){x.set.call(this,b);a.C(this)},configurable:!0,enumerable:!0});var Ve=/[&\u00A0"]/g,yc=/[&\u00A0<>]/g,zc=function(a){switch(a){case "&":return"&amp;";case "<":return"&lt;";case ">":return"&gt;";case '"':return"&quot;";case "\u00a0":return"&nbsp;"}};V=function(a){for(var b={},c=0;c<a.length;c++)b[a[c]]=!0;return b};var We=V("area base br col command embed hr img input keygen link meta param source track wbr".split(" ")),
Xe=V("style script xmp iframe noembed noframes plaintext noscript".split(" ")),nb=function(a,b){"template"===a.localName&&(a=a.content);for(var c="",d=b?b(a):M.get.call(a),e=0,f=d.length,g;e<f&&(g=d[e]);e++){a:{var h=g;var k=a;var l=b;switch(h.nodeType){case Node.ELEMENT_NODE:for(var P=h.localName,m="<"+P,W=h.attributes,q=0;k=W[q];q++)m+=" "+k.name+'="'+k.value.replace(Ve,zc)+'"';m+=">";h=We[P]?m:m+nb(h,l)+"</"+P+">";break a;case Node.TEXT_NODE:h=h.data;h=k&&Xe[k.localName]?h:h.replace(yc,zc);break a;
case Node.COMMENT_NODE:h="\x3c!--"+h.data+"--\x3e";break a;default:throw window.console.error(h),Error("not implemented");}}c+=h}return c}}if(c||mb){a.a=function(a,b){var c=f.call(a,!1);this.G&&this.G(c);b&&(l.call(c.content,f.call(a.content,!0)),ob(c.content,a.content));return c};var ob=function(c,d){if(d.querySelectorAll&&(d=b(d,"template"),0!==d.length)){c=b(c,"template");for(var e=0,f=c.length,g,h;e<f;e++)h=d[e],g=c[e],a&&a.G&&a.G(h),m.call(g.parentNode,Ye.call(h,!0),g)}},Ye=Node.prototype.cloneNode=
function(b){if(!e&&d&&this instanceof DocumentFragment)if(b)var c=Ze.call(this.ownerDocument,this,!0);else return this.ownerDocument.createDocumentFragment();else this.nodeType===Node.ELEMENT_NODE&&"template"===this.localName&&this.namespaceURI==document.documentElement.namespaceURI?c=a.a(this,b):c=f.call(this,b);b&&ob(c,this);return c},Ze=Document.prototype.importNode=function(c,d){d=d||!1;if("template"===c.localName)return a.a(c,d);var e=h.call(this,c,d);if(d){ob(e,c);c=b(e,'script:not([type]),script[type="application/javascript"],script[type="text/javascript"]');
for(var f,k=0;k<c.length;k++){f=c[k];d=g.call(document,"script");d.textContent=f.textContent;for(var l=f.attributes,P=0,W;P<l.length;P++)W=l[P],d.setAttribute(W.name,W.value);m.call(f.parentNode,d,f)}}return e}}c&&(window.HTMLTemplateElement=a)})();var ka=setTimeout;function la(){}function ma(a,b){return function(){a.apply(b,arguments)}}function r(a){if(!(this instanceof r))throw new TypeError("Promises must be constructed via new");if("function"!==typeof a)throw new TypeError("not a function");this.u=0;this.ma=!1;this.h=void 0;this.I=[];na(a,this)}
function oa(a,b){for(;3===a.u;)a=a.h;0===a.u?a.I.push(b):(a.ma=!0,pa(function(){var c=1===a.u?b.Na:b.Oa;if(null===c)(1===a.u?qa:ra)(b.ga,a.h);else{try{var d=c(a.h)}catch(e){ra(b.ga,e);return}qa(b.ga,d)}}))}function qa(a,b){try{if(b===a)throw new TypeError("A promise cannot be resolved with itself.");if(b&&("object"===typeof b||"function"===typeof b)){var c=b.then;if(b instanceof r){a.u=3;a.h=b;sa(a);return}if("function"===typeof c){na(ma(c,b),a);return}}a.u=1;a.h=b;sa(a)}catch(d){ra(a,d)}}
function ra(a,b){a.u=2;a.h=b;sa(a)}function sa(a){2===a.u&&0===a.I.length&&pa(function(){a.ma||"undefined"!==typeof console&&console&&console.warn("Possible Unhandled Promise Rejection:",a.h)});for(var b=0,c=a.I.length;b<c;b++)oa(a,a.I[b]);a.I=null}function ta(a,b,c){this.Na="function"===typeof a?a:null;this.Oa="function"===typeof b?b:null;this.ga=c}function na(a,b){var c=!1;try{a(function(a){c||(c=!0,qa(b,a))},function(a){c||(c=!0,ra(b,a))})}catch(d){c||(c=!0,ra(b,d))}}
r.prototype["catch"]=function(a){return this.then(null,a)};r.prototype.then=function(a,b){var c=new this.constructor(la);oa(this,new ta(a,b,c));return c};r.prototype["finally"]=function(a){var b=this.constructor;return this.then(function(c){return b.resolve(a()).then(function(){return c})},function(c){return b.resolve(a()).then(function(){return b.reject(c)})})};
function wa(a){return new r(function(b,c){function d(a,g){try{if(g&&("object"===typeof g||"function"===typeof g)){var h=g.then;if("function"===typeof h){h.call(g,function(b){d(a,b)},c);return}}e[a]=g;0===--f&&b(e)}catch(m){c(m)}}if(!a||"undefined"===typeof a.length)throw new TypeError("Promise.all accepts an array");var e=Array.prototype.slice.call(a);if(0===e.length)return b([]);for(var f=e.length,g=0;g<e.length;g++)d(g,e[g])})}
function xa(a){return a&&"object"===typeof a&&a.constructor===r?a:new r(function(b){b(a)})}function ya(a){return new r(function(b,c){c(a)})}function za(a){return new r(function(b,c){for(var d=0,e=a.length;d<e;d++)a[d].then(b,c)})}var pa="function"===typeof setImmediate&&function(a){setImmediate(a)}||function(a){ka(a,0)};/*

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
*/
if(!window.Promise){window.Promise=r;r.prototype.then=r.prototype.then;r.all=wa;r.race=za;r.resolve=xa;r.reject=ya;var Aa=document.createTextNode(""),Ba=[];(new MutationObserver(function(){for(var a=Ba.length,b=0;b<a;b++)Ba[b]();Ba.splice(0,a)})).observe(Aa,{characterData:!0});pa=function(a){Ba.push(a);Aa.textContent=0<Aa.textContent.length?"":"a"}};(function(a){function b(a,b){if("function"===typeof window.CustomEvent)return new CustomEvent(a,b);var c=document.createEvent("CustomEvent");c.initCustomEvent(a,!!b.bubbles,!!b.cancelable,b.detail);return c}function c(a){if(M)return a.ownerDocument!==document?a.ownerDocument:null;var b=a.__importDoc;if(!b&&a.parentNode){b=a.parentNode;if("function"===typeof b.closest)b=b.closest("link[rel=import]");else for(;!h(b)&&(b=b.parentNode););a.__importDoc=b}return b}function d(a){var b=m(document,"link[rel=import]:not([import-dependency])"),
c=b.length;c?q(b,function(b){return g(b,function(){0===--c&&a()})}):a()}function e(a){function b(){"loading"!==document.readyState&&document.body&&(document.removeEventListener("readystatechange",b),a())}document.addEventListener("readystatechange",b);b()}function f(a){e(function(){return d(function(){return a&&a()})})}function g(a,b){if(a.__loaded)b&&b();else if("script"===a.localName&&!a.src||"style"===a.localName&&!a.firstChild)a.__loaded=!0,b&&b();else{var c=function(d){a.removeEventListener(d.type,
c);a.__loaded=!0;b&&b()};a.addEventListener("load",c);ha&&"style"===a.localName||a.addEventListener("error",c)}}function h(a){return a.nodeType===Node.ELEMENT_NODE&&"link"===a.localName&&"import"===a.rel}function k(){var a=this;this.a={};this.b=0;this.c=new MutationObserver(function(b){return a.Ja(b)});this.c.observe(document.head,{childList:!0,subtree:!0});this.loadImports(document)}function l(a){q(m(a,"template"),function(a){q(m(a.content,'script:not([type]),script[type="application/javascript"],script[type="text/javascript"],script[type="module"]'),
function(a){var b=document.createElement("script");q(a.attributes,function(a){return b.setAttribute(a.name,a.value)});b.textContent=a.textContent;a.parentNode.replaceChild(b,a)});l(a.content)})}function m(a,b){return a.childNodes.length?a.querySelectorAll(b):U}function q(a,b,c){var d=a?a.length:0,e=c?-1:1;for(c=c?d-1:0;c<d&&0<=c;c+=e)b(a[c],c)}var x=document.createElement("link"),M="import"in x,U=x.querySelectorAll("*"),ua=null;!1==="currentScript"in document&&Object.defineProperty(document,"currentScript",
{get:function(){return ua||("complete"!==document.readyState?document.scripts[document.scripts.length-1]:null)},configurable:!0});var lb=/(url\()([^)]*)(\))/g,mb=/(@import[\s]+(?!url\())([^;]*)(;)/g,S=/(<link[^>]*)(rel=['|"]?stylesheet['|"]?[^>]*>)/g,C={Ea:function(a,b){a.href&&a.setAttribute("href",C.X(a.getAttribute("href"),b));a.src&&a.setAttribute("src",C.X(a.getAttribute("src"),b));if("style"===a.localName){var c=C.qa(a.textContent,b,lb);a.textContent=C.qa(c,b,mb)}},qa:function(a,b,c){return a.replace(c,
function(a,c,d,e){a=d.replace(/["']/g,"");b&&(a=C.X(a,b));return c+"'"+a+"'"+e})},X:function(a,b){if(void 0===C.aa){C.aa=!1;try{var c=new URL("b","http://a");c.pathname="c%20d";C.aa="http://a/c%20d"===c.href}catch(yc){}}if(C.aa)return(new URL(a,b)).href;c=C.xa;c||(c=document.implementation.createHTMLDocument("temp"),C.xa=c,c.ja=c.createElement("base"),c.head.appendChild(c.ja),c.ia=c.createElement("a"));c.ja.href=b;c.ia.href=a;return c.ia.href||a}},V={async:!0,load:function(a,b,c){if(a)if(a.match(/^data:/)){a=
a.split(",");var d=a[1];d=-1<a[0].indexOf(";base64")?atob(d):decodeURIComponent(d);b(d)}else{var e=new XMLHttpRequest;e.open("GET",a,V.async);e.onload=function(){var a=e.responseURL||e.getResponseHeader("Location");a&&0===a.indexOf("/")&&(a=(location.origin||location.protocol+"//"+location.host)+a);var d=e.response||e.responseText;304===e.status||0===e.status||200<=e.status&&300>e.status?b(d,a):c(d)};e.send()}else c("error: href must be specified")}},ha=/Trident/.test(navigator.userAgent)||/Edge\/\d./i.test(navigator.userAgent);
k.prototype.loadImports=function(a){var b=this;a=m(a,"link[rel=import]");q(a,function(a){return b.g(a)})};k.prototype.g=function(a){var b=this,c=a.href;if(void 0!==this.a[c]){var d=this.a[c];d&&d.__loaded&&(a.__import=d,this.f(a))}else this.b++,this.a[c]="pending",V.load(c,function(a,d){a=b.Ka(a,d||c);b.a[c]=a;b.b--;b.loadImports(a);b.l()},function(){b.a[c]=null;b.b--;b.l()})};k.prototype.Ka=function(a,b){if(!a)return document.createDocumentFragment();ha&&(a=a.replace(S,function(a,b,c){return-1===
a.indexOf("type=")?b+" type=import-disable "+c:a}));var c=document.createElement("template");c.innerHTML=a;if(c.content)a=c.content,l(a);else for(a=document.createDocumentFragment();c.firstChild;)a.appendChild(c.firstChild);if(c=a.querySelector("base"))b=C.X(c.getAttribute("href"),b),c.removeAttribute("href");c=m(a,'link[rel=import],link[rel=stylesheet][href][type=import-disable],style:not([type]),link[rel=stylesheet][href]:not([type]),script:not([type]),script[type="application/javascript"],script[type="text/javascript"],script[type="module"]');
var d=0;q(c,function(a){g(a);C.Ea(a,b);a.setAttribute("import-dependency","");if("script"===a.localName&&!a.src&&a.textContent){if("module"===a.type)throw Error("Inline module scripts are not supported in HTML Imports.");a.setAttribute("src","data:text/javascript;charset=utf-8,"+encodeURIComponent(a.textContent+("\n//# sourceURL="+b+(d?"-"+d:"")+".js\n")));a.textContent="";d++}});return a};k.prototype.l=function(){var a=this;if(!this.b){this.c.disconnect();this.flatten(document);var b=!1,c=!1,d=function(){c&&
b&&(a.loadImports(document),a.b||(a.c.observe(document.head,{childList:!0,subtree:!0}),a.da()))};this.Ma(function(){c=!0;d()});this.La(function(){b=!0;d()})}};k.prototype.flatten=function(a){var b=this;a=m(a,"link[rel=import]");q(a,function(a){var c=b.a[a.href];(a.__import=c)&&c.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&(b.a[a.href]=a,a.readyState="loading",a.__import=a,b.flatten(c),a.appendChild(c))})};k.prototype.La=function(a){function b(e){if(e<d){var f=c[e],h=document.createElement("script");f.removeAttribute("import-dependency");
q(f.attributes,function(a){return h.setAttribute(a.name,a.value)});ua=h;f.parentNode.replaceChild(h,f);g(h,function(){ua=null;b(e+1)})}else a()}var c=m(document,"script[import-dependency]"),d=c.length;b(0)};k.prototype.Ma=function(a){var b=m(document,"style[import-dependency],link[rel=stylesheet][import-dependency]"),d=b.length;if(d){var e=ha&&!!document.querySelector("link[rel=stylesheet][href][type=import-disable]");q(b,function(b){g(b,function(){b.removeAttribute("import-dependency");0===--d&&
a()});if(e&&b.parentNode!==document.head){var f=document.createElement(b.localName);f.__appliedElement=b;f.setAttribute("type","import-placeholder");b.parentNode.insertBefore(f,b.nextSibling);for(f=c(b);f&&c(f);)f=c(f);f.parentNode!==document.head&&(f=null);document.head.insertBefore(b,f);b.removeAttribute("type")}})}else a()};k.prototype.da=function(){var a=this,b=m(document,"link[rel=import]");q(b,function(b){return a.f(b)},!0)};k.prototype.f=function(a){a.__loaded||(a.__loaded=!0,a.import&&(a.import.readyState=
"complete"),a.dispatchEvent(b(a.import?"load":"error",{bubbles:!1,cancelable:!1,detail:void 0})))};k.prototype.Ja=function(a){var b=this;q(a,function(a){return q(a.addedNodes,function(a){a&&a.nodeType===Node.ELEMENT_NODE&&(h(a)?b.g(a):b.loadImports(a))})})};var va=null;if(M)x=m(document,"link[rel=import]"),q(x,function(a){a.import&&"loading"===a.import.readyState||(a.__loaded=!0)}),x=function(a){a=a.target;h(a)&&(a.__loaded=!0)},document.addEventListener("load",x,!0),document.addEventListener("error",
x,!0);else{var X=Object.getOwnPropertyDescriptor(Node.prototype,"baseURI");Object.defineProperty((!X||X.configurable?Node:Element).prototype,"baseURI",{get:function(){var a=h(this)?this:c(this);return a?a.href:X&&X.get?X.get.call(this):(document.querySelector("base")||window.location).href},configurable:!0,enumerable:!0});Object.defineProperty(HTMLLinkElement.prototype,"import",{get:function(){return this.__import||null},configurable:!0,enumerable:!0});e(function(){va=new k})}f(function(){return document.dispatchEvent(b("HTMLImportsLoaded",
{cancelable:!0,bubbles:!0,detail:void 0}))});a.useNative=M;a.whenReady=f;a.importForElement=c;a.loadImports=function(a){va&&va.loadImports(a)}})(window.HTMLImports=window.HTMLImports||{});/*

 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
*/
window.WebComponents=window.WebComponents||{flags:{}};var Ca=document.querySelector('script[src*="webcomponents-lite.js"]'),Da=/wc-(.+)/,t={};if(!t.noOpts){location.search.slice(1).split("&").forEach(function(a){a=a.split("=");var b;a[0]&&(b=a[0].match(Da))&&(t[b[1]]=a[1]||!0)});if(Ca)for(var Ea=0,Fa=void 0;Fa=Ca.attributes[Ea];Ea++)"src"!==Fa.name&&(t[Fa.name]=Fa.value||!0);if(t.log&&t.log.split){var Ga=t.log.split(",");t.log={};Ga.forEach(function(a){t.log[a]=!0})}else t.log={}}
window.WebComponents.flags=t;var Ha=t.shadydom;Ha&&(window.ShadyDOM=window.ShadyDOM||{},window.ShadyDOM.force=Ha);var Ia=t.register||t.ce;Ia&&window.customElements&&(window.customElements.forcePolyfill=Ia);/*

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
*/
function Ja(){this.pa=this.root=null;this.T=!1;this.D=this.P=this.ca=this.assignedSlot=this.assignedNodes=this.H=null;this.childNodes=this.nextSibling=this.previousSibling=this.lastChild=this.firstChild=this.parentNode=this.K=void 0;this.ka=this.la=!1;this.O={}}Ja.prototype.toJSON=function(){return{}};function u(a){a.__shady||(a.__shady=new Ja);return a.__shady}function v(a){return a&&a.__shady};var w=window.ShadyDOM||{};w.Ga=!(!Element.prototype.attachShadow||!Node.prototype.getRootNode);var Ka=Object.getOwnPropertyDescriptor(Node.prototype,"firstChild");w.m=!!(Ka&&Ka.configurable&&Ka.get);w.ea=w.force||!w.Ga;w.J=w.noPatch||!1;w.oa=w.preferPerformance;function y(a){return(a=v(a))&&void 0!==a.firstChild}function z(a){return"ShadyRoot"===a.za}function La(a){return(a=(a=v(a))&&a.root)&&Ma(a)}
var Na=Element.prototype,Oa=Na.matches||Na.matchesSelector||Na.mozMatchesSelector||Na.msMatchesSelector||Na.oMatchesSelector||Na.webkitMatchesSelector,Pa=document.createTextNode(""),Qa=0,Ra=[];(new MutationObserver(function(){for(;Ra.length;)try{Ra.shift()()}catch(a){throw Pa.textContent=Qa++,a;}})).observe(Pa,{characterData:!0});function Sa(a){Ra.push(a);Pa.textContent=Qa++}var Ta=!!document.contains;function Ua(a,b){for(;b;){if(b==a)return!0;b=b.__shady_parentNode}return!1}
function Va(a){for(var b=a.length-1;0<=b;b--){var c=a[b],d=c.getAttribute("id")||c.getAttribute("name");d&&"length"!==d&&isNaN(d)&&(a[d]=c)}a.item=function(b){return a[b]};a.namedItem=function(b){if("length"!==b&&isNaN(b)&&a[b])return a[b];for(var c=ia(a),d=c.next();!d.done;d=c.next())if(d=d.value,(d.getAttribute("id")||d.getAttribute("name"))==b)return d;return null};return a}
function A(a,b,c,d){c=void 0===c?"":c;for(var e in b){var f=b[e];if(!(d&&0<=d.indexOf(e))){f.configurable=!0;var g=c+e;if(f.value)a[g]=f.value;else try{Object.defineProperty(a,g,f)}catch(h){}}}}function B(a){var b={};Object.getOwnPropertyNames(a).forEach(function(c){b[c]=Object.getOwnPropertyDescriptor(a,c)});return b};var Wa=[],Xa;function Ya(a){Xa||(Xa=!0,Sa(Za));Wa.push(a)}function Za(){Xa=!1;for(var a=!!Wa.length;Wa.length;)Wa.shift()();return a}Za.list=Wa;function $a(){this.a=!1;this.addedNodes=[];this.removedNodes=[];this.S=new Set}function ab(a){a.a||(a.a=!0,Sa(function(){a.flush()}))}$a.prototype.flush=function(){if(this.a){this.a=!1;var a=this.takeRecords();a.length&&this.S.forEach(function(b){b(a)})}};$a.prototype.takeRecords=function(){if(this.addedNodes.length||this.removedNodes.length){var a=[{addedNodes:this.addedNodes,removedNodes:this.removedNodes}];this.addedNodes=[];this.removedNodes=[];return a}return[]};
function bb(a,b){var c=u(a);c.H||(c.H=new $a);c.H.S.add(b);var d=c.H;return{ya:b,F:d,Aa:a,takeRecords:function(){return d.takeRecords()}}}function cb(a){var b=a&&a.F;b&&(b.S.delete(a.ya),b.S.size||(u(a.Aa).H=null))}
function db(a,b){var c=b.getRootNode();return a.map(function(a){var b=c===a.target.getRootNode();if(b&&a.addedNodes){if(b=Array.from(a.addedNodes).filter(function(a){return c===a.getRootNode()}),b.length)return a=Object.create(a),Object.defineProperty(a,"addedNodes",{value:b,configurable:!0}),a}else if(b)return a}).filter(function(a){return a})};var eb=/[&\u00A0"]/g,fb=/[&\u00A0<>]/g;function gb(a){switch(a){case "&":return"&amp;";case "<":return"&lt;";case ">":return"&gt;";case '"':return"&quot;";case "\u00a0":return"&nbsp;"}}function hb(a){for(var b={},c=0;c<a.length;c++)b[a[c]]=!0;return b}var ib=hb("area base br col command embed hr img input keygen link meta param source track wbr".split(" ")),jb=hb("style script xmp iframe noembed noframes plaintext noscript".split(" "));
function kb(a,b){"template"===a.localName&&(a=a.content);for(var c="",d=b?b(a):a.childNodes,e=0,f=d.length,g=void 0;e<f&&(g=d[e]);e++){a:{var h=g;var k=a,l=b;switch(h.nodeType){case Node.ELEMENT_NODE:k=h.localName;for(var m="<"+k,q=h.attributes,x=0,M;M=q[x];x++)m+=" "+M.name+'="'+M.value.replace(eb,gb)+'"';m+=">";h=ib[k]?m:m+kb(h,l)+"</"+k+">";break a;case Node.TEXT_NODE:h=h.data;h=k&&jb[k.localName]?h:h.replace(fb,gb);break a;case Node.COMMENT_NODE:h="\x3c!--"+h.data+"--\x3e";break a;default:throw window.console.error(h),
Error("not implemented");}}c+=h}return c};var pb=w.m,qb={querySelector:function(a){return this.__shady_native_querySelector(a)},querySelectorAll:function(a){return this.__shady_native_querySelectorAll(a)}},rb={};function sb(a){rb[a]=function(b){return b["__shady_native_"+a]}}function tb(a,b){A(a,b,"__shady_native_");for(var c in b)sb(c)}function D(a,b){b=void 0===b?[]:b;for(var c=0;c<b.length;c++){var d=b[c],e=Object.getOwnPropertyDescriptor(a,d);e&&(Object.defineProperty(a,"__shady_native_"+d,e),e.value?qb[d]||(qb[d]=e.value):sb(d))}}
var E=document.createTreeWalker(document,NodeFilter.SHOW_ALL,null,!1),F=document.createTreeWalker(document,NodeFilter.SHOW_ELEMENT,null,!1),ub=document.implementation.createHTMLDocument("inert");function vb(a){for(var b;b=a.__shady_native_firstChild;)a.__shady_native_removeChild(b)}var wb=["firstElementChild","lastElementChild","children","childElementCount"],xb=["querySelector","querySelectorAll"];
function yb(){var a=["dispatchEvent","addEventListener","removeEventListener"];window.EventTarget?D(window.EventTarget.prototype,a):(D(Node.prototype,a),D(Window.prototype,a));pb?D(Node.prototype,"parentNode firstChild lastChild previousSibling nextSibling childNodes parentElement textContent".split(" ")):tb(Node.prototype,{parentNode:{get:function(){E.currentNode=this;return E.parentNode()}},firstChild:{get:function(){E.currentNode=this;return E.firstChild()}},lastChild:{get:function(){E.currentNode=
this;return E.lastChild()}},previousSibling:{get:function(){E.currentNode=this;return E.previousSibling()}},nextSibling:{get:function(){E.currentNode=this;return E.nextSibling()}},childNodes:{get:function(){var a=[];E.currentNode=this;for(var c=E.firstChild();c;)a.push(c),c=E.nextSibling();return a}},parentElement:{get:function(){F.currentNode=this;return F.parentNode()}},textContent:{get:function(){switch(this.nodeType){case Node.ELEMENT_NODE:case Node.DOCUMENT_FRAGMENT_NODE:for(var a=document.createTreeWalker(this,
NodeFilter.SHOW_TEXT,null,!1),c="",d;d=a.nextNode();)c+=d.nodeValue;return c;default:return this.nodeValue}},set:function(a){if("undefined"===typeof a||null===a)a="";switch(this.nodeType){case Node.ELEMENT_NODE:case Node.DOCUMENT_FRAGMENT_NODE:vb(this);(0<a.length||this.nodeType===Node.ELEMENT_NODE)&&this.__shady_native_insertBefore(document.createTextNode(a),void 0);break;default:this.nodeValue=a}}}});D(Node.prototype,"appendChild insertBefore removeChild replaceChild cloneNode contains".split(" "));
a={firstElementChild:{get:function(){F.currentNode=this;return F.firstChild()}},lastElementChild:{get:function(){F.currentNode=this;return F.lastChild()}},children:{get:function(){var a=[];F.currentNode=this;for(var c=F.firstChild();c;)a.push(c),c=F.nextSibling();return Va(a)}},childElementCount:{get:function(){return this.children?this.children.length:0}}};pb?(D(Element.prototype,wb),D(Element.prototype,["previousElementSibling","nextElementSibling","innerHTML"]),Object.getOwnPropertyDescriptor(HTMLElement.prototype,
"children")&&D(HTMLElement.prototype,["children"]),Object.getOwnPropertyDescriptor(HTMLElement.prototype,"innerHTML")&&D(HTMLElement.prototype,["innerHTML"])):(tb(Element.prototype,a),tb(Element.prototype,{previousElementSibling:{get:function(){F.currentNode=this;return F.previousSibling()}},nextElementSibling:{get:function(){F.currentNode=this;return F.nextSibling()}},innerHTML:{get:function(){return kb(this,function(a){return a.__shady_native_childNodes})},set:function(a){var b="template"===this.localName?
this.content:this;vb(b);var d=this.localName||"div";d=this.namespaceURI&&this.namespaceURI!==ub.namespaceURI?ub.createElementNS(this.namespaceURI,d):ub.createElement(d);d.innerHTML=a;for(a="template"===this.localName?d.content:d;d=a.__shady_native_firstChild;)b.__shady_native_insertBefore(d,void 0)}}}));D(Element.prototype,"setAttribute getAttribute hasAttribute removeAttribute focus blur".split(" "));D(Element.prototype,xb);D(HTMLElement.prototype,["focus","blur","contains"]);pb&&D(HTMLElement.prototype,
["parentElement","children","innerHTML"]);window.HTMLTemplateElement&&D(window.HTMLTemplateElement.prototype,["innerHTML"]);pb?D(DocumentFragment.prototype,wb):tb(DocumentFragment.prototype,a);D(DocumentFragment.prototype,xb);pb?(D(Document.prototype,wb),D(Document.prototype,["activeElement"])):tb(Document.prototype,a);D(Document.prototype,["importNode","getElementById"]);D(Document.prototype,xb)};var zb=B({get childNodes(){return this.__shady_childNodes},get firstChild(){return this.__shady_firstChild},get lastChild(){return this.__shady_lastChild},get textContent(){return this.__shady_textContent},set textContent(a){this.__shady_textContent=a},get childElementCount(){return this.__shady_childElementCount},get children(){return this.__shady_children},get firstElementChild(){return this.__shady_firstElementChild},get lastElementChild(){return this.__shady_lastElementChild},get innerHTML(){return this.__shady_innerHTML},
set innerHTML(a){return this.__shady_innerHTML=a},get shadowRoot(){return this.__shady_shadowRoot}}),Ab=B({get parentElement(){return this.__shady_parentElement},get parentNode(){return this.__shady_parentNode},get nextSibling(){return this.__shady_nextSibling},get previousSibling(){return this.__shady_previousSibling},get nextElementSibling(){return this.__shady_nextElementSibling},get previousElementSibling(){return this.__shady_previousElementSibling},get className(){return this.__shady_className},
set className(a){return this.__shady_className=a}}),Bb;for(Bb in zb)zb[Bb].enumerable=!1;for(var Cb in Ab)Ab[Cb].enumerable=!1;var Db=w.m||w.J,Eb=Db?function(){}:function(a){var b=u(a);b.la||(b.la=!0,A(a,Ab))},Fb=Db?function(){}:function(a){var b=u(a);b.ka||(b.ka=!0,A(a,zb))};var Gb="__eventWrappers"+Date.now(),Hb=function(){var a=Object.getOwnPropertyDescriptor(Event.prototype,"composed");return a?function(b){return a.get.call(b)}:null}(),Ib={blur:!0,focus:!0,focusin:!0,focusout:!0,click:!0,dblclick:!0,mousedown:!0,mouseenter:!0,mouseleave:!0,mousemove:!0,mouseout:!0,mouseover:!0,mouseup:!0,wheel:!0,beforeinput:!0,input:!0,keydown:!0,keyup:!0,compositionstart:!0,compositionupdate:!0,compositionend:!0,touchstart:!0,touchend:!0,touchmove:!0,touchcancel:!0,pointerover:!0,
pointerenter:!0,pointerdown:!0,pointermove:!0,pointerup:!0,pointercancel:!0,pointerout:!0,pointerleave:!0,gotpointercapture:!0,lostpointercapture:!0,dragstart:!0,drag:!0,dragenter:!0,dragleave:!0,dragover:!0,drop:!0,dragend:!0,DOMActivate:!0,DOMFocusIn:!0,DOMFocusOut:!0,keypress:!0},Jb={DOMAttrModified:!0,DOMAttributeNameChanged:!0,DOMCharacterDataModified:!0,DOMElementNameChanged:!0,DOMNodeInserted:!0,DOMNodeInsertedIntoDocument:!0,DOMNodeRemoved:!0,DOMNodeRemovedFromDocument:!0,DOMSubtreeModified:!0};
function Kb(a){return a instanceof Node?a.__shady_getRootNode():a}function Lb(a,b){var c=[],d=a;for(a=Kb(a);d;)c.push(d),d.__shady_assignedSlot?d=d.__shady_assignedSlot:d.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&d.host&&(b||d!==a)?d=d.host:d=d.__shady_parentNode;c[c.length-1]===document&&c.push(window);return c}function Mb(a){a.__composedPath||(a.__composedPath=Lb(a.target,!0));return a.__composedPath}
function Nb(a,b){if(!z)return a;a=Lb(a,!0);for(var c=0,d,e=void 0,f,g=void 0;c<b.length;c++)if(d=b[c],f=Kb(d),f!==e&&(g=a.indexOf(f),e=f),!z(f)||-1<g)return d}function Ob(a){function b(b,d){b=new a(b,d);b.__composed=d&&!!d.composed;return b}b.__proto__=a;b.prototype=a.prototype;return b}var Pb={focus:!0,blur:!0};function Qb(a){return a.__target!==a.target||a.__relatedTarget!==a.relatedTarget}
function Rb(a,b,c){if(c=b.__handlers&&b.__handlers[a.type]&&b.__handlers[a.type][c])for(var d=0,e;(e=c[d])&&(!Qb(a)||a.target!==a.relatedTarget)&&(e.call(b,a),!a.__immediatePropagationStopped);d++);}
function Sb(a){var b=a.composedPath();Object.defineProperty(a,"currentTarget",{get:function(){return d},configurable:!0});for(var c=b.length-1;0<=c;c--){var d=b[c];Rb(a,d,"capture");if(a.Z)return}Object.defineProperty(a,"eventPhase",{get:function(){return Event.AT_TARGET}});var e;for(c=0;c<b.length;c++){d=b[c];var f=v(d);f=f&&f.root;if(0===c||f&&f===e)if(Rb(a,d,"bubble"),d!==window&&(e=d.__shady_getRootNode()),a.Z)break}}
function Tb(a,b,c,d,e,f){for(var g=0;g<a.length;g++){var h=a[g],k=h.type,l=h.capture,m=h.once,q=h.passive;if(b===h.node&&c===k&&d===l&&e===m&&f===q)return g}return-1}
function Ub(a,b,c){if(b){var d=typeof b;if("function"===d||"object"===d)if("object"!==d||b.handleEvent&&"function"===typeof b.handleEvent){if(Jb[a])return this.__shady_native_addEventListener(a,b,c);if(c&&"object"===typeof c){var e=!!c.capture;var f=!!c.once;var g=!!c.passive}else e=!!c,g=f=!1;var h=c&&c.$||this,k=b[Gb];if(k){if(-1<Tb(k,h,a,e,f,g))return}else b[Gb]=[];k=function(e){f&&this.__shady_removeEventListener(a,b,c);e.__target||Vb(e);if(h!==this){var g=Object.getOwnPropertyDescriptor(e,"currentTarget");
Object.defineProperty(e,"currentTarget",{get:function(){return h},configurable:!0})}e.__previousCurrentTarget=e.currentTarget;if(!z(h)||-1!=e.composedPath().indexOf(h))if(e.composed||-1<e.composedPath().indexOf(h))if(Qb(e)&&e.target===e.relatedTarget)e.eventPhase===Event.BUBBLING_PHASE&&e.stopImmediatePropagation();else if(e.eventPhase===Event.CAPTURING_PHASE||e.bubbles||e.target===h||h instanceof Window){var k="function"===d?b.call(h,e):b.handleEvent&&b.handleEvent(e);h!==this&&(g?(Object.defineProperty(e,
"currentTarget",g),g=null):delete e.currentTarget);return k}};b[Gb].push({node:h,type:a,capture:e,once:f,passive:g,Ya:k});Pb[a]?(this.__handlers=this.__handlers||{},this.__handlers[a]=this.__handlers[a]||{capture:[],bubble:[]},this.__handlers[a][e?"capture":"bubble"].push(k)):this.__shady_native_addEventListener(a,k,c)}}}
function Wb(a,b,c){if(b){if(Jb[a])return this.__shady_native_removeEventListener(a,b,c);if(c&&"object"===typeof c){var d=!!c.capture;var e=!!c.once;var f=!!c.passive}else d=!!c,f=e=!1;var g=c&&c.$||this,h=void 0;var k=null;try{k=b[Gb]}catch(l){}k&&(e=Tb(k,g,a,d,e,f),-1<e&&(h=k.splice(e,1)[0].Ya,k.length||(b[Gb]=void 0)));this.__shady_native_removeEventListener(a,h||b,c);h&&Pb[a]&&this.__handlers&&this.__handlers[a]&&(a=this.__handlers[a][d?"capture":"bubble"],h=a.indexOf(h),-1<h&&a.splice(h,1))}}
function Xb(){for(var a in Pb)window.__shady_native_addEventListener(a,function(a){a.__target||(Vb(a),Sb(a))},!0)}
var Yb=B({get composed(){void 0===this.__composed&&(Hb?this.__composed="focusin"===this.type||"focusout"===this.type||Hb(this):!1!==this.isTrusted&&(this.__composed=Ib[this.type]));return this.__composed||!1},composedPath:function(){this.__composedPath||(this.__composedPath=Lb(this.__target,this.composed));return this.__composedPath},get target(){return Nb(this.currentTarget||this.__previousCurrentTarget,this.composedPath())},get relatedTarget(){if(!this.__relatedTarget)return null;this.__relatedTargetComposedPath||
(this.__relatedTargetComposedPath=Lb(this.__relatedTarget,!0));return Nb(this.currentTarget||this.__previousCurrentTarget,this.__relatedTargetComposedPath)},stopPropagation:function(){Event.prototype.stopPropagation.call(this);this.Z=!0},stopImmediatePropagation:function(){Event.prototype.stopImmediatePropagation.call(this);this.Z=this.__immediatePropagationStopped=!0}});
function Vb(a){a.__target=a.target;a.__relatedTarget=a.relatedTarget;if(w.m){var b=Object.getPrototypeOf(a);if(!Object.hasOwnProperty(b,"__shady_patchedProto")){var c=Object.create(b);c.__shady_sourceProto=b;A(c,Yb);b.__shady_patchedProto=c}a.__proto__=b.__shady_patchedProto}else A(a,Yb)}var Zb=Ob(Event),$b=Ob(CustomEvent),ac=Ob(MouseEvent);
function bc(){if(!Hb&&Object.getOwnPropertyDescriptor(Event.prototype,"isTrusted")){var a=function(){var a=new MouseEvent("click",{bubbles:!0,cancelable:!0,composed:!0});this.__shady_dispatchEvent(a)};Element.prototype.click?Element.prototype.click=a:HTMLElement.prototype.click&&(HTMLElement.prototype.click=a)}}var cc=Object.getOwnPropertyNames(Document.prototype).filter(function(a){return"on"===a.substring(0,2)});function dc(a,b){return{index:a,L:[],R:b}}
function ec(a,b,c,d){var e=0,f=0,g=0,h=0,k=Math.min(b-e,d-f);if(0==e&&0==f)a:{for(g=0;g<k;g++)if(a[g]!==c[g])break a;g=k}if(b==a.length&&d==c.length){h=a.length;for(var l=c.length,m=0;m<k-g&&fc(a[--h],c[--l]);)m++;h=m}e+=g;f+=g;b-=h;d-=h;if(0==b-e&&0==d-f)return[];if(e==b){for(b=dc(e,0);f<d;)b.L.push(c[f++]);return[b]}if(f==d)return[dc(e,b-e)];k=e;g=f;d=d-g+1;h=b-k+1;b=Array(d);for(l=0;l<d;l++)b[l]=Array(h),b[l][0]=l;for(l=0;l<h;l++)b[0][l]=l;for(l=1;l<d;l++)for(m=1;m<h;m++)if(a[k+m-1]===c[g+l-1])b[l][m]=
b[l-1][m-1];else{var q=b[l-1][m]+1,x=b[l][m-1]+1;b[l][m]=q<x?q:x}k=b.length-1;g=b[0].length-1;d=b[k][g];for(a=[];0<k||0<g;)0==k?(a.push(2),g--):0==g?(a.push(3),k--):(h=b[k-1][g-1],l=b[k-1][g],m=b[k][g-1],q=l<m?l<h?l:h:m<h?m:h,q==h?(h==d?a.push(0):(a.push(1),d=h),k--,g--):q==l?(a.push(3),k--,d=l):(a.push(2),g--,d=m));a.reverse();b=void 0;k=[];for(g=0;g<a.length;g++)switch(a[g]){case 0:b&&(k.push(b),b=void 0);e++;f++;break;case 1:b||(b=dc(e,0));b.R++;e++;b.L.push(c[f]);f++;break;case 2:b||(b=dc(e,0));
b.R++;e++;break;case 3:b||(b=dc(e,0)),b.L.push(c[f]),f++}b&&k.push(b);return k}function fc(a,b){return a===b};function gc(a,b,c){Eb(a);c=c||null;var d=u(a),e=u(b),f=c?u(c):null;d.previousSibling=c?f.previousSibling:b.__shady_lastChild;if(f=v(d.previousSibling))f.nextSibling=a;if(f=v(d.nextSibling=c))f.previousSibling=a;d.parentNode=b;c?c===e.firstChild&&(e.firstChild=a):(e.lastChild=a,e.firstChild||(e.firstChild=a));e.childNodes=null}
function hc(a,b,c){Fb(b);var d=u(b);void 0!==d.firstChild&&(d.childNodes=null);if(a.nodeType===Node.DOCUMENT_FRAGMENT_NODE){d=a.__shady_childNodes;for(var e=0;e<d.length;e++)gc(d[e],b,c);a=u(a);b=void 0!==a.firstChild?null:void 0;a.firstChild=a.lastChild=b;a.childNodes=b}else gc(a,b,c)}
function ic(a,b){var c=u(a);b=u(b);a===b.firstChild&&(b.firstChild=c.nextSibling);a===b.lastChild&&(b.lastChild=c.previousSibling);a=c.previousSibling;var d=c.nextSibling;a&&(u(a).nextSibling=d);d&&(u(d).previousSibling=a);c.parentNode=c.previousSibling=c.nextSibling=void 0;void 0!==b.childNodes&&(b.childNodes=null)}
function jc(a){var b=u(a);if(void 0===b.firstChild){b.childNodes=null;var c=b.firstChild=a.__shady_native_firstChild||null;b.lastChild=a.__shady_native_lastChild||null;Fb(a);b=c;for(c=void 0;b;b=b.__shady_native_nextSibling){var d=u(b);d.parentNode=a;d.nextSibling=b.__shady_native_nextSibling||null;d.previousSibling=c||null;c=b;Eb(b)}}};var kc=null;function G(){kc||(kc=window.ShadyCSS&&window.ShadyCSS.ScopingShim);return kc||null}function lc(a,b){var c=G();c&&c.unscopeNode(a,b)}function mc(a,b){var c=G();if(!c)return!0;if(a.nodeType===Node.DOCUMENT_FRAGMENT_NODE){c=!0;a=a.__shady_childNodes;for(var d=0;c&&d<a.length;d++)c=c&&mc(a[d],b);return c}return a.nodeType!==Node.ELEMENT_NODE?!0:c.currentScopeForNode(a)===b}function nc(a){if(a.nodeType!==Node.ELEMENT_NODE)return"";var b=G();return b?b.currentScopeForNode(a):""}
function oc(a,b){if(a){a.nodeType===Node.ELEMENT_NODE&&b(a);a=a.__shady_childNodes;for(var c=0,d;c<a.length;c++)d=a[c],d.nodeType===Node.ELEMENT_NODE&&oc(d,b)}};var pc=window.document,qc=w.oa,rc=Object.getOwnPropertyDescriptor(Node.prototype,"isConnected"),sc=rc&&rc.get;function tc(a){for(var b;b=a.__shady_firstChild;)a.__shady_removeChild(b)}function uc(a){var b=v(a);if(b&&void 0!==b.K){b=a.__shady_childNodes;for(var c=0,d=b.length,e=void 0;c<d&&(e=b[c]);c++)uc(e)}if(a=v(a))a.K=void 0}function vc(a){var b=a;a&&"slot"===a.localName&&(b=(b=(b=v(a))&&b.D)&&b.length?b[0]:vc(a.__shady_nextSibling));return b}
function wc(a,b,c){if(a=(a=v(a))&&a.H)b&&a.addedNodes.push(b),c&&a.removedNodes.push(c),ab(a)}
var Cc=B({get parentNode(){var a=v(this);a=a&&a.parentNode;return void 0!==a?a:this.__shady_native_parentNode},get firstChild(){var a=v(this);a=a&&a.firstChild;return void 0!==a?a:this.__shady_native_firstChild},get lastChild(){var a=v(this);a=a&&a.lastChild;return void 0!==a?a:this.__shady_native_lastChild},get nextSibling(){var a=v(this);a=a&&a.nextSibling;return void 0!==a?a:this.__shady_native_nextSibling},get previousSibling(){var a=v(this);a=a&&a.previousSibling;return void 0!==a?a:this.__shady_native_previousSibling},
get childNodes(){if(y(this)){var a=v(this);if(!a.childNodes){a.childNodes=[];for(var b=this.__shady_firstChild;b;b=b.__shady_nextSibling)a.childNodes.push(b)}var c=a.childNodes}else c=this.__shady_native_childNodes;c.item=function(a){return c[a]};return c},get parentElement(){var a=v(this);(a=a&&a.parentNode)&&a.nodeType!==Node.ELEMENT_NODE&&(a=null);return void 0!==a?a:this.__shady_native_parentElement},get isConnected(){if(sc&&sc.call(this))return!0;if(this.nodeType==Node.DOCUMENT_FRAGMENT_NODE)return!1;
var a=this.ownerDocument;if(Ta){if(a.__shady_native_contains(this))return!0}else if(a.documentElement&&a.documentElement.__shady_native_contains(this))return!0;for(a=this;a&&!(a instanceof Document);)a=a.__shady_parentNode||(z(a)?a.host:void 0);return!!(a&&a instanceof Document)},get textContent(){if(y(this)){for(var a=[],b=0,c=this.__shady_childNodes,d;d=c[b];b++)d.nodeType!==Node.COMMENT_NODE&&a.push(d.__shady_textContent);return a.join("")}return this.__shady_native_textContent},set textContent(a){if("undefined"===
typeof a||null===a)a="";switch(this.nodeType){case Node.ELEMENT_NODE:case Node.DOCUMENT_FRAGMENT_NODE:if(!y(this)&&w.m){var b=this.__shady_firstChild;(b!=this.__shady_lastChild||b&&b.nodeType!=Node.TEXT_NODE)&&tc(this);this.__shady_native_textContent=a}else tc(this),(0<a.length||this.nodeType===Node.ELEMENT_NODE)&&this.__shady_insertBefore(document.createTextNode(a));break;default:this.nodeValue=a}},insertBefore:function(a,b){if(this.ownerDocument!==pc&&a.ownerDocument!==pc)return this.__shady_native_insertBefore(a,
b),a;if(a===this)throw Error("Failed to execute 'appendChild' on 'Node': The new child element contains the parent.");if(b){var c=v(b);c=c&&c.parentNode;if(void 0!==c&&c!==this||void 0===c&&b.__shady_native_parentNode!==this)throw Error("Failed to execute 'insertBefore' on 'Node': The node before which the new node is to be inserted is not a child of this node.");}if(b===a)return a;var d=[],e=(c=xc(this))?c.host.localName:nc(this),f=a.__shady_parentNode;if(f){var g=nc(a);f.__shady_removeChild(a,!!c||
!xc(a))}f=!0;var h=(!qc||void 0===a.__noInsertionPoint)&&!mc(a,e),k=c&&!a.__noInsertionPoint&&(!qc||a.nodeType===Node.DOCUMENT_FRAGMENT_NODE);if(k||h)h&&(g=g||nc(a)),oc(a,function(a){k&&"slot"===a.localName&&d.push(a);if(h){var b=g;G()&&(b&&lc(a,b),(b=G())&&b.scopeNode(a,e))}});if("slot"===this.localName||d.length)d.length&&(c.c=c.c||[],c.a=c.a||[],c.b=c.b||{},c.c.push.apply(c.c,d instanceof Array?d:ja(ia(d)))),c&&Ac(c);y(this)&&(hc(a,this,b),c=v(this),La(this)?(Ac(c.root),f=!1):c.root&&(f=!1));f?
(c=z(this)?this.host:this,b?(b=vc(b),c.__shady_native_insertBefore(a,b)):c.__shady_native_appendChild(a)):a.ownerDocument!==this.ownerDocument&&this.ownerDocument.adoptNode(a);wc(this,a);return a},appendChild:function(a){return this.__shady_insertBefore(a)},removeChild:function(a,b){b=void 0===b?!1:b;if(this.ownerDocument!==pc)return this.__shady_native_removeChild(a);if(a.__shady_parentNode!==this)throw Error("The node to be removed is not a child of this node: "+a);var c=xc(a),d=c&&Bc(c,a),e=v(this);
if(y(this)&&(ic(a,this),La(this))){Ac(e.root);var f=!0}if(G()&&!b&&c){var g=nc(a);oc(a,function(a){lc(a,g)})}uc(a);c&&((b=this&&"slot"===this.localName)&&(f=!0),(d||b)&&Ac(c));f||(f=z(this)?this.host:this,(!e.root&&"slot"!==a.localName||f===a.__shady_native_parentNode)&&f.__shady_native_removeChild(a));wc(this,null,a);return a},replaceChild:function(a,b){this.__shady_insertBefore(a,b);this.__shady_removeChild(b);return a},cloneNode:function(a){if("template"==this.localName)return this.__shady_native_cloneNode(a);
var b=this.__shady_native_cloneNode(!1);if(a&&b.nodeType!==Node.ATTRIBUTE_NODE){a=this.__shady_childNodes;for(var c=0,d;c<a.length;c++)d=a[c].__shady_cloneNode(!0),b.__shady_appendChild(d)}return b},getRootNode:function(a){if(this&&this.nodeType){var b=u(this),c=b.K;void 0===c&&(z(this)?(c=this,b.K=c):(c=(c=this.__shady_parentNode)?c.__shady_getRootNode(a):this,document.documentElement.__shady_native_contains(this)&&(b.K=c)));return c}},contains:function(a){return Ua(this,a)}});function Dc(a,b,c){var d=[];Ec(a.__shady_childNodes,b,c,d);return d}function Ec(a,b,c,d){for(var e=0,f=a.length,g=void 0;e<f&&(g=a[e]);e++){var h;if(h=g.nodeType===Node.ELEMENT_NODE){h=g;var k=b,l=c,m=d,q=k(h);q&&m.push(h);l&&l(q)?h=q:(Ec(h.__shady_childNodes,k,l,m),h=void 0)}if(h)break}}
var Fc=B({get firstElementChild(){var a=v(this);if(a&&void 0!==a.firstChild){for(a=this.__shady_firstChild;a&&a.nodeType!==Node.ELEMENT_NODE;)a=a.__shady_nextSibling;return a}return this.__shady_native_firstElementChild},get lastElementChild(){var a=v(this);if(a&&void 0!==a.lastChild){for(a=this.__shady_lastChild;a&&a.nodeType!==Node.ELEMENT_NODE;)a=a.__shady_previousSibling;return a}return this.__shady_native_lastElementChild},get children(){return y(this)?Va(Array.prototype.filter.call(this.__shady_childNodes,
function(a){return a.nodeType===Node.ELEMENT_NODE})):this.__shady_native_children},get childElementCount(){var a=this.__shady_children;return a?a.length:0}}),Gc=B({querySelector:function(a){return Dc(this,function(b){return Oa.call(b,a)},function(a){return!!a})[0]||null},querySelectorAll:function(a,b){if(b){b=Array.prototype.slice.call(this.__shady_native_querySelectorAll(a));var c=this.__shady_getRootNode();return b.filter(function(a){return a.__shady_getRootNode()==c})}return Dc(this,function(b){return Oa.call(b,
a)})}}),Hc=w.oa?Object.assign({},Fc):Fc;Object.assign(Fc,Gc);var Ic=B({getElementById:function(a){return""===a?null:Dc(this,function(b){return b.id==a},function(a){return!!a})[0]||null}});var Jc=B({get activeElement(){var a=w.m?document.__shady_native_activeElement:document.activeElement;if(!a||!a.nodeType)return null;var b=!!z(this);if(!(this===document||b&&this.host!==a&&this.host.__shady_native_contains(a)))return null;for(b=xc(a);b&&b!==this;)a=b.host,b=xc(a);return this===document?b?null:a:b===this?a:null}});var Kc=document.implementation.createHTMLDocument("inert"),Lc=B({get innerHTML(){return y(this)?kb("template"===this.localName?this.content:this,function(a){return a.__shady_childNodes}):this.__shady_native_innerHTML},set innerHTML(a){if("template"===this.localName)this.__shady_native_innerHTML=a;else{tc(this);var b=this.localName||"div";b=this.namespaceURI&&this.namespaceURI!==Kc.namespaceURI?Kc.createElementNS(this.namespaceURI,b):Kc.createElement(b);for(w.m?b.__shady_native_innerHTML=a:b.innerHTML=
a;a=b.__shady_firstChild;)this.__shady_insertBefore(a)}}});var Mc=B({addEventListener:function(a,b,c){"object"!==typeof c&&(c={capture:!!c});c.$=this;this.host.__shady_addEventListener(a,b,c)},removeEventListener:function(a,b,c){"object"!==typeof c&&(c={capture:!!c});c.$=this;this.host.__shady_removeEventListener(a,b,c)}});function Nc(a,b){A(a,Mc,b);A(a,Jc,b);A(a,Lc,b);A(a,Fc,b);w.J&&!b?(A(a,Cc,b),A(a,Ic,b)):w.m||(A(a,Ab),A(a,zb))};var Oc={},Pc=w.deferConnectionCallbacks&&"loading"===document.readyState,Qc;function Rc(a){var b=[];do b.unshift(a);while(a=a.__shady_parentNode);return b}
function Sc(a,b,c){if(a!==Oc)throw new TypeError("Illegal constructor");this.za="ShadyRoot";this.host=b;this.mode=c&&c.mode;jc(b);a=u(b);a.root=this;a.pa="closed"!==this.mode?this:null;a=u(this);a.firstChild=a.lastChild=a.parentNode=a.nextSibling=a.previousSibling=null;a.childNodes=[];this.ba=this.B=!1;this.c=this.b=this.a=null;if(w.preferPerformance)for(;a=b.__shady_native_firstChild;)b.__shady_native_removeChild(a);else Ac(this)}function Ac(a){a.B||(a.B=!0,Ya(function(){return Tc(a)}))}
function Tc(a){var b;if(b=a.B){for(var c;a;)a:{a.B&&(c=a),b=a;a=b.host.__shady_getRootNode();if(z(a)&&(b=v(b.host))&&0<b.N)break a;a=void 0}b=c}(c=b)&&c._renderSelf()}
Sc.prototype._renderSelf=function(){var a=Pc;Pc=!0;this.B=!1;if(this.a){Uc(this);for(var b=0,c;b<this.a.length;b++){c=this.a[b];var d=v(c),e=d.assignedNodes;d.assignedNodes=[];d.D=[];if(d.ca=e)for(d=0;d<e.length;d++){var f=v(e[d]);f.P=f.assignedSlot;f.assignedSlot===c&&(f.assignedSlot=null)}}for(b=this.host.__shady_firstChild;b;b=b.__shady_nextSibling)Vc(this,b);for(b=0;b<this.a.length;b++){c=this.a[b];e=v(c);if(!e.assignedNodes.length)for(d=c.__shady_firstChild;d;d=d.__shady_nextSibling)Vc(this,
d,c);(d=(d=v(c.__shady_parentNode))&&d.root)&&(Ma(d)||d.B)&&d._renderSelf();Wc(this,e.D,e.assignedNodes);if(d=e.ca){for(f=0;f<d.length;f++)v(d[f]).P=null;e.ca=null;d.length>e.assignedNodes.length&&(e.T=!0)}e.T&&(e.T=!1,Xc(this,c))}c=this.a;b=[];for(e=0;e<c.length;e++)d=c[e].__shady_parentNode,(f=v(d))&&f.root||!(0>b.indexOf(d))||b.push(d);for(c=0;c<b.length;c++){f=b[c];e=f===this?this.host:f;d=[];f=f.__shady_childNodes;for(var g=0;g<f.length;g++){var h=f[g];if("slot"==h.localName){h=v(h).D;for(var k=
0;k<h.length;k++)d.push(h[k])}else d.push(h)}f=Array.prototype.slice.call(e.__shady_native_childNodes);g=ec(d,d.length,f,f.length);k=h=0;for(var l=void 0;h<g.length&&(l=g[h]);h++){for(var m=0,q=void 0;m<l.L.length&&(q=l.L[m]);m++)q.__shady_native_parentNode===e&&e.__shady_native_removeChild(q),f.splice(l.index+k,1);k-=l.R}k=0;for(l=void 0;k<g.length&&(l=g[k]);k++)for(h=f[l.index],m=l.index;m<l.index+l.R;m++)q=d[m],e.__shady_native_insertBefore(q,h),f.splice(m,0,q)}}if(!w.preferPerformance&&!this.ba)for(b=
this.host.__shady_childNodes,c=0,e=b.length;c<e;c++)d=b[c],f=v(d),d.__shady_native_parentNode!==this.host||"slot"!==d.localName&&f.assignedSlot||this.host.__shady_native_removeChild(d);this.ba=!0;Pc=a;Qc&&Qc()};function Vc(a,b,c){var d=u(b),e=d.P;d.P=null;c||(c=(a=a.b[b.__shady_slot||"__catchall"])&&a[0]);c?(u(c).assignedNodes.push(b),d.assignedSlot=c):d.assignedSlot=void 0;e!==d.assignedSlot&&d.assignedSlot&&(u(d.assignedSlot).T=!0)}
function Wc(a,b,c){for(var d=0,e=void 0;d<c.length&&(e=c[d]);d++)if("slot"==e.localName){var f=v(e).assignedNodes;f&&f.length&&Wc(a,b,f)}else b.push(c[d])}function Xc(a,b){b.__shady_native_dispatchEvent(new Event("slotchange"));b=v(b);b.assignedSlot&&Xc(a,b.assignedSlot)}
function Uc(a){if(a.c&&a.c.length){for(var b=a.c,c,d=0;d<b.length;d++){var e=b[d];jc(e);var f=e.__shady_parentNode;jc(f);f=v(f);f.N=(f.N||0)+1;f=Yc(e);a.b[f]?(c=c||{},c[f]=!0,a.b[f].push(e)):a.b[f]=[e];a.a.push(e)}if(c)for(var g in c)a.b[g]=Zc(a.b[g]);a.c=[]}}function Yc(a){var b=a.name||a.getAttribute("name")||"__catchall";return a.wa=b}
function Zc(a){return a.sort(function(a,c){a=Rc(a);for(var b=Rc(c),e=0;e<a.length;e++){c=a[e];var f=b[e];if(c!==f)return a=Array.from(c.__shady_parentNode.__shady_childNodes),a.indexOf(c)-a.indexOf(f)}})}
function Bc(a,b){if(a.a){Uc(a);var c=a.b,d;for(d in c)for(var e=c[d],f=0;f<e.length;f++){var g=e[f];if(Ua(b,g)){e.splice(f,1);var h=a.a.indexOf(g);0<=h&&(a.a.splice(h,1),(h=v(g.__shady_parentNode))&&h.N&&h.N--);f--;g=v(g);if(h=g.D)for(var k=0;k<h.length;k++){var l=h[k],m=l.__shady_native_parentNode;m&&m.__shady_native_removeChild(l)}g.D=[];g.assignedNodes=[];h=!0}}return h}}function Ma(a){Uc(a);return!(!a.a||!a.a.length)}
(function(a){a.__proto__=DocumentFragment.prototype;Nc(a,"__shady_");Nc(a);Object.defineProperties(a,{nodeType:{value:Node.DOCUMENT_FRAGMENT_NODE,configurable:!0},nodeName:{value:"#document-fragment",configurable:!0},nodeValue:{value:null,configurable:!0}});["localName","namespaceURI","prefix"].forEach(function(b){Object.defineProperty(a,b,{value:void 0,configurable:!0})});["ownerDocument","baseURI","isConnected"].forEach(function(b){Object.defineProperty(a,b,{get:function(){return this.host[b]},
configurable:!0})})})(Sc.prototype);
if(window.customElements&&w.ea&&!w.preferPerformance){var $c=new Map;Qc=function(){var a=[];$c.forEach(function(b,c){a.push([c,b])});$c.clear();for(var b=0;b<a.length;b++){var c=a[b][0];a[b][1]?c.ua():c.va()}};Pc&&document.addEventListener("readystatechange",function(){Pc=!1;Qc()},{once:!0});var ad=function(a,b,c){var d=0,e="__isConnected"+d++;if(b||c)a.prototype.connectedCallback=a.prototype.ua=function(){Pc?$c.set(this,!0):this[e]||(this[e]=!0,b&&b.call(this))},a.prototype.disconnectedCallback=
a.prototype.va=function(){Pc?this.isConnected||$c.set(this,!1):this[e]&&(this[e]=!1,c&&c.call(this))};return a},bd=window.customElements.define;Object.defineProperty(window.CustomElementRegistry.prototype,"define",{value:function(a,b){var c=b.prototype.connectedCallback,d=b.prototype.disconnectedCallback;bd.call(window.customElements,a,ad(b,c,d));b.prototype.connectedCallback=c;b.prototype.disconnectedCallback=d}})}function xc(a){a=a.__shady_getRootNode();if(z(a))return a};function cd(a){this.node=a}n=cd.prototype;n.addEventListener=function(a,b,c){return this.node.__shady_addEventListener(a,b,c)};n.removeEventListener=function(a,b,c){return this.node.__shady_removeEventListener(a,b,c)};n.appendChild=function(a){return this.node.__shady_appendChild(a)};n.insertBefore=function(a,b){return this.node.__shady_insertBefore(a,b)};n.removeChild=function(a){return this.node.__shady_removeChild(a)};n.replaceChild=function(a,b){return this.node.__shady_replaceChild(a,b)};
n.cloneNode=function(a){return this.node.__shady_cloneNode(a)};n.getRootNode=function(a){return this.node.__shady_getRootNode(a)};n.contains=function(a){return this.node.__shady_contains(a)};n.dispatchEvent=function(a){return this.node.__shady_dispatchEvent(a)};n.setAttribute=function(a,b){this.node.__shady_setAttribute(a,b)};n.getAttribute=function(a){return this.node.__shady_native_getAttribute(a)};n.hasAttribute=function(a){return this.node.__shady_native_hasAttribute(a)};n.removeAttribute=function(a){this.node.__shady_removeAttribute(a)};
n.attachShadow=function(a){return this.node.__shady_attachShadow(a)};n.focus=function(){this.node.__shady_native_focus()};n.blur=function(){this.node.__shady_blur()};n.importNode=function(a,b){if(this.node.nodeType===Node.DOCUMENT_NODE)return this.node.__shady_importNode(a,b)};n.getElementById=function(a){if(this.node.nodeType===Node.DOCUMENT_NODE)return this.node.__shady_getElementById(a)};n.querySelector=function(a){return this.node.__shady_querySelector(a)};
n.querySelectorAll=function(a,b){return this.node.__shady_querySelectorAll(a,b)};n.assignedNodes=function(a){if("slot"===this.node.localName)return this.node.__shady_assignedNodes(a)};
p.Object.defineProperties(cd.prototype,{activeElement:{configurable:!0,enumerable:!0,get:function(){if(z(this.node)||this.node.nodeType===Node.DOCUMENT_NODE)return this.node.__shady_activeElement}},_activeElement:{configurable:!0,enumerable:!0,get:function(){return this.activeElement}},host:{configurable:!0,enumerable:!0,get:function(){if(z(this.node))return this.node.host}},parentNode:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_parentNode}},firstChild:{configurable:!0,
enumerable:!0,get:function(){return this.node.__shady_firstChild}},lastChild:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_lastChild}},nextSibling:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_nextSibling}},previousSibling:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_previousSibling}},childNodes:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_childNodes}},parentElement:{configurable:!0,enumerable:!0,
get:function(){return this.node.__shady_parentElement}},firstElementChild:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_firstElementChild}},lastElementChild:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_lastElementChild}},nextElementSibling:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_nextElementSibling}},previousElementSibling:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_previousElementSibling}},
children:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_children}},childElementCount:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_childElementCount}},shadowRoot:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_shadowRoot}},assignedSlot:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_assignedSlot}},isConnected:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_isConnected}},innerHTML:{configurable:!0,
enumerable:!0,get:function(){return this.node.__shady_innerHTML},set:function(a){this.node.__shady_innerHTML=a}},textContent:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_textContent},set:function(a){this.node.__shady_textContent=a}},slot:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_slot},set:function(a){this.node.__shady_slot=a}}});
cc.forEach(function(a){Object.defineProperty(cd.prototype,a,{get:function(){return this.node["__shady_"+a]},set:function(b){this.node["__shady_"+a]=b},configurable:!0})});var dd=new WeakMap;function ed(a){if(z(a)||a instanceof cd)return a;var b=dd.get(a);b||(b=new cd(a),dd.set(a,b));return b};var fd=B({dispatchEvent:function(a){Za();return this.__shady_native_dispatchEvent(a)},addEventListener:Ub,removeEventListener:Wb});var gd=B({get assignedSlot(){var a=this.__shady_parentNode;(a=a&&a.__shady_shadowRoot)&&Tc(a);return(a=v(this))&&a.assignedSlot||null}});var hd=window.document;function id(a,b){if("slot"===b)a=a.__shady_parentNode,La(a)&&Ac(v(a).root);else if("slot"===a.localName&&"name"===b&&(b=xc(a))){if(b.a){Uc(b);var c=a.wa,d=Yc(a);if(d!==c){c=b.b[c];var e=c.indexOf(a);0<=e&&c.splice(e,1);c=b.b[d]||(b.b[d]=[]);c.push(a);1<c.length&&(b.b[d]=Zc(c))}}Ac(b)}}
var jd=B({get previousElementSibling(){var a=v(this);if(a&&void 0!==a.previousSibling){for(a=this.__shady_previousSibling;a&&a.nodeType!==Node.ELEMENT_NODE;)a=a.__shady_previousSibling;return a}return this.__shady_native_previousElementSibling},get nextElementSibling(){var a=v(this);if(a&&void 0!==a.nextSibling){for(a=this.__shady_nextSibling;a&&a.nodeType!==Node.ELEMENT_NODE;)a=a.__shady_nextSibling;return a}return this.__shady_native_nextElementSibling},get slot(){return this.getAttribute("slot")},
set slot(a){this.__shady_setAttribute("slot",a)},get shadowRoot(){var a=v(this);return a&&a.pa||null},get className(){return this.getAttribute("class")||""},set className(a){this.__shady_setAttribute("class",a)},setAttribute:function(a,b){if(this.ownerDocument!==hd)this.__shady_native_setAttribute(a,b);else{var c;(c=G())&&"class"===a?(c.setElementClass(this,b),c=!0):c=!1;c||(this.__shady_native_setAttribute(a,b),id(this,a))}},removeAttribute:function(a){this.__shady_native_removeAttribute(a);id(this,
a)},attachShadow:function(a){if(!this)throw Error("Must provide a host.");if(!a)throw Error("Not enough arguments.");return new Sc(Oc,this,a)}});var kd=B({blur:function(){var a=v(this);(a=(a=a&&a.root)&&a.activeElement)?a.__shady_blur():this.__shady_native_blur()}});cc.forEach(function(a){kd[a]={set:function(b){var c=u(this),d=a.substring(2);c.O[a]&&this.removeEventListener(d,c.O[a]);this.__shady_addEventListener(d,b);c.O[a]=b},get:function(){var b=v(this);return b&&b.O[a]},configurable:!0}});var ld=B({assignedNodes:function(a){if("slot"===this.localName){var b=this.__shady_getRootNode();b&&z(b)&&Tc(b);return(b=v(this))?(a&&a.flatten?b.D:b.assignedNodes)||[]:[]}}});var md=window.document,nd=B({importNode:function(a,b){if(a.ownerDocument!==md||"template"===a.localName)return this.__shady_native_importNode(a,b);var c=this.__shady_native_importNode(a,!1);if(b){a=a.__shady_childNodes;b=0;for(var d;b<a.length;b++)d=this.__shady_importNode(a[b],!0),c.__shady_appendChild(d)}return c}});var od=B({addEventListener:Ub.bind(window),removeEventListener:Wb.bind(window)});var pd={};Object.getOwnPropertyDescriptor(HTMLElement.prototype,"parentElement")&&(pd.parentElement=Cc.parentElement);Object.getOwnPropertyDescriptor(HTMLElement.prototype,"contains")&&(pd.contains=Cc.contains);Object.getOwnPropertyDescriptor(HTMLElement.prototype,"children")&&(pd.children=Fc.children);Object.getOwnPropertyDescriptor(HTMLElement.prototype,"innerHTML")&&(pd.innerHTML=Lc.innerHTML);Object.getOwnPropertyDescriptor(HTMLElement.prototype,"className")&&(pd.className=jd.className);
var qd={EventTarget:[fd],Node:[Cc,window.EventTarget?null:fd],Text:[gd],Element:[jd,Fc,gd,!w.m||"innerHTML"in Element.prototype?Lc:null,window.HTMLSlotElement?null:ld],HTMLElement:[kd,pd],HTMLSlotElement:[ld],DocumentFragment:[Hc,Ic],Document:[nd,Hc,Ic,Jc],Window:[od]},rd=w.m?null:["innerHTML","textContent"];function sd(a){var b=a?null:rd,c={},d;for(d in qd)c.W=window[d]&&window[d].prototype,qd[d].forEach(function(c){return function(d){return c.W&&d&&A(c.W,d,a,b)}}(c)),c={W:c.W}};if(w.ea){var ShadyDOM={inUse:w.ea,patch:function(a){Fb(a);Eb(a);return a},isShadyRoot:z,enqueue:Ya,flush:Za,flushInitial:function(a){!a.ba&&a.B&&Tc(a)},settings:w,filterMutations:db,observeChildren:bb,unobserveChildren:cb,deferConnectionCallbacks:w.deferConnectionCallbacks,preferPerformance:w.preferPerformance,handlesDynamicScoping:!0,wrap:w.J?ed:function(a){return a},Wrapper:cd,composedPath:Mb,noPatch:w.J,nativeMethods:qb,nativeTree:rb};window.ShadyDOM=ShadyDOM;yb();sd("__shady_");Object.defineProperty(document,
"_activeElement",Jc.activeElement);A(Window.prototype,od,"__shady_");w.J||(sd(),bc());Xb();window.Event=Zb;window.CustomEvent=$b;window.MouseEvent=ac;window.ShadowRoot=Sc};var td=new Set("annotation-xml color-profile font-face font-face-src font-face-uri font-face-format font-face-name missing-glyph".split(" "));function ud(a){var b=td.has(a);a=/^[a-z][.0-9_a-z]*-[\-.0-9_a-z]*$/.test(a);return!b&&a}function H(a){var b=a.isConnected;if(void 0!==b)return b;for(;a&&!(a.__CE_isImportDocument||a instanceof Document);)a=a.parentNode||(window.ShadowRoot&&a instanceof ShadowRoot?a.host:void 0);return!(!a||!(a.__CE_isImportDocument||a instanceof Document))}
function vd(a,b){for(;b&&b!==a&&!b.nextSibling;)b=b.parentNode;return b&&b!==a?b.nextSibling:null}
function wd(a,b,c){c=void 0===c?new Set:c;for(var d=a;d;){if(d.nodeType===Node.ELEMENT_NODE){var e=d;b(e);var f=e.localName;if("link"===f&&"import"===e.getAttribute("rel")){d=e.import;if(d instanceof Node&&!c.has(d))for(c.add(d),d=d.firstChild;d;d=d.nextSibling)wd(d,b,c);d=vd(a,e);continue}else if("template"===f){d=vd(a,e);continue}if(e=e.__CE_shadowRoot)for(e=e.firstChild;e;e=e.nextSibling)wd(e,b,c)}d=d.firstChild?d.firstChild:vd(a,d)}}function I(a,b,c){a[b]=c};function xd(){this.a=new Map;this.g=new Map;this.f=[];this.c=!1}function yd(a,b,c){a.a.set(b,c);a.g.set(c.constructorFunction,c)}function zd(a,b){a.c=!0;a.f.push(b)}function Ad(a,b){a.c&&wd(b,function(b){return a.b(b)})}xd.prototype.b=function(a){if(this.c&&!a.__CE_patched){a.__CE_patched=!0;for(var b=0;b<this.f.length;b++)this.f[b](a)}};function J(a,b){var c=[];wd(b,function(a){return c.push(a)});for(b=0;b<c.length;b++){var d=c[b];1===d.__CE_state?a.connectedCallback(d):Bd(a,d)}}
function K(a,b){var c=[];wd(b,function(a){return c.push(a)});for(b=0;b<c.length;b++){var d=c[b];1===d.__CE_state&&a.disconnectedCallback(d)}}
function L(a,b,c){c=void 0===c?{}:c;var d=c.Xa||new Set,e=c.Y||function(b){return Bd(a,b)},f=[];wd(b,function(b){if("link"===b.localName&&"import"===b.getAttribute("rel")){var c=b.import;c instanceof Node&&(c.__CE_isImportDocument=!0,c.__CE_hasRegistry=!0);c&&"complete"===c.readyState?c.__CE_documentLoadHandled=!0:b.addEventListener("load",function(){var c=b.import;if(!c.__CE_documentLoadHandled){c.__CE_documentLoadHandled=!0;var f=new Set(d);f.delete(c);L(a,c,{Xa:f,Y:e})}})}else f.push(b)},d);if(a.c)for(b=
0;b<f.length;b++)a.b(f[b]);for(b=0;b<f.length;b++)e(f[b])}
function Bd(a,b){if(void 0===b.__CE_state){var c=b.ownerDocument;if(c.defaultView||c.__CE_isImportDocument&&c.__CE_hasRegistry)if(c=a.a.get(b.localName)){c.constructionStack.push(b);var d=c.constructorFunction;try{try{if(new d!==b)throw Error("The custom element constructor did not produce the element being upgraded.");}finally{c.constructionStack.pop()}}catch(g){throw b.__CE_state=2,g;}b.__CE_state=1;b.__CE_definition=c;if(c.attributeChangedCallback)for(c=c.observedAttributes,d=0;d<c.length;d++){var e=
c[d],f=b.getAttribute(e);null!==f&&a.attributeChangedCallback(b,e,null,f,null)}H(b)&&a.connectedCallback(b)}}}xd.prototype.connectedCallback=function(a){var b=a.__CE_definition;b.connectedCallback&&b.connectedCallback.call(a)};xd.prototype.disconnectedCallback=function(a){var b=a.__CE_definition;b.disconnectedCallback&&b.disconnectedCallback.call(a)};
xd.prototype.attributeChangedCallback=function(a,b,c,d,e){var f=a.__CE_definition;f.attributeChangedCallback&&-1<f.observedAttributes.indexOf(b)&&f.attributeChangedCallback.call(a,b,c,d,e)};function Cd(a){var b=document;this.b=a;this.a=b;this.F=void 0;L(this.b,this.a);"loading"===this.a.readyState&&(this.F=new MutationObserver(this.c.bind(this)),this.F.observe(this.a,{childList:!0,subtree:!0}))}function Dd(a){a.F&&a.F.disconnect()}Cd.prototype.c=function(a){var b=this.a.readyState;"interactive"!==b&&"complete"!==b||Dd(this);for(b=0;b<a.length;b++)for(var c=a[b].addedNodes,d=0;d<c.length;d++)L(this.b,c[d])};function Ed(){var a=this;this.a=this.h=void 0;this.b=new Promise(function(b){a.a=b;a.h&&b(a.h)})}Ed.prototype.resolve=function(a){if(this.h)throw Error("Already resolved.");this.h=a;this.a&&this.a(a)};function N(a){this.c=!1;this.a=a;this.l=new Map;this.f=function(a){return a()};this.b=!1;this.g=[];this.da=new Cd(a)}n=N.prototype;
n.sa=function(a,b){var c=this;if(!(b instanceof Function))throw new TypeError("Custom element constructors must be functions.");if(!ud(a))throw new SyntaxError("The element name '"+a+"' is not valid.");if(this.a.a.get(a))throw Error("A custom element with name '"+a+"' has already been defined.");if(this.c)throw Error("A custom element is already being defined.");this.c=!0;try{var d=function(a){var b=e[a];if(void 0!==b&&!(b instanceof Function))throw Error("The '"+a+"' callback must be a function.");
return b},e=b.prototype;if(!(e instanceof Object))throw new TypeError("The custom element constructor's prototype is not an object.");var f=d("connectedCallback");var g=d("disconnectedCallback");var h=d("adoptedCallback");var k=d("attributeChangedCallback");var l=b.observedAttributes||[]}catch(m){return}finally{this.c=!1}b={localName:a,constructorFunction:b,connectedCallback:f,disconnectedCallback:g,adoptedCallback:h,attributeChangedCallback:k,observedAttributes:l,constructionStack:[]};yd(this.a,
a,b);this.g.push(b);this.b||(this.b=!0,this.f(function(){return Fd(c)}))};n.Y=function(a){L(this.a,a)};
function Fd(a){if(!1!==a.b){a.b=!1;for(var b=a.g,c=[],d=new Map,e=0;e<b.length;e++)d.set(b[e].localName,[]);L(a.a,document,{Y:function(b){if(void 0===b.__CE_state){var e=b.localName,f=d.get(e);f?f.push(b):a.a.a.get(e)&&c.push(b)}}});for(e=0;e<c.length;e++)Bd(a.a,c[e]);for(;0<b.length;){var f=b.shift();e=f.localName;f=d.get(f.localName);for(var g=0;g<f.length;g++)Bd(a.a,f[g]);(e=a.l.get(e))&&e.resolve(void 0)}}}n.get=function(a){if(a=this.a.a.get(a))return a.constructorFunction};
n.ta=function(a){if(!ud(a))return Promise.reject(new SyntaxError("'"+a+"' is not a valid custom element name."));var b=this.l.get(a);if(b)return b.b;b=new Ed;this.l.set(a,b);this.a.a.get(a)&&!this.g.some(function(b){return b.localName===a})&&b.resolve(void 0);return b.b};n.Pa=function(a){Dd(this.da);var b=this.f;this.f=function(c){return a(function(){return b(c)})}};window.CustomElementRegistry=N;N.prototype.define=N.prototype.sa;N.prototype.upgrade=N.prototype.Y;N.prototype.get=N.prototype.get;
N.prototype.whenDefined=N.prototype.ta;N.prototype.polyfillWrapFlushCallback=N.prototype.Pa;var Gd=window.Document.prototype.createElement,Hd=window.Document.prototype.createElementNS,Id=window.Document.prototype.importNode,Jd=window.Document.prototype.prepend,Kd=window.Document.prototype.append,Ld=window.DocumentFragment.prototype.prepend,Md=window.DocumentFragment.prototype.append,Nd=window.Node.prototype.cloneNode,Od=window.Node.prototype.appendChild,Pd=window.Node.prototype.insertBefore,Qd=window.Node.prototype.removeChild,Rd=window.Node.prototype.replaceChild,Sd=Object.getOwnPropertyDescriptor(window.Node.prototype,
"textContent"),Td=window.Element.prototype.attachShadow,Ud=Object.getOwnPropertyDescriptor(window.Element.prototype,"innerHTML"),Vd=window.Element.prototype.getAttribute,Wd=window.Element.prototype.setAttribute,Xd=window.Element.prototype.removeAttribute,Yd=window.Element.prototype.getAttributeNS,Zd=window.Element.prototype.setAttributeNS,$d=window.Element.prototype.removeAttributeNS,ae=window.Element.prototype.insertAdjacentElement,be=window.Element.prototype.insertAdjacentHTML,ce=window.Element.prototype.prepend,
de=window.Element.prototype.append,ee=window.Element.prototype.before,fe=window.Element.prototype.after,ge=window.Element.prototype.replaceWith,he=window.Element.prototype.remove,ie=window.HTMLElement,je=Object.getOwnPropertyDescriptor(window.HTMLElement.prototype,"innerHTML"),ke=window.HTMLElement.prototype.insertAdjacentElement,le=window.HTMLElement.prototype.insertAdjacentHTML;var me=new function(){};function ne(){var a=oe;window.HTMLElement=function(){function b(){var b=this.constructor,d=a.g.get(b);if(!d)throw Error("The custom element being constructed was not registered with `customElements`.");var e=d.constructionStack;if(0===e.length)return e=Gd.call(document,d.localName),Object.setPrototypeOf(e,b.prototype),e.__CE_state=1,e.__CE_definition=d,a.b(e),e;d=e.length-1;var f=e[d];if(f===me)throw Error("The HTMLElement constructor was either called reentrantly for this constructor or called multiple times.");
e[d]=me;Object.setPrototypeOf(f,b.prototype);a.b(f);return f}b.prototype=ie.prototype;Object.defineProperty(b.prototype,"constructor",{writable:!0,configurable:!0,enumerable:!1,value:b});return b}()};function pe(a,b,c){function d(b){return function(c){for(var d=[],e=0;e<arguments.length;++e)d[e]=arguments[e];e=[];for(var f=[],l=0;l<d.length;l++){var m=d[l];m instanceof Element&&H(m)&&f.push(m);if(m instanceof DocumentFragment)for(m=m.firstChild;m;m=m.nextSibling)e.push(m);else e.push(m)}b.apply(this,d);for(d=0;d<f.length;d++)K(a,f[d]);if(H(this))for(d=0;d<e.length;d++)f=e[d],f instanceof Element&&J(a,f)}}void 0!==c.V&&(b.prepend=d(c.V));void 0!==c.append&&(b.append=d(c.append))};function qe(){var a=oe;I(Document.prototype,"createElement",function(b){if(this.__CE_hasRegistry){var c=a.a.get(b);if(c)return new c.constructorFunction}b=Gd.call(this,b);a.b(b);return b});I(Document.prototype,"importNode",function(b,c){b=Id.call(this,b,!!c);this.__CE_hasRegistry?L(a,b):Ad(a,b);return b});I(Document.prototype,"createElementNS",function(b,c){if(this.__CE_hasRegistry&&(null===b||"http://www.w3.org/1999/xhtml"===b)){var d=a.a.get(c);if(d)return new d.constructorFunction}b=Hd.call(this,
b,c);a.b(b);return b});pe(a,Document.prototype,{V:Jd,append:Kd})};function re(){function a(a,d){Object.defineProperty(a,"textContent",{enumerable:d.enumerable,configurable:!0,get:d.get,set:function(a){if(this.nodeType===Node.TEXT_NODE)d.set.call(this,a);else{var c=void 0;if(this.firstChild){var e=this.childNodes,h=e.length;if(0<h&&H(this)){c=Array(h);for(var k=0;k<h;k++)c[k]=e[k]}}d.set.call(this,a);if(c)for(a=0;a<c.length;a++)K(b,c[a])}}})}var b=oe;I(Node.prototype,"insertBefore",function(a,d){if(a instanceof DocumentFragment){var c=Array.prototype.slice.apply(a.childNodes);
a=Pd.call(this,a,d);if(H(this))for(d=0;d<c.length;d++)J(b,c[d]);return a}c=H(a);d=Pd.call(this,a,d);c&&K(b,a);H(this)&&J(b,a);return d});I(Node.prototype,"appendChild",function(a){if(a instanceof DocumentFragment){var c=Array.prototype.slice.apply(a.childNodes);a=Od.call(this,a);if(H(this))for(var e=0;e<c.length;e++)J(b,c[e]);return a}c=H(a);e=Od.call(this,a);c&&K(b,a);H(this)&&J(b,a);return e});I(Node.prototype,"cloneNode",function(a){a=Nd.call(this,!!a);this.ownerDocument.__CE_hasRegistry?L(b,a):
Ad(b,a);return a});I(Node.prototype,"removeChild",function(a){var c=H(a),e=Qd.call(this,a);c&&K(b,a);return e});I(Node.prototype,"replaceChild",function(a,d){if(a instanceof DocumentFragment){var c=Array.prototype.slice.apply(a.childNodes);a=Rd.call(this,a,d);if(H(this))for(K(b,d),d=0;d<c.length;d++)J(b,c[d]);return a}c=H(a);var f=Rd.call(this,a,d),g=H(this);g&&K(b,d);c&&K(b,a);g&&J(b,a);return f});Sd&&Sd.get?a(Node.prototype,Sd):zd(b,function(b){a(b,{enumerable:!0,configurable:!0,get:function(){for(var a=
[],b=0;b<this.childNodes.length;b++)a.push(this.childNodes[b].textContent);return a.join("")},set:function(a){for(;this.firstChild;)Qd.call(this,this.firstChild);Od.call(this,document.createTextNode(a))}})})};function se(a){function b(b){return function(c){for(var d=[],e=0;e<arguments.length;++e)d[e]=arguments[e];e=[];for(var h=[],k=0;k<d.length;k++){var l=d[k];l instanceof Element&&H(l)&&h.push(l);if(l instanceof DocumentFragment)for(l=l.firstChild;l;l=l.nextSibling)e.push(l);else e.push(l)}b.apply(this,d);for(d=0;d<h.length;d++)K(a,h[d]);if(H(this))for(d=0;d<e.length;d++)h=e[d],h instanceof Element&&J(a,h)}}var c=Element.prototype;void 0!==ee&&(c.before=b(ee));void 0!==ee&&(c.after=b(fe));void 0!==ge&&
I(c,"replaceWith",function(b){for(var c=[],d=0;d<arguments.length;++d)c[d]=arguments[d];d=[];for(var g=[],h=0;h<c.length;h++){var k=c[h];k instanceof Element&&H(k)&&g.push(k);if(k instanceof DocumentFragment)for(k=k.firstChild;k;k=k.nextSibling)d.push(k);else d.push(k)}h=H(this);ge.apply(this,c);for(c=0;c<g.length;c++)K(a,g[c]);if(h)for(K(a,this),c=0;c<d.length;c++)g=d[c],g instanceof Element&&J(a,g)});void 0!==he&&I(c,"remove",function(){var b=H(this);he.call(this);b&&K(a,this)})};function te(){function a(a,b){Object.defineProperty(a,"innerHTML",{enumerable:b.enumerable,configurable:!0,get:b.get,set:function(a){var c=this,e=void 0;H(this)&&(e=[],wd(this,function(a){a!==c&&e.push(a)}));b.set.call(this,a);if(e)for(var f=0;f<e.length;f++){var g=e[f];1===g.__CE_state&&d.disconnectedCallback(g)}this.ownerDocument.__CE_hasRegistry?L(d,this):Ad(d,this);return a}})}function b(a,b){I(a,"insertAdjacentElement",function(a,c){var e=H(c);a=b.call(this,a,c);e&&K(d,c);H(a)&&J(d,c);return a})}
function c(a,b){function c(a,b){for(var c=[];a!==b;a=a.nextSibling)c.push(a);for(b=0;b<c.length;b++)L(d,c[b])}I(a,"insertAdjacentHTML",function(a,d){a=a.toLowerCase();if("beforebegin"===a){var e=this.previousSibling;b.call(this,a,d);c(e||this.parentNode.firstChild,this)}else if("afterbegin"===a)e=this.firstChild,b.call(this,a,d),c(this.firstChild,e);else if("beforeend"===a)e=this.lastChild,b.call(this,a,d),c(e||this.firstChild,null);else if("afterend"===a)e=this.nextSibling,b.call(this,a,d),c(this.nextSibling,
e);else throw new SyntaxError("The value provided ("+String(a)+") is not one of 'beforebegin', 'afterbegin', 'beforeend', or 'afterend'.");})}var d=oe;Td&&I(Element.prototype,"attachShadow",function(a){return this.__CE_shadowRoot=a=Td.call(this,a)});Ud&&Ud.get?a(Element.prototype,Ud):je&&je.get?a(HTMLElement.prototype,je):zd(d,function(b){a(b,{enumerable:!0,configurable:!0,get:function(){return Nd.call(this,!0).innerHTML},set:function(a){var b="template"===this.localName,c=b?this.content:this,d=Hd.call(document,
this.namespaceURI,this.localName);for(d.innerHTML=a;0<c.childNodes.length;)Qd.call(c,c.childNodes[0]);for(a=b?d.content:d;0<a.childNodes.length;)Od.call(c,a.childNodes[0])}})});I(Element.prototype,"setAttribute",function(a,b){if(1!==this.__CE_state)return Wd.call(this,a,b);var c=Vd.call(this,a);Wd.call(this,a,b);b=Vd.call(this,a);d.attributeChangedCallback(this,a,c,b,null)});I(Element.prototype,"setAttributeNS",function(a,b,c){if(1!==this.__CE_state)return Zd.call(this,a,b,c);var e=Yd.call(this,a,
b);Zd.call(this,a,b,c);c=Yd.call(this,a,b);d.attributeChangedCallback(this,b,e,c,a)});I(Element.prototype,"removeAttribute",function(a){if(1!==this.__CE_state)return Xd.call(this,a);var b=Vd.call(this,a);Xd.call(this,a);null!==b&&d.attributeChangedCallback(this,a,b,null,null)});I(Element.prototype,"removeAttributeNS",function(a,b){if(1!==this.__CE_state)return $d.call(this,a,b);var c=Yd.call(this,a,b);$d.call(this,a,b);var e=Yd.call(this,a,b);c!==e&&d.attributeChangedCallback(this,b,c,e,a)});ke?b(HTMLElement.prototype,
ke):ae?b(Element.prototype,ae):console.warn("Custom Elements: `Element#insertAdjacentElement` was not patched.");le?c(HTMLElement.prototype,le):be?c(Element.prototype,be):console.warn("Custom Elements: `Element#insertAdjacentHTML` was not patched.");pe(d,Element.prototype,{V:ce,append:de});se(d)};var ue=window.customElements;if(!ue||ue.forcePolyfill||"function"!=typeof ue.define||"function"!=typeof ue.get){var oe=new xd;ne();qe();pe(oe,DocumentFragment.prototype,{V:Ld,append:Md});re();te();document.__CE_hasRegistry=!0;var customElements=new N(oe);Object.defineProperty(window,"customElements",{configurable:!0,enumerable:!0,value:customElements})};function ve(){this.end=this.start=0;this.rules=this.parent=this.previous=null;this.cssText=this.parsedCssText="";this.atRule=!1;this.type=0;this.parsedSelector=this.selector=this.keyframesName=""}
function we(a){a=a.replace(xe,"").replace(ye,"");var b=ze,c=a,d=new ve;d.start=0;d.end=c.length;for(var e=d,f=0,g=c.length;f<g;f++)if("{"===c[f]){e.rules||(e.rules=[]);var h=e,k=h.rules[h.rules.length-1]||null;e=new ve;e.start=f+1;e.parent=h;e.previous=k;h.rules.push(e)}else"}"===c[f]&&(e.end=f+1,e=e.parent||d);return b(d,a)}
function ze(a,b){var c=b.substring(a.start,a.end-1);a.parsedCssText=a.cssText=c.trim();a.parent&&(c=b.substring(a.previous?a.previous.end:a.parent.start,a.start-1),c=Ae(c),c=c.replace(Be," "),c=c.substring(c.lastIndexOf(";")+1),c=a.parsedSelector=a.selector=c.trim(),a.atRule=0===c.indexOf("@"),a.atRule?0===c.indexOf("@media")?a.type=Ce:c.match(De)&&(a.type=Ee,a.keyframesName=a.selector.split(Be).pop()):a.type=0===c.indexOf("--")?Fe:Ge);if(c=a.rules)for(var d=0,e=c.length,f=void 0;d<e&&(f=c[d]);d++)ze(f,
b);return a}function Ae(a){return a.replace(/\\([0-9a-f]{1,6})\s/gi,function(a,c){a=c;for(c=6-a.length;c--;)a="0"+a;return"\\"+a})}
function He(a,b,c){c=void 0===c?"":c;var d="";if(a.cssText||a.rules){var e=a.rules,f;if(f=e)f=e[0],f=!(f&&f.selector&&0===f.selector.indexOf("--"));if(f){f=0;for(var g=e.length,h=void 0;f<g&&(h=e[f]);f++)d=He(h,b,d)}else b?b=a.cssText:(b=a.cssText,b=b.replace(Ie,"").replace(Je,""),b=b.replace(Ke,"").replace(Le,"")),(d=b.trim())&&(d="  "+d+"\n")}d&&(a.selector&&(c+=a.selector+" {\n"),c+=d,a.selector&&(c+="}\n\n"));return c}
var Ge=1,Ee=7,Ce=4,Fe=1E3,xe=/\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,ye=/@import[^;]*;/gim,Ie=/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\n]|$)/gim,Je=/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\n]|$)?/gim,Ke=/@apply\s*\(?[^);]*\)?\s*(?:[;\n]|$)?/gim,Le=/[^;:]*?:[^;]*?var\([^;]*\)(?:[;\n]|$)?/gim,De=/^@[^\s]*keyframes/,Be=/\s+/g;var O=!(window.ShadyDOM&&window.ShadyDOM.inUse),Me;function Ne(a){Me=a&&a.shimcssproperties?!1:O||!(navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/)||!window.CSS||!CSS.supports||!CSS.supports("box-shadow","0 0 0 var(--foo)"))}var Oe;window.ShadyCSS&&void 0!==window.ShadyCSS.cssBuild&&(Oe=window.ShadyCSS.cssBuild);var Pe=!(!window.ShadyCSS||!window.ShadyCSS.disableRuntime);
window.ShadyCSS&&void 0!==window.ShadyCSS.nativeCss?Me=window.ShadyCSS.nativeCss:window.ShadyCSS?(Ne(window.ShadyCSS),window.ShadyCSS=void 0):Ne(window.WebComponents&&window.WebComponents.flags);var Q=Me,Qe=Oe;var Re=/(?:^|[;\s{]\s*)(--[\w-]*?)\s*:\s*(?:((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};{])+)|\{([^}]*)\}(?:(?=[;\s}])|$))/gi,Se=/(?:^|\W+)@apply\s*\(?([^);\n]*)\)?/gi,Te=/(--[\w-]+)\s*([:,;)]|$)/gi,Ue=/(animation\s*:)|(animation-name\s*:)/,$e=/@media\s(.*)/,af=/\{[^}]*\}/g;var bf=new Set;function cf(a,b){if(!a)return"";"string"===typeof a&&(a=we(a));b&&df(a,b);return He(a,Q)}function ef(a){!a.__cssRules&&a.textContent&&(a.__cssRules=we(a.textContent));return a.__cssRules||null}function ff(a){return!!a.parent&&a.parent.type===Ee}function df(a,b,c,d){if(a){var e=!1,f=a.type;if(d&&f===Ce){var g=a.selector.match($e);g&&(window.matchMedia(g[1]).matches||(e=!0))}f===Ge?b(a):c&&f===Ee?c(a):f===Fe&&(e=!0);if((a=a.rules)&&!e)for(e=0,f=a.length,g=void 0;e<f&&(g=a[e]);e++)df(g,b,c,d)}}
function gf(a,b,c,d){var e=document.createElement("style");b&&e.setAttribute("scope",b);e.textContent=a;hf(e,c,d);return e}var jf=null;function kf(a){a=document.createComment(" Shady DOM styles for "+a+" ");var b=document.head;b.insertBefore(a,(jf?jf.nextSibling:null)||b.firstChild);return jf=a}function hf(a,b,c){b=b||document.head;b.insertBefore(a,c&&c.nextSibling||b.firstChild);jf?a.compareDocumentPosition(jf)===Node.DOCUMENT_POSITION_PRECEDING&&(jf=a):jf=a}
function lf(a,b){for(var c=0,d=a.length;b<d;b++)if("("===a[b])c++;else if(")"===a[b]&&0===--c)return b;return-1}function mf(a,b){var c=a.indexOf("var(");if(-1===c)return b(a,"","","");var d=lf(a,c+3),e=a.substring(c+4,d);c=a.substring(0,c);a=mf(a.substring(d+1),b);d=e.indexOf(",");return-1===d?b(c,e.trim(),"",a):b(c,e.substring(0,d).trim(),e.substring(d+1).trim(),a)}function nf(a,b){O?a.setAttribute("class",b):window.ShadyDOM.nativeMethods.setAttribute.call(a,"class",b)}
var of=window.ShadyDOM&&window.ShadyDOM.wrap||function(a){return a};function pf(a){var b=a.localName,c="";b?-1<b.indexOf("-")||(c=b,b=a.getAttribute&&a.getAttribute("is")||""):(b=a.is,c=a.extends);return{is:b,M:c}}function qf(a){for(var b=[],c="",d=0;0<=d&&d<a.length;d++)if("("===a[d]){var e=lf(a,d);c+=a.slice(d,e+1);d=e}else","===a[d]?(b.push(c),c=""):c+=a[d];c&&b.push(c);return b}
function rf(a){if(void 0!==Qe)return Qe;if(void 0===a.__cssBuild){var b=a.getAttribute("css-build");if(b)a.__cssBuild=b;else{a:{b="template"===a.localName?a.content.firstChild:a.firstChild;if(b instanceof Comment&&(b=b.textContent.trim().split(":"),"css-build"===b[0])){b=b[1];break a}b=""}if(""!==b){var c="template"===a.localName?a.content.firstChild:a.firstChild;c.parentNode.removeChild(c)}a.__cssBuild=b}}return a.__cssBuild||""}
function sf(a){a=void 0===a?"":a;return""!==a&&Q?O?"shadow"===a:"shady"===a:!1};function tf(){}function uf(a,b){vf(R,a,function(a){wf(a,b||"")})}function vf(a,b,c){b.nodeType===Node.ELEMENT_NODE&&c(b);var d;"template"===b.localName?d=(b.content||b._content||b).childNodes:d=b.children||b.childNodes;if(d)for(b=0;b<d.length;b++)vf(a,d[b],c)}
function wf(a,b,c){if(b)if(a.classList)c?(a.classList.remove("style-scope"),a.classList.remove(b)):(a.classList.add("style-scope"),a.classList.add(b));else if(a.getAttribute){var d=a.getAttribute("class");c?d&&(b=d.replace("style-scope","").replace(b,""),nf(a,b)):nf(a,(d?d+" ":"")+"style-scope "+b)}}function xf(a,b,c){vf(R,a,function(a){wf(a,b,!0);wf(a,c)})}function yf(a,b){vf(R,a,function(a){wf(a,b||"",!0)})}
function zf(a,b,c,d,e){var f=R;e=void 0===e?"":e;""===e&&(O||"shady"===(void 0===d?"":d)?e=cf(b,c):(a=pf(a),e=Af(f,b,a.is,a.M,c)+"\n\n"));return e.trim()}function Af(a,b,c,d,e){var f=Bf(c,d);c=c?"."+c:"";return cf(b,function(b){b.c||(b.selector=b.j=Cf(a,b,a.b,c,f),b.c=!0);e&&e(b,c,f)})}function Bf(a,b){return b?"[is="+a+"]":a}
function Cf(a,b,c,d,e){var f=qf(b.selector);if(!ff(b)){b=0;for(var g=f.length,h=void 0;b<g&&(h=f[b]);b++)f[b]=c.call(a,h,d,e)}return f.filter(function(a){return!!a}).join(",")}function Df(a){return a.replace(Ef,function(a,c,d){-1<d.indexOf("+")?d=d.replace(/\+/g,"___"):-1<d.indexOf("___")&&(d=d.replace(/___/g,"+"));return":"+c+"("+d+")"})}
function Ff(a){for(var b=[],c;c=a.match(Gf);){var d=c.index,e=lf(a,d);if(-1===e)throw Error(c.input+" selector missing ')'");c=a.slice(d,e+1);a=a.replace(c,"\ue000");b.push(c)}return{ha:a,matches:b}}function Hf(a,b){var c=a.split("\ue000");return b.reduce(function(a,b,f){return a+b+c[f+1]},c[0])}
tf.prototype.b=function(a,b,c){var d=!1;a=a.trim();var e=Ef.test(a);e&&(a=a.replace(Ef,function(a,b,c){return":"+b+"("+c.replace(/\s/g,"")+")"}),a=Df(a));var f=Gf.test(a);if(f){var g=Ff(a);a=g.ha;g=g.matches}a=a.replace(If,":host $1");a=a.replace(Jf,function(a,e,f){d||(a=Kf(f,e,b,c),d=d||a.stop,e=a.Ca,f=a.value);return e+f});f&&(a=Hf(a,g));e&&(a=Df(a));return a};
function Kf(a,b,c,d){var e=a.indexOf("::slotted");0<=a.indexOf(":host")?a=Lf(a,d):0!==e&&(a=c?Mf(a,c):a);c=!1;0<=e&&(b="",c=!0);if(c){var f=!0;c&&(a=a.replace(Nf,function(a,b){return" > "+b}))}a=a.replace(Of,function(a,b,c){return'[dir="'+c+'"] '+b+", "+b+'[dir="'+c+'"]'});return{value:a,Ca:b,stop:f}}
function Mf(a,b){a=a.split(/(\[.+?\])/);for(var c=[],d=0;d<a.length;d++)if(1===d%2)c.push(a[d]);else{var e=a[d];if(""!==e||d!==a.length-1)e=e.split(":"),e[0]+=b,c.push(e.join(":"))}return c.join("")}function Lf(a,b){var c=a.match(Pf);return(c=c&&c[2].trim()||"")?c[0].match(Qf)?a.replace(Pf,function(a,c,f){return b+f}):c.split(Qf)[0]===b?c:"should_not_match":a.replace(":host",b)}function Rf(a){":root"===a.selector&&(a.selector="html")}
tf.prototype.c=function(a){return a.match(":host")?"":a.match("::slotted")?this.b(a,":not(.style-scope)"):Mf(a.trim(),":not(.style-scope)")};p.Object.defineProperties(tf.prototype,{a:{configurable:!0,enumerable:!0,get:function(){return"style-scope"}}});
var Ef=/:(nth[-\w]+)\(([^)]+)\)/,Jf=/(^|[\s>+~]+)((?:\[.+?\]|[^\s>+~=[])+)/g,Qf=/[[.:#*]/,If=/^(::slotted)/,Pf=/(:host)(?:\(((?:\([^)(]*\)|[^)(]*)+?)\))/,Nf=/(?:::slotted)(?:\(((?:\([^)(]*\)|[^)(]*)+?)\))/,Of=/(.*):dir\((?:(ltr|rtl))\)/,Gf=/:(?:matches|any|-(?:webkit|moz)-any)/,R=new tf;function Sf(a,b,c,d,e){this.A=a||null;this.b=b||null;this.fa=c||[];this.o=null;this.cssBuild=e||"";this.M=d||"";this.a=this.s=this.w=null}function T(a){return a?a.__styleInfo:null}function Tf(a,b){return a.__styleInfo=b}Sf.prototype.c=function(){return this.A};Sf.prototype._getStyleRules=Sf.prototype.c;function Uf(a){var b=this.matches||this.matchesSelector||this.mozMatchesSelector||this.msMatchesSelector||this.oMatchesSelector||this.webkitMatchesSelector;return b&&b.call(this,a)}var Vf=navigator.userAgent.match("Trident");function Wf(){}function Xf(a){var b={},c=[],d=0;df(a,function(a){Yf(a);a.index=d++;a=a.i.cssText;for(var c;c=Te.exec(a);){var e=c[1];":"!==c[2]&&(b[e]=!0)}},function(a){c.push(a)});a.b=c;a=[];for(var e in b)a.push(e);return a}
function Yf(a){if(!a.i){var b={},c={};Zf(a,c)&&(b.v=c,a.rules=null);b.cssText=a.parsedCssText.replace(af,"").replace(Re,"");a.i=b}}function Zf(a,b){var c=a.i;if(c){if(c.v)return Object.assign(b,c.v),!0}else{c=a.parsedCssText;for(var d;a=Re.exec(c);){d=(a[2]||a[3]).trim();if("inherit"!==d||"unset"!==d)b[a[1].trim()]=d;d=!0}return d}}
function $f(a,b,c){b&&(b=0<=b.indexOf(";")?ag(a,b,c):mf(b,function(b,e,f,g){if(!e)return b+g;(e=$f(a,c[e],c))&&"initial"!==e?"apply-shim-inherit"===e&&(e="inherit"):e=$f(a,c[f]||f,c)||f;return b+(e||"")+g}));return b&&b.trim()||""}
function ag(a,b,c){b=b.split(";");for(var d=0,e,f;d<b.length;d++)if(e=b[d]){Se.lastIndex=0;if(f=Se.exec(e))e=$f(a,c[f[1]],c);else if(f=e.indexOf(":"),-1!==f){var g=e.substring(f);g=g.trim();g=$f(a,g,c)||g;e=e.substring(0,f)+g}b[d]=e&&e.lastIndexOf(";")===e.length-1?e.slice(0,-1):e||""}return b.join(";")}
function bg(a,b){var c={},d=[];df(a,function(a){a.i||Yf(a);var e=a.j||a.parsedSelector;b&&a.i.v&&e&&Uf.call(b,e)&&(Zf(a,c),a=a.index,e=parseInt(a/32,10),d[e]=(d[e]||0)|1<<a%32)},null,!0);return{v:c,key:d}}
function cg(a,b,c,d){b.i||Yf(b);if(b.i.v){var e=pf(a);a=e.is;e=e.M;e=a?Bf(a,e):"html";var f=b.parsedSelector,g=":host > *"===f||"html"===f,h=0===f.indexOf(":host")&&!g;"shady"===c&&(g=f===e+" > *."+e||-1!==f.indexOf("html"),h=!g&&0===f.indexOf(e));if(g||h)c=e,h&&(b.j||(b.j=Cf(R,b,R.b,a?"."+a:"",e)),c=b.j||e),d({ha:c,Ia:h,Za:g})}}function dg(a,b,c){var d={},e={};df(b,function(b){cg(a,b,c,function(c){Uf.call(a._element||a,c.ha)&&(c.Ia?Zf(b,d):Zf(b,e))})},null,!0);return{Ra:e,Ha:d}}
function eg(a,b,c,d){var e=pf(b),f=Bf(e.is,e.M),g=new RegExp("(?:^|[^.#[:])"+(b.extends?"\\"+f.slice(0,-1)+"\\]":f)+"($|[.:[\\s>+~])"),h=T(b);e=h.A;h=h.cssBuild;var k=fg(e,d);return zf(b,e,function(b){var e="";b.i||Yf(b);b.i.cssText&&(e=ag(a,b.i.cssText,c));b.cssText=e;if(!O&&!ff(b)&&b.cssText){var h=e=b.cssText;null==b.na&&(b.na=Ue.test(e));if(b.na)if(null==b.U){b.U=[];for(var l in k)h=k[l],h=h(e),e!==h&&(e=h,b.U.push(l))}else{for(l=0;l<b.U.length;++l)h=k[b.U[l]],e=h(e);h=e}b.cssText=h;b.j=b.j||
b.selector;e="."+d;l=qf(b.j);h=0;for(var M=l.length,U=void 0;h<M&&(U=l[h]);h++)l[h]=U.match(g)?U.replace(f,e):e+" "+U;b.selector=l.join(",")}},h)}function fg(a,b){a=a.b;var c={};if(!O&&a)for(var d=0,e=a[d];d<a.length;e=a[++d]){var f=e,g=b;f.f=new RegExp("\\b"+f.keyframesName+"(?!\\B|-)","g");f.a=f.keyframesName+"-"+g;f.j=f.j||f.selector;f.selector=f.j.replace(f.keyframesName,f.a);c[e.keyframesName]=gg(e)}return c}function gg(a){return function(b){return b.replace(a.f,a.a)}}
function hg(a,b){var c=ig,d=ef(a);a.textContent=cf(d,function(a){var d=a.cssText=a.parsedCssText;a.i&&a.i.cssText&&(d=d.replace(Ie,"").replace(Je,""),a.cssText=ag(c,d,b))})}p.Object.defineProperties(Wf.prototype,{a:{configurable:!0,enumerable:!0,get:function(){return"x-scope"}}});var ig=new Wf;var jg={},kg=window.customElements;if(kg&&!O&&!Pe){var lg=kg.define;kg.define=function(a,b,c){jg[a]||(jg[a]=kf(a));lg.call(kg,a,b,c)}};function mg(){this.cache={}}mg.prototype.store=function(a,b,c,d){var e=this.cache[a]||[];e.push({v:b,styleElement:c,s:d});100<e.length&&e.shift();this.cache[a]=e};function ng(){}var og=new RegExp(R.a+"\\s*([^\\s]*)");function pg(a){return(a=(a.classList&&a.classList.value?a.classList.value:a.getAttribute("class")||"").match(og))?a[1]:""}function qg(a){var b=of(a).getRootNode();return b===a||b===a.ownerDocument?"":(a=b.host)?pf(a).is:""}
function rg(a){for(var b=0;b<a.length;b++){var c=a[b];if(c.target!==document.documentElement&&c.target!==document.head)for(var d=0;d<c.addedNodes.length;d++){var e=c.addedNodes[d];if(e.nodeType===Node.ELEMENT_NODE){var f=e.getRootNode(),g=pg(e);if(g&&f===e.ownerDocument&&("style"!==e.localName&&"template"!==e.localName||""===rf(e)))yf(e,g);else if(f instanceof ShadowRoot)for(f=qg(e),f!==g&&xf(e,g,f),e=window.ShadyDOM.nativeMethods.querySelectorAll.call(e,":not(."+R.a+")"),g=0;g<e.length;g++){f=e[g];
var h=qg(f);h&&wf(f,h)}}}}}
if(!(O||window.ShadyDOM&&window.ShadyDOM.handlesDynamicScoping)){var sg=new MutationObserver(rg),tg=function(a){sg.observe(a,{childList:!0,subtree:!0})};if(window.customElements&&!window.customElements.polyfillWrapFlushCallback)tg(document);else{var ug=function(){tg(document.body)};window.HTMLImports?window.HTMLImports.whenReady(ug):requestAnimationFrame(function(){if("loading"===document.readyState){var a=function(){ug();document.removeEventListener("readystatechange",a)};document.addEventListener("readystatechange",
a)}else ug()})}ng=function(){rg(sg.takeRecords())}}var vg=ng;var wg={};var xg=Promise.resolve();function yg(a){if(a=wg[a])a._applyShimCurrentVersion=a._applyShimCurrentVersion||0,a._applyShimValidatingVersion=a._applyShimValidatingVersion||0,a._applyShimNextVersion=(a._applyShimNextVersion||0)+1}function zg(a){return a._applyShimCurrentVersion===a._applyShimNextVersion}function Ag(a){a._applyShimValidatingVersion=a._applyShimNextVersion;a._validating||(a._validating=!0,xg.then(function(){a._applyShimCurrentVersion=a._applyShimNextVersion;a._validating=!1}))};var Bg={},Cg=new mg;function Y(){this.l={};this.c=document.documentElement;var a=new ve;a.rules=[];this.f=Tf(this.c,new Sf(a));this.g=!1;this.b=this.a=null}n=Y.prototype;n.flush=function(){vg()};n.Fa=function(a){return ef(a)};n.Va=function(a){return cf(a)};n.prepareTemplate=function(a,b,c){this.prepareTemplateDom(a,b);this.prepareTemplateStyles(a,b,c)};
n.prepareTemplateStyles=function(a,b,c){if(!a._prepared&&!Pe){O||jg[b]||(jg[b]=kf(b));a._prepared=!0;a.name=b;a.extends=c;wg[b]=a;var d=rf(a),e=sf(d);c={is:b,extends:c};for(var f=[],g=a.content.querySelectorAll("style"),h=0;h<g.length;h++){var k=g[h];if(k.hasAttribute("shady-unscoped")){if(!O){var l=k.textContent;bf.has(l)||(bf.add(l),l=k.cloneNode(!0),document.head.appendChild(l));k.parentNode.removeChild(k)}}else f.push(k.textContent),k.parentNode.removeChild(k)}f=f.join("").trim()+(Bg[b]||"");
Dg(this);if(!e){if(g=!d)g=Se.test(f)||Re.test(f),Se.lastIndex=0,Re.lastIndex=0;h=we(f);g&&Q&&this.a&&this.a.transformRules(h,b);a._styleAst=h}g=[];Q||(g=Xf(a._styleAst));if(!g.length||Q)h=O?a.content:null,b=jg[b]||null,d=zf(c,a._styleAst,null,d,e?f:""),d=d.length?gf(d,c.is,h,b):null,a._style=d;a.a=g}};n.Qa=function(a,b){Bg[b]=a.join(" ")};n.prepareTemplateDom=function(a,b){if(!Pe){var c=rf(a);O||"shady"===c||a._domPrepared||(a._domPrepared=!0,uf(a.content,b))}};
function Eg(a){var b=pf(a),c=b.is;b=b.M;var d=jg[c]||null,e=wg[c];if(e){c=e._styleAst;var f=e.a;e=rf(e);b=new Sf(c,d,f,b,e);Tf(a,b);return b}}function Fg(a){!a.b&&window.ShadyCSS&&window.ShadyCSS.CustomStyleInterface&&(a.b=window.ShadyCSS.CustomStyleInterface,a.b.transformCallback=function(b){a.ra(b)},a.b.validateCallback=function(){requestAnimationFrame(function(){(a.b.enqueued||a.g)&&a.flushCustomStyles()})})}
function Dg(a){!a.a&&window.ShadyCSS&&window.ShadyCSS.ApplyShim&&(a.a=window.ShadyCSS.ApplyShim,a.a.invalidCallback=yg);Fg(a)}
n.flushCustomStyles=function(){if(!Pe&&(Dg(this),this.b)){var a=this.b.processStyles();if(this.b.enqueued&&!sf(this.f.cssBuild)){if(Q){if(!this.f.cssBuild)for(var b=0;b<a.length;b++){var c=this.b.getStyleForCustomStyle(a[b]);if(c&&Q&&this.a){var d=ef(c);Dg(this);this.a.transformRules(d);c.textContent=cf(d)}}}else{Gg(this,this.c,this.f);for(b=0;b<a.length;b++)(c=this.b.getStyleForCustomStyle(a[b]))&&hg(c,this.f.w);this.g&&this.styleDocument()}this.b.enqueued=!1}}};
n.styleElement=function(a,b){if(Pe){if(b){T(a)||Tf(a,new Sf(null));var c=T(a);c.o=c.o||{};Object.assign(c.o,b);Hg(this,a,c)}}else if(c=T(a)||Eg(a))if(a!==this.c&&(this.g=!0),b&&(c.o=c.o||{},Object.assign(c.o,b)),Q)Hg(this,a,c);else if(this.flush(),Gg(this,a,c),c.fa&&c.fa.length){b=pf(a).is;var d;a:{if(d=Cg.cache[b])for(var e=d.length-1;0<=e;e--){var f=d[e];b:{var g=c.fa;for(var h=0;h<g.length;h++){var k=g[h];if(f.v[k]!==c.w[k]){g=!1;break b}}g=!0}if(g){d=f;break a}}d=void 0}g=d?d.styleElement:null;
e=c.s;(f=d&&d.s)||(f=this.l[b]=(this.l[b]||0)+1,f=b+"-"+f);c.s=f;f=c.s;h=ig;h=g?g.textContent||"":eg(h,a,c.w,f);k=T(a);var l=k.a;l&&!O&&l!==g&&(l._useCount--,0>=l._useCount&&l.parentNode&&l.parentNode.removeChild(l));O?k.a?(k.a.textContent=h,g=k.a):h&&(g=gf(h,f,a.shadowRoot,k.b)):g?g.parentNode||(Vf&&-1<h.indexOf("@media")&&(g.textContent=h),hf(g,null,k.b)):h&&(g=gf(h,f,null,k.b));g&&(g._useCount=g._useCount||0,k.a!=g&&g._useCount++,k.a=g);f=g;O||(g=c.s,k=h=a.getAttribute("class")||"",e&&(k=h.replace(new RegExp("\\s*x-scope\\s*"+
e+"\\s*","g")," ")),k+=(k?" ":"")+"x-scope "+g,h!==k&&nf(a,k));d||Cg.store(b,c.w,f,c.s)}};
function Hg(a,b,c){var d=pf(b).is;if(c.o){var e=c.o,f;for(f in e)null===f?b.style.removeProperty(f):b.style.setProperty(f,e[f])}e=wg[d];if(!(!e&&b!==a.c||e&&""!==rf(e))&&e&&e._style&&!zg(e)){if(zg(e)||e._applyShimValidatingVersion!==e._applyShimNextVersion)Dg(a),a.a&&a.a.transformRules(e._styleAst,d),e._style.textContent=zf(b,c.A),Ag(e);O&&(a=b.shadowRoot)&&(a=a.querySelector("style"))&&(a.textContent=zf(b,c.A));c.A=e._styleAst}}
function Ig(a,b){return(b=of(b).getRootNode().host)?T(b)||Eg(b)?b:Ig(a,b):a.c}function Gg(a,b,c){var d=Ig(a,b),e=T(d),f=e.w;d===a.c||f||(Gg(a,d,e),f=e.w);a=Object.create(f||null);d=dg(b,c.A,c.cssBuild);b=bg(e.A,b).v;Object.assign(a,d.Ha,b,d.Ra);b=c.o;for(var g in b)if((e=b[g])||0===e)a[g]=e;g=ig;b=Object.getOwnPropertyNames(a);for(e=0;e<b.length;e++)d=b[e],a[d]=$f(g,a[d],a);c.w=a}n.styleDocument=function(a){this.styleSubtree(this.c,a)};
n.styleSubtree=function(a,b){var c=of(a),d=c.shadowRoot;(d||a===this.c)&&this.styleElement(a,b);if(a=d&&(d.children||d.childNodes))for(c=0;c<a.length;c++)this.styleSubtree(a[c]);else if(c=c.children||c.childNodes)for(a=0;a<c.length;a++)this.styleSubtree(c[a])};
n.ra=function(a){var b=this,c=rf(a);c!==this.f.cssBuild&&(this.f.cssBuild=c);if(!sf(c)){var d=ef(a);df(d,function(a){if(O)Rf(a);else{var d=R;a.selector=a.parsedSelector;Rf(a);a.selector=a.j=Cf(d,a,d.c,void 0,void 0)}Q&&""===c&&(Dg(b),b.a&&b.a.transformRule(a))});Q?a.textContent=cf(d):this.f.A.rules.push(d)}};n.getComputedStyleValue=function(a,b){var c;Q||(c=(T(a)||T(Ig(this,a))).w[b]);return(c=c||window.getComputedStyle(a).getPropertyValue(b))?c.trim():""};
n.Ua=function(a,b){var c=of(a).getRootNode();b=b?b.split(/\s/):[];c=c.host&&c.host.localName;if(!c){var d=a.getAttribute("class");if(d){d=d.split(/\s/);for(var e=0;e<d.length;e++)if(d[e]===R.a){c=d[e+1];break}}}c&&b.push(R.a,c);Q||(c=T(a))&&c.s&&b.push(ig.a,c.s);nf(a,b.join(" "))};n.Ba=function(a){return T(a)};n.Ta=function(a,b){wf(a,b)};n.Wa=function(a,b){wf(a,b,!0)};n.Sa=function(a){return qg(a)};n.Da=function(a){return pg(a)};Y.prototype.flush=Y.prototype.flush;Y.prototype.prepareTemplate=Y.prototype.prepareTemplate;
Y.prototype.styleElement=Y.prototype.styleElement;Y.prototype.styleDocument=Y.prototype.styleDocument;Y.prototype.styleSubtree=Y.prototype.styleSubtree;Y.prototype.getComputedStyleValue=Y.prototype.getComputedStyleValue;Y.prototype.setElementClass=Y.prototype.Ua;Y.prototype._styleInfoForNode=Y.prototype.Ba;Y.prototype.transformCustomStyleForDocument=Y.prototype.ra;Y.prototype.getStyleAst=Y.prototype.Fa;Y.prototype.styleAstToString=Y.prototype.Va;Y.prototype.flushCustomStyles=Y.prototype.flushCustomStyles;
Y.prototype.scopeNode=Y.prototype.Ta;Y.prototype.unscopeNode=Y.prototype.Wa;Y.prototype.scopeForNode=Y.prototype.Sa;Y.prototype.currentScopeForNode=Y.prototype.Da;Y.prototype.prepareAdoptedCssText=Y.prototype.Qa;Object.defineProperties(Y.prototype,{nativeShadow:{get:function(){return O}},nativeCss:{get:function(){return Q}}});var Z=new Y,Jg,Kg;window.ShadyCSS&&(Jg=window.ShadyCSS.ApplyShim,Kg=window.ShadyCSS.CustomStyleInterface);
window.ShadyCSS={ScopingShim:Z,prepareTemplate:function(a,b,c){Z.flushCustomStyles();Z.prepareTemplate(a,b,c)},prepareTemplateDom:function(a,b){Z.prepareTemplateDom(a,b)},prepareTemplateStyles:function(a,b,c){Z.flushCustomStyles();Z.prepareTemplateStyles(a,b,c)},styleSubtree:function(a,b){Z.flushCustomStyles();Z.styleSubtree(a,b)},styleElement:function(a){Z.flushCustomStyles();Z.styleElement(a)},styleDocument:function(a){Z.flushCustomStyles();Z.styleDocument(a)},flushCustomStyles:function(){Z.flushCustomStyles()},
getComputedStyleValue:function(a,b){return Z.getComputedStyleValue(a,b)},nativeCss:Q,nativeShadow:O,cssBuild:Qe,disableRuntime:Pe};Jg&&(window.ShadyCSS.ApplyShim=Jg);Kg&&(window.ShadyCSS.CustomStyleInterface=Kg);var Lg=window.customElements,Mg=window.HTMLImports,Ng=window.HTMLTemplateElement;window.WebComponents=window.WebComponents||{};if(Lg&&Lg.polyfillWrapFlushCallback){var Og,Pg=function(){if(Og){Ng.C&&Ng.C(window.document);var a=Og;Og=null;a();return!0}},Qg=Mg.whenReady;Lg.polyfillWrapFlushCallback(function(a){Og=a;Qg(Pg)});Mg.whenReady=function(a){Qg(function(){Pg()?Mg.whenReady(a):a()})}}
Mg.whenReady(function(){requestAnimationFrame(function(){window.WebComponents.ready=!0;document.dispatchEvent(new CustomEvent("WebComponentsReady",{bubbles:!0}))})});var Rg=document.createElement("style");Rg.textContent="body {transition: opacity ease-in 0.2s; } \nbody[unresolved] {opacity: 0; display: block; overflow: hidden; position: relative; } \n";var Sg=document.querySelector("head");Sg.insertBefore(Rg,Sg.firstChild);}).call(this);



(function(){/*

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
*/
'use strict';var l=!(window.ShadyDOM&&window.ShadyDOM.inUse),p;function r(a){p=a&&a.shimcssproperties?!1:l||!(navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/)||!window.CSS||!CSS.supports||!CSS.supports("box-shadow","0 0 0 var(--foo)"))}var t;window.ShadyCSS&&void 0!==window.ShadyCSS.cssBuild&&(t=window.ShadyCSS.cssBuild);var aa=!(!window.ShadyCSS||!window.ShadyCSS.disableRuntime);
window.ShadyCSS&&void 0!==window.ShadyCSS.nativeCss?p=window.ShadyCSS.nativeCss:window.ShadyCSS?(r(window.ShadyCSS),window.ShadyCSS=void 0):r(window.WebComponents&&window.WebComponents.flags);var u=p,v=t;function w(){this.end=this.start=0;this.rules=this.parent=this.previous=null;this.cssText=this.parsedCssText="";this.atRule=!1;this.type=0;this.parsedSelector=this.selector=this.keyframesName=""}
function x(a){a=a.replace(ba,"").replace(ca,"");var b=y,c=a,e=new w;e.start=0;e.end=c.length;for(var d=e,f=0,g=c.length;f<g;f++)if("{"===c[f]){d.rules||(d.rules=[]);var h=d,k=h.rules[h.rules.length-1]||null;d=new w;d.start=f+1;d.parent=h;d.previous=k;h.rules.push(d)}else"}"===c[f]&&(d.end=f+1,d=d.parent||e);return b(e,a)}
function y(a,b){var c=b.substring(a.start,a.end-1);a.parsedCssText=a.cssText=c.trim();a.parent&&(c=b.substring(a.previous?a.previous.end:a.parent.start,a.start-1),c=da(c),c=c.replace(z," "),c=c.substring(c.lastIndexOf(";")+1),c=a.parsedSelector=a.selector=c.trim(),a.atRule=0===c.indexOf("@"),a.atRule?0===c.indexOf("@media")?a.type=A:c.match(ea)&&(a.type=B,a.keyframesName=a.selector.split(z).pop()):a.type=0===c.indexOf("--")?C:D);if(c=a.rules)for(var e=0,d=c.length,f=void 0;e<d&&(f=c[e]);e++)y(f,b);
return a}function da(a){return a.replace(/\\([0-9a-f]{1,6})\s/gi,function(a,c){a=c;for(c=6-a.length;c--;)a="0"+a;return"\\"+a})}
function E(a,b,c){c=void 0===c?"":c;var e="";if(a.cssText||a.rules){var d=a.rules,f;if(f=d)f=d[0],f=!(f&&f.selector&&0===f.selector.indexOf("--"));if(f){f=0;for(var g=d.length,h=void 0;f<g&&(h=d[f]);f++)e=E(h,b,e)}else b?b=a.cssText:(b=a.cssText,b=b.replace(fa,"").replace(ha,""),b=b.replace(ia,"").replace(ja,"")),(e=b.trim())&&(e="  "+e+"\n")}e&&(a.selector&&(c+=a.selector+" {\n"),c+=e,a.selector&&(c+="}\n\n"));return c}
var D=1,B=7,A=4,C=1E3,ba=/\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,ca=/@import[^;]*;/gim,fa=/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\n]|$)/gim,ha=/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\n]|$)?/gim,ia=/@apply\s*\(?[^);]*\)?\s*(?:[;\n]|$)?/gim,ja=/[^;:]*?:[^;]*?var\([^;]*\)(?:[;\n]|$)?/gim,ea=/^@[^\s]*keyframes/,z=/\s+/g;var G=/(?:^|[;\s{]\s*)(--[\w-]*?)\s*:\s*(?:((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};{])+)|\{([^}]*)\}(?:(?=[;\s}])|$))/gi,H=/(?:^|\W+)@apply\s*\(?([^);\n]*)\)?/gi,ka=/@media\s(.*)/;var I=new Set;function J(a){if(!a)return"";"string"===typeof a&&(a=x(a));return E(a,u)}function K(a){!a.__cssRules&&a.textContent&&(a.__cssRules=x(a.textContent));return a.__cssRules||null}function L(a,b,c,e){if(a){var d=!1,f=a.type;if(e&&f===A){var g=a.selector.match(ka);g&&(window.matchMedia(g[1]).matches||(d=!0))}f===D?b(a):c&&f===B?c(a):f===C&&(d=!0);if((a=a.rules)&&!d)for(d=0,f=a.length,g=void 0;d<f&&(g=a[d]);d++)L(g,b,c,e)}}
function M(a,b){var c=a.indexOf("var(");if(-1===c)return b(a,"","","");a:{var e=0;var d=c+3;for(var f=a.length;d<f;d++)if("("===a[d])e++;else if(")"===a[d]&&0===--e)break a;d=-1}e=a.substring(c+4,d);c=a.substring(0,c);a=M(a.substring(d+1),b);d=e.indexOf(",");return-1===d?b(c,e.trim(),"",a):b(c,e.substring(0,d).trim(),e.substring(d+1).trim(),a)}
function N(a){if(void 0!==v)return v;if(void 0===a.__cssBuild){var b=a.getAttribute("css-build");if(b)a.__cssBuild=b;else{a:{b="template"===a.localName?a.content.firstChild:a.firstChild;if(b instanceof Comment&&(b=b.textContent.trim().split(":"),"css-build"===b[0])){b=b[1];break a}b=""}if(""!==b){var c="template"===a.localName?a.content.firstChild:a.firstChild;c.parentNode.removeChild(c)}a.__cssBuild=b}}return a.__cssBuild||""};var la=/;\s*/m,ma=/^\s*(initial)|(inherit)\s*$/,O=/\s*!important/;function P(){this.a={}}P.prototype.set=function(a,b){a=a.trim();this.a[a]={h:b,i:{}}};P.prototype.get=function(a){a=a.trim();return this.a[a]||null};var Q=null;function R(){this.b=this.c=null;this.a=new P}R.prototype.o=function(a){a=H.test(a)||G.test(a);H.lastIndex=0;G.lastIndex=0;return a};
R.prototype.m=function(a,b){if(void 0===a._gatheredStyle){var c=[];for(var e=a.content.querySelectorAll("style"),d=0;d<e.length;d++){var f=e[d];if(f.hasAttribute("shady-unscoped")){if(!l){var g=f.textContent;I.has(g)||(I.add(g),g=f.cloneNode(!0),document.head.appendChild(g));f.parentNode.removeChild(f)}}else c.push(f.textContent),f.parentNode.removeChild(f)}(c=c.join("").trim())?(e=document.createElement("style"),e.textContent=c,a.content.insertBefore(e,a.content.firstChild),c=e):c=null;a._gatheredStyle=
c}return(a=a._gatheredStyle)?this.j(a,b):null};R.prototype.j=function(a,b){b=void 0===b?"":b;var c=K(a);this.l(c,b);a.textContent=J(c);return c};R.prototype.f=function(a){var b=this,c=K(a);L(c,function(a){":root"===a.selector&&(a.selector="html");b.g(a)});a.textContent=J(c);return c};R.prototype.l=function(a,b){var c=this;this.c=b;L(a,function(a){c.g(a)});this.c=null};R.prototype.g=function(a){a.cssText=na(this,a.parsedCssText,a);":root"===a.selector&&(a.selector=":host > *")};
function na(a,b,c){b=b.replace(G,function(b,d,f,g){return oa(a,b,d,f,g,c)});return S(a,b,c)}function pa(a,b){for(var c=b;c.parent;)c=c.parent;var e={},d=!1;L(c,function(c){(d=d||c===b)||c.selector===b.selector&&Object.assign(e,T(a,c.parsedCssText))});return e}
function S(a,b,c){for(var e;e=H.exec(b);){var d=e[0],f=e[1];e=e.index;var g=b.slice(0,e+d.indexOf("@apply"));b=b.slice(e+d.length);var h=c?pa(a,c):{};Object.assign(h,T(a,g));d=void 0;var k=a;f=f.replace(la,"");var n=[];var m=k.a.get(f);m||(k.a.set(f,{}),m=k.a.get(f));if(m){k.c&&(m.i[k.c]=!0);var q=m.h;for(d in q)k=h&&h[d],m=[d,": var(",f,"_-_",d],k&&m.push(",",k.replace(O,"")),m.push(")"),O.test(q[d])&&m.push(" !important"),n.push(m.join(""))}d=n.join("; ");b=g+d+b;H.lastIndex=e+d.length}return b}
function T(a,b,c){c=void 0===c?!1:c;b=b.split(";");for(var e,d,f={},g=0,h;g<b.length;g++)if(e=b[g])if(h=e.split(":"),1<h.length){e=h[0].trim();d=h.slice(1).join(":");if(c){var k=a;h=e;var n=ma.exec(d);n&&(n[1]?(k.b||(k.b=document.createElement("meta"),k.b.setAttribute("apply-shim-measure",""),k.b.style.all="initial",document.head.appendChild(k.b)),h=window.getComputedStyle(k.b).getPropertyValue(h)):h="apply-shim-inherit",d=h)}f[e]=d}return f}function qa(a,b){if(Q)for(var c in b.i)c!==a.c&&Q(c)}
function oa(a,b,c,e,d,f){e&&M(e,function(b,c){c&&a.a.get(c)&&(d="@apply "+c+";")});if(!d)return b;var g=S(a,""+d,f);f=b.slice(0,b.indexOf("--"));var h=g=T(a,g,!0),k=a.a.get(c),n=k&&k.h;n?h=Object.assign(Object.create(n),g):a.a.set(c,h);var m=[],q,Z=!1;for(q in h){var F=g[q];void 0===F&&(F="initial");!n||q in n||(Z=!0);m.push(c+"_-_"+q+": "+F)}Z&&qa(a,k);k&&(k.h=h);e&&(f=b+";"+f);return f+m.join("; ")+";"}R.prototype.detectMixin=R.prototype.o;R.prototype.transformStyle=R.prototype.j;
R.prototype.transformCustomStyle=R.prototype.f;R.prototype.transformRules=R.prototype.l;R.prototype.transformRule=R.prototype.g;R.prototype.transformTemplate=R.prototype.m;R.prototype._separator="_-_";Object.defineProperty(R.prototype,"invalidCallback",{get:function(){return Q},set:function(a){Q=a}});var U={};var ra=Promise.resolve();function sa(a){if(a=U[a])a._applyShimCurrentVersion=a._applyShimCurrentVersion||0,a._applyShimValidatingVersion=a._applyShimValidatingVersion||0,a._applyShimNextVersion=(a._applyShimNextVersion||0)+1}function ta(a){return a._applyShimCurrentVersion===a._applyShimNextVersion}function ua(a){a._applyShimValidatingVersion=a._applyShimNextVersion;a._validating||(a._validating=!0,ra.then(function(){a._applyShimCurrentVersion=a._applyShimNextVersion;a._validating=!1}))};var V=new R;function W(){this.a=null;V.invalidCallback=sa}function X(a){!a.a&&window.ShadyCSS.CustomStyleInterface&&(a.a=window.ShadyCSS.CustomStyleInterface,a.a.transformCallback=function(a){V.f(a)},a.a.validateCallback=function(){requestAnimationFrame(function(){a.a.enqueued&&a.flushCustomStyles()})})}W.prototype.prepareTemplate=function(a,b){X(this);""===N(a)&&(U[b]=a,b=V.m(a,b),a._styleAst=b)};
W.prototype.flushCustomStyles=function(){X(this);if(this.a){var a=this.a.processStyles();if(this.a.enqueued){for(var b=0;b<a.length;b++){var c=this.a.getStyleForCustomStyle(a[b]);c&&V.f(c)}this.a.enqueued=!1}}};
W.prototype.styleSubtree=function(a,b){X(this);if(b)for(var c in b)null===c?a.style.removeProperty(c):a.style.setProperty(c,b[c]);if(a.shadowRoot)for(this.styleElement(a),a=a.shadowRoot.children||a.shadowRoot.childNodes,b=0;b<a.length;b++)this.styleSubtree(a[b]);else for(a=a.children||a.childNodes,b=0;b<a.length;b++)this.styleSubtree(a[b])};
W.prototype.styleElement=function(a){X(this);var b=a.localName,c;b?-1<b.indexOf("-")?c=b:c=a.getAttribute&&a.getAttribute("is")||"":c=a.is;b=U[c];if(!(b&&""!==N(b)||!b||ta(b))){if(ta(b)||b._applyShimValidatingVersion!==b._applyShimNextVersion)this.prepareTemplate(b,c),ua(b);if(a=a.shadowRoot)if(a=a.querySelector("style"))a.__cssRules=b._styleAst,a.textContent=J(b._styleAst)}};W.prototype.styleDocument=function(a){X(this);this.styleSubtree(document.body,a)};
if(!window.ShadyCSS||!window.ShadyCSS.ScopingShim){var Y=new W,va=window.ShadyCSS&&window.ShadyCSS.CustomStyleInterface;window.ShadyCSS={prepareTemplate:function(a,b){Y.flushCustomStyles();Y.prepareTemplate(a,b)},prepareTemplateStyles:function(a,b,c){window.ShadyCSS.prepareTemplate(a,b,c)},prepareTemplateDom:function(){},styleSubtree:function(a,b){Y.flushCustomStyles();Y.styleSubtree(a,b)},styleElement:function(a){Y.flushCustomStyles();Y.styleElement(a)},styleDocument:function(a){Y.flushCustomStyles();
Y.styleDocument(a)},getComputedStyleValue:function(a,b){return(a=window.getComputedStyle(a).getPropertyValue(b))?a.trim():""},flushCustomStyles:function(){Y.flushCustomStyles()},nativeCss:u,nativeShadow:l,cssBuild:v,disableRuntime:aa};va&&(window.ShadyCSS.CustomStyleInterface=va)}window.ShadyCSS.ApplyShim=V;}).call(this);




(function() {
  'use strict';

  const userPolymer = window.Polymer;

  /**
   * @namespace Polymer
   * @summary Polymer is a lightweight library built on top of the web
   *   standards-based Web Components API's, and makes it easy to build your
   *   own custom HTML elements.
   * @param {!PolymerInit} info Prototype for the custom element. It must contain
   *   an `is` property to specify the element name. Other properties populate
   *   the element prototype. The `properties`, `observers`, `hostAttributes`,
   *   and `listeners` properties are processed to create element features.
   * @return {!Object} Returns a custom element class for the given provided
   *   prototype `info` object. The name of the element if given by `info.is`.
   */
  window.Polymer = function(info) {
    return window.Polymer._polymerFn(info);
  };

  // support user settings on the Polymer object
  if (userPolymer) {
    Object.assign(Polymer, userPolymer);
  }

  // To be plugged by legacy implementation if loaded
  /* eslint-disable valid-jsdoc */
  /**
   * @param {!PolymerInit} info Prototype for the custom element. It must contain
   *   an `is` property to specify the element name. Other properties populate
   *   the element prototype. The `properties`, `observers`, `hostAttributes`,
   *   and `listeners` properties are processed to create element features.
   * @return {!Object} Returns a custom element class for the given provided
   *   prototype `info` object. The name of the element if given by `info.is`.
   */
  window.Polymer._polymerFn = function(info) { // eslint-disable-line no-unused-vars
    throw new Error('Load polymer.html to use the Polymer() function.');
  };
  /* eslint-enable */

  window.Polymer.version = '2.7.0';

  /* eslint-disable no-unused-vars */
  /*
  When using Closure Compiler, JSCompiler_renameProperty(property, object) is replaced by the munged name for object[property]
  We cannot alias this function, so we have to use a small shim that has the same behavior when not compiling.
  */
  window.JSCompiler_renameProperty = function(prop, obj) {
    return prop;
  };
  /* eslint-enable */

})();



  (function() {
    'use strict';

    let CSS_URL_RX = /(url\()([^)]*)(\))/g;
    let ABS_URL = /(^\/)|(^#)|(^[\w-\d]*:)/;
    let workingURL;
    let resolveDoc;
    /**
     * Resolves the given URL against the provided `baseUri'.
     * 
     * Note that this function performs no resolution for URLs that start
     * with `/` (absolute URLs) or `#` (hash identifiers).  For general purpose
     * URL resolution, use `window.URL`.
     *
     * @memberof Polymer.ResolveUrl
     * @param {string} url Input URL to resolve
     * @param {?string=} baseURI Base URI to resolve the URL against
     * @return {string} resolved URL
     */
    function resolveUrl(url, baseURI) {
      if (url && ABS_URL.test(url)) {
        return url;
      }
      // Lazy feature detection.
      if (workingURL === undefined) {
        workingURL = false;
        try {
          const u = new URL('b', 'http://a');
          u.pathname = 'c%20d';
          workingURL = (u.href === 'http://a/c%20d');
        } catch (e) {
          // silently fail
        }
      }
      if (!baseURI) {
        baseURI = document.baseURI || window.location.href;
      }
      if (workingURL) {
        return (new URL(url, baseURI)).href;
      }
      // Fallback to creating an anchor into a disconnected document.
      if (!resolveDoc) {
        resolveDoc = document.implementation.createHTMLDocument('temp');
        resolveDoc.base = resolveDoc.createElement('base');
        resolveDoc.head.appendChild(resolveDoc.base);
        resolveDoc.anchor = resolveDoc.createElement('a');
        resolveDoc.body.appendChild(resolveDoc.anchor);
      }
      resolveDoc.base.href = baseURI;
      resolveDoc.anchor.href = url;
      return resolveDoc.anchor.href || url;

    }

    /**
     * Resolves any relative URL's in the given CSS text against the provided
     * `ownerDocument`'s `baseURI`.
     *
     * @memberof Polymer.ResolveUrl
     * @param {string} cssText CSS text to process
     * @param {string} baseURI Base URI to resolve the URL against
     * @return {string} Processed CSS text with resolved URL's
     */
    function resolveCss(cssText, baseURI) {
      return cssText.replace(CSS_URL_RX, function(m, pre, url, post) {
        return pre + '\'' +
          resolveUrl(url.replace(/["']/g, ''), baseURI) +
          '\'' + post;
      });
    }

    /**
     * Returns a path from a given `url`. The path includes the trailing
     * `/` from the url.
     *
     * @memberof Polymer.ResolveUrl
     * @param {string} url Input URL to transform
     * @return {string} resolved path
     */
    function pathFromUrl(url) {
      return url.substring(0, url.lastIndexOf('/') + 1);
    }

    /**
     * Module with utilities for resolving relative URL's.
     *
     * @namespace
     * @memberof Polymer
     * @summary Module with utilities for resolving relative URL's.
     */
    Polymer.ResolveUrl = {
      resolveCss: resolveCss,
      resolveUrl: resolveUrl,
      pathFromUrl: pathFromUrl
    };

  })();



/** @suppress {deprecated} */
(function() {
  'use strict';

  /**
   * Sets the global, legacy settings.
   *
   * @deprecated
   * @namespace
   * @memberof Polymer
   */
  Polymer.Settings = Polymer.Settings || {};

  Polymer.Settings.useShadow = !(window.ShadyDOM);
  Polymer.Settings.useNativeCSSProperties =
    Boolean(!window.ShadyCSS || window.ShadyCSS.nativeCss);
  Polymer.Settings.useNativeCustomElements =
    !(window.customElements.polyfillWrapFlushCallback);


  /**
   * Globally settable property that is automatically assigned to
   * `Polymer.ElementMixin` instances, useful for binding in templates to
   * make URL's relative to an application's root.  Defaults to the main
   * document URL, but can be overridden by users.  It may be useful to set
   * `Polymer.rootPath` to provide a stable application mount path when
   * using client side routing.
   *
   * @memberof Polymer
   */
  Polymer.rootPath = Polymer.rootPath ||
    Polymer.ResolveUrl.pathFromUrl(document.baseURI || window.location.href);

  /**
   * Sets the global rootPath property used by `Polymer.ElementMixin` and
   * available via `Polymer.rootPath`.
   *
   * @memberof Polymer
   * @param {string} path The new root path
   * @return {void}
   */
  Polymer.setRootPath = function(path) {
    Polymer.rootPath = path;
  };

  /**
   * A global callback used to sanitize any value before inserting it into the DOM. The callback signature is:
   *
   *     Polymer = {
   *       sanitizeDOMValue: function(value, name, type, node) { ... }
   *     }
   *
   * Where:
   *
   * `value` is the value to sanitize.
   * `name` is the name of an attribute or property (for example, href).
   * `type` indicates where the value is being inserted: one of property, attribute, or text.
   * `node` is the node where the value is being inserted.
   *
   * @type {(function(*,string,string,Node):*)|undefined}
   * @memberof Polymer
   */
  Polymer.sanitizeDOMValue = Polymer.sanitizeDOMValue || null;

  /**
   * Sets the global sanitizeDOMValue available via `Polymer.sanitizeDOMValue`.
   *
   * @memberof Polymer
   * @param {(function(*,string,string,Node):*)|undefined} newSanitizeDOMValue the global sanitizeDOMValue callback
   * @return {void}
   */
  Polymer.setSanitizeDOMValue = function(newSanitizeDOMValue) {
    Polymer.sanitizeDOMValue = newSanitizeDOMValue;
  };

  /**
   * Globally settable property to make Polymer Gestures use passive TouchEvent listeners when recognizing gestures.
   * When set to `true`, gestures made from touch will not be able to prevent scrolling, allowing for smoother
   * scrolling performance.
   * Defaults to `false` for backwards compatibility.
   *
   * @memberof Polymer
   */
  Polymer.passiveTouchGestures = Polymer.passiveTouchGestures || false;

  /**
   * Sets `passiveTouchGestures` globally for all elements using Polymer Gestures.
   *
   * @memberof Polymer
   * @param {boolean} usePassive enable or disable passive touch gestures globally
   * @return {void}
   */
  Polymer.setPassiveTouchGestures = function(usePassive) {
    Polymer.passiveTouchGestures = usePassive;
  };

  Polymer.legacyOptimizations = Polymer.legacyOptimizations ||
      window.PolymerSettings && window.PolymerSettings.legacyOptimizations || false;

  /**
   * Sets `legacyOptimizations` globally for all elements. Enables
   * optimizations when only legacy Polymer() style elements are used.
   *
   * @memberof Polymer
   * @param {boolean} useLegacyOptimizations enable or disable legacy optimizations globally.
   * @return {void}
   */
  Polymer.setLegacyOptimizations = function(useLegacyOptimizations) {
    Polymer.legacyOptimizations = useLegacyOptimizations;
  };
})();



(function() {

  'use strict';

  // unique global id for deduping mixins.
  let dedupeId = 0;

  /**
   * @constructor
   * @extends {Function}
   * @private
   */
  function MixinFunction(){}
  /** @type {(WeakMap | undefined)} */
  MixinFunction.prototype.__mixinApplications;
  /** @type {(Object | undefined)} */
  MixinFunction.prototype.__mixinSet;

  /* eslint-disable valid-jsdoc */
  /**
   * Wraps an ES6 class expression mixin such that the mixin is only applied
   * if it has not already been applied its base argument. Also memoizes mixin
   * applications.
   *
   * @memberof Polymer
   * @template T
   * @param {T} mixin ES6 class expression mixin to wrap
   * @return {T}
   * @suppress {invalidCasts}
   */
  Polymer.dedupingMixin = function(mixin) {
    let mixinApplications = /** @type {!MixinFunction} */(mixin).__mixinApplications;
    if (!mixinApplications) {
      mixinApplications = new WeakMap();
      /** @type {!MixinFunction} */(mixin).__mixinApplications = mixinApplications;
    }
    // maintain a unique id for each mixin
    let mixinDedupeId = dedupeId++;
    function dedupingMixin(base) {
      let baseSet = /** @type {!MixinFunction} */(base).__mixinSet;
      if (baseSet && baseSet[mixinDedupeId]) {
        return base;
      }
      let map = mixinApplications;
      let extended = map.get(base);
      if (!extended) {
        extended = /** @type {!Function} */(mixin)(base);
        map.set(base, extended);
      }
      // copy inherited mixin set from the extended class, or the base class
      // NOTE: we avoid use of Set here because some browser (IE11)
      // cannot extend a base Set via the constructor.
      let mixinSet = Object.create(/** @type {!MixinFunction} */(extended).__mixinSet || baseSet || null);
      mixinSet[mixinDedupeId] = true;
      /** @type {!MixinFunction} */(extended).__mixinSet = mixinSet;
      return extended;
    }

    return /** @type {T} */ (dedupingMixin);
  };
  /* eslint-enable valid-jsdoc */

})();



(function() {
  'use strict';

  const MODULE_STYLE_LINK_SELECTOR = 'link[rel=import][type~=css]';
  const INCLUDE_ATTR = 'include';
  const SHADY_UNSCOPED_ATTR = 'shady-unscoped';

  function importModule(moduleId) {
    const /** Polymer.DomModule */ PolymerDomModule = customElements.get('dom-module');
    if (!PolymerDomModule) {
      return null;
    }
    return PolymerDomModule.import(moduleId);
  }

  function styleForImport(importDoc) {
    // NOTE: polyfill affordance.
    // under the HTMLImports polyfill, there will be no 'body',
    // but the import pseudo-doc can be used directly.
    let container = importDoc.body ? importDoc.body : importDoc;
    const importCss = Polymer.ResolveUrl.resolveCss(container.textContent,
      importDoc.baseURI);
    const style = document.createElement('style');
    style.textContent = importCss;
    return style;
  }

  /** @typedef {{assetpath: string}} */
  let templateWithAssetPath; // eslint-disable-line no-unused-vars

  /**
   * Module with utilities for collection CSS text from `<templates>`, external
   * stylesheets, and `dom-module`s.
   *
   * @namespace
   * @memberof Polymer
   * @summary Module with utilities for collection CSS text from various sources.
   */
  const StyleGather = {

    /**
     * Returns a list of <style> elements in a space-separated list of `dom-module`s.
     *
     * @memberof Polymer.StyleGather
     * @param {string} moduleIds List of dom-module id's within which to
     * search for css.
     * @return {!Array<!HTMLStyleElement>} Array of contained <style> elements
     * @this {StyleGather}
     */
     stylesFromModules(moduleIds) {
      const modules = moduleIds.trim().split(/\s+/);
      const styles = [];
      for (let i=0; i < modules.length; i++) {
        styles.push(...this.stylesFromModule(modules[i]));
      }
      return styles;
    },

    /**
     * Returns a list of <style> elements in a given `dom-module`.
     * Styles in a `dom-module` can come either from `<style>`s within the
     * first `<template>`, or else from one or more
     * `<link rel="import" type="css">` links outside the template.
     *
     * @memberof Polymer.StyleGather
     * @param {string} moduleId dom-module id to gather styles from
     * @return {!Array<!HTMLStyleElement>} Array of contained styles.
     * @this {StyleGather}
     */
    stylesFromModule(moduleId) {
      const m = importModule(moduleId);

      if (!m) {
        console.warn('Could not find style data in module named', moduleId);
        return [];
      }

      if (m._styles === undefined) {
        const styles = [];
        // module imports: <link rel="import" type="css">
        styles.push(...this._stylesFromModuleImports(m));
        // include css from the first template in the module
        const template = m.querySelector('template');
        if (template) {
          styles.push(...this.stylesFromTemplate(template,
            /** @type {templateWithAssetPath} */(m).assetpath));
        }

        m._styles = styles;
      }

      return m._styles;
    },

    /**
     * Returns the `<style>` elements within a given template.
     *
     * @memberof Polymer.StyleGather
     * @param {!HTMLTemplateElement} template Template to gather styles from
     * @param {string} baseURI baseURI for style content
     * @return {!Array<!HTMLStyleElement>} Array of styles
     * @this {StyleGather}
     */
    stylesFromTemplate(template, baseURI) {
      if (!template._styles) {
        const styles = [];
        // if element is a template, get content from its .content
        const e$ = template.content.querySelectorAll('style');
        for (let i=0; i < e$.length; i++) {
          let e = e$[i];
          // support style sharing by allowing styles to "include"
          // other dom-modules that contain styling
          let include = e.getAttribute(INCLUDE_ATTR);
          if (include) {
            styles.push(...this.stylesFromModules(include).filter(function(item, index, self) {
              return self.indexOf(item) === index;
            }));
          }
          if (baseURI) {
            e.textContent = Polymer.ResolveUrl.resolveCss(e.textContent, baseURI);
          }
          styles.push(e);
        }
        template._styles = styles;
      }
      return template._styles;
    },

    /**
     * Returns a list of <style> elements  from stylesheets loaded via `<link rel="import" type="css">` links within the specified `dom-module`.
     *
     * @memberof Polymer.StyleGather
     * @param {string} moduleId Id of `dom-module` to gather CSS from
     * @return {!Array<!HTMLStyleElement>} Array of contained styles.
     * @this {StyleGather}
     */
     stylesFromModuleImports(moduleId) {
      let m = importModule(moduleId);
      return m ? this._stylesFromModuleImports(m) : [];
    },

    /**
     * @memberof Polymer.StyleGather
     * @this {StyleGather}
     * @param {!HTMLElement} module dom-module element that could contain `<link rel="import" type="css">` styles
     * @return {!Array<!HTMLStyleElement>} Array of contained styles
     */
    _stylesFromModuleImports(module) {
      const styles = [];
      const p$ = module.querySelectorAll(MODULE_STYLE_LINK_SELECTOR);
      for (let i=0; i < p$.length; i++) {
        let p = p$[i];
        if (p.import) {
          const importDoc = p.import;
          const unscoped = p.hasAttribute(SHADY_UNSCOPED_ATTR);
          if (unscoped && !importDoc._unscopedStyle) {
            const style = styleForImport(importDoc);
            style.setAttribute(SHADY_UNSCOPED_ATTR, '');
            importDoc._unscopedStyle = style;
          } else if (!importDoc._style) {
            importDoc._style = styleForImport(importDoc);
          }
          styles.push(unscoped ? importDoc._unscopedStyle : importDoc._style);
        }
      }
      return styles;
    },

    /**
     *
     * Returns CSS text of styles in a space-separated list of `dom-module`s.
     * Note: This method is deprecated, use `stylesFromModules` instead.
     *
     * @deprecated
     * @memberof Polymer.StyleGather
     * @param {string} moduleIds List of dom-module id's within which to
     * search for css.
     * @return {string} Concatenated CSS content from specified `dom-module`s
     * @this {StyleGather}
     */
     cssFromModules(moduleIds) {
      let modules = moduleIds.trim().split(/\s+/);
      let cssText = '';
      for (let i=0; i < modules.length; i++) {
        cssText += this.cssFromModule(modules[i]);
      }
      return cssText;
    },

    /**
     * Returns CSS text of styles in a given `dom-module`.  CSS in a `dom-module`
     * can come either from `<style>`s within the first `<template>`, or else
     * from one or more `<link rel="import" type="css">` links outside the
     * template.
     *
     * Any `<styles>` processed are removed from their original location.
     * Note: This method is deprecated, use `styleFromModule` instead.
     *
     * @deprecated
     * @memberof Polymer.StyleGather
     * @param {string} moduleId dom-module id to gather styles from
     * @return {string} Concatenated CSS content from specified `dom-module`
     * @this {StyleGather}
     */
    cssFromModule(moduleId) {
      let m = importModule(moduleId);
      if (m && m._cssText === undefined) {
        // module imports: <link rel="import" type="css">
        let cssText = this._cssFromModuleImports(m);
        // include css from the first template in the module
        let t = m.querySelector('template');
        if (t) {
          cssText += this.cssFromTemplate(t,
            /** @type {templateWithAssetPath} */(m).assetpath);
        }
        m._cssText = cssText || null;
      }
      if (!m) {
        console.warn('Could not find style data in module named', moduleId);
      }
      return m && m._cssText || '';
    },

    /**
     * Returns CSS text of `<styles>` within a given template.
     *
     * Any `<styles>` processed are removed from their original location.
     * Note: This method is deprecated, use `styleFromTemplate` instead.
     *
     * @deprecated
     * @memberof Polymer.StyleGather
     * @param {!HTMLTemplateElement} template Template to gather styles from
     * @param {string} baseURI Base URI to resolve the URL against
     * @return {string} Concatenated CSS content from specified template
     * @this {StyleGather}
     */
    cssFromTemplate(template, baseURI) {
      let cssText = '';
      const e$ = this.stylesFromTemplate(template, baseURI);
      // if element is a template, get content from its .content
      for (let i=0; i < e$.length; i++) {
        let e = e$[i];
        if (e.parentNode) {
          e.parentNode.removeChild(e);
        }
        cssText += e.textContent;
      }
      return cssText;
    },

    /**
     * Returns CSS text from stylesheets loaded via `<link rel="import" type="css">`
     * links within the specified `dom-module`.
     *
     * Note: This method is deprecated, use `stylesFromModuleImports` instead.
     *
     * @deprecated
     *
     * @memberof Polymer.StyleGather
     * @param {string} moduleId Id of `dom-module` to gather CSS from
     * @return {string} Concatenated CSS content from links in specified `dom-module`
     * @this {StyleGather}
     */
    cssFromModuleImports(moduleId) {
      let m = importModule(moduleId);
      return m ? this._cssFromModuleImports(m) : '';
    },

    /**
     * @deprecated
     * @memberof Polymer.StyleGather
     * @this {StyleGather}
     * @param {!HTMLElement} module dom-module element that could contain `<link rel="import" type="css">` styles
     * @return {string} Concatenated CSS content from links in the dom-module
     */
     _cssFromModuleImports(module) {
      let cssText = '';
      let styles = this._stylesFromModuleImports(module);
      for (let i=0; i < styles.length; i++) {
        cssText += styles[i].textContent;
      }
      return cssText;
    }
  };

  Polymer.StyleGather = StyleGather;
})();


(function() {
  'use strict';

  let modules = {};
  let lcModules = {};
  function setModule(id, module) {
    // store id separate from lowercased id so that
    // in all cases mixedCase id will stored distinctly
    // and lowercase version is a fallback
    modules[id] = lcModules[id.toLowerCase()] = module;
  }
  function findModule(id) {
    return modules[id] || lcModules[id.toLowerCase()];
  }

  function styleOutsideTemplateCheck(inst) {
    if (inst.querySelector('style')) {
      console.warn('dom-module %s has style outside template', inst.id);
    }
  }

  /**
   * The `dom-module` element registers the dom it contains to the name given
   * by the module's id attribute. It provides a unified database of dom
   * accessible via its static `import` API.
   *
   * A key use case of `dom-module` is for providing custom element `<template>`s
   * via HTML imports that are parsed by the native HTML parser, that can be
   * relocated during a bundling pass and still looked up by `id`.
   *
   * Example:
   *
   *     <dom-module id="foo">
   *       <img src="stuff.png">
   *     </dom-module>
   *
   * Then in code in some other location that cannot access the dom-module above
   *
   *     let img = customElements.get('dom-module').import('foo', 'img');
   *
   * @customElement
   * @extends HTMLElement
   * @memberof Polymer
   * @summary Custom element that provides a registry of relocatable DOM content
   *   by `id` that is agnostic to bundling.
   * @unrestricted
   */
  class DomModule extends HTMLElement {

    static get observedAttributes() { return ['id']; }

    /**
     * Retrieves the element specified by the css `selector` in the module
     * registered by `id`. For example, this.import('foo', 'img');
     * @param {string} id The id of the dom-module in which to search.
     * @param {string=} selector The css selector by which to find the element.
     * @return {Element} Returns the element which matches `selector` in the
     * module registered at the specified `id`.
     */
    static import(id, selector) {
      if (id) {
        let m = findModule(id);
        if (m && selector) {
          return m.querySelector(selector);
        }
        return m;
      }
      return null;
    }

    /* eslint-disable no-unused-vars */
    /**
     * @param {string} name Name of attribute.
     * @param {?string} old Old value of attribute.
     * @param {?string} value Current value of attribute.
     * @param {?string} namespace Attribute namespace.
     * @return {void}
     */
    attributeChangedCallback(name, old, value, namespace) {
      if (old !== value) {
        this.register();
      }
    }
    /* eslint-enable no-unused-args */

    /**
     * The absolute URL of the original location of this `dom-module`.
     *
     * This value will differ from this element's `ownerDocument` in the
     * following ways:
     * - Takes into account any `assetpath` attribute added during bundling
     *   to indicate the original location relative to the bundled location
     * - Uses the HTMLImports polyfill's `importForElement` API to ensure
     *   the path is relative to the import document's location since
     *   `ownerDocument` is not currently polyfilled
     */
    get assetpath() {
      // Don't override existing assetpath.
      if (!this.__assetpath) {
        // note: assetpath set via an attribute must be relative to this
        // element's location; accomodate polyfilled HTMLImports
        const owner = window.HTMLImports && HTMLImports.importForElement ?
          HTMLImports.importForElement(this) || document : this.ownerDocument;
        const url = Polymer.ResolveUrl.resolveUrl(
          this.getAttribute('assetpath') || '', owner.baseURI);
        this.__assetpath = Polymer.ResolveUrl.pathFromUrl(url);
      }
      return this.__assetpath;
    }

    /**
     * Registers the dom-module at a given id. This method should only be called
     * when a dom-module is imperatively created. For
     * example, `document.createElement('dom-module').register('foo')`.
     * @param {string=} id The id at which to register the dom-module.
     * @return {void}
     */
    register(id) {
      id = id || this.id;
      if (id) {
        // Under strictTemplatePolicy, reject and null out any re-registered
        // dom-module since it is ambiguous whether first-in or last-in is trusted 
        if (Polymer.strictTemplatePolicy && findModule(id) !== undefined) {
          setModule(id, null);
          throw new Error(`strictTemplatePolicy: dom-module ${id} re-registered`);
        }
        this.id = id;
        setModule(id, this);
        styleOutsideTemplateCheck(this);
      }
    }
  }

  DomModule.prototype['modules'] = modules;

  customElements.define('dom-module', DomModule);

  /** @const */
  Polymer.DomModule = DomModule;

})();


(function() {
  'use strict';

  /**
   * Module with utilities for manipulating structured data path strings.
   *
   * @namespace
   * @memberof Polymer
   * @summary Module with utilities for manipulating structured data path strings.
   */
  const Path = {

    /**
     * Returns true if the given string is a structured data path (has dots).
     *
     * Example:
     *
     * ```
     * Polymer.Path.isPath('foo.bar.baz') // true
     * Polymer.Path.isPath('foo')         // false
     * ```
     *
     * @memberof Polymer.Path
     * @param {string} path Path string
     * @return {boolean} True if the string contained one or more dots
     */
    isPath: function(path) {
      return path.indexOf('.') >= 0;
    },

    /**
     * Returns the root property name for the given path.
     *
     * Example:
     *
     * ```
     * Polymer.Path.root('foo.bar.baz') // 'foo'
     * Polymer.Path.root('foo')         // 'foo'
     * ```
     *
     * @memberof Polymer.Path
     * @param {string} path Path string
     * @return {string} Root property name
     */
    root: function(path) {
      let dotIndex = path.indexOf('.');
      if (dotIndex === -1) {
        return path;
      }
      return path.slice(0, dotIndex);
    },

    /**
     * Given `base` is `foo.bar`, `foo` is an ancestor, `foo.bar` is not
     * Returns true if the given path is an ancestor of the base path.
     *
     * Example:
     *
     * ```
     * Polymer.Path.isAncestor('foo.bar', 'foo')         // true
     * Polymer.Path.isAncestor('foo.bar', 'foo.bar')     // false
     * Polymer.Path.isAncestor('foo.bar', 'foo.bar.baz') // false
     * ```
     *
     * @memberof Polymer.Path
     * @param {string} base Path string to test against.
     * @param {string} path Path string to test.
     * @return {boolean} True if `path` is an ancestor of `base`.
     */
    isAncestor: function(base, path) {
      //     base.startsWith(path + '.');
      return base.indexOf(path + '.') === 0;
    },

    /**
     * Given `base` is `foo.bar`, `foo.bar.baz` is an descendant
     *
     * Example:
     *
     * ```
     * Polymer.Path.isDescendant('foo.bar', 'foo.bar.baz') // true
     * Polymer.Path.isDescendant('foo.bar', 'foo.bar')     // false
     * Polymer.Path.isDescendant('foo.bar', 'foo')         // false
     * ```
     *
     * @memberof Polymer.Path
     * @param {string} base Path string to test against.
     * @param {string} path Path string to test.
     * @return {boolean} True if `path` is a descendant of `base`.
     */
    isDescendant: function(base, path) {
      //     path.startsWith(base + '.');
      return path.indexOf(base + '.') === 0;
    },

    /**
     * Replaces a previous base path with a new base path, preserving the
     * remainder of the path.
     *
     * User must ensure `path` has a prefix of `base`.
     *
     * Example:
     *
     * ```
     * Polymer.Path.translate('foo.bar', 'zot', 'foo.bar.baz') // 'zot.baz'
     * ```
     *
     * @memberof Polymer.Path
     * @param {string} base Current base string to remove
     * @param {string} newBase New base string to replace with
     * @param {string} path Path to translate
     * @return {string} Translated string
     */
    translate: function(base, newBase, path) {
      return newBase + path.slice(base.length);
    },

    /**
     * @param {string} base Path string to test against
     * @param {string} path Path string to test
     * @return {boolean} True if `path` is equal to `base`
     * @this {Path}
     */
    matches: function(base, path) {
      return (base === path) ||
             this.isAncestor(base, path) ||
             this.isDescendant(base, path);
    },

    /**
     * Converts array-based paths to flattened path.  String-based paths
     * are returned as-is.
     *
     * Example:
     *
     * ```
     * Polymer.Path.normalize(['foo.bar', 0, 'baz'])  // 'foo.bar.0.baz'
     * Polymer.Path.normalize('foo.bar.0.baz')        // 'foo.bar.0.baz'
     * ```
     *
     * @memberof Polymer.Path
     * @param {string | !Array<string|number>} path Input path
     * @return {string} Flattened path
     */
    normalize: function(path) {
      if (Array.isArray(path)) {
        let parts = [];
        for (let i=0; i<path.length; i++) {
          let args = path[i].toString().split('.');
          for (let j=0; j<args.length; j++) {
            parts.push(args[j]);
          }
        }
        return parts.join('.');
      } else {
        return path;
      }
    },

    /**
     * Splits a path into an array of property names. Accepts either arrays
     * of path parts or strings.
     *
     * Example:
     *
     * ```
     * Polymer.Path.split(['foo.bar', 0, 'baz'])  // ['foo', 'bar', '0', 'baz']
     * Polymer.Path.split('foo.bar.0.baz')        // ['foo', 'bar', '0', 'baz']
     * ```
     *
     * @memberof Polymer.Path
     * @param {string | !Array<string|number>} path Input path
     * @return {!Array<string>} Array of path parts
     * @this {Path}
     * @suppress {checkTypes}
     */
    split: function(path) {
      if (Array.isArray(path)) {
        return this.normalize(path).split('.');
      }
      return path.toString().split('.');
    },

    /**
     * Reads a value from a path.  If any sub-property in the path is `undefined`,
     * this method returns `undefined` (will never throw.
     *
     * @memberof Polymer.Path
     * @param {Object} root Object from which to dereference path from
     * @param {string | !Array<string|number>} path Path to read
     * @param {Object=} info If an object is provided to `info`, the normalized
     *  (flattened) path will be set to `info.path`.
     * @return {*} Value at path, or `undefined` if the path could not be
     *  fully dereferenced.
     * @this {Path}
     */
    get: function(root, path, info) {
      let prop = root;
      let parts = this.split(path);
      // Loop over path parts[0..n-1] and dereference
      for (let i=0; i<parts.length; i++) {
        if (!prop) {
          return;
        }
        let part = parts[i];
        prop = prop[part];
      }
      if (info) {
        info.path = parts.join('.');
      }
      return prop;
    },

    /**
     * Sets a value to a path.  If any sub-property in the path is `undefined`,
     * this method will no-op.
     *
     * @memberof Polymer.Path
     * @param {Object} root Object from which to dereference path from
     * @param {string | !Array<string|number>} path Path to set
     * @param {*} value Value to set to path
     * @return {string | undefined} The normalized version of the input path
     * @this {Path}
     */
    set: function(root, path, value) {
      let prop = root;
      let parts = this.split(path);
      let last = parts[parts.length-1];
      if (parts.length > 1) {
        // Loop over path parts[0..n-2] and dereference
        for (let i=0; i<parts.length-1; i++) {
          let part = parts[i];
          prop = prop[part];
          if (!prop) {
            return;
          }
        }
        // Set value to object at end of path
        prop[last] = value;
      } else {
        // Simple property set
        prop[path] = value;
      }
      return parts.join('.');
    }

  };

  /**
   * Returns true if the given string is a structured data path (has dots).
   *
   * This function is deprecated.  Use `Polymer.Path.isPath` instead.
   *
   * Example:
   *
   * ```
   * Polymer.Path.isDeep('foo.bar.baz') // true
   * Polymer.Path.isDeep('foo')         // false
   * ```
   *
   * @deprecated
   * @memberof Polymer.Path
   * @param {string} path Path string
   * @return {boolean} True if the string contained one or more dots
   */
  Path.isDeep = Path.isPath;

  Polymer.Path = Path;

})();


(function() {
  'use strict';

  const caseMap = {};
  const DASH_TO_CAMEL = /-[a-z]/g;
  const CAMEL_TO_DASH = /([A-Z])/g;

  /**
   * Module with utilities for converting between "dash-case" and "camelCase"
   * identifiers.
   *
   * @namespace
   * @memberof Polymer
   * @summary Module that provides utilities for converting between "dash-case"
   *   and "camelCase".
   */
  const CaseMap = {

    /**
     * Converts "dash-case" identifier (e.g. `foo-bar-baz`) to "camelCase"
     * (e.g. `fooBarBaz`).
     *
     * @memberof Polymer.CaseMap
     * @param {string} dash Dash-case identifier
     * @return {string} Camel-case representation of the identifier
     */
    dashToCamelCase(dash) {
      return caseMap[dash] || (
        caseMap[dash] = dash.indexOf('-') < 0 ? dash : dash.replace(DASH_TO_CAMEL,
          (m) => m[1].toUpperCase()
        )
      );
    },

    /**
     * Converts "camelCase" identifier (e.g. `fooBarBaz`) to "dash-case"
     * (e.g. `foo-bar-baz`).
     *
     * @memberof Polymer.CaseMap
     * @param {string} camel Camel-case identifier
     * @return {string} Dash-case representation of the identifier
     */
    camelToDashCase(camel) {
      return caseMap[camel] || (
        caseMap[camel] = camel.replace(CAMEL_TO_DASH, '-$1').toLowerCase()
      );
    }

  };

  Polymer.CaseMap = CaseMap;
})();


(function() {

  'use strict';

  // Microtask implemented using Mutation Observer
  let microtaskCurrHandle = 0;
  let microtaskLastHandle = 0;
  let microtaskCallbacks = [];
  let microtaskNodeContent = 0;
  let microtaskNode = document.createTextNode('');
  new window.MutationObserver(microtaskFlush).observe(microtaskNode, {characterData: true});

  function microtaskFlush() {
    const len = microtaskCallbacks.length;
    for (let i = 0; i < len; i++) {
      let cb = microtaskCallbacks[i];
      if (cb) {
        try {
          cb();
        } catch (e) {
          setTimeout(() => { throw e; });
        }
      }
    }
    microtaskCallbacks.splice(0, len);
    microtaskLastHandle += len;
  }

  /**
   * Module that provides a number of strategies for enqueuing asynchronous
   * tasks.  Each sub-module provides a standard `run(fn)` interface that returns a
   * handle, and a `cancel(handle)` interface for canceling async tasks before
   * they run.
   *
   * @namespace
   * @memberof Polymer
   * @summary Module that provides a number of strategies for enqueuing asynchronous
   * tasks.
   */
  Polymer.Async = {

    /**
     * Async interface wrapper around `setTimeout`.
     *
     * @namespace
     * @memberof Polymer.Async
     * @summary Async interface wrapper around `setTimeout`.
     */
    timeOut: {
      /**
       * Returns a sub-module with the async interface providing the provided
       * delay.
       *
       * @memberof Polymer.Async.timeOut
       * @param {number=} delay Time to wait before calling callbacks in ms
       * @return {!AsyncInterface} An async timeout interface
       */
      after(delay) {
        return {
          run(fn) { return window.setTimeout(fn, delay); },
          cancel(handle) {
            window.clearTimeout(handle);
          }
        };
      },
      /**
       * Enqueues a function called in the next task.
       *
       * @memberof Polymer.Async.timeOut
       * @param {!Function} fn Callback to run
       * @param {number=} delay Delay in milliseconds
       * @return {number} Handle used for canceling task
       */
      run(fn, delay) {
        return window.setTimeout(fn, delay);
      },
      /**
       * Cancels a previously enqueued `timeOut` callback.
       *
       * @memberof Polymer.Async.timeOut
       * @param {number} handle Handle returned from `run` of callback to cancel
       * @return {void}
       */
      cancel(handle) {
        window.clearTimeout(handle);
      }
    },

    /**
     * Async interface wrapper around `requestAnimationFrame`.
     *
     * @namespace
     * @memberof Polymer.Async
     * @summary Async interface wrapper around `requestAnimationFrame`.
     */
    animationFrame: {
      /**
       * Enqueues a function called at `requestAnimationFrame` timing.
       *
       * @memberof Polymer.Async.animationFrame
       * @param {function(number):void} fn Callback to run
       * @return {number} Handle used for canceling task
       */
      run(fn) {
        return window.requestAnimationFrame(fn);
      },
      /**
       * Cancels a previously enqueued `animationFrame` callback.
       *
       * @memberof Polymer.Async.animationFrame
       * @param {number} handle Handle returned from `run` of callback to cancel
       * @return {void}
       */
      cancel(handle) {
        window.cancelAnimationFrame(handle);
      }
    },

    /**
     * Async interface wrapper around `requestIdleCallback`.  Falls back to
     * `setTimeout` on browsers that do not support `requestIdleCallback`.
     *
     * @namespace
     * @memberof Polymer.Async
     * @summary Async interface wrapper around `requestIdleCallback`.
     */
    idlePeriod: {
      /**
       * Enqueues a function called at `requestIdleCallback` timing.
       *
       * @memberof Polymer.Async.idlePeriod
       * @param {function(!IdleDeadline):void} fn Callback to run
       * @return {number} Handle used for canceling task
       */
      run(fn) {
        return window.requestIdleCallback ?
          window.requestIdleCallback(fn) :
          window.setTimeout(fn, 16);
      },
      /**
       * Cancels a previously enqueued `idlePeriod` callback.
       *
       * @memberof Polymer.Async.idlePeriod
       * @param {number} handle Handle returned from `run` of callback to cancel
       * @return {void}
       */
      cancel(handle) {
        window.cancelIdleCallback ?
          window.cancelIdleCallback(handle) :
          window.clearTimeout(handle);
      }
    },

    /**
     * Async interface for enqueuing callbacks that run at microtask timing.
     *
     * Note that microtask timing is achieved via a single `MutationObserver`,
     * and thus callbacks enqueued with this API will all run in a single
     * batch, and not interleaved with other microtasks such as promises.
     * Promises are avoided as an implementation choice for the time being
     * due to Safari bugs that cause Promises to lack microtask guarantees.
     *
     * @namespace
     * @memberof Polymer.Async
     * @summary Async interface for enqueuing callbacks that run at microtask
     *   timing.
     */
    microTask: {

      /**
       * Enqueues a function called at microtask timing.
       *
       * @memberof Polymer.Async.microTask
       * @param {!Function=} callback Callback to run
       * @return {number} Handle used for canceling task
       */
      run(callback) {
        microtaskNode.textContent = microtaskNodeContent++;
        microtaskCallbacks.push(callback);
        return microtaskCurrHandle++;
      },

      /**
       * Cancels a previously enqueued `microTask` callback.
       *
       * @memberof Polymer.Async.microTask
       * @param {number} handle Handle returned from `run` of callback to cancel
       * @return {void}
       */
      cancel(handle) {
        const idx = handle - microtaskLastHandle;
        if (idx >= 0) {
          if (!microtaskCallbacks[idx]) {
            throw new Error('invalid async handle: ' + handle);
          }
          microtaskCallbacks[idx] = null;
        }
      }

    }
  };

})();


  (function () {

    'use strict';

    /** @const {!AsyncInterface} */
    const microtask = Polymer.Async.microTask;

    /**
     * Element class mixin that provides basic meta-programming for creating one
     * or more property accessors (getter/setter pair) that enqueue an async
     * (batched) `_propertiesChanged` callback.
     *
     * For basic usage of this mixin, call `MyClass.createProperties(props)`
     * once at class definition time to create property accessors for properties
     * named in props, implement `_propertiesChanged` to react as desired to
     * property changes, and implement `static get observedAttributes()` and
     * include lowercase versions of any property names that should be set from
     * attributes. Last, call `this._enableProperties()` in the element's
     * `connectedCallback` to enable the accessors.
     *
     * @mixinFunction
     * @polymer
     * @memberof Polymer
     * @summary Element class mixin for reacting to property changes from
     *   generated property accessors.
     */
    Polymer.PropertiesChanged = Polymer.dedupingMixin(superClass => {

      /**
       * @polymer
       * @mixinClass
       * @extends {superClass}
       * @implements {Polymer_PropertiesChanged}
       * @unrestricted
       */
      class PropertiesChanged extends superClass {

        /**
         * Creates property accessors for the given property names.
         * @param {!Object} props Object whose keys are names of accessors.
         * @return {void}
         * @protected
         */
        static createProperties(props) {
          const proto = this.prototype;
          for (let prop in props) {
            // don't stomp an existing accessor
            if (!(prop in proto)) {
              proto._createPropertyAccessor(prop);
            }
          }
        }

        /**
         * Returns an attribute name that corresponds to the given property.
         * The attribute name is the lowercased property name. Override to
         * customize this mapping.
         * @param {string} property Property to convert
         * @return {string} Attribute name corresponding to the given property.
         *
         * @protected
         */
        static attributeNameForProperty(property) {
          return property.toLowerCase();
        }

        /**
         * Override point to provide a type to which to deserialize a value to
         * a given property.
         * @param {string} name Name of property
         *
         * @protected
         */
        static typeForProperty(name) { } //eslint-disable-line no-unused-vars

        /**
         * Creates a setter/getter pair for the named property with its own
         * local storage.  The getter returns the value in the local storage,
         * and the setter calls `_setProperty`, which updates the local storage
         * for the property and enqueues a `_propertiesChanged` callback.
         *
         * This method may be called on a prototype or an instance.  Calling
         * this method may overwrite a property value that already exists on
         * the prototype/instance by creating the accessor.
         *
         * @param {string} property Name of the property
         * @param {boolean=} readOnly When true, no setter is created; the
         *   protected `_setProperty` function must be used to set the property
         * @return {void}
         * @protected
         */
        _createPropertyAccessor(property, readOnly) {
          this._addPropertyToAttributeMap(property);
          if (!this.hasOwnProperty('__dataHasAccessor')) {
            this.__dataHasAccessor = Object.assign({}, this.__dataHasAccessor);
          }
          if (!this.__dataHasAccessor[property]) {
            this.__dataHasAccessor[property] = true;
            this._definePropertyAccessor(property, readOnly);
          }
        }

        /**
         * Adds the given `property` to a map matching attribute names
         * to property names, using `attributeNameForProperty`. This map is
         * used when deserializing attribute values to properties.
         *
         * @param {string} property Name of the property
         */
        _addPropertyToAttributeMap(property) {
          if (!this.hasOwnProperty('__dataAttributes')) {
            this.__dataAttributes = Object.assign({}, this.__dataAttributes);
          }
          if (!this.__dataAttributes[property]) {
            const attr = this.constructor.attributeNameForProperty(property);
            this.__dataAttributes[attr] = property;
          }
        }

        /**
         * Defines a property accessor for the given property.
         * @param {string} property Name of the property
         * @param {boolean=} readOnly When true, no setter is created
         * @return {void}
         */
         _definePropertyAccessor(property, readOnly) {
          Object.defineProperty(this, property, {
            /* eslint-disable valid-jsdoc */
            /** @this {PropertiesChanged} */
            get() {
              return this._getProperty(property);
            },
            /** @this {PropertiesChanged} */
            set: readOnly ? function () {} : function (value) {
              this._setProperty(property, value);
            }
            /* eslint-enable */
          });
        }

        constructor() {
          super();
          this.__dataEnabled = false;
          this.__dataReady = false;
          this.__dataInvalid = false;
          this.__data = {};
          this.__dataPending = null;
          this.__dataOld = null;
          this.__dataInstanceProps = null;
          this.__serializing = false;
          this._initializeProperties();
        }

        /**
         * Lifecycle callback called when properties are enabled via
         * `_enableProperties`.
         *
         * Users may override this function to implement behavior that is
         * dependent on the element having its property data initialized, e.g.
         * from defaults (initialized from `constructor`, `_initializeProperties`),
         * `attributeChangedCallback`, or values propagated from host e.g. via
         * bindings.  `super.ready()` must be called to ensure the data system
         * becomes enabled.
         *
         * @return {void}
         * @public
         */
        ready() {
          this.__dataReady = true;
          this._flushProperties();
        }

        /**
         * Initializes the local storage for property accessors.
         *
         * Provided as an override point for performing any setup work prior
         * to initializing the property accessor system.
         *
         * @return {void}
         * @protected
         */
        _initializeProperties() {
          // Capture instance properties; these will be set into accessors
          // during first flush. Don't set them here, since we want
          // these to overwrite defaults/constructor assignments
          for (let p in this.__dataHasAccessor) {
            if (this.hasOwnProperty(p)) {
              this.__dataInstanceProps = this.__dataInstanceProps || {};
              this.__dataInstanceProps[p] = this[p];
              delete this[p];
            }
          }
        }

        /**
         * Called at ready time with bag of instance properties that overwrote
         * accessors when the element upgraded.
         *
         * The default implementation sets these properties back into the
         * setter at ready time.  This method is provided as an override
         * point for customizing or providing more efficient initialization.
         *
         * @param {Object} props Bag of property values that were overwritten
         *   when creating property accessors.
         * @return {void}
         * @protected
         */
        _initializeInstanceProperties(props) {
          Object.assign(this, props);
        }

        /**
         * Updates the local storage for a property (via `_setPendingProperty`)
         * and enqueues a `_proeprtiesChanged` callback.
         *
         * @param {string} property Name of the property
         * @param {*} value Value to set
         * @return {void}
         * @protected
         */
        _setProperty(property, value) {
          if (this._setPendingProperty(property, value)) {
            this._invalidateProperties();
          }
        }

        /**
         * Returns the value for the given property.
         * @param {string} property Name of property
         * @return {*} Value for the given property
         * @protected
         */
        _getProperty(property) {
          return this.__data[property];
        }

        /* eslint-disable no-unused-vars */
        /**
         * Updates the local storage for a property, records the previous value,
         * and adds it to the set of "pending changes" that will be passed to the
         * `_propertiesChanged` callback.  This method does not enqueue the
         * `_propertiesChanged` callback.
         *
         * @param {string} property Name of the property
         * @param {*} value Value to set
         * @param {boolean=} ext Not used here; affordance for closure
         * @return {boolean} Returns true if the property changed
         * @protected
         */
        _setPendingProperty(property, value, ext) {
          let old = this.__data[property];
          let changed = this._shouldPropertyChange(property, value, old);
          if (changed) {
            if (!this.__dataPending) {
              this.__dataPending = {};
              this.__dataOld = {};
            }
            // Ensure old is captured from the last turn
            if (this.__dataOld && !(property in this.__dataOld)) {
              this.__dataOld[property] = old;
            }
            this.__data[property] = value;
            this.__dataPending[property] = value;
          }
          return changed;
        }
        /* eslint-enable */

        /**
         * Marks the properties as invalid, and enqueues an async
         * `_propertiesChanged` callback.
         *
         * @return {void}
         * @protected
         */
        _invalidateProperties() {
          if (!this.__dataInvalid && this.__dataReady) {
            this.__dataInvalid = true;
            microtask.run(() => {
              if (this.__dataInvalid) {
                this.__dataInvalid = false;
                this._flushProperties();
              }
            });
          }
        }

        /**
         * Call to enable property accessor processing. Before this method is
         * called accessor values will be set but side effects are
         * queued. When called, any pending side effects occur immediately.
         * For elements, generally `connectedCallback` is a normal spot to do so.
         * It is safe to call this method multiple times as it only turns on
         * property accessors once.
         *
         * @return {void}
         * @protected
         */
        _enableProperties() {
          if (!this.__dataEnabled) {
            this.__dataEnabled = true;
            if (this.__dataInstanceProps) {
              this._initializeInstanceProperties(this.__dataInstanceProps);
              this.__dataInstanceProps = null;
            }
            this.ready();
          }
        }

        /**
         * Calls the `_propertiesChanged` callback with the current set of
         * pending changes (and old values recorded when pending changes were
         * set), and resets the pending set of changes. Generally, this method
         * should not be called in user code.
         *
         * @return {void}
         * @protected
         */
        _flushProperties() {
          const props = this.__data;
          const changedProps = this.__dataPending;
          const old = this.__dataOld;
          if (this._shouldPropertiesChange(props, changedProps, old)) {
            this.__dataPending = null;
            this.__dataOld = null;
            this._propertiesChanged(props, changedProps, old);
          }
        }

        /**
         * Called in `_flushProperties` to determine if `_propertiesChanged`
         * should be called. The default implementation returns true if
         * properties are pending. Override to customize when
         * `_propertiesChanged` is called.
         * @param {!Object} currentProps Bag of all current accessor values
         * @param {!Object} changedProps Bag of properties changed since the last
         *   call to `_propertiesChanged`
         * @param {!Object} oldProps Bag of previous values for each property
         *   in `changedProps`
         * @return {boolean} true if changedProps is truthy
         */
        _shouldPropertiesChange(currentProps, changedProps, oldProps) { // eslint-disable-line no-unused-vars
          return Boolean(changedProps);
        }

        /**
         * Callback called when any properties with accessors created via
         * `_createPropertyAccessor` have been set.
         *
         * @param {!Object} currentProps Bag of all current accessor values
         * @param {!Object} changedProps Bag of properties changed since the last
         *   call to `_propertiesChanged`
         * @param {!Object} oldProps Bag of previous values for each property
         *   in `changedProps`
         * @return {void}
         * @protected
         */
        _propertiesChanged(currentProps, changedProps, oldProps) { // eslint-disable-line no-unused-vars
        }

        /**
         * Method called to determine whether a property value should be
         * considered as a change and cause the `_propertiesChanged` callback
         * to be enqueued.
         *
         * The default implementation returns `true` if a strict equality
         * check fails. The method always returns false for `NaN`.
         *
         * Override this method to e.g. provide stricter checking for
         * Objects/Arrays when using immutable patterns.
         *
         * @param {string} property Property name
         * @param {*} value New property value
         * @param {*} old Previous property value
         * @return {boolean} Whether the property should be considered a change
         *   and enqueue a `_proeprtiesChanged` callback
         * @protected
         */
        _shouldPropertyChange(property, value, old) {
          return (
            // Strict equality check
            (old !== value &&
              // This ensures (old==NaN, value==NaN) always returns false
              (old === old || value === value))
          );
        }

        /**
         * Implements native Custom Elements `attributeChangedCallback` to
         * set an attribute value to a property via `_attributeToProperty`.
         *
         * @param {string} name Name of attribute that changed
         * @param {?string} old Old attribute value
         * @param {?string} value New attribute value
         * @param {?string} namespace Attribute namespace.
         * @return {void}
         * @suppress {missingProperties} Super may or may not implement the callback
         */
        attributeChangedCallback(name, old, value, namespace) {
          if (old !== value) {
            this._attributeToProperty(name, value);
          }
          if (super.attributeChangedCallback) {
            super.attributeChangedCallback(name, old, value, namespace);
          }
        }

        /**
         * Deserializes an attribute to its associated property.
         *
         * This method calls the `_deserializeValue` method to convert the string to
         * a typed value.
         *
         * @param {string} attribute Name of attribute to deserialize.
         * @param {?string} value of the attribute.
         * @param {*=} type type to deserialize to, defaults to the value
         * returned from `typeForProperty`
         * @return {void}
         */
        _attributeToProperty(attribute, value, type) {
          if (!this.__serializing) {
            const map = this.__dataAttributes;
            const property = map && map[attribute] || attribute;
            this[property] = this._deserializeValue(value, type ||
              this.constructor.typeForProperty(property));
          }
        }

        /**
         * Serializes a property to its associated attribute.
         *
         * @suppress {invalidCasts} Closure can't figure out `this` is an element.
         *
         * @param {string} property Property name to reflect.
         * @param {string=} attribute Attribute name to reflect to.
         * @param {*=} value Property value to refect.
         * @return {void}
         */
        _propertyToAttribute(property, attribute, value) {
          this.__serializing = true;
          value = (arguments.length < 3) ? this[property] : value;
          this._valueToNodeAttribute(/** @type {!HTMLElement} */(this), value,
            attribute || this.constructor.attributeNameForProperty(property));
          this.__serializing = false;
        }

        /**
         * Sets a typed value to an HTML attribute on a node.
         *
         * This method calls the `_serializeValue` method to convert the typed
         * value to a string.  If the `_serializeValue` method returns `undefined`,
         * the attribute will be removed (this is the default for boolean
         * type `false`).
         *
         * @param {Element} node Element to set attribute to.
         * @param {*} value Value to serialize.
         * @param {string} attribute Attribute name to serialize to.
         * @return {void}
         */
        _valueToNodeAttribute(node, value, attribute) {
          const str = this._serializeValue(value);
          if (str === undefined) {
            node.removeAttribute(attribute);
          } else {
            node.setAttribute(attribute, str);
          }
        }

        /**
         * Converts a typed JavaScript value to a string.
         *
         * This method is called when setting JS property values to
         * HTML attributes.  Users may override this method to provide
         * serialization for custom types.
         *
         * @param {*} value Property value to serialize.
         * @return {string | undefined} String serialized from the provided
         * property  value.
         */
        _serializeValue(value) {
          switch (typeof value) {
            case 'boolean':
              return value ? '' : undefined;
            default:
              return value != null ? value.toString() : undefined;
          }
        }

        /**
         * Converts a string to a typed JavaScript value.
         *
         * This method is called when reading HTML attribute values to
         * JS properties.  Users may override this method to provide
         * deserialization for custom `type`s. Types for `Boolean`, `String`,
         * and `Number` convert attributes to the expected types.
         *
         * @param {?string} value Value to deserialize.
         * @param {*=} type Type to deserialize the string to.
         * @return {*} Typed value deserialized from the provided string.
         */
        _deserializeValue(value, type) {
          switch (type) {
            case Boolean:
              return (value !== null);
            case Number:
              return Number(value);
            default:
              return value;
          }
        }

      }

      return PropertiesChanged;
    });


  })();



(function() {

  'use strict';

  let caseMap = Polymer.CaseMap;

  // Save map of native properties; this forms a blacklist or properties
  // that won't have their values "saved" by `saveAccessorValue`, since
  // reading from an HTMLElement accessor from the context of a prototype throws
  const nativeProperties = {};
  let proto = HTMLElement.prototype;
  while (proto) {
    let props = Object.getOwnPropertyNames(proto);
    for (let i=0; i<props.length; i++) {
      nativeProperties[props[i]] = true;
    }
    proto = Object.getPrototypeOf(proto);
  }

  /**
   * Used to save the value of a property that will be overridden with
   * an accessor. If the `model` is a prototype, the values will be saved
   * in `__dataProto`, and it's up to the user (or downstream mixin) to
   * decide how/when to set these values back into the accessors.
   * If `model` is already an instance (it has a `__data` property), then
   * the value will be set as a pending property, meaning the user should
   * call `_invalidateProperties` or `_flushProperties` to take effect
   *
   * @param {Object} model Prototype or instance
   * @param {string} property Name of property
   * @return {void}
   * @private
   */
  function saveAccessorValue(model, property) {
    // Don't read/store value for any native properties since they could throw
    if (!nativeProperties[property]) {
      let value = model[property];
      if (value !== undefined) {
        if (model.__data) {
          // Adding accessor to instance; update the property
          // It is the user's responsibility to call _flushProperties
          model._setPendingProperty(property, value);
        } else {
          // Adding accessor to proto; save proto's value for instance-time use
          if (!model.__dataProto) {
            model.__dataProto = {};
          } else if (!model.hasOwnProperty(JSCompiler_renameProperty('__dataProto', model))) {
            model.__dataProto = Object.create(model.__dataProto);
          }
          model.__dataProto[property] = value;
        }
      }
    }
  }

  /**
   * Element class mixin that provides basic meta-programming for creating one
   * or more property accessors (getter/setter pair) that enqueue an async
   * (batched) `_propertiesChanged` callback.
   *
   * For basic usage of this mixin:
   * 
   * -   Declare attributes to observe via the standard `static get observedAttributes()`. Use
   *     `dash-case` attribute names to represent `camelCase` property names. 
   * -   Implement the `_propertiesChanged` callback on the class.
   * -   Call `MyClass.createPropertiesForAttributes()` **once** on the class to generate 
   *     property accessors for each observed attribute. This must be called before the first 
   *     instance is created, for example, by calling it before calling `customElements.define`.
   *     It can also be called lazily from the element's `constructor`, as long as it's guarded so
   *     that the call is only made once, when the first instance is created.
   * -   Call `this._enableProperties()` in the element's `connectedCallback` to enable 
   *     the accessors.
   *
   * Any `observedAttributes` will automatically be
   * deserialized via `attributeChangedCallback` and set to the associated
   * property using `dash-case`-to-`camelCase` convention.
   *
   * @mixinFunction
   * @polymer
   * @appliesMixin Polymer.PropertiesChanged
   * @memberof Polymer
   * @summary Element class mixin for reacting to property changes from
   *   generated property accessors.
   */
  Polymer.PropertyAccessors = Polymer.dedupingMixin(superClass => {

    /**
     * @constructor
     * @extends {superClass}
     * @implements {Polymer_PropertiesChanged}
     * @unrestricted
     * @private
     */
     const base = Polymer.PropertiesChanged(superClass);

    /**
     * @polymer
     * @mixinClass
     * @implements {Polymer_PropertyAccessors}
     * @extends {base}
     * @unrestricted
     */
    class PropertyAccessors extends base {

      /**
       * Generates property accessors for all attributes in the standard
       * static `observedAttributes` array.
       *
       * Attribute names are mapped to property names using the `dash-case` to
       * `camelCase` convention
       *
       * @return {void}
       */
      static createPropertiesForAttributes() {
        let a$ = this.observedAttributes;
        for (let i=0; i < a$.length; i++) {
          this.prototype._createPropertyAccessor(caseMap.dashToCamelCase(a$[i]));
        }
      }

      /**
       * Returns an attribute name that corresponds to the given property.
       * By default, converts camel to dash case, e.g. `fooBar` to `foo-bar`.
       * @param {string} property Property to convert
       * @return {string} Attribute name corresponding to the given property.
       *
       * @protected
       */
      static attributeNameForProperty(property) {
        return caseMap.camelToDashCase(property);
      }

      /**
       * Overrides PropertiesChanged implementation to initialize values for
       * accessors created for values that already existed on the element
       * prototype.
       *
       * @return {void}
       * @protected
       */
      _initializeProperties() {
        if (this.__dataProto) {
          this._initializeProtoProperties(this.__dataProto);
          this.__dataProto = null;
        }
        super._initializeProperties();
      }

      /**
       * Called at instance time with bag of properties that were overwritten
       * by accessors on the prototype when accessors were created.
       *
       * The default implementation sets these properties back into the
       * setter at instance time.  This method is provided as an override
       * point for customizing or providing more efficient initialization.
       *
       * @param {Object} props Bag of property values that were overwritten
       *   when creating property accessors.
       * @return {void}
       * @protected
       */
      _initializeProtoProperties(props) {
        for (let p in props) {
          this._setProperty(p, props[p]);
        }
      }

      /**
       * Ensures the element has the given attribute. If it does not,
       * assigns the given value to the attribute.
       *
       * @suppress {invalidCasts} Closure can't figure out `this` is infact an element
       *
       * @param {string} attribute Name of attribute to ensure is set.
       * @param {string} value of the attribute.
       * @return {void}
       */
      _ensureAttribute(attribute, value) {
        const el = /** @type {!HTMLElement} */(this);
        if (!el.hasAttribute(attribute)) {
          this._valueToNodeAttribute(el, value, attribute);
        }
      }

      /**
       * Overrides PropertiesChanged implemention to serialize objects as JSON.
       *
       * @param {*} value Property value to serialize.
       * @return {string | undefined} String serialized from the provided property value.
       */
      _serializeValue(value) {
        /* eslint-disable no-fallthrough */
        switch (typeof value) {
          case 'object':
            if (value instanceof Date) {
              return value.toString();
            } else if (value) {
              try {
                return JSON.stringify(value);
              } catch(x) {
                return '';
              }
            }

          default:
            return super._serializeValue(value);
        }
      }

      /**
       * Converts a string to a typed JavaScript value.
       *
       * This method is called by Polymer when reading HTML attribute values to
       * JS properties.  Users may override this method on Polymer element
       * prototypes to provide deserialization for custom `type`s.  Note,
       * the `type` argument is the value of the `type` field provided in the
       * `properties` configuration object for a given property, and is
       * by convention the constructor for the type to deserialize.
       *
       *
       * @param {?string} value Attribute value to deserialize.
       * @param {*=} type Type to deserialize the string to.
       * @return {*} Typed value deserialized from the provided string.
       */
      _deserializeValue(value, type) {
        /**
         * @type {*}
         */
        let outValue;
        switch (type) {
          case Object:
            try {
              outValue = JSON.parse(/** @type {string} */(value));
            } catch(x) {
              // allow non-JSON literals like Strings and Numbers
              outValue = value;
            }
            break;
          case Array:
            try {
              outValue = JSON.parse(/** @type {string} */(value));
            } catch(x) {
              outValue = null;
              console.warn(`Polymer::Attributes: couldn't decode Array as JSON: ${value}`);
            }
            break;
          case Date:
            outValue = isNaN(value) ? String(value) : Number(value);
            outValue = new Date(outValue);
            break;
          default:
            outValue = super._deserializeValue(value, type);
            break;
        }
        return outValue;
      }
      /* eslint-enable no-fallthrough */

      /**
       * Overrides PropertiesChanged implementation to save existing prototype
       * property value so that it can be reset.
       * @param {string} property Name of the property
       * @param {boolean=} readOnly When true, no setter is created
       *
       * When calling on a prototype, any overwritten values are saved in
       * `__dataProto`, and it is up to the subclasser to decide how/when
       * to set those properties back into the accessor.  When calling on an
       * instance, the overwritten value is set via `_setPendingProperty`,
       * and the user should call `_invalidateProperties` or `_flushProperties`
       * for the values to take effect.
       * @protected
       * @return {void}
       */
      _definePropertyAccessor(property, readOnly) {
        saveAccessorValue(this, property);
        super._definePropertyAccessor(property, readOnly);
      }

      /**
       * Returns true if this library created an accessor for the given property.
       *
       * @param {string} property Property name
       * @return {boolean} True if an accessor was created
       */
      _hasAccessor(property) {
        return this.__dataHasAccessor && this.__dataHasAccessor[property];
      }

      /**
       * Returns true if the specified property has a pending change.
       *
       * @param {string} prop Property name
       * @return {boolean} True if property has a pending change
       * @protected
       */
      _isPropertyPending(prop) {
        return Boolean(this.__dataPending && (prop in this.__dataPending));
      }

    }

    return PropertyAccessors;

  });

})();


(function() {

  'use strict';

  const walker = document.createTreeWalker(document, NodeFilter.SHOW_ALL,
      null, false);

  // 1.x backwards-compatible auto-wrapper for template type extensions
  // This is a clear layering violation and gives favored-nation status to
  // dom-if and dom-repeat templates.  This is a conceit we're choosing to keep
  // a.) to ease 1.x backwards-compatibility due to loss of `is`, and
  // b.) to maintain if/repeat capability in parser-constrained elements
  //     (e.g. table, select) in lieu of native CE type extensions without
  //     massive new invention in this space (e.g. directive system)
  const templateExtensions = {
    'dom-if': true,
    'dom-repeat': true
  };
  function wrapTemplateExtension(node) {
    let is = node.getAttribute('is');
    if (is && templateExtensions[is]) {
      let t = node;
      t.removeAttribute('is');
      node = t.ownerDocument.createElement(is);
      t.parentNode.replaceChild(node, t);
      node.appendChild(t);
      while(t.attributes.length) {
        node.setAttribute(t.attributes[0].name, t.attributes[0].value);
        t.removeAttribute(t.attributes[0].name);
      }
    }
    return node;
  }

  function findTemplateNode(root, nodeInfo) {
    // recursively ascend tree until we hit root
    let parent = nodeInfo.parentInfo && findTemplateNode(root, nodeInfo.parentInfo);
    // unwind the stack, returning the indexed node at each level
    if (parent) {
      // note: marginally faster than indexing via childNodes
      // (http://jsperf.com/childnodes-lookup)
      walker.currentNode = parent;
      for (let n=walker.firstChild(), i=0; n; n=walker.nextSibling()) {
        if (nodeInfo.parentIndex === i++) {
          return n;
        }
      }
    } else {
      return root;
    }
  }

  // construct `$` map (from id annotations)
  function applyIdToMap(inst, map, node, nodeInfo) {
    if (nodeInfo.id) {
      map[nodeInfo.id] = node;
    }
  }

  // install event listeners (from event annotations)
  function applyEventListener(inst, node, nodeInfo) {
    if (nodeInfo.events && nodeInfo.events.length) {
      for (let j=0, e$=nodeInfo.events, e; (j<e$.length) && (e=e$[j]); j++) {
        inst._addMethodEventListenerToNode(node, e.name, e.value, inst);
      }
    }
  }

  // push configuration references at configure time
  function applyTemplateContent(inst, node, nodeInfo) {
    if (nodeInfo.templateInfo) {
      node._templateInfo = nodeInfo.templateInfo;
    }
  }

  function createNodeEventHandler(context, eventName, methodName) {
    // Instances can optionally have a _methodHost which allows redirecting where
    // to find methods. Currently used by `templatize`.
    context = context._methodHost || context;
    let handler = function(e) {
      if (context[methodName]) {
        context[methodName](e, e.detail);
      } else {
        console.warn('listener method `' + methodName + '` not defined');
      }
    };
    return handler;
  }

  /**
   * Element mixin that provides basic template parsing and stamping, including
   * the following template-related features for stamped templates:
   *
   * - Declarative event listeners (`on-eventname="listener"`)
   * - Map of node id's to stamped node instances (`this.$.id`)
   * - Nested template content caching/removal and re-installation (performance
   *   optimization)
   *
   * @mixinFunction
   * @polymer
   * @memberof Polymer
   * @summary Element class mixin that provides basic template parsing and stamping
   */
  Polymer.TemplateStamp = Polymer.dedupingMixin(superClass => {

    /**
     * @polymer
     * @mixinClass
     * @implements {Polymer_TemplateStamp}
     */
    class TemplateStamp extends superClass {

      /**
       * Scans a template to produce template metadata.
       *
       * Template-specific metadata are stored in the object returned, and node-
       * specific metadata are stored in objects in its flattened `nodeInfoList`
       * array.  Only nodes in the template that were parsed as nodes of
       * interest contain an object in `nodeInfoList`.  Each `nodeInfo` object
       * contains an `index` (`childNodes` index in parent) and optionally
       * `parent`, which points to node info of its parent (including its index).
       *
       * The template metadata object returned from this method has the following
       * structure (many fields optional):
       *
       * ```js
       *   {
       *     // Flattened list of node metadata (for nodes that generated metadata)
       *     nodeInfoList: [
       *       {
       *         // `id` attribute for any nodes with id's for generating `$` map
       *         id: {string},
       *         // `on-event="handler"` metadata
       *         events: [
       *           {
       *             name: {string},   // event name
       *             value: {string},  // handler method name
       *           }, ...
       *         ],
       *         // Notes when the template contained a `<slot>` for shady DOM
       *         // optimization purposes
       *         hasInsertionPoint: {boolean},
       *         // For nested `<template>`` nodes, nested template metadata
       *         templateInfo: {object}, // nested template metadata
       *         // Metadata to allow efficient retrieval of instanced node
       *         // corresponding to this metadata
       *         parentInfo: {number},   // reference to parent nodeInfo>
       *         parentIndex: {number},  // index in parent's `childNodes` collection
       *         infoIndex: {number},    // index of this `nodeInfo` in `templateInfo.nodeInfoList`
       *       },
       *       ...
       *     ],
       *     // When true, the template had the `strip-whitespace` attribute
       *     // or was nested in a template with that setting
       *     stripWhitespace: {boolean},
       *     // For nested templates, nested template content is moved into
       *     // a document fragment stored here; this is an optimization to
       *     // avoid the cost of nested template cloning
       *     content: {DocumentFragment}
       *   }
       * ```
       *
       * This method kicks off a recursive treewalk as follows:
       *
       * ```
       *    _parseTemplate <---------------------+
       *      _parseTemplateContent              |
       *        _parseTemplateNode  <------------|--+
       *          _parseTemplateNestedTemplate --+  |
       *          _parseTemplateChildNodes ---------+
       *          _parseTemplateNodeAttributes
       *            _parseTemplateNodeAttribute
       *
       * ```
       *
       * These methods may be overridden to add custom metadata about templates
       * to either `templateInfo` or `nodeInfo`.
       *
       * Note that this method may be destructive to the template, in that
       * e.g. event annotations may be removed after being noted in the
       * template metadata.
       *
       * @param {!HTMLTemplateElement} template Template to parse
       * @param {TemplateInfo=} outerTemplateInfo Template metadata from the outer
       *   template, for parsing nested templates
       * @return {!TemplateInfo} Parsed template metadata
       */
      static _parseTemplate(template, outerTemplateInfo) {
        // since a template may be re-used, memo-ize metadata
        if (!template._templateInfo) {
          let templateInfo = template._templateInfo = {};
          templateInfo.nodeInfoList = [];
          templateInfo.stripWhiteSpace = Polymer.legacyOptimizations ||
            (outerTemplateInfo && outerTemplateInfo.stripWhiteSpace) ||
            template.hasAttribute('strip-whitespace');
          this._parseTemplateContent(template, templateInfo, {parent: null});
        }
        return template._templateInfo;
      }

      static _parseTemplateContent(template, templateInfo, nodeInfo) {
        return this._parseTemplateNode(template.content, templateInfo, nodeInfo);
      }

      /**
       * Parses template node and adds template and node metadata based on
       * the current node, and its `childNodes` and `attributes`.
       *
       * This method may be overridden to add custom node or template specific
       * metadata based on this node.
       *
       * @param {Node} node Node to parse
       * @param {!TemplateInfo} templateInfo Template metadata for current template
       * @param {!NodeInfo} nodeInfo Node metadata for current template.
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       */
      static _parseTemplateNode(node, templateInfo, nodeInfo) {
        let noted;
        let element = /** @type {Element} */(node);
        if (element.localName == 'template' && !element.hasAttribute('preserve-content')) {
          noted = this._parseTemplateNestedTemplate(element, templateInfo, nodeInfo) || noted;
        } else if (element.localName === 'slot') {
          // For ShadyDom optimization, indicating there is an insertion point
          templateInfo.hasInsertionPoint = true;
        }
        walker.currentNode = element;
        if (walker.firstChild()) {
          noted = this._parseTemplateChildNodes(element, templateInfo, nodeInfo) || noted;
        }
        if (element.hasAttributes && element.hasAttributes()) {
          noted = this._parseTemplateNodeAttributes(element, templateInfo, nodeInfo) || noted;
        }
        return noted;
      }

      /**
       * Parses template child nodes for the given root node.
       *
       * This method also wraps whitelisted legacy template extensions
       * (`is="dom-if"` and `is="dom-repeat"`) with their equivalent element
       * wrappers, collapses text nodes, and strips whitespace from the template
       * if the `templateInfo.stripWhitespace` setting was provided.
       *
       * @param {Node} root Root node whose `childNodes` will be parsed
       * @param {!TemplateInfo} templateInfo Template metadata for current template
       * @param {!NodeInfo} nodeInfo Node metadata for current template.
       * @return {void}
       */
      static _parseTemplateChildNodes(root, templateInfo, nodeInfo) {
        if (root.localName === 'script' || root.localName === 'style') {
          return;
        }
        walker.currentNode = root;
        for (let node=walker.firstChild(), parentIndex=0, next; node; node=next) {
          // Wrap templates
          if (node.localName == 'template') {
            node = wrapTemplateExtension(node);
          }
          // collapse adjacent textNodes: fixes an IE issue that can cause
          // text nodes to be inexplicably split =(
          // note that root.normalize() should work but does not so we do this
          // manually.
          walker.currentNode = node;
          next = walker.nextSibling();
          if (node.nodeType === Node.TEXT_NODE) {
            let /** Node */ n = next;
            while (n && (n.nodeType === Node.TEXT_NODE)) {
              node.textContent += n.textContent;
              next = walker.nextSibling();
              root.removeChild(n);
              n = next;
            }
            // optionally strip whitespace
            if (templateInfo.stripWhiteSpace && !node.textContent.trim()) {
              root.removeChild(node);
              continue;
            }
          }
          let childInfo = { parentIndex, parentInfo: nodeInfo };
          if (this._parseTemplateNode(node, templateInfo, childInfo)) {
            childInfo.infoIndex = templateInfo.nodeInfoList.push(/** @type {!NodeInfo} */(childInfo)) - 1;
          }
          // Increment if not removed
          walker.currentNode = node;
          if (walker.parentNode()) {
            parentIndex++;
          }
        }
      }

      /**
       * Parses template content for the given nested `<template>`.
       *
       * Nested template info is stored as `templateInfo` in the current node's
       * `nodeInfo`. `template.content` is removed and stored in `templateInfo`.
       * It will then be the responsibility of the host to set it back to the
       * template and for users stamping nested templates to use the
       * `_contentForTemplate` method to retrieve the content for this template
       * (an optimization to avoid the cost of cloning nested template content).
       *
       * @param {HTMLTemplateElement} node Node to parse (a <template>)
       * @param {TemplateInfo} outerTemplateInfo Template metadata for current template
       *   that includes the template `node`
       * @param {!NodeInfo} nodeInfo Node metadata for current template.
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       */
      static _parseTemplateNestedTemplate(node, outerTemplateInfo, nodeInfo) {
        let templateInfo = this._parseTemplate(node, outerTemplateInfo);
        let content = templateInfo.content =
          node.content.ownerDocument.createDocumentFragment();
        content.appendChild(node.content);
        nodeInfo.templateInfo = templateInfo;
        return true;
      }

      /**
       * Parses template node attributes and adds node metadata to `nodeInfo`
       * for nodes of interest.
       *
       * @param {Element} node Node to parse
       * @param {TemplateInfo} templateInfo Template metadata for current template
       * @param {NodeInfo} nodeInfo Node metadata for current template.
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       */
      static _parseTemplateNodeAttributes(node, templateInfo, nodeInfo) {
        // Make copy of original attribute list, since the order may change
        // as attributes are added and removed
        let noted = false;
        let attrs = Array.from(node.attributes);
        for (let i=attrs.length-1, a; (a=attrs[i]); i--) {
          noted = this._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, a.name, a.value) || noted;
        }
        return noted;
      }

      /**
       * Parses a single template node attribute and adds node metadata to
       * `nodeInfo` for attributes of interest.
       *
       * This implementation adds metadata for `on-event="handler"` attributes
       * and `id` attributes.
       *
       * @param {Element} node Node to parse
       * @param {!TemplateInfo} templateInfo Template metadata for current template
       * @param {!NodeInfo} nodeInfo Node metadata for current template.
       * @param {string} name Attribute name
       * @param {string} value Attribute value
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       */
      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
        // events (on-*)
        if (name.slice(0, 3) === 'on-') {
          node.removeAttribute(name);
          nodeInfo.events = nodeInfo.events || [];
          nodeInfo.events.push({
            name: name.slice(3),
            value
          });
          return true;
        }
        // static id
        else if (name === 'id') {
          nodeInfo.id = value;
          return true;
        }
        return false;
      }

      /**
       * Returns the `content` document fragment for a given template.
       *
       * For nested templates, Polymer performs an optimization to cache nested
       * template content to avoid the cost of cloning deeply nested templates.
       * This method retrieves the cached content for a given template.
       *
       * @param {HTMLTemplateElement} template Template to retrieve `content` for
       * @return {DocumentFragment} Content fragment
       */
      static _contentForTemplate(template) {
        let templateInfo = /** @type {HTMLTemplateElementWithInfo} */ (template)._templateInfo;
        return (templateInfo && templateInfo.content) || template.content;
      }

      /**
       * Clones the provided template content and returns a document fragment
       * containing the cloned dom.
       *
       * The template is parsed (once and memoized) using this library's
       * template parsing features, and provides the following value-added
       * features:
       * * Adds declarative event listeners for `on-event="handler"` attributes
       * * Generates an "id map" for all nodes with id's under `$` on returned
       *   document fragment
       * * Passes template info including `content` back to templates as
       *   `_templateInfo` (a performance optimization to avoid deep template
       *   cloning)
       *
       * Note that the memoized template parsing process is destructive to the
       * template: attributes for bindings and declarative event listeners are
       * removed after being noted in notes, and any nested `<template>.content`
       * is removed and stored in notes as well.
       *
       * @param {!HTMLTemplateElement} template Template to stamp
       * @return {!StampedTemplate} Cloned template content
       */
      _stampTemplate(template) {
        // Polyfill support: bootstrap the template if it has not already been
        if (template && !template.content &&
            window.HTMLTemplateElement && HTMLTemplateElement.decorate) {
          HTMLTemplateElement.decorate(template);
        }
        let templateInfo = this.constructor._parseTemplate(template);
        let nodeInfo = templateInfo.nodeInfoList;
        let content = templateInfo.content || template.content;
        let dom = /** @type {DocumentFragment} */ (document.importNode(content, true));
        // NOTE: ShadyDom optimization indicating there is an insertion point
        dom.__noInsertionPoint = !templateInfo.hasInsertionPoint;
        let nodes = dom.nodeList = new Array(nodeInfo.length);
        dom.$ = {};
        for (let i=0, l=nodeInfo.length, info; (i<l) && (info=nodeInfo[i]); i++) {
          let node = nodes[i] = findTemplateNode(dom, info);
          applyIdToMap(this, dom.$, node, info);
          applyTemplateContent(this, node, info);
          applyEventListener(this, node, info);
        }
        dom = /** @type {!StampedTemplate} */(dom); // eslint-disable-line no-self-assign
        return dom;
      }

      /**
       * Adds an event listener by method name for the event provided.
       *
       * This method generates a handler function that looks up the method
       * name at handling time.
       *
       * @param {!Node} node Node to add listener on
       * @param {string} eventName Name of event
       * @param {string} methodName Name of method
       * @param {*=} context Context the method will be called on (defaults
       *   to `node`)
       * @return {Function} Generated handler function
       */
      _addMethodEventListenerToNode(node, eventName, methodName, context) {
        context = context || node;
        let handler = createNodeEventHandler(context, eventName, methodName);
        this._addEventListenerToNode(node, eventName, handler);
        return handler;
      }

      /**
       * Override point for adding custom or simulated event handling.
       *
       * @param {!Node} node Node to add event listener to
       * @param {string} eventName Name of event
       * @param {function(!Event):void} handler Listener function to add
       * @return {void}
       */
      _addEventListenerToNode(node, eventName, handler) {
        node.addEventListener(eventName, handler);
      }

      /**
       * Override point for adding custom or simulated event handling.
       *
       * @param {!Node} node Node to remove event listener from
       * @param {string} eventName Name of event
       * @param {function(!Event):void} handler Listener function to remove
       * @return {void}
       */
      _removeEventListenerFromNode(node, eventName, handler) {
        node.removeEventListener(eventName, handler);
      }

    }

    return TemplateStamp;

  });

})();


(function() {

  'use strict';

  /** @const {Object} */
  const CaseMap = Polymer.CaseMap;

  // Monotonically increasing unique ID used for de-duping effects triggered
  // from multiple properties in the same turn
  let dedupeId = 0;

  /**
   * Property effect types; effects are stored on the prototype using these keys
   * @enum {string}
   */
  const TYPES = {
    COMPUTE: '__computeEffects',
    REFLECT: '__reflectEffects',
    NOTIFY: '__notifyEffects',
    PROPAGATE: '__propagateEffects',
    OBSERVE: '__observeEffects',
    READ_ONLY: '__readOnly'
  };

  /** @const {RegExp} */
  const capitalAttributeRegex = /[A-Z]/;

  /**
   * @typedef {{
   * name: (string | undefined),
   * structured: (boolean | undefined),
   * wildcard: (boolean | undefined)
   * }}
   */
  let DataTrigger; //eslint-disable-line no-unused-vars

  /**
   * @typedef {{
   * info: ?,
   * trigger: (!DataTrigger | undefined),
   * fn: (!Function | undefined)
   * }}
   */
  let DataEffect; //eslint-disable-line no-unused-vars

  let PropertyEffectsType; //eslint-disable-line no-unused-vars

  /**
   * Ensures that the model has an own-property map of effects for the given type.
   * The model may be a prototype or an instance.
   *
   * Property effects are stored as arrays of effects by property in a map,
   * by named type on the model. e.g.
   *
   *   __computeEffects: {
   *     foo: [ ... ],
   *     bar: [ ... ]
   *   }
   *
   * If the model does not yet have an effect map for the type, one is created
   * and returned.  If it does, but it is not an own property (i.e. the
   * prototype had effects), the the map is deeply cloned and the copy is
   * set on the model and returned, ready for new effects to be added.
   *
   * @param {Object} model Prototype or instance
   * @param {string} type Property effect type
   * @return {Object} The own-property map of effects for the given type
   * @private
   */
  function ensureOwnEffectMap(model, type) {
    let effects = model[type];
    if (!effects) {
      effects = model[type] = {};
    } else if (!model.hasOwnProperty(type)) {
      effects = model[type] = Object.create(model[type]);
      for (let p in effects) {
        let protoFx = effects[p];
        let instFx = effects[p] = Array(protoFx.length);
        for (let i=0; i<protoFx.length; i++) {
          instFx[i] = protoFx[i];
        }
      }
    }
    return effects;
  }

  // -- effects ----------------------------------------------

  /**
   * Runs all effects of a given type for the given set of property changes
   * on an instance.
   *
   * @param {!PropertyEffectsType} inst The instance with effects to run
   * @param {Object} effects Object map of property-to-Array of effects
   * @param {Object} props Bag of current property changes
   * @param {Object=} oldProps Bag of previous values for changed properties
   * @param {boolean=} hasPaths True with `props` contains one or more paths
   * @param {*=} extraArgs Additional metadata to pass to effect function
   * @return {boolean} True if an effect ran for this property
   * @private
   */
  function runEffects(inst, effects, props, oldProps, hasPaths, extraArgs) {
    if (effects) {
      let ran = false;
      let id = dedupeId++;
      for (let prop in props) {
        if (runEffectsForProperty(inst, effects, id, prop, props, oldProps, hasPaths, extraArgs)) {
          ran = true;
        }
      }
      return ran;
    }
    return false;
  }

  /**
   * Runs a list of effects for a given property.
   *
   * @param {!PropertyEffectsType} inst The instance with effects to run
   * @param {Object} effects Object map of property-to-Array of effects
   * @param {number} dedupeId Counter used for de-duping effects
   * @param {string} prop Name of changed property
   * @param {*} props Changed properties
   * @param {*} oldProps Old properties
   * @param {boolean=} hasPaths True with `props` contains one or more paths
   * @param {*=} extraArgs Additional metadata to pass to effect function
   * @return {boolean} True if an effect ran for this property
   * @private
   */
  function runEffectsForProperty(inst, effects, dedupeId, prop, props, oldProps, hasPaths, extraArgs) {
    let ran = false;
    let rootProperty = hasPaths ? Polymer.Path.root(prop) : prop;
    let fxs = effects[rootProperty];
    if (fxs) {
      for (let i=0, l=fxs.length, fx; (i<l) && (fx=fxs[i]); i++) {
        if ((!fx.info || fx.info.lastRun !== dedupeId) &&
            (!hasPaths || pathMatchesTrigger(prop, fx.trigger))) {
          if (fx.info) {
            fx.info.lastRun = dedupeId;
          }
          fx.fn(inst, prop, props, oldProps, fx.info, hasPaths, extraArgs);
          ran = true;
        }
      }
    }
    return ran;
  }

  /**
   * Determines whether a property/path that has changed matches the trigger
   * criteria for an effect.  A trigger is a descriptor with the following
   * structure, which matches the descriptors returned from `parseArg`.
   * e.g. for `foo.bar.*`:
   * ```
   * trigger: {
   *   name: 'a.b',
   *   structured: true,
   *   wildcard: true
   * }
   * ```
   * If no trigger is given, the path is deemed to match.
   *
   * @param {string} path Path or property that changed
   * @param {DataTrigger} trigger Descriptor
   * @return {boolean} Whether the path matched the trigger
   */
  function pathMatchesTrigger(path, trigger) {
    if (trigger) {
      let triggerPath = trigger.name;
      return (triggerPath == path) ||
        (trigger.structured && Polymer.Path.isAncestor(triggerPath, path)) ||
        (trigger.wildcard && Polymer.Path.isDescendant(triggerPath, path));
    } else {
      return true;
    }
  }

  /**
   * Implements the "observer" effect.
   *
   * Calls the method with `info.methodName` on the instance, passing the
   * new and old values.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {string} property Name of property
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {?} info Effect metadata
   * @return {void}
   * @private
   */
  function runObserverEffect(inst, property, props, oldProps, info) {
    let fn = typeof info.method === "string" ? inst[info.method] : info.method;
    let changedProp = info.property;
    if (fn) {
      fn.call(inst, inst.__data[changedProp], oldProps[changedProp]);
    } else if (!info.dynamicFn) {
      console.warn('observer method `' + info.method + '` not defined');
    }
  }

  /**
   * Runs "notify" effects for a set of changed properties.
   *
   * This method differs from the generic `runEffects` method in that it
   * will dispatch path notification events in the case that the property
   * changed was a path and the root property for that path didn't have a
   * "notify" effect.  This is to maintain 1.0 behavior that did not require
   * `notify: true` to ensure object sub-property notifications were
   * sent.
   *
   * @param {!PropertyEffectsType} inst The instance with effects to run
   * @param {Object} notifyProps Bag of properties to notify
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {boolean} hasPaths True with `props` contains one or more paths
   * @return {void}
   * @private
   */
  function runNotifyEffects(inst, notifyProps, props, oldProps, hasPaths) {
    // Notify
    let fxs = inst[TYPES.NOTIFY];
    let notified;
    let id = dedupeId++;
    // Try normal notify effects; if none, fall back to try path notification
    for (let prop in notifyProps) {
      if (notifyProps[prop]) {
        if (fxs && runEffectsForProperty(inst, fxs, id, prop, props, oldProps, hasPaths)) {
          notified = true;
        } else if (hasPaths && notifyPath(inst, prop, props)) {
          notified = true;
        }
      }
    }
    // Flush host if we actually notified and host was batching
    // And the host has already initialized clients; this prevents
    // an issue with a host observing data changes before clients are ready.
    let host;
    if (notified && (host = inst.__dataHost) && host._invalidateProperties) {
      host._invalidateProperties();
    }
  }

  /**
   * Dispatches {property}-changed events with path information in the detail
   * object to indicate a sub-path of the property was changed.
   *
   * @param {!PropertyEffectsType} inst The element from which to fire the event
   * @param {string} path The path that was changed
   * @param {Object} props Bag of current property changes
   * @return {boolean} Returns true if the path was notified
   * @private
   */
  function notifyPath(inst, path, props) {
    let rootProperty = Polymer.Path.root(path);
    if (rootProperty !== path) {
      let eventName = Polymer.CaseMap.camelToDashCase(rootProperty) + '-changed';
      dispatchNotifyEvent(inst, eventName, props[path], path);
      return true;
    }
    return false;
  }

  /**
   * Dispatches {property}-changed events to indicate a property (or path)
   * changed.
   *
   * @param {!PropertyEffectsType} inst The element from which to fire the event
   * @param {string} eventName The name of the event to send ('{property}-changed')
   * @param {*} value The value of the changed property
   * @param {string | null | undefined} path If a sub-path of this property changed, the path
   *   that changed (optional).
   * @return {void}
   * @private
   * @suppress {invalidCasts}
   */
  function dispatchNotifyEvent(inst, eventName, value, path) {
    let detail = {
      value: value,
      queueProperty: true
    };
    if (path) {
      detail.path = path;
    }
    /** @type {!HTMLElement} */(inst).dispatchEvent(new CustomEvent(eventName, { detail }));
  }

  /**
   * Implements the "notify" effect.
   *
   * Dispatches a non-bubbling event named `info.eventName` on the instance
   * with a detail object containing the new `value`.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {string} property Name of property
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {?} info Effect metadata
   * @param {boolean} hasPaths True with `props` contains one or more paths
   * @return {void}
   * @private
   */
  function runNotifyEffect(inst, property, props, oldProps, info, hasPaths) {
    let rootProperty = hasPaths ? Polymer.Path.root(property) : property;
    let path = rootProperty != property ? property : null;
    let value = path ? Polymer.Path.get(inst, path) : inst.__data[property];
    if (path && value === undefined) {
      value = props[property];  // specifically for .splices
    }
    dispatchNotifyEvent(inst, info.eventName, value, path);
  }

  /**
   * Handler function for 2-way notification events. Receives context
   * information captured in the `addNotifyListener` closure from the
   * `__notifyListeners` metadata.
   *
   * Sets the value of the notified property to the host property or path.  If
   * the event contained path information, translate that path to the host
   * scope's name for that path first.
   *
   * @param {CustomEvent} event Notification event (e.g. '<property>-changed')
   * @param {!PropertyEffectsType} inst Host element instance handling the notification event
   * @param {string} fromProp Child element property that was bound
   * @param {string} toPath Host property/path that was bound
   * @param {boolean} negate Whether the binding was negated
   * @return {void}
   * @private
   */
  function handleNotification(event, inst, fromProp, toPath, negate) {
    let value;
    let detail = /** @type {Object} */(event.detail);
    let fromPath = detail && detail.path;
    if (fromPath) {
      toPath = Polymer.Path.translate(fromProp, toPath, fromPath);
      value = detail && detail.value;
    } else {
      value = event.currentTarget[fromProp];
    }
    value = negate ? !value : value;
    if (!inst[TYPES.READ_ONLY] || !inst[TYPES.READ_ONLY][toPath]) {
      if (inst._setPendingPropertyOrPath(toPath, value, true, Boolean(fromPath))
        && (!detail || !detail.queueProperty)) {
        inst._invalidateProperties();
      }
    }
  }

  /**
   * Implements the "reflect" effect.
   *
   * Sets the attribute named `info.attrName` to the given property value.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {string} property Name of property
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {?} info Effect metadata
   * @return {void}
   * @private
   */
  function runReflectEffect(inst, property, props, oldProps, info) {
    let value = inst.__data[property];
    if (Polymer.sanitizeDOMValue) {
      value = Polymer.sanitizeDOMValue(value, info.attrName, 'attribute', /** @type {Node} */(inst));
    }
    inst._propertyToAttribute(property, info.attrName, value);
  }

  /**
   * Runs "computed" effects for a set of changed properties.
   *
   * This method differs from the generic `runEffects` method in that it
   * continues to run computed effects based on the output of each pass until
   * there are no more newly computed properties.  This ensures that all
   * properties that will be computed by the initial set of changes are
   * computed before other effects (binding propagation, observers, and notify)
   * run.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {!Object} changedProps Bag of changed properties
   * @param {!Object} oldProps Bag of previous values for changed properties
   * @param {boolean} hasPaths True with `props` contains one or more paths
   * @return {void}
   * @private
   */
  function runComputedEffects(inst, changedProps, oldProps, hasPaths) {
    let computeEffects = inst[TYPES.COMPUTE];
    if (computeEffects) {
      let inputProps = changedProps;
      while (runEffects(inst, computeEffects, inputProps, oldProps, hasPaths)) {
        Object.assign(oldProps, inst.__dataOld);
        Object.assign(changedProps, inst.__dataPending);
        inputProps = inst.__dataPending;
        inst.__dataPending = null;
      }
    }
  }

  /**
   * Implements the "computed property" effect by running the method with the
   * values of the arguments specified in the `info` object and setting the
   * return value to the computed property specified.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {string} property Name of property
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {?} info Effect metadata
   * @return {void}
   * @private
   */
  function runComputedEffect(inst, property, props, oldProps, info) {
    let result = runMethodEffect(inst, property, props, oldProps, info);
    let computedProp = info.methodInfo;
    if (inst.__dataHasAccessor && inst.__dataHasAccessor[computedProp]) {
      inst._setPendingProperty(computedProp, result, true);
    } else {
      inst[computedProp] = result;
    }
  }

  /**
   * Computes path changes based on path links set up using the `linkPaths`
   * API.
   *
   * @param {!PropertyEffectsType} inst The instance whose props are changing
   * @param {string | !Array<(string|number)>} path Path that has changed
   * @param {*} value Value of changed path
   * @return {void}
   * @private
   */
  function computeLinkedPaths(inst, path, value) {
    let links = inst.__dataLinkedPaths;
    if (links) {
      let link;
      for (let a in links) {
        let b = links[a];
        if (Polymer.Path.isDescendant(a, path)) {
          link = Polymer.Path.translate(a, b, path);
          inst._setPendingPropertyOrPath(link, value, true, true);
        } else if (Polymer.Path.isDescendant(b, path)) {
          link = Polymer.Path.translate(b, a, path);
          inst._setPendingPropertyOrPath(link, value, true, true);
        }
      }
    }
  }

  // -- bindings ----------------------------------------------

  /**
   * Adds binding metadata to the current `nodeInfo`, and binding effects
   * for all part dependencies to `templateInfo`.
   *
   * @param {Function} constructor Class that `_parseTemplate` is currently
   *   running on
   * @param {TemplateInfo} templateInfo Template metadata for current template
   * @param {NodeInfo} nodeInfo Node metadata for current template node
   * @param {string} kind Binding kind, either 'property', 'attribute', or 'text'
   * @param {string} target Target property name
   * @param {!Array<!BindingPart>} parts Array of binding part metadata
   * @param {string=} literal Literal text surrounding binding parts (specified
   *   only for 'property' bindings, since these must be initialized as part
   *   of boot-up)
   * @return {void}
   * @private
   */
  function addBinding(constructor, templateInfo, nodeInfo, kind, target, parts, literal) {
    // Create binding metadata and add to nodeInfo
    nodeInfo.bindings = nodeInfo.bindings || [];
    let /** Binding */ binding = { kind, target, parts, literal, isCompound: (parts.length !== 1) };
    nodeInfo.bindings.push(binding);
    // Add listener info to binding metadata
    if (shouldAddListener(binding)) {
      let {event, negate} = binding.parts[0];
      binding.listenerEvent = event || (CaseMap.camelToDashCase(target) + '-changed');
      binding.listenerNegate = negate;
    }
    // Add "propagate" property effects to templateInfo
    let index = templateInfo.nodeInfoList.length;
    for (let i=0; i<binding.parts.length; i++) {
      let part = binding.parts[i];
      part.compoundIndex = i;
      addEffectForBindingPart(constructor, templateInfo, binding, part, index);
    }
  }

  /**
   * Adds property effects to the given `templateInfo` for the given binding
   * part.
   *
   * @param {Function} constructor Class that `_parseTemplate` is currently
   *   running on
   * @param {TemplateInfo} templateInfo Template metadata for current template
   * @param {!Binding} binding Binding metadata
   * @param {!BindingPart} part Binding part metadata
   * @param {number} index Index into `nodeInfoList` for this node
   * @return {void}
   */
  function addEffectForBindingPart(constructor, templateInfo, binding, part, index) {
    if (!part.literal) {
      if (binding.kind === 'attribute' && binding.target[0] === '-') {
        console.warn('Cannot set attribute ' + binding.target +
          ' because "-" is not a valid attribute starting character');
      } else {
        let dependencies = part.dependencies;
        let info = { index, binding, part, evaluator: constructor };
        for (let j=0; j<dependencies.length; j++) {
          let trigger = dependencies[j];
          if (typeof trigger == 'string') {
            trigger = parseArg(trigger);
            trigger.wildcard = true;
          }
          constructor._addTemplatePropertyEffect(templateInfo, trigger.rootProperty, {
            fn: runBindingEffect,
            info, trigger
          });
        }
      }
    }
  }

  /**
   * Implements the "binding" (property/path binding) effect.
   *
   * Note that binding syntax is overridable via `_parseBindings` and
   * `_evaluateBinding`.  This method will call `_evaluateBinding` for any
   * non-literal parts returned from `_parseBindings`.  However,
   * there is no support for _path_ bindings via custom binding parts,
   * as this is specific to Polymer's path binding syntax.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {string} path Name of property
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {?} info Effect metadata
   * @param {boolean} hasPaths True with `props` contains one or more paths
   * @param {Array} nodeList List of nodes associated with `nodeInfoList` template
   *   metadata
   * @return {void}
   * @private
   */
  function runBindingEffect(inst, path, props, oldProps, info, hasPaths, nodeList) {
    let node = nodeList[info.index];
    let binding = info.binding;
    let part = info.part;
    // Subpath notification: transform path and set to client
    // e.g.: foo="{{obj.sub}}", path: 'obj.sub.prop', set 'foo.prop'=obj.sub.prop
    if (hasPaths && part.source && (path.length > part.source.length) &&
        (binding.kind == 'property') && !binding.isCompound &&
        node.__isPropertyEffectsClient &&
        node.__dataHasAccessor && node.__dataHasAccessor[binding.target]) {
      let value = props[path];
      path = Polymer.Path.translate(part.source, binding.target, path);
      if (node._setPendingPropertyOrPath(path, value, false, true)) {
        inst._enqueueClient(node);
      }
    } else {
      let value = info.evaluator._evaluateBinding(inst, part, path, props, oldProps, hasPaths);
      // Propagate value to child
      applyBindingValue(inst, node, binding, part, value);
    }
  }

  /**
   * Sets the value for an "binding" (binding) effect to a node,
   * either as a property or attribute.
   *
   * @param {!PropertyEffectsType} inst The instance owning the binding effect
   * @param {Node} node Target node for binding
   * @param {!Binding} binding Binding metadata
   * @param {!BindingPart} part Binding part metadata
   * @param {*} value Value to set
   * @return {void}
   * @private
   */
  function applyBindingValue(inst, node, binding, part, value) {
    value = computeBindingValue(node, value, binding, part);
    if (Polymer.sanitizeDOMValue) {
      value = Polymer.sanitizeDOMValue(value, binding.target, binding.kind, node);
    }
    if (binding.kind == 'attribute') {
      // Attribute binding
      inst._valueToNodeAttribute(/** @type {Element} */(node), value, binding.target);
    } else {
      // Property binding
      let prop = binding.target;
      if (node.__isPropertyEffectsClient &&
          node.__dataHasAccessor && node.__dataHasAccessor[prop]) {
        if (!node[TYPES.READ_ONLY] || !node[TYPES.READ_ONLY][prop]) {
          if (node._setPendingProperty(prop, value)) {
            inst._enqueueClient(node);
          }
        }
      } else  {
        inst._setUnmanagedPropertyToNode(node, prop, value);
      }
    }
  }

  /**
   * Transforms an "binding" effect value based on compound & negation
   * effect metadata, as well as handling for special-case properties
   *
   * @param {Node} node Node the value will be set to
   * @param {*} value Value to set
   * @param {!Binding} binding Binding metadata
   * @param {!BindingPart} part Binding part metadata
   * @return {*} Transformed value to set
   * @private
   */
  function computeBindingValue(node, value, binding, part) {
    if (binding.isCompound) {
      let storage = node.__dataCompoundStorage[binding.target];
      storage[part.compoundIndex] = value;
      value = storage.join('');
    }
    if (binding.kind !== 'attribute') {
      // Some browsers serialize `undefined` to `"undefined"`
      if (binding.target === 'textContent' ||
          (binding.target === 'value' &&
            (node.localName === 'input' || node.localName === 'textarea'))) {
        value = value == undefined ? '' : value;
      }
    }
    return value;
  }

  /**
   * Returns true if a binding's metadata meets all the requirements to allow
   * 2-way binding, and therefore a `<property>-changed` event listener should be
   * added:
   * - used curly braces
   * - is a property (not attribute) binding
   * - is not a textContent binding
   * - is not compound
   *
   * @param {!Binding} binding Binding metadata
   * @return {boolean} True if 2-way listener should be added
   * @private
   */
  function shouldAddListener(binding) {
    return Boolean(binding.target) &&
           binding.kind != 'attribute' &&
           binding.kind != 'text' &&
           !binding.isCompound &&
           binding.parts[0].mode === '{';
  }

  /**
   * Setup compound binding storage structures, notify listeners, and dataHost
   * references onto the bound nodeList.
   *
   * @param {!PropertyEffectsType} inst Instance that bas been previously bound
   * @param {TemplateInfo} templateInfo Template metadata
   * @return {void}
   * @private
   */
  function setupBindings(inst, templateInfo) {
    // Setup compound storage, dataHost, and notify listeners
    let {nodeList, nodeInfoList} = templateInfo;
    if (nodeInfoList.length) {
      for (let i=0; i < nodeInfoList.length; i++) {
        let info = nodeInfoList[i];
        let node = nodeList[i];
        let bindings = info.bindings;
        if (bindings) {
          for (let i=0; i<bindings.length; i++) {
            let binding = bindings[i];
            setupCompoundStorage(node, binding);
            addNotifyListener(node, inst, binding);
          }
        }
        node.__dataHost = inst;
      }
    }
  }

  /**
   * Initializes `__dataCompoundStorage` local storage on a bound node with
   * initial literal data for compound bindings, and sets the joined
   * literal parts to the bound property.
   *
   * When changes to compound parts occur, they are first set into the compound
   * storage array for that property, and then the array is joined to result in
   * the final value set to the property/attribute.
   *
   * @param {Node} node Bound node to initialize
   * @param {Binding} binding Binding metadata
   * @return {void}
   * @private
   */
  function setupCompoundStorage(node, binding) {
    if (binding.isCompound) {
      // Create compound storage map
      let storage = node.__dataCompoundStorage ||
        (node.__dataCompoundStorage = {});
      let parts = binding.parts;
      // Copy literals from parts into storage for this binding
      let literals = new Array(parts.length);
      for (let j=0; j<parts.length; j++) {
        literals[j] = parts[j].literal;
      }
      let target = binding.target;
      storage[target] = literals;
      // Configure properties with their literal parts
      if (binding.literal && binding.kind == 'property') {
        node[target] = binding.literal;
      }
    }
  }

  /**
   * Adds a 2-way binding notification event listener to the node specified
   *
   * @param {Object} node Child element to add listener to
   * @param {!PropertyEffectsType} inst Host element instance to handle notification event
   * @param {Binding} binding Binding metadata
   * @return {void}
   * @private
   */
  function addNotifyListener(node, inst, binding) {
    if (binding.listenerEvent) {
      let part = binding.parts[0];
      node.addEventListener(binding.listenerEvent, function(e) {
        handleNotification(e, inst, binding.target, part.source, part.negate);
      });
    }
  }

  // -- for method-based effects (complexObserver & computed) --------------

  /**
   * Adds property effects for each argument in the method signature (and
   * optionally, for the method name if `dynamic` is true) that calls the
   * provided effect function.
   *
   * @param {Element | Object} model Prototype or instance
   * @param {!MethodSignature} sig Method signature metadata
   * @param {string} type Type of property effect to add
   * @param {Function} effectFn Function to run when arguments change
   * @param {*=} methodInfo Effect-specific information to be included in
   *   method effect metadata
   * @param {boolean|Object=} dynamicFn Boolean or object map indicating whether
   *   method names should be included as a dependency to the effect. Note,
   *   defaults to true if the signature is static (sig.static is true).
   * @return {void}
   * @private
   */
  function createMethodEffect(model, sig, type, effectFn, methodInfo, dynamicFn) {
    dynamicFn = sig.static || (dynamicFn &&
      (typeof dynamicFn !== 'object' || dynamicFn[sig.methodName]));
    let info = {
      methodName: sig.methodName,
      args: sig.args,
      methodInfo,
      dynamicFn
    };
    for (let i=0, arg; (i<sig.args.length) && (arg=sig.args[i]); i++) {
      if (!arg.literal) {
        model._addPropertyEffect(arg.rootProperty, type, {
          fn: effectFn, info: info, trigger: arg
        });
      }
    }
    if (dynamicFn) {
      model._addPropertyEffect(sig.methodName, type, {
        fn: effectFn, info: info
      });
    }
  }

  /**
   * Calls a method with arguments marshaled from properties on the instance
   * based on the method signature contained in the effect metadata.
   *
   * Multi-property observers, computed properties, and inline computing
   * functions call this function to invoke the method, then use the return
   * value accordingly.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {string} property Name of property
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {?} info Effect metadata
   * @return {*} Returns the return value from the method invocation
   * @private
   */
  function runMethodEffect(inst, property, props, oldProps, info) {
    // Instances can optionally have a _methodHost which allows redirecting where
    // to find methods. Currently used by `templatize`.
    let context = inst._methodHost || inst;
    let fn = context[info.methodName];
    if (fn) {
      let args = inst._marshalArgs(info.args, property, props);
      return fn.apply(context, args);
    } else if (!info.dynamicFn) {
      console.warn('method `' + info.methodName + '` not defined');
    }
  }

  const emptyArray = [];

  // Regular expressions used for binding
  const IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$\\-*]*' + ')';
  const NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
  const SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
  const DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';
  const STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';
  const ARGUMENT = '(?:(' + IDENT + '|' + NUMBER + '|' +  STRING + ')\\s*' + ')';
  const ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\s*' + ARGUMENT + ')*' + ')';
  const ARGUMENT_LIST = '(?:' + '\\(\\s*' +
                                '(?:' + ARGUMENTS + '?' + ')' +
                              '\\)\\s*' + ')';
  const BINDING = '(' + IDENT + '\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3
  const OPEN_BRACKET = '(\\[\\[|{{)' + '\\s*';
  const CLOSE_BRACKET = '(?:]]|}})';
  const NEGATE = '(?:(!)\\s*)?'; // Group 2
  const EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
  const bindingRegex = new RegExp(EXPRESSION, "g");

  /**
   * Create a string from binding parts of all the literal parts
   *
   * @param {!Array<BindingPart>} parts All parts to stringify
   * @return {string} String made from the literal parts
   */
  function literalFromParts(parts) {
    let s = '';
    for (let i=0; i<parts.length; i++) {
      let literal = parts[i].literal;
      s += literal || '';
    }
    return s;
  }

  /**
   * Parses an expression string for a method signature, and returns a metadata
   * describing the method in terms of `methodName`, `static` (whether all the
   * arguments are literals), and an array of `args`
   *
   * @param {string} expression The expression to parse
   * @return {?MethodSignature} The method metadata object if a method expression was
   *   found, otherwise `undefined`
   * @private
   */
  function parseMethod(expression) {
    // tries to match valid javascript property names
    let m = expression.match(/([^\s]+?)\(([\s\S]*)\)/);
    if (m) {
      let methodName = m[1];
      let sig = { methodName, static: true, args: emptyArray };
      if (m[2].trim()) {
        // replace escaped commas with comma entity, split on un-escaped commas
        let args = m[2].replace(/\\,/g, '&comma;').split(',');
        return parseArgs(args, sig);
      } else {
        return sig;
      }
    }
    return null;
  }

  /**
   * Parses an array of arguments and sets the `args` property of the supplied
   * signature metadata object. Sets the `static` property to false if any
   * argument is a non-literal.
   *
   * @param {!Array<string>} argList Array of argument names
   * @param {!MethodSignature} sig Method signature metadata object
   * @return {!MethodSignature} The updated signature metadata object
   * @private
   */
  function parseArgs(argList, sig) {
    sig.args = argList.map(function(rawArg) {
      let arg = parseArg(rawArg);
      if (!arg.literal) {
        sig.static = false;
      }
      return arg;
    }, this);
    return sig;
  }

  /**
   * Parses an individual argument, and returns an argument metadata object
   * with the following fields:
   *
   *   {
   *     value: 'prop',        // property/path or literal value
   *     literal: false,       // whether argument is a literal
   *     structured: false,    // whether the property is a path
   *     rootProperty: 'prop', // the root property of the path
   *     wildcard: false       // whether the argument was a wildcard '.*' path
   *   }
   *
   * @param {string} rawArg The string value of the argument
   * @return {!MethodArg} Argument metadata object
   * @private
   */
  function parseArg(rawArg) {
    // clean up whitespace
    let arg = rawArg.trim()
      // replace comma entity with comma
      .replace(/&comma;/g, ',')
      // repair extra escape sequences; note only commas strictly need
      // escaping, but we allow any other char to be escaped since its
      // likely users will do this
      .replace(/\\(.)/g, '\$1')
      ;
    // basic argument descriptor
    let a = {
      name: arg,
      value: '',
      literal: false
    };
    // detect literal value (must be String or Number)
    let fc = arg[0];
    if (fc === '-') {
      fc = arg[1];
    }
    if (fc >= '0' && fc <= '9') {
      fc = '#';
    }
    switch(fc) {
      case "'":
      case '"':
        a.value = arg.slice(1, -1);
        a.literal = true;
        break;
      case '#':
        a.value = Number(arg);
        a.literal = true;
        break;
    }
    // if not literal, look for structured path
    if (!a.literal) {
      a.rootProperty = Polymer.Path.root(arg);
      // detect structured path (has dots)
      a.structured = Polymer.Path.isPath(arg);
      if (a.structured) {
        a.wildcard = (arg.slice(-2) == '.*');
        if (a.wildcard) {
          a.name = arg.slice(0, -2);
        }
      }
    }
    return a;
  }

  // data api

  /**
   * Sends array splice notifications (`.splices` and `.length`)
   *
   * Note: this implementation only accepts normalized paths
   *
   * @param {!PropertyEffectsType} inst Instance to send notifications to
   * @param {Array} array The array the mutations occurred on
   * @param {string} path The path to the array that was mutated
   * @param {Array} splices Array of splice records
   * @return {void}
   * @private
   */
  function notifySplices(inst, array, path, splices) {
    let splicesPath = path + '.splices';
    inst.notifyPath(splicesPath, { indexSplices: splices });
    inst.notifyPath(path + '.length', array.length);
    // Null here to allow potentially large splice records to be GC'ed.
    inst.__data[splicesPath] = {indexSplices: null};
  }

  /**
   * Creates a splice record and sends an array splice notification for
   * the described mutation
   *
   * Note: this implementation only accepts normalized paths
   *
   * @param {!PropertyEffectsType} inst Instance to send notifications to
   * @param {Array} array The array the mutations occurred on
   * @param {string} path The path to the array that was mutated
   * @param {number} index Index at which the array mutation occurred
   * @param {number} addedCount Number of added items
   * @param {Array} removed Array of removed items
   * @return {void}
   * @private
   */
  function notifySplice(inst, array, path, index, addedCount, removed) {
    notifySplices(inst, array, path, [{
      index: index,
      addedCount: addedCount,
      removed: removed,
      object: array,
      type: 'splice'
    }]);
  }

  /**
   * Returns an upper-cased version of the string.
   *
   * @param {string} name String to uppercase
   * @return {string} Uppercased string
   * @private
   */
  function upper(name) {
    return name[0].toUpperCase() + name.substring(1);
  }

  /**
   * Element class mixin that provides meta-programming for Polymer's template
   * binding and data observation (collectively, "property effects") system.
   *
   * This mixin uses provides the following key static methods for adding
   * property effects to an element class:
   * - `addPropertyEffect`
   * - `createPropertyObserver`
   * - `createMethodObserver`
   * - `createNotifyingProperty`
   * - `createReadOnlyProperty`
   * - `createReflectedProperty`
   * - `createComputedProperty`
   * - `bindTemplate`
   *
   * Each method creates one or more property accessors, along with metadata
   * used by this mixin's implementation of `_propertiesChanged` to perform
   * the property effects.
   *
   * Underscored versions of the above methods also exist on the element
   * prototype for adding property effects on instances at runtime.
   *
   * Note that this mixin overrides several `PropertyAccessors` methods, in
   * many cases to maintain guarantees provided by the Polymer 1.x features;
   * notably it changes property accessors to be synchronous by default
   * whereas the default when using `PropertyAccessors` standalone is to be
   * async by default.
   *
   * @mixinFunction
   * @polymer
   * @appliesMixin Polymer.TemplateStamp
   * @appliesMixin Polymer.PropertyAccessors
   * @memberof Polymer
   * @summary Element class mixin that provides meta-programming for Polymer's
   * template binding and data observation system.
   */
  Polymer.PropertyEffects = Polymer.dedupingMixin(superClass => {

    /**
     * @constructor
     * @extends {superClass}
     * @implements {Polymer_PropertyAccessors}
     * @implements {Polymer_TemplateStamp}
     * @unrestricted
     * @private
     */
    const propertyEffectsBase = Polymer.TemplateStamp(Polymer.PropertyAccessors(superClass));

    /**
     * @polymer
     * @mixinClass
     * @implements {Polymer_PropertyEffects}
     * @extends {propertyEffectsBase}
     * @unrestricted
     */
    class PropertyEffects extends propertyEffectsBase {

      constructor() {
        super();
        /** @type {boolean} */
        // Used to identify users of this mixin, ala instanceof
        this.__isPropertyEffectsClient = true;
        /** @type {number} */
        // NOTE: used to track re-entrant calls to `_flushProperties`
        // path changes dirty check against `__dataTemp` only during one "turn"
        // and are cleared when `__dataCounter` returns to 0.
        this.__dataCounter = 0;
        /** @type {boolean} */
        this.__dataClientsReady;
        /** @type {Array} */
        this.__dataPendingClients;
        /** @type {Object} */
        this.__dataToNotify;
        /** @type {Object} */
        this.__dataLinkedPaths;
        /** @type {boolean} */
        this.__dataHasPaths;
        /** @type {Object} */
        this.__dataCompoundStorage;
        /** @type {Polymer_PropertyEffects} */
        this.__dataHost;
        /** @type {!Object} */
        this.__dataTemp;
        /** @type {boolean} */
        this.__dataClientsInitialized;
        /** @type {!Object} */
        this.__data;
        /** @type {!Object} */
        this.__dataPending;
        /** @type {!Object} */
        this.__dataOld;
        /** @type {Object} */
        this.__computeEffects;
        /** @type {Object} */
        this.__reflectEffects;
        /** @type {Object} */
        this.__notifyEffects;
        /** @type {Object} */
        this.__propagateEffects;
        /** @type {Object} */
        this.__observeEffects;
        /** @type {Object} */
        this.__readOnly;
        /** @type {!TemplateInfo} */
        this.__templateInfo;
      }

      get PROPERTY_EFFECT_TYPES() {
        return TYPES;
      }

      /**
       * @return {void}
       */
      _initializeProperties() {
        super._initializeProperties();
        hostStack.registerHost(this);
        this.__dataClientsReady = false;
        this.__dataPendingClients = null;
        this.__dataToNotify = null;
        this.__dataLinkedPaths = null;
        this.__dataHasPaths = false;
        // May be set on instance prior to upgrade
        this.__dataCompoundStorage = this.__dataCompoundStorage || null;
        this.__dataHost = this.__dataHost || null;
        this.__dataTemp = {};
        this.__dataClientsInitialized = false;
      }

      /**
       * Overrides `Polymer.PropertyAccessors` implementation to provide a
       * more efficient implementation of initializing properties from
       * the prototype on the instance.
       *
       * @override
       * @param {Object} props Properties to initialize on the prototype
       * @return {void}
       */
      _initializeProtoProperties(props) {
        this.__data = Object.create(props);
        this.__dataPending = Object.create(props);
        this.__dataOld = {};
      }

      /**
       * Overrides `Polymer.PropertyAccessors` implementation to avoid setting
       * `_setProperty`'s `shouldNotify: true`.
       *
       * @override
       * @param {Object} props Properties to initialize on the instance
       * @return {void}
       */
      _initializeInstanceProperties(props) {
        let readOnly = this[TYPES.READ_ONLY];
        for (let prop in props) {
          if (!readOnly || !readOnly[prop]) {
            this.__dataPending = this.__dataPending || {};
            this.__dataOld = this.__dataOld || {};
            this.__data[prop] = this.__dataPending[prop] = props[prop];
          }
        }
      }

      // Prototype setup ----------------------------------------

      /**
       * Equivalent to static `addPropertyEffect` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} property Property that should trigger the effect
       * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
       * @param {Object=} effect Effect metadata object
       * @return {void}
       * @protected
       */
      _addPropertyEffect(property, type, effect) {
        this._createPropertyAccessor(property, type == TYPES.READ_ONLY);
        // effects are accumulated into arrays per property based on type
        let effects = ensureOwnEffectMap(this, type)[property];
        if (!effects) {
          effects = this[type][property] = [];
        }
        effects.push(effect);
      }

      /**
       * Removes the given property effect.
       *
       * @param {string} property Property the effect was associated with
       * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
       * @param {Object=} effect Effect metadata object to remove
       * @return {void}
       */
      _removePropertyEffect(property, type, effect) {
        let effects = ensureOwnEffectMap(this, type)[property];
        let idx = effects.indexOf(effect);
        if (idx >= 0) {
          effects.splice(idx, 1);
        }
      }

      /**
       * Returns whether the current prototype/instance has a property effect
       * of a certain type.
       *
       * @param {string} property Property name
       * @param {string=} type Effect type, from this.PROPERTY_EFFECT_TYPES
       * @return {boolean} True if the prototype/instance has an effect of this type
       * @protected
       */
      _hasPropertyEffect(property, type) {
        let effects = this[type];
        return Boolean(effects && effects[property]);
      }

      /**
       * Returns whether the current prototype/instance has a "read only"
       * accessor for the given property.
       *
       * @param {string} property Property name
       * @return {boolean} True if the prototype/instance has an effect of this type
       * @protected
       */
      _hasReadOnlyEffect(property) {
        return this._hasPropertyEffect(property, TYPES.READ_ONLY);
      }

      /**
       * Returns whether the current prototype/instance has a "notify"
       * property effect for the given property.
       *
       * @param {string} property Property name
       * @return {boolean} True if the prototype/instance has an effect of this type
       * @protected
       */
      _hasNotifyEffect(property) {
        return this._hasPropertyEffect(property, TYPES.NOTIFY);
      }

      /**
       * Returns whether the current prototype/instance has a "reflect to attribute"
       * property effect for the given property.
       *
       * @param {string} property Property name
       * @return {boolean} True if the prototype/instance has an effect of this type
       * @protected
       */
      _hasReflectEffect(property) {
        return this._hasPropertyEffect(property, TYPES.REFLECT);
      }

      /**
       * Returns whether the current prototype/instance has a "computed"
       * property effect for the given property.
       *
       * @param {string} property Property name
       * @return {boolean} True if the prototype/instance has an effect of this type
       * @protected
       */
      _hasComputedEffect(property) {
        return this._hasPropertyEffect(property, TYPES.COMPUTE);
      }

      // Runtime ----------------------------------------

      /**
       * Sets a pending property or path.  If the root property of the path in
       * question had no accessor, the path is set, otherwise it is enqueued
       * via `_setPendingProperty`.
       *
       * This function isolates relatively expensive functionality necessary
       * for the public API (`set`, `setProperties`, `notifyPath`, and property
       * change listeners via {{...}} bindings), such that it is only done
       * when paths enter the system, and not at every propagation step.  It
       * also sets a `__dataHasPaths` flag on the instance which is used to
       * fast-path slower path-matching code in the property effects host paths.
       *
       * `path` can be a path string or array of path parts as accepted by the
       * public API.
       *
       * @param {string | !Array<number|string>} path Path to set
       * @param {*} value Value to set
       * @param {boolean=} shouldNotify Set to true if this change should
       *  cause a property notification event dispatch
       * @param {boolean=} isPathNotification If the path being set is a path
       *   notification of an already changed value, as opposed to a request
       *   to set and notify the change.  In the latter `false` case, a dirty
       *   check is performed and then the value is set to the path before
       *   enqueuing the pending property change.
       * @return {boolean} Returns true if the property/path was enqueued in
       *   the pending changes bag.
       * @protected
       */
      _setPendingPropertyOrPath(path, value, shouldNotify, isPathNotification) {
        if (isPathNotification ||
            Polymer.Path.root(Array.isArray(path) ? path[0] : path) !== path) {
          // Dirty check changes being set to a path against the actual object,
          // since this is the entry point for paths into the system; from here
          // the only dirty checks are against the `__dataTemp` cache to prevent
          // duplicate work in the same turn only. Note, if this was a notification
          // of a change already set to a path (isPathNotification: true),
          // we always let the change through and skip the `set` since it was
          // already dirty checked at the point of entry and the underlying
          // object has already been updated
          if (!isPathNotification) {
            let old = Polymer.Path.get(this, path);
            path = /** @type {string} */ (Polymer.Path.set(this, path, value));
            // Use property-accessor's simpler dirty check
            if (!path || !super._shouldPropertyChange(path, value, old)) {
              return false;
            }
          }
          this.__dataHasPaths = true;
          if (this._setPendingProperty(/**@type{string}*/(path), value, shouldNotify)) {
            computeLinkedPaths(this, path, value);
            return true;
          }
        } else {
          if (this.__dataHasAccessor && this.__dataHasAccessor[path]) {
            return this._setPendingProperty(/**@type{string}*/(path), value, shouldNotify);
          } else {
            this[path] = value;
          }
        }
        return false;
      }

      /**
       * Applies a value to a non-Polymer element/node's property.
       *
       * The implementation makes a best-effort at binding interop:
       * Some native element properties have side-effects when
       * re-setting the same value (e.g. setting `<input>.value` resets the
       * cursor position), so we do a dirty-check before setting the value.
       * However, for better interop with non-Polymer custom elements that
       * accept objects, we explicitly re-set object changes coming from the
       * Polymer world (which may include deep object changes without the
       * top reference changing), erring on the side of providing more
       * information.
       *
       * Users may override this method to provide alternate approaches.
       *
       * @param {!Node} node The node to set a property on
       * @param {string} prop The property to set
       * @param {*} value The value to set
       * @return {void}
       * @protected
       */
      _setUnmanagedPropertyToNode(node, prop, value) {
        // It is a judgment call that resetting primitives is
        // "bad" and resettings objects is also "good"; alternatively we could
        // implement a whitelist of tag & property values that should never
        // be reset (e.g. <input>.value && <select>.value)
        if (value !== node[prop] || typeof value == 'object') {
          node[prop] = value;
        }
      }

      /**
       * Overrides the `PropertiesChanged` implementation to introduce special
       * dirty check logic depending on the property & value being set:
       *
       * 1. Any value set to a path (e.g. 'obj.prop': 42 or 'obj.prop': {...})
       *    Stored in `__dataTemp`, dirty checked against `__dataTemp`
       * 2. Object set to simple property (e.g. 'prop': {...})
       *    Stored in `__dataTemp` and `__data`, dirty checked against
       *    `__dataTemp` by default implementation of `_shouldPropertyChange`
       * 3. Primitive value set to simple property (e.g. 'prop': 42)
       *    Stored in `__data`, dirty checked against `__data`
       *
       * The dirty-check is important to prevent cycles due to two-way
       * notification, but paths and objects are only dirty checked against any
       * previous value set during this turn via a "temporary cache" that is
       * cleared when the last `_propertiesChanged` exits. This is so:
       * a. any cached array paths (e.g. 'array.3.prop') may be invalidated
       *    due to array mutations like shift/unshift/splice; this is fine
       *    since path changes are dirty-checked at user entry points like `set`
       * b. dirty-checking for objects only lasts one turn to allow the user
       *    to mutate the object in-place and re-set it with the same identity
       *    and have all sub-properties re-propagated in a subsequent turn.
       *
       * The temp cache is not necessarily sufficient to prevent invalid array
       * paths, since a splice can happen during the same turn (with pathological
       * user code); we could introduce a "fixup" for temporarily cached array
       * paths if needed: https://github.com/Polymer/polymer/issues/4227
       *
       * @override
       * @param {string} property Name of the property
       * @param {*} value Value to set
       * @param {boolean=} shouldNotify True if property should fire notification
       *   event (applies only for `notify: true` properties)
       * @return {boolean} Returns true if the property changed
       */
      _setPendingProperty(property, value, shouldNotify) {
        let isPath = this.__dataHasPaths && Polymer.Path.isPath(property);
        let prevProps = isPath ? this.__dataTemp : this.__data;
        if (this._shouldPropertyChange(property, value, prevProps[property])) {
          if (!this.__dataPending) {
            this.__dataPending = {};
            this.__dataOld = {};
          }
          // Ensure old is captured from the last turn
          if (!(property in this.__dataOld)) {
            this.__dataOld[property] = this.__data[property];
          }
          // Paths are stored in temporary cache (cleared at end of turn),
          // which is used for dirty-checking, all others stored in __data
          if (isPath) {
            this.__dataTemp[property] = value;
          } else {
            this.__data[property] = value;
          }
          // All changes go into pending property bag, passed to _propertiesChanged
          this.__dataPending[property] = value;
          // Track properties that should notify separately
          if (isPath || (this[TYPES.NOTIFY] && this[TYPES.NOTIFY][property])) {
            this.__dataToNotify = this.__dataToNotify || {};
            this.__dataToNotify[property] = shouldNotify;
          }
          return true;
        }
        return false;
      }

      /**
       * Overrides base implementation to ensure all accessors set `shouldNotify`
       * to true, for per-property notification tracking.
       *
       * @override
       * @param {string} property Name of the property
       * @param {*} value Value to set
       * @return {void}
       */
      _setProperty(property, value) {
        if (this._setPendingProperty(property, value, true)) {
          this._invalidateProperties();
        }
      }

      /**
       * Overrides `PropertyAccessor`'s default async queuing of
       * `_propertiesChanged`: if `__dataReady` is false (has not yet been
       * manually flushed), the function no-ops; otherwise flushes
       * `_propertiesChanged` synchronously.
       *
       * @override
       * @return {void}
       */
      _invalidateProperties() {
        if (this.__dataReady) {
          this._flushProperties();
        }
      }

      /**
       * Enqueues the given client on a list of pending clients, whose
       * pending property changes can later be flushed via a call to
       * `_flushClients`.
       *
       * @param {Object} client PropertyEffects client to enqueue
       * @return {void}
       * @protected
       */
      _enqueueClient(client) {
        this.__dataPendingClients = this.__dataPendingClients || [];
        if (client !== this) {
          this.__dataPendingClients.push(client);
        }
      }

      /**
       * Overrides superclass implementation.
       *
       * @return {void}
       * @protected
       */
      _flushProperties() {
        this.__dataCounter++;
        super._flushProperties();
        this.__dataCounter--;
      }

      /**
       * Flushes any clients previously enqueued via `_enqueueClient`, causing
       * their `_flushProperties` method to run.
       *
       * @return {void}
       * @protected
       */
      _flushClients() {
        if (!this.__dataClientsReady) {
          this.__dataClientsReady = true;
          this._readyClients();
          // Override point where accessors are turned on; importantly,
          // this is after clients have fully readied, providing a guarantee
          // that any property effects occur only after all clients are ready.
          this.__dataReady = true;
        } else {
          this.__enableOrFlushClients();
        }
      }

      // NOTE: We ensure clients either enable or flush as appropriate. This
      // handles two corner cases:
      // (1) clients flush properly when connected/enabled before the host
      // enables; e.g.
      //   (a) Templatize stamps with no properties and does not flush and
      //   (b) the instance is inserted into dom and
      //   (c) then the instance flushes.
      // (2) clients enable properly when not connected/enabled when the host
      // flushes; e.g.
      //   (a) a template is runtime stamped and not yet connected/enabled
      //   (b) a host sets a property, causing stamped dom to flush
      //   (c) the stamped dom enables.
      __enableOrFlushClients() {
        let clients = this.__dataPendingClients;
        if (clients) {
          this.__dataPendingClients = null;
          for (let i=0; i < clients.length; i++) {
            let client = clients[i];
            if (!client.__dataEnabled) {
              client._enableProperties();
            } else if (client.__dataPending) {
              client._flushProperties();
            }
          }
        }
      }

      /**
       * Perform any initial setup on client dom. Called before the first
       * `_flushProperties` call on client dom and before any element
       * observers are called.
       *
       * @return {void}
       * @protected
       */
      _readyClients() {
        this.__enableOrFlushClients();
      }

      /**
       * Sets a bag of property changes to this instance, and
       * synchronously processes all effects of the properties as a batch.
       *
       * Property names must be simple properties, not paths.  Batched
       * path propagation is not supported.
       *
       * @param {Object} props Bag of one or more key-value pairs whose key is
       *   a property and value is the new value to set for that property.
       * @param {boolean=} setReadOnly When true, any private values set in
       *   `props` will be set. By default, `setProperties` will not set
       *   `readOnly: true` root properties.
       * @return {void}
       * @public
       */
      setProperties(props, setReadOnly) {
        for (let path in props) {
          if (setReadOnly || !this[TYPES.READ_ONLY] || !this[TYPES.READ_ONLY][path]) {
            //TODO(kschaaf): explicitly disallow paths in setProperty?
            // wildcard observers currently only pass the first changed path
            // in the `info` object, and you could do some odd things batching
            // paths, e.g. {'foo.bar': {...}, 'foo': null}
            this._setPendingPropertyOrPath(path, props[path], true);
          }
        }
        this._invalidateProperties();
      }

      /**
       * Overrides `PropertyAccessors` so that property accessor
       * side effects are not enabled until after client dom is fully ready.
       * Also calls `_flushClients` callback to ensure client dom is enabled
       * that was not enabled as a result of flushing properties.
       *
       * @override
       * @return {void}
       */
      ready() {
        // It is important that `super.ready()` is not called here as it
        // immediately turns on accessors. Instead, we wait until `readyClients`
        // to enable accessors to provide a guarantee that clients are ready
        // before processing any accessors side effects.
        this._flushProperties();
        // If no data was pending, `_flushProperties` will not `flushClients`
        // so ensure this is done.
        if (!this.__dataClientsReady) {
          this._flushClients();
        }
        // Before ready, client notifications do not trigger _flushProperties.
        // Therefore a flush is necessary here if data has been set.
        if (this.__dataPending) {
          this._flushProperties();
        }
      }

      /**
       * Implements `PropertyAccessors`'s properties changed callback.
       *
       * Runs each class of effects for the batch of changed properties in
       * a specific order (compute, propagate, reflect, observe, notify).
       *
       * @param {!Object} currentProps Bag of all current accessor values
       * @param {!Object} changedProps Bag of properties changed since the last
       *   call to `_propertiesChanged`
       * @param {!Object} oldProps Bag of previous values for each property
       *   in `changedProps`
       * @return {void}
       */
      _propertiesChanged(currentProps, changedProps, oldProps) {
        // ----------------------------
        // let c = Object.getOwnPropertyNames(changedProps || {});
        // window.debug && console.group(this.localName + '#' + this.id + ': ' + c);
        // if (window.debug) { debugger; }
        // ----------------------------
        let hasPaths = this.__dataHasPaths;
        this.__dataHasPaths = false;
        // Compute properties
        runComputedEffects(this, changedProps, oldProps, hasPaths);
        // Clear notify properties prior to possible reentry (propagate, observe),
        // but after computing effects have a chance to add to them
        let notifyProps = this.__dataToNotify;
        this.__dataToNotify = null;
        // Propagate properties to clients
        this._propagatePropertyChanges(changedProps, oldProps, hasPaths);
        // Flush clients
        this._flushClients();
        // Reflect properties
        runEffects(this, this[TYPES.REFLECT], changedProps, oldProps, hasPaths);
        // Observe properties
        runEffects(this, this[TYPES.OBSERVE], changedProps, oldProps, hasPaths);
        // Notify properties to host
        if (notifyProps) {
          runNotifyEffects(this, notifyProps, changedProps, oldProps, hasPaths);
        }
        // Clear temporary cache at end of turn
        if (this.__dataCounter == 1) {
          this.__dataTemp = {};
        }
        // ----------------------------
        // window.debug && console.groupEnd(this.localName + '#' + this.id + ': ' + c);
        // ----------------------------
      }

      /**
       * Called to propagate any property changes to stamped template nodes
       * managed by this element.
       *
       * @param {Object} changedProps Bag of changed properties
       * @param {Object} oldProps Bag of previous values for changed properties
       * @param {boolean} hasPaths True with `props` contains one or more paths
       * @return {void}
       * @protected
       */
      _propagatePropertyChanges(changedProps, oldProps, hasPaths) {
        if (this[TYPES.PROPAGATE]) {
          runEffects(this, this[TYPES.PROPAGATE], changedProps, oldProps, hasPaths);
        }
        let templateInfo = this.__templateInfo;
        while (templateInfo) {
          runEffects(this, templateInfo.propertyEffects, changedProps, oldProps,
            hasPaths, templateInfo.nodeList);
          templateInfo = templateInfo.nextTemplateInfo;
        }
      }

      /**
       * Aliases one data path as another, such that path notifications from one
       * are routed to the other.
       *
       * @param {string | !Array<string|number>} to Target path to link.
       * @param {string | !Array<string|number>} from Source path to link.
       * @return {void}
       * @public
       */
      linkPaths(to, from) {
        to = Polymer.Path.normalize(to);
        from = Polymer.Path.normalize(from);
        this.__dataLinkedPaths = this.__dataLinkedPaths || {};
        this.__dataLinkedPaths[to] = from;
      }

      /**
       * Removes a data path alias previously established with `_linkPaths`.
       *
       * Note, the path to unlink should be the target (`to`) used when
       * linking the paths.
       *
       * @param {string | !Array<string|number>} path Target path to unlink.
       * @return {void}
       * @public
       */
      unlinkPaths(path) {
        path = Polymer.Path.normalize(path);
        if (this.__dataLinkedPaths) {
          delete this.__dataLinkedPaths[path];
        }
      }

      /**
       * Notify that an array has changed.
       *
       * Example:
       *
       *     this.items = [ {name: 'Jim'}, {name: 'Todd'}, {name: 'Bill'} ];
       *     ...
       *     this.items.splice(1, 1, {name: 'Sam'});
       *     this.items.push({name: 'Bob'});
       *     this.notifySplices('items', [
       *       { index: 1, removed: [{name: 'Todd'}], addedCount: 1, object: this.items, type: 'splice' },
       *       { index: 3, removed: [], addedCount: 1, object: this.items, type: 'splice'}
       *     ]);
       *
       * @param {string} path Path that should be notified.
       * @param {Array} splices Array of splice records indicating ordered
       *   changes that occurred to the array. Each record should have the
       *   following fields:
       *    * index: index at which the change occurred
       *    * removed: array of items that were removed from this index
       *    * addedCount: number of new items added at this index
       *    * object: a reference to the array in question
       *    * type: the string literal 'splice'
       *
       *   Note that splice records _must_ be normalized such that they are
       *   reported in index order (raw results from `Object.observe` are not
       *   ordered and must be normalized/merged before notifying).
       * @return {void}
       * @public
      */
      notifySplices(path, splices) {
        let info = {path: ''};
        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
        notifySplices(this, array, info.path, splices);
      }

      /**
       * Convenience method for reading a value from a path.
       *
       * Note, if any part in the path is undefined, this method returns
       * `undefined` (this method does not throw when dereferencing undefined
       * paths).
       *
       * @param {(string|!Array<(string|number)>)} path Path to the value
       *   to read.  The path may be specified as a string (e.g. `foo.bar.baz`)
       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
       *   bracketed expressions are not supported; string-based path parts
       *   *must* be separated by dots.  Note that when dereferencing array
       *   indices, the index may be used as a dotted part directly
       *   (e.g. `users.12.name` or `['users', 12, 'name']`).
       * @param {Object=} root Root object from which the path is evaluated.
       * @return {*} Value at the path, or `undefined` if any part of the path
       *   is undefined.
       * @public
       */
      get(path, root) {
        return Polymer.Path.get(root || this, path);
      }

      /**
       * Convenience method for setting a value to a path and notifying any
       * elements bound to the same path.
       *
       * Note, if any part in the path except for the last is undefined,
       * this method does nothing (this method does not throw when
       * dereferencing undefined paths).
       *
       * @param {(string|!Array<(string|number)>)} path Path to the value
       *   to write.  The path may be specified as a string (e.g. `'foo.bar.baz'`)
       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
       *   bracketed expressions are not supported; string-based path parts
       *   *must* be separated by dots.  Note that when dereferencing array
       *   indices, the index may be used as a dotted part directly
       *   (e.g. `'users.12.name'` or `['users', 12, 'name']`).
       * @param {*} value Value to set at the specified path.
       * @param {Object=} root Root object from which the path is evaluated.
       *   When specified, no notification will occur.
       * @return {void}
       * @public
      */
      set(path, value, root) {
        if (root) {
          Polymer.Path.set(root, path, value);
        } else {
          if (!this[TYPES.READ_ONLY] || !this[TYPES.READ_ONLY][/** @type {string} */(path)]) {
            if (this._setPendingPropertyOrPath(path, value, true)) {
              this._invalidateProperties();
            }
          }
        }
      }

      /**
       * Adds items onto the end of the array at the path specified.
       *
       * The arguments after `path` and return value match that of
       * `Array.prototype.push`.
       *
       * This method notifies other paths to the same array that a
       * splice occurred to the array.
       *
       * @param {string | !Array<string|number>} path Path to array.
       * @param {...*} items Items to push onto array
       * @return {number} New length of the array.
       * @public
       */
      push(path, ...items) {
        let info = {path: ''};
        let array = /** @type {Array}*/(Polymer.Path.get(this, path, info));
        let len = array.length;
        let ret = array.push(...items);
        if (items.length) {
          notifySplice(this, array, info.path, len, items.length, []);
        }
        return ret;
      }

      /**
       * Removes an item from the end of array at the path specified.
       *
       * The arguments after `path` and return value match that of
       * `Array.prototype.pop`.
       *
       * This method notifies other paths to the same array that a
       * splice occurred to the array.
       *
       * @param {string | !Array<string|number>} path Path to array.
       * @return {*} Item that was removed.
       * @public
       */
      pop(path) {
        let info = {path: ''};
        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
        let hadLength = Boolean(array.length);
        let ret = array.pop();
        if (hadLength) {
          notifySplice(this, array, info.path, array.length, 0, [ret]);
        }
        return ret;
      }

      /**
       * Starting from the start index specified, removes 0 or more items
       * from the array and inserts 0 or more new items in their place.
       *
       * The arguments after `path` and return value match that of
       * `Array.prototype.splice`.
       *
       * This method notifies other paths to the same array that a
       * splice occurred to the array.
       *
       * @param {string | !Array<string|number>} path Path to array.
       * @param {number} start Index from which to start removing/inserting.
       * @param {number} deleteCount Number of items to remove.
       * @param {...*} items Items to insert into array.
       * @return {Array} Array of removed items.
       * @public
       */
      splice(path, start, deleteCount, ...items) {
        let info = {path : ''};
        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
        // Normalize fancy native splice handling of crazy start values
        if (start < 0) {
          start = array.length - Math.floor(-start);
        } else if (start) {
          start = Math.floor(start);
        }
        // array.splice does different things based on the number of arguments
        // you pass in. Therefore, array.splice(0) and array.splice(0, undefined)
        // do different things. In the former, the whole array is cleared. In the
        // latter, no items are removed.
        // This means that we need to detect whether 1. one of the arguments
        // is actually passed in and then 2. determine how many arguments
        // we should pass on to the native array.splice
        //
        let ret;
        // Omit any additional arguments if they were not passed in
        if (arguments.length === 2) {
          ret = array.splice(start);
        // Either start was undefined and the others were defined, but in this
        // case we can safely pass on all arguments
        //
        // Note: this includes the case where none of the arguments were passed in,
        // e.g. this.splice('array'). However, if both start and deleteCount
        // are undefined, array.splice will not modify the array (as expected)
        } else {
          ret = array.splice(start, deleteCount, ...items);
        }
        // At the end, check whether any items were passed in (e.g. insertions)
        // or if the return array contains items (e.g. deletions).
        // Only notify if items were added or deleted.
        if (items.length || ret.length) {
          notifySplice(this, array, info.path, start, items.length, ret);
        }
        return ret;
      }

      /**
       * Removes an item from the beginning of array at the path specified.
       *
       * The arguments after `path` and return value match that of
       * `Array.prototype.pop`.
       *
       * This method notifies other paths to the same array that a
       * splice occurred to the array.
       *
       * @param {string | !Array<string|number>} path Path to array.
       * @return {*} Item that was removed.
       * @public
       */
      shift(path) {
        let info = {path: ''};
        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
        let hadLength = Boolean(array.length);
        let ret = array.shift();
        if (hadLength) {
          notifySplice(this, array, info.path, 0, 0, [ret]);
        }
        return ret;
      }

      /**
       * Adds items onto the beginning of the array at the path specified.
       *
       * The arguments after `path` and return value match that of
       * `Array.prototype.push`.
       *
       * This method notifies other paths to the same array that a
       * splice occurred to the array.
       *
       * @param {string | !Array<string|number>} path Path to array.
       * @param {...*} items Items to insert info array
       * @return {number} New length of the array.
       * @public
       */
      unshift(path, ...items) {
        let info = {path: ''};
        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
        let ret = array.unshift(...items);
        if (items.length) {
          notifySplice(this, array, info.path, 0, items.length, []);
        }
        return ret;
      }

      /**
       * Notify that a path has changed.
       *
       * Example:
       *
       *     this.item.user.name = 'Bob';
       *     this.notifyPath('item.user.name');
       *
       * @param {string} path Path that should be notified.
       * @param {*=} value Value at the path (optional).
       * @return {void}
       * @public
      */
      notifyPath(path, value) {
        /** @type {string} */
        let propPath;
        if (arguments.length == 1) {
          // Get value if not supplied
          let info = {path: ''};
          value = Polymer.Path.get(this, path, info);
          propPath = info.path;
        } else if (Array.isArray(path)) {
          // Normalize path if needed
          propPath = Polymer.Path.normalize(path);
        } else {
          propPath = /** @type{string} */(path);
        }
        if (this._setPendingPropertyOrPath(propPath, value, true, true)) {
          this._invalidateProperties();
        }
      }

      /**
       * Equivalent to static `createReadOnlyProperty` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} property Property name
       * @param {boolean=} protectedSetter Creates a custom protected setter
       *   when `true`.
       * @return {void}
       * @protected
       */
      _createReadOnlyProperty(property, protectedSetter) {
        this._addPropertyEffect(property, TYPES.READ_ONLY);
        if (protectedSetter) {
          this['_set' + upper(property)] = /** @this {PropertyEffects} */function(value) {
            this._setProperty(property, value);
          };
        }
      }

      /**
       * Equivalent to static `createPropertyObserver` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} property Property name
       * @param {string|function(*,*)} method Function or name of observer method to call
       * @param {boolean=} dynamicFn Whether the method name should be included as
       *   a dependency to the effect.
       * @return {void}
       * @protected
       */
      _createPropertyObserver(property, method, dynamicFn) {
        let info = { property, method, dynamicFn: Boolean(dynamicFn) };
        this._addPropertyEffect(property, TYPES.OBSERVE, {
          fn: runObserverEffect, info, trigger: {name: property}
        });
        if (dynamicFn) {
          this._addPropertyEffect(/** @type {string} */(method), TYPES.OBSERVE, {
            fn: runObserverEffect, info, trigger: {name: method}
          });
        }
      }

      /**
       * Equivalent to static `createMethodObserver` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} expression Method expression
       * @param {boolean|Object=} dynamicFn Boolean or object map indicating
       *   whether method names should be included as a dependency to the effect.
       * @return {void}
       * @protected
       */
      _createMethodObserver(expression, dynamicFn) {
        let sig = parseMethod(expression);
        if (!sig) {
          throw new Error("Malformed observer expression '" + expression + "'");
        }
        createMethodEffect(this, sig, TYPES.OBSERVE, runMethodEffect, null, dynamicFn);
      }

      /**
       * Equivalent to static `createNotifyingProperty` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} property Property name
       * @return {void}
       * @protected
       */
      _createNotifyingProperty(property) {
        this._addPropertyEffect(property, TYPES.NOTIFY, {
          fn: runNotifyEffect,
          info: {
            eventName: CaseMap.camelToDashCase(property) + '-changed',
            property: property
          }
        });
      }

      /**
       * Equivalent to static `createReflectedProperty` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} property Property name
       * @return {void}
       * @protected
       */
      _createReflectedProperty(property) {
        let attr = this.constructor.attributeNameForProperty(property);
        if (attr[0] === '-') {
          console.warn('Property ' + property + ' cannot be reflected to attribute ' +
            attr + ' because "-" is not a valid starting attribute name. Use a lowercase first letter for the property instead.');
        } else {
          this._addPropertyEffect(property, TYPES.REFLECT, {
            fn: runReflectEffect,
            info: {
              attrName: attr
            }
          });
        }
      }

      /**
       * Equivalent to static `createComputedProperty` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} property Name of computed property to set
       * @param {string} expression Method expression
       * @param {boolean|Object=} dynamicFn Boolean or object map indicating
       *   whether method names should be included as a dependency to the effect.
       * @return {void}
       * @protected
       */
      _createComputedProperty(property, expression, dynamicFn) {
        let sig = parseMethod(expression);
        if (!sig) {
          throw new Error("Malformed computed expression '" + expression + "'");
        }
        createMethodEffect(this, sig, TYPES.COMPUTE, runComputedEffect, property, dynamicFn);
      }

      /**
       * Gather the argument values for a method specified in the provided array
       * of argument metadata.
       *
       * The `path` and `value` arguments are used to fill in wildcard descriptor
       * when the method is being called as a result of a path notification.
       *
       * @param {!Array<!MethodArg>} args Array of argument metadata
       * @param {string} path Property/path name that triggered the method effect
       * @param {Object} props Bag of current property changes
       * @return {Array<*>} Array of argument values
       * @private
       */
      _marshalArgs(args, path, props) {
        const data = this.__data;
        let values = [];
        for (let i=0, l=args.length; i<l; i++) {
          let arg = args[i];
          let name = arg.name;
          let v;
          if (arg.literal) {
            v = arg.value;
          } else {
            if (arg.structured) {
              v = Polymer.Path.get(data, name);
              // when data is not stored e.g. `splices`
              if (v === undefined) {
                v = props[name];
              }
            } else {
              v = data[name];
            }
          }
          if (arg.wildcard) {
            // Only send the actual path changed info if the change that
            // caused the observer to run matched the wildcard
            let baseChanged = (name.indexOf(path + '.') === 0);
            let matches = (path.indexOf(name) === 0 && !baseChanged);
            values[i] = {
              path: matches ? path : name,
              value: matches ? props[path] : v,
              base: v
            };
          } else {
            values[i] = v;
          }
        }
        return values;
      }

      // -- static class methods ------------

      /**
       * Ensures an accessor exists for the specified property, and adds
       * to a list of "property effects" that will run when the accessor for
       * the specified property is set.  Effects are grouped by "type", which
       * roughly corresponds to a phase in effect processing.  The effect
       * metadata should be in the following form:
       *
       *     {
       *       fn: effectFunction, // Reference to function to call to perform effect
       *       info: { ... }       // Effect metadata passed to function
       *       trigger: {          // Optional triggering metadata; if not provided
       *         name: string      // the property is treated as a wildcard
       *         structured: boolean
       *         wildcard: boolean
       *       }
       *     }
       *
       * Effects are called from `_propertiesChanged` in the following order by
       * type:
       *
       * 1. COMPUTE
       * 2. PROPAGATE
       * 3. REFLECT
       * 4. OBSERVE
       * 5. NOTIFY
       *
       * Effect functions are called with the following signature:
       *
       *     effectFunction(inst, path, props, oldProps, info, hasPaths)
       *
       * @param {string} property Property that should trigger the effect
       * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
       * @param {Object=} effect Effect metadata object
       * @return {void}
       * @protected
       */
      static addPropertyEffect(property, type, effect) {
        this.prototype._addPropertyEffect(property, type, effect);
      }

      /**
       * Creates a single-property observer for the given property.
       *
       * @param {string} property Property name
       * @param {string|function(*,*)} method Function or name of observer method to call
       * @param {boolean=} dynamicFn Whether the method name should be included as
       *   a dependency to the effect.
       * @return {void}
       * @protected
       */
      static createPropertyObserver(property, method, dynamicFn) {
        this.prototype._createPropertyObserver(property, method, dynamicFn);
      }

      /**
       * Creates a multi-property "method observer" based on the provided
       * expression, which should be a string in the form of a normal JavaScript
       * function signature: `'methodName(arg1, [..., argn])'`.  Each argument
       * should correspond to a property or path in the context of this
       * prototype (or instance), or may be a literal string or number.
       *
       * @param {string} expression Method expression
       * @param {boolean|Object=} dynamicFn Boolean or object map indicating
       * @return {void}
       *   whether method names should be included as a dependency to the effect.
       * @protected
       */
      static createMethodObserver(expression, dynamicFn) {
        this.prototype._createMethodObserver(expression, dynamicFn);
      }

      /**
       * Causes the setter for the given property to dispatch `<property>-changed`
       * events to notify of changes to the property.
       *
       * @param {string} property Property name
       * @return {void}
       * @protected
       */
      static createNotifyingProperty(property) {
        this.prototype._createNotifyingProperty(property);
      }

      /**
       * Creates a read-only accessor for the given property.
       *
       * To set the property, use the protected `_setProperty` API.
       * To create a custom protected setter (e.g. `_setMyProp()` for
       * property `myProp`), pass `true` for `protectedSetter`.
       *
       * Note, if the property will have other property effects, this method
       * should be called first, before adding other effects.
       *
       * @param {string} property Property name
       * @param {boolean=} protectedSetter Creates a custom protected setter
       *   when `true`.
       * @return {void}
       * @protected
       */
      static createReadOnlyProperty(property, protectedSetter) {
        this.prototype._createReadOnlyProperty(property, protectedSetter);
      }

      /**
       * Causes the setter for the given property to reflect the property value
       * to a (dash-cased) attribute of the same name.
       *
       * @param {string} property Property name
       * @return {void}
       * @protected
       */
      static createReflectedProperty(property) {
        this.prototype._createReflectedProperty(property);
      }

      /**
       * Creates a computed property whose value is set to the result of the
       * method described by the given `expression` each time one or more
       * arguments to the method changes.  The expression should be a string
       * in the form of a normal JavaScript function signature:
       * `'methodName(arg1, [..., argn])'`
       *
       * @param {string} property Name of computed property to set
       * @param {string} expression Method expression
       * @param {boolean|Object=} dynamicFn Boolean or object map indicating whether
       *   method names should be included as a dependency to the effect.
       * @return {void}
       * @protected
       */
      static createComputedProperty(property, expression, dynamicFn) {
        this.prototype._createComputedProperty(property, expression, dynamicFn);
      }

      /**
       * Parses the provided template to ensure binding effects are created
       * for them, and then ensures property accessors are created for any
       * dependent properties in the template.  Binding effects for bound
       * templates are stored in a linked list on the instance so that
       * templates can be efficiently stamped and unstamped.
       *
       * @param {!HTMLTemplateElement} template Template containing binding
       *   bindings
       * @return {!TemplateInfo} Template metadata object
       * @protected
       */
      static bindTemplate(template) {
        return this.prototype._bindTemplate(template);
      }

      // -- binding ----------------------------------------------

      /**
       * Equivalent to static `bindTemplate` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * This method may be called on the prototype (for prototypical template
       * binding, to avoid creating accessors every instance) once per prototype,
       * and will be called with `runtimeBinding: true` by `_stampTemplate` to
       * create and link an instance of the template metadata associated with a
       * particular stamping.
       *
       * @param {!HTMLTemplateElement} template Template containing binding
       *   bindings
       * @param {boolean=} instanceBinding When false (default), performs
       *   "prototypical" binding of the template and overwrites any previously
       *   bound template for the class. When true (as passed from
       *   `_stampTemplate`), the template info is instanced and linked into
       *   the list of bound templates.
       * @return {!TemplateInfo} Template metadata object; for `runtimeBinding`,
       *   this is an instance of the prototypical template info
       * @protected
       */
      _bindTemplate(template, instanceBinding) {
        let templateInfo = this.constructor._parseTemplate(template);
        let wasPreBound = this.__templateInfo == templateInfo;
        // Optimization: since this is called twice for proto-bound templates,
        // don't attempt to recreate accessors if this template was pre-bound
        if (!wasPreBound) {
          for (let prop in templateInfo.propertyEffects) {
            this._createPropertyAccessor(prop);
          }
        }
        if (instanceBinding) {
          // For instance-time binding, create instance of template metadata
          // and link into list of templates if necessary
          templateInfo = /** @type {!TemplateInfo} */(Object.create(templateInfo));
          templateInfo.wasPreBound = wasPreBound;
          if (!wasPreBound && this.__templateInfo) {
            let last = this.__templateInfoLast || this.__templateInfo;
            this.__templateInfoLast = last.nextTemplateInfo = templateInfo;
            templateInfo.previousTemplateInfo = last;
            return templateInfo;
          }
        }
        return this.__templateInfo = templateInfo;
      }

      /**
       * Adds a property effect to the given template metadata, which is run
       * at the "propagate" stage of `_propertiesChanged` when the template
       * has been bound to the element via `_bindTemplate`.
       *
       * The `effect` object should match the format in `_addPropertyEffect`.
       *
       * @param {Object} templateInfo Template metadata to add effect to
       * @param {string} prop Property that should trigger the effect
       * @param {Object=} effect Effect metadata object
       * @return {void}
       * @protected
       */
      static _addTemplatePropertyEffect(templateInfo, prop, effect) {
        let hostProps = templateInfo.hostProps = templateInfo.hostProps || {};
        hostProps[prop] = true;
        let effects = templateInfo.propertyEffects = templateInfo.propertyEffects || {};
        let propEffects = effects[prop] = effects[prop] || [];
        propEffects.push(effect);
      }

      /**
       * Stamps the provided template and performs instance-time setup for
       * Polymer template features, including data bindings, declarative event
       * listeners, and the `this.$` map of `id`'s to nodes.  A document fragment
       * is returned containing the stamped DOM, ready for insertion into the
       * DOM.
       *
       * This method may be called more than once; however note that due to
       * `shadycss` polyfill limitations, only styles from templates prepared
       * using `ShadyCSS.prepareTemplate` will be correctly polyfilled (scoped
       * to the shadow root and support CSS custom properties), and note that
       * `ShadyCSS.prepareTemplate` may only be called once per element. As such,
       * any styles required by in runtime-stamped templates must be included
       * in the main element template.
       *
       * @param {!HTMLTemplateElement} template Template to stamp
       * @return {!StampedTemplate} Cloned template content
       * @override
       * @protected
       */
      _stampTemplate(template) {
        // Ensures that created dom is `_enqueueClient`'d to this element so
        // that it can be flushed on next call to `_flushProperties`
        hostStack.beginHosting(this);
        let dom = super._stampTemplate(template);
        hostStack.endHosting(this);
        let templateInfo = /** @type {!TemplateInfo} */(this._bindTemplate(template, true));
        // Add template-instance-specific data to instanced templateInfo
        templateInfo.nodeList = dom.nodeList;
        // Capture child nodes to allow unstamping of non-prototypical templates
        if (!templateInfo.wasPreBound) {
          let nodes = templateInfo.childNodes = [];
          for (let n=dom.firstChild; n; n=n.nextSibling) {
            nodes.push(n);
          }
        }
        dom.templateInfo = templateInfo;
        // Setup compound storage, 2-way listeners, and dataHost for bindings
        setupBindings(this, templateInfo);
        // Flush properties into template nodes if already booted
        if (this.__dataReady) {
          runEffects(this, templateInfo.propertyEffects, this.__data, null,
            false, templateInfo.nodeList);
        }
        return dom;
      }

      /**
       * Removes and unbinds the nodes previously contained in the provided
       * DocumentFragment returned from `_stampTemplate`.
       *
       * @param {!StampedTemplate} dom DocumentFragment previously returned
       *   from `_stampTemplate` associated with the nodes to be removed
       * @return {void}
       * @protected
       */
      _removeBoundDom(dom) {
        // Unlink template info
        let templateInfo = dom.templateInfo;
        if (templateInfo.previousTemplateInfo) {
          templateInfo.previousTemplateInfo.nextTemplateInfo =
            templateInfo.nextTemplateInfo;
        }
        if (templateInfo.nextTemplateInfo) {
          templateInfo.nextTemplateInfo.previousTemplateInfo =
            templateInfo.previousTemplateInfo;
        }
        if (this.__templateInfoLast == templateInfo) {
          this.__templateInfoLast = templateInfo.previousTemplateInfo;
        }
        templateInfo.previousTemplateInfo = templateInfo.nextTemplateInfo = null;
        // Remove stamped nodes
        let nodes = templateInfo.childNodes;
        for (let i=0; i<nodes.length; i++) {
          let node = nodes[i];
          node.parentNode.removeChild(node);
        }
      }

      /**
       * Overrides default `TemplateStamp` implementation to add support for
       * parsing bindings from `TextNode`'s' `textContent`.  A `bindings`
       * array is added to `nodeInfo` and populated with binding metadata
       * with information capturing the binding target, and a `parts` array
       * with one or more metadata objects capturing the source(s) of the
       * binding.
       *
       * @override
       * @param {Node} node Node to parse
       * @param {TemplateInfo} templateInfo Template metadata for current template
       * @param {NodeInfo} nodeInfo Node metadata for current template node
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       * @protected
       * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
       */
      static _parseTemplateNode(node, templateInfo, nodeInfo) {
        let noted = super._parseTemplateNode(node, templateInfo, nodeInfo);
        if (node.nodeType === Node.TEXT_NODE) {
          let parts = this._parseBindings(node.textContent, templateInfo);
          if (parts) {
            // Initialize the textContent with any literal parts
            // NOTE: default to a space here so the textNode remains; some browsers
            // (IE) omit an empty textNode following cloneNode/importNode.
            node.textContent = literalFromParts(parts) || ' ';
            addBinding(this, templateInfo, nodeInfo, 'text', 'textContent', parts);
            noted = true;
          }
        }
        return noted;
      }

      /**
       * Overrides default `TemplateStamp` implementation to add support for
       * parsing bindings from attributes.  A `bindings`
       * array is added to `nodeInfo` and populated with binding metadata
       * with information capturing the binding target, and a `parts` array
       * with one or more metadata objects capturing the source(s) of the
       * binding.
       *
       * @override
       * @param {Element} node Node to parse
       * @param {TemplateInfo} templateInfo Template metadata for current template
       * @param {NodeInfo} nodeInfo Node metadata for current template node
       * @param {string} name Attribute name
       * @param {string} value Attribute value
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       * @protected
       * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
       */
      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
        let parts = this._parseBindings(value, templateInfo);
        if (parts) {
          // Attribute or property
          let origName = name;
          let kind = 'property';
          // The only way we see a capital letter here is if the attr has
          // a capital letter in it per spec. In this case, to make sure
          // this binding works, we go ahead and make the binding to the attribute.
          if (capitalAttributeRegex.test(name)) {
            kind = 'attribute';
          } else if (name[name.length-1] == '$') {
            name = name.slice(0, -1);
            kind = 'attribute';
          }
          // Initialize attribute bindings with any literal parts
          let literal = literalFromParts(parts);
          if (literal && kind == 'attribute') {
            // Ensure a ShadyCSS template scoped style is not removed
            // when a class$ binding's initial literal value is set.
            if (name == 'class' && node.hasAttribute('class')) {
              literal += ' ' + node.getAttribute(name);
            }
            node.setAttribute(name, literal);
          }
          // Clear attribute before removing, since IE won't allow removing
          // `value` attribute if it previously had a value (can't
          // unconditionally set '' before removing since attributes with `$`
          // can't be set using setAttribute)
          if (node.localName === 'input' && origName === 'value') {
            node.setAttribute(origName, '');
          }
          // Remove annotation
          node.removeAttribute(origName);
          // Case hackery: attributes are lower-case, but bind targets
          // (properties) are case sensitive. Gambit is to map dash-case to
          // camel-case: `foo-bar` becomes `fooBar`.
          // Attribute bindings are excepted.
          if (kind === 'property') {
            name = Polymer.CaseMap.dashToCamelCase(name);
          }
          addBinding(this, templateInfo, nodeInfo, kind, name, parts, literal);
          return true;
        } else {
          return super._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value);
        }
      }

      /**
       * Overrides default `TemplateStamp` implementation to add support for
       * binding the properties that a nested template depends on to the template
       * as `_host_<property>`.
       *
       * @override
       * @param {Node} node Node to parse
       * @param {TemplateInfo} templateInfo Template metadata for current template
       * @param {NodeInfo} nodeInfo Node metadata for current template node
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       * @protected
       * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
       */
      static _parseTemplateNestedTemplate(node, templateInfo, nodeInfo) {
        let noted = super._parseTemplateNestedTemplate(node, templateInfo, nodeInfo);
        // Merge host props into outer template and add bindings
        let hostProps = nodeInfo.templateInfo.hostProps;
        let mode = '{';
        for (let source in hostProps) {
          let parts = [{ mode, source, dependencies: [source] }];
          addBinding(this, templateInfo, nodeInfo, 'property', '_host_' + source, parts);
        }
        return noted;
      }

      /**
       * Called to parse text in a template (either attribute values or
       * textContent) into binding metadata.
       *
       * Any overrides of this method should return an array of binding part
       * metadata  representing one or more bindings found in the provided text
       * and any "literal" text in between.  Any non-literal parts will be passed
       * to `_evaluateBinding` when any dependencies change.  The only required
       * fields of each "part" in the returned array are as follows:
       *
       * - `dependencies` - Array containing trigger metadata for each property
       *   that should trigger the binding to update
       * - `literal` - String containing text if the part represents a literal;
       *   in this case no `dependencies` are needed
       *
       * Additional metadata for use by `_evaluateBinding` may be provided in
       * each part object as needed.
       *
       * The default implementation handles the following types of bindings
       * (one or more may be intermixed with literal strings):
       * - Property binding: `[[prop]]`
       * - Path binding: `[[object.prop]]`
       * - Negated property or path bindings: `[[!prop]]` or `[[!object.prop]]`
       * - Two-way property or path bindings (supports negation):
       *   `{{prop}}`, `{{object.prop}}`, `{{!prop}}` or `{{!object.prop}}`
       * - Inline computed method (supports negation):
       *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
       *
       * The default implementation uses a regular expression for best
       * performance. However, the regular expression uses a white-list of
       * allowed characters in a data-binding, which causes problems for
       * data-bindings that do use characters not in this white-list.
       *
       * Instead of updating the white-list with all allowed characters,
       * there is a StrictBindingParser (see lib/mixins/strict-binding-parser)
       * that uses a state machine instead. This state machine is able to handle
       * all characters. However, it is slightly less performant, therefore we
       * extracted it into a separate optional mixin.
       *
       * @param {string} text Text to parse from attribute or textContent
       * @param {Object} templateInfo Current template metadata
       * @return {Array<!BindingPart>} Array of binding part metadata
       * @protected
       */
      static _parseBindings(text, templateInfo) {
        let parts = [];
        let lastIndex = 0;
        let m;
        // Example: "literal1{{prop}}literal2[[!compute(foo,bar)]]final"
        // Regex matches:
        //        Iteration 1:  Iteration 2:
        // m[1]: '{{'          '[['
        // m[2]: ''            '!'
        // m[3]: 'prop'        'compute(foo,bar)'
        while ((m = bindingRegex.exec(text)) !== null) {
          // Add literal part
          if (m.index > lastIndex) {
            parts.push({literal: text.slice(lastIndex, m.index)});
          }
          // Add binding part
          let mode = m[1][0];
          let negate = Boolean(m[2]);
          let source = m[3].trim();
          let customEvent = false, notifyEvent = '', colon = -1;
          if (mode == '{' && (colon = source.indexOf('::')) > 0) {
            notifyEvent = source.substring(colon + 2);
            source = source.substring(0, colon);
            customEvent = true;
          }
          let signature = parseMethod(source);
          let dependencies = [];
          if (signature) {
            // Inline computed function
            let {args, methodName} = signature;
            for (let i=0; i<args.length; i++) {
              let arg = args[i];
              if (!arg.literal) {
                dependencies.push(arg);
              }
            }
            let dynamicFns = templateInfo.dynamicFns;
            if (dynamicFns && dynamicFns[methodName] || signature.static) {
              dependencies.push(methodName);
              signature.dynamicFn = true;
            }
          } else {
            // Property or path
            dependencies.push(source);
          }
          parts.push({
            source, mode, negate, customEvent, signature, dependencies,
            event: notifyEvent
          });
          lastIndex = bindingRegex.lastIndex;
        }
        // Add a final literal part
        if (lastIndex && lastIndex < text.length) {
          let literal = text.substring(lastIndex);
          if (literal) {
            parts.push({
              literal: literal
            });
          }
        }
        if (parts.length) {
          return parts;
        } else {
          return null;
        }
      }

      /**
       * Called to evaluate a previously parsed binding part based on a set of
       * one or more changed dependencies.
       *
       * @param {this} inst Element that should be used as scope for
       *   binding dependencies
       * @param {BindingPart} part Binding part metadata
       * @param {string} path Property/path that triggered this effect
       * @param {Object} props Bag of current property changes
       * @param {Object} oldProps Bag of previous values for changed properties
       * @param {boolean} hasPaths True with `props` contains one or more paths
       * @return {*} Value the binding part evaluated to
       * @protected
       */
      static _evaluateBinding(inst, part, path, props, oldProps, hasPaths) {
        let value;
        if (part.signature) {
          value = runMethodEffect(inst, path, props, oldProps, part.signature);
        } else if (path != part.source) {
          value = Polymer.Path.get(inst, part.source);
        } else {
          if (hasPaths && Polymer.Path.isPath(path)) {
            value = Polymer.Path.get(inst, path);
          } else {
            value = inst.__data[path];
          }
        }
        if (part.negate) {
          value = !value;
        }
        return value;
      }

    }

    // make a typing for closure :P
    PropertyEffectsType = PropertyEffects;

    return PropertyEffects;
  });

  /**
   * Helper api for enqueuing client dom created by a host element.
   *
   * By default elements are flushed via `_flushProperties` when
   * `connectedCallback` is called. Elements attach their client dom to
   * themselves at `ready` time which results from this first flush.
   * This provides an ordering guarantee that the client dom an element
   * creates is flushed before the element itself (i.e. client `ready`
   * fires before host `ready`).
   *
   * However, if `_flushProperties` is called *before* an element is connected,
   * as for example `Templatize` does, this ordering guarantee cannot be
   * satisfied because no elements are connected. (Note: Bound elements that
   * receive data do become enqueued clients and are properly ordered but
   * unbound elements are not.)
   *
   * To maintain the desired "client before host" ordering guarantee for this
   * case we rely on the "host stack. Client nodes registers themselves with
   * the creating host element when created. This ensures that all client dom
   * is readied in the proper order, maintaining the desired guarantee.
   *
   * @private
   */
  let hostStack = {

    stack: [],

    /**
     * @param {*} inst Instance to add to hostStack
     * @return {void}
     * @this {hostStack}
     */
    registerHost(inst) {
      if (this.stack.length) {
        let host = this.stack[this.stack.length-1];
        host._enqueueClient(inst);
      }
    },

    /**
     * @param {*} inst Instance to begin hosting
     * @return {void}
     * @this {hostStack}
     */
    beginHosting(inst) {
      this.stack.push(inst);
    },

    /**
     * @param {*} inst Instance to end hosting
     * @return {void}
     * @this {hostStack}
     */
    endHosting(inst) {
      let stackLen = this.stack.length;
      if (stackLen && this.stack[stackLen-1] == inst) {
        this.stack.pop();
      }
    }

  };

})();


(function() {
  'use strict';

  /**
   * Provides basic tracking of element definitions (registrations) and
   * instance counts.
   *
   * @namespace
   * @summary Provides basic tracking of element definitions (registrations) and
   * instance counts.
   */
  Polymer.telemetry = {
    /**
     * Total number of Polymer element instances created.
     * @type {number}
     */
    instanceCount: 0,
    /**
     * Array of Polymer element classes that have been finalized.
     * @type {Array<Polymer.Element>}
     */
    registrations: [],
    /**
     * @param {!PolymerElementConstructor} prototype Element prototype to log
     * @this {this}
     * @private
     */
    _regLog: function(prototype) {
      console.log('[' + prototype.is + ']: registered');
    },
    /**
     * Registers a class prototype for telemetry purposes.
     * @param {HTMLElement} prototype Element prototype to register
     * @this {this}
     * @protected
     */
    register: function(prototype) {
      this.registrations.push(prototype);
      Polymer.log && this._regLog(prototype);
    },
    /**
     * Logs all elements registered with an `is` to the console.
     * @public
     * @this {this}
     */
    dumpRegistrations: function() {
      this.registrations.forEach(this._regLog);
    }
  };

})();


(function() {
  'use strict';

  /**
   * Creates a copy of `props` with each property normalized such that
   * upgraded it is an object with at least a type property { type: Type}.
   *
   * @param {Object} props Properties to normalize
   * @return {Object} Copy of input `props` with normalized properties that
   * are in the form {type: Type}
   * @private
   */
  function normalizeProperties(props) {
    const output = {};
    for (let p in props) {
      const o = props[p];
      output[p] = (typeof o === 'function') ? {type: o} : o;
    }
    return output;
  }

  /**
   * Mixin that provides a minimal starting point to using the PropertiesChanged
   * mixin by providing a mechanism to declare properties in a static
   * getter (e.g. static get properties() { return { foo: String } }). Changes
   * are reported via the `_propertiesChanged` method.
   *
   * This mixin provides no specific support for rendering. Users are expected
   * to create a ShadowRoot and put content into it and update it in whatever
   * way makes sense. This can be done in reaction to properties changing by
   * implementing `_propertiesChanged`.
   *
   * @mixinFunction
   * @polymer
   * @appliesMixin Polymer.PropertiesChanged
   * @memberof Polymer
   * @summary Mixin that provides a minimal starting point for using
   * the PropertiesChanged mixin by providing a declarative `properties` object.
   */
   Polymer.PropertiesMixin = Polymer.dedupingMixin(superClass => {

    /**
     * @constructor
     * @extends {superClass}
     * @implements {Polymer_PropertiesChanged}
     * @private
     */
    const base = Polymer.PropertiesChanged(superClass);

    /**
     * Returns the super class constructor for the given class, if it is an
     * instance of the PropertiesMixin.
     *
     * @param {!PropertiesMixinConstructor} constructor PropertiesMixin constructor
     * @return {PropertiesMixinConstructor} Super class constructor
     */
    function superPropertiesClass(constructor) {
      const superCtor = Object.getPrototypeOf(constructor);

      // Note, the `PropertiesMixin` class below only refers to the class
      // generated by this call to the mixin; the instanceof test only works
      // because the mixin is deduped and guaranteed only to apply once, hence
      // all constructors in a proto chain will see the same `PropertiesMixin`
      return (superCtor.prototype instanceof PropertiesMixin) ?
        /** @type {PropertiesMixinConstructor} */ (superCtor) : null;
    }

    /**
     * Returns a memoized version of the `properties` object for the
     * given class. Properties not in object format are converted to at
     * least {type}.
     *
     * @param {PropertiesMixinConstructor} constructor PropertiesMixin constructor
     * @return {Object} Memoized properties object
     */
    function ownProperties(constructor) {
      if (!constructor.hasOwnProperty(JSCompiler_renameProperty('__ownProperties', constructor))) {
        let props = null;

        if (constructor.hasOwnProperty(JSCompiler_renameProperty('properties', constructor))) {
          const properties = constructor.properties;
          
          if (properties) {
            props = normalizeProperties(properties);
          }
        }

        constructor.__ownProperties = props;
      }
      return constructor.__ownProperties;
    }

    /**
     * @polymer
     * @mixinClass
     * @extends {base}
     * @implements {Polymer_PropertiesMixin}
     * @unrestricted
     */
    class PropertiesMixin extends base {

      /**
       * Implements standard custom elements getter to observes the attributes
       * listed in `properties`.
       * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
       */
      static get observedAttributes() {
        if (!this.hasOwnProperty('__observedAttributes')) {
          Polymer.telemetry.register(this.prototype);
          const props = this._properties;
          this.__observedAttributes = props ? Object.keys(props).map(p => this.attributeNameForProperty(p)) : [];
        }
        return this.__observedAttributes;
      }

      /**
       * Finalizes an element definition, including ensuring any super classes
       * are also finalized. This includes ensuring property
       * accessors exist on the element prototype. This method calls
       * `_finalizeClass` to finalize each constructor in the prototype chain.
       * @return {void}
       */
      static finalize() {
        if (!this.hasOwnProperty(JSCompiler_renameProperty('__finalized', this))) {
          const superCtor = superPropertiesClass(/** @type {PropertiesMixinConstructor} */(this));
          if (superCtor) {
            superCtor.finalize();
          }
          this.__finalized = true;
          this._finalizeClass();
        }
      }

      /**
       * Finalize an element class. This includes ensuring property
       * accessors exist on the element prototype. This method is called by
       * `finalize` and finalizes the class constructor.
       *
       * @protected
       */
      static _finalizeClass() {
        const props = ownProperties(/** @type {PropertiesMixinConstructor} */(this));
        if (props) {
          this.createProperties(props);
        }
      }

      /**
       * Returns a memoized version of all properties, including those inherited
       * from super classes. Properties not in object format are converted to
       * at least {type}.
       *
       * @return {Object} Object containing properties for this class
       * @protected
       */
      static get _properties() {
        if (!this.hasOwnProperty(
          JSCompiler_renameProperty('__properties', this))) {
          const superCtor = superPropertiesClass(/** @type {PropertiesMixinConstructor} */(this));
          this.__properties = Object.assign({},
            superCtor && superCtor._properties,
            ownProperties(/** @type {PropertiesMixinConstructor} */(this)));
        }
        return this.__properties;
      }

      /**
       * Overrides `PropertiesChanged` method to return type specified in the
       * static `properties` object for the given property.
       * @param {string} name Name of property
       * @return {*} Type to which to deserialize attribute
       *
       * @protected
       */
      static typeForProperty(name) {
        const info = this._properties[name];
        return info && info.type;
      }

      /**
       * Overrides `PropertiesChanged` method and adds a call to
       * `finalize` which lazily configures the element's property accessors.
       * @override
       * @return {void}
       */
      _initializeProperties() {
        Polymer.telemetry.instanceCount++;
        this.constructor.finalize();
        super._initializeProperties();
      }

      /**
       * Called when the element is added to a document.
       * Calls `_enableProperties` to turn on property system from
       * `PropertiesChanged`.
       * @suppress {missingProperties} Super may or may not implement the callback
       * @return {void}
       */
      connectedCallback() {
        if (super.connectedCallback) {
          super.connectedCallback();
        }
        this._enableProperties();
      }

      /**
       * Called when the element is removed from a document
       * @suppress {missingProperties} Super may or may not implement the callback
       * @return {void}
       */
      disconnectedCallback() {
        if (super.disconnectedCallback) {
          super.disconnectedCallback();
        }
      }

    }

    return PropertiesMixin;

  });

})();



(function() {
  'use strict';

  const builtCSS = window.ShadyCSS && window.ShadyCSS['cssBuild'];

  /**
   * Element class mixin that provides the core API for Polymer's meta-programming
   * features including template stamping, data-binding, attribute deserialization,
   * and property change observation.
   *
   * Subclassers may provide the following static getters to return metadata
   * used to configure Polymer's features for the class:
   *
   * - `static get is()`: When the template is provided via a `dom-module`,
   *   users should return the `dom-module` id from a static `is` getter.  If
   *   no template is needed or the template is provided directly via the
   *   `template` getter, there is no need to define `is` for the element.
   *
   * - `static get template()`: Users may provide the template directly (as
   *   opposed to via `dom-module`) by implementing a static `template` getter.
   *   The getter may return an `HTMLTemplateElement` or a string, which will
   *   automatically be parsed into a template.
   *
   * - `static get properties()`: Should return an object describing
   *   property-related metadata used by Polymer features (key: property name
   *   value: object containing property metadata). Valid keys in per-property
   *   metadata include:
   *   - `type` (String|Number|Object|Array|...): Used by
   *     `attributeChangedCallback` to determine how string-based attributes
   *     are deserialized to JavaScript property values.
   *   - `notify` (boolean): Causes a change in the property to fire a
   *     non-bubbling event called `<property>-changed`. Elements that have
   *     enabled two-way binding to the property use this event to observe changes.
   *   - `readOnly` (boolean): Creates a getter for the property, but no setter.
   *     To set a read-only property, use the private setter method
   *     `_setProperty(property, value)`.
   *   - `observer` (string): Observer method name that will be called when
   *     the property changes. The arguments of the method are
   *     `(value, previousValue)`.
   *   - `computed` (string): String describing method and dependent properties
   *     for computing the value of this property (e.g. `'computeFoo(bar, zot)'`).
   *     Computed properties are read-only by default and can only be changed
   *     via the return value of the computing method.
   *
   * - `static get observers()`: Array of strings describing multi-property
   *   observer methods and their dependent properties (e.g.
   *   `'observeABC(a, b, c)'`).
   *
   * The base class provides default implementations for the following standard
   * custom element lifecycle callbacks; users may override these, but should
   * call the super method to ensure
   * - `constructor`: Run when the element is created or upgraded
   * - `connectedCallback`: Run each time the element is connected to the
   *   document
   * - `disconnectedCallback`: Run each time the element is disconnected from
   *   the document
   * - `attributeChangedCallback`: Run each time an attribute in
   *   `observedAttributes` is set or removed (note: this element's default
   *   `observedAttributes` implementation will automatically return an array
   *   of dash-cased attributes based on `properties`)
   *
   * @mixinFunction
   * @polymer
   * @appliesMixin Polymer.PropertyEffects
   * @appliesMixin Polymer.PropertiesMixin
   * @memberof Polymer
   * @property rootPath {string} Set to the value of `Polymer.rootPath`,
   *   which defaults to the main document path
   * @property importPath {string} Set to the value of the class's static
   *   `importPath` property, which defaults to the path of this element's
   *   `dom-module` (when `is` is used), but can be overridden for other
   *   import strategies.
   * @summary Element class mixin that provides the core API for Polymer's
   * meta-programming features.
   */
  Polymer.ElementMixin = Polymer.dedupingMixin(base => {

    /**
     * @constructor
     * @extends {base}
     * @implements {Polymer_PropertyEffects}
     * @implements {Polymer_PropertiesMixin}
     * @private
     */
    const polymerElementBase = Polymer.PropertiesMixin(Polymer.PropertyEffects(base));

    /**
     * Returns a list of properties with default values.
     * This list is created as an optimization since it is a subset of
     * the list returned from `_properties`.
     * This list is used in `_initializeProperties` to set property defaults.
     *
     * @param {PolymerElementConstructor} constructor Element class
     * @return {PolymerElementProperties} Flattened properties for this class
     *   that have default values
     * @private
     */
    function propertyDefaults(constructor) {
      if (!constructor.hasOwnProperty(
        JSCompiler_renameProperty('__propertyDefaults', constructor))) {
        constructor.__propertyDefaults = null;
        let props = constructor._properties;
        for (let p in props) {
          let info = props[p];
          if ('value' in info) {
            constructor.__propertyDefaults = constructor.__propertyDefaults || {};
            constructor.__propertyDefaults[p] = info;
          }
        }
      }
      return constructor.__propertyDefaults;
    }

    /**
     * Returns a memoized version of the `observers` array.
     * @param {PolymerElementConstructor} constructor Element class
     * @return {Array} Array containing own observers for the given class
     * @protected
     */
    function ownObservers(constructor) {
      if (!constructor.hasOwnProperty(
        JSCompiler_renameProperty('__ownObservers', constructor))) {
          constructor.__ownObservers =
          constructor.hasOwnProperty(JSCompiler_renameProperty('observers', constructor)) ?
          /** @type {PolymerElementConstructor} */ (constructor).observers : null;
      }
      return constructor.__ownObservers;
    }

    /**
     * Creates effects for a property.
     *
     * Note, once a property has been set to
     * `readOnly`, `computed`, `reflectToAttribute`, or `notify`
     * these values may not be changed. For example, a subclass cannot
     * alter these settings. However, additional `observers` may be added
     * by subclasses.
     *
     * The info object should contain property metadata as follows:
     *
     * * `type`: {function} type to which an attribute matching the property
     * is deserialized. Note the property is camel-cased from a dash-cased
     * attribute. For example, 'foo-bar' attribute is deserialized to a
     * property named 'fooBar'.
     *
     * * `readOnly`: {boolean} creates a readOnly property and
     * makes a private setter for the private of the form '_setFoo' for a
     * property 'foo',
     *
     * * `computed`: {string} creates a computed property. A computed property
     * is also automatically set to `readOnly: true`. The value is calculated
     * by running a method and arguments parsed from the given string. For
     * example 'compute(foo)' will compute a given property when the
     * 'foo' property changes by executing the 'compute' method. This method
     * must return the computed value.
     *
     * * `reflectToAttribute`: {boolean} If true, the property value is reflected
     * to an attribute of the same name. Note, the attribute is dash-cased
     * so a property named 'fooBar' is reflected as 'foo-bar'.
     *
     * * `notify`: {boolean} sends a non-bubbling notification event when
     * the property changes. For example, a property named 'foo' sends an
     * event named 'foo-changed' with `event.detail` set to the value of
     * the property.
     *
     * * observer: {string} name of a method that runs when the property
     * changes. The arguments of the method are (value, previousValue).
     *
     * Note: Users may want control over modifying property
     * effects via subclassing. For example, a user might want to make a
     * reflectToAttribute property not do so in a subclass. We've chosen to
     * disable this because it leads to additional complication.
     * For example, a readOnly effect generates a special setter. If a subclass
     * disables the effect, the setter would fail unexpectedly.
     * Based on feedback, we may want to try to make effects more malleable
     * and/or provide an advanced api for manipulating them.
     * Also consider adding warnings when an effect cannot be changed.
     *
     * @param {!PolymerElement} proto Element class prototype to add accessors
     *   and effects to
     * @param {string} name Name of the property.
     * @param {Object} info Info object from which to create property effects.
     * Supported keys:
     * @param {Object} allProps Flattened map of all properties defined in this
     *   element (including inherited properties)
     * @return {void}
     * @private
     */
    function createPropertyFromConfig(proto, name, info, allProps) {
      // computed forces readOnly...
      if (info.computed) {
        info.readOnly = true;
      }
      // Note, since all computed properties are readOnly, this prevents
      // adding additional computed property effects (which leads to a confusing
      // setup where multiple triggers for setting a property)
      // While we do have `hasComputedEffect` this is set on the property's
      // dependencies rather than itself.
      if (info.computed && !proto._hasReadOnlyEffect(name)) {
        proto._createComputedProperty(name, info.computed, allProps);
      }
      if (info.readOnly && !proto._hasReadOnlyEffect(name)) {
        proto._createReadOnlyProperty(name, !info.computed);
      }
      if (info.reflectToAttribute && !proto._hasReflectEffect(name)) {
        proto._createReflectedProperty(name);
      }
      if (info.notify && !proto._hasNotifyEffect(name)) {
        proto._createNotifyingProperty(name);
      }
      // always add observer
      if (info.observer) {
        proto._createPropertyObserver(name, info.observer, allProps[info.observer]);
      }
      // always create the mapping from attribute back to property for deserialization.
      proto._addPropertyToAttributeMap(name);
    }

    /**
     * Process all style elements in the element template. Styles with the
     * `include` attribute are processed such that any styles in
     * the associated "style modules" are included in the element template.
     * @param {PolymerElementConstructor} klass Element class
     * @param {!HTMLTemplateElement} template Template to process
     * @param {string} is Name of element
     * @param {string} baseURI Base URI for element
     * @private
     */
    function processElementStyles(klass, template, is, baseURI) {
      if (!builtCSS) {
        const templateStyles = template.content.querySelectorAll('style');
        const stylesWithImports = Polymer.StyleGather.stylesFromTemplate(template);
        // insert styles from <link rel="import" type="css"> at the top of the template
        const linkedStyles = Polymer.StyleGather.stylesFromModuleImports(is);
        const firstTemplateChild = template.content.firstElementChild;
        for (let idx = 0; idx < linkedStyles.length; idx++) {
          let s = linkedStyles[idx];
          s.textContent = klass._processStyleText(s.textContent, baseURI);
          template.content.insertBefore(s, firstTemplateChild);
        }
        // keep track of the last "concrete" style in the template we have encountered
        let templateStyleIndex = 0;
        // ensure all gathered styles are actually in this template.
        for (let i = 0; i < stylesWithImports.length; i++) {
          let s = stylesWithImports[i];
          let templateStyle = templateStyles[templateStyleIndex];
          // if the style is not in this template, it's been "included" and
          // we put a clone of it in the template before the style that included it
          if (templateStyle !== s) {
            s = s.cloneNode(true);
            templateStyle.parentNode.insertBefore(s, templateStyle);
          } else {
            templateStyleIndex++;
          }
          s.textContent = klass._processStyleText(s.textContent, baseURI);
        }
      }
      if (window.ShadyCSS) {
        window.ShadyCSS.prepareTemplate(template, is);
      }
    }

    /**
     * Look up template from dom-module for element
     *
     * @param {!string} is Element name to look up
     * @return {!HTMLTemplateElement} Template found in dom module, or
     *   undefined if not found
     * @protected
     */
    function getTemplateFromDomModule(is) {
      let template = null;
      if (is && Polymer.DomModule) {
        template = Polymer.DomModule.import(is, 'template');
        // Under strictTemplatePolicy, require any element with an `is`
        // specified to have a dom-module
        if (Polymer.strictTemplatePolicy && !template) {
          throw new Error(`strictTemplatePolicy: expecting dom-module or null template for ${is}`);
        }
      }
      return template;
    }

  /**
     * @polymer
     * @mixinClass
     * @unrestricted
     * @implements {Polymer_ElementMixin}
     */
    class PolymerElement extends polymerElementBase {

      /**
       * Override of PropertiesMixin _finalizeClass to create observers and
       * find the template.
       * @return {void}
       * @protected
       * @override
       * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
       */
      static _finalizeClass() {
        super._finalizeClass();
        const observers = ownObservers(this);
        if (observers) {
          this.createObservers(observers, this._properties);
        }
        this._prepareTemplate();
      }

      static _prepareTemplate() {
        // note: create "working" template that is finalized at instance time
        let template = /** @type {PolymerElementConstructor} */ (this).template;
        if (template) {
          if (typeof template === 'string') {
            let t = document.createElement('template');
            t.innerHTML = template;
            template = t;
          } else if (!Polymer.legacyOptimizations) {
             template = template.cloneNode(true);
          }
        }

        this.prototype._template = template;
      }

      /**
       * Override of PropertiesChanged createProperties to create accessors
       * and property effects for all of the properties.
       * @return {void}
       * @protected
       * @override
       */
      static createProperties(props) {
        for (let p in props) {
          createPropertyFromConfig(this.prototype, p, props[p], props);
        }
      }

      /**
       * Creates observers for the given `observers` array.
       * Leverages `PropertyEffects` to create observers.
       * @param {Object} observers Array of observer descriptors for
       *   this class
       * @param {Object} dynamicFns Object containing keys for any properties
       *   that are functions and should trigger the effect when the function
       *   reference is changed
       * @return {void}
       * @protected
       */
      static createObservers(observers, dynamicFns) {
        const proto = this.prototype;
        for (let i=0; i < observers.length; i++) {
          proto._createMethodObserver(observers[i], dynamicFns);
        }
      }

      /**
       * Returns the template that will be stamped into this element's shadow root.
       *
       * If a `static get is()` getter is defined, the default implementation
       * will return the first `<template>` in a `dom-module` whose `id`
       * matches this element's `is`.
       *
       * Users may override this getter to return an arbitrary template
       * (in which case the `is` getter is unnecessary). The template returned
       * may be either an `HTMLTemplateElement` or a string that will be
       * automatically parsed into a template.
       *
       * Note that when subclassing, if the super class overrode the default
       * implementation and the subclass would like to provide an alternate
       * template via a `dom-module`, it should override this getter and
       * return `Polymer.DomModule.import(this.is, 'template')`.
       *
       * If a subclass would like to modify the super class template, it should
       * clone it rather than modify it in place.  If the getter does expensive
       * work such as cloning/modifying a template, it should memoize the
       * template for maximum performance:
       *
       *   let memoizedTemplate;
       *   class MySubClass extends MySuperClass {
       *     static get template() {
       *       if (!memoizedTemplate) {
       *         memoizedTemplate = MySuperClass.template.cloneNode(true);
       *         let subContent = document.createElement('div');
       *         subContent.textContent = 'This came from MySubClass';
       *         memoizedTemplate.content.appendChild(subContent);
       *       }
       *       return memoizedTemplate;
       *     }
       *   }
       *
       * @return {HTMLTemplateElement|string} Template to be stamped
       */
      static get template() {
        // Explanation of template-related properties:
        // - constructor.template (this getter): the template for the class.
        //     This can come from the prototype (for legacy elements), from a
        //     dom-module, or from the super class's template (or can be overridden
        //     altogether by the user)
        // - constructor._template: memoized version of constructor.template
        // - prototype._template: working template for the element, which will be
        //     parsed and modified in place. It is a cloned version of
        //     constructor.template, saved in _finalizeClass(). Note that before
        //     this getter is called, for legacy elements this could be from a
        //     _template field on the info object passed to Polymer(), a behavior,
        //     or set in registered(); once the static getter runs, a clone of it
        //     will overwrite it on the prototype as the working template.
        if (!this.hasOwnProperty(JSCompiler_renameProperty('_template', this))) {
          this._template =
            // If user has put template on prototype (e.g. in legacy via registered
            // callback or info object), prefer that first
            this.prototype.hasOwnProperty(JSCompiler_renameProperty('_template', this.prototype)) ?
            this.prototype._template :
            // Look in dom-module associated with this element's is
            (getTemplateFromDomModule(/** @type {PolymerElementConstructor}*/ (this).is) ||
            // Next look for superclass template (call the super impl this
            // way so that `this` points to the superclass)
            Object.getPrototypeOf(/** @type {PolymerElementConstructor}*/ (this).prototype).constructor.template);
        }
        return this._template;
      }

      /**
       * Set the template.
       *
       * @param {!HTMLTemplateElement|string} value Template to set.
       */
      static set template(value) {
        this._template = value;
      }

      /**
       * Path matching the url from which the element was imported.
       *
       * This path is used to resolve url's in template style cssText.
       * The `importPath` property is also set on element instances and can be
       * used to create bindings relative to the import path.
       *
       * For elements defined in ES modules, users should implement
       * `static get importMeta() { return import.meta; }`, and the default
       * implementation of `importPath` will  return `import.meta.url`'s path.
       * For elements defined in HTML imports, this getter will return the path
       * to the document containing a `dom-module` element matching this
       * element's static `is` property.
       *
       * Note, this path should contain a trailing `/`.
       *
       * @return {string} The import path for this element class
       * @suppress {missingProperties}
       */
      static get importPath() {
        if (!this.hasOwnProperty(JSCompiler_renameProperty('_importPath', this))) {
          const meta = this.importMeta;
          if (meta) {
            this._importPath = Polymer.ResolveUrl.pathFromUrl(meta.url);
          } else {
            const module = Polymer.DomModule && Polymer.DomModule.import(/** @type {PolymerElementConstructor} */ (this).is);
            this._importPath = (module && module.assetpath) ||
              Object.getPrototypeOf(/** @type {PolymerElementConstructor}*/ (this).prototype).constructor.importPath;
          }
        }
        return this._importPath;
      }

      constructor() {
        super();
        /** @type {HTMLTemplateElement} */
        this._template;
        /** @type {string} */
        this._importPath;
        /** @type {string} */
        this.rootPath;
        /** @type {string} */
        this.importPath;
        /** @type {StampedTemplate | HTMLElement | ShadowRoot} */
        this.root;
        /** @type {!Object<string, !Element>} */
        this.$;
      }

      /**
       * Overrides the default `Polymer.PropertyAccessors` to ensure class
       * metaprogramming related to property accessors and effects has
       * completed (calls `finalize`).
       *
       * It also initializes any property defaults provided via `value` in
       * `properties` metadata.
       *
       * @return {void}
       * @override
       * @suppress {invalidCasts}
       */
      _initializeProperties() {
        this.constructor.finalize();
        // note: finalize template when we have access to `localName` to
        // avoid dependence on `is` for polyfilling styling.
        this.constructor._finalizeTemplate(/** @type {!HTMLElement} */(this).localName);
        super._initializeProperties();
        // set path defaults
        this.rootPath = Polymer.rootPath;
        this.importPath = this.constructor.importPath;
        // apply property defaults...
        let p$ = propertyDefaults(this.constructor);
        if (!p$) {
          return;
        }
        for (let p in p$) {
          let info = p$[p];
          // Don't set default value if there is already an own property, which
          // happens when a `properties` property with default but no effects had
          // a property set (e.g. bound) by its host before upgrade
          if (!this.hasOwnProperty(p)) {
            let value = typeof info.value == 'function' ?
              info.value.call(this) :
              info.value;
            // Set via `_setProperty` if there is an accessor, to enable
            // initializing readOnly property defaults
            if (this._hasAccessor(p)) {
              this._setPendingProperty(p, value, true);
            } else {
              this[p] = value;
            }
          }
        }
      }

      /**
       * Gather style text for a style element in the template.
       *
       * @param {string} cssText Text containing styling to process
       * @param {string} baseURI Base URI to rebase CSS paths against
       * @return {string} The processed CSS text
       * @protected
       */
      static _processStyleText(cssText, baseURI) {
        return Polymer.ResolveUrl.resolveCss(cssText, baseURI);
      }

      /**
      * Configures an element `proto` to function with a given `template`.
      * The element name `is` and extends `ext` must be specified for ShadyCSS
      * style scoping.
      *
      * @param {string} is Tag name (or type extension name) for this element
      * @return {void}
      * @protected
      */
      static _finalizeTemplate(is) {
        /** @const {HTMLTemplateElement} */
        const template = this.prototype._template;
        if (template && !template.__polymerFinalized) {
          template.__polymerFinalized = true;
          const importPath = this.importPath;
          const baseURI = importPath ? Polymer.ResolveUrl.resolveUrl(importPath) : '';
          // e.g. support `include="module-name"`, and ShadyCSS
          processElementStyles(this, template, is, baseURI);
          this.prototype._bindTemplate(template);
        }
      }

      /**
       * Provides a default implementation of the standard Custom Elements
       * `connectedCallback`.
       *
       * The default implementation enables the property effects system and
       * flushes any pending properties, and updates shimmed CSS properties
       * when using the ShadyCSS scoping/custom properties polyfill.
       *
       * @suppress {missingProperties, invalidCasts} Super may or may not implement the callback
       * @return {void}
       */
      connectedCallback() {
        if (window.ShadyCSS && this._template) {
          window.ShadyCSS.styleElement(/** @type {!HTMLElement} */(this));
        }
        super.connectedCallback();
      }

      /**
       * Stamps the element template.
       *
       * @return {void}
       * @override
       */
      ready() {
        if (this._template) {
          this.root = this._stampTemplate(this._template);
          this.$ = this.root.$;
        }
        super.ready();
      }

      /**
       * Implements `PropertyEffects`'s `_readyClients` call. Attaches
       * element dom by calling `_attachDom` with the dom stamped from the
       * element's template via `_stampTemplate`. Note that this allows
       * client dom to be attached to the element prior to any observers
       * running.
       *
       * @return {void}
       * @override
       */
      _readyClients() {
        if (this._template) {
          this.root = this._attachDom(/** @type {StampedTemplate} */(this.root));
        }
        // The super._readyClients here sets the clients initialized flag.
        // We must wait to do this until after client dom is created/attached
        // so that this flag can be checked to prevent notifications fired
        // during this process from being handled before clients are ready.
        super._readyClients();
      }


      /**
       * Attaches an element's stamped dom to itself. By default,
       * this method creates a `shadowRoot` and adds the dom to it.
       * However, this method may be overridden to allow an element
       * to put its dom in another location.
       *
       * @throws {Error}
       * @suppress {missingReturn}
       * @param {StampedTemplate} dom to attach to the element.
       * @return {ShadowRoot} node to which the dom has been attached.
       */
      _attachDom(dom) {
        if (this.attachShadow) {
          if (dom) {
            if (!this.shadowRoot) {
              this.attachShadow({mode: 'open'});
            }
            this.shadowRoot.appendChild(dom);
            return this.shadowRoot;
          }
          return null;
        } else {
          throw new Error('ShadowDOM not available. ' +
            // TODO(sorvell): move to compile-time conditional when supported
          'Polymer.Element can create dom as children instead of in ' +
          'ShadowDOM by setting `this.root = this;\` before \`ready\`.');
        }
      }

      /**
       * When using the ShadyCSS scoping and custom property shim, causes all
       * shimmed styles in this element (and its subtree) to be updated
       * based on current custom property values.
       *
       * The optional parameter overrides inline custom property styles with an
       * object of properties where the keys are CSS properties, and the values
       * are strings.
       *
       * Example: `this.updateStyles({'--color': 'blue'})`
       *
       * These properties are retained unless a value of `null` is set.
       *
       * Note: This function does not support updating CSS mixins.
       * You can not dynamically change the value of an `@apply`.
       *
       * @param {Object=} properties Bag of custom property key/values to
       *   apply to this element.
       * @return {void}
       * @suppress {invalidCasts}
       */
      updateStyles(properties) {
        if (window.ShadyCSS) {
          window.ShadyCSS.styleSubtree(/** @type {!HTMLElement} */(this), properties);
        }
      }

      /**
       * Rewrites a given URL relative to a base URL. The base URL defaults to
       * the original location of the document containing the `dom-module` for
       * this element. This method will return the same URL before and after
       * bundling.
       *
       * Note that this function performs no resolution for URLs that start
       * with `/` (absolute URLs) or `#` (hash identifiers).  For general purpose
       * URL resolution, use `window.URL`.
       *
       * @param {string} url URL to resolve.
       * @param {string=} base Optional base URL to resolve against, defaults
       * to the element's `importPath`
       * @return {string} Rewritten URL relative to base
       */
      resolveUrl(url, base) {
        if (!base && this.importPath) {
          base = Polymer.ResolveUrl.resolveUrl(this.importPath);
        }
        return Polymer.ResolveUrl.resolveUrl(url, base);
      }

      /**
       * Overrides `PropertyAccessors` to add map of dynamic functions on
       * template info, for consumption by `PropertyEffects` template binding
       * code. This map determines which method templates should have accessors
       * created for them.
       *
       * @override
       * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
       */
      static _parseTemplateContent(template, templateInfo, nodeInfo) {
        templateInfo.dynamicFns = templateInfo.dynamicFns || this._properties;
        return super._parseTemplateContent(template, templateInfo, nodeInfo);
      }

    }

    return PolymerElement;
  });

  /**
   * When using the ShadyCSS scoping and custom property shim, causes all
   * shimmed `styles` (via `custom-style`) in the document (and its subtree)
   * to be updated based on current custom property values.
   *
   * The optional parameter overrides inline custom property styles with an
   * object of properties where the keys are CSS properties, and the values
   * are strings.
   *
   * Example: `Polymer.updateStyles({'--color': 'blue'})`
   *
   * These properties are retained unless a value of `null` is set.
   *
   * @param {Object=} props Bag of custom property key/values to
   *   apply to the document.
   * @return {void}
   */
  Polymer.updateStyles = function(props) {
    if (window.ShadyCSS) {
      window.ShadyCSS.styleDocument(props);
    }
  };

})();


(function() {
  'use strict';

  /**
   * @summary Collapse multiple callbacks into one invocation after a timer.
   * @memberof Polymer
   */
  class Debouncer {
    constructor() {
      this._asyncModule = null;
      this._callback = null;
      this._timer = null;
    }
    /**
     * Sets the scheduler; that is, a module with the Async interface,
     * a callback and optional arguments to be passed to the run function
     * from the async module.
     *
     * @param {!AsyncInterface} asyncModule Object with Async interface.
     * @param {function()} callback Callback to run.
     * @return {void}
     */
    setConfig(asyncModule, callback) {
      this._asyncModule = asyncModule;
      this._callback = callback;
      this._timer = this._asyncModule.run(() => {
        this._timer = null;
        this._callback();
      });
    }
    /**
     * Cancels an active debouncer and returns a reference to itself.
     *
     * @return {void}
     */
    cancel() {
      if (this.isActive()) {
        this._asyncModule.cancel(this._timer);
        this._timer = null;
      }
    }
    /**
     * Flushes an active debouncer and returns a reference to itself.
     *
     * @return {void}
     */
    flush() {
      if (this.isActive()) {
        this.cancel();
        this._callback();
      }
    }
    /**
     * Returns true if the debouncer is active.
     *
     * @return {boolean} True if active.
     */
    isActive() {
      return this._timer != null;
    }
    /**
     * Creates a debouncer if no debouncer is passed as a parameter
     * or it cancels an active debouncer otherwise. The following
     * example shows how a debouncer can be called multiple times within a
     * microtask and "debounced" such that the provided callback function is
     * called once. Add this method to a custom element:
     *
     * _debounceWork() {
     *   this._debounceJob = Polymer.Debouncer.debounce(this._debounceJob,
     *       Polymer.Async.microTask, () => {
     *     this._doWork();
     *   });
     * }
     *
     * If the `_debounceWork` method is called multiple times within the same
     * microtask, the `_doWork` function will be called only once at the next
     * microtask checkpoint.
     *
     * Note: In testing it is often convenient to avoid asynchrony. To accomplish
     * this with a debouncer, you can use `Polymer.enqueueDebouncer` and
     * `Polymer.flush`. For example, extend the above example by adding
     * `Polymer.enqueueDebouncer(this._debounceJob)` at the end of the
     * `_debounceWork` method. Then in a test, call `Polymer.flush` to ensure
     * the debouncer has completed.
     *
     * @param {Debouncer?} debouncer Debouncer object.
     * @param {!AsyncInterface} asyncModule Object with Async interface
     * @param {function()} callback Callback to run.
     * @return {!Debouncer} Returns a debouncer object.
     */
    static debounce(debouncer, asyncModule, callback) {
      if (debouncer instanceof Debouncer) {
        debouncer.cancel();
      } else {
        debouncer = new Debouncer();
      }
      debouncer.setConfig(asyncModule, callback);
      return debouncer;
    }
  }

  /** @const */
  Polymer.Debouncer = Debouncer;
})();


(function() {

  'use strict';

  // detect native touch action support
  let HAS_NATIVE_TA = typeof document.head.style.touchAction === 'string';
  let GESTURE_KEY = '__polymerGestures';
  let HANDLED_OBJ = '__polymerGesturesHandled';
  let TOUCH_ACTION = '__polymerGesturesTouchAction';
  // radius for tap and track
  let TAP_DISTANCE = 25;
  let TRACK_DISTANCE = 5;
  // number of last N track positions to keep
  let TRACK_LENGTH = 2;

  // Disabling "mouse" handlers for 2500ms is enough
  let MOUSE_TIMEOUT = 2500;
  let MOUSE_EVENTS = ['mousedown', 'mousemove', 'mouseup', 'click'];
  // an array of bitmask values for mapping MouseEvent.which to MouseEvent.buttons
  let MOUSE_WHICH_TO_BUTTONS = [0, 1, 4, 2];
  let MOUSE_HAS_BUTTONS = (function() {
    try {
      return new MouseEvent('test', {buttons: 1}).buttons === 1;
    } catch (e) {
      return false;
    }
  })();

  /**
   * @param {string} name Possible mouse event name
   * @return {boolean} true if mouse event, false if not
   */
  function isMouseEvent(name) {
    return MOUSE_EVENTS.indexOf(name) > -1;
  }

  /* eslint no-empty: ["error", { "allowEmptyCatch": true }] */
  // check for passive event listeners
  let SUPPORTS_PASSIVE = false;
  (function() {
    try {
      let opts = Object.defineProperty({}, 'passive', {get() {SUPPORTS_PASSIVE = true;}});
      window.addEventListener('test', null, opts);
      window.removeEventListener('test', null, opts);
    } catch(e) {}
  })();

  /**
   * Generate settings for event listeners, dependant on `Polymer.passiveTouchGestures`
   *
   * @param {string} eventName Event name to determine if `{passive}` option is needed
   * @return {{passive: boolean} | undefined} Options to use for addEventListener and removeEventListener
   */
  function PASSIVE_TOUCH(eventName) {
    if (isMouseEvent(eventName) || eventName === 'touchend') {
      return;
    }
    if (HAS_NATIVE_TA && SUPPORTS_PASSIVE && Polymer.passiveTouchGestures) {
      return {passive: true};
    } else {
      return;
    }
  }

  // Check for touch-only devices
  let IS_TOUCH_ONLY = navigator.userAgent.match(/iP(?:[oa]d|hone)|Android/);

  let GestureRecognizer = function(){}; // eslint-disable-line no-unused-vars
  /** @type {function(): void} */
  GestureRecognizer.prototype.reset;
  /** @type {function(MouseEvent): void | undefined} */
  GestureRecognizer.prototype.mousedown;
  /** @type {(function(MouseEvent): void | undefined)} */
  GestureRecognizer.prototype.mousemove;
  /** @type {(function(MouseEvent): void | undefined)} */
  GestureRecognizer.prototype.mouseup;
  /** @type {(function(TouchEvent): void | undefined)} */
  GestureRecognizer.prototype.touchstart;
  /** @type {(function(TouchEvent): void | undefined)} */
  GestureRecognizer.prototype.touchmove;
  /** @type {(function(TouchEvent): void | undefined)} */
  GestureRecognizer.prototype.touchend;
  /** @type {(function(MouseEvent): void | undefined)} */
  GestureRecognizer.prototype.click;

  // keep track of any labels hit by the mouseCanceller
  /** @type {!Array<!HTMLLabelElement>} */
  const clickedLabels = [];

  /** @type {!Object<boolean>} */
  const labellable = {
    'button': true,
    'input': true,
    'keygen': true,
    'meter': true,
    'output': true,
    'textarea': true,
    'progress': true,
    'select': true
  };

  // Defined at https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#enabling-and-disabling-form-controls:-the-disabled-attribute
  /** @type {!Object<boolean>} */
  const canBeDisabled = {
    'button': true,
    'command': true,
    'fieldset': true,
    'input': true,
    'keygen': true,
    'optgroup': true,
    'option': true,
    'select': true,
    'textarea': true
  };

  /**
   * @param {HTMLElement} el Element to check labelling status
   * @return {boolean} element can have labels
   */
  function canBeLabelled(el) {
    return labellable[el.localName] || false;
  }

  /**
   * @param {HTMLElement} el Element that may be labelled.
   * @return {!Array<!HTMLLabelElement>} Relevant label for `el`
   */
  function matchingLabels(el) {
    let labels = Array.from(/** @type {HTMLInputElement} */(el).labels || []);
    // IE doesn't have `labels` and Safari doesn't populate `labels`
    // if element is in a shadowroot.
    // In this instance, finding the non-ancestor labels is enough,
    // as the mouseCancellor code will handle ancstor labels
    if (!labels.length) {
      labels = [];
      let root = el.getRootNode();
      // if there is an id on `el`, check for all labels with a matching `for` attribute
      if (el.id) {
        let matching = root.querySelectorAll(`label[for = ${el.id}]`);
        for (let i = 0; i < matching.length; i++) {
          labels.push(/** @type {!HTMLLabelElement} */(matching[i]));
        }
      }
    }
    return labels;
  }

  // touch will make synthetic mouse events
  // `preventDefault` on touchend will cancel them,
  // but this breaks `<input>` focus and link clicks
  // disable mouse handlers for MOUSE_TIMEOUT ms after
  // a touchend to ignore synthetic mouse events
  let mouseCanceller = function(mouseEvent) {
    // Check for sourceCapabilities, used to distinguish synthetic events
    // if mouseEvent did not come from a device that fires touch events,
    // it was made by a real mouse and should be counted
    // http://wicg.github.io/InputDeviceCapabilities/#dom-inputdevicecapabilities-firestouchevents
    let sc = mouseEvent.sourceCapabilities;
    if (sc && !sc.firesTouchEvents) {
      return;
    }
    // skip synthetic mouse events
    mouseEvent[HANDLED_OBJ] = {skip: true};
    // disable "ghost clicks"
    if (mouseEvent.type === 'click') {
      let clickFromLabel = false;
      let path = mouseEvent.composedPath && mouseEvent.composedPath();
      if (path) {
        for (let i = 0; i < path.length; i++) {
          if (path[i].nodeType === Node.ELEMENT_NODE) {
            if (path[i].localName === 'label') {
              clickedLabels.push(path[i]);
            } else if (canBeLabelled(path[i])) {
              let ownerLabels = matchingLabels(path[i]);
              // check if one of the clicked labels is labelling this element
              for (let j = 0; j < ownerLabels.length; j++) {
                clickFromLabel = clickFromLabel || clickedLabels.indexOf(ownerLabels[j]) > -1;
              }
            }
          }
          if (path[i] === POINTERSTATE.mouse.target) {
            return;
          }
        }
      }
      // if one of the clicked labels was labelling the target element,
      // this is not a ghost click
      if (clickFromLabel) {
        return;
      }
      mouseEvent.preventDefault();
      mouseEvent.stopPropagation();
    }
  };

  /**
   * @param {boolean=} setup True to add, false to remove.
   * @return {void}
   */
  function setupTeardownMouseCanceller(setup) {
    let events = IS_TOUCH_ONLY ? ['click'] : MOUSE_EVENTS;
    for (let i = 0, en; i < events.length; i++) {
      en = events[i];
      if (setup) {
        // reset clickLabels array
        clickedLabels.length = 0;
        document.addEventListener(en, mouseCanceller, true);
      } else {
        document.removeEventListener(en, mouseCanceller, true);
      }
    }
  }

  function ignoreMouse(e) {
    if (!POINTERSTATE.mouse.mouseIgnoreJob) {
      setupTeardownMouseCanceller(true);
    }
    let unset = function() {
      setupTeardownMouseCanceller();
      POINTERSTATE.mouse.target = null;
      POINTERSTATE.mouse.mouseIgnoreJob = null;
    };
    POINTERSTATE.mouse.target = e.composedPath()[0];
    POINTERSTATE.mouse.mouseIgnoreJob = Polymer.Debouncer.debounce(
          POINTERSTATE.mouse.mouseIgnoreJob
        , Polymer.Async.timeOut.after(MOUSE_TIMEOUT)
        , unset);
  }

  /**
   * @param {MouseEvent} ev event to test for left mouse button down
   * @return {boolean} has left mouse button down
   */
  function hasLeftMouseButton(ev) {
    let type = ev.type;
    // exit early if the event is not a mouse event
    if (!isMouseEvent(type)) {
      return false;
    }
    // ev.button is not reliable for mousemove (0 is overloaded as both left button and no buttons)
    // instead we use ev.buttons (bitmask of buttons) or fall back to ev.which (deprecated, 0 for no buttons, 1 for left button)
    if (type === 'mousemove') {
      // allow undefined for testing events
      let buttons = ev.buttons === undefined ? 1 : ev.buttons;
      if ((ev instanceof window.MouseEvent) && !MOUSE_HAS_BUTTONS) {
        buttons = MOUSE_WHICH_TO_BUTTONS[ev.which] || 0;
      }
      // buttons is a bitmask, check that the left button bit is set (1)
      return Boolean(buttons & 1);
    } else {
      // allow undefined for testing events
      let button = ev.button === undefined ? 0 : ev.button;
      // ev.button is 0 in mousedown/mouseup/click for left button activation
      return button === 0;
    }
  }

  function isSyntheticClick(ev) {
    if (ev.type === 'click') {
      // ev.detail is 0 for HTMLElement.click in most browsers
      if (ev.detail === 0) {
        return true;
      }
      // in the worst case, check that the x/y position of the click is within
      // the bounding box of the target of the event
      // Thanks IE 10 >:(
      let t = Gestures._findOriginalTarget(ev);
      // make sure the target of the event is an element so we can use getBoundingClientRect,
      // if not, just assume it is a synthetic click
      if (!t.nodeType || /** @type {Element} */(t).nodeType !== Node.ELEMENT_NODE) {
        return true;
      }
      let bcr = /** @type {Element} */(t).getBoundingClientRect();
      // use page x/y to account for scrolling
      let x = ev.pageX, y = ev.pageY;
      // ev is a synthetic click if the position is outside the bounding box of the target
      return !((x >= bcr.left && x <= bcr.right) && (y >= bcr.top && y <= bcr.bottom));
    }
    return false;
  }

  let POINTERSTATE = {
    mouse: {
      target: null,
      mouseIgnoreJob: null
    },
    touch: {
      x: 0,
      y: 0,
      id: -1,
      scrollDecided: false
    }
  };

  function firstTouchAction(ev) {
    let ta = 'auto';
    let path = ev.composedPath && ev.composedPath();
    if (path) {
      for (let i = 0, n; i < path.length; i++) {
        n = path[i];
        if (n[TOUCH_ACTION]) {
          ta = n[TOUCH_ACTION];
          break;
        }
      }
    }
    return ta;
  }

  function trackDocument(stateObj, movefn, upfn) {
    stateObj.movefn = movefn;
    stateObj.upfn = upfn;
    document.addEventListener('mousemove', movefn);
    document.addEventListener('mouseup', upfn);
  }

  function untrackDocument(stateObj) {
    document.removeEventListener('mousemove', stateObj.movefn);
    document.removeEventListener('mouseup', stateObj.upfn);
    stateObj.movefn = null;
    stateObj.upfn = null;
  }

  // use a document-wide touchend listener to start the ghost-click prevention mechanism
  // Use passive event listeners, if supported, to not affect scrolling performance
  document.addEventListener('touchend', ignoreMouse, SUPPORTS_PASSIVE ? {passive: true} : false);

  /**
   * Module for adding listeners to a node for the following normalized
   * cross-platform "gesture" events:
   * - `down` - mouse or touch went down
   * - `up` - mouse or touch went up
   * - `tap` - mouse click or finger tap
   * - `track` - mouse drag or touch move
   *
   * @namespace
   * @memberof Polymer
   * @summary Module for adding cross-platform gesture event listeners.
   */
  const Gestures = {
    gestures: {},
    recognizers: [],

    /**
     * Finds the element rendered on the screen at the provided coordinates.
     *
     * Similar to `document.elementFromPoint`, but pierces through
     * shadow roots.
     *
     * @memberof Polymer.Gestures
     * @param {number} x Horizontal pixel coordinate
     * @param {number} y Vertical pixel coordinate
     * @return {Element} Returns the deepest shadowRoot inclusive element
     * found at the screen position given.
     */
    deepTargetFind: function(x, y) {
      let node = document.elementFromPoint(x, y);
      let next = node;
      // this code path is only taken when native ShadowDOM is used
      // if there is a shadowroot, it may have a node at x/y
      // if there is not a shadowroot, exit the loop
      while (next && next.shadowRoot && !window.ShadyDOM) {
        // if there is a node at x/y in the shadowroot, look deeper
        let oldNext = next;
        next = next.shadowRoot.elementFromPoint(x, y);
        // on Safari, elementFromPoint may return the shadowRoot host
        if (oldNext === next) {
          break;
        }
        if (next) {
          node = next;
        }
      }
      return node;
    },
    /**
     * a cheaper check than ev.composedPath()[0];
     *
     * @private
     * @param {Event} ev Event.
     * @return {EventTarget} Returns the event target.
     */
    _findOriginalTarget: function(ev) {
      // shadowdom
      if (ev.composedPath) {
        const targets = /** @type {!Array<!EventTarget>} */(ev.composedPath());
        // It shouldn't be, but sometimes targets is empty (window on Safari).
        return targets.length > 0 ? targets[0] : ev.target;
      }
      // shadydom
      return ev.target;
    },

    /**
     * @private
     * @param {Event} ev Event.
     * @return {void}
     */
    _handleNative: function(ev) {
      let handled;
      let type = ev.type;
      let node = ev.currentTarget;
      let gobj = node[GESTURE_KEY];
      if (!gobj) {
        return;
      }
      let gs = gobj[type];
      if (!gs) {
        return;
      }
      if (!ev[HANDLED_OBJ]) {
        ev[HANDLED_OBJ] = {};
        if (type.slice(0, 5) === 'touch') {
          ev = /** @type {TouchEvent} */(ev); // eslint-disable-line no-self-assign
          let t = ev.changedTouches[0];
          if (type === 'touchstart') {
            // only handle the first finger
            if (ev.touches.length === 1) {
              POINTERSTATE.touch.id = t.identifier;
            }
          }
          if (POINTERSTATE.touch.id !== t.identifier) {
            return;
          }
          if (!HAS_NATIVE_TA) {
            if (type === 'touchstart' || type === 'touchmove') {
              Gestures._handleTouchAction(ev);
            }
          }
        }
      }
      handled = ev[HANDLED_OBJ];
      // used to ignore synthetic mouse events
      if (handled.skip) {
        return;
      }
      // reset recognizer state
      for (let i = 0, r; i < Gestures.recognizers.length; i++) {
        r = Gestures.recognizers[i];
        if (gs[r.name] && !handled[r.name]) {
          if (r.flow && r.flow.start.indexOf(ev.type) > -1 && r.reset) {
            r.reset();
          }
        }
      }
      // enforce gesture recognizer order
      for (let i = 0, r; i < Gestures.recognizers.length; i++) {
        r = Gestures.recognizers[i];
        if (gs[r.name] && !handled[r.name]) {
          handled[r.name] = true;
          r[type](ev);
        }
      }
    },

    /**
     * @private
     * @param {TouchEvent} ev Event.
     * @return {void}
     */
    _handleTouchAction: function(ev) {
      let t = ev.changedTouches[0];
      let type = ev.type;
      if (type === 'touchstart') {
        POINTERSTATE.touch.x = t.clientX;
        POINTERSTATE.touch.y = t.clientY;
        POINTERSTATE.touch.scrollDecided = false;
      } else if (type === 'touchmove') {
        if (POINTERSTATE.touch.scrollDecided) {
          return;
        }
        POINTERSTATE.touch.scrollDecided = true;
        let ta = firstTouchAction(ev);
        let prevent = false;
        let dx = Math.abs(POINTERSTATE.touch.x - t.clientX);
        let dy = Math.abs(POINTERSTATE.touch.y - t.clientY);
        if (!ev.cancelable) {
          // scrolling is happening
        } else if (ta === 'none') {
          prevent = true;
        } else if (ta === 'pan-x') {
          prevent = dy > dx;
        } else if (ta === 'pan-y') {
          prevent = dx > dy;
        }
        if (prevent) {
          ev.preventDefault();
        } else {
          Gestures.prevent('track');
        }
      }
    },

    /**
     * Adds an event listener to a node for the given gesture type.
     *
     * @memberof Polymer.Gestures
     * @param {!Node} node Node to add listener on
     * @param {string} evType Gesture type: `down`, `up`, `track`, or `tap`
     * @param {!function(!Event):void} handler Event listener function to call
     * @return {boolean} Returns true if a gesture event listener was added.
     * @this {Gestures}
     */
    addListener: function(node, evType, handler) {
      if (this.gestures[evType]) {
        this._add(node, evType, handler);
        return true;
      }
      return false;
    },

    /**
     * Removes an event listener from a node for the given gesture type.
     *
     * @memberof Polymer.Gestures
     * @param {!Node} node Node to remove listener from
     * @param {string} evType Gesture type: `down`, `up`, `track`, or `tap`
     * @param {!function(!Event):void} handler Event listener function previously passed to
     *  `addListener`.
     * @return {boolean} Returns true if a gesture event listener was removed.
     * @this {Gestures}
     */
    removeListener: function(node, evType, handler) {
      if (this.gestures[evType]) {
        this._remove(node, evType, handler);
        return true;
      }
      return false;
    },

    /**
     * automate the event listeners for the native events
     *
     * @private
     * @param {!HTMLElement} node Node on which to add the event.
     * @param {string} evType Event type to add.
     * @param {function(!Event)} handler Event handler function.
     * @return {void}
     * @this {Gestures}
     */
    _add: function(node, evType, handler) {
      let recognizer = this.gestures[evType];
      let deps = recognizer.deps;
      let name = recognizer.name;
      let gobj = node[GESTURE_KEY];
      if (!gobj) {
        node[GESTURE_KEY] = gobj = {};
      }
      for (let i = 0, dep, gd; i < deps.length; i++) {
        dep = deps[i];
        // don't add mouse handlers on iOS because they cause gray selection overlays
        if (IS_TOUCH_ONLY && isMouseEvent(dep) && dep !== 'click') {
          continue;
        }
        gd = gobj[dep];
        if (!gd) {
          gobj[dep] = gd = {_count: 0};
        }
        if (gd._count === 0) {
          node.addEventListener(dep, this._handleNative, PASSIVE_TOUCH(dep));
        }
        gd[name] = (gd[name] || 0) + 1;
        gd._count = (gd._count || 0) + 1;
      }
      node.addEventListener(evType, handler);
      if (recognizer.touchAction) {
        this.setTouchAction(node, recognizer.touchAction);
      }
    },

    /**
     * automate event listener removal for native events
     *
     * @private
     * @param {!HTMLElement} node Node on which to remove the event.
     * @param {string} evType Event type to remove.
     * @param {function(Event?)} handler Event handler function.
     * @return {void}
     * @this {Gestures}
     */
    _remove: function(node, evType, handler) {
      let recognizer = this.gestures[evType];
      let deps = recognizer.deps;
      let name = recognizer.name;
      let gobj = node[GESTURE_KEY];
      if (gobj) {
        for (let i = 0, dep, gd; i < deps.length; i++) {
          dep = deps[i];
          gd = gobj[dep];
          if (gd && gd[name]) {
            gd[name] = (gd[name] || 1) - 1;
            gd._count = (gd._count || 1) - 1;
            if (gd._count === 0) {
              node.removeEventListener(dep, this._handleNative, PASSIVE_TOUCH(dep));
            }
          }
        }
      }
      node.removeEventListener(evType, handler);
    },

    /**
     * Registers a new gesture event recognizer for adding new custom
     * gesture event types.
     *
     * @memberof Polymer.Gestures
     * @param {!GestureRecognizer} recog Gesture recognizer descriptor
     * @return {void}
     * @this {Gestures}
     */
    register: function(recog) {
      this.recognizers.push(recog);
      for (let i = 0; i < recog.emits.length; i++) {
        this.gestures[recog.emits[i]] = recog;
      }
    },

    /**
     * @private
     * @param {string} evName Event name.
     * @return {Object} Returns the gesture for the given event name.
     * @this {Gestures}
     */
    _findRecognizerByEvent: function(evName) {
      for (let i = 0, r; i < this.recognizers.length; i++) {
        r = this.recognizers[i];
        for (let j = 0, n; j < r.emits.length; j++) {
          n = r.emits[j];
          if (n === evName) {
            return r;
          }
        }
      }
      return null;
    },

    /**
     * Sets scrolling direction on node.
     *
     * This value is checked on first move, thus it should be called prior to
     * adding event listeners.
     *
     * @memberof Polymer.Gestures
     * @param {!Element} node Node to set touch action setting on
     * @param {string} value Touch action value
     * @return {void}
     */
    setTouchAction: function(node, value) {
      if (HAS_NATIVE_TA) {
        // NOTE: add touchAction async so that events can be added in
        // custom element constructors. Otherwise we run afoul of custom
        // elements restriction against settings attributes (style) in the
        // constructor.
        Polymer.Async.microTask.run(() => {
          node.style.touchAction = value;
        });
      }
      node[TOUCH_ACTION] = value;
    },

    /**
     * Dispatches an event on the `target` element of `type` with the given
     * `detail`.
     * @private
     * @param {!EventTarget} target The element on which to fire an event.
     * @param {string} type The type of event to fire.
     * @param {!Object=} detail The detail object to populate on the event.
     * @return {void}
     */
    _fire: function(target, type, detail) {
      let ev = new Event(type, { bubbles: true, cancelable: true, composed: true });
      ev.detail = detail;
      target.dispatchEvent(ev);
      // forward `preventDefault` in a clean way
      if (ev.defaultPrevented) {
        let preventer = detail.preventer || detail.sourceEvent;
        if (preventer && preventer.preventDefault) {
          preventer.preventDefault();
        }
      }
    },

    /**
     * Prevents the dispatch and default action of the given event name.
     *
     * @memberof Polymer.Gestures
     * @param {string} evName Event name.
     * @return {void}
     * @this {Gestures}
     */
    prevent: function(evName) {
      let recognizer = this._findRecognizerByEvent(evName);
      if (recognizer.info) {
        recognizer.info.prevent = true;
      }
    },

    /**
     * Reset the 2500ms timeout on processing mouse input after detecting touch input.
     *
     * Touch inputs create synthesized mouse inputs anywhere from 0 to 2000ms after the touch.
     * This method should only be called during testing with simulated touch inputs.
     * Calling this method in production may cause duplicate taps or other Gestures.
     *
     * @memberof Polymer.Gestures
     * @return {void}
     */
    resetMouseCanceller: function() {
      if (POINTERSTATE.mouse.mouseIgnoreJob) {
        POINTERSTATE.mouse.mouseIgnoreJob.flush();
      }
    }
  };

  /* eslint-disable valid-jsdoc */

  Gestures.register({
    name: 'downup',
    deps: ['mousedown', 'touchstart', 'touchend'],
    flow: {
      start: ['mousedown', 'touchstart'],
      end: ['mouseup', 'touchend']
    },
    emits: ['down', 'up'],

    info: {
      movefn: null,
      upfn: null
    },

    /**
     * @this {GestureRecognizer}
     * @return {void}
     */
    reset: function() {
      untrackDocument(this.info);
    },

    /**
     * @this {GestureRecognizer}
     * @param {MouseEvent} e
     * @return {void}
     */
    mousedown: function(e) {
      if (!hasLeftMouseButton(e)) {
        return;
      }
      let t = Gestures._findOriginalTarget(e);
      let self = this;
      let movefn = function movefn(e) {
        if (!hasLeftMouseButton(e)) {
          self._fire('up', t, e);
          untrackDocument(self.info);
        }
      };
      let upfn = function upfn(e) {
        if (hasLeftMouseButton(e)) {
          self._fire('up', t, e);
        }
        untrackDocument(self.info);
      };
      trackDocument(this.info, movefn, upfn);
      this._fire('down', t, e);
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchstart: function(e) {
      this._fire('down', Gestures._findOriginalTarget(e), e.changedTouches[0], e);
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchend: function(e) {
      this._fire('up', Gestures._findOriginalTarget(e), e.changedTouches[0], e);
    },
    /**
     * @param {string} type
     * @param {!EventTarget} target
     * @param {Event} event
     * @param {Function} preventer
     * @return {void}
     */
    _fire: function(type, target, event, preventer) {
      Gestures._fire(target, type, {
        x: event.clientX,
        y: event.clientY,
        sourceEvent: event,
        preventer: preventer,
        prevent: function(e) {
          return Gestures.prevent(e);
        }
      });
    }
  });

  Gestures.register({
    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: false,
      moves: [],
      /** @this {GestureRecognizer} */
      addMove: function(move) {
        if (this.moves.length > TRACK_LENGTH) {
          this.moves.shift();
        }
        this.moves.push(move);
      },
      movefn: null,
      upfn: null,
      prevent: false
    },

    /**
     * @this {GestureRecognizer}
     * @return {void}
     */
    reset: function() {
      this.info.state = 'start';
      this.info.started = false;
      this.info.moves = [];
      this.info.x = 0;
      this.info.y = 0;
      this.info.prevent = false;
      untrackDocument(this.info);
    },

    /**
     * @this {GestureRecognizer}
     * @param {number} x
     * @param {number} y
     * @return {boolean}
     */
    hasMovedEnough: function(x, y) {
      if (this.info.prevent) {
        return false;
      }
      if (this.info.started) {
        return true;
      }
      let dx = Math.abs(this.info.x - x);
      let dy = Math.abs(this.info.y - y);
      return (dx >= TRACK_DISTANCE || dy >= TRACK_DISTANCE);
    },
    /**
     * @this {GestureRecognizer}
     * @param {MouseEvent} e
     * @return {void}
     */
    mousedown: function(e) {
      if (!hasLeftMouseButton(e)) {
        return;
      }
      let t = Gestures._findOriginalTarget(e);
      let self = this;
      let movefn = function movefn(e) {
        let x = e.clientX, y = e.clientY;
        if (self.hasMovedEnough(x, y)) {
          // first move is 'start', subsequent moves are 'move', mouseup is 'end'
          self.info.state = self.info.started ? (e.type === 'mouseup' ? 'end' : 'track') : 'start';
          if (self.info.state === 'start') {
            // if and only if tracking, always prevent tap
            Gestures.prevent('tap');
          }
          self.info.addMove({x: x, y: y});
          if (!hasLeftMouseButton(e)) {
            // always _fire "end"
            self.info.state = 'end';
            untrackDocument(self.info);
          }
          self._fire(t, e);
          self.info.started = true;
        }
      };
      let upfn = function upfn(e) {
        if (self.info.started) {
          movefn(e);
        }

        // remove the temporary listeners
        untrackDocument(self.info);
      };
      // add temporary document listeners as mouse retargets
      trackDocument(this.info, movefn, upfn);
      this.info.x = e.clientX;
      this.info.y = e.clientY;
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchstart: function(e) {
      let ct = e.changedTouches[0];
      this.info.x = ct.clientX;
      this.info.y = ct.clientY;
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchmove: function(e) {
      let t = Gestures._findOriginalTarget(e);
      let ct = e.changedTouches[0];
      let x = ct.clientX, y = ct.clientY;
      if (this.hasMovedEnough(x, y)) {
        if (this.info.state === 'start') {
          // if and only if tracking, always prevent tap
          Gestures.prevent('tap');
        }
        this.info.addMove({x: x, y: y});
        this._fire(t, ct);
        this.info.state = 'track';
        this.info.started = true;
      }
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchend: function(e) {
      let t = Gestures._findOriginalTarget(e);
      let ct = e.changedTouches[0];
      // only trackend if track was started and not aborted
      if (this.info.started) {
        // reset started state on up
        this.info.state = 'end';
        this.info.addMove({x: ct.clientX, y: ct.clientY});
        this._fire(t, ct, e);
      }
    },

    /**
     * @this {GestureRecognizer}
     * @param {!EventTarget} target
     * @param {Touch} touch
     * @return {void}
     */
    _fire: function(target, touch) {
      let secondlast = this.info.moves[this.info.moves.length - 2];
      let lastmove = this.info.moves[this.info.moves.length - 1];
      let dx = lastmove.x - this.info.x;
      let dy = lastmove.y - this.info.y;
      let ddx, ddy = 0;
      if (secondlast) {
        ddx = lastmove.x - secondlast.x;
        ddy = lastmove.y - secondlast.y;
      }
      Gestures._fire(target, 'track', {
        state: this.info.state,
        x: touch.clientX,
        y: touch.clientY,
        dx: dx,
        dy: dy,
        ddx: ddx,
        ddy: ddy,
        sourceEvent: touch,
        hover: function() {
          return Gestures.deepTargetFind(touch.clientX, touch.clientY);
        }
      });
    }

  });

  Gestures.register({
    name: 'tap',
    deps: ['mousedown', 'click', 'touchstart', 'touchend'],
    flow: {
      start: ['mousedown', 'touchstart'],
      end: ['click', 'touchend']
    },
    emits: ['tap'],
    info: {
      x: NaN,
      y: NaN,
      prevent: false
    },
    /**
     * @this {GestureRecognizer}
     * @return {void}
     */
    reset: function() {
      this.info.x = NaN;
      this.info.y = NaN;
      this.info.prevent = false;
    },
    /**
     * @this {GestureRecognizer}
     * @param {MouseEvent} e
     * @return {void}
     */
    save: function(e) {
      this.info.x = e.clientX;
      this.info.y = e.clientY;
    },
    /**
     * @this {GestureRecognizer}
     * @param {MouseEvent} e
     * @return {void}
     */
    mousedown: function(e) {
      if (hasLeftMouseButton(e)) {
        this.save(e);
      }
    },
    /**
     * @this {GestureRecognizer}
     * @param {MouseEvent} e
     * @return {void}
     */
    click: function(e) {
      if (hasLeftMouseButton(e)) {
        this.forward(e);
      }
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchstart: function(e) {
      this.save(e.changedTouches[0], e);
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchend: function(e) {
      this.forward(e.changedTouches[0], e);
    },
    /**
     * @this {GestureRecognizer}
     * @param {Event | Touch} e
     * @param {Event=} preventer
     * @return {void}
     */
    forward: function(e, preventer) {
      let dx = Math.abs(e.clientX - this.info.x);
      let dy = Math.abs(e.clientY - this.info.y);
      // find original target from `preventer` for TouchEvents, or `e` for MouseEvents
      let t = Gestures._findOriginalTarget(/** @type {Event} */(preventer || e));
      if (!t || (canBeDisabled[/** @type {!HTMLElement} */(t).localName] && t.hasAttribute('disabled'))) {
        return;
      }
      // dx,dy can be NaN if `click` has been simulated and there was no `down` for `start`
      if (isNaN(dx) || isNaN(dy) || (dx <= TAP_DISTANCE && dy <= TAP_DISTANCE) || isSyntheticClick(e)) {
        // prevent taps from being generated if an event has canceled them
        if (!this.info.prevent) {
          Gestures._fire(t, 'tap', {
            x: e.clientX,
            y: e.clientY,
            sourceEvent: e,
            preventer: preventer
          });
        }
      }
    }
  });

  /* eslint-enable valid-jsdoc */

  /** @deprecated */
  Gestures.findOriginalTarget = Gestures._findOriginalTarget;

  /** @deprecated */
  Gestures.add = Gestures.addListener;

  /** @deprecated */
  Gestures.remove = Gestures.removeListener;

  Polymer.Gestures = Gestures;

})();


(function() {

  'use strict';

  /**
   * @const {Polymer.Gestures}
   */
  const gestures = Polymer.Gestures;

  /**
   * Element class mixin that provides API for adding Polymer's cross-platform
   * gesture events to nodes.
   *
   * The API is designed to be compatible with override points implemented
   * in `Polymer.TemplateStamp` such that declarative event listeners in
   * templates will support gesture events when this mixin is applied along with
   * `Polymer.TemplateStamp`.
   *
   * @mixinFunction
   * @polymer
   * @memberof Polymer
   * @summary Element class mixin that provides API for adding Polymer's cross-platform
   * gesture events to nodes
   */
  Polymer.GestureEventListeners = Polymer.dedupingMixin(superClass => {

    /**
     * @polymer
     * @mixinClass
     * @implements {Polymer_GestureEventListeners}
     */
    class GestureEventListeners extends superClass {

      /**
       * Add the event listener to the node if it is a gestures event.
       *
       * @param {!Node} node Node to add event listener to
       * @param {string} eventName Name of event
       * @param {function(!Event):void} handler Listener function to add
       * @return {void}
       */
      _addEventListenerToNode(node, eventName, handler) {
        if (!gestures.addListener(node, eventName, handler)) {
          super._addEventListenerToNode(node, eventName, handler);
        }
      }

      /**
       * Remove the event listener to the node if it is a gestures event.
       *
       * @param {!Node} node Node to remove event listener from
       * @param {string} eventName Name of event
       * @param {function(!Event):void} handler Listener function to remove
       * @return {void}
       */
      _removeEventListenerFromNode(node, eventName, handler) {
        if (!gestures.removeListener(node, eventName, handler)) {
          super._removeEventListenerFromNode(node, eventName, handler);
        }
      }

    }

    return GestureEventListeners;

  });

})();


  (function() {
    'use strict';

    const HOST_DIR = /:host\(:dir\((ltr|rtl)\)\)/g;
    const HOST_DIR_REPLACMENT = ':host([dir="$1"])';

    const EL_DIR = /([\s\w-#\.\[\]\*]*):dir\((ltr|rtl)\)/g;
    const EL_DIR_REPLACMENT = ':host([dir="$2"]) $1';

    const DIR_CHECK = /:dir\((?:ltr|rtl)\)/;
    
    const SHIM_SHADOW = Boolean(window['ShadyDOM'] && window['ShadyDOM']['inUse']);

    /**
     * @type {!Array<!Polymer_DirMixin>}
     */
    const DIR_INSTANCES = [];

    /** @type {MutationObserver} */
    let observer = null;

    let DOCUMENT_DIR = '';

    function getRTL() {
      DOCUMENT_DIR = document.documentElement.getAttribute('dir');
    }

    /**
     * @param {!Polymer_DirMixin} instance Instance to set RTL status on
     */
    function setRTL(instance) {
      if (!instance.__autoDirOptOut) {
        const el = /** @type {!HTMLElement} */(instance);
        el.setAttribute('dir', DOCUMENT_DIR);
      }
    }

    function updateDirection() {
      getRTL();
      DOCUMENT_DIR = document.documentElement.getAttribute('dir');
      for (let i = 0; i < DIR_INSTANCES.length; i++) {
        setRTL(DIR_INSTANCES[i]);
      }
    }

    function takeRecords() {
      if (observer && observer.takeRecords().length) {
        updateDirection();
      }
    }

    /**
     * Element class mixin that allows elements to use the `:dir` CSS Selector to have
     * text direction specific styling.
     *
     * With this mixin, any stylesheet provided in the template will transform `:dir` into
     * `:host([dir])` and sync direction with the page via the element's `dir` attribute.
     *
     * Elements can opt out of the global page text direction by setting the `dir` attribute
     * directly in `ready()` or in HTML.
     *
     * Caveats:
     * - Applications must set `<html dir="ltr">` or `<html dir="rtl">` to sync direction
     * - Automatic left-to-right or right-to-left styling is sync'd with the `<html>` element only.
     * - Changing `dir` at runtime is supported.
     * - Opting out of the global direction styling is permanent
     *
     * @mixinFunction
     * @polymer
     * @appliesMixin Polymer.PropertyAccessors
     * @memberof Polymer
     */
    Polymer.DirMixin = Polymer.dedupingMixin((base) => {

      if (!SHIM_SHADOW) {
        if (!observer) {
          getRTL();
          observer = new MutationObserver(updateDirection);
          observer.observe(document.documentElement, {attributes: true, attributeFilter: ['dir']});
        }
      }

      /**
       * @constructor
       * @extends {base}
       * @implements {Polymer_PropertyAccessors}
       * @private
       */
      const elementBase = Polymer.PropertyAccessors(base);

      /**
       * @polymer
       * @mixinClass
       * @implements {Polymer_DirMixin}
       */
      class Dir extends elementBase {

        /**
         * @override
         * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
         */
        static _processStyleText(cssText, baseURI) {
          cssText = super._processStyleText(cssText, baseURI);
          if (!SHIM_SHADOW && DIR_CHECK.test(cssText)) {
            cssText = this._replaceDirInCssText(cssText);
            this.__activateDir = true;
          }
          return cssText;
        }

        /**
         * Replace `:dir` in the given CSS text
         *
         * @param {string} text CSS text to replace DIR
         * @return {string} Modified CSS
         */
        static _replaceDirInCssText(text) {
          let replacedText = text;
          replacedText = replacedText.replace(HOST_DIR, HOST_DIR_REPLACMENT);
          replacedText = replacedText.replace(EL_DIR, EL_DIR_REPLACMENT);
          return replacedText;
        }

        constructor() {
          super();
          /** @type {boolean} */
          this.__autoDirOptOut = false;
        }

        /**
         * @suppress {invalidCasts} Closure doesn't understand that `this` is an HTMLElement
         * @return {void}
         */
        ready() {
          super.ready();
          this.__autoDirOptOut = /** @type {!HTMLElement} */(this).hasAttribute('dir');
        }

        /**
         * @suppress {missingProperties} If it exists on elementBase, it can be super'd
         * @return {void}
         */
        connectedCallback() {
          if (elementBase.prototype.connectedCallback) {
            super.connectedCallback();
          }
          if (this.constructor.__activateDir) {
            takeRecords();
            DIR_INSTANCES.push(this);
            setRTL(this);
          }
        }

        /**
         * @suppress {missingProperties} If it exists on elementBase, it can be super'd
         * @return {void}
         */
        disconnectedCallback() {
          if (elementBase.prototype.disconnectedCallback) {
            super.disconnectedCallback();
          }
          if (this.constructor.__activateDir) {
            const idx = DIR_INSTANCES.indexOf(this);
            if (idx > -1) {
              DIR_INSTANCES.splice(idx, 1);
            }
          }
        }
      }

      Dir.__activateDir = false;

      return Dir;
    });
  })();



(function() {

  'use strict';

  // run a callback when HTMLImports are ready or immediately if
  // this api is not available.
  function whenImportsReady(cb) {
    if (window.HTMLImports) {
      HTMLImports.whenReady(cb);
    } else {
      cb();
    }
  }

  /**
   * Convenience method for importing an HTML document imperatively.
   *
   * This method creates a new `<link rel="import">` element with
   * the provided URL and appends it to the document to start loading.
   * In the `onload` callback, the `import` property of the `link`
   * element will contain the imported document contents.
   *
   * @memberof Polymer
   * @param {string} href URL to document to load.
   * @param {?function(!Event):void=} onload Callback to notify when an import successfully
   *   loaded.
   * @param {?function(!ErrorEvent):void=} onerror Callback to notify when an import
   *   unsuccessfully loaded.
   * @param {boolean=} optAsync True if the import should be loaded `async`.
   *   Defaults to `false`.
   * @return {!HTMLLinkElement} The link element for the URL to be loaded.
   */
  Polymer.importHref = function(href, onload, onerror, optAsync) {
    let link = /** @type {HTMLLinkElement} */
      (document.head.querySelector('link[href="' + href + '"][import-href]'));
    if (!link) {
      link = /** @type {HTMLLinkElement} */ (document.createElement('link'));
      link.rel = 'import';
      link.href = href;
      link.setAttribute('import-href', '');
    }
    // always ensure link has `async` attribute if user specified one,
    // even if it was previously not async. This is considered less confusing.
    if (optAsync) {
      link.setAttribute('async', '');
    }
    // NOTE: the link may now be in 3 states: (1) pending insertion,
    // (2) inflight, (3) already loaded. In each case, we need to add
    // event listeners to process callbacks.
    let cleanup = function() {
      link.removeEventListener('load', loadListener);
      link.removeEventListener('error', errorListener);
    };
    let loadListener = function(event) {
      cleanup();
      // In case of a successful load, cache the load event on the link so
      // that it can be used to short-circuit this method in the future when
      // it is called with the same href param.
      link.__dynamicImportLoaded = true;
      if (onload) {
        whenImportsReady(() => {
          onload(event);
        });
      }
    };
    let errorListener = function(event) {
      cleanup();
      // In case of an error, remove the link from the document so that it
      // will be automatically created again the next time `importHref` is
      // called.
      if (link.parentNode) {
        link.parentNode.removeChild(link);
      }
      if (onerror) {
        whenImportsReady(() => {
          onerror(event);
        });
      }
    };
    link.addEventListener('load', loadListener);
    link.addEventListener('error', errorListener);
    if (link.parentNode == null) {
      document.head.appendChild(link);
    // if the link already loaded, dispatch a fake load event
    // so that listeners are called and get a proper event argument.
    } else if (link.__dynamicImportLoaded) {
      link.dispatchEvent(new Event('load'));
    }
    return link;
  };

})();


(function() {

  'use strict';

  let scheduled = false;
  let beforeRenderQueue = [];
  let afterRenderQueue = [];

  function schedule() {
    scheduled = true;
    // before next render
    requestAnimationFrame(function() {
      scheduled = false;
      flushQueue(beforeRenderQueue);
      // after the render
      setTimeout(function() {
        runQueue(afterRenderQueue);
      });
    });
  }

  function flushQueue(queue) {
    while (queue.length) {
      callMethod(queue.shift());
    }
  }

  function runQueue(queue) {
    for (let i=0, l=queue.length; i < l; i++) {
      callMethod(queue.shift());
    }
  }

  function callMethod(info) {
    const context = info[0];
    const callback = info[1];
    const args = info[2];
    try {
      callback.apply(context, args);
    } catch(e) {
      setTimeout(() => {
        throw e;
      });
    }
  }

  function flush() {
    while (beforeRenderQueue.length || afterRenderQueue.length) {
      flushQueue(beforeRenderQueue);
      flushQueue(afterRenderQueue);
    }
    scheduled = false;
  }

  /**
   * Module for scheduling flushable pre-render and post-render tasks.
   *
   * @namespace
   * @memberof Polymer
   * @summary Module for scheduling flushable pre-render and post-render tasks.
   */
  Polymer.RenderStatus = {

    /**
     * Enqueues a callback which will be run before the next render, at
     * `requestAnimationFrame` timing.
     *
     * This method is useful for enqueuing work that requires DOM measurement,
     * since measurement may not be reliable in custom element callbacks before
     * the first render, as well as for batching measurement tasks in general.
     *
     * Tasks in this queue may be flushed by calling `Polymer.RenderStatus.flush()`.
     *
     * @memberof Polymer.RenderStatus
     * @param {*} context Context object the callback function will be bound to
     * @param {function(...*):void} callback Callback function
     * @param {!Array=} args An array of arguments to call the callback function with
     * @return {void}
     */
    beforeNextRender: function(context, callback, args) {
      if (!scheduled) {
        schedule();
      }
      beforeRenderQueue.push([context, callback, args]);
    },

    /**
     * Enqueues a callback which will be run after the next render, equivalent
     * to one task (`setTimeout`) after the next `requestAnimationFrame`.
     *
     * This method is useful for tuning the first-render performance of an
     * element or application by deferring non-critical work until after the
     * first paint.  Typical non-render-critical work may include adding UI
     * event listeners and aria attributes.
     *
     * @memberof Polymer.RenderStatus
     * @param {*} context Context object the callback function will be bound to
     * @param {function(...*):void} callback Callback function
     * @param {!Array=} args An array of arguments to call the callback function with
     * @return {void}
     */
    afterNextRender: function(context, callback, args) {
      if (!scheduled) {
        schedule();
      }
      afterRenderQueue.push([context, callback, args]);
    },

    /**
     * Flushes all `beforeNextRender` tasks, followed by all `afterNextRender`
     * tasks.
     *
     * @memberof Polymer.RenderStatus
     * @return {void}
     */
    flush: flush

  };

})();


(function() {
  'use strict';

  // unresolved

  function resolve() {
    document.body.removeAttribute('unresolved');
  }

  if (window.WebComponents) {
    window.addEventListener('WebComponentsReady', resolve);
  } else {
    if (document.readyState === 'interactive' || document.readyState === 'complete') {
      resolve();
    } else {
      window.addEventListener('DOMContentLoaded', resolve);
    }
  }

})();


(function() {

  'use strict';

  function newSplice(index, removed, addedCount) {
    return {
      index: index,
      removed: removed,
      addedCount: addedCount
    };
  }

  const EDIT_LEAVE = 0;
  const EDIT_UPDATE = 1;
  const EDIT_ADD = 2;
  const EDIT_DELETE = 3;

  // Note: This function is *based* on the computation of the Levenshtein
  // "edit" distance. The one change is that "updates" are treated as two
  // edits - not one. With Array splices, an update is really a delete
  // followed by an add. By retaining this, we optimize for "keeping" the
  // maximum array items in the original array. For example:
  //
  //   'xxxx123' -> '123yyyy'
  //
  // With 1-edit updates, the shortest path would be just to update all seven
  // characters. With 2-edit updates, we delete 4, leave 3, and add 4. This
  // leaves the substring '123' intact.
  function calcEditDistances(current, currentStart, currentEnd,
                              old, oldStart, oldEnd) {
    // "Deletion" columns
    let rowCount = oldEnd - oldStart + 1;
    let columnCount = currentEnd - currentStart + 1;
    let distances = new Array(rowCount);

    // "Addition" rows. Initialize null column.
    for (let i = 0; i < rowCount; i++) {
      distances[i] = new Array(columnCount);
      distances[i][0] = i;
    }

    // Initialize null row
    for (let j = 0; j < columnCount; j++)
      distances[0][j] = j;

    for (let i = 1; i < rowCount; i++) {
      for (let j = 1; j < columnCount; j++) {
        if (equals(current[currentStart + j - 1], old[oldStart + i - 1]))
          distances[i][j] = distances[i - 1][j - 1];
        else {
          let north = distances[i - 1][j] + 1;
          let west = distances[i][j - 1] + 1;
          distances[i][j] = north < west ? north : west;
        }
      }
    }

    return distances;
  }

  // This starts at the final weight, and walks "backward" by finding
  // the minimum previous weight recursively until the origin of the weight
  // matrix.
  function spliceOperationsFromEditDistances(distances) {
    let i = distances.length - 1;
    let j = distances[0].length - 1;
    let current = distances[i][j];
    let edits = [];
    while (i > 0 || j > 0) {
      if (i == 0) {
        edits.push(EDIT_ADD);
        j--;
        continue;
      }
      if (j == 0) {
        edits.push(EDIT_DELETE);
        i--;
        continue;
      }
      let northWest = distances[i - 1][j - 1];
      let west = distances[i - 1][j];
      let north = distances[i][j - 1];

      let min;
      if (west < north)
        min = west < northWest ? west : northWest;
      else
        min = north < northWest ? north : northWest;

      if (min == northWest) {
        if (northWest == current) {
          edits.push(EDIT_LEAVE);
        } else {
          edits.push(EDIT_UPDATE);
          current = northWest;
        }
        i--;
        j--;
      } else if (min == west) {
        edits.push(EDIT_DELETE);
        i--;
        current = west;
      } else {
        edits.push(EDIT_ADD);
        j--;
        current = north;
      }
    }

    edits.reverse();
    return edits;
  }

  /**
   * Splice Projection functions:
   *
   * A splice map is a representation of how a previous array of items
   * was transformed into a new array of items. Conceptually it is a list of
   * tuples of
   *
   *   <index, removed, addedCount>
   *
   * which are kept in ascending index order of. The tuple represents that at
   * the |index|, |removed| sequence of items were removed, and counting forward
   * from |index|, |addedCount| items were added.
   */

  /**
   * Lacking individual splice mutation information, the minimal set of
   * splices can be synthesized given the previous state and final state of an
   * array. The basic approach is to calculate the edit distance matrix and
   * choose the shortest path through it.
   *
   * Complexity: O(l * p)
   *   l: The length of the current array
   *   p: The length of the old array
   *
   * @param {!Array} current The current "changed" array for which to
   * calculate splices.
   * @param {number} currentStart Starting index in the `current` array for
   * which splices are calculated.
   * @param {number} currentEnd Ending index in the `current` array for
   * which splices are calculated.
   * @param {!Array} old The original "unchanged" array to compare `current`
   * against to determine splices.
   * @param {number} oldStart Starting index in the `old` array for
   * which splices are calculated.
   * @param {number} oldEnd Ending index in the `old` array for
   * which splices are calculated.
   * @return {!Array} Returns an array of splice record objects. Each of these
   * contains: `index` the location where the splice occurred; `removed`
   * the array of removed items from this location; `addedCount` the number
   * of items added at this location.
   */
  function calcSplices(current, currentStart, currentEnd,
                        old, oldStart, oldEnd) {
    let prefixCount = 0;
    let suffixCount = 0;
    let splice;

    let minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);
    if (currentStart == 0 && oldStart == 0)
      prefixCount = sharedPrefix(current, old, minLength);

    if (currentEnd == current.length && oldEnd == old.length)
      suffixCount = sharedSuffix(current, old, minLength - prefixCount);

    currentStart += prefixCount;
    oldStart += prefixCount;
    currentEnd -= suffixCount;
    oldEnd -= suffixCount;

    if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0)
      return [];

    if (currentStart == currentEnd) {
      splice = newSplice(currentStart, [], 0);
      while (oldStart < oldEnd)
        splice.removed.push(old[oldStart++]);

      return [ splice ];
    } else if (oldStart == oldEnd)
      return [ newSplice(currentStart, [], currentEnd - currentStart) ];

    let ops = spliceOperationsFromEditDistances(
        calcEditDistances(current, currentStart, currentEnd,
                               old, oldStart, oldEnd));

    splice = undefined;
    let splices = [];
    let index = currentStart;
    let oldIndex = oldStart;
    for (let i = 0; i < ops.length; i++) {
      switch(ops[i]) {
        case EDIT_LEAVE:
          if (splice) {
            splices.push(splice);
            splice = undefined;
          }

          index++;
          oldIndex++;
          break;
        case EDIT_UPDATE:
          if (!splice)
            splice = newSplice(index, [], 0);

          splice.addedCount++;
          index++;

          splice.removed.push(old[oldIndex]);
          oldIndex++;
          break;
        case EDIT_ADD:
          if (!splice)
            splice = newSplice(index, [], 0);

          splice.addedCount++;
          index++;
          break;
        case EDIT_DELETE:
          if (!splice)
            splice = newSplice(index, [], 0);

          splice.removed.push(old[oldIndex]);
          oldIndex++;
          break;
      }
    }

    if (splice) {
      splices.push(splice);
    }
    return splices;
  }

  function sharedPrefix(current, old, searchLength) {
    for (let i = 0; i < searchLength; i++)
      if (!equals(current[i], old[i]))
        return i;
    return searchLength;
  }

  function sharedSuffix(current, old, searchLength) {
    let index1 = current.length;
    let index2 = old.length;
    let count = 0;
    while (count < searchLength && equals(current[--index1], old[--index2]))
      count++;

    return count;
  }

  function calculateSplices(current, previous) {
    return calcSplices(current, 0, current.length, previous, 0,
                            previous.length);
  }

  function equals(currentValue, previousValue) {
    return currentValue === previousValue;
  }

  /**
   * @namespace
   * @memberof Polymer
   * @summary Module that provides utilities for diffing arrays.
   */
  Polymer.ArraySplice = {
    /**
     * Returns an array of splice records indicating the minimum edits required
     * to transform the `previous` array into the `current` array.
     *
     * Splice records are ordered by index and contain the following fields:
     * - `index`: index where edit started
     * - `removed`: array of removed items from this index
     * - `addedCount`: number of items added at this index
     *
     * This function is based on the Levenshtein "minimum edit distance"
     * algorithm. Note that updates are treated as removal followed by addition.
     *
     * The worst-case time complexity of this algorithm is `O(l * p)`
     *   l: The length of the current array
     *   p: The length of the previous array
     *
     * However, the worst-case complexity is reduced by an `O(n)` optimization
     * to detect any shared prefix & suffix between the two arrays and only
     * perform the more expensive minimum edit distance calculation over the
     * non-shared portions of the arrays.
     *
     * @function
     * @memberof Polymer.ArraySplice
     * @param {!Array} current The "changed" array for which splices will be
     * calculated.
     * @param {!Array} previous The "unchanged" original array to compare
     * `current` against to determine the splices.
     * @return {!Array} Returns an array of splice record objects. Each of these
     * contains: `index` the location where the splice occurred; `removed`
     * the array of removed items from this location; `addedCount` the number
     * of items added at this location.
     */
    calculateSplices
  };

})();


(function() {
  'use strict';

  /**
   * Returns true if `node` is a slot element
   * @param {Node} node Node to test.
   * @return {boolean} Returns true if the given `node` is a slot
   * @private
   */
  function isSlot(node) {
    return (node.localName === 'slot');
  }

  /**
   * Class that listens for changes (additions or removals) to
   * "flattened nodes" on a given `node`. The list of flattened nodes consists
   * of a node's children and, for any children that are `<slot>` elements,
   * the expanded flattened list of `assignedNodes`.
   * For example, if the observed node has children `<a></a><slot></slot><b></b>`
   * and the `<slot>` has one `<div>` assigned to it, then the flattened
   * nodes list is `<a></a><div></div><b></b>`. If the `<slot>` has other
   * `<slot>` elements assigned to it, these are flattened as well.
   *
   * The provided `callback` is called whenever any change to this list
   * of flattened nodes occurs, where an addition or removal of a node is
   * considered a change. The `callback` is called with one argument, an object
   * containing an array of any `addedNodes` and `removedNodes`.
   *
   * Note: the callback is called asynchronous to any changes
   * at a microtask checkpoint. This is because observation is performed using
   * `MutationObserver` and the `<slot>` element's `slotchange` event which
   * are asynchronous.
   *
   * An example:
   * ```js
   * class TestSelfObserve extends Polymer.Element {
   *   static get is() { return 'test-self-observe';}
   *   connectedCallback() {
   *     super.connectedCallback();
   *     this._observer = new Polymer.FlattenedNodesObserver(this, (info) => {
   *       this.info = info;
   *     });
   *   }
   *   disconnectedCallback() {
   *     super.disconnectedCallback();
   *     this._observer.disconnect();
   *   }
   * }
   * customElements.define(TestSelfObserve.is, TestSelfObserve);
   * ```
   *
   * @memberof Polymer
   * @summary Class that listens for changes (additions or removals) to
   * "flattened nodes" on a given `node`.
   */
  class FlattenedNodesObserver {

    /**
     * Returns the list of flattened nodes for the given `node`.
     * This list consists of a node's children and, for any children
     * that are `<slot>` elements, the expanded flattened list of `assignedNodes`.
     * For example, if the observed node has children `<a></a><slot></slot><b></b>`
     * and the `<slot>` has one `<div>` assigned to it, then the flattened
     * nodes list is `<a></a><div></div><b></b>`. If the `<slot>` has other
     * `<slot>` elements assigned to it, these are flattened as well.
     *
     * @param {HTMLElement|HTMLSlotElement} node The node for which to return the list of flattened nodes.
     * @return {Array} The list of flattened nodes for the given `node`.
    */
    static getFlattenedNodes(node) {
      if (isSlot(node)) {
        node = /** @type {HTMLSlotElement} */(node); // eslint-disable-line no-self-assign
        return node.assignedNodes({flatten: true});
      } else {
        return Array.from(node.childNodes).map((node) => {
          if (isSlot(node)) {
            node = /** @type {HTMLSlotElement} */(node); // eslint-disable-line no-self-assign
            return node.assignedNodes({flatten: true});
          } else {
            return [node];
          }
        }).reduce((a, b) => a.concat(b), []);
      }
    }

    /**
     * @param {Element} target Node on which to listen for changes.
     * @param {?function(!Element, { target: !Element, addedNodes: !Array<!Element>, removedNodes: !Array<!Element> }):void} callback Function called when there are additions
     * or removals from the target's list of flattened nodes.
    */
    constructor(target, callback) {
      /**
       * @type {MutationObserver}
       * @private
       */
      this._shadyChildrenObserver = null;
      /**
       * @type {MutationObserver}
       * @private
       */
      this._nativeChildrenObserver = null;
      this._connected = false;
      /**
       * @type {Element}
       * @private
       */
      this._target = target;
      this.callback = callback;
      this._effectiveNodes = [];
      this._observer = null;
      this._scheduled = false;
      /**
       * @type {function()}
       * @private
       */
      this._boundSchedule = () => {
        this._schedule();
      };
      this.connect();
      this._schedule();
    }

    /**
     * Activates an observer. This method is automatically called when
     * a `FlattenedNodesObserver` is created. It should only be called to
     * re-activate an observer that has been deactivated via the `disconnect` method.
     *
     * @return {void}
     */
    connect() {
      if (isSlot(this._target)) {
        this._listenSlots([this._target]);
      } else if (this._target.children) {
        this._listenSlots(this._target.children);
        if (window.ShadyDOM) {
          this._shadyChildrenObserver =
            ShadyDOM.observeChildren(this._target, (mutations) => {
              this._processMutations(mutations);
            });
        } else {
          this._nativeChildrenObserver =
            new MutationObserver((mutations) => {
              this._processMutations(mutations);
            });
          this._nativeChildrenObserver.observe(this._target, {childList: true});
        }
      }
      this._connected = true;
    }

    /**
     * Deactivates the flattened nodes observer. After calling this method
     * the observer callback will not be called when changes to flattened nodes
     * occur. The `connect` method may be subsequently called to reactivate
     * the observer.
     *
     * @return {void}
     */
    disconnect() {
      if (isSlot(this._target)) {
        this._unlistenSlots([this._target]);
      } else if (this._target.children) {
        this._unlistenSlots(this._target.children);
        if (window.ShadyDOM && this._shadyChildrenObserver) {
          ShadyDOM.unobserveChildren(this._shadyChildrenObserver);
          this._shadyChildrenObserver = null;
        } else if (this._nativeChildrenObserver) {
          this._nativeChildrenObserver.disconnect();
          this._nativeChildrenObserver = null;
        }
      }
      this._connected = false;
    }

    /**
     * @return {void}
     * @private
     */
    _schedule() {
      if (!this._scheduled) {
        this._scheduled = true;
        Polymer.Async.microTask.run(() => this.flush());
      }
    }

    /**
     * @param {Array<MutationRecord>} mutations Mutations signaled by the mutation observer
     * @return {void}
     * @private
     */
    _processMutations(mutations) {
      this._processSlotMutations(mutations);
      this.flush();
    }

    /**
     * @param {Array<MutationRecord>} mutations Mutations signaled by the mutation observer
     * @return {void}
     * @private
     */
    _processSlotMutations(mutations) {
      if (mutations) {
        for (let i=0; i < mutations.length; i++) {
          let mutation = mutations[i];
          if (mutation.addedNodes) {
            this._listenSlots(mutation.addedNodes);
          }
          if (mutation.removedNodes) {
            this._unlistenSlots(mutation.removedNodes);
          }
        }
      }
    }

    /**
     * Flushes the observer causing any pending changes to be immediately
     * delivered the observer callback. By default these changes are delivered
     * asynchronously at the next microtask checkpoint.
     *
     * @return {boolean} Returns true if any pending changes caused the observer
     * callback to run.
     */
    flush() {
      if (!this._connected) {
        return false;
      }
      if (window.ShadyDOM) {
        ShadyDOM.flush();
      }
      if (this._nativeChildrenObserver) {
        this._processSlotMutations(this._nativeChildrenObserver.takeRecords());
      } else if (this._shadyChildrenObserver) {
        this._processSlotMutations(this._shadyChildrenObserver.takeRecords());
      }
      this._scheduled = false;
      let info = {
        target: this._target,
        addedNodes: [],
        removedNodes: []
      };
      let newNodes = this.constructor.getFlattenedNodes(this._target);
      let splices = Polymer.ArraySplice.calculateSplices(newNodes,
        this._effectiveNodes);
      // process removals
      for (let i=0, s; (i<splices.length) && (s=splices[i]); i++) {
        for (let j=0, n; (j < s.removed.length) && (n=s.removed[j]); j++) {
          info.removedNodes.push(n);
        }
      }
      // process adds
      for (let i=0, s; (i<splices.length) && (s=splices[i]); i++) {
        for (let j=s.index; j < s.index + s.addedCount; j++) {
          info.addedNodes.push(newNodes[j]);
        }
      }
      // update cache
      this._effectiveNodes = newNodes;
      let didFlush = false;
      if (info.addedNodes.length || info.removedNodes.length) {
        didFlush = true;
        this.callback.call(this._target, info);
      }
      return didFlush;
    }

    /**
     * @param {!Array<Element|Node>|!NodeList<Node>} nodeList Nodes that could change
     * @return {void}
     * @private
     */
    _listenSlots(nodeList) {
      for (let i=0; i < nodeList.length; i++) {
        let n = nodeList[i];
        if (isSlot(n)) {
          n.addEventListener('slotchange', this._boundSchedule);
        }
      }
    }

    /**
     * @param {!Array<Element|Node>|!NodeList<Node>} nodeList Nodes that could change
     * @return {void}
     * @private
     */
    _unlistenSlots(nodeList) {
      for (let i=0; i < nodeList.length; i++) {
        let n = nodeList[i];
        if (isSlot(n)) {
          n.removeEventListener('slotchange', this._boundSchedule);
        }
      }
    }

  }

  Polymer.FlattenedNodesObserver = FlattenedNodesObserver;

})();


(function() {
  'use strict';

  let debouncerQueue = [];

  /**
   * Adds a `Polymer.Debouncer` to a list of globally flushable tasks.
   *
   * @memberof Polymer
   * @param {!Polymer.Debouncer} debouncer Debouncer to enqueue
   * @return {void}
   */
  Polymer.enqueueDebouncer = function(debouncer) {
    debouncerQueue.push(debouncer);
  };

  function flushDebouncers() {
    const didFlush = Boolean(debouncerQueue.length);
    while (debouncerQueue.length) {
      try {
        debouncerQueue.shift().flush();
      } catch(e) {
        setTimeout(() => {
          throw e;
        });
      }
    }
    return didFlush;
  }

  /**
   * Forces several classes of asynchronously queued tasks to flush:
   * - Debouncers added via `enqueueDebouncer`
   * - ShadyDOM distribution
   *
   * @memberof Polymer
   * @return {void}
   */
  Polymer.flush = function() {
    let shadyDOM, debouncers;
    do {
      shadyDOM = window.ShadyDOM && ShadyDOM.flush();
      if (window.ShadyCSS && window.ShadyCSS.ScopingShim) {
        window.ShadyCSS.ScopingShim.flush();
      }
      debouncers = flushDebouncers();
    } while (shadyDOM || debouncers);
  };

})();


(function() {
  'use strict';

  const p = Element.prototype;
  /**
   * @const {function(this:Node, string): boolean}
   */
  const normalizedMatchesSelector = p.matches || p.matchesSelector ||
    p.mozMatchesSelector || p.msMatchesSelector ||
    p.oMatchesSelector || p.webkitMatchesSelector;

  /**
   * Cross-platform `element.matches` shim.
   *
   * @function matchesSelector
   * @memberof Polymer.dom
   * @param {!Node} node Node to check selector against
   * @param {string} selector Selector to match
   * @return {boolean} True if node matched selector
   */
  const matchesSelector = function(node, selector) {
    return normalizedMatchesSelector.call(node, selector);
  };

  /**
   * Node API wrapper class returned from `Polymer.dom.(target)` when
   * `target` is a `Node`.
   *
   * @memberof Polymer
   */
  class DomApi {

    /**
     * @param {Node} node Node for which to create a Polymer.dom helper object.
     */
    constructor(node) {
      this.node = node;
    }

    /**
     * Returns an instance of `Polymer.FlattenedNodesObserver` that
     * listens for node changes on this element.
     *
     * @param {function(!Element, { target: !Element, addedNodes: !Array<!Element>, removedNodes: !Array<!Element> }):void} callback Called when direct or distributed children
     *   of this element changes
     * @return {!Polymer.FlattenedNodesObserver} Observer instance
     */
    observeNodes(callback) {
      return new Polymer.FlattenedNodesObserver(this.node, callback);
    }

    /**
     * Disconnects an observer previously created via `observeNodes`
     *
     * @param {!Polymer.FlattenedNodesObserver} observerHandle Observer instance
     *   to disconnect.
     * @return {void}
     */
    unobserveNodes(observerHandle) {
      observerHandle.disconnect();
    }

    /**
     * Provided as a backwards-compatible API only.  This method does nothing.
     * @return {void}
     */
    notifyObserver() {}

    /**
     * Returns true if the provided node is contained with this element's
     * light-DOM children or shadow root, including any nested shadow roots
     * of children therein.
     *
     * @param {Node} node Node to test
     * @return {boolean} Returns true if the given `node` is contained within
     *   this element's light or shadow DOM.
     */
    deepContains(node) {
      if (this.node.contains(node)) {
        return true;
      }
      let n = node;
      let doc = node.ownerDocument;
      // walk from node to `this` or `document`
      while (n && n !== doc && n !== this.node) {
        // use logical parentnode, or native ShadowRoot host
        n = n.parentNode || n.host;
      }
      return n === this.node;
    }

    /**
     * Returns the root node of this node.  Equivalent to `getRoodNode()`.
     *
     * @return {Node} Top most element in the dom tree in which the node
     * exists. If the node is connected to a document this is either a
     * shadowRoot or the document; otherwise, it may be the node
     * itself or a node or document fragment containing it.
     */
    getOwnerRoot() {
      return this.node.getRootNode();
    }

    /**
     * For slot elements, returns the nodes assigned to the slot; otherwise
     * an empty array. It is equivalent to `<slot>.addignedNodes({flatten:true})`.
     *
     * @return {!Array<!Node>} Array of assigned nodes
     */
    getDistributedNodes() {
      return (this.node.localName === 'slot') ?
        this.node.assignedNodes({flatten: true}) :
        [];
    }

    /**
     * Returns an array of all slots this element was distributed to.
     *
     * @return {!Array<!HTMLSlotElement>} Description
     */
    getDestinationInsertionPoints() {
      let ip$ = [];
      let n = this.node.assignedSlot;
      while (n) {
        ip$.push(n);
        n = n.assignedSlot;
      }
      return ip$;
    }

    /**
     * Calls `importNode` on the `ownerDocument` for this node.
     *
     * @param {!Node} node Node to import
     * @param {boolean} deep True if the node should be cloned deeply during
     *   import
     * @return {Node} Clone of given node imported to this owner document
     */
    importNode(node, deep) {
      let doc = this.node instanceof Document ? this.node :
        this.node.ownerDocument;
      return doc.importNode(node, deep);
    }

    /**
     * @return {!Array<!Node>} Returns a flattened list of all child nodes and
     * nodes assigned to child slots.
     */
    getEffectiveChildNodes() {
      return Polymer.FlattenedNodesObserver.getFlattenedNodes(this.node);
    }

    /**
     * Returns a filtered list of flattened child elements for this element based
     * on the given selector.
     *
     * @param {string} selector Selector to filter nodes against
     * @return {!Array<!HTMLElement>} List of flattened child elements
     */
    queryDistributedElements(selector) {
      let c$ = this.getEffectiveChildNodes();
      let list = [];
      for (let i=0, l=c$.length, c; (i<l) && (c=c$[i]); i++) {
        if ((c.nodeType === Node.ELEMENT_NODE) &&
            matchesSelector(c, selector)) {
          list.push(c);
        }
      }
      return list;
    }

    /**
     * For shadow roots, returns the currently focused element within this
     * shadow root.
     *
     * @return {Node|undefined} Currently focused element
     */
    get activeElement() {
      let node = this.node;
      return node._activeElement !== undefined ? node._activeElement : node.activeElement;
    }
  }

  function forwardMethods(proto, methods) {
    for (let i=0; i < methods.length; i++) {
      let method = methods[i];
      /* eslint-disable valid-jsdoc */
      proto[method] = /** @this {DomApi} */ function() {
        return this.node[method].apply(this.node, arguments);
      };
      /* eslint-enable */
    }
  }

  function forwardReadOnlyProperties(proto, properties) {
    for (let i=0; i < properties.length; i++) {
      let name = properties[i];
      Object.defineProperty(proto, name, {
        get: function() {
          const domApi = /** @type {DomApi} */(this);
          return domApi.node[name];
        },
        configurable: true
      });
    }
  }

  function forwardProperties(proto, properties) {
    for (let i=0; i < properties.length; i++) {
      let name = properties[i];
      Object.defineProperty(proto, name, {
        get: function() {
          const domApi = /** @type {DomApi} */(this);
          return domApi.node[name];
        },
        set: function(value) {
          /** @type {DomApi} */ (this).node[name] = value;
        },
        configurable: true
      });
    }
  }

  forwardMethods(DomApi.prototype, [
    'cloneNode', 'appendChild', 'insertBefore', 'removeChild',
    'replaceChild', 'setAttribute', 'removeAttribute',
    'querySelector', 'querySelectorAll'
  ]);

  forwardReadOnlyProperties(DomApi.prototype, [
    'parentNode', 'firstChild', 'lastChild',
    'nextSibling', 'previousSibling', 'firstElementChild',
    'lastElementChild', 'nextElementSibling', 'previousElementSibling',
    'childNodes', 'children', 'classList'
  ]);

  forwardProperties(DomApi.prototype, [
    'textContent', 'innerHTML'
  ]);


  /**
   * Event API wrapper class returned from `Polymer.dom.(target)` when
   * `target` is an `Event`.
   */
  class EventApi {
    constructor(event) {
      this.event = event;
    }

    /**
     * Returns the first node on the `composedPath` of this event.
     *
     * @return {!EventTarget} The node this event was dispatched to
     */
    get rootTarget() {
      return this.event.composedPath()[0];
    }

    /**
     * Returns the local (re-targeted) target for this event.
     *
     * @return {!EventTarget} The local (re-targeted) target for this event.
     */
    get localTarget() {
      return this.event.target;
    }

    /**
     * Returns the `composedPath` for this event.
     * @return {!Array<!EventTarget>} The nodes this event propagated through
     */
    get path() {
      return this.event.composedPath();
    }
  }

  Polymer.DomApi = DomApi;

  /**
   * @function
   * @param {boolean=} deep
   * @return {!Node}
   */
  Polymer.DomApi.prototype.cloneNode;
  /**
   * @function
   * @param {!Node} node
   * @return {!Node}
   */
  Polymer.DomApi.prototype.appendChild;
  /**
   * @function
   * @param {!Node} newChild
   * @param {Node} refChild
   * @return {!Node}
   */
  Polymer.DomApi.prototype.insertBefore;
  /**
   * @function
   * @param {!Node} node
   * @return {!Node}
   */
  Polymer.DomApi.prototype.removeChild;
  /**
   * @function
   * @param {!Node} oldChild
   * @param {!Node} newChild
   * @return {!Node}
   */
  Polymer.DomApi.prototype.replaceChild;
  /**
   * @function
   * @param {string} name
   * @param {string} value
   * @return {void}
   */
  Polymer.DomApi.prototype.setAttribute;
  /**
   * @function
   * @param {string} name
   * @return {void}
   */
  Polymer.DomApi.prototype.removeAttribute;
  /**
   * @function
   * @param {string} selector
   * @return {?Element}
   */
  Polymer.DomApi.prototype.querySelector;
  /**
   * @function
   * @param {string} selector
   * @return {!NodeList<!Element>}
   */
  Polymer.DomApi.prototype.querySelectorAll;

  /**
   * Legacy DOM and Event manipulation API wrapper factory used to abstract
   * differences between native Shadow DOM and "Shady DOM" when polyfilling on
   * older browsers.
   *
   * Note that in Polymer 2.x use of `Polymer.dom` is no longer required and
   * in the majority of cases simply facades directly to the standard native
   * API.
   *
   * @namespace
   * @summary Legacy DOM and Event manipulation API wrapper factory used to
   * abstract differences between native Shadow DOM and "Shady DOM."
   * @memberof Polymer
   * @param {(Node|Event)=} obj Node or event to operate on
   * @return {!DomApi|!EventApi} Wrapper providing either node API or event API
   */
  Polymer.dom = function(obj) {
    obj = obj || document;
    if (!obj.__domApi) {
      let helper;
      if (obj instanceof Event) {
        helper = new EventApi(obj);
      } else {
        helper = new DomApi(obj);
      }
      obj.__domApi = helper;
    }
    return obj.__domApi;
  };

  Polymer.dom.matchesSelector = matchesSelector;

  /**
   * Forces several classes of asynchronously queued tasks to flush:
   * - Debouncers added via `Polymer.enqueueDebouncer`
   * - ShadyDOM distribution
   *
   * This method facades to `Polymer.flush`.
   *
   * @memberof Polymer.dom
   */
  Polymer.dom.flush = Polymer.flush;

  /**
   * Adds a `Polymer.Debouncer` to a list of globally flushable tasks.
   *
   * This method facades to `Polymer.enqueueDebouncer`.
   *
   * @memberof Polymer.dom
   * @param {!Polymer.Debouncer} debouncer Debouncer to enqueue
   */
  Polymer.dom.addDebouncer = Polymer.enqueueDebouncer;
})();


(function() {

  'use strict';

  let styleInterface = window.ShadyCSS;

  /**
   * Element class mixin that provides Polymer's "legacy" API intended to be
   * backward-compatible to the greatest extent possible with the API
   * found on the Polymer 1.x `Polymer.Base` prototype applied to all elements
   * defined using the `Polymer({...})` function.
   *
   * @mixinFunction
   * @polymer
   * @appliesMixin Polymer.ElementMixin
   * @appliesMixin Polymer.GestureEventListeners
   * @property isAttached {boolean} Set to `true` in this element's
   *   `connectedCallback` and `false` in `disconnectedCallback`
   * @memberof Polymer
   * @summary Element class mixin that provides Polymer's "legacy" API
   */
  Polymer.LegacyElementMixin = Polymer.dedupingMixin((base) => {

    /**
     * @constructor
     * @extends {base}
     * @implements {Polymer_ElementMixin}
     * @implements {Polymer_GestureEventListeners}
     * @implements {Polymer_DirMixin}
     * @private
     */
    const legacyElementBase = Polymer.DirMixin(Polymer.GestureEventListeners(Polymer.ElementMixin(base)));

    /**
     * Map of simple names to touch action names
     * @dict
     */
    const DIRECTION_MAP = {
      'x': 'pan-x',
      'y': 'pan-y',
      'none': 'none',
      'all': 'auto'
    };

    /**
     * @polymer
     * @mixinClass
     * @extends {legacyElementBase}
     * @implements {Polymer_LegacyElementMixin}
     * @unrestricted
     */
    class LegacyElement extends legacyElementBase {

      constructor() {
        super();
        /** @type {boolean} */
        this.isAttached;
        /** @type {WeakMap<!Element, !Object<string, !Function>>} */
        this.__boundListeners;
        /** @type {Object<string, Function>} */
        this._debouncers;
      }

      /**
       * Forwards `importMeta` from the prototype (i.e. from the info object
       * passed to `Polymer({...})`) to the static API.
       *
       * @return {!Object} The `import.meta` object set on the prototype
       * @suppress {missingProperties} `this` is always in the instance in
       *  closure for some reason even in a static method, rather than the class
       */
      static get importMeta() {
        return this.prototype.importMeta;
      }

      /**
       * Legacy callback called during the `constructor`, for overriding
       * by the user.
       * @return {void}
       */
      created() {}

      /**
       * Provides an implementation of `connectedCallback`
       * which adds Polymer legacy API's `attached` method.
       * @return {void}
       * @override
       */
      connectedCallback() {
        super.connectedCallback();
        this.isAttached = true;
        this.attached();
      }

      /**
       * Legacy callback called during `connectedCallback`, for overriding
       * by the user.
       * @return {void}
       */
      attached() {}

      /**
       * Provides an implementation of `disconnectedCallback`
       * which adds Polymer legacy API's `detached` method.
       * @return {void}
       * @override
       */
      disconnectedCallback() {
        super.disconnectedCallback();
        this.isAttached = false;
        this.detached();
      }

      /**
       * Legacy callback called during `disconnectedCallback`, for overriding
       * by the user.
       * @return {void}
       */
      detached() {}

      /**
       * Provides an override implementation of `attributeChangedCallback`
       * which adds the Polymer legacy API's `attributeChanged` method.
       * @param {string} name Name of attribute.
       * @param {?string} old Old value of attribute.
       * @param {?string} value Current value of attribute.
       * @param {?string} namespace Attribute namespace.
       * @return {void}
       * @override
       */
      attributeChangedCallback(name, old, value, namespace) {
        if (old !== value) {
          super.attributeChangedCallback(name, old, value, namespace);
          this.attributeChanged(name, old, value);
        }
      }

      /**
       * Legacy callback called during `attributeChangedChallback`, for overriding
       * by the user.
       * @param {string} name Name of attribute.
       * @param {?string} old Old value of attribute.
       * @param {?string} value Current value of attribute.
       * @return {void}
       */
      attributeChanged(name, old, value) {} // eslint-disable-line no-unused-vars

      /**
       * Overrides the default `Polymer.PropertyEffects` implementation to
       * add support for class initialization via the `_registered` callback.
       * This is called only when the first instance of the element is created.
       *
       * @return {void}
       * @override
       * @suppress {invalidCasts}
       */
      _initializeProperties() {
        let proto = Object.getPrototypeOf(this);
        if (!proto.hasOwnProperty('__hasRegisterFinished')) {
          this._registered();
          // backstop in case the `_registered` implementation does not set this
          proto.__hasRegisterFinished = true;
        }
        super._initializeProperties();
        this.root = /** @type {HTMLElement} */(this);
        this.created();
        // Ensure listeners are applied immediately so that they are
        // added before declarative event listeners. This allows an element to
        // decorate itself via an event prior to any declarative listeners
        // seeing the event. Note, this ensures compatibility with 1.x ordering.
        this._applyListeners();
      }

      /**
       * Called automatically when an element is initializing.
       * Users may override this method to perform class registration time
       * work. The implementation should ensure the work is performed
       * only once for the class.
       * @protected
       * @return {void}
       */
      _registered() {}

      /**
       * Overrides the default `Polymer.PropertyEffects` implementation to
       * add support for installing `hostAttributes` and `listeners`.
       *
       * @return {void}
       * @override
       */
      ready() {
        this._ensureAttributes();
        super.ready();
      }

      /**
       * Ensures an element has required attributes. Called when the element
       * is being readied via `ready`. Users should override to set the
       * element's required attributes. The implementation should be sure
       * to check and not override existing attributes added by
       * the user of the element. Typically, setting attributes should be left
       * to the element user and not done here; reasonable exceptions include
       * setting aria roles and focusability.
       * @protected
       * @return {void}
       */
      _ensureAttributes() {}

      /**
       * Adds element event listeners. Called when the element
       * is being readied via `ready`. Users should override to
       * add any required element event listeners.
       * In performance critical elements, the work done here should be kept
       * to a minimum since it is done before the element is rendered. In
       * these elements, consider adding listeners asynchronously so as not to
       * block render.
       * @protected
       * @return {void}
       */
      _applyListeners() {}

      /**
       * Converts a typed JavaScript value to a string.
       *
       * Note this method is provided as backward-compatible legacy API
       * only.  It is not directly called by any Polymer features. To customize
       * how properties are serialized to attributes for attribute bindings and
       * `reflectToAttribute: true` properties as well as this method, override
       * the `_serializeValue` method provided by `Polymer.PropertyAccessors`.
       *
       * @param {*} value Value to deserialize
       * @return {string | undefined} Serialized value
       */
      serialize(value) {
        return this._serializeValue(value);
      }

      /**
       * Converts a string to a typed JavaScript value.
       *
       * Note this method is provided as backward-compatible legacy API
       * only.  It is not directly called by any Polymer features.  To customize
       * how attributes are deserialized to properties for in
       * `attributeChangedCallback`, override `_deserializeValue` method
       * provided by `Polymer.PropertyAccessors`.
       *
       * @param {string} value String to deserialize
       * @param {*} type Type to deserialize the string to
       * @return {*} Returns the deserialized value in the `type` given.
       */
      deserialize(value, type) {
        return this._deserializeValue(value, type);
      }

      /**
       * Serializes a property to its associated attribute.
       *
       * Note this method is provided as backward-compatible legacy API
       * only.  It is not directly called by any Polymer features.
       *
       * @param {string} property Property name to reflect.
       * @param {string=} attribute Attribute name to reflect.
       * @param {*=} value Property value to reflect.
       * @return {void}
       */
      reflectPropertyToAttribute(property, attribute, value) {
        this._propertyToAttribute(property, attribute, value);
      }

      /**
       * Sets a typed value to an HTML attribute on a node.
       *
       * Note this method is provided as backward-compatible legacy API
       * only.  It is not directly called by any Polymer features.
       *
       * @param {*} value Value to serialize.
       * @param {string} attribute Attribute name to serialize to.
       * @param {Element} node Element to set attribute to.
       * @return {void}
       */
      serializeValueToAttribute(value, attribute, node) {
        this._valueToNodeAttribute(/** @type {Element} */ (node || this), value, attribute);
      }

      /**
       * Copies own properties (including accessor descriptors) from a source
       * object to a target object.
       *
       * @param {Object} prototype Target object to copy properties to.
       * @param {Object} api Source object to copy properties from.
       * @return {Object} prototype object that was passed as first argument.
       */
      extend(prototype, api) {
        if (!(prototype && api)) {
          return prototype || api;
        }
        let n$ = Object.getOwnPropertyNames(api);
        for (let i=0, n; (i<n$.length) && (n=n$[i]); i++) {
          let pd = Object.getOwnPropertyDescriptor(api, n);
          if (pd) {
            Object.defineProperty(prototype, n, pd);
          }
        }
        return prototype;
      }

      /**
       * Copies props from a source object to a target object.
       *
       * Note, this method uses a simple `for...in` strategy for enumerating
       * properties.  To ensure only `ownProperties` are copied from source
       * to target and that accessor implementations are copied, use `extend`.
       *
       * @param {!Object} target Target object to copy properties to.
       * @param {!Object} source Source object to copy properties from.
       * @return {!Object} Target object that was passed as first argument.
       */
      mixin(target, source) {
        for (let i in source) {
          target[i] = source[i];
        }
        return target;
      }

      /**
       * Sets the prototype of an object.
       *
       * Note this method is provided as backward-compatible legacy API
       * only.  It is not directly called by any Polymer features.
       * @param {Object} object The object on which to set the prototype.
       * @param {Object} prototype The prototype that will be set on the given
       * `object`.
       * @return {Object} Returns the given `object` with its prototype set
       * to the given `prototype` object.
       */
      chainObject(object, prototype) {
        if (object && prototype && object !== prototype) {
          object.__proto__ = prototype;
        }
        return object;
      }

      /* **** Begin Template **** */

      /**
       * Calls `importNode` on the `content` of the `template` specified and
       * returns a document fragment containing the imported content.
       *
       * @param {HTMLTemplateElement} template HTML template element to instance.
       * @return {!DocumentFragment} Document fragment containing the imported
       *   template content.
      */
      instanceTemplate(template) {
        let content = this.constructor._contentForTemplate(template);
        let dom = /** @type {!DocumentFragment} */
          (document.importNode(content, true));
        return dom;
      }

      /* **** Begin Events **** */



      /**
       * Dispatches a custom event with an optional detail value.
       *
       * @param {string} type Name of event type.
       * @param {*=} detail Detail value containing event-specific
       *   payload.
       * @param {{ bubbles: (boolean|undefined), cancelable: (boolean|undefined), composed: (boolean|undefined) }=}
       *  options Object specifying options.  These may include:
       *  `bubbles` (boolean, defaults to `true`),
       *  `cancelable` (boolean, defaults to false), and
       *  `node` on which to fire the event (HTMLElement, defaults to `this`).
       * @return {!Event} The new event that was fired.
       */
      fire(type, detail, options) {
        options = options || {};
        detail = (detail === null || detail === undefined) ? {} : detail;
        let event = new Event(type, {
          bubbles: options.bubbles === undefined ? true : options.bubbles,
          cancelable: Boolean(options.cancelable),
          composed: options.composed === undefined ? true: options.composed
        });
        event.detail = detail;
        let node = options.node || this;
        node.dispatchEvent(event);
        return event;
      }

      /**
       * Convenience method to add an event listener on a given element,
       * late bound to a named method on this element.
       *
       * @param {Element} node Element to add event listener to.
       * @param {string} eventName Name of event to listen for.
       * @param {string} methodName Name of handler method on `this` to call.
       * @return {void}
       */
      listen(node, eventName, methodName) {
        node = /** @type {!Element} */ (node || this);
        let hbl = this.__boundListeners ||
          (this.__boundListeners = new WeakMap());
        let bl = hbl.get(node);
        if (!bl) {
          bl = {};
          hbl.set(node, bl);
        }
        let key = eventName + methodName;
        if (!bl[key]) {
          bl[key] = this._addMethodEventListenerToNode(
            node, eventName, methodName, this);
        }
      }

      /**
       * Convenience method to remove an event listener from a given element,
       * late bound to a named method on this element.
       *
       * @param {Element} node Element to remove event listener from.
       * @param {string} eventName Name of event to stop listening to.
       * @param {string} methodName Name of handler method on `this` to not call
       anymore.
       * @return {void}
       */
      unlisten(node, eventName, methodName) {
        node = /** @type {!Element} */ (node || this);
        let bl = this.__boundListeners && this.__boundListeners.get(node);
        let key = eventName + methodName;
        let handler = bl && bl[key];
        if (handler) {
          this._removeEventListenerFromNode(node, eventName, handler);
          bl[key] = null;
        }
      }

      /**
       * Override scrolling behavior to all direction, one direction, or none.
       *
       * Valid scroll directions:
       *   - 'all': scroll in any direction
       *   - 'x': scroll only in the 'x' direction
       *   - 'y': scroll only in the 'y' direction
       *   - 'none': disable scrolling for this node
       *
       * @param {string=} direction Direction to allow scrolling
       * Defaults to `all`.
       * @param {Element=} node Element to apply scroll direction setting.
       * Defaults to `this`.
       * @return {void}
       */
      setScrollDirection(direction, node) {
        Polymer.Gestures.setTouchAction(/** @type {Element} */ (node || this), DIRECTION_MAP[direction] || 'auto');
      }
      /* **** End Events **** */

      /**
       * Convenience method to run `querySelector` on this local DOM scope.
       *
       * This function calls `Polymer.dom(this.root).querySelector(slctr)`.
       *
       * @param {string} slctr Selector to run on this local DOM scope
       * @return {Element} Element found by the selector, or null if not found.
       */
      $$(slctr) {
        return this.root.querySelector(slctr);
      }

      /**
       * Return the element whose local dom within which this element
       * is contained. This is a shorthand for
       * `this.getRootNode().host`.
       * @this {Element}
       */
      get domHost() {
        let root = this.getRootNode();
        return (root instanceof DocumentFragment) ? /** @type {ShadowRoot} */ (root).host : root;
      }

      /**
       * Force this element to distribute its children to its local dom.
       * This should not be necessary as of Polymer 2.0.2 and is provided only
       * for backwards compatibility.
       * @return {void}
       */
      distributeContent() {
        if (window.ShadyDOM && this.shadowRoot) {
          ShadyDOM.flush();
        }
      }

      /**
       * Returns a list of nodes that are the effective childNodes. The effective
       * childNodes list is the same as the element's childNodes except that
       * any `<content>` elements are replaced with the list of nodes distributed
       * to the `<content>`, the result of its `getDistributedNodes` method.
       * @return {!Array<!Node>} List of effective child nodes.
       * @suppress {invalidCasts} LegacyElementMixin must be applied to an HTMLElement
       */
      getEffectiveChildNodes() {
        const thisEl = /** @type {Element} */ (this);
        const domApi = /** @type {Polymer.DomApi} */(Polymer.dom(thisEl));
        return domApi.getEffectiveChildNodes();
      }

      /**
       * Returns a list of nodes distributed within this element that match
       * `selector`. These can be dom children or elements distributed to
       * children that are insertion points.
       * @param {string} selector Selector to run.
       * @return {!Array<!Node>} List of distributed elements that match selector.
       * @suppress {invalidCasts} LegacyElementMixin must be applied to an HTMLElement
       */
      queryDistributedElements(selector) {
        const thisEl = /** @type {Element} */ (this);
        const domApi = /** @type {Polymer.DomApi} */(Polymer.dom(thisEl));
        return domApi.queryDistributedElements(selector);
      }

      /**
       * Returns a list of elements that are the effective children. The effective
       * children list is the same as the element's children except that
       * any `<content>` elements are replaced with the list of elements
       * distributed to the `<content>`.
       *
       * @return {!Array<!Node>} List of effective children.
       */
      getEffectiveChildren() {
        let list = this.getEffectiveChildNodes();
        return list.filter(function(/** @type {!Node} */ n) {
          return (n.nodeType === Node.ELEMENT_NODE);
        });
      }

      /**
       * Returns a string of text content that is the concatenation of the
       * text content's of the element's effective childNodes (the elements
       * returned by <a href="#getEffectiveChildNodes>getEffectiveChildNodes</a>.
       *
       * @return {string} List of effective children.
       */
      getEffectiveTextContent() {
        let cn = this.getEffectiveChildNodes();
        let tc = [];
        for (let i=0, c; (c = cn[i]); i++) {
          if (c.nodeType !== Node.COMMENT_NODE) {
            tc.push(c.textContent);
          }
        }
        return tc.join('');
      }

      /**
       * Returns the first effective childNode within this element that
       * match `selector`. These can be dom child nodes or elements distributed
       * to children that are insertion points.
       * @param {string} selector Selector to run.
       * @return {Node} First effective child node that matches selector.
       */
      queryEffectiveChildren(selector) {
        let e$ = this.queryDistributedElements(selector);
        return e$ && e$[0];
      }

      /**
       * Returns a list of effective childNodes within this element that
       * match `selector`. These can be dom child nodes or elements distributed
       * to children that are insertion points.
       * @param {string} selector Selector to run.
       * @return {!Array<!Node>} List of effective child nodes that match selector.
       */
      queryAllEffectiveChildren(selector) {
        return this.queryDistributedElements(selector);
      }

      /**
       * Returns a list of nodes distributed to this element's `<slot>`.
       *
       * If this element contains more than one `<slot>` in its local DOM,
       * an optional selector may be passed to choose the desired content.
       *
       * @param {string=} slctr CSS selector to choose the desired
       *   `<slot>`.  Defaults to `content`.
       * @return {!Array<!Node>} List of distributed nodes for the `<slot>`.
       */
      getContentChildNodes(slctr) {
        let content = this.root.querySelector(slctr || 'slot');
        return content ? /** @type {Polymer.DomApi} */(Polymer.dom(content)).getDistributedNodes() : [];
      }

      /**
       * Returns a list of element children distributed to this element's
       * `<slot>`.
       *
       * If this element contains more than one `<slot>` in its
       * local DOM, an optional selector may be passed to choose the desired
       * content.  This method differs from `getContentChildNodes` in that only
       * elements are returned.
       *
       * @param {string=} slctr CSS selector to choose the desired
       *   `<content>`.  Defaults to `content`.
       * @return {!Array<!HTMLElement>} List of distributed nodes for the
       *   `<slot>`.
       * @suppress {invalidCasts}
       */
      getContentChildren(slctr) {
        let children = /** @type {!Array<!HTMLElement>} */(this.getContentChildNodes(slctr).filter(function(n) {
          return (n.nodeType === Node.ELEMENT_NODE);
        }));
        return children;
      }

      /**
       * Checks whether an element is in this element's light DOM tree.
       *
       * @param {?Node} node The element to be checked.
       * @return {boolean} true if node is in this element's light DOM tree.
       * @suppress {invalidCasts} LegacyElementMixin must be applied to an HTMLElement
       */
      isLightDescendant(node) {
        const thisNode = /** @type {Node} */ (this);
        return thisNode !== node && thisNode.contains(node) &&
          thisNode.getRootNode() === node.getRootNode();
      }

      /**
       * Checks whether an element is in this element's local DOM tree.
       *
       * @param {!Element} node The element to be checked.
       * @return {boolean} true if node is in this element's local DOM tree.
       */
      isLocalDescendant(node) {
        return this.root === node.getRootNode();
      }

      /**
       * No-op for backwards compatibility. This should now be handled by
       * ShadyCss library.
       * @param  {*} container Unused
       * @param  {*} shouldObserve Unused
       * @return {void}
       */
      scopeSubtree(container, shouldObserve) { // eslint-disable-line no-unused-vars
      }

      /**
       * Returns the computed style value for the given property.
       * @param {string} property The css property name.
       * @return {string} Returns the computed css property value for the given
       * `property`.
       * @suppress {invalidCasts} LegacyElementMixin must be applied to an HTMLElement
       */
      getComputedStyleValue(property) {
        return styleInterface.getComputedStyleValue(/** @type {!Element} */(this), property);
      }

      // debounce

      /**
       * Call `debounce` to collapse multiple requests for a named task into
       * one invocation which is made after the wait time has elapsed with
       * no new request.  If no wait time is given, the callback will be called
       * at microtask timing (guaranteed before paint).
       *
       *     debouncedClickAction(e) {
       *       // will not call `processClick` more than once per 100ms
       *       this.debounce('click', function() {
       *        this.processClick();
       *       } 100);
       *     }
       *
       * @param {string} jobName String to identify the debounce job.
       * @param {function():void} callback Function that is called (with `this`
       *   context) when the wait time elapses.
       * @param {number} wait Optional wait time in milliseconds (ms) after the
       *   last signal that must elapse before invoking `callback`
       * @return {!Object} Returns a debouncer object on which exists the
       * following methods: `isActive()` returns true if the debouncer is
       * active; `cancel()` cancels the debouncer if it is active;
       * `flush()` immediately invokes the debounced callback if the debouncer
       * is active.
       */
      debounce(jobName, callback, wait) {
        this._debouncers = this._debouncers || {};
        return this._debouncers[jobName] = Polymer.Debouncer.debounce(
              this._debouncers[jobName]
            , wait > 0 ? Polymer.Async.timeOut.after(wait) : Polymer.Async.microTask
            , callback.bind(this));
      }

      /**
       * Returns whether a named debouncer is active.
       *
       * @param {string} jobName The name of the debouncer started with `debounce`
       * @return {boolean} Whether the debouncer is active (has not yet fired).
       */
      isDebouncerActive(jobName) {
        this._debouncers = this._debouncers || {};
        let debouncer = this._debouncers[jobName];
        return !!(debouncer && debouncer.isActive());
      }

      /**
       * Immediately calls the debouncer `callback` and inactivates it.
       *
       * @param {string} jobName The name of the debouncer started with `debounce`
       * @return {void}
       */
      flushDebouncer(jobName) {
        this._debouncers = this._debouncers || {};
        let debouncer = this._debouncers[jobName];
        if (debouncer) {
          debouncer.flush();
        }
      }

      /**
       * Cancels an active debouncer.  The `callback` will not be called.
       *
       * @param {string} jobName The name of the debouncer started with `debounce`
       * @return {void}
       */
      cancelDebouncer(jobName) {
        this._debouncers = this._debouncers || {};
        let debouncer = this._debouncers[jobName];
        if (debouncer) {
          debouncer.cancel();
        }
      }

      /**
       * Runs a callback function asynchronously.
       *
       * By default (if no waitTime is specified), async callbacks are run at
       * microtask timing, which will occur before paint.
       *
       * @param {!Function} callback The callback function to run, bound to `this`.
       * @param {number=} waitTime Time to wait before calling the
       *   `callback`.  If unspecified or 0, the callback will be run at microtask
       *   timing (before paint).
       * @return {number} Handle that may be used to cancel the async job.
       */
      async(callback, waitTime) {
        return waitTime > 0 ? Polymer.Async.timeOut.run(callback.bind(this), waitTime) :
            ~Polymer.Async.microTask.run(callback.bind(this));
      }

      /**
       * Cancels an async operation started with `async`.
       *
       * @param {number} handle Handle returned from original `async` call to
       *   cancel.
       * @return {void}
       */
      cancelAsync(handle) {
        handle < 0 ? Polymer.Async.microTask.cancel(~handle) :
            Polymer.Async.timeOut.cancel(handle);
      }

      // other

      /**
       * Convenience method for creating an element and configuring it.
       *
       * @param {string} tag HTML element tag to create.
       * @param {Object=} props Object of properties to configure on the
       *    instance.
       * @return {!Element} Newly created and configured element.
       */
      create(tag, props) {
        let elt = document.createElement(tag);
        if (props) {
          if (elt.setProperties) {
            elt.setProperties(props);
          } else {
            for (let n in props) {
              elt[n] = props[n];
            }
          }
        }
        return elt;
      }

      /**
       * Convenience method for importing an HTML document imperatively.
       *
       * This method creates a new `<link rel="import">` element with
       * the provided URL and appends it to the document to start loading.
       * In the `onload` callback, the `import` property of the `link`
       * element will contain the imported document contents.
       *
       * @param {string} href URL to document to load.
       * @param {?function(!Event):void=} onload Callback to notify when an import successfully
       *   loaded.
       * @param {?function(!ErrorEvent):void=} onerror Callback to notify when an import
       *   unsuccessfully loaded.
       * @param {boolean=} optAsync True if the import should be loaded `async`.
       *   Defaults to `false`.
       * @return {!HTMLLinkElement} The link element for the URL to be loaded.
       */
      importHref(href, onload, onerror, optAsync) { // eslint-disable-line no-unused-vars
        let loadFn = onload ? onload.bind(this) : null;
        let errorFn = onerror ? onerror.bind(this) : null;
        return Polymer.importHref(href, loadFn, errorFn, optAsync);
      }

      /**
       * Polyfill for Element.prototype.matches, which is sometimes still
       * prefixed.
       *
       * @param {string} selector Selector to test.
       * @param {!Element=} node Element to test the selector against.
       * @return {boolean} Whether the element matches the selector.
       */
      elementMatches(selector, node) {
        return Polymer.dom.matchesSelector(/** @type {!Element} */ (node || this), selector);
      }

      /**
       * Toggles an HTML attribute on or off.
       *
       * @param {string} name HTML attribute name
       * @param {boolean=} bool Boolean to force the attribute on or off.
       *    When unspecified, the state of the attribute will be reversed.
       * @param {Element=} node Node to target.  Defaults to `this`.
       * @return {void}
       */
      toggleAttribute(name, bool, node) {
        node = /** @type {Element} */ (node || this);
        if (arguments.length == 1) {
          bool = !node.hasAttribute(name);
        }
        if (bool) {
          node.setAttribute(name, '');
        } else {
          node.removeAttribute(name);
        }
      }


      /**
       * Toggles a CSS class on or off.
       *
       * @param {string} name CSS class name
       * @param {boolean=} bool Boolean to force the class on or off.
       *    When unspecified, the state of the class will be reversed.
       * @param {Element=} node Node to target.  Defaults to `this`.
       * @return {void}
       */
      toggleClass(name, bool, node) {
        node = /** @type {Element} */ (node || this);
        if (arguments.length == 1) {
          bool = !node.classList.contains(name);
        }
        if (bool) {
          node.classList.add(name);
        } else {
          node.classList.remove(name);
        }
      }

      /**
       * Cross-platform helper for setting an element's CSS `transform` property.
       *
       * @param {string} transformText Transform setting.
       * @param {Element=} node Element to apply the transform to.
       * Defaults to `this`
       * @return {void}
       */
      transform(transformText, node) {
        node = /** @type {Element} */ (node || this);
        node.style.webkitTransform = transformText;
        node.style.transform = transformText;
      }

      /**
       * Cross-platform helper for setting an element's CSS `translate3d`
       * property.
       *
       * @param {number} x X offset.
       * @param {number} y Y offset.
       * @param {number} z Z offset.
       * @param {Element=} node Element to apply the transform to.
       * Defaults to `this`.
       * @return {void}
       */
      translate3d(x, y, z, node) {
        node = /** @type {Element} */ (node || this);
        this.transform('translate3d(' + x + ',' + y + ',' + z + ')', node);
      }

      /**
       * Removes an item from an array, if it exists.
       *
       * If the array is specified by path, a change notification is
       * generated, so that observers, data bindings and computed
       * properties watching that path can update.
       *
       * If the array is passed directly, **no change
       * notification is generated**.
       *
       * @param {string | !Array<number|string>} arrayOrPath Path to array from which to remove the item
       *   (or the array itself).
       * @param {*} item Item to remove.
       * @return {Array} Array containing item removed.
       */
      arrayDelete(arrayOrPath, item) {
        let index;
        if (Array.isArray(arrayOrPath)) {
          index = arrayOrPath.indexOf(item);
          if (index >= 0) {
            return arrayOrPath.splice(index, 1);
          }
        } else {
          let arr = Polymer.Path.get(this, arrayOrPath);
          index = arr.indexOf(item);
          if (index >= 0) {
            return this.splice(arrayOrPath, index, 1);
          }
        }
        return null;
      }

      // logging

      /**
       * Facades `console.log`/`warn`/`error` as override point.
       *
       * @param {string} level One of 'log', 'warn', 'error'
       * @param {Array} args Array of strings or objects to log
       * @return {void}
       */
      _logger(level, args) {
        // accept ['foo', 'bar'] and [['foo', 'bar']]
        if (Array.isArray(args) && args.length === 1 && Array.isArray(args[0])) {
          args = args[0];
        }
        switch(level) {
          case 'log':
          case 'warn':
          case 'error':
            console[level](...args);
        }
      }

      /**
       * Facades `console.log` as an override point.
       *
       * @param {...*} args Array of strings or objects to log
       * @return {void}
       */
      _log(...args) {
        this._logger('log', args);
      }

      /**
       * Facades `console.warn` as an override point.
       *
       * @param {...*} args Array of strings or objects to log
       * @return {void}
       */
      _warn(...args) {
        this._logger('warn', args);
      }

      /**
       * Facades `console.error` as an override point.
       *
       * @param {...*} args Array of strings or objects to log
       * @return {void}
       */
      _error(...args) {
        this._logger('error', args);
      }

      /**
       * Formats a message using the element type an a method name.
       *
       * @param {string} methodName Method name to associate with message
       * @param {...*} args Array of strings or objects to log
       * @return {Array} Array with formatting information for `console`
       *   logging.
       */
      _logf(methodName, ...args) {
        return ['[%s::%s]', this.is, methodName, ...args];
      }

    }

    LegacyElement.prototype.is = '';

    return LegacyElement;

  });

})();



  (function() {

    'use strict';

    const lifecycleProps = {
      attached: true,
      detached: true,
      ready: true,
      created: true,
      beforeRegister: true,
      registered: true,
      attributeChanged: true,
      listeners: true,
      hostAttributes: true
    };

    const excludeOnInfo = {
      attached: true,
      detached: true,
      ready: true,
      created: true,
      beforeRegister: true,
      registered: true,
      attributeChanged: true,
      behaviors: true,
      _noAccessors: true
    };

    const excludeOnBehaviors = Object.assign({
      listeners: true,
      hostAttributes: true,
      properties: true,
      observers: true,
    }, excludeOnInfo);

    function copyProperties(source, target, excludeProps) {
      const noAccessors = source._noAccessors;
      for (let p in source) {
        if (!(p in excludeProps)) {
          if (noAccessors) {
            target[p] = source[p];
          } else {
            let pd = Object.getOwnPropertyDescriptor(source, p);
            if (pd) {
              // ensure property is configurable so that a later behavior can
              // re-configure it.
              pd.configurable = true;
              Object.defineProperty(target, p, pd);
            }
          }
        }
      }
    }

    /**
     * Applies a "legacy" behavior or array of behaviors to the provided class.
     *
     * Note: this method will automatically also apply the `Polymer.LegacyElementMixin`
     * to ensure that any legacy behaviors can rely on legacy Polymer API on
     * the underlying element.
     *
     * @template T
     * @param {!Object|!Array<!Object>} behaviors Behavior object or array of behaviors.
     * @param {function(new:T)} klass Element class.
     * @return {function(new:T)} Returns a new Element class extended by the
     * passed in `behaviors` and also by `Polymer.LegacyElementMixin`.
     * @memberof Polymer
     * @suppress {invalidCasts, checkTypes}
     */
    function mixinBehaviors(behaviors, klass) {
      return GenerateClassFromInfo({}, Polymer.LegacyElementMixin(klass), behaviors);
    }

    // NOTE:
    // 1.x
    // Behaviors were mixed in *in reverse order* and de-duped on the fly.
    // The rule was that behavior properties were copied onto the element
    // prototype if and only if the property did not already exist.
    // Given: Polymer{ behaviors: [A, B, C, A, B]}, property copy order was:
    // (1), B, (2), A, (3) C. This means prototype properties win over
    // B properties win over A win over C. This mirrors what would happen
    // with inheritance if element extended B extended A extended C.
    //
    // Again given, Polymer{ behaviors: [A, B, C, A, B]}, the resulting
    // `behaviors` array was [C, A, B].
    // Behavior lifecycle methods were called in behavior array order
    // followed by the element, e.g. (1) C.created, (2) A.created,
    // (3) B.created, (4) element.created. There was no support for
    // super, and "super-behavior" methods were callable only by name).
    //
    // 2.x
    // Behaviors are made into proper mixins which live in the
    // element's prototype chain. Behaviors are placed in the element prototype
    // eldest to youngest and de-duped youngest to oldest:
    // So, first [A, B, C, A, B] becomes [C, A, B] then,
    // the element prototype becomes (oldest) (1) Polymer.Element, (2) class(C),
    // (3) class(A), (4) class(B), (5) class(Polymer({...})).
    // Result:
    // This means element properties win over B properties win over A win
    // over C. (same as 1.x)
    // If lifecycle is called (super then me), order is
    // (1) C.created, (2) A.created, (3) B.created, (4) element.created
    // (again same as 1.x)
    function applyBehaviors(proto, behaviors, lifecycle) {
      for (let i=0; i<behaviors.length; i++) {
        applyInfo(proto, behaviors[i], lifecycle, excludeOnBehaviors);
      }
    }

    function applyInfo(proto, info, lifecycle, excludeProps) {
      copyProperties(info, proto, excludeProps);
      for (let p in lifecycleProps) {
        if (info[p]) {
          lifecycle[p] = lifecycle[p] || [];
          lifecycle[p].push(info[p]);
        }
      }
    }

    /**
     * @param {Array} behaviors List of behaviors to flatten.
     * @param {Array=} list Target list to flatten behaviors into.
     * @param {Array=} exclude List of behaviors to exclude from the list.
     * @return {!Array} Returns the list of flattened behaviors.
     */
    function flattenBehaviors(behaviors, list, exclude) {
      list = list || [];
      for (let i=behaviors.length-1; i >= 0; i--) {
        let b = behaviors[i];
        if (b) {
          if (Array.isArray(b)) {
            flattenBehaviors(b, list);
          } else {
            // dedup
            if (list.indexOf(b) < 0 && (!exclude || exclude.indexOf(b) < 0)) {
              list.unshift(b);
            }
          }
        } else {
          console.warn('behavior is null, check for missing or 404 import');
        }
      }
      return list;
    }

    /* Note about construction and extension of legacy classes.
      [Changed in Q4 2018 to optimize performance.]

      When calling `Polymer` or `mixinBehaviors`, the generated class below is
      made. The list of behaviors was previously made into one generated class per
      behavior, but this is no longer the case as behaviors are now called
      manually. Note, there may *still* be multiple generated classes in the
      element's prototype chain if extension is used with `mixinBehaviors`.

      The generated class is directly tied to the info object and behaviors
      used to create it. That list of behaviors is filtered so it's only the
      behaviors not active on the superclass. In order to call through to the
      entire list of lifecycle methods, it's important to call `super`.

      The element's `properties` and `observers` are controlled via the finalization
      mechanism provided by `PropertiesMixin`. `Properties` and `observers` are
      collected by manually traversing the prototype chain and merging.

      To limit changes, the `_registered` method is called via `_initializeProperties`
      and not `_finalizeClass`.
    */
    /**
     * @param {!PolymerInit} info Polymer info object
     * @param {function(new:HTMLElement)} Base base class to extend with info object
     * @param {Object} behaviors behaviors to copy into the element
     * @return {function(new:HTMLElement)} Generated class
     * @suppress {checkTypes}
     * @private
     */
    function GenerateClassFromInfo(info, Base, behaviors) {

      // manages behavior and lifecycle processing (filled in after class definition)
      let behaviorList;
      const lifecycle = {};

      /** @private */
      class PolymerGenerated extends Base {

        // explicitly not calling super._finalizeClass
        static _finalizeClass() {
          // if calling via a subclass that hasn't been generated, pass through to super
          if (!this.hasOwnProperty(window.JSCompiler_renameProperty('generatedFrom', this))) {
            super._finalizeClass();
          } else {
            // interleave properties and observers per behavior and `info`
            if (behaviorList) {
              for (let i=0, b; i < behaviorList.length; i++) {
                b = behaviorList[i];
                if (b.properties) {
                  this.createProperties(b.properties);
                }
                if (b.observers) {
                  this.createObservers(b.observers, b.properties);
                }
              }
            }
            if (info.properties) {
              this.createProperties(info.properties);
            }
            if (info.observers) {
              this.createObservers(info.observers, info.properties);
            }
            // make sure to prepare the element template
            this._prepareTemplate();
          }
        }

        static get properties() {
          const properties = {};
          if (behaviorList) {
            for (let i=0; i < behaviorList.length; i++) {
              Object.assign(properties, behaviorList[i].properties);
            }
          }
          Object.assign(properties, info.properties);
          return properties;
        }

        static get observers() {
          let observers = [];
          if (behaviorList) {
            for (let i=0, b; i < behaviorList.length; i++) {
              b = behaviorList[i];
              if (b.observers) {
                observers = observers.concat(b.observers);
              }
            }
          }
          if (info.observers) {
            observers = observers.concat(info.observers);
          }
          return observers;
        }

        /**
         * @return {void}
         */
        created() {
          super.created();
          const list = lifecycle.created;
          if (list) {
            for (let i=0; i < list.length; i++) {
              list[i].call(this);
            }
          }
        }

        /**
         * @return {void}
         */
        _registered() {
          /* NOTE: `beforeRegister` is called here for bc, but the behavior
            is different than in 1.x. In 1.0, the method was called *after*
            mixing prototypes together but *before* processing of meta-objects.
            However, dynamic effects can still be set here and can be done either
            in `beforeRegister` or `registered`. It is no longer possible to set
            `is` in `beforeRegister` as you could in 1.x.
          */
          // only proceed if the generated class' prototype has not been registered.
          const generatedProto = PolymerGenerated.prototype;
          if (!generatedProto.hasOwnProperty('__hasRegisterFinished')) {
            generatedProto.__hasRegisterFinished = true;
            // ensure superclass is registered first.
            super._registered();
            // copy properties onto the generated class lazily if we're optimizing,
            if (Polymer.legacyOptimizations) {
              copyPropertiesToProto(generatedProto);
            }
            // make sure legacy lifecycle is called on the *element*'s prototype
            // and not the generated class prototype; if the element has been
            // extended, these are *not* the same.
            const proto = Object.getPrototypeOf(this);
            let list = lifecycle.beforeRegister;
            if (list) {
              for (let i=0; i < list.length; i++) {
                list[i].call(proto);
              }
            }
            list = lifecycle.registered;
            if (list) {
              for (let i=0; i < list.length; i++) {
                list[i].call(proto);
              }
            }
          }
        }

        /**
         * @return {void}
         */
        _applyListeners() {
          super._applyListeners();
          const list = lifecycle.listeners;
          if (list) {
            for (let i=0; i < list.length; i++) {
              const listeners = list[i];
              if (listeners) {
                for (let l in listeners) {
                  this._addMethodEventListenerToNode(this, l, listeners[l]);
                }
              }
            }
          }
        }

        // note: exception to "super then me" rule;
        // do work before calling super so that super attributes
        // only apply if not already set.
        /**
         * @return {void}
         */
        _ensureAttributes() {
          const list = lifecycle.hostAttributes;
          if (list) {
            for (let i=list.length-1; i >= 0; i--) {
              const hostAttributes = list[i];
              for (let a in hostAttributes) {
                  this._ensureAttribute(a, hostAttributes[a]);
                }
            }
          }
          super._ensureAttributes();
        }

        /**
         * @return {void}
         */
        ready() {
          super.ready();
          let list = lifecycle.ready;
          if (list) {
            for (let i=0; i < list.length; i++) {
              list[i].call(this);
            }
          }
        }

        /**
         * @return {void}
         */
        attached() {
          super.attached();
          let list = lifecycle.attached;
          if (list) {
            for (let i=0; i < list.length; i++) {
              list[i].call(this);
            }
          }
        }

        /**
         * @return {void}
         */
        detached() {
          super.detached();
          let list = lifecycle.detached;
          if (list) {
            for (let i=0; i < list.length; i++) {
              list[i].call(this);
            }
          }
        }

        /**
         * Implements native Custom Elements `attributeChangedCallback` to
         * set an attribute value to a property via `_attributeToProperty`.
         *
         * @param {string} name Name of attribute that changed
         * @param {?string} old Old attribute value
         * @param {?string} value New attribute value
         * @return {void}
         */
        attributeChanged(name, old, value) {
          super.attributeChanged();
          let list = lifecycle.attributeChanged;
          if (list) {
            for (let i=0; i < list.length; i++) {
              list[i].call(this, name, old, value);
            }
          }
        }
      }

      // apply behaviors, note actual copying is done lazily at first instance creation
      if (behaviors) {
        // NOTE: ensure the behavior is extending a class with
        // legacy element api. This is necessary since behaviors expect to be able
        // to access 1.x legacy api.
        if (!Array.isArray(behaviors)) {
          behaviors = [behaviors];
        }
        let superBehaviors = Base.prototype.behaviors;
        // get flattened, deduped list of behaviors *not* already on super class
        behaviorList = flattenBehaviors(behaviors, null, superBehaviors);
        PolymerGenerated.prototype.behaviors = superBehaviors ?
          superBehaviors.concat(behaviors) : behaviorList;
      }

      const copyPropertiesToProto = (proto) => {
        if (behaviorList) {
          applyBehaviors(proto, behaviorList, lifecycle);
        }
        applyInfo(proto, info, lifecycle, excludeOnInfo);
      };

      // copy properties if we're not optimizing
      if (!Polymer.legacyOptimizations) {
        copyPropertiesToProto(PolymerGenerated.prototype);
      }

      PolymerGenerated.generatedFrom = info;

      return PolymerGenerated;
    }

    /**
     * Generates a class that extends `Polymer.LegacyElement` based on the
     * provided info object.  Metadata objects on the `info` object
     * (`properties`, `observers`, `listeners`, `behaviors`, `is`) are used
     * for Polymer's meta-programming systems, and any functions are copied
     * to the generated class.
     *
     * Valid "metadata" values are as follows:
     *
     * `is`: String providing the tag name to register the element under. In
     * addition, if a `dom-module` with the same id exists, the first template
     * in that `dom-module` will be stamped into the shadow root of this element,
     * with support for declarative event listeners (`on-...`), Polymer data
     * bindings (`[[...]]` and `{{...}}`), and id-based node finding into
     * `this.$`.
     *
     * `properties`: Object describing property-related metadata used by Polymer
     * features (key: property names, value: object containing property metadata).
     * Valid keys in per-property metadata include:
     * - `type` (String|Number|Object|Array|...): Used by
     *   `attributeChangedCallback` to determine how string-based attributes
     *   are deserialized to JavaScript property values.
     * - `notify` (boolean): Causes a change in the property to fire a
     *   non-bubbling event called `<property>-changed`. Elements that have
     *   enabled two-way binding to the property use this event to observe changes.
     * - `readOnly` (boolean): Creates a getter for the property, but no setter.
     *   To set a read-only property, use the private setter method
     *   `_setProperty(property, value)`.
     * - `observer` (string): Observer method name that will be called when
     *   the property changes. The arguments of the method are
     *   `(value, previousValue)`.
     * - `computed` (string): String describing method and dependent properties
     *   for computing the value of this property (e.g. `'computeFoo(bar, zot)'`).
     *   Computed properties are read-only by default and can only be changed
     *   via the return value of the computing method.
     *
     * `observers`: Array of strings describing multi-property observer methods
     *  and their dependent properties (e.g. `'observeABC(a, b, c)'`).
     *
     * `listeners`: Object describing event listeners to be added to each
     *  instance of this element (key: event name, value: method name).
     *
     * `behaviors`: Array of additional `info` objects containing metadata
     * and callbacks in the same format as the `info` object here which are
     * merged into this element.
     *
     * `hostAttributes`: Object listing attributes to be applied to the host
     *  once created (key: attribute name, value: attribute value).  Values
     *  are serialized based on the type of the value.  Host attributes should
     *  generally be limited to attributes such as `tabIndex` and `aria-...`.
     *  Attributes in `hostAttributes` are only applied if a user-supplied
     *  attribute is not already present (attributes in markup override
     *  `hostAttributes`).
     *
     * In addition, the following Polymer-specific callbacks may be provided:
     * - `registered`: called after first instance of this element,
     * - `created`: called during `constructor`
     * - `attached`: called during `connectedCallback`
     * - `detached`: called during `disconnectedCallback`
     * - `ready`: called before first `attached`, after all properties of
     *   this element have been propagated to its template and all observers
     *   have run
     *
     * @param {!PolymerInit} info Object containing Polymer metadata and functions
     *   to become class methods.
     * @template T
     * @param {function(T):T} mixin Optional mixin to apply to legacy base class
     *   before extending with Polymer metaprogramming.
     * @return {function(new:HTMLElement)} Generated class
     * @memberof Polymer
     */
    Polymer.Class = function(info, mixin) {
      if (!info) {
        console.warn('Polymer.Class requires `info` argument');
      }
      let klass = mixin ? mixin(Polymer.LegacyElementMixin(HTMLElement)) :
          Polymer.LegacyElementMixin(HTMLElement);
      klass = GenerateClassFromInfo(info, klass, info.behaviors);
      if (info._enableDisableUpgrade) {
        klass = Polymer.DisableUpgradeMixin(klass);
      }
      // decorate klass with registration info
      klass.is = klass.prototype.is = info.is;
      return klass;
    };

    Polymer.mixinBehaviors = mixinBehaviors;

  })();




  (function() {
    'use strict';

    /**
     * Legacy class factory and registration helper for defining Polymer
     * elements.
     *
     * This method is equivalent to
     * `customElements.define(info.is, Polymer.Class(info));`
     *
     * See `Polymer.Class` for details on valid legacy metadata format for `info`.
     *
     * @global
     * @override
     * @function Polymer
     * @param {!PolymerInit} info Object containing Polymer metadata and functions
     *   to become class methods.
     * @return {function(new: HTMLElement)} Generated class
     * @suppress {duplicate, invalidCasts, checkTypes}
     */
    window.Polymer._polymerFn = function(info) {
      // if input is a `class` (aka a function with a prototype), use the prototype
      // remember that the `constructor` will never be called
      let klass;
      if (typeof info === 'function') {
        klass = info;
      } else {
        klass = Polymer.Class(info);
      }
      customElements.define(klass.is, /** @type {!HTMLElement} */(klass));
      return klass;
    };

  })();



(function() {
  'use strict';

  // Common implementation for mixin & behavior
  function mutablePropertyChange(inst, property, value, old, mutableData) {
    let isObject;
    if (mutableData) {
      isObject = (typeof value === 'object' && value !== null);
      // Pull `old` for Objects from temp cache, but treat `null` as a primitive
      if (isObject) {
        old = inst.__dataTemp[property];
      }
    }
    // Strict equality check, but return false for NaN===NaN
    let shouldChange = (old !== value && (old === old || value === value));
    // Objects are stored in temporary cache (cleared at end of
    // turn), which is used for dirty-checking
    if (isObject && shouldChange) {
      inst.__dataTemp[property] = value;
    }
    return shouldChange;
  }

  /**
   * Element class mixin to skip strict dirty-checking for objects and arrays
   * (always consider them to be "dirty"), for use on elements utilizing
   * `Polymer.PropertyEffects`
   *
   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
   * objects, which means that any deep modifications to an object or array will
   * not be propagated unless "immutable" data patterns are used (i.e. all object
   * references from the root to the mutation were changed).
   *
   * Polymer also provides a proprietary data mutation and path notification API
   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
   * mutation and notification of deep changes in an object graph to all elements
   * bound to the same object graph.
   *
   * In cases where neither immutable patterns nor the data mutation API can be
   * used, applying this mixin will cause Polymer to skip dirty checking for
   * objects and arrays (always consider them to be "dirty").  This allows a
   * user to make a deep modification to a bound object graph, and then either
   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
   * elements that wish to be updated based on deep mutations must apply this
   * mixin or otherwise skip strict dirty checking for objects/arrays.
   * Specifically, any elements in the binding tree between the source of a
   * mutation and the consumption of it must apply this mixin or enable the
   * `Polymer.OptionalMutableData` mixin.
   *
   * In order to make the dirty check strategy configurable, see
   * `Polymer.OptionalMutableData`.
   *
   * Note, the performance characteristics of propagating large object graphs
   * will be worse as opposed to using strict dirty checking with immutable
   * patterns or Polymer's path notification API.
   *
   * @mixinFunction
   * @polymer
   * @memberof Polymer
   * @summary Element class mixin to skip strict dirty-checking for objects
   *   and arrays
   */
  Polymer.MutableData = Polymer.dedupingMixin(superClass => {

    /**
     * @polymer
     * @mixinClass
     * @implements {Polymer_MutableData}
     */
    class MutableData extends superClass {
      /**
       * Overrides `Polymer.PropertyEffects` to provide option for skipping
       * strict equality checking for Objects and Arrays.
       *
       * This method pulls the value to dirty check against from the `__dataTemp`
       * cache (rather than the normal `__data` cache) for Objects.  Since the temp
       * cache is cleared at the end of a turn, this implementation allows
       * side-effects of deep object changes to be processed by re-setting the
       * same object (using the temp cache as an in-turn backstop to prevent
       * cycles due to 2-way notification).
       *
       * @param {string} property Property name
       * @param {*} value New property value
       * @param {*} old Previous property value
       * @return {boolean} Whether the property should be considered a change
       * @protected
       */
      _shouldPropertyChange(property, value, old) {
        return mutablePropertyChange(this, property, value, old, true);
      }

    }

    return MutableData;

  });


  /**
   * Element class mixin to add the optional ability to skip strict
   * dirty-checking for objects and arrays (always consider them to be
   * "dirty") by setting a `mutable-data` attribute on an element instance.
   *
   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
   * objects, which means that any deep modifications to an object or array will
   * not be propagated unless "immutable" data patterns are used (i.e. all object
   * references from the root to the mutation were changed).
   *
   * Polymer also provides a proprietary data mutation and path notification API
   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
   * mutation and notification of deep changes in an object graph to all elements
   * bound to the same object graph.
   *
   * In cases where neither immutable patterns nor the data mutation API can be
   * used, applying this mixin will allow Polymer to skip dirty checking for
   * objects and arrays (always consider them to be "dirty").  This allows a
   * user to make a deep modification to a bound object graph, and then either
   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
   * elements that wish to be updated based on deep mutations must apply this
   * mixin or otherwise skip strict dirty checking for objects/arrays.
   * Specifically, any elements in the binding tree between the source of a
   * mutation and the consumption of it must enable this mixin or apply the
   * `Polymer.MutableData` mixin.
   *
   * While this mixin adds the ability to forgo Object/Array dirty checking,
   * the `mutableData` flag defaults to false and must be set on the instance.
   *
   * Note, the performance characteristics of propagating large object graphs
   * will be worse by relying on `mutableData: true` as opposed to using
   * strict dirty checking with immutable patterns or Polymer's path notification
   * API.
   *
   * @mixinFunction
   * @polymer
   * @memberof Polymer
   * @summary Element class mixin to optionally skip strict dirty-checking
   *   for objects and arrays
   */
  Polymer.OptionalMutableData = Polymer.dedupingMixin(superClass => {

    /**
     * @mixinClass
     * @polymer
     * @implements {Polymer_OptionalMutableData}
     */
    class OptionalMutableData extends superClass {

      static get properties() {
        return {
          /**
           * Instance-level flag for configuring the dirty-checking strategy
           * for this element.  When true, Objects and Arrays will skip dirty
           * checking, otherwise strict equality checking will be used.
           */
          mutableData: Boolean
        };
      }

      /**
       * Overrides `Polymer.PropertyEffects` to provide option for skipping
       * strict equality checking for Objects and Arrays.
       *
       * When `this.mutableData` is true on this instance, this method
       * pulls the value to dirty check against from the `__dataTemp` cache
       * (rather than the normal `__data` cache) for Objects.  Since the temp
       * cache is cleared at the end of a turn, this implementation allows
       * side-effects of deep object changes to be processed by re-setting the
       * same object (using the temp cache as an in-turn backstop to prevent
       * cycles due to 2-way notification).
       *
       * @param {string} property Property name
       * @param {*} value New property value
       * @param {*} old Previous property value
       * @return {boolean} Whether the property should be considered a change
       * @protected
       */
      _shouldPropertyChange(property, value, old) {
        return mutablePropertyChange(this, property, value, old, this.mutableData);
      }
    }

    return OptionalMutableData;

  });

  // Export for use by legacy behavior
  Polymer.MutableData._mutablePropertyChange = mutablePropertyChange;

})();


  (function() {
    'use strict';

    // Base class for HTMLTemplateElement extension that has property effects
    // machinery for propagating host properties to children. This is an ES5
    // class only because Babel (incorrectly) requires super() in the class
    // constructor even though no `this` is used and it returns an instance.
    let newInstance = null;

    /**
     * @constructor
     * @extends {HTMLTemplateElement}
     * @private
     */
    function HTMLTemplateElementExtension() { return newInstance; }
    HTMLTemplateElementExtension.prototype = Object.create(HTMLTemplateElement.prototype, {
      constructor: {
        value: HTMLTemplateElementExtension,
        writable: true
      }
    });

    /**
     * @constructor
     * @implements {Polymer_PropertyEffects}
     * @extends {HTMLTemplateElementExtension}
     * @private
     */
    const DataTemplate = Polymer.PropertyEffects(HTMLTemplateElementExtension);

    /**
     * @constructor
     * @implements {Polymer_MutableData}
     * @extends {DataTemplate}
     * @private
     */
    const MutableDataTemplate = Polymer.MutableData(DataTemplate);

    // Applies a DataTemplate subclass to a <template> instance
    function upgradeTemplate(template, constructor) {
      newInstance = template;
      Object.setPrototypeOf(template, constructor.prototype);
      new constructor();
      newInstance = null;
    }

    /**
     * Base class for TemplateInstance.
     * @constructor
     * @implements {Polymer_PropertyEffects}
     * @private
     */
    const base = Polymer.PropertyEffects(class {});

    /**
     * @polymer
     * @customElement
     * @appliesMixin Polymer.PropertyEffects
     * @unrestricted
     */
    class TemplateInstanceBase extends base {
      constructor(props) {
        super();
        this._configureProperties(props);
        this.root = this._stampTemplate(this.__dataHost);
        // Save list of stamped children
        let children = this.children = [];
        for (let n = this.root.firstChild; n; n=n.nextSibling) {
          children.push(n);
          n.__templatizeInstance = this;
        }
        if (this.__templatizeOwner &&
          this.__templatizeOwner.__hideTemplateChildren__) {
          this._showHideChildren(true);
        }
        // Flush props only when props are passed if instance props exist
        // or when there isn't instance props.
        let options = this.__templatizeOptions;
        if ((props && options.instanceProps) || !options.instanceProps) {
          this._enableProperties();
        }
      }
      /**
       * Configure the given `props` by calling `_setPendingProperty`. Also
       * sets any properties stored in `__hostProps`.
       * @private
       * @param {Object} props Object of property name-value pairs to set.
       * @return {void}
       */
      _configureProperties(props) {
        let options = this.__templatizeOptions;
        if (options.forwardHostProp) {
          for (let hprop in this.__hostProps) {
            this._setPendingProperty(hprop, this.__dataHost['_host_' + hprop]);
          }
        }
        // Any instance props passed in the constructor will overwrite host props;
        // normally this would be a user error but we don't specifically filter them
        for (let iprop in props) {
          this._setPendingProperty(iprop, props[iprop]);
        }
      }
      /**
       * Forwards a host property to this instance.  This method should be
       * called on instances from the `options.forwardHostProp` callback
       * to propagate changes of host properties to each instance.
       *
       * Note this method enqueues the change, which are flushed as a batch.
       *
       * @param {string} prop Property or path name
       * @param {*} value Value of the property to forward
       * @return {void}
       */
      forwardHostProp(prop, value) {
        if (this._setPendingPropertyOrPath(prop, value, false, true)) {
          this.__dataHost._enqueueClient(this);
        }
      }

      /**
       * Override point for adding custom or simulated event handling.
       *
       * @param {!Node} node Node to add event listener to
       * @param {string} eventName Name of event
       * @param {function(!Event):void} handler Listener function to add
       * @return {void}
       */
      _addEventListenerToNode(node, eventName, handler) {
        if (this._methodHost && this.__templatizeOptions.parentModel) {
          // If this instance should be considered a parent model, decorate
          // events this template instance as `model`
          this._methodHost._addEventListenerToNode(node, eventName, (e) => {
            e.model = this;
            handler(e);
          });
        } else {
          // Otherwise delegate to the template's host (which could be)
          // another template instance
          let templateHost = this.__dataHost.__dataHost;
          if (templateHost) {
            templateHost._addEventListenerToNode(node, eventName, handler);
          }
        }
      }
      /**
       * Shows or hides the template instance top level child elements. For
       * text nodes, `textContent` is removed while "hidden" and replaced when
       * "shown."
       * @param {boolean} hide Set to true to hide the children;
       * set to false to show them.
       * @return {void}
       * @protected
       */
      _showHideChildren(hide) {
        let c = this.children;
        for (let i=0; i<c.length; i++) {
          let n = c[i];
          // Ignore non-changes
          if (Boolean(hide) != Boolean(n.__hideTemplateChildren__)) {
            if (n.nodeType === Node.TEXT_NODE) {
              if (hide) {
                n.__polymerTextContent__ = n.textContent;
                n.textContent = '';
              } else {
                n.textContent = n.__polymerTextContent__;
              }
            // remove and replace slot
            } else if (n.localName === 'slot') {
              if (hide) {
                n.__polymerReplaced__ = document.createComment('hidden-slot');
                n.parentNode.replaceChild(n.__polymerReplaced__, n);
              } else {
                const replace = n.__polymerReplaced__;
                if (replace) {
                  replace.parentNode.replaceChild(n, replace);
                }
              }
            }

            else if (n.style) {
              if (hide) {
                n.__polymerDisplay__ = n.style.display;
                n.style.display = 'none';
              } else {
                n.style.display = n.__polymerDisplay__;
              }
            }
          }
          n.__hideTemplateChildren__ = hide;
          if (n._showHideChildren) {
            n._showHideChildren(hide);
          }
        }
      }
      /**
       * Overrides default property-effects implementation to intercept
       * textContent bindings while children are "hidden" and cache in
       * private storage for later retrieval.
       *
       * @param {!Node} node The node to set a property on
       * @param {string} prop The property to set
       * @param {*} value The value to set
       * @return {void}
       * @protected
       */
      _setUnmanagedPropertyToNode(node, prop, value) {
        if (node.__hideTemplateChildren__ &&
            node.nodeType == Node.TEXT_NODE && prop == 'textContent') {
          node.__polymerTextContent__ = value;
        } else {
          super._setUnmanagedPropertyToNode(node, prop, value);
        }
      }
      /**
       * Find the parent model of this template instance.  The parent model
       * is either another templatize instance that had option `parentModel: true`,
       * or else the host element.
       *
       * @return {!Polymer_PropertyEffects} The parent model of this instance
       */
      get parentModel() {
        let model = this.__parentModel;
        if (!model) {
          let options;
          model = this;
          do {
            // A template instance's `__dataHost` is a <template>
            // `model.__dataHost.__dataHost` is the template's host
            model = model.__dataHost.__dataHost;
          } while ((options = model.__templatizeOptions) && !options.parentModel);
          this.__parentModel = model;
        }
        return model;
      }

      /**
       * Stub of HTMLElement's `dispatchEvent`, so that effects that may
       * dispatch events safely no-op.
       *
       * @param {Event} event Event to dispatch
       * @return {boolean} Always true.
       */
       dispatchEvent(event) { // eslint-disable-line no-unused-vars
         return true;
      }
    }

    /** @type {!DataTemplate} */
    TemplateInstanceBase.prototype.__dataHost;
    /** @type {!TemplatizeOptions} */
    TemplateInstanceBase.prototype.__templatizeOptions;
    /** @type {!Polymer_PropertyEffects} */
    TemplateInstanceBase.prototype._methodHost;
    /** @type {!Object} */
    TemplateInstanceBase.prototype.__templatizeOwner;
    /** @type {!Object} */
    TemplateInstanceBase.prototype.__hostProps;

    /**
     * @constructor
     * @extends {TemplateInstanceBase}
     * @implements {Polymer_MutableData}
     * @private
     */
    const MutableTemplateInstanceBase = Polymer.MutableData(TemplateInstanceBase);

    function findMethodHost(template) {
      // Technically this should be the owner of the outermost template.
      // In shadow dom, this is always getRootNode().host, but we can
      // approximate this via cooperation with our dataHost always setting
      // `_methodHost` as long as there were bindings (or id's) on this
      // instance causing it to get a dataHost.
      let templateHost = template.__dataHost;
      return templateHost && templateHost._methodHost || templateHost;
    }

    /* eslint-disable valid-jsdoc */
    /**
     * @suppress {missingProperties} class.prototype is not defined for some reason
     */
    function createTemplatizerClass(template, templateInfo, options) {
      // Anonymous class created by the templatize
      let base = options.mutableData ?
        MutableTemplateInstanceBase : TemplateInstanceBase;
      // Affordance for global mixins onto TemplatizeInstance
      if (Polymer.Templatize.mixin) {
        base = Polymer.Templatize.mixin(base);
      }
      /**
       * @constructor
       * @extends {base}
       * @private
       */
      let klass = class extends base { };
      klass.prototype.__templatizeOptions = options;
      klass.prototype._bindTemplate(template);
      addNotifyEffects(klass, template, templateInfo, options);
      return klass;
    }

    /**
     * @suppress {missingProperties} class.prototype is not defined for some reason
     */
    function addPropagateEffects(template, templateInfo, options) {
      let userForwardHostProp = options.forwardHostProp;
      if (userForwardHostProp) {
        // Provide data API and property effects on memoized template class
        let klass = templateInfo.templatizeTemplateClass;
        if (!klass) {
          let base = options.mutableData ? MutableDataTemplate : DataTemplate;
          /** @private */
          klass = templateInfo.templatizeTemplateClass =
            class TemplatizedTemplate extends base {};
          // Add template - >instances effects
          // and host <- template effects
          let hostProps = templateInfo.hostProps;
          for (let prop in hostProps) {
            klass.prototype._addPropertyEffect('_host_' + prop,
              klass.prototype.PROPERTY_EFFECT_TYPES.PROPAGATE,
              {fn: createForwardHostPropEffect(prop, userForwardHostProp)});
            klass.prototype._createNotifyingProperty('_host_' + prop);
          }
        }
        upgradeTemplate(template, klass);
        // Mix any pre-bound data into __data; no need to flush this to
        // instances since they pull from the template at instance-time
        if (template.__dataProto) {
          // Note, generally `__dataProto` could be chained, but it's guaranteed
          // to not be since this is a vanilla template we just added effects to
          Object.assign(template.__data, template.__dataProto);
        }
        // Clear any pending data for performance
        template.__dataTemp = {};
        template.__dataPending = null;
        template.__dataOld = null;
        template._enableProperties();
      }
    }
    /* eslint-enable valid-jsdoc */

    function createForwardHostPropEffect(hostProp, userForwardHostProp) {
      return function forwardHostProp(template, prop, props) {
        userForwardHostProp.call(template.__templatizeOwner,
          prop.substring('_host_'.length), props[prop]);
      };
    }

    function addNotifyEffects(klass, template, templateInfo, options) {
      let hostProps = templateInfo.hostProps || {};
      for (let iprop in options.instanceProps) {
        delete hostProps[iprop];
        let userNotifyInstanceProp = options.notifyInstanceProp;
        if (userNotifyInstanceProp) {
          klass.prototype._addPropertyEffect(iprop,
            klass.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,
            {fn: createNotifyInstancePropEffect(iprop, userNotifyInstanceProp)});
        }
      }
      if (options.forwardHostProp && template.__dataHost) {
        for (let hprop in hostProps) {
          klass.prototype._addPropertyEffect(hprop,
            klass.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,
            {fn: createNotifyHostPropEffect()});
        }
      }
    }

    function createNotifyInstancePropEffect(instProp, userNotifyInstanceProp) {
      return function notifyInstanceProp(inst, prop, props) {
        userNotifyInstanceProp.call(inst.__templatizeOwner,
          inst, prop, props[prop]);
      };
    }

    function createNotifyHostPropEffect() {
      return function notifyHostProp(inst, prop, props) {
        inst.__dataHost._setPendingPropertyOrPath('_host_' + prop, props[prop], true, true);
      };
    }

    /**
     * Module for preparing and stamping instances of templates that utilize
     * Polymer's data-binding and declarative event listener features.
     *
     * Example:
     *
     *     // Get a template from somewhere, e.g. light DOM
     *     let template = this.querySelector('template');
     *     // Prepare the template
     *     let TemplateClass = Polymer.Templatize.templatize(template);
     *     // Instance the template with an initial data model
     *     let instance = new TemplateClass({myProp: 'initial'});
     *     // Insert the instance's DOM somewhere, e.g. element's shadow DOM
     *     this.shadowRoot.appendChild(instance.root);
     *     // Changing a property on the instance will propagate to bindings
     *     // in the template
     *     instance.myProp = 'new value';
     *
     * The `options` dictionary passed to `templatize` allows for customizing
     * features of the generated template class, including how outer-scope host
     * properties should be forwarded into template instances, how any instance
     * properties added into the template's scope should be notified out to
     * the host, and whether the instance should be decorated as a "parent model"
     * of any event handlers.
     *
     *     // Customize property forwarding and event model decoration
     *     let TemplateClass = Polymer.Templatize.templatize(template, this, {
     *       parentModel: true,
     *       forwardHostProp(property, value) {...},
     *       instanceProps: {...},
     *       notifyInstanceProp(instance, property, value) {...},
     *     });
     *
     * @namespace
     * @memberof Polymer
     * @summary Module for preparing and stamping instances of templates
     *   utilizing Polymer templating features.
     */
    Polymer.Templatize = {

      /**
       * Returns an anonymous `Polymer.PropertyEffects` class bound to the
       * `<template>` provided.  Instancing the class will result in the
       * template being stamped into a document fragment stored as the instance's
       * `root` property, after which it can be appended to the DOM.
       *
       * Templates may utilize all Polymer data-binding features as well as
       * declarative event listeners.  Event listeners and inline computing
       * functions in the template will be called on the host of the template.
       *
       * The constructor returned takes a single argument dictionary of initial
       * property values to propagate into template bindings.  Additionally
       * host properties can be forwarded in, and instance properties can be
       * notified out by providing optional callbacks in the `options` dictionary.
       *
       * Valid configuration in `options` are as follows:
       *
       * - `forwardHostProp(property, value)`: Called when a property referenced
       *   in the template changed on the template's host. As this library does
       *   not retain references to templates instanced by the user, it is the
       *   templatize owner's responsibility to forward host property changes into
       *   user-stamped instances.  The `instance.forwardHostProp(property, value)`
       *    method on the generated class should be called to forward host
       *   properties into the template to prevent unnecessary property-changed
       *   notifications. Any properties referenced in the template that are not
       *   defined in `instanceProps` will be notified up to the template's host
       *   automatically.
       * - `instanceProps`: Dictionary of property names that will be added
       *   to the instance by the templatize owner.  These properties shadow any
       *   host properties, and changes within the template to these properties
       *   will result in `notifyInstanceProp` being called.
       * - `mutableData`: When `true`, the generated class will skip strict
       *   dirty-checking for objects and arrays (always consider them to be
       *   "dirty").
       * - `notifyInstanceProp(instance, property, value)`: Called when
       *   an instance property changes.  Users may choose to call `notifyPath`
       *   on e.g. the owner to notify the change.
       * - `parentModel`: When `true`, events handled by declarative event listeners
       *   (`on-event="handler"`) will be decorated with a `model` property pointing
       *   to the template instance that stamped it.  It will also be returned
       *   from `instance.parentModel` in cases where template instance nesting
       *   causes an inner model to shadow an outer model.
       *
       * All callbacks are called bound to the `owner`. Any context
       * needed for the callbacks (such as references to `instances` stamped)
       * should be stored on the `owner` such that they can be retrieved via
       * `this`.
       *
       * When `options.forwardHostProp` is declared as an option, any properties
       * referenced in the template will be automatically forwarded from the host of
       * the `<template>` to instances, with the exception of any properties listed in
       * the `options.instanceProps` object.  `instanceProps` are assumed to be
       * managed by the owner of the instances, either passed into the constructor
       * or set after the fact.  Note, any properties passed into the constructor will
       * always be set to the instance (regardless of whether they would normally
       * be forwarded from the host).
       *
       * Note that `templatize()` can be run only once for a given `<template>`.
       * Further calls will result in an error. Also, there is a special
       * behavior if the template was duplicated through a mechanism such as
       * `<dom-repeat>` or `<test-fixture>`. In this case, all calls to
       * `templatize()` return the same class for all duplicates of a template.
       * The class returned from `templatize()` is generated only once using
       * the `options` from the first call. This means that any `options`
       * provided to subsequent calls will be ignored. Therefore, it is very
       * important not to close over any variables inside the callbacks. Also,
       * arrow functions must be avoided because they bind the outer `this`.
       * Inside the callbacks, any contextual information can be accessed
       * through `this`, which points to the `owner`.
       *
       * @memberof Polymer.Templatize
       * @param {!HTMLTemplateElement} template Template to templatize
       * @param {Polymer_PropertyEffects=} owner Owner of the template instances;
       *   any optional callbacks will be bound to this owner.
       * @param {Object=} options Options dictionary (see summary for details)
       * @return {function(new:TemplateInstanceBase)} Generated class bound to the template
       *   provided
       * @suppress {invalidCasts}
       */
      templatize(template, owner, options) {
        // Under strictTemplatePolicy, the templatized element must be owned
        // by a (trusted) Polymer element, indicated by existence of _methodHost;
        // e.g. for dom-if & dom-repeat in main document, _methodHost is null
        if (Polymer.strictTemplatePolicy && !findMethodHost(template)) {
          throw new Error('strictTemplatePolicy: template owner not trusted');
        }
        options = /** @type {!TemplatizeOptions} */(options || {});
        if (template.__templatizeOwner) {
          throw new Error('A <template> can only be templatized once');
        }
        template.__templatizeOwner = owner;
        const ctor = owner ? owner.constructor : TemplateInstanceBase;
        let templateInfo = ctor._parseTemplate(template);
        // Get memoized base class for the prototypical template, which
        // includes property effects for binding template & forwarding
        let baseClass = templateInfo.templatizeInstanceClass;
        if (!baseClass) {
          baseClass = createTemplatizerClass(template, templateInfo, options);
          templateInfo.templatizeInstanceClass = baseClass;
        }
        // Host property forwarding must be installed onto template instance
        addPropagateEffects(template, templateInfo, options);
        // Subclass base class and add reference for this specific template
        /** @private */
        let klass = class TemplateInstance extends baseClass {};
        klass.prototype._methodHost = findMethodHost(template);
        klass.prototype.__dataHost = template;
        klass.prototype.__templatizeOwner = owner;
        klass.prototype.__hostProps = templateInfo.hostProps;
        klass = /** @type {function(new:TemplateInstanceBase)} */(klass); //eslint-disable-line no-self-assign
        return klass;
      },

      /**
       * Returns the template "model" associated with a given element, which
       * serves as the binding scope for the template instance the element is
       * contained in. A template model is an instance of
       * `TemplateInstanceBase`, and should be used to manipulate data
       * associated with this template instance.
       *
       * Example:
       *
       *   let model = modelForElement(el);
       *   if (model.index < 10) {
       *     model.set('item.checked', true);
       *   }
       *
       * @memberof Polymer.Templatize
       * @param {HTMLTemplateElement} template The model will be returned for
       *   elements stamped from this template
       * @param {Node=} node Node for which to return a template model.
       * @return {TemplateInstanceBase} Template instance representing the
       *   binding scope for the element
       */
      modelForElement(template, node) {
        let model;
        while (node) {
          // An element with a __templatizeInstance marks the top boundary
          // of a scope; walk up until we find one, and then ensure that
          // its __dataHost matches `this`, meaning this dom-repeat stamped it
          if ((model = node.__templatizeInstance)) {
            // Found an element stamped by another template; keep walking up
            // from its __dataHost
            if (model.__dataHost != template) {
              node = model.__dataHost;
            } else {
              return model;
            }
          } else {
            // Still in a template scope, keep going up until
            // a __templatizeInstance is found
            node = node.parentNode;
          }
        }
        return null;
      }
    };

    Polymer.TemplateInstanceBase = TemplateInstanceBase;

  })();



  (function() {
    'use strict';

    let TemplateInstanceBase = Polymer.TemplateInstanceBase; // eslint-disable-line

    /**
     * @typedef {{
     *   _templatizerTemplate: HTMLTemplateElement,
     *   _parentModel: boolean,
     *   _instanceProps: Object,
     *   _forwardHostPropV2: Function,
     *   _notifyInstancePropV2: Function,
     *   ctor: TemplateInstanceBase
     * }}
     */
    let TemplatizerUser; // eslint-disable-line

    /**
     * The `Polymer.Templatizer` behavior adds methods to generate instances of
     * templates that are each managed by an anonymous `Polymer.PropertyEffects`
     * instance where data-bindings in the stamped template content are bound to
     * accessors on itself.
     *
     * This behavior is provided in Polymer 2.x as a hybrid-element convenience
     * only.  For non-hybrid usage, the `Polymer.Templatize` library
     * should be used instead.
     *
     * Example:
     *
     *     // Get a template from somewhere, e.g. light DOM
     *     let template = this.querySelector('template');
     *     // Prepare the template
     *     this.templatize(template);
     *     // Instance the template with an initial data model
     *     let instance = this.stamp({myProp: 'initial'});
     *     // Insert the instance's DOM somewhere, e.g. light DOM
     *     Polymer.dom(this).appendChild(instance.root);
     *     // Changing a property on the instance will propagate to bindings
     *     // in the template
     *     instance.myProp = 'new value';
     *
     * Users of `Templatizer` may need to implement the following abstract
     * API's to determine how properties and paths from the host should be
     * forwarded into to instances:
     *
     *     _forwardHostPropV2: function(prop, value)
     *
     * Likewise, users may implement these additional abstract API's to determine
     * how instance-specific properties that change on the instance should be
     * forwarded out to the host, if necessary.
     *
     *     _notifyInstancePropV2: function(inst, prop, value)
     *
     * In order to determine which properties are instance-specific and require
     * custom notification via `_notifyInstanceProp`, define an `_instanceProps`
     * object containing keys for each instance prop, for example:
     *
     *     _instanceProps: {
     *       item: true,
     *       index: true
     *     }
     *
     * Any properties used in the template that are not defined in _instanceProp
     * will be forwarded out to the Templatize `owner` automatically.
     *
     * Users may also implement the following abstract function to show or
     * hide any DOM generated using `stamp`:
     *
     *     _showHideChildren: function(shouldHide)
     *
     * Note that some callbacks are suffixed with `V2` in the Polymer 2.x behavior
     * as the implementations will need to differ from the callbacks required
     * by the 1.x Templatizer API due to changes in the `TemplateInstance` API
     * between versions 1.x and 2.x.
     *
     * @polymerBehavior
     */
    Polymer.Templatizer = {

      /**
       * Generates an anonymous `TemplateInstance` class (stored as `this.ctor`)
       * for the provided template.  This method should be called once per
       * template to prepare an element for stamping the template, followed
       * by `stamp` to create new instances of the template.
       *
       * @param {!HTMLTemplateElement} template Template to prepare
       * @param {boolean=} mutableData When `true`, the generated class will skip
       *   strict dirty-checking for objects and arrays (always consider them to
       *   be "dirty"). Defaults to false.
       * @return {void}
       * @this {TemplatizerUser}
       */
      templatize(template, mutableData) {
        this._templatizerTemplate = template;
        this.ctor = Polymer.Templatize.templatize(template, this, {
          mutableData: Boolean(mutableData),
          parentModel: this._parentModel,
          instanceProps: this._instanceProps,
          forwardHostProp: this._forwardHostPropV2,
          notifyInstanceProp: this._notifyInstancePropV2
        });
      },

      /**
       * Creates an instance of the template prepared by `templatize`.  The object
       * returned is an instance of the anonymous class generated by `templatize`
       * whose `root` property is a document fragment containing newly cloned
       * template content, and which has property accessors corresponding to
       * properties referenced in template bindings.
       *
       * @param {Object=} model Object containing initial property values to
       *   populate into the template bindings.
       * @return {TemplateInstanceBase} Returns the created instance of
       * the template prepared by `templatize`.
       * @this {TemplatizerUser}
       */
      stamp(model) {
        return new this.ctor(model);
      },

      /**
       * Returns the template "model" (`TemplateInstance`) associated with
       * a given element, which serves as the binding scope for the template
       * instance the element is contained in.  A template model should be used
       * to manipulate data associated with this template instance.
       *
       * @param {HTMLElement} el Element for which to return a template model.
       * @return {TemplateInstanceBase} Model representing the binding scope for
       *   the element.
       * @this {TemplatizerUser}
       */
      modelForElement(el) {
        return Polymer.Templatize.modelForElement(this._templatizerTemplate, el);
      }
    };

  })();



  (function() {
    'use strict';

    /**
     * @constructor
     * @extends {HTMLElement}
     * @implements {Polymer_PropertyEffects}
     * @implements {Polymer_OptionalMutableData}
     * @implements {Polymer_GestureEventListeners}
     * @private
     */
    const domBindBase =
      Polymer.GestureEventListeners(
        Polymer.OptionalMutableData(
          Polymer.PropertyEffects(HTMLElement)));

    /**
     * Custom element to allow using Polymer's template features (data binding,
     * declarative event listeners, etc.) in the main document without defining
     * a new custom element.
     *
     * `<template>` tags utilizing bindings may be wrapped with the `<dom-bind>`
     * element, which will immediately stamp the wrapped template into the main
     * document and bind elements to the `dom-bind` element itself as the
     * binding scope.
     *
     * @polymer
     * @customElement
     * @appliesMixin Polymer.PropertyEffects
     * @appliesMixin Polymer.OptionalMutableData
     * @appliesMixin Polymer.GestureEventListeners
     * @extends {domBindBase}
     * @memberof Polymer
     * @summary Custom element to allow using Polymer's template features (data
     *   binding, declarative event listeners, etc.) in the main document.
     */
    class DomBind extends domBindBase {

      static get observedAttributes() { return ['mutable-data']; }

      constructor() {
        super();
        if (Polymer.strictTemplatePolicy) {
          throw new Error(`strictTemplatePolicy: dom-bind not allowed`);
        }
        this.root = null;
        this.$ = null;
        this.__children = null;
      }

      /** @return {void} */
      attributeChangedCallback() {
        // assumes only one observed attribute
        this.mutableData = true;
      }

      /** @return {void} */
      connectedCallback() {
        this.style.display = 'none';
        this.render();
      }

      /** @return {void} */
      disconnectedCallback() {
        this.__removeChildren();
      }

      __insertChildren() {
        this.parentNode.insertBefore(this.root, this);
      }

      __removeChildren() {
        if (this.__children) {
          for (let i=0; i<this.__children.length; i++) {
            this.root.appendChild(this.__children[i]);
          }
        }
      }

      /**
       * Forces the element to render its content. This is typically only
       * necessary to call if HTMLImports with the async attribute are used.
       * @return {void}
       */
      render() {
        let template;
        if (!this.__children) {
          template = /** @type {HTMLTemplateElement} */(template || this.querySelector('template'));
          if (!template) {
            // Wait until childList changes and template should be there by then
            let observer = new MutationObserver(() => {
              template = /** @type {HTMLTemplateElement} */(this.querySelector('template'));
              if (template) {
                observer.disconnect();
                this.render();
              } else {
                throw new Error('dom-bind requires a <template> child');
              }
            });
            observer.observe(this, {childList: true});
            return;
          }
          this.root = this._stampTemplate(template);
          this.$ = this.root.$;
          this.__children = [];
          for (let n=this.root.firstChild; n; n=n.nextSibling) {
            this.__children[this.__children.length] = n;
          }
          this._enableProperties();
        }
        this.__insertChildren();
        this.dispatchEvent(new CustomEvent('dom-change', {
          bubbles: true,
          composed: true
        }));
      }

    }

    customElements.define('dom-bind', DomBind);

    /** @const */
    Polymer.DomBind = DomBind;

  })();



  (function() {
    'use strict';

    /**
     * Class representing a static string value which can be used to filter
     * strings by asseting that they have been created via this class. The
     * `value` property returns the string passed to the constructor.
     */
    class LiteralString {
      constructor(string) {
        /** @type {string} */
        this.value = string.toString();
      }
      /**
       * @return {string} LiteralString string value
       */
      toString() {
        return this.value;
      }
    }

    /**
     * @param {*} value Object to stringify into HTML
     * @return {string} HTML stringified form of `obj`
     */
    function literalValue(value) {
      if (value instanceof LiteralString) {
        return /** @type {!LiteralString} */(value).value;
      } else {
        throw new Error(`non-literal value passed to Polymer.htmlLiteral: ${value}`);
      }
    }

    /**
     * @param {*} value Object to stringify into HTML
     * @return {string} HTML stringified form of `obj`
     */
    function htmlValue(value) {
      if (value instanceof HTMLTemplateElement) {
        return /** @type {!HTMLTemplateElement } */(value).innerHTML;
      } else if (value instanceof LiteralString) {
        return literalValue(value);
      } else {
        throw new Error(`non-template value passed to Polymer.html: ${value}`);
      }
    }

    /**
     * A template literal tag that creates an HTML <template> element from the
     * contents of the string.
     *
     * This allows you to write a Polymer Template in JavaScript.
     *
     * Templates can be composed by interpolating `HTMLTemplateElement`s in
     * expressions in the JavaScript template literal. The nested template's
     * `innerHTML` is included in the containing template.  The only other
     * values allowed in expressions are those returned from `Polymer.htmlLiteral`
     * which ensures only literal values from JS source ever reach the HTML, to
     * guard against XSS risks.
     *
     * All other values are disallowed in expressions to help prevent XSS
     * attacks; however, `Polymer.htmlLiteral` can be used to compose static
     * string values into templates. This is useful to compose strings into
     * places that do not accept html, like the css text of a `style`
     * element.
     *
     * Example:
     *
     *     static get template() {
     *       return Polymer.html`
     *         <style>:host{ content:"..." }</style>
     *         <div class="shadowed">${this.partialTemplate}</div>
     *         ${super.template}
     *       `;
     *     }
     *     static get partialTemplate() { return Polymer.html`<span>Partial!</span>`; }
     *
     * @memberof Polymer
     * @param {!ITemplateArray} strings Constant parts of tagged template literal
     * @param {...*} values Variable parts of tagged template literal
     * @return {!HTMLTemplateElement} Constructed HTMLTemplateElement
     */
    Polymer.html = function html(strings, ...values) {
      const template = /** @type {!HTMLTemplateElement} */(document.createElement('template'));
      template.innerHTML = values.reduce((acc, v, idx) =>
          acc + htmlValue(v) + strings[idx + 1], strings[0]);
      return template;
    };

    /**
     * An html literal tag that can be used with `Polymer.html` to compose.
     * a literal string.
     *
     * Example:
     *
     *     static get template() {
     *       return Polymer.html`
     *         <style>
     *           :host { display: block; }
     *           ${styleTemplate}
     *         </style>
     *         <div class="shadowed">${staticValue}</div>
     *         ${super.template}
     *       `;
     *     }
     *     static get styleTemplate() { return Polymer.htmlLiteral`.shadowed { background: gray; }`; }
     *
     * @memberof Polymer
     * @param {!ITemplateArray} strings Constant parts of tagged template literal
     * @param {...*} values Variable parts of tagged template literal
     * @return {!LiteralString} Constructed literal string
     */
    Polymer.htmlLiteral = function(strings, ...values) {
      return new LiteralString(values.reduce((acc, v, idx) =>
          acc + literalValue(v) + strings[idx + 1], strings[0]));
    };
  })();


(function() {
  'use strict';

  /**
   * Base class that provides the core API for Polymer's meta-programming
   * features including template stamping, data-binding, attribute deserialization,
   * and property change observation.
   *
   * @customElement
   * @memberof Polymer
   * @constructor
   * @implements {Polymer_ElementMixin}
   * @extends {HTMLElement}
   * @appliesMixin Polymer.ElementMixin
   * @summary Custom element base class that provides the core API for Polymer's
   *   key meta-programming features including template stamping, data-binding,
   *   attribute deserialization, and property change observation
   */
  Polymer.Element = Polymer.ElementMixin(HTMLElement);

  // NOTE: this is here for modulizer to export `html` for the module version of this file
  Polymer.html = Polymer.html;
})();


(function() {
  'use strict';

  let TemplateInstanceBase = Polymer.TemplateInstanceBase; // eslint-disable-line

  /**
   * @constructor
   * @implements {Polymer_OptionalMutableData}
   * @extends {Polymer.Element}
   * @private
   */
  const domRepeatBase = Polymer.OptionalMutableData(Polymer.Element);

  /**
   * The `<dom-repeat>` element will automatically stamp and binds one instance
   * of template content to each object in a user-provided array.
   * `dom-repeat` accepts an `items` property, and one instance of the template
   * is stamped for each item into the DOM at the location of the `dom-repeat`
   * element.  The `item` property will be set on each instance's binding
   * scope, thus templates should bind to sub-properties of `item`.
   *
   * Example:
   *
   * ```html
   * <dom-module id="employee-list">
   *
   *   <template>
   *
   *     <div> Employee list: </div>
   *     <dom-repeat items="{{employees}}">
   *       <template>
   *         <div>First name: <span>{{item.first}}</span></div>
   *         <div>Last name: <span>{{item.last}}</span></div>
   *       </template>
   *     </dom-repeat>
   *
   *   </template>
   *
   * </dom-module>
   * ```
   *
   * With the following custom element definition:
   *
   * ```js
   * class EmployeeList extends Polymer.Element {
   *   static get is() { return 'employee-list'; }
   *   static get properties() {
   *     return {
   *       employees: {
   *         value() {
   *           return [
   *             {first: 'Bob', last: 'Smith'},
   *             {first: 'Sally', last: 'Johnson'},
   *             ...
   *           ];
   *         }
   *       }
   *     };
   *   }
   * }
   * ```
   *
   * Notifications for changes to items sub-properties will be forwarded to template
   * instances, which will update via the normal structured data notification system.
   *
   * Mutations to the `items` array itself should be made using the Array
   * mutation API's on `Polymer.Base` (`push`, `pop`, `splice`, `shift`,
   * `unshift`), and template instances will be kept in sync with the data in the
   * array.
   *
   * Events caught by event handlers within the `dom-repeat` template will be
   * decorated with a `model` property, which represents the binding scope for
   * each template instance.  The model is an instance of Polymer.Base, and should
   * be used to manipulate data on the instance, for example
   * `event.model.set('item.checked', true);`.
   *
   * Alternatively, the model for a template instance for an element stamped by
   * a `dom-repeat` can be obtained using the `modelForElement` API on the
   * `dom-repeat` that stamped it, for example
   * `this.$.domRepeat.modelForElement(event.target).set('item.checked', true);`.
   * This may be useful for manipulating instance data of event targets obtained
   * by event handlers on parents of the `dom-repeat` (event delegation).
   *
   * A view-specific filter/sort may be applied to each `dom-repeat` by supplying a
   * `filter` and/or `sort` property.  This may be a string that names a function on
   * the host, or a function may be assigned to the property directly.  The functions
   * should implemented following the standard `Array` filter/sort API.
   *
   * In order to re-run the filter or sort functions based on changes to sub-fields
   * of `items`, the `observe` property may be set as a space-separated list of
   * `item` sub-fields that should cause a re-filter/sort when modified.  If
   * the filter or sort function depends on properties not contained in `items`,
   * the user should observe changes to those properties and call `render` to update
   * the view based on the dependency change.
   *
   * For example, for an `dom-repeat` with a filter of the following:
   *
   * ```js
   * isEngineer(item) {
   *   return item.type == 'engineer' || item.manager.type == 'engineer';
   * }
   * ```
   *
   * Then the `observe` property should be configured as follows:
   *
   * ```html
   * <dom-repeat items="{{employees}}" filter="isEngineer" observe="type manager.type">
   * ```
   *
   * @customElement
   * @polymer
   * @memberof Polymer
   * @extends {domRepeatBase}
   * @appliesMixin Polymer.OptionalMutableData
   * @summary Custom element for stamping instance of a template bound to
   *   items in an array.
   */
  class DomRepeat extends domRepeatBase {

    // Not needed to find template; can be removed once the analyzer
    // can find the tag name from customElements.define call
    static get is() { return 'dom-repeat'; }

    static get template() { return null; }

    static get properties() {

      /**
       * Fired whenever DOM is added or removed by this template (by
       * default, rendering occurs lazily).  To force immediate rendering, call
       * `render`.
       *
       * @event dom-change
       */
      return {

        /**
         * An array containing items determining how many instances of the template
         * to stamp and that that each template instance should bind to.
         */
        items: {
          type: Array
        },

        /**
         * The name of the variable to add to the binding scope for the array
         * element associated with a given template instance.
         */
        as: {
          type: String,
          value: 'item'
        },

        /**
         * The name of the variable to add to the binding scope with the index
         * of the instance in the sorted and filtered list of rendered items.
         * Note, for the index in the `this.items` array, use the value of the
         * `itemsIndexAs` property.
         */
        indexAs: {
          type: String,
          value: 'index'
        },

        /**
         * The name of the variable to add to the binding scope with the index
         * of the instance in the `this.items` array. Note, for the index of
         * this instance in the sorted and filtered list of rendered items,
         * use the value of the `indexAs` property.
         */
        itemsIndexAs: {
          type: String,
          value: 'itemsIndex'
        },

        /**
         * A function that should determine the sort order of the items.  This
         * property should either be provided as a string, indicating a method
         * name on the element's host, or else be an actual function.  The
         * function should match the sort function passed to `Array.sort`.
         * Using a sort function has no effect on the underlying `items` array.
         */
        sort: {
          type: Function,
          observer: '__sortChanged'
        },

        /**
         * A function that can be used to filter items out of the view.  This
         * property should either be provided as a string, indicating a method
         * name on the element's host, or else be an actual function.  The
         * function should match the sort function passed to `Array.filter`.
         * Using a filter function has no effect on the underlying `items` array.
         */
        filter: {
          type: Function,
          observer: '__filterChanged'
        },

        /**
         * When using a `filter` or `sort` function, the `observe` property
         * should be set to a space-separated list of the names of item
         * sub-fields that should trigger a re-sort or re-filter when changed.
         * These should generally be fields of `item` that the sort or filter
         * function depends on.
         */
        observe: {
          type: String,
          observer: '__observeChanged'
        },

        /**
         * When using a `filter` or `sort` function, the `delay` property
         * determines a debounce time in ms after a change to observed item
         * properties that must pass before the filter or sort is re-run.
         * This is useful in rate-limiting shuffling of the view when
         * item changes may be frequent.
         */
        delay: Number,

        /**
         * Count of currently rendered items after `filter` (if any) has been applied.
         * If "chunking mode" is enabled, `renderedItemCount` is updated each time a
         * set of template instances is rendered.
         *
         */
        renderedItemCount: {
          type: Number,
          notify: true,
          readOnly: true
        },

        /**
         * Defines an initial count of template instances to render after setting
         * the `items` array, before the next paint, and puts the `dom-repeat`
         * into "chunking mode".  The remaining items will be created and rendered
         * incrementally at each animation frame therof until all instances have
         * been rendered.
         */
        initialCount: {
          type: Number,
          observer: '__initializeChunking'
        },

        /**
         * When `initialCount` is used, this property defines a frame rate (in
         * fps) to target by throttling the number of instances rendered each
         * frame to not exceed the budget for the target frame rate.  The
         * framerate is effectively the number of `requestAnimationFrame`s that
         * it tries to allow to actually fire in a given second. It does this
         * by measuring the time between `rAF`s and continuously adjusting the
         * number of items created each `rAF` to maintain the target framerate.
         * Setting this to a higher number allows lower latency and higher
         * throughput for event handlers and other tasks, but results in a
         * longer time for the remaining items to complete rendering.
         */
        targetFramerate: {
          type: Number,
          value: 20
        },

        _targetFrameTime: {
          type: Number,
          computed: '__computeFrameTime(targetFramerate)'
        }

      };

    }

    static get observers() {
      return [ '__itemsChanged(items.*)' ];
    }

    constructor() {
      super();
      this.__instances = [];
      this.__limit = Infinity;
      this.__pool = [];
      this.__renderDebouncer = null;
      this.__itemsIdxToInstIdx = {};
      this.__chunkCount = null;
      this.__lastChunkTime = null;
      this.__sortFn = null;
      this.__filterFn = null;
      this.__observePaths = null;
      this.__ctor = null;
      this.__isDetached = true;
      this.template = null;
    }

    /**
     * @return {void}
     */
    disconnectedCallback() {
      super.disconnectedCallback();
      this.__isDetached = true;
      for (let i=0; i<this.__instances.length; i++) {
        this.__detachInstance(i);
      }
    }

    /**
     * @return {void}
     */
    connectedCallback() {
      super.connectedCallback();
      this.style.display = 'none';
      // only perform attachment if the element was previously detached.
      if (this.__isDetached) {
        this.__isDetached = false;
        let parent = this.parentNode;
        for (let i=0; i<this.__instances.length; i++) {
          this.__attachInstance(i, parent);
        }
      }
    }

    __ensureTemplatized() {
      // Templatizing (generating the instance constructor) needs to wait
      // until ready, since won't have its template content handed back to
      // it until then
      if (!this.__ctor) {
        let template = this.template = /** @type {HTMLTemplateElement} */(this.querySelector('template'));
        if (!template) {
          // // Wait until childList changes and template should be there by then
          let observer = new MutationObserver(() => {
            if (this.querySelector('template')) {
              observer.disconnect();
              this.__render();
            } else {
              throw new Error('dom-repeat requires a <template> child');
            }
          });
          observer.observe(this, {childList: true});
          return false;
        }
        // Template instance props that should be excluded from forwarding
        let instanceProps = {};
        instanceProps[this.as] = true;
        instanceProps[this.indexAs] = true;
        instanceProps[this.itemsIndexAs] = true;
        this.__ctor = Polymer.Templatize.templatize(template, this, {
          mutableData: this.mutableData,
          parentModel: true,
          instanceProps: instanceProps,
          /**
           * @this {this}
           * @param {string} prop Property to set
           * @param {*} value Value to set property to
           */
          forwardHostProp: function(prop, value) {
            let i$ = this.__instances;
            for (let i=0, inst; (i<i$.length) && (inst=i$[i]); i++) {
              inst.forwardHostProp(prop, value);
            }
          },
          /**
           * @this {this}
           * @param {Object} inst Instance to notify
           * @param {string} prop Property to notify
           * @param {*} value Value to notify
           */
          notifyInstanceProp: function(inst, prop, value) {
            if (Polymer.Path.matches(this.as, prop)) {
              let idx = inst[this.itemsIndexAs];
              if (prop == this.as) {
                this.items[idx] = value;
              }
              let path = Polymer.Path.translate(this.as, 'items.' + idx, prop);
              this.notifyPath(path, value);
            }
          }
        });
      }
      return true;
    }

    __getMethodHost() {
      // Technically this should be the owner of the outermost template.
      // In shadow dom, this is always getRootNode().host, but we can
      // approximate this via cooperation with our dataHost always setting
      // `_methodHost` as long as there were bindings (or id's) on this
      // instance causing it to get a dataHost.
      return this.__dataHost._methodHost || this.__dataHost;
    }

    __functionFromPropertyValue(functionOrMethodName) {
      if (typeof functionOrMethodName === 'string') {
        let methodName = functionOrMethodName;
        let obj = this.__getMethodHost();
        return function() { return obj[methodName].apply(obj, arguments); };
      }

      return functionOrMethodName;
    }

    __sortChanged(sort) {
      this.__sortFn = this.__functionFromPropertyValue(sort);
      if (this.items) { this.__debounceRender(this.__render); }
    }

    __filterChanged(filter) {
      this.__filterFn = this.__functionFromPropertyValue(filter);
      if (this.items) { this.__debounceRender(this.__render); }
    }

    __computeFrameTime(rate) {
      return Math.ceil(1000/rate);
    }

    __initializeChunking() {
      if (this.initialCount) {
        this.__limit = this.initialCount;
        this.__chunkCount = this.initialCount;
        this.__lastChunkTime = performance.now();
      }
    }

    __tryRenderChunk() {
      // Debounced so that multiple calls through `_render` between animation
      // frames only queue one new rAF (e.g. array mutation & chunked render)
      if (this.items && this.__limit < this.items.length) {
        this.__debounceRender(this.__requestRenderChunk);
      }
    }

    __requestRenderChunk() {
      requestAnimationFrame(()=>this.__renderChunk());
    }

    __renderChunk() {
      // Simple auto chunkSize throttling algorithm based on feedback loop:
      // measure actual time between frames and scale chunk count by ratio
      // of target/actual frame time
      let currChunkTime = performance.now();
      let ratio = this._targetFrameTime / (currChunkTime - this.__lastChunkTime);
      this.__chunkCount = Math.round(this.__chunkCount * ratio) || 1;
      this.__limit += this.__chunkCount;
      this.__lastChunkTime = currChunkTime;
      this.__debounceRender(this.__render);
    }

    __observeChanged() {
      this.__observePaths = this.observe &&
        this.observe.replace('.*', '.').split(' ');
    }

    __itemsChanged(change) {
      if (this.items && !Array.isArray(this.items)) {
        console.warn('dom-repeat expected array for `items`, found', this.items);
      }
      // If path was to an item (e.g. 'items.3' or 'items.3.foo'), forward the
      // path to that instance synchronously (returns false for non-item paths)
      if (!this.__handleItemPath(change.path, change.value)) {
        // Otherwise, the array was reset ('items') or spliced ('items.splices'),
        // so queue a full refresh
        this.__initializeChunking();
        this.__debounceRender(this.__render);
      }
    }

    __handleObservedPaths(path) {
      // Handle cases where path changes should cause a re-sort/filter
      if (this.__sortFn || this.__filterFn) {
        if (!path) {
          // Always re-render if the item itself changed
          this.__debounceRender(this.__render, this.delay);
        } else if (this.__observePaths) {
          // Otherwise, re-render if the path changed matches an observed path
          let paths = this.__observePaths;
          for (let i=0; i<paths.length; i++) {
            if (path.indexOf(paths[i]) === 0) {
              this.__debounceRender(this.__render, this.delay);
            }
          }
        }
      }
    }

    /**
     * @param {function(this:DomRepeat)} fn Function to debounce.
     * @param {number=} delay Delay in ms to debounce by.
     */
    __debounceRender(fn, delay = 0) {
      this.__renderDebouncer = Polymer.Debouncer.debounce(
            this.__renderDebouncer
          , delay > 0 ? Polymer.Async.timeOut.after(delay) : Polymer.Async.microTask
          , fn.bind(this));
      Polymer.enqueueDebouncer(this.__renderDebouncer);
    }

    /**
     * Forces the element to render its content. Normally rendering is
     * asynchronous to a provoking change. This is done for efficiency so
     * that multiple changes trigger only a single render. The render method
     * should be called if, for example, template rendering is required to
     * validate application state.
     * @return {void}
     */
    render() {
      // Queue this repeater, then flush all in order
      this.__debounceRender(this.__render);
      Polymer.flush();
    }

    __render() {
      if (!this.__ensureTemplatized()) {
        // No template found yet
        return;
      }
      this.__applyFullRefresh();
      // Reset the pool
      // TODO(kschaaf): Reuse pool across turns and nested templates
      // Now that objects/arrays are re-evaluated when set, we can safely
      // reuse pooled instances across turns, however we still need to decide
      // semantics regarding how long to hold, how many to hold, etc.
      this.__pool.length = 0;
      // Set rendered item count
      this._setRenderedItemCount(this.__instances.length);
      // Notify users
      this.dispatchEvent(new CustomEvent('dom-change', {
        bubbles: true,
        composed: true
      }));
      // Check to see if we need to render more items
      this.__tryRenderChunk();
    }

    __applyFullRefresh() {
      let items = this.items || [];
      let isntIdxToItemsIdx = new Array(items.length);
      for (let i=0; i<items.length; i++) {
        isntIdxToItemsIdx[i] = i;
      }
      // Apply user filter
      if (this.__filterFn) {
        isntIdxToItemsIdx = isntIdxToItemsIdx.filter((i, idx, array) =>
          this.__filterFn(items[i], idx, array));
      }
      // Apply user sort
      if (this.__sortFn) {
        isntIdxToItemsIdx.sort((a, b) => this.__sortFn(items[a], items[b]));
      }
      // items->inst map kept for item path forwarding
      const itemsIdxToInstIdx = this.__itemsIdxToInstIdx = {};
      let instIdx = 0;
      // Generate instances and assign items
      const limit = Math.min(isntIdxToItemsIdx.length, this.__limit);
      for (; instIdx<limit; instIdx++) {
        let inst = this.__instances[instIdx];
        let itemIdx = isntIdxToItemsIdx[instIdx];
        let item = items[itemIdx];
        itemsIdxToInstIdx[itemIdx] = instIdx;
        if (inst) {
          inst._setPendingProperty(this.as, item);
          inst._setPendingProperty(this.indexAs, instIdx);
          inst._setPendingProperty(this.itemsIndexAs, itemIdx);
          inst._flushProperties();
        } else {
          this.__insertInstance(item, instIdx, itemIdx);
        }
      }
      // Remove any extra instances from previous state
      for (let i=this.__instances.length-1; i>=instIdx; i--) {
        this.__detachAndRemoveInstance(i);
      }
    }

    __detachInstance(idx) {
      let inst = this.__instances[idx];
      for (let i=0; i<inst.children.length; i++) {
        let el = inst.children[i];
        inst.root.appendChild(el);
      }
      return inst;
    }

    __attachInstance(idx, parent) {
      let inst = this.__instances[idx];
      parent.insertBefore(inst.root, this);
    }

    __detachAndRemoveInstance(idx) {
      let inst = this.__detachInstance(idx);
      if (inst) {
        this.__pool.push(inst);
      }
      this.__instances.splice(idx, 1);
    }

    __stampInstance(item, instIdx, itemIdx) {
      let model = {};
      model[this.as] = item;
      model[this.indexAs] = instIdx;
      model[this.itemsIndexAs] = itemIdx;
      return new this.__ctor(model);
    }

    __insertInstance(item, instIdx, itemIdx) {
      let inst = this.__pool.pop();
      if (inst) {
        // TODO(kschaaf): If the pool is shared across turns, hostProps
        // need to be re-set to reused instances in addition to item
        inst._setPendingProperty(this.as, item);
        inst._setPendingProperty(this.indexAs, instIdx);
        inst._setPendingProperty(this.itemsIndexAs, itemIdx);
        inst._flushProperties();
      } else {
        inst = this.__stampInstance(item, instIdx, itemIdx);
      }
      let beforeRow = this.__instances[instIdx + 1];
      let beforeNode = beforeRow ? beforeRow.children[0] : this;
      this.parentNode.insertBefore(inst.root, beforeNode);
      this.__instances[instIdx] = inst;
      return inst;
    }

    // Implements extension point from Templatize mixin
    /**
     * Shows or hides the template instance top level child elements. For
     * text nodes, `textContent` is removed while "hidden" and replaced when
     * "shown."
     * @param {boolean} hidden Set to true to hide the children;
     * set to false to show them.
     * @return {void}
     * @protected
     */
    _showHideChildren(hidden) {
      for (let i=0; i<this.__instances.length; i++) {
        this.__instances[i]._showHideChildren(hidden);
      }
    }

    // Called as a side effect of a host items.<key>.<path> path change,
    // responsible for notifying item.<path> changes to inst for key
    __handleItemPath(path, value) {
      let itemsPath = path.slice(6); // 'items.'.length == 6
      let dot = itemsPath.indexOf('.');
      let itemsIdx = dot < 0 ? itemsPath : itemsPath.substring(0, dot);
      // If path was index into array...
      if (itemsIdx == parseInt(itemsIdx, 10)) {
        let itemSubPath = dot < 0 ? '' : itemsPath.substring(dot+1);
        // If the path is observed, it will trigger a full refresh
        this.__handleObservedPaths(itemSubPath);
        // Note, even if a rull refresh is triggered, always do the path
        // notification because unless mutableData is used for dom-repeat
        // and all elements in the instance subtree, a full refresh may
        // not trigger the proper update.
        let instIdx = this.__itemsIdxToInstIdx[itemsIdx];
        let inst = this.__instances[instIdx];
        if (inst) {
          let itemPath = this.as + (itemSubPath ? '.' + itemSubPath : '');
          // This is effectively `notifyPath`, but avoids some of the overhead
          // of the public API
          inst._setPendingPropertyOrPath(itemPath, value, false, true);
          inst._flushProperties();
        }
        return true;
      }
    }

    /**
     * Returns the item associated with a given element stamped by
     * this `dom-repeat`.
     *
     * Note, to modify sub-properties of the item,
     * `modelForElement(el).set('item.<sub-prop>', value)`
     * should be used.
     *
     * @param {!HTMLElement} el Element for which to return the item.
     * @return {*} Item associated with the element.
     */
    itemForElement(el) {
      let instance = this.modelForElement(el);
      return instance && instance[this.as];
    }

    /**
     * Returns the inst index for a given element stamped by this `dom-repeat`.
     * If `sort` is provided, the index will reflect the sorted order (rather
     * than the original array order).
     *
     * @param {!HTMLElement} el Element for which to return the index.
     * @return {?number} Row index associated with the element (note this may
     *   not correspond to the array index if a user `sort` is applied).
     */
    indexForElement(el) {
      let instance = this.modelForElement(el);
      return instance && instance[this.indexAs];
    }

    /**
     * Returns the template "model" associated with a given element, which
     * serves as the binding scope for the template instance the element is
     * contained in. A template model is an instance of `Polymer.Base`, and
     * should be used to manipulate data associated with this template instance.
     *
     * Example:
     *
     *   let model = modelForElement(el);
     *   if (model.index < 10) {
     *     model.set('item.checked', true);
     *   }
     *
     * @param {!HTMLElement} el Element for which to return a template model.
     * @return {TemplateInstanceBase} Model representing the binding scope for
     *   the element.
     */
    modelForElement(el) {
      return Polymer.Templatize.modelForElement(this.template, el);
    }

  }

  customElements.define(DomRepeat.is, DomRepeat);

  /** @const */
  Polymer.DomRepeat = DomRepeat;

})();




(function() {
  'use strict';

  /**
   * The `<dom-if>` element will stamp a light-dom `<template>` child when
   * the `if` property becomes truthy, and the template can use Polymer
   * data-binding and declarative event features when used in the context of
   * a Polymer element's template.
   *
   * When `if` becomes falsy, the stamped content is hidden but not
   * removed from dom. When `if` subsequently becomes truthy again, the content
   * is simply re-shown. This approach is used due to its favorable performance
   * characteristics: the expense of creating template content is paid only
   * once and lazily.
   *
   * Set the `restamp` property to true to force the stamped content to be
   * created / destroyed when the `if` condition changes.
   *
   * @customElement
   * @polymer
   * @extends Polymer.Element
   * @memberof Polymer
   * @summary Custom element that conditionally stamps and hides or removes
   *   template content based on a boolean flag.
   */
  class DomIf extends Polymer.Element {

    // Not needed to find template; can be removed once the analyzer
    // can find the tag name from customElements.define call
    static get is() { return 'dom-if'; }

    static get template() { return null; }

    static get properties() {

      return {

        /**
         * Fired whenever DOM is added or removed/hidden by this template (by
         * default, rendering occurs lazily).  To force immediate rendering, call
         * `render`.
         *
         * @event dom-change
         */

        /**
         * A boolean indicating whether this template should stamp.
         */
        if: {
          type: Boolean,
          observer: '__debounceRender'
        },

        /**
         * When true, elements will be removed from DOM and discarded when `if`
         * becomes false and re-created and added back to the DOM when `if`
         * becomes true.  By default, stamped elements will be hidden but left
         * in the DOM when `if` becomes false, which is generally results
         * in better performance.
         */
        restamp: {
          type: Boolean,
          observer: '__debounceRender'
        }

      };

    }

    constructor() {
      super();
      this.__renderDebouncer = null;
      this.__invalidProps = null;
      this.__instance = null;
      this._lastIf = false;
      this.__ctor = null;
    }

    __debounceRender() {
      // Render is async for 2 reasons:
      // 1. To eliminate dom creation trashing if user code thrashes `if` in the
      //    same turn. This was more common in 1.x where a compound computed
      //    property could result in the result changing multiple times, but is
      //    mitigated to a large extent by batched property processing in 2.x.
      // 2. To avoid double object propagation when a bag including values bound
      //    to the `if` property as well as one or more hostProps could enqueue
      //    the <dom-if> to flush before the <template>'s host property
      //    forwarding. In that scenario creating an instance would result in
      //    the host props being set once, and then the enqueued changes on the
      //    template would set properties a second time, potentially causing an
      //    object to be set to an instance more than once.  Creating the
      //    instance async from flushing data ensures this doesn't happen. If
      //    we wanted a sync option in the future, simply having <dom-if> flush
      //    (or clear) its template's pending host properties before creating
      //    the instance would also avoid the problem.
      this.__renderDebouncer = Polymer.Debouncer.debounce(
            this.__renderDebouncer
          , Polymer.Async.microTask
          , () => this.__render());
      Polymer.enqueueDebouncer(this.__renderDebouncer);
    }

    /**
     * @return {void}
     */
    disconnectedCallback() {
      super.disconnectedCallback();
      if (!this.parentNode ||
          (this.parentNode.nodeType == Node.DOCUMENT_FRAGMENT_NODE &&
           !this.parentNode.host)) {
        this.__teardownInstance();
      }
    }

    /**
     * @return {void}
     */
    connectedCallback() {
      super.connectedCallback();
      this.style.display = 'none';
      if (this.if) {
        this.__debounceRender();
      }
    }

    /**
     * Forces the element to render its content. Normally rendering is
     * asynchronous to a provoking change. This is done for efficiency so
     * that multiple changes trigger only a single render. The render method
     * should be called if, for example, template rendering is required to
     * validate application state.
     * @return {void}
     */
    render() {
      Polymer.flush();
    }

    __render() {
      if (this.if) {
        if (!this.__ensureInstance()) {
          // No template found yet
          return;
        }
        this._showHideChildren();
      } else if (this.restamp) {
        this.__teardownInstance();
      }
      if (!this.restamp && this.__instance) {
        this._showHideChildren();
      }
      if (this.if != this._lastIf) {
        this.dispatchEvent(new CustomEvent('dom-change', {
          bubbles: true,
          composed: true
        }));
        this._lastIf = this.if;
      }
    }

    __ensureInstance() {
      let parentNode = this.parentNode;
      // Guard against element being detached while render was queued
      if (parentNode) {
        if (!this.__ctor) {
          let template = /** @type {HTMLTemplateElement} */(this.querySelector('template'));
          if (!template) {
            // Wait until childList changes and template should be there by then
            let observer = new MutationObserver(() => {
              if (this.querySelector('template')) {
                observer.disconnect();
                this.__render();
              } else {
                throw new Error('dom-if requires a <template> child');
              }
            });
            observer.observe(this, {childList: true});
            return false;
          }
          this.__ctor = Polymer.Templatize.templatize(template, this, {
            // dom-if templatizer instances require `mutable: true`, as
            // `__syncHostProperties` relies on that behavior to sync objects
            mutableData: true,
            /**
             * @param {string} prop Property to forward
             * @param {*} value Value of property
             * @this {this}
             */
            forwardHostProp: function(prop, value) {
              if (this.__instance) {
                if (this.if) {
                  this.__instance.forwardHostProp(prop, value);
                } else {
                  // If we have an instance but are squelching host property
                  // forwarding due to if being false, note the invalidated
                  // properties so `__syncHostProperties` can sync them the next
                  // time `if` becomes true
                  this.__invalidProps = this.__invalidProps || Object.create(null);
                  this.__invalidProps[Polymer.Path.root(prop)] = true;
                }
              }
            }
          });
        }
        if (!this.__instance) {
          this.__instance = new this.__ctor();
          parentNode.insertBefore(this.__instance.root, this);
        } else {
          this.__syncHostProperties();
          let c$ = this.__instance.children;
          if (c$ && c$.length) {
            // Detect case where dom-if was re-attached in new position
            let lastChild = this.previousSibling;
            if (lastChild !== c$[c$.length-1]) {
              for (let i=0, n; (i<c$.length) && (n=c$[i]); i++) {
                parentNode.insertBefore(n, this);
              }
            }
          }
        }
      }
      return true;
    }

    __syncHostProperties() {
      let props = this.__invalidProps;
      if (props) {
        for (let prop in props) {
          this.__instance._setPendingProperty(prop, this.__dataHost[prop]);
        }
        this.__invalidProps = null;
        this.__instance._flushProperties();
      }
    }

    __teardownInstance() {
      if (this.__instance) {
        let c$ = this.__instance.children;
        if (c$ && c$.length) {
          // use first child parent, for case when dom-if may have been detached
          let parent = c$[0].parentNode;
          // Instance children may be disconnected from parents when dom-if
          // detaches if a tree was innerHTML'ed
          if (parent) {
            for (let i=0, n; (i<c$.length) && (n=c$[i]); i++) {
              parent.removeChild(n);
            }
          }
        }
        this.__instance = null;
        this.__invalidProps = null;
      }
    }

    /**
     * Shows or hides the template instance top level child elements. For
     * text nodes, `textContent` is removed while "hidden" and replaced when
     * "shown."
     * @return {void}
     * @protected
     */
    _showHideChildren() {
      let hidden = this.__hideTemplateChildren__ || !this.if;
      if (this.__instance) {
        this.__instance._showHideChildren(hidden);
      }
    }

  }

  customElements.define(DomIf.is, DomIf);

  /** @const */
  Polymer.DomIf = DomIf;

})();


(function() {
  'use strict';

  /**
   * Element mixin for recording dynamic associations between item paths in a
   * master `items` array and a `selected` array such that path changes to the
   * master array (at the host) element or elsewhere via data-binding) are
   * correctly propagated to items in the selected array and vice-versa.
   *
   * The `items` property accepts an array of user data, and via the
   * `select(item)` and `deselect(item)` API, updates the `selected` property
   * which may be bound to other parts of the application, and any changes to
   * sub-fields of `selected` item(s) will be kept in sync with items in the
   * `items` array.  When `multi` is false, `selected` is a property
   * representing the last selected item.  When `multi` is true, `selected`
   * is an array of multiply selected items.
   *
   * @polymer
   * @mixinFunction
   * @appliesMixin Polymer.ElementMixin
   * @memberof Polymer
   * @summary Element mixin for recording dynamic associations between item paths in a
   * master `items` array and a `selected` array
   */
  let ArraySelectorMixin = Polymer.dedupingMixin(superClass => {

    /**
     * @constructor
     * @extends {superClass}
     * @implements {Polymer_ElementMixin}
     * @private
     */
    let elementBase = Polymer.ElementMixin(superClass);

    /**
     * @polymer
     * @mixinClass
     * @implements {Polymer_ArraySelectorMixin}
     * @unrestricted
     */
    class ArraySelectorMixin extends elementBase {

      static get properties() {

        return {

          /**
           * An array containing items from which selection will be made.
           */
          items: {
            type: Array,
          },

          /**
           * When `true`, multiple items may be selected at once (in this case,
           * `selected` is an array of currently selected items).  When `false`,
           * only one item may be selected at a time.
           */
          multi: {
            type: Boolean,
            value: false,
          },

          /**
           * When `multi` is true, this is an array that contains any selected.
           * When `multi` is false, this is the currently selected item, or `null`
           * if no item is selected.
           * @type {?(Object|Array<!Object>)}
           */
          selected: {
            type: Object,
            notify: true
          },

          /**
           * When `multi` is false, this is the currently selected item, or `null`
           * if no item is selected.
           * @type {?Object}
           */
          selectedItem: {
            type: Object,
            notify: true
          },

          /**
           * When `true`, calling `select` on an item that is already selected
           * will deselect the item.
           */
          toggle: {
            type: Boolean,
            value: false
          }

        };
      }

      static get observers() {
        return ['__updateSelection(multi, items.*)'];
      }

      constructor() {
        super();
        this.__lastItems = null;
        this.__lastMulti = null;
        this.__selectedMap = null;
      }

      __updateSelection(multi, itemsInfo) {
        let path = itemsInfo.path;
        if (path == 'items') {
          // Case 1 - items array changed, so diff against previous array and
          // deselect any removed items and adjust selected indices
          let newItems = itemsInfo.base || [];
          let lastItems = this.__lastItems;
          let lastMulti = this.__lastMulti;
          if (multi !== lastMulti) {
            this.clearSelection();
          }
          if (lastItems) {
            let splices = Polymer.ArraySplice.calculateSplices(newItems, lastItems);
            this.__applySplices(splices);
          }
          this.__lastItems = newItems;
          this.__lastMulti = multi;
        } else if (itemsInfo.path == 'items.splices') {
          // Case 2 - got specific splice information describing the array mutation:
          // deselect any removed items and adjust selected indices
          this.__applySplices(itemsInfo.value.indexSplices);
        } else {
          // Case 3 - an array element was changed, so deselect the previous
          // item for that index if it was previously selected
          let part = path.slice('items.'.length);
          let idx = parseInt(part, 10);
          if ((part.indexOf('.') < 0) && part == idx) {
            this.__deselectChangedIdx(idx);
          }
        }
      }

      __applySplices(splices) {
        let selected = this.__selectedMap;
        // Adjust selected indices and mark removals
        for (let i=0; i<splices.length; i++) {
          let s = splices[i];
          selected.forEach((idx, item) => {
            if (idx < s.index) {
              // no change
            } else if (idx >= s.index + s.removed.length) {
              // adjust index
              selected.set(item, idx + s.addedCount - s.removed.length);
            } else {
              // remove index
              selected.set(item, -1);
            }
          });
          for (let j=0; j<s.addedCount; j++) {
            let idx = s.index + j;
            if (selected.has(this.items[idx])) {
              selected.set(this.items[idx], idx);
            }
          }
        }
        // Update linked paths
        this.__updateLinks();
        // Remove selected items that were removed from the items array
        let sidx = 0;
        selected.forEach((idx, item) => {
          if (idx < 0) {
            if (this.multi) {
              this.splice('selected', sidx, 1);
            } else {
              this.selected = this.selectedItem = null;
            }
            selected.delete(item);
          } else {
            sidx++;
          }
        });
      }

      __updateLinks() {
        this.__dataLinkedPaths = {};
        if (this.multi) {
          let sidx = 0;
          this.__selectedMap.forEach(idx => {
            if (idx >= 0) {
              this.linkPaths('items.' + idx, 'selected.' + sidx++);
            }
          });
        } else {
          this.__selectedMap.forEach(idx => {
            this.linkPaths('selected', 'items.' + idx);
            this.linkPaths('selectedItem', 'items.' + idx);
          });
        }
      }

      /**
       * Clears the selection state.
       * @return {void}
       */
      clearSelection() {
        // Unbind previous selection
        this.__dataLinkedPaths = {};
        // The selected map stores 3 pieces of information:
        // key: items array object
        // value: items array index
        // order: selected array index
        this.__selectedMap = new Map();
        // Initialize selection
        this.selected = this.multi ? [] : null;
        this.selectedItem = null;
      }

      /**
       * Returns whether the item is currently selected.
       *
       * @param {*} item Item from `items` array to test
       * @return {boolean} Whether the item is selected
       */
      isSelected(item) {
        return this.__selectedMap.has(item);
      }

      /**
       * Returns whether the item is currently selected.
       *
       * @param {number} idx Index from `items` array to test
       * @return {boolean} Whether the item is selected
       */
      isIndexSelected(idx) {
        return this.isSelected(this.items[idx]);
      }

      __deselectChangedIdx(idx) {
        let sidx = this.__selectedIndexForItemIndex(idx);
        if (sidx >= 0) {
          let i = 0;
          this.__selectedMap.forEach((idx, item) => {
            if (sidx == i++) {
              this.deselect(item);
            }
          });
        }
      }

      __selectedIndexForItemIndex(idx) {
        let selected = this.__dataLinkedPaths['items.' + idx];
        if (selected) {
          return parseInt(selected.slice('selected.'.length), 10);
        }
      }

      /**
       * Deselects the given item if it is already selected.
       *
       * @param {*} item Item from `items` array to deselect
       * @return {void}
       */
      deselect(item) {
        let idx = this.__selectedMap.get(item);
        if (idx >= 0) {
          this.__selectedMap.delete(item);
          let sidx;
          if (this.multi) {
            sidx = this.__selectedIndexForItemIndex(idx);
          }
          this.__updateLinks();
          if (this.multi) {
            this.splice('selected', sidx, 1);
          } else {
            this.selected = this.selectedItem = null;
          }
        }
      }

      /**
       * Deselects the given index if it is already selected.
       *
       * @param {number} idx Index from `items` array to deselect
       * @return {void}
       */
      deselectIndex(idx) {
        this.deselect(this.items[idx]);
      }

      /**
       * Selects the given item.  When `toggle` is true, this will automatically
       * deselect the item if already selected.
       *
       * @param {*} item Item from `items` array to select
       * @return {void}
       */
      select(item) {
        this.selectIndex(this.items.indexOf(item));
      }

      /**
       * Selects the given index.  When `toggle` is true, this will automatically
       * deselect the item if already selected.
       *
       * @param {number} idx Index from `items` array to select
       * @return {void}
       */
      selectIndex(idx) {
        let item = this.items[idx];
        if (!this.isSelected(item)) {
          if (!this.multi) {
            this.__selectedMap.clear();
          }
          this.__selectedMap.set(item, idx);
          this.__updateLinks();
          if (this.multi) {
            this.push('selected', item);
          } else {
            this.selected = this.selectedItem = item;
          }
        } else if (this.toggle) {
          this.deselectIndex(idx);
        }
      }

    }

    return ArraySelectorMixin;

  });

  // export mixin
  Polymer.ArraySelectorMixin = ArraySelectorMixin;

  /**
   * @constructor
   * @extends {Polymer.Element}
   * @implements {Polymer_ArraySelectorMixin}
   * @private
   */
  let baseArraySelector = ArraySelectorMixin(Polymer.Element);

  /**
   * Element implementing the `Polymer.ArraySelector` mixin, which records
   * dynamic associations between item paths in a master `items` array and a
   * `selected` array such that path changes to the master array (at the host)
   * element or elsewhere via data-binding) are correctly propagated to items
   * in the selected array and vice-versa.
   *
   * The `items` property accepts an array of user data, and via the
   * `select(item)` and `deselect(item)` API, updates the `selected` property
   * which may be bound to other parts of the application, and any changes to
   * sub-fields of `selected` item(s) will be kept in sync with items in the
   * `items` array.  When `multi` is false, `selected` is a property
   * representing the last selected item.  When `multi` is true, `selected`
   * is an array of multiply selected items.
   *
   * Example:
   *
   * ```html
   * <dom-module id="employee-list">
   *
   *   <template>
   *
   *     <div> Employee list: </div>
   *     <dom-repeat id="employeeList" items="{{employees}}">
   *       <template>
   *         <div>First name: <span>{{item.first}}</span></div>
   *           <div>Last name: <span>{{item.last}}</span></div>
   *           <button on-click="toggleSelection">Select</button>
   *       </template>
   *     </dom-repeat>
   *
   *     <array-selector id="selector" items="{{employees}}" selected="{{selected}}" multi toggle></array-selector>
   *
   *     <div> Selected employees: </div>
   *     <dom-repeat items="{{selected}}">
   *       <template>
   *         <div>First name: <span>{{item.first}}</span></div>
   *         <div>Last name: <span>{{item.last}}</span></div>
   *       </template>
   *     </dom-repeat>
   *
   *   </template>
   *
   * </dom-module>
   * ```
   *
   * ```js
   *class EmployeeList extends Polymer.Element {
   *  static get is() { return 'employee-list'; }
   *  static get properties() {
   *    return {
   *      employees: {
   *        value() {
   *          return [
   *            {first: 'Bob', last: 'Smith'},
   *            {first: 'Sally', last: 'Johnson'},
   *            ...
   *          ];
   *        }
   *      }
   *    };
   *  }
   *  toggleSelection(e) {
   *    let item = this.$.employeeList.itemForElement(e.target);
   *    this.$.selector.select(item);
   *  }
   *}
   * ```
   *
   * @polymer
   * @customElement
   * @extends {baseArraySelector}
   * @appliesMixin Polymer.ArraySelectorMixin
   * @memberof Polymer
   * @summary Custom element that links paths between an input `items` array and
   *   an output `selected` item or array based on calls to its selection API.
   */
  class ArraySelector extends baseArraySelector {
    // Not needed to find template; can be removed once the analyzer
    // can find the tag name from customElements.define call
    static get is() { return 'array-selector'; }
  }
  customElements.define(ArraySelector.is, ArraySelector);

  /** @const */
  Polymer.ArraySelector = ArraySelector;

})();


(function(){/*

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
*/
'use strict';var c=null,f=window.HTMLImports&&window.HTMLImports.whenReady||null,g;function h(a){requestAnimationFrame(function(){f?f(a):(c||(c=new Promise(function(a){g=a}),"complete"===document.readyState?g():document.addEventListener("readystatechange",function(){"complete"===document.readyState&&g()})),c.then(function(){a&&a()}))})};var k=null,l=null;function m(){this.customStyles=[];this.enqueued=!1;h(function(){window.ShadyCSS.flushCustomStyles&&window.ShadyCSS.flushCustomStyles()})}function n(a){!a.enqueued&&l&&(a.enqueued=!0,h(l))}m.prototype.c=function(a){a.__seenByShadyCSS||(a.__seenByShadyCSS=!0,this.customStyles.push(a),n(this))};m.prototype.b=function(a){if(a.__shadyCSSCachedStyle)return a.__shadyCSSCachedStyle;var b;a.getStyle?b=a.getStyle():b=a;return b};
m.prototype.a=function(){for(var a=this.customStyles,b=0;b<a.length;b++){var d=a[b];if(!d.__shadyCSSCachedStyle){var e=this.b(d);e&&(e=e.__appliedElement||e,k&&k(e),d.__shadyCSSCachedStyle=e)}}return a};m.prototype.addCustomStyle=m.prototype.c;m.prototype.getStyleForCustomStyle=m.prototype.b;m.prototype.processStyles=m.prototype.a;
Object.defineProperties(m.prototype,{transformCallback:{get:function(){return k},set:function(a){k=a}},validateCallback:{get:function(){return l},set:function(a){var b=!1;l||(b=!0);l=a;b&&n(this)}}});function p(a,b){for(var d in b)null===d?a.style.removeProperty(d):a.style.setProperty(d,b[d])};var q=!(window.ShadyDOM&&window.ShadyDOM.inUse),r;function t(a){r=a&&a.shimcssproperties?!1:q||!(navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/)||!window.CSS||!CSS.supports||!CSS.supports("box-shadow","0 0 0 var(--foo)"))}var u;window.ShadyCSS&&void 0!==window.ShadyCSS.cssBuild&&(u=window.ShadyCSS.cssBuild);var v=!(!window.ShadyCSS||!window.ShadyCSS.disableRuntime);
window.ShadyCSS&&void 0!==window.ShadyCSS.nativeCss?r=window.ShadyCSS.nativeCss:window.ShadyCSS?(t(window.ShadyCSS),window.ShadyCSS=void 0):t(window.WebComponents&&window.WebComponents.flags);var w=r,x=u;var y=new m;window.ShadyCSS||(window.ShadyCSS={prepareTemplate:function(){},prepareTemplateDom:function(){},prepareTemplateStyles:function(){},styleSubtree:function(a,b){y.a();p(a,b)},styleElement:function(){y.a()},styleDocument:function(a){y.a();p(document.body,a)},getComputedStyleValue:function(a,b){return(a=window.getComputedStyle(a).getPropertyValue(b))?a.trim():""},flushCustomStyles:function(){},nativeCss:w,nativeShadow:q,cssBuild:x,disableRuntime:v});window.ShadyCSS.CustomStyleInterface=y;}).call(this);




(function() {
  'use strict';

  const attr = 'include';

  const CustomStyleInterface = window.ShadyCSS.CustomStyleInterface;

  /**
   * Custom element for defining styles in the main document that can take
   * advantage of [shady DOM](https://github.com/webcomponents/shadycss) shims
   * for style encapsulation, custom properties, and custom mixins.
   *
   * - Document styles defined in a `<custom-style>` are shimmed to ensure they
   *   do not leak into local DOM when running on browsers without native
   *   Shadow DOM.
   * - Custom properties can be defined in a `<custom-style>`. Use the `html` selector
   *   to define custom properties that apply to all custom elements.
   * - Custom mixins can be defined in a `<custom-style>`, if you import the optional
   *   [apply shim](https://github.com/webcomponents/shadycss#about-applyshim)
   *   (`shadycss/apply-shim.html`).
   *
   * To use:
   *
   * - Import `custom-style.html`.
   * - Place a `<custom-style>` element in the main document, wrapping an inline `<style>` tag that
   *   contains the CSS rules you want to shim.
   *
   * For example:
   *
   * ```html
   * <!-- import apply shim--only required if using mixins -->
   * <link rel="import" href="bower_components/shadycss/apply-shim.html">
   * <!-- import custom-style element -->
   * <link rel="import" href="bower_components/polymer/lib/elements/custom-style.html">
   *
   * <custom-style>
   *   <style>
   *     html {
   *       --custom-color: blue;
   *       --custom-mixin: {
   *         font-weight: bold;
   *         color: red;
   *       };
   *     }
   *   </style>
   * </custom-style>
   * ```
   *
   * @customElement
   * @extends HTMLElement
   * @memberof Polymer
   * @summary Custom element for defining styles in the main document that can
   *   take advantage of Polymer's style scoping and custom properties shims.
   */
  class CustomStyle extends HTMLElement {
    constructor() {
      super();
      this._style = null;
      CustomStyleInterface.addCustomStyle(this);
    }
    /**
     * Returns the light-DOM `<style>` child this element wraps.  Upon first
     * call any style modules referenced via the `include` attribute will be
     * concatenated to this element's `<style>`.
     *
     * @return {HTMLStyleElement} This element's light-DOM `<style>`
     */
    getStyle() {
      if (this._style) {
        return this._style;
      }
      const style = /** @type {HTMLStyleElement} */(this.querySelector('style'));
      if (!style) {
        return null;
      }
      this._style = style;
      const include = style.getAttribute(attr);
      if (include) {
        style.removeAttribute(attr);
        style.textContent = Polymer.StyleGather.cssFromModules(include) + style.textContent;
      }
      /*
      HTML Imports styling the main document are deprecated in Chrome
      https://crbug.com/523952

      If this element is not in the main document, then it must be in an HTML Import document.
      In that case, move the custom style to the main document.

      The ordering of `<custom-style>` should stay the same as when loaded by HTML Imports, but there may be odd
      cases of ordering w.r.t the main document styles.
      */
      if (this.ownerDocument !== window.document) {
        window.document.head.appendChild(this);
      }
      return this._style;
    }
  }

  window.customElements.define('custom-style', CustomStyle);

  /** @const */
  Polymer.CustomStyle = CustomStyle;
})();


(function() {
  'use strict';

  let mutablePropertyChange;
  /** @suppress {missingProperties} */
  (() => {
    mutablePropertyChange = Polymer.MutableData._mutablePropertyChange;
  })();

  /**
   * Legacy element behavior to skip strict dirty-checking for objects and arrays,
   * (always consider them to be "dirty") for use on legacy API Polymer elements.
   *
   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
   * objects, which means that any deep modifications to an object or array will
   * not be propagated unless "immutable" data patterns are used (i.e. all object
   * references from the root to the mutation were changed).
   *
   * Polymer also provides a proprietary data mutation and path notification API
   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
   * mutation and notification of deep changes in an object graph to all elements
   * bound to the same object graph.
   *
   * In cases where neither immutable patterns nor the data mutation API can be
   * used, applying this mixin will cause Polymer to skip dirty checking for
   * objects and arrays (always consider them to be "dirty").  This allows a
   * user to make a deep modification to a bound object graph, and then either
   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
   * elements that wish to be updated based on deep mutations must apply this
   * mixin or otherwise skip strict dirty checking for objects/arrays.
   * Specifically, any elements in the binding tree between the source of a
   * mutation and the consumption of it must apply this behavior or enable the
   * `Polymer.OptionalMutableDataBehavior`.
   *
   * In order to make the dirty check strategy configurable, see
   * `Polymer.OptionalMutableDataBehavior`.
   *
   * Note, the performance characteristics of propagating large object graphs
   * will be worse as opposed to using strict dirty checking with immutable
   * patterns or Polymer's path notification API.
   *
   * @polymerBehavior
   * @memberof Polymer
   * @summary Behavior to skip strict dirty-checking for objects and
   *   arrays
   */
  Polymer.MutableDataBehavior = {

    /**
     * Overrides `Polymer.PropertyEffects` to provide option for skipping
     * strict equality checking for Objects and Arrays.
     *
     * This method pulls the value to dirty check against from the `__dataTemp`
     * cache (rather than the normal `__data` cache) for Objects.  Since the temp
     * cache is cleared at the end of a turn, this implementation allows
     * side-effects of deep object changes to be processed by re-setting the
     * same object (using the temp cache as an in-turn backstop to prevent
     * cycles due to 2-way notification).
     *
     * @param {string} property Property name
     * @param {*} value New property value
     * @param {*} old Previous property value
     * @return {boolean} Whether the property should be considered a change
     * @protected
     */
    _shouldPropertyChange(property, value, old) {
      return mutablePropertyChange(this, property, value, old, true);
    }
  };

  /**
   * Legacy element behavior to add the optional ability to skip strict
   * dirty-checking for objects and arrays (always consider them to be
   * "dirty") by setting a `mutable-data` attribute on an element instance.
   *
   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
   * objects, which means that any deep modifications to an object or array will
   * not be propagated unless "immutable" data patterns are used (i.e. all object
   * references from the root to the mutation were changed).
   *
   * Polymer also provides a proprietary data mutation and path notification API
   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
   * mutation and notification of deep changes in an object graph to all elements
   * bound to the same object graph.
   *
   * In cases where neither immutable patterns nor the data mutation API can be
   * used, applying this mixin will allow Polymer to skip dirty checking for
   * objects and arrays (always consider them to be "dirty").  This allows a
   * user to make a deep modification to a bound object graph, and then either
   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
   * elements that wish to be updated based on deep mutations must apply this
   * mixin or otherwise skip strict dirty checking for objects/arrays.
   * Specifically, any elements in the binding tree between the source of a
   * mutation and the consumption of it must enable this behavior or apply the
   * `Polymer.OptionalMutableDataBehavior`.
   *
   * While this behavior adds the ability to forgo Object/Array dirty checking,
   * the `mutableData` flag defaults to false and must be set on the instance.
   *
   * Note, the performance characteristics of propagating large object graphs
   * will be worse by relying on `mutableData: true` as opposed to using
   * strict dirty checking with immutable patterns or Polymer's path notification
   * API.
   *
   * @polymerBehavior
   * @memberof Polymer
   * @summary Behavior to optionally skip strict dirty-checking for objects and
   *   arrays
   */
  Polymer.OptionalMutableDataBehavior = {

    properties: {
      /**
       * Instance-level flag for configuring the dirty-checking strategy
       * for this element.  When true, Objects and Arrays will skip dirty
       * checking, otherwise strict equality checking will be used.
       */
      mutableData: Boolean
    },

    /**
     * Overrides `Polymer.PropertyEffects` to skip strict equality checking
     * for Objects and Arrays.
     *
     * Pulls the value to dirty check against from the `__dataTemp` cache
     * (rather than the normal `__data` cache) for Objects.  Since the temp
     * cache is cleared at the end of a turn, this implementation allows
     * side-effects of deep object changes to be processed by re-setting the
     * same object (using the temp cache as an in-turn backstop to prevent
     * cycles due to 2-way notification).
     *
     * @param {string} property Property name
     * @param {*} value New property value
     * @param {*} old Previous property value
     * @return {boolean} Whether the property should be considered a change
     * @this {this}
     * @protected
     */
    _shouldPropertyChange(property, value, old) {
      return mutablePropertyChange(this, property, value, old, this.mutableData);
    }
  };

})();



  // bc
  Polymer.Base = Polymer.LegacyElementMixin(HTMLElement).prototype;

  // NOTE: this is here for modulizer to export `html` for the module version of this file
  Polymer.html = Polymer.html;

//# sourceURL=build://iron-flex-layout/iron-flex-layout.html.js
(function(){var b=document.createElement("style");b.textContent="[hidden] { display: none !important; }";document.head.appendChild(b)})();

//# sourceURL=build://iron-a11y-keys-behavior/iron-a11y-keys-behavior.html.js
(function(){function b(w,C){var G="";if(w)if(w=w.toLowerCase()," "===w||A.test(w))G="space";else if(y.test(w))G="esc";else if(1==w.length){if(!C||q.test(w))G=w}else G=x.test(w)?w.replace("arrow",""):"multiply"==w?"*":w;return G}function d(w){var C="";w&&(w in p?C=p[w]:u.test(w)?(w=parseInt(w.replace("U+","0x"),16),C=String.fromCharCode(w).toLowerCase()):C=w.toLowerCase());return C}function f(w){var C="";Number(w)&&(C=65<=w&&90>=w?String.fromCharCode(32+w):112<=w&&123>=w?"f"+(w-112+1):48<=w&&57>=w?
String(w-48):96<=w&&105>=w?String(w-96):m[w]);return C}function h(w,C){return w.key?b(w.key,C):w.detail&&w.detail.key?b(w.detail.key,C):d(w.keyIdentifier)||f(w.keyCode)||""}function k(w,C){return h(C,w.hasModifiers)===w.key&&(!w.hasModifiers||!!C.shiftKey===!!w.shiftKey&&!!C.ctrlKey===!!w.ctrlKey&&!!C.altKey===!!w.altKey&&!!C.metaKey===!!w.metaKey)}function t(w){return 1===w.length?{combo:w,key:w,event:"keydown"}:w.split("+").reduce(function(C,G){var D=G.split(":");G=D[0];D=D[1];G in n?(C[n[G]]=!0,
C.hasModifiers=!0):(C.key=G,C.event=D||"keydown");return C},{combo:w.split(":").shift()})}function l(w){return w.trim().split(" ").map(function(C){return t(C)})}var p={"U+0008":"backspace","U+0009":"tab","U+001B":"esc","U+0020":"space","U+007F":"del"},m={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:"*"},n={shift:"shiftKey",ctrl:"ctrlKey",alt:"altKey",meta:"metaKey"},q=/[a-z0-9*]/,u=/U\+/,x=/^arrow/,
A=/^space(bar)?/,y=/^escape$/;Polymer.IronA11yKeysBehavior={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(w,C){this._imperativeKeyBindings[w]=C;this._prepKeyBindings();this._resetKeyEventListeners()},removeOwnKeyBindings:function(){this._imperativeKeyBindings={};this._prepKeyBindings();this._resetKeyEventListeners()},keyboardEventMatchesKeys:function(w,C){C=l(C);for(var G=0;G<C.length;++G)if(k(C[G],w))return!0;return!1},_collectKeyBindings:function(){var w=this.behaviors.map(function(C){return C.keyBindings});-1===w.indexOf(this.keyBindings)&&w.push(this.keyBindings);return w},
_prepKeyBindings:function(){this._keyBindings={};this._collectKeyBindings().forEach(function(G){for(var D in G)this._addKeyBinding(D,G[D])},this);for(var w in this._imperativeKeyBindings)this._addKeyBinding(w,this._imperativeKeyBindings[w]);for(var C in this._keyBindings)this._keyBindings[C].sort(function(G,D){G=G[0].hasModifiers;return G===D[0].hasModifiers?0:G?-1:1})},_addKeyBinding:function(w,C){l(w).forEach(function(G){this._keyBindings[G.event]=this._keyBindings[G.event]||[];this._keyBindings[G.event].push([G,
C])},this)},_resetKeyEventListeners:function(){this._unlistenKeyEventListeners();this.isAttached&&this._listenKeyEventListeners()},_listenKeyEventListeners:function(){this.keyEventTarget&&Object.keys(this._keyBindings).forEach(function(w){var C=this._onKeyBindingEvent.bind(this,this._keyBindings[w]);this._boundKeyHandlers.push([this.keyEventTarget,w,C]);this.keyEventTarget.addEventListener(w,C)},this)},_unlistenKeyEventListeners:function(){for(var w,C,G;this._boundKeyHandlers.length;)w=this._boundKeyHandlers.pop(),
C=w[0],G=w[1],w=w[2],C.removeEventListener(G,w)},_onKeyBindingEvent:function(w,C){this.stopKeyboardEventPropagation&&C.stopPropagation();if(!C.defaultPrevented)for(var G=0;G<w.length;G++){var D=w[G][0],B=w[G][1];if(k(D,C)&&(this._triggerKeyHandler(D,B,C),C.defaultPrevented))break}},_triggerKeyHandler:function(w,C,G){var D=Object.create(w);D.keyboardEvent=G;w=new CustomEvent(w.event,{detail:D,cancelable:!0});this[C].call(this,w);w.defaultPrevented&&G.preventDefault()}}})();

//# sourceURL=build://iron-behaviors/iron-control-state.html.js
Polymer.IronControlState={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)}},__handleEventRetargeting:{type:Boolean,value:function(){return!this.shadowRoot&&!Polymer.Element}}},observers:["_changedControlState(focused, disabled)"],ready:function(){this.addEventListener("focus",
this._boundFocusBlurHandler,!0);this.addEventListener("blur",this._boundFocusBlurHandler,!0)},_focusBlurHandler:function(b){if(Polymer.Element)this._setFocused("focus"===b.type);else if(b.target===this)this._setFocused("focus"===b.type);else if(this.__handleEventRetargeting){var d=Polymer.dom(b).localTarget;this.isLightDescendant(d)||this.fire(b.type,{sourceEvent:b},{node:this,bubbles:b.bubbles,cancelable:b.cancelable})}},_disabledChanged:function(b){this.setAttribute("aria-disabled",b?"true":"false");
this.style.pointerEvents=b?"none":"";b?(this._oldTabIndex=this.getAttribute("tabindex"),this._setFocused(!1),this.tabIndex=-1,this.blur()):void 0!==this._oldTabIndex&&(null===this._oldTabIndex?this.removeAttribute("tabindex"):this.setAttribute("tabindex",this._oldTabIndex))},_changedControlState:function(){this._controlStateChanged&&this._controlStateChanged()}};

//# sourceURL=build://iron-behaviors/iron-button-state.html.js
Polymer.IronButtonStateImpl={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(b){this._detectKeyboardFocus(b);b||this._setPressed(!1)},_detectKeyboardFocus:function(b){this._setReceivedFocusFromKeyboard(!this.pointerDown&&b)},_userActivate:function(b){this.active!==
b&&(this.active=b,this.fire("change"))},_downHandler:function(){this._setPointerDown(!0);this._setPressed(!0);this._setReceivedFocusFromKeyboard(!1)},_upHandler:function(){this._setPointerDown(!1);this._setPressed(!1)},_spaceKeyDownHandler:function(b){b=b.detail.keyboardEvent;var d=Polymer.dom(b).localTarget;this.isLightDescendant(d)||(b.preventDefault(),b.stopImmediatePropagation(),this._setPressed(!0))},_spaceKeyUpHandler:function(b){b=Polymer.dom(b.detail.keyboardEvent).localTarget;this.isLightDescendant(b)||
(this.pressed&&this._asyncClick(),this._setPressed(!1))},_asyncClick:function(){this.async(function(){this.click()},1)},_pressedChanged:function(){this._changedButtonState()},_ariaActiveAttributeChanged:function(b,d){d&&d!=b&&this.hasAttribute(d)&&this.removeAttribute(d)},_activeChanged:function(b){this.toggles?this.setAttribute(this.ariaActiveAttribute,b?"true":"false"):this.removeAttribute(this.ariaActiveAttribute);this._changedButtonState()},_controlStateChanged:function(){this.disabled?this._setPressed(!1):
this._changedButtonState()},_changedButtonState:function(){this._buttonStateChanged&&this._buttonStateChanged()}};Polymer.IronButtonState=[Polymer.IronA11yKeysBehavior,Polymer.IronButtonStateImpl];

//# sourceURL=build://paper-ripple/paper-ripple.html.js
(function(){function b(h){this.element=h;this.width=this.boundingRect.width;this.height=this.boundingRect.height;this.size=Math.max(this.width,this.height)}function d(h){this.element=h;this.color=window.getComputedStyle(h).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");Polymer.dom(this.waveContainer).appendChild(this.wave);this.resetInteractionState()}
var f={distance:function(h,k,t,l){h-=t;k-=l;return Math.sqrt(h*h+k*k)},now:window.performance&&window.performance.now?window.performance.now.bind(window.performance):Date.now};b.prototype={get boundingRect(){return this.element.getBoundingClientRect()},furthestCornerDistanceFrom:function(h,k){var t=f.distance(h,k,0,0),l=f.distance(h,k,this.width,0),p=f.distance(h,k,0,this.height);h=f.distance(h,k,this.width,this.height);return Math.max(t,l,p,h)}};d.MAX_RADIUS=300;d.prototype={get recenters(){return this.element.recenters},
get center(){return this.element.center},get mouseDownElapsed(){if(!this.mouseDownStart)return 0;var h=f.now()-this.mouseDownStart;this.mouseUpStart&&(h-=this.mouseUpElapsed);return h},get mouseUpElapsed(){return this.mouseUpStart?f.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 h=1.1*Math.min(Math.sqrt(this.containerMetrics.width*this.containerMetrics.width+this.containerMetrics.height*this.containerMetrics.height),d.MAX_RADIUS)+5;return Math.abs(h*(1-Math.pow(80,-(this.mouseInteractionSeconds/(1.1-h/d.MAX_RADIUS*.2)))))},get opacity(){return this.mouseUpStart?Math.max(0,this.initialOpacity-this.mouseUpElapsedSeconds*this.opacityDecayVelocity):this.initialOpacity},get outerOpacity(){return Math.max(0,
Math.min(.3*this.mouseUpElapsedSeconds,this.opacity))},get isOpacityFullyDecayed(){return.01>this.opacity&&this.radius>=Math.min(this.maxRadius,d.MAX_RADIUS)},get isRestingAtMaxRadius(){return this.opacity>=this.initialOpacity&&this.radius>=Math.min(this.maxRadius,d.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.slideDistance=this.yEnd=this.xEnd=this.yStart=this.xStart=this.mouseUpStart=this.mouseDownStart=this.maxRadius=0;this.containerMetrics=new b(this.element)},draw:function(){this.wave.style.opacity=this.opacity;var h=this.radius/
(this.containerMetrics.size/2);var k=this.xNow-this.containerMetrics.width/2;var t=this.yNow-this.containerMetrics.height/2;this.waveContainer.style.webkitTransform="translate("+k+"px, "+t+"px)";this.waveContainer.style.transform="translate3d("+k+"px, "+t+"px, 0)";this.wave.style.webkitTransform="scale("+h+","+h+")";this.wave.style.transform="scale3d("+h+","+h+",1)"},downAction:function(h){var k=this.containerMetrics.width/2,t=this.containerMetrics.height/2;this.resetInteractionState();this.mouseDownStart=
f.now();this.center?(this.xStart=k,this.yStart=t,this.slideDistance=f.distance(this.xStart,this.yStart,this.xEnd,this.yEnd)):(this.xStart=h?h.detail.x-this.containerMetrics.boundingRect.left:this.containerMetrics.width/2,this.yStart=h?h.detail.y-this.containerMetrics.boundingRect.top:this.containerMetrics.height/2);this.recenters&&(this.xEnd=k,this.yEnd=t,this.slideDistance=f.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(){this.isMouseDown&&(this.mouseUpStart=f.now())},remove:function(){Polymer.dom(this.waveContainer.parentNode).removeChild(this.waveContainer)}};Polymer({is:"paper-ripple",
behaviors:[Polymer.IronA11yKeysBehavior],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(){var h=this.keyEventTarget=11==this.parentNode.nodeType?Polymer.dom(this).getOwnerRoot().host:this.parentNode;this.listen(h,"up","uiUpAction");this.listen(h,"down","uiDownAction")},detached:function(){this.unlisten(this.keyEventTarget,"up","uiUpAction");this.unlisten(this.keyEventTarget,"down","uiDownAction");this.keyEventTarget=
null},get shouldKeepAnimating(){for(var h=0;h<this.ripples.length;++h)if(!this.ripples[h].isAnimationComplete)return!0;return!1},simulatedRipple:function(){this.downAction(null);this.async(function(){this.upAction()},1)},uiDownAction:function(h){this.noink||this.downAction(h)},downAction:function(h){this.holdDown&&0<this.ripples.length||(this.addRipple().downAction(h),this._animating||(this._animating=!0,this.animate()))},uiUpAction:function(h){this.noink||this.upAction(h)},upAction:function(h){this.holdDown||
(this.ripples.forEach(function(k){k.upAction(h)}),this._animating=!0,this.animate())},onAnimationComplete:function(){this._animating=!1;this.$.background.style.backgroundColor=null;this.fire("transitionend")},addRipple:function(){var h=new d(this);Polymer.dom(this.$.waves).appendChild(h.waveContainer);this.$.background.style.backgroundColor=h.color;this.ripples.push(h);this._setAnimating(!0);return h},removeRipple:function(h){var k=this.ripples.indexOf(h);0>k||(this.ripples.splice(k,1),h.remove(),
this.ripples.length||this._setAnimating(!1))},animate:function(){if(this._animating){var h;for(h=0;h<this.ripples.length;++h){var k=this.ripples[h];k.draw();this.$.background.style.opacity=k.outerOpacity;k.isOpacityFullyDecayed&&!k.isRestingAtMaxRadius&&this.removeRipple(k)}if(this.shouldKeepAnimating||0!==this.ripples.length)window.requestAnimationFrame(this._boundAnimate);else this.onAnimationComplete()}},_onEnterKeydown:function(){this.uiDownAction();this.async(this.uiUpAction,1)},_onSpaceKeydown:function(){this.uiDownAction()},
_onSpaceKeyup:function(){this.uiUpAction()},_holdDownChanged:function(h,k){void 0!==k&&(h?this.downAction():this.upAction())}})})();

//# sourceURL=build://paper-behaviors/paper-ripple-behavior.html.js
Polymer.PaperRippleBehavior={properties:{noink:{type:Boolean,observer:"_noinkChanged"},_rippleContainer:{type:Object}},_buttonStateChanged:function(){this.focused&&this.ensureRipple()},_downHandler:function(b){Polymer.IronButtonStateImpl._downHandler.call(this,b);this.pressed&&this.ensureRipple(b)},ensureRipple:function(b){if(!this.hasRipple()){this._ripple=this._createRipple();this._ripple.noink=this.noink;var d=this._rippleContainer||this.root;d&&Polymer.dom(d).appendChild(this._ripple);if(b){d=
Polymer.dom(this._rippleContainer||this);var f=Polymer.dom(b).rootTarget;d.deepContains(f)&&this._ripple.uiDownAction(b)}}},getRipple:function(){this.ensureRipple();return this._ripple},hasRipple:function(){return!!this._ripple},_createRipple:function(){return document.createElement("paper-ripple")},_noinkChanged:function(b){this.hasRipple()&&(this._ripple.noink=b)}};

//# sourceURL=build://paper-behaviors/paper-button-behavior.html.js
Polymer.PaperButtonBehaviorImpl={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 b=1;this.disabled?b=0:this.active||this.pressed?b=4:this.receivedFocusFromKeyboard&&(b=3);this._setElevation(b)},_computeKeyboardClass:function(b){this.toggleClass("keyboard-focus",
b)},_spaceKeyDownHandler:function(b){Polymer.IronButtonStateImpl._spaceKeyDownHandler.call(this,b);this.hasRipple()&&1>this.getRipple().ripples.length&&this._ripple.uiDownAction()},_spaceKeyUpHandler:function(b){Polymer.IronButtonStateImpl._spaceKeyUpHandler.call(this,b);this.hasRipple()&&this._ripple.uiUpAction()}};Polymer.PaperButtonBehavior=[Polymer.IronButtonState,Polymer.IronControlState,Polymer.PaperRippleBehavior,Polymer.PaperButtonBehaviorImpl];

//# sourceURL=build://paper-button/paper-button.html.js
Polymer({is:"paper-button",behaviors:[Polymer.PaperButtonBehavior],properties:{raised:{type:Boolean,reflectToAttribute:!0,value:!1,observer:"_calculateElevation"}},_calculateElevation:function(){this.raised?Polymer.PaperButtonBehaviorImpl._calculateElevation.apply(this):this._setElevation(0)}});

//# sourceURL=build://iron-meta/iron-meta.html.js
(function(){Polymer.IronMeta=function(d){Polymer.IronMeta[" "](d);this.type=d&&d.type||"default";this.key=d&&d.key;d&&"value"in d&&(this.value=d.value)};Polymer.IronMeta[" "]=function(){};Polymer.IronMeta.types={};Polymer.IronMeta.prototype={get value(){var d=this.type,f=this.key;if(d&&f)return Polymer.IronMeta.types[d]&&Polymer.IronMeta.types[d][f]},set value(d){var f=this.type,h=this.key;f&&h&&(f=Polymer.IronMeta.types[f]=Polymer.IronMeta.types[f]||{},null==d?delete f[h]:f[h]=d)},get list(){if(this.type){var d=
Polymer.IronMeta.types[this.type];return d?Object.keys(d).map(function(f){return b[this.type][f]},this):[]}},byKey:function(d){this.key=d;return this.value}};var b=Polymer.IronMeta.types;Polymer({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(d,f,h){d=new Polymer.IronMeta({type:d,
key:f});void 0!==h&&h!==d.value?d.value=h:this.value!==d.value&&(this.value=d.value);return d},get list(){return this.__meta&&this.__meta.list},_selfChanged:function(d){d&&(this.value=this)},byKey:function(d){return(new Polymer.IronMeta({type:this.type,key:d})).value}})})();

//# sourceURL=build://iron-validatable-behavior/iron-validatable-behavior.html.js
Polymer.IronValidatableBehaviorMeta=null;
Polymer.IronValidatableBehavior={properties:{validator:{type:String},invalid:{notify:!0,reflectToAttribute:!0,type:Boolean,value:!1,observer:"_invalidChanged"}},registered:function(){Polymer.IronValidatableBehaviorMeta=new Polymer.IronMeta({type:"validator"})},_invalidChanged:function(){this.invalid?this.setAttribute("aria-invalid","true"):this.removeAttribute("aria-invalid")},get _validator(){return Polymer.IronValidatableBehaviorMeta&&Polymer.IronValidatableBehaviorMeta.byKey(this.validator)},hasValidator:function(){return null!=
this._validator},validate:function(b){this.invalid=void 0===b&&void 0!==this.value?!this._getValidity(this.value):!this._getValidity(b);return!this.invalid},_getValidity:function(b){return this.hasValidator()?this._validator.validate(b):!0}};

//# sourceURL=build://iron-form-element-behavior/iron-form-element-behavior.html.js
Polymer.IronFormElementBehavior={properties:{name:{type:String},value:{notify:!0,type:String},required:{type:Boolean,value:!1},_parentForm:{type:Object}},attached:function(){Polymer.Element||this.fire("iron-form-element-register")},detached:function(){!Polymer.Element&&this._parentForm&&this._parentForm.fire("iron-form-element-unregister",{target:this})}};

//# sourceURL=build://iron-checked-element-behavior/iron-checked-element-behavior.html.js
Polymer.IronCheckedElementBehaviorImpl={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(){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(){if(void 0===this.value||null===this.value)this.value="on"}};Polymer.IronCheckedElementBehavior=[Polymer.IronFormElementBehavior,Polymer.IronValidatableBehavior,Polymer.IronCheckedElementBehaviorImpl];

//# sourceURL=build://paper-behaviors/paper-inky-focus-behavior.html.js
Polymer.PaperInkyFocusBehaviorImpl={observers:["_focusedChanged(receivedFocusFromKeyboard)"],_focusedChanged:function(b){b&&this.ensureRipple();this.hasRipple()&&(this._ripple.holdDown=b)},_createRipple:function(){var b=Polymer.PaperRippleBehavior._createRipple();b.id="ink";b.setAttribute("center","");b.classList.add("circle");return b}};Polymer.PaperInkyFocusBehavior=[Polymer.IronButtonState,Polymer.IronControlState,Polymer.PaperRippleBehavior,Polymer.PaperInkyFocusBehaviorImpl];

//# sourceURL=build://paper-behaviors/paper-checked-element-behavior.html.js
Polymer.PaperCheckedElementBehaviorImpl={_checkedChanged:function(){Polymer.IronCheckedElementBehaviorImpl._checkedChanged.call(this);this.hasRipple()&&(this.checked?this._ripple.setAttribute("checked",""):this._ripple.removeAttribute("checked"))},_buttonStateChanged:function(){Polymer.PaperRippleBehavior._buttonStateChanged.call(this);!this.disabled&&this.isAttached&&(this.checked=this.active)}};
Polymer.PaperCheckedElementBehavior=[Polymer.PaperInkyFocusBehavior,Polymer.IronCheckedElementBehavior,Polymer.PaperCheckedElementBehaviorImpl];

//# sourceURL=build://paper-checkbox/paper-checkbox.html.js
Polymer({is:"paper-checkbox",behaviors:[Polymer.PaperCheckedElementBehavior],hostAttributes:{role:"checkbox","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},attached:function(){Polymer.RenderStatus.afterNextRender(this,function(){if("-1px"===this.getComputedStyleValue("--calculated-paper-checkbox-ink-size").trim()){var b=this.getComputedStyleValue("--calculated-paper-checkbox-size").trim(),d="px",f=b.match(/[A-Za-z]+$/);null!==f&&(d=f[0]);b=parseFloat(b);
f=8/3*b;"px"===d&&(f=Math.floor(f),f%2!==b%2&&f++);this.updateStyles({"--paper-checkbox-ink-size":f+d})}})},_computeCheckboxClass:function(b,d){var f="";b&&(f+="checked ");d&&(f+="invalid");return f},_computeCheckmarkClass:function(b){return b?"":"hidden"},_createRipple:function(){this._rippleContainer=this.$.checkboxContainer;return Polymer.PaperInkyFocusBehaviorImpl._createRipple.call(this)}});

//# sourceURL=build://iron-icon/iron-icon.html.js
Polymer({is:"iron-icon",properties:{icon:{type:String},theme:{type:String},src:{type:String},_meta:{value:Polymer.Base.create("iron-meta",{type:"iconset"})}},observers:["_updateIcon(_meta, isAttached)","_updateIcon(theme, isAttached)","_srcChanged(src, isAttached)","_iconChanged(icon, isAttached)"],_DEFAULT_ICONSET:"icons",_iconChanged:function(b){b=(b||"").split(":");this._iconName=b.pop();this._iconsetName=b.pop()||this._DEFAULT_ICONSET;this._updateIcon()},_srcChanged:function(){this._updateIcon()},
_usesIconset:function(){return this.icon||!this.src},_updateIcon:function(){this._usesIconset()?(this._img&&this._img.parentNode&&Polymer.dom(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.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,Polymer.dom(this.root).appendChild(this._img))}});

//# sourceURL=build://iron-a11y-announcer/iron-a11y-announcer.html.js
(function(){Polymer.IronA11yAnnouncer=function(){};Polymer.IronA11yAnnouncer=Polymer({is:"iron-a11y-announcer",properties:{mode:{type:String,value:"polite"},_text:{type:String,value:""}},created:function(){Polymer.IronA11yAnnouncer.instance||(Polymer.IronA11yAnnouncer.instance=this);document.body.addEventListener("iron-announce",this._onIronAnnounce.bind(this))},announce:function(b){this._text="";this.async(function(){this._text=b},100)},_onIronAnnounce:function(b){b.detail&&b.detail.text&&this.announce(b.detail.text)}});
Polymer.IronA11yAnnouncer.instance=null;Polymer.IronA11yAnnouncer.requestAvailability=function(){Polymer.IronA11yAnnouncer.instance||(Polymer.IronA11yAnnouncer.instance=document.createElement("iron-a11y-announcer"));document.body.appendChild(Polymer.IronA11yAnnouncer.instance)}})();

//# sourceURL=build://iron-input/iron-input.html.js
Polymer({is:"iron-input",behaviors:[Polymer.IronValidatableBehavior],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(){Polymer.IronA11yAnnouncer.requestAvailability();this._previousValidInput="";this._patternAlreadyChecked=!1},attached:function(){this._observer=
Polymer.dom(this).observeNodes(function(){this._initSlottedInput()}.bind(this))},detached:function(){this._observer&&(Polymer.dom(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(){if(this.allowedPattern)var b=new RegExp(this.allowedPattern);
else switch(this.inputElement.type){case "number":b=/[0-9.,e-]/}return b},_bindValueChanged:function(b,d){d&&(void 0===b?d.value=null:b!==d.value&&(this.inputElement.value=b),this.autoValidate&&this.validate(),this.fire("bind-value-changed",{value:b}))},_onInput:function(){!this.allowedPattern||this._patternAlreadyChecked||this._checkPatternValidity()||(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(b){var d=19==b.keyCode||20==b.keyCode||45==b.keyCode||46==b.keyCode||144==b.keyCode||145==b.keyCode||32<b.keyCode&&41>b.keyCode||111<b.keyCode&&124>b.keyCode;return!(8==b.keyCode||9==b.keyCode||13==b.keyCode||27==b.keyCode)&&!(0==b.charCode&&d)},_onKeypress:function(b){if(this.allowedPattern||"number"===this.inputElement.type){var d=this._patternRegExp;if(d&&!(b.metaKey||b.ctrlKey||b.altKey)){this._patternAlreadyChecked=
!0;var f=String.fromCharCode(b.charCode);this._isPrintable(b)&&!d.test(f)&&(b.preventDefault(),this._announceInvalidCharacter("Invalid character "+f+" not entered."))}}},_checkPatternValidity:function(){var b=this._patternRegExp;if(!b)return!0;for(var d=0;d<this.inputElement.value.length;d++)if(!b.test(this.inputElement.value[d]))return!1;return!0},validate:function(){if(!this.inputElement)return this.invalid=!1,!0;var b=this.inputElement.checkValidity();b&&(this.required&&""===this.bindValue?b=!1:
this.hasValidator()&&(b=Polymer.IronValidatableBehavior.validate.call(this,this.bindValue)));this.invalid=!b;this.fire("iron-input-validate");return b},_announceInvalidCharacter:function(b){this.fire("iron-announce",{text:b})},_computeValue:function(b){return b}});

//# sourceURL=build://paper-input/paper-input-behavior.html.js
Polymer.PaperInputHelper={};Polymer.PaperInputHelper.NextLabelID=1;Polymer.PaperInputHelper.NextAddonID=1;Polymer.PaperInputHelper.NextInputID=1;
Polymer.PaperInputBehaviorImpl={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(){this.$||(this.$={});this.$.input||(this._generateInputId(),this.$.input=this.$$("#"+this._inputId));return this.$.input},get _focusableElement(){return this.inputElement},created:function(){this._typesThatHaveText="date datetime datetime-local month time week file".split(" ")},attached:function(){this._updateAriaLabelledBy();
!Polymer.Element&&this.inputElement&&-1!==this._typesThatHaveText.indexOf(this.inputElement.type)&&(this.alwaysFloatLabel=!0)},_appendStringWithSpace:function(b,d){return b?b+" "+d:d},_onAddonAttached:function(b){b=Polymer.dom(b).rootTarget;if(b.id)this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,b.id);else{var d="paper-input-add-on-"+Polymer.PaperInputHelper.NextAddonID++;b.id=d;this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,d)}},validate:function(){return this.inputElement.validate()},
_focusBlurHandler:function(b){Polymer.IronControlState._focusBlurHandler.call(this,b);this.focused&&!this._shiftTabPressed&&this._focusableElement&&this._focusableElement.focus()},_onShiftTabDown:function(){var b=this.getAttribute("tabindex");this._shiftTabPressed=!0;this.setAttribute("tabindex","-1");this.async(function(){this.setAttribute("tabindex",b);this._shiftTabPressed=!1},1)},_handleAutoValidate:function(){this.autoValidate&&this.validate()},updateValueAndPreserveCaret:function(b){try{var d=
this.inputElement.selectionStart;this.value=b;this.inputElement.selectionStart=d;this.inputElement.selectionEnd=d}catch(f){this.value=b}},_computeAlwaysFloatLabel:function(b,d){return d||b},_updateAriaLabelledBy:function(){var b=Polymer.dom(this.root).querySelector("label");if(b){if(b.id)var d=b.id;else d="paper-input-label-"+Polymer.PaperInputHelper.NextLabelID++,b.id=d;this._ariaLabelledBy=d}else this._ariaLabelledBy=""},_generateInputId:function(){this._inputId&&""!==this._inputId||(this._inputId=
"input-"+Polymer.PaperInputHelper.NextInputID++)},_onChange:function(b){this.shadowRoot&&this.fire(b.type,{sourceEvent:b},{node:this,bubbles:b.bubbles,cancelable:b.cancelable})},_autofocusChanged:function(){if(this.autofocus&&this._focusableElement){var b=document.activeElement;b instanceof HTMLElement&&b!==document.body&&b!==document.documentElement||this._focusableElement.focus()}}};Polymer.PaperInputBehavior=[Polymer.IronControlState,Polymer.IronA11yKeysBehavior,Polymer.PaperInputBehaviorImpl];

//# sourceURL=build://paper-input/paper-input-addon-behavior.html.js
Polymer.PaperInputAddonBehavior={attached:function(){this.fire("addon-attached")},update:function(){}};

//# sourceURL=build://paper-input/paper-input-char-counter.html.js
Polymer({is:"paper-input-char-counter",behaviors:[Polymer.PaperInputAddonBehavior],properties:{_charCounterStr:{type:String,value:"0"}},update:function(b){if(b.inputElement){b.value=b.value||"";var d=b.value.toString().length.toString();b.inputElement.hasAttribute("maxlength")&&(d+="/"+b.inputElement.getAttribute("maxlength"));this._charCounterStr=d}}});

//# sourceURL=build://paper-input/paper-input-container.html.js
Polymer({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 Polymer.CaseMap.dashToCamelCase(this.attrForValue)},get _inputElement(){return Polymer.dom(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(b){this._addons||(this._addons=[]);b=b.target;-1===this._addons.indexOf(b)&&(this._addons.push(b),this.isAttached&&this._handleValue(this._inputElement))},_onFocus:function(){this._setFocused(!0)},_onBlur:function(){this._setFocused(!1);this._handleValueAndAutoValidate(this._inputElement)},_onInput:function(b){this._handleValueAndAutoValidate(b.target)},_onValueChanged:function(b){var d=
b.target;if(this.__isFirstValueUpdate&&(this.__isFirstValueUpdate=!1,void 0===d.value||""===d.value))return;this._handleValueAndAutoValidate(b.target)},_handleValue:function(b){var d=this._inputElementValue;d||0===d||"number"===b.type&&!b.checkValidity()?this._inputHasContent=!0:this._inputHasContent=!1;this.updateAddons({inputElement:b,value:d,invalid:this.invalid})},_handleValueAndAutoValidate:function(b){this.autoValidate&&b&&(this.invalid=!(b.validate?b.validate(this._inputElementValue):b.checkValidity()));
this._handleValue(b)},_onIronInputValidate:function(){this.invalid=this._inputElement.invalid},_invalidChanged:function(){this._addons&&this.updateAddons({invalid:this.invalid})},updateAddons:function(b){for(var d,f=0;d=this._addons[f];f++)d.update(b)},_computeInputContentClass:function(b,d,f,h,k){var t="input-content";b?(k&&(t+=" label-is-hidden"),h&&(t+=" is-invalid")):(b=this.querySelector("label"),d||k?(t+=" label-is-floating",this.$.labelAndInputContainer.style.position="static",h?t+=" is-invalid":
f&&(t+=" label-is-highlighted")):(b&&(this.$.labelAndInputContainer.style.position="relative"),h&&(t+=" is-invalid")));f&&(t+=" focused");return t},_computeUnderlineClass:function(b,d){var f="underline";d?f+=" is-invalid":b&&(f+=" is-highlighted");return f},_computeAddOnContentClass:function(b,d){var f="add-on-content";d?f+=" is-invalid":b&&(f+=" is-highlighted");return f}});

//# sourceURL=build://paper-input/paper-input-error.html.js
Polymer({is:"paper-input-error",behaviors:[Polymer.PaperInputAddonBehavior],properties:{invalid:{readOnly:!0,reflectToAttribute:!0,type:Boolean}},update:function(b){this._setInvalid(b.invalid)}});

//# sourceURL=build://paper-input/paper-input.html.js
Polymer({is:"paper-input",behaviors:[Polymer.PaperInputBehavior,Polymer.IronFormElementBehavior],properties:{value:{type:String}},beforeRegister:function(){var b="function"==typeof document.createElement("iron-input")._initSlottedInput?"v1":"v0",d=Polymer.DomModule.import("paper-input","template");b=Polymer.DomModule.import("paper-input","template#"+b);(d=d.content.querySelector("#template-placeholder"))&&d.parentNode.replaceChild(b.content,d)},get _focusableElement(){return Polymer.Element?this.inputElement._inputElement:
this.inputElement},listeners:{"iron-input-ready":"_onIronInputReady"},_onIronInputReady:function(){this.$.nativeInput||(this.$.nativeInput=this.$$("input"));this.inputElement&&-1!==this._typesThatHaveText.indexOf(this.$.nativeInput.type)&&(this.alwaysFloatLabel=!0);this.inputElement.bindValue&&this.$.container._handleValueAndAutoValidate(this.inputElement)}});

//# sourceURL=build://iron-fit-behavior/iron-fit-behavior.html.js
Polymer.IronFitBehavior={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},_fitInfo:{type:Object}},get _fitWidth(){return this.fitInto===window?this.fitInto.innerWidth:this.fitInto.getBoundingClientRect().width},
get _fitHeight(){return this.fitInto===window?this.fitInto.innerHeight:this.fitInto.getBoundingClientRect().height},get _fitLeft(){return this.fitInto===window?0:this.fitInto.getBoundingClientRect().left},get _fitTop(){return this.fitInto===window?0:this.fitInto.getBoundingClientRect().top},get _defaultPositionTarget(){var b=Polymer.dom(this).parentNode;b&&b.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&(b=b.host);return b},get _localeHorizontalAlign(){if(this._isRTL){if("right"===this.horizontalAlign)return"left";
if("left"===this.horizontalAlign)return"right"}return this.horizontalAlign},get __shouldPosition(){return(this.horizontalAlign||this.verticalAlign)&&this.positionTarget},attached:function(){"undefined"===typeof this._isRTL&&(this._isRTL="rtl"==window.getComputedStyle(this).direction);this.positionTarget=this.positionTarget||this._defaultPositionTarget;this.autoFitOnAttach&&("none"===window.getComputedStyle(this).display?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 b=window.getComputedStyle(this),d=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:"auto"!==b.top?"top":"auto"!==b.bottom?"bottom":null,horizontally:"auto"!==b.left?"left":"auto"!==b.right?"right":null},sizedBy:{height:"none"!==d.maxHeight,width:"none"!==d.maxWidth,minWidth:parseInt(d.minWidth,10)||0,minHeight:parseInt(d.minHeight,10)||0},margin:{top:parseInt(b.marginTop,10)||0,right:parseInt(b.marginRight,10)||0,bottom:parseInt(b.marginBottom,10)||0,left:parseInt(b.marginLeft,10)||0}}}},resetFit:function(){var b=
this._fitInfo||{},d;for(d in b.sizerInlineStyle)this.sizingTarget.style[d]=b.sizerInlineStyle[d];for(d in b.inlineStyle)this.style[d]=b.inlineStyle[d];this._fitInfo=null},refit:function(){var b=this.sizingTarget.scrollLeft,d=this.sizingTarget.scrollTop;this.resetFit();this.fit();this.sizingTarget.scrollLeft=b;this.sizingTarget.scrollTop=d},position:function(){if(this.__shouldPosition){this._discoverInfo();this.style.position="fixed";this.sizingTarget.style.boxSizing="border-box";this.style.left="0px";
this.style.top="0px";var b=this.getBoundingClientRect(),d=this.__getNormalizedRect(this.positionTarget),f=this.__getNormalizedRect(this.fitInto),h=this._fitInfo.margin,k=this.__getPosition(this._localeHorizontalAlign,this.verticalAlign,{width:b.width+h.left+h.right,height:b.height+h.top+h.bottom},b,d,f);d=k.left+h.left;k=k.top+h.top;var t=Math.min(f.right-h.right,d+b.width),l=Math.min(f.bottom-h.bottom,k+b.height);d=Math.max(f.left+h.left,Math.min(d,t-this._fitInfo.sizedBy.minWidth));k=Math.max(f.top+
h.top,Math.min(k,l-this._fitInfo.sizedBy.minHeight));this.sizingTarget.style.maxWidth=Math.max(t-d,this._fitInfo.sizedBy.minWidth)+"px";this.sizingTarget.style.maxHeight=Math.max(l-k,this._fitInfo.sizedBy.minHeight)+"px";this.style.left=d-b.left+"px";this.style.top=k-b.top+"px"}},constrain:function(){if(!this.__shouldPosition){this._discoverInfo();var b=this._fitInfo;b.positionedBy.vertically||(this.style.position="fixed",this.style.top="0px");b.positionedBy.horizontally||(this.style.position="fixed",
this.style.left="0px");this.sizingTarget.style.boxSizing="border-box";var d=this.getBoundingClientRect();b.sizedBy.height||this.__sizeDimension(d,b.positionedBy.vertically,"top","bottom","Height");b.sizedBy.width||this.__sizeDimension(d,b.positionedBy.horizontally,"left","right","Width")}},_sizeDimension:function(b,d,f,h,k){this.__sizeDimension(b,d,f,h,k)},__sizeDimension:function(b,d,f,h,k){var t=this._fitInfo,l=this.__getNormalizedRect(this.fitInto);l="Width"===k?l.width:l.height;d=d===h;var p=
"offset"+k;this.sizingTarget.style["max"+k]=l-t.margin[d?f:h]-(d?l-b[h]:b[f])-(this[p]-this.sizingTarget[p])+"px"},center:function(){if(!this.__shouldPosition){this._discoverInfo();var b=this._fitInfo.positionedBy;if(!b.vertically||!b.horizontally){this.style.position="fixed";b.vertically||(this.style.top="0px");b.horizontally||(this.style.left="0px");var d=this.getBoundingClientRect(),f=this.__getNormalizedRect(this.fitInto);b.vertically||(this.style.top=f.top-d.top+(f.height-d.height)/2+"px");b.horizontally||
(this.style.left=f.left-d.left+(f.width-d.width)/2+"px")}}},__getNormalizedRect:function(b){return b===document.documentElement||b===window?{top:0,left:0,width:window.innerWidth,height:window.innerHeight,right:window.innerWidth,bottom:window.innerHeight}:b.getBoundingClientRect()},__getOffscreenArea:function(b,d,f){return Math.abs(Math.min(0,b.top)+Math.min(0,f.bottom-(b.top+d.height)))*d.width+Math.abs(Math.min(0,b.left)+Math.min(0,f.right-(b.left+d.width)))*d.height},__getPosition:function(b,d,
f,h,k,t){var l=[{verticalAlign:"top",horizontalAlign:"left",top:k.top+this.verticalOffset,left:k.left+this.horizontalOffset},{verticalAlign:"top",horizontalAlign:"right",top:k.top+this.verticalOffset,left:k.right-f.width-this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"left",top:k.bottom-f.height-this.verticalOffset,left:k.left+this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"right",top:k.bottom-f.height-this.verticalOffset,left:k.right-f.width-this.horizontalOffset}];
if(this.noOverlap){for(var p=0,m=l.length;p<m;p++){var n={},q;for(q in l[p])n[q]=l[p][q];l.push(n)}l[0].top=l[1].top+=k.height;l[2].top=l[3].top-=k.height;l[4].left=l[6].left+=k.width;l[5].left=l[7].left-=k.width}d="auto"===d?null:d;b="auto"===b?null:b;b&&"center"!==b||(l.push({verticalAlign:"top",horizontalAlign:"center",top:k.top+this.verticalOffset+(this.noOverlap?k.height:0),left:k.left-h.width/2+k.width/2+this.horizontalOffset}),l.push({verticalAlign:"bottom",horizontalAlign:"center",top:k.bottom-
f.height-this.verticalOffset-(this.noOverlap?k.height:0),left:k.left-h.width/2+k.width/2+this.horizontalOffset}));d&&"middle"!==d||(l.push({verticalAlign:"middle",horizontalAlign:"left",top:k.top-h.height/2+k.height/2+this.verticalOffset,left:k.left+this.horizontalOffset+(this.noOverlap?k.width:0)}),l.push({verticalAlign:"middle",horizontalAlign:"right",top:k.top-h.height/2+k.height/2+this.verticalOffset,left:k.right-f.width-this.horizontalOffset-(this.noOverlap?k.width:0)}));"middle"===d&&"center"===
b&&l.push({verticalAlign:"middle",horizontalAlign:"center",top:k.top-h.height/2+k.height/2+this.verticalOffset,left:k.left-h.width/2+k.width/2+this.horizontalOffset});for(p=0;p<l.length;p++){h=l[p];k=h.verticalAlign===d;m=h.horizontalAlign===b;if(!this.dynamicAlign&&!this.noOverlap&&k&&m){var u=h;break}n=(!d||k)&&(!b||m);if(this.dynamicAlign||n){h.offscreenArea=this.__getOffscreenArea(h,f,t);if(0===h.offscreenArea&&n){u=h;break}u=u||h;n=h.offscreenArea-u.offscreenArea;if(0>n||0===n&&(k||m))u=h}}return u}};

//# sourceURL=build://iron-resizable-behavior/iron-resizable-behavior.html.js
Polymer.IronResizableBehavior={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)},attached:function(){this._requestResizeNotifications()},detached:function(){this._parentResizable?this._parentResizable.stopResizeNotificationsFor(this):window.removeEventListener("resize",
this._boundNotifyResize);this._parentResizable=null},notifyResize:function(){this.isAttached&&(this._interestedResizables.forEach(function(b){this.resizerShouldNotify(b)&&this._notifyDescendant(b)},this),this._fireResize())},assignParentResizable:function(b){this._parentResizable=b},stopResizeNotificationsFor:function(b){var d=this._interestedResizables.indexOf(b);-1<d&&(this._interestedResizables.splice(d,1),this.unlisten(b,"iron-resize","_onDescendantIronResize"))},resizerShouldNotify:function(){return!0},
_onDescendantIronResize:function(b){this._notifyingDescendant?b.stopPropagation():Polymer.Settings.useShadow||this._fireResize()},_fireResize:function(){this.fire("iron-resize",null,{node:this,bubbles:!1})},_onIronRequestResizeNotifications:function(b){var d=Polymer.dom(b).rootTarget;d!==this&&(-1===this._interestedResizables.indexOf(d)&&(this._interestedResizables.push(d),this.listen(d,"iron-resize","_onDescendantIronResize")),d.assignParentResizable(this),this._notifyDescendant(d),b.stopPropagation())},
_parentResizableChanged:function(b){b&&window.removeEventListener("resize",this._boundNotifyResize)},_notifyDescendant:function(b){this.isAttached&&(this._notifyingDescendant=!0,b.notifyResize(),this._notifyingDescendant=!1)},_requestResizeNotifications:function(){if(this.isAttached)if("loading"===document.readyState){var b=this._requestResizeNotifications.bind(this);document.addEventListener("readystatechange",function f(){document.removeEventListener("readystatechange",f);b()})}else this.fire("iron-request-resize-notifications",
null,{node:this,bubbles:!0,cancelable:!0}),this._parentResizable||(window.addEventListener("resize",this._boundNotifyResize),this.notifyResize())}};

//# sourceURL=build://iron-overlay-behavior/iron-overlay-backdrop.html.js
(function(){Polymer({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&&Polymer.dom(document.body).appendChild(this)},open:function(){this.opened=!0},close:function(){this.opened=!1},complete:function(){this.opened||this.parentNode!==
document.body||Polymer.dom(this.parentNode).removeChild(this)},_onTransitionend:function(b){b&&b.target===this&&this.complete()},_openedChanged:function(b){b?this.prepare():(b=window.getComputedStyle(this),"0s"!==b.transitionDuration&&0!=b.opacity||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)))}})})();

//# sourceURL=build://iron-overlay-behavior/iron-overlay-manager.html.js
Polymer.IronOverlayManagerClass=function(){this._overlays=[];this._minimumZ=101;this._backdropElement=null;Polymer.Gestures.add(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)};
Polymer.IronOverlayManagerClass.prototype={constructor:Polymer.IronOverlayManagerClass,get backdropElement(){this._backdropElement||(this._backdropElement=document.createElement("iron-overlay-backdrop"));return this._backdropElement},get deepActiveElement(){var b=document.activeElement;b&&!1!==b instanceof Element||(b=document.body);for(;b.root&&Polymer.dom(b.root).activeElement;)b=Polymer.dom(b.root).activeElement;return b},_bringOverlayAtIndexToFront:function(b){var d=this._overlays[b];if(d){var f=
this._overlays.length-1,h=this._overlays[f];h&&this._shouldBeBehindOverlay(d,h)&&f--;if(!(b>=f)){h=Math.max(this.currentOverlayZ(),this._minimumZ);for(this._getZ(d)<=h&&this._applyOverlayZ(d,h);b<f;)this._overlays[b]=this._overlays[b+1],b++;this._overlays[f]=d}}},addOrRemoveOverlay:function(b){b.opened?this.addOverlay(b):this.removeOverlay(b)},addOverlay:function(b){var d=this._overlays.indexOf(b);if(0<=d)this._bringOverlayAtIndexToFront(d);else{d=this._overlays.length;var f=this._overlays[d-1],h=
Math.max(this._getZ(f),this._minimumZ),k=this._getZ(b);f&&this._shouldBeBehindOverlay(b,f)&&(this._applyOverlayZ(f,h),d--,h=Math.max(this._getZ(this._overlays[d-1]),this._minimumZ));k<=h&&this._applyOverlayZ(b,h);this._overlays.splice(d,0,b)}this.trackBackdrop()},removeOverlay:function(b){b=this._overlays.indexOf(b);-1!==b&&(this._overlays.splice(b,1),this.trackBackdrop())},currentOverlay:function(){return this._overlays[this._overlays.length-1]},currentOverlayZ:function(){return this._getZ(this.currentOverlay())},
ensureMinimumZ:function(b){this._minimumZ=Math.max(this._minimumZ,b)},focusOverlay:function(){var b=this.currentOverlay();b&&b._applyFocus()},trackBackdrop:function(){var b=this._overlayWithBackdrop();if(b||this._backdropElement)this.backdropElement.style.zIndex=this._getZ(b)-1,this.backdropElement.opened=!!b,this.backdropElement.prepare()},getBackdrops:function(){for(var b=[],d=0;d<this._overlays.length;d++)this._overlays[d].withBackdrop&&b.push(this._overlays[d]);return b},backdropZ:function(){return this._getZ(this._overlayWithBackdrop())-
1},_overlayWithBackdrop:function(){for(var b=this._overlays.length-1;0<=b;b--)if(this._overlays[b].withBackdrop)return this._overlays[b]},_getZ:function(b){var d=this._minimumZ;b&&(b=Number(b.style.zIndex||window.getComputedStyle(b).zIndex),b===b&&(d=b));return d},_setZ:function(b,d){b.style.zIndex=d},_applyOverlayZ:function(b,d){this._setZ(b,d+2)},_overlayInPath:function(b){b=b||[];for(var d=0;d<b.length;d++)if(b[d]._manager===this)return b[d]},_onCaptureClick:function(b){var d=this._overlays.length-
1;if(-1!==d)for(var f=Polymer.dom(b).path,h;(h=this._overlays[d])&&this._overlayInPath(f)!==h;)if(h._onCaptureClick(b),h.allowClickThrough)d--;else break},_onCaptureFocus:function(b){var d=this.currentOverlay();d&&d._onCaptureFocus(b)},_onCaptureKeyDown:function(b){var d=this.currentOverlay();d&&(Polymer.IronA11yKeysBehavior.keyboardEventMatchesKeys(b,"esc")?d._onCaptureEsc(b):Polymer.IronA11yKeysBehavior.keyboardEventMatchesKeys(b,"tab")&&d._onCaptureTab(b))},_shouldBeBehindOverlay:function(b,d){return!b.alwaysOnTop&&
d.alwaysOnTop}};Polymer.IronOverlayManager=new Polymer.IronOverlayManagerClass;

//# sourceURL=build://iron-overlay-behavior/iron-scroll-manager.html.js
(function(){var b=0,d=0,f=null,h=[],k=["wheel","mousewheel","DOMMouseScroll","touchstart","touchmove"];Polymer.IronScrollManager={get currentLockingElement(){return this._lockingElements[this._lockingElements.length-1]},elementIsScrollLocked:function(t){var l=this.currentLockingElement;if(void 0===l)return!1;if(this._hasCachedLockedElement(t))return!0;if(this._hasCachedUnlockedElement(t))return!1;(l=!!l&&l!==t&&!this._composedTreeContains(l,t))?this._lockedElementCache.push(t):this._unlockedElementCache.push(t);
return l},pushScrollLock:function(t){0<=this._lockingElements.indexOf(t)||(0===this._lockingElements.length&&this._lockScrollInteractions(),this._lockingElements.push(t),this._lockedElementCache=[],this._unlockedElementCache=[])},removeScrollLock:function(t){t=this._lockingElements.indexOf(t);-1!==t&&(this._lockingElements.splice(t,1),this._lockedElementCache=[],this._unlockedElementCache=[],0===this._lockingElements.length&&this._unlockScrollInteractions())},_lockingElements:[],_lockedElementCache:null,
_unlockedElementCache:null,_hasCachedLockedElement:function(t){return-1<this._lockedElementCache.indexOf(t)},_hasCachedUnlockedElement:function(t){return-1<this._unlockedElementCache.indexOf(t)},_composedTreeContains:function(t,l){var p,m;if(t.contains(l))return!0;t=Polymer.dom(t).querySelectorAll("content,slot");for(p=0;p<t.length;++p){var n=Polymer.dom(t[p]).getDistributedNodes();for(m=0;m<n.length;++m)if(n[m].nodeType===Node.ELEMENT_NODE&&this._composedTreeContains(n[m],l))return!0}return!1},_scrollInteractionHandler:function(t){t.cancelable&&
this._shouldPreventScrolling(t)&&t.preventDefault();t.targetTouches&&(t=t.targetTouches[0],b=t.pageX,d=t.pageY)},_lockScrollInteractions:function(){this._boundScrollHandler=this._boundScrollHandler||this._scrollInteractionHandler.bind(this);for(var t=0,l=k.length;t<l;t++)document.addEventListener(k[t],this._boundScrollHandler,{capture:!0,passive:!1})},_unlockScrollInteractions:function(){for(var t=0,l=k.length;t<l;t++)document.removeEventListener(k[t],this._boundScrollHandler,{capture:!0,passive:!1})},
_shouldPreventScrolling:function(t){var l=Polymer.dom(t).rootTarget;"touchmove"!==t.type&&f!==l&&(f=l,h=this._getScrollableNodes(Polymer.dom(t).path));if(!h.length)return!0;if("touchstart"===t.type)return!1;t=this._getScrollInfo(t);return!this._getScrollingNode(h,t.deltaX,t.deltaY)},_getScrollableNodes:function(t){for(var l=[],p=t.indexOf(this.currentLockingElement),m=0;m<=p;m++)if(t[m].nodeType===Node.ELEMENT_NODE){var n=t[m],q=n.style;"scroll"!==q.overflow&&"auto"!==q.overflow&&(q=window.getComputedStyle(n));
"scroll"!==q.overflow&&"auto"!==q.overflow||l.push(n)}return l},_getScrollingNode:function(t,l,p){if(l||p)for(var m=Math.abs(p)>=Math.abs(l),n=0;n<t.length;n++){var q=t[n];if(m?0>p?0<q.scrollTop:q.scrollTop<q.scrollHeight-q.clientHeight:0>l?0<q.scrollLeft:q.scrollLeft<q.scrollWidth-q.clientWidth)return q}},_getScrollInfo:function(t){var l={deltaX:t.deltaX,deltaY:t.deltaY};"deltaX"in t||("wheelDeltaX"in t&&"wheelDeltaY"in t?(l.deltaX=-t.wheelDeltaX,l.deltaY=-t.wheelDeltaY):"wheelDelta"in t?(l.deltaX=
0,l.deltaY=-t.wheelDelta):"axis"in t?(l.deltaX=1===t.axis?t.detail:0,l.deltaY=2===t.axis?t.detail:0):t.targetTouches&&(t=t.targetTouches[0],l.deltaX=b-t.pageX,l.deltaY=d-t.pageY));return l}}})();

//# sourceURL=build://iron-overlay-behavior/iron-focusables-helper.html.js
(function(){var b=Element.prototype,d=b.matches||b.matchesSelector||b.mozMatchesSelector||b.msMatchesSelector||b.oMatchesSelector||b.webkitMatchesSelector;Polymer.IronFocusablesHelper={getTabbableNodes:function(f){var h=[];return this._collectTabbableNodes(f,h)?this._sortByTabIndex(h):h},isFocusable:function(f){return d.call(f,"input, select, textarea, button, object")?d.call(f,":not([disabled])"):d.call(f,"a[href], area[href], iframe, [tabindex], [contentEditable]")},isTabbable:function(f){return this.isFocusable(f)&&
d.call(f,':not([tabindex\x3d"-1"])')&&this._isVisible(f)},_normalizedTabIndex:function(f){return this.isFocusable(f)?(f=f.getAttribute("tabindex")||0,Number(f)):-1},_collectTabbableNodes:function(f,h){if(f.nodeType!==Node.ELEMENT_NODE||!this._isVisible(f))return!1;var k=this._normalizedTabIndex(f),t=0<k;0<=k&&h.push(f);f="content"===f.localName||"slot"===f.localName?Polymer.dom(f).getDistributedNodes():Polymer.dom(f.root||f).children;for(k=0;k<f.length;k++)t=this._collectTabbableNodes(f[k],h)||t;
return t},_isVisible:function(f){var h=f.style;return"hidden"!==h.visibility&&"none"!==h.display?(h=window.getComputedStyle(f),"hidden"!==h.visibility&&"none"!==h.display):!1},_sortByTabIndex:function(f){var h=f.length;if(2>h)return f;var k=Math.ceil(h/2);h=this._sortByTabIndex(f.slice(0,k));f=this._sortByTabIndex(f.slice(k));return this._mergeSortByTabIndex(h,f)},_mergeSortByTabIndex:function(f,h){for(var k=[];0<f.length&&0<h.length;)this._hasLowerTabOrder(f[0],h[0])?k.push(h.shift()):k.push(f.shift());
return k.concat(f,h)},_hasLowerTabOrder:function(f,h){f=Math.max(f.tabIndex,0);h=Math.max(h.tabIndex,0);return 0===f||0===h?h>f:f>h}}})();

//# sourceURL=build://iron-overlay-behavior/iron-overlay-behavior.html.js
(function(){Polymer.IronOverlayBehaviorImpl={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:Polymer.IronOverlayManager},_focusedChild:{type:Object}},listeners:{"iron-resize":"_onIronResize"},observers:["__updateScrollObservers(isAttached, opened, scrollAction)"],get backdropElement(){return this._manager.backdropElement},get _focusNode(){return this._focusedChild||Polymer.dom(this).querySelector("[autofocus]")||this},get _focusableNodes(){return Polymer.IronFocusablesHelper.getTabbableNodes(this)},ready:function(){this.__shouldRemoveTabIndex=
this.__isAnimating=!1;this.__firstFocusableNode=this.__lastFocusableNode=null;this.__rafs={};this.__scrollTop=this.__scrollLeft=this.__restoreFocusNode=null;this.__onCaptureScroll=this.__onCaptureScroll.bind(this);this.__rootNodes=null;this._ensureSetup()},attached:function(){this.opened&&this._openedChanged(this.opened);this._observer=Polymer.dom(this).observeNodes(this._onNodesChange)},detached:function(){Polymer.dom(this).unobserveNodes(this._observer);this._observer=null;for(var b in this.__rafs)null!==
this.__rafs[b]&&cancelAnimationFrame(this.__rafs[b]);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(b){this.fire("iron-overlay-canceled",b,{cancelable:!0}).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(b){b?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{this._focusNode.blur();this._focusedChild=null;if(this.restoreFocusOnClose&&
this.__restoreFocusNode){var b=this._manager.deepActiveElement;(b===document.body||Polymer.dom(this).deepContains(b))&&this.__restoreFocusNode.focus()}this.__restoreFocusNode=null;(b=this._manager.currentOverlay())&&this!==b&&b._applyFocus()}},_onCaptureClick:function(b){this.noCancelOnOutsideClick||this.cancel(b)},_onCaptureFocus:function(b){if(this.withBackdrop){var d=Polymer.dom(b).path;-1===d.indexOf(this)?(b.stopPropagation(),this._applyFocus()):this._focusedChild=d[0]}},_onCaptureEsc:function(b){this.noCancelOnEscKey||
this.cancel(b)},_onCaptureTab:function(b){if(this.withBackdrop){this.__ensureFirstLastFocusables();var d=b.shiftKey,f=d?this.__firstFocusableNode:this.__lastFocusableNode;d=d?this.__lastFocusableNode:this.__firstFocusableNode;if(f===d)f=!0;else{var h=this._manager.deepActiveElement;f=h===f||h===this}f&&(b.preventDefault(),this._focusedChild=d,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(){if(!this.__firstFocusableNode||!this.__lastFocusableNode){var b=this._focusableNodes;this.__firstFocusableNode=b[0];this.__lastFocusableNode=b[b.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(b,d){var f=this.__rafs;
null!==f[b]&&cancelAnimationFrame(f[b]);f[b]=requestAnimationFrame(function(){f[b]=null;d.call(this)}.bind(this))},__updateScrollObservers:function(b,d,f){b&&d&&this.__isValidScrollAction(f)?("lock"===f&&(this.__saveScrollPosition(),Polymer.IronScrollManager.pushScrollLock(this)),this.__addScrollListeners()):(Polymer.IronScrollManager.removeScrollLock(this),this.__removeScrollListeners())},__addScrollListeners:function(){if(!this.__rootNodes){this.__rootNodes=[];if(Polymer.Settings.useShadow)for(var b=
this;b;)b.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&b.host&&this.__rootNodes.push(b),b=b.host||b.assignedSlot||b.parentNode;this.__rootNodes.push(document)}this.__rootNodes.forEach(function(d){d.addEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})},this)},__removeScrollListeners:function(){this.__rootNodes&&this.__rootNodes.forEach(function(b){b.removeEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})},this);this.isAttached||(this.__rootNodes=null)},__isValidScrollAction:function(b){return"lock"===
b||"refit"===b||"cancel"===b},__onCaptureScroll:function(b){if(!(this.__isAnimating||0<=Polymer.dom(b).path.indexOf(this)))switch(this.scrollAction){case "lock":this.__restoreScrollPosition();break;case "refit":this.__deraf("refit",this.refit);break;case "cancel":this.cancel(b)}},__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)}};Polymer.IronOverlayBehavior=[Polymer.IronFitBehavior,Polymer.IronResizableBehavior,
Polymer.IronOverlayBehaviorImpl]})();

//# sourceURL=build://neon-animation/neon-animatable-behavior.html.js
Polymer.NeonAnimatableBehavior={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(b,
d){for(var f in d)b[f]=d[f]},_cloneConfig:function(b){var d={isClone:!0};this._copyProperties(d,b);return d},_getAnimationConfigRecursive:function(b,d,f){if(this.animationConfig)if(this.animationConfig.value&&"function"===typeof this.animationConfig.value)this._warn(this._logf("playAnimation","Please put 'animationConfig' inside of your components 'properties' object instead of outside of it."));else{var h=b?this.animationConfig[b]:this.animationConfig;Array.isArray(h)||(h=[h]);if(h)for(var k,t=0;k=
h[t];t++)if(k.animatable)k.animatable._getAnimationConfigRecursive(k.type||b,d,f);else if(k.id){var l=d[k.id];l?(l.isClone||(d[k.id]=this._cloneConfig(l),l=d[k.id]),this._copyProperties(l,k)):d[k.id]=k}else f.push(k)}},getAnimationConfig:function(b){var d={},f=[];this._getAnimationConfigRecursive(b,d,f);for(var h in d)f.push(d[h]);return f}};

//# sourceURL=build://neon-animation/neon-animation-runner-behavior.html.js
Polymer.NeonAnimationRunnerBehaviorImpl={_configureAnimations:function(b){var d=[],f=[];if(0<b.length)for(var h,k=0;h=b[k];k++){var t=document.createElement(h.name);if(t.isNeonAnimation){var l=null;t.configure||(t.configure=function(){return null});l=t.configure(h);f.push({result:l,config:h})}else console.warn(this.is+":",h.name,"not found!")}for(b=0;b<f.length;b++){l=f[b].result;h=f[b].config;try{"function"!=typeof l.cancel&&(l=document.timeline.play(l))}catch(p){l=null,console.warn("Couldnt play",
"(",h.name,").",p)}l&&d.push({neonAnimation:t,config:h,animation:l})}return d},_shouldComplete:function(b){for(var d=!0,f=0;f<b.length;f++)if("finished"!=b[f].animation.playState){d=!1;break}return d},_complete:function(b){for(var d=0;d<b.length;d++)b[d].neonAnimation.complete(b[d].config);for(d=0;d<b.length;d++)b[d].animation.cancel()},playAnimation:function(b,d){var f=this.getAnimationConfig(b);if(f){this._active=this._active||{};this._active[b]&&(this._complete(this._active[b]),delete this._active[b]);
var h=this._configureAnimations(f);if(0==h.length)this.fire("neon-animation-finish",d,{bubbles:!1});else for(this._active[b]=h,f=0;f<h.length;f++)h[f].animation.onfinish=function(){this._shouldComplete(h)&&(this._complete(h),delete this._active[b],this.fire("neon-animation-finish",d,{bubbles:!1}))}.bind(this)}},cancelAnimation:function(){for(var b in this._active){var d=this._active[b],f;for(f in d)d[f].animation.cancel()}this._active={}}};
Polymer.NeonAnimationRunnerBehavior=[Polymer.NeonAnimatableBehavior,Polymer.NeonAnimationRunnerBehaviorImpl];

//# sourceURL=build://iron-dropdown/iron-dropdown-scroll-manager.html.js
(function(){Polymer.IronDropdownScrollManager=Polymer.IronScrollManager})();

//# sourceURL=build://iron-dropdown/iron-dropdown.html.js
(function(){Polymer({is:"iron-dropdown",behaviors:[Polymer.IronControlState,Polymer.IronA11yKeysBehavior,Polymer.IronOverlayBehavior,Polymer.NeonAnimationRunnerBehavior],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 b=Polymer.dom(this.$.content).getDistributedNodes(),d=0,f=b.length;d<f;d++)if(b[d].nodeType===Node.ELEMENT_NODE)return b[d]},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(),Polymer.IronOverlayBehaviorImpl._openedChanged.apply(this,arguments))},_renderOpened:function(){!this.noAnimations&&this.animationConfig.open?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("open")):Polymer.IronOverlayBehaviorImpl._renderOpened.apply(this,arguments)},
_renderClosed:function(){!this.noAnimations&&this.animationConfig.close?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("close")):Polymer.IronOverlayBehaviorImpl._renderClosed.apply(this,arguments)},_onNeonAnimationFinish:function(){this.$.contentWrapper.classList.remove("animating");this.opened?this._finishRenderOpened():this._finishRenderClosed()},_updateAnimationConfig:function(){for(var b=this.containedElement,d=[].concat(this.openAnimationConfig||[]).concat(this.closeAnimationConfig||
[]),f=0;f<d.length;f++)d[f].node=b;this.animationConfig={open:this.openAnimationConfig,close:this.closeAnimationConfig}},_updateOverlayPosition:function(){this.isAttached&&this.notifyResize()},_allowOutsideScrollChanged:function(b){this._readied&&(b?this.scrollAction&&"lock"!==this.scrollAction||(this.scrollAction="refit"):this.scrollAction="lock")},_applyFocus:function(){var b=this.focusTarget||this.containedElement;b&&this.opened&&!this.noAutoFocus?b.focus():Polymer.IronOverlayBehaviorImpl._applyFocus.apply(this,
arguments)}})})();

//# sourceURL=build://neon-animation/neon-animation-behavior.html.js
Polymer.NeonAnimationBehavior={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(b){if(b.timing)for(var d in b.timing)this.animationTiming[d]=b.timing[d];return this.animationTiming},setPrefixedProperty:function(b,d,f){for(var h=
{transform:["webkitTransform"],transformOrigin:["mozTransformOrigin","webkitTransformOrigin"]}[d],k,t=0;k=h[t];t++)b.style[k]=f;b.style[d]=f},complete:function(){}};

//# sourceURL=build://neon-animation/animations/fade-in-animation.html.js
Polymer({is:"fade-in-animation",behaviors:[Polymer.NeonAnimationBehavior],configure:function(b){return this._effect=new KeyframeEffect(b.node,[{opacity:"0"},{opacity:"1"}],this.timingFromConfig(b))}});

//# sourceURL=build://neon-animation/animations/fade-out-animation.html.js
Polymer({is:"fade-out-animation",behaviors:[Polymer.NeonAnimationBehavior],configure:function(b){return this._effect=new KeyframeEffect(b.node,[{opacity:"1"},{opacity:"0"}],this.timingFromConfig(b))}});

//# sourceURL=build://paper-menu-button/paper-menu-button-animations.html.js
Polymer({is:"paper-menu-grow-height-animation",behaviors:[Polymer.NeonAnimationBehavior],configure:function(b){var d=b.node,f=d.getBoundingClientRect().height;return this._effect=new KeyframeEffect(d,[{height:f/2+"px"},{height:f+"px"}],this.timingFromConfig(b))}});Polymer({is:"paper-menu-grow-width-animation",behaviors:[Polymer.NeonAnimationBehavior],configure:function(b){var d=b.node,f=d.getBoundingClientRect().width;return this._effect=new KeyframeEffect(d,[{width:f/2+"px"},{width:f+"px"}],this.timingFromConfig(b))}});
Polymer({is:"paper-menu-shrink-width-animation",behaviors:[Polymer.NeonAnimationBehavior],configure:function(b){var d=b.node,f=d.getBoundingClientRect().width;return this._effect=new KeyframeEffect(d,[{width:f+"px"},{width:f-f/20+"px"}],this.timingFromConfig(b))}});
Polymer({is:"paper-menu-shrink-height-animation",behaviors:[Polymer.NeonAnimationBehavior],configure:function(b){var d=b.node,f=d.getBoundingClientRect().height;this.setPrefixedProperty(d,"transformOrigin","0 0");return this._effect=new KeyframeEffect(d,[{height:f+"px",transform:"translateY(0)"},{height:f/2+"px",transform:"translateY(-20px)"}],this.timingFromConfig(b))}});

//# sourceURL=build://paper-menu-button/paper-menu-button.html.js
(function(){var b={ANIMATION_CUBIC_BEZIER:"cubic-bezier(.3,.95,.5,1)",MAX_ANIMATION_TIME_MS:400};Polymer.PaperMenuButton=function(){};Polymer.PaperMenuButton.prototype.registered=function(){};Polymer.PaperMenuButton.prototype.addOwnKeyBinding=function(){};Polymer.PaperMenuButton.prototype.removeOwnKeyBindings=function(){};Polymer.PaperMenuButton.prototype.keyboardEventMatchesKeys=function(){};Polymer.PaperMenuButton.prototype._collectKeyBindings=function(){};Polymer.PaperMenuButton.prototype._prepKeyBindings=
function(){};Polymer.PaperMenuButton.prototype._addKeyBinding=function(){};Polymer.PaperMenuButton.prototype._resetKeyEventListeners=function(){};Polymer.PaperMenuButton.prototype._listenKeyEventListeners=function(){};Polymer.PaperMenuButton.prototype._unlistenKeyEventListeners=function(){};Polymer.PaperMenuButton.prototype._onKeyBindingEvent=function(){};Polymer.PaperMenuButton.prototype._triggerKeyHandler=function(){};Polymer.PaperMenuButton.prototype._focusBlurHandler=function(d){if(Polymer.Element)this._setFocused("focus"===
d.type);else if(d.target===this)this._setFocused("focus"===d.type);else if(this.__handleEventRetargeting){var f=Polymer.dom(d).localTarget;this.isLightDescendant(f)||this.fire(d.type,{sourceEvent:d},{node:this,bubbles:d.bubbles,cancelable:d.cancelable})}};Polymer.PaperMenuButton.prototype._changedControlState=function(){this._controlStateChanged&&this._controlStateChanged()};Polymer.PaperMenuButton.prototype._setFocused=function(){};Polymer.PaperMenuButton=Polymer({is:"paper-menu-button",behaviors:[Polymer.IronA11yKeysBehavior,
Polymer.IronControlState],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:b.ANIMATION_CUBIC_BEZIER}},{name:"paper-menu-grow-height-animation",timing:{delay:100,duration:275,easing:b.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:b.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},_dropdownContent:{type:Object}},hostAttributes:{role:"group","aria-haspopup":"true"},listeners:{"iron-activate":"_onIronActivate","iron-select":"_onIronSelect"},get contentElement(){for(var d=Polymer.dom(this.$.content).getDistributedNodes(),f=0,h=d.length;f<h;f++)if(d[f].nodeType===Node.ELEMENT_NODE)return d[f]},toggle:function(){this.opened?
this.close():this.open()},open:function(){this.disabled||this.$.dropdown.open()},close:function(){this.$.dropdown.close()},_onIronSelect:function(){this.ignoreSelect||this.close()},_onIronActivate:function(){this.closeOnActivate&&this.close()},_openedChanged:function(d,f){d?(this._dropdownContent=this.contentElement,this.fire("paper-dropdown-open")):null!=f&&this.fire("paper-dropdown-close")},_disabledChanged:function(d){Polymer.IronControlState._disabledChanged.apply(this,arguments);d&&this.opened&&
this.close()},__onIronOverlayCanceled:function(d){var f=this.$.trigger;-1<Polymer.dom(d.detail).path.indexOf(f)&&d.preventDefault()}});Object.keys(b).forEach(function(d){Polymer.PaperMenuButton[d]=b[d]})})();

//# sourceURL=build://iron-iconset-svg/iron-iconset-svg.html.js
Polymer({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 Polymer.IronMeta({type:"iconset",key:null,value:null})},attached:function(){this.style.display="none"},getIconNames:function(){this._icons=this._createIconMap();return Object.keys(this._icons).map(function(b){return this.name+":"+b},this)},applyIcon:function(b,d){this.removeIcon(b);
if(d=this._cloneIcon(d,this.rtlMirroring&&this._targetIsRTL(b))){var f=Polymer.dom(b.root||b);f.insertBefore(d,f.childNodes[0]);return b._svgIcon=d}return null},removeIcon:function(b){b._svgIcon&&(Polymer.dom(b.root||b).removeChild(b._svgIcon),b._svgIcon=null)},_targetIsRTL:function(b){null==this.__targetIsRTL&&(this.useGlobalRtlAttribute?this.__targetIsRTL="rtl"===(document.body&&document.body.hasAttribute("dir")?document.body:document.documentElement).getAttribute("dir"):(b&&b.nodeType!==Node.ELEMENT_NODE&&
(b=b.host),this.__targetIsRTL=b&&"rtl"===window.getComputedStyle(b).direction));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 b=Object.create(null);Polymer.dom(this).querySelectorAll("[id]").forEach(function(d){b[d.id]=d});return b},_cloneIcon:function(b,d){this._icons=this._icons||this._createIconMap();return this._prepareSvgClone(this._icons[b],
this.size,d)},_prepareSvgClone:function(b,d,f){if(b){b=b.cloneNode(!0);var h=document.createElementNS("http://www.w3.org/2000/svg","svg");d=b.getAttribute("viewBox")||"0 0 "+d+" "+d;var k="pointer-events: none; display: block; width: 100%; height: 100%;";f&&b.hasAttribute("mirror-in-rtl")&&(k+="-webkit-transform:scale(-1,1);transform:scale(-1,1);transform-origin:center;");h.setAttribute("viewBox",d);h.setAttribute("preserveAspectRatio","xMidYMid meet");h.setAttribute("focusable","false");h.style.cssText=
k;h.appendChild(b).removeAttribute("id");return h}return null}});

//# sourceURL=build://paper-dropdown-menu/paper-dropdown-menu.html.js
(function(){Polymer({is:"paper-dropdown-menu",behaviors:[Polymer.IronButtonState,Polymer.IronControlState,Polymer.IronFormElementBehavior,Polymer.IronValidatableBehavior],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}},listeners:{tap:"_onTap"},keyBindings:{"up down":"open",esc:"close"},hostAttributes:{role:"combobox","aria-autocomplete":"none","aria-haspopup":"true"},observers:["_selectedItemChanged(selectedItem)"],attached:function(){var b=
this.contentElement;b&&b.selectedItem&&this._setSelectedItem(b.selectedItem)},get contentElement(){for(var b=Polymer.dom(this.$.content).getDistributedNodes(),d=0,f=b.length;d<f;d++)if(b[d].nodeType===Node.ELEMENT_NODE)return b[d]},open:function(){this.$.menuButton.open()},close:function(){this.$.menuButton.close()},_onIronSelect:function(b){this._setSelectedItem(b.detail.item)},_onIronDeselect:function(){this._setSelectedItem(null)},_onTap:function(b){Polymer.Gestures.findOriginalTarget(b)===this&&
this.open()},_selectedItemChanged:function(b){this.value=b=b?b.label||b.getAttribute("label")||b.textContent.trim():"";this._setSelectedItemLabel(b)},_computeMenuVerticalOffset:function(b,d){return d?d:b?-4:8},_getValidity:function(){return this.disabled||!this.required||this.required&&!!this.value},_openedChanged:function(){var b=this.opened?"true":"false",d=this.contentElement;d&&d.setAttribute("aria-expanded",b)}})})();

//# sourceURL=build://iron-selector/iron-selection.html.js
Polymer.IronSelection=function(b){this.selection=[];this.selectCallback=b};
Polymer.IronSelection.prototype={get:function(){return this.multi?this.selection.slice():this.selection[0]},clear:function(b){this.selection.slice().forEach(function(d){(!b||0>b.indexOf(d))&&this.setItemSelected(d,!1)},this)},isSelected:function(b){return 0<=this.selection.indexOf(b)},setItemSelected:function(b,d){if(null!=b&&d!==this.isSelected(b)){if(d)this.selection.push(b);else{var f=this.selection.indexOf(b);0<=f&&this.selection.splice(f,1)}this.selectCallback&&this.selectCallback(b,d)}},select:function(b){this.multi?
this.toggle(b):this.get()!==b&&(this.setItemSelected(this.get(),!1),this.setItemSelected(b,!0))},toggle:function(b){this.setItemSelected(b,!this.isSelected(b))}};

//# sourceURL=build://iron-selector/iron-selectable.html.js
Polymer.IronSelectableBehavior={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 Polymer.IronSelection(this._applySelection.bind(this))},attached:function(){this._observer=this._observeItems(this);this._addListener(this.activateEvent)},detached:function(){this._observer&&Polymer.dom(this).unobserveNodes(this._observer);this._removeListener(this.activateEvent)},
indexOf:function(b){return this.items?this.items.indexOf(b):-1},select:function(b){this.selected=b},selectPrevious:function(){var b=this.items.length;b=(Number(this._valueToIndex(this.selected))-1+b)%b;this.selected=this._indexToValue(b)},selectNext:function(){var b=(Number(this._valueToIndex(this.selected))+1)%this.items.length;this.selected=this._indexToValue(b)},selectIndex:function(b){this.select(this._indexToValue(b))},forceSynchronousItemUpdate:function(){this._observer&&"function"===typeof this._observer.flush?
this._observer.flush():this._updateItems()},get _shouldUpdateSelection(){return null!=this.selected},_checkFallback:function(){this._updateSelected()},_addListener:function(b){this.listen(this,b,"_activateHandler")},_removeListener:function(b){this.unlisten(this,b,"_activateHandler")},_activateEventChanged:function(b,d){this._removeListener(d);this._addListener(b)},_updateItems:function(){var b=Polymer.dom(this).queryDistributedElements(this.selectable||"*");b=Array.prototype.filter.call(b,this._bindFilterItem);
this._setItems(b)},_updateAttrForSelected:function(){this.selectedItem&&(this.selected=this._valueForItem(this.selectedItem))},_updateSelected:function(){this._selectSelected(this.selected)},_selectSelected:function(){if(this.items){var b=this._valueToItem(this.selected);b?this._selection.select(b):this._selection.clear();this.fallbackSelection&&this.items.length&&void 0===this._selection.get()&&(this.selected=this.fallbackSelection)}},_filterItem:function(b){return!this._excludedLocalNames[b.localName]},
_valueToItem:function(b){return null==b?null:this.items[this._valueToIndex(b)]},_valueToIndex:function(b){if(this.attrForSelected)for(var d=0,f;f=this.items[d];d++){if(this._valueForItem(f)==b)return d}else return Number(b)},_indexToValue:function(b){if(this.attrForSelected){if(b=this.items[b])return this._valueForItem(b)}else return b},_valueForItem:function(b){if(!b)return null;if(!this.attrForSelected)return b=this.indexOf(b),-1===b?null:b;var d=b[Polymer.CaseMap.dashToCamelCase(this.attrForSelected)];
return void 0!=d?d:b.getAttribute(this.attrForSelected)},_applySelection:function(b,d){this.selectedClass&&this.toggleClass(this.selectedClass,d,b);this.selectedAttribute&&this.toggleAttribute(this.selectedAttribute,d,b);this._selectionChange();this.fire("iron-"+(d?"select":"deselect"),{item:b})},_selectionChange:function(){this._setSelectedItem(this._selection.get())},_observeItems:function(b){return Polymer.dom(b).observeNodes(function(d){this._updateItems();this._updateSelected();this.fire("iron-items-changed",
d,{bubbles:!1,cancelable:!1})})},_activateHandler:function(b){b=b.target;for(var d=this.items;b&&b!=this;){var f=d.indexOf(b);if(0<=f){d=this._indexToValue(f);this._itemActivate(d,b);break}b=b.parentNode}},_itemActivate:function(b,d){this.fire("iron-activate",{selected:b,item:d},{cancelable:!0}).defaultPrevented||this.select(b)}};

//# sourceURL=build://iron-selector/iron-multi-selectable.html.js
Polymer.IronMultiSelectableBehaviorImpl={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(b){this.multi?this._toggleSelected(b):this.selected=b},multiChanged:function(b){this._selection.multi=b;this._updateSelected()},get _shouldUpdateSelection(){return null!=this.selected||
null!=this.selectedValues&&this.selectedValues.length},_updateAttrForSelected:function(){this.multi?this.selectedItems&&0<this.selectedItems.length&&(this.selectedValues=this.selectedItems.map(function(b){return this._indexToValue(this.indexOf(b))},this).filter(function(b){return null!=b},this)):Polymer.IronSelectableBehavior._updateAttrForSelected.apply(this)},_updateSelected:function(){this.multi?this._selectMulti(this.selectedValues):this._selectSelected(this.selected)},_selectMulti:function(b){b=
b||[];b=(this._valuesToItems(b)||[]).filter(function(f){return null!==f&&void 0!==f});this._selection.clear(b);for(var d=0;d<b.length;d++)this._selection.setItemSelected(b[d],!0);this.fallbackSelection&&!this._selection.get().length&&this._valueToItem(this.fallbackSelection)&&this.select(this.fallbackSelection)},_selectionChange:function(){var b=this._selection.get();this.multi?(this._setSelectedItems(b),this._setSelectedItem(b.length?b[0]:null)):null!==b&&void 0!==b?(this._setSelectedItems([b]),
this._setSelectedItem(b)):(this._setSelectedItems([]),this._setSelectedItem(null))},_toggleSelected:function(b){var d=this.selectedValues.indexOf(b);0>d?this.push("selectedValues",b):this.splice("selectedValues",d,1)},_valuesToItems:function(b){return null==b?null:b.map(function(d){return this._valueToItem(d)},this)}};Polymer.IronMultiSelectableBehavior=[Polymer.IronSelectableBehavior,Polymer.IronMultiSelectableBehaviorImpl];

//# sourceURL=build://iron-menu-behavior/iron-menu-behavior.html.js
Polymer.IronMenuBehaviorImpl={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".split(" "),_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(b){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null);var d=this._valueToItem(b);d&&d.hasAttribute("disabled")||(this._setFocusedItem(d),Polymer.IronMultiSelectableBehaviorImpl.select.apply(this,arguments))},_resetTabindices:function(){var b=this.multi?
this.selectedItems&&this.selectedItems[0]:this.selectedItem;this.items.forEach(function(d){d.setAttribute("tabindex",d===b?"0":"-1")},this)},_updateMultiselectable:function(b){b?this.setAttribute("aria-multiselectable","true"):this.removeAttribute("aria-multiselectable")},_focusWithKeyboardEvent:function(b){if(-1===this._MODIFIER_KEYS.indexOf(b.key)){this.cancelDebouncer("_clearSearchText");var d=this._searchText||"";d+=(b.key&&1==b.key.length?b.key:String.fromCharCode(b.keyCode)).toLocaleLowerCase();
b=d.length;for(var f=0,h;h=this.items[f];f++)if(!h.hasAttribute("disabled")){var k=this.attrForItemTitle||"textContent";k=(h[k]||h.getAttribute(k)||"").trim();if(!(k.length<b)&&k.slice(0,b).toLocaleLowerCase()==d){this._setFocusedItem(h);break}}this._searchText=d;this.debounce("_clearSearchText",this._clearSearchText,this._SEARCH_RESET_TIMEOUT_MS)}},_clearSearchText:function(){this._searchText=""},_focusPrevious:function(){for(var b=this.items.length,d=Number(this.indexOf(this.focusedItem)),f=1;f<
b+1;f++){var h=this.items[(d-f+b)%b];if(!h.hasAttribute("disabled")){var k=Polymer.dom(h).getOwnerRoot()||document;this._setFocusedItem(h);if(Polymer.dom(k).activeElement==h)break}}},_focusNext:function(){for(var b=this.items.length,d=Number(this.indexOf(this.focusedItem)),f=1;f<b+1;f++){var h=this.items[(d+f)%b];if(!h.hasAttribute("disabled")){var k=Polymer.dom(h).getOwnerRoot()||document;this._setFocusedItem(h);if(Polymer.dom(k).activeElement==h)break}}},_applySelection:function(b,d){d?b.setAttribute("aria-selected",
"true"):b.removeAttribute("aria-selected");Polymer.IronSelectableBehavior._applySelection.apply(this,arguments)},_focusedItemChanged:function(b,d){d&&d.setAttribute("tabindex","-1");!b||b.hasAttribute("disabled")||this.disabled||(b.setAttribute("tabindex","0"),b.focus())},_onIronItemsChanged:function(b){b.detail.addedNodes.length&&this._resetTabindices()},_onShiftTabDown:function(){var b=this.getAttribute("tabindex");Polymer.IronMenuBehaviorImpl._shiftTabPressed=!0;this._setFocusedItem(null);this.setAttribute("tabindex",
"-1");this.async(function(){this.setAttribute("tabindex",b);Polymer.IronMenuBehaviorImpl._shiftTabPressed=!1},1)},_onFocus:function(b){!Polymer.IronMenuBehaviorImpl._shiftTabPressed&&(b=Polymer.dom(b).rootTarget,b===this||"undefined"===typeof b.tabIndex||this.isLightDescendant(b))&&(this._defaultFocusAsync=this.async(function(){var d=this.multi?this.selectedItems&&this.selectedItems[0]:this.selectedItem;this._setFocusedItem(null);d?this._setFocusedItem(d):this.items[0]&&this._focusNext()}))},_onUpKey:function(b){this._focusPrevious();
b.detail.keyboardEvent.preventDefault()},_onDownKey:function(b){this._focusNext();b.detail.keyboardEvent.preventDefault()},_onEscKey:function(){var b=this.focusedItem;b&&b.blur()},_onKeydown:function(b){this.keyboardEventMatchesKeys(b,"up down esc")||this._focusWithKeyboardEvent(b);b.stopPropagation()},_activateHandler:function(b){Polymer.IronSelectableBehavior._activateHandler.call(this,b);b.stopPropagation()},_disabledChanged:function(b){b?(this._previousTabIndex=this.hasAttribute("tabindex")?this.tabIndex:
0,this.removeAttribute("tabindex")):this.hasAttribute("tabindex")||this.setAttribute("tabindex",this._previousTabIndex)}};Polymer.IronMenuBehaviorImpl._shiftTabPressed=!1;Polymer.IronMenuBehavior=[Polymer.IronMultiSelectableBehavior,Polymer.IronA11yKeysBehavior,Polymer.IronMenuBehaviorImpl];

//# sourceURL=build://paper-listbox/paper-listbox.html.js
(function(){Polymer({is:"paper-listbox",behaviors:[Polymer.IronMenuBehavior],hostAttributes:{role:"listbox"}})})();

//# sourceURL=build://paper-item/paper-item-behavior.html.js
Polymer.PaperItemBehaviorImpl={hostAttributes:{role:"option",tabindex:"0"}};Polymer.PaperItemBehavior=[Polymer.IronButtonState,Polymer.IronControlState,Polymer.PaperItemBehaviorImpl];

//# sourceURL=build://paper-item/paper-item.html.js
Polymer({is:"paper-item",behaviors:[Polymer.PaperItemBehavior]});

/*

 Lodash <https://lodash.com/>
 Copyright JS Foundation and other contributors <https://js.foundation/>
 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
*/
(function(){var undefined;var VERSION="4.17.5";var LARGE_ARRAY_SIZE=200;var CORE_ERROR_TEXT="Unsupported core-js use. Try https://npms.io/search?q\x3dponyfill.",FUNC_ERROR_TEXT="Expected a function";var HASH_UNDEFINED="__lodash_hash_undefined__";var MAX_MEMOIZE_SIZE=500;var PLACEHOLDER="__lodash_placeholder__";var CLONE_DEEP_FLAG=1,CLONE_FLAT_FLAG=2,CLONE_SYMBOLS_FLAG=4;var COMPARE_PARTIAL_FLAG=1,COMPARE_UNORDERED_FLAG=2;var WRAP_BIND_FLAG=1,WRAP_BIND_KEY_FLAG=2,WRAP_CURRY_BOUND_FLAG=4,WRAP_CURRY_FLAG=
8,WRAP_CURRY_RIGHT_FLAG=16,WRAP_PARTIAL_FLAG=32,WRAP_PARTIAL_RIGHT_FLAG=64,WRAP_ARY_FLAG=128,WRAP_REARG_FLAG=256,WRAP_FLIP_FLAG=512;var DEFAULT_TRUNC_LENGTH=30,DEFAULT_TRUNC_OMISSION="...";var HOT_COUNT=800,HOT_SPAN=16;var LAZY_FILTER_FLAG=1,LAZY_MAP_FLAG=2,LAZY_WHILE_FLAG=3;var INFINITY=1/0,MAX_SAFE_INTEGER=9007199254740991,MAX_INTEGER=1.7976931348623157E308,NAN=0/0;var MAX_ARRAY_LENGTH=4294967295,MAX_ARRAY_INDEX=MAX_ARRAY_LENGTH-1,HALF_MAX_ARRAY_LENGTH=MAX_ARRAY_LENGTH>>>1;var wrapFlags=[["ary",
WRAP_ARY_FLAG],["bind",WRAP_BIND_FLAG],["bindKey",WRAP_BIND_KEY_FLAG],["curry",WRAP_CURRY_FLAG],["curryRight",WRAP_CURRY_RIGHT_FLAG],["flip",WRAP_FLIP_FLAG],["partial",WRAP_PARTIAL_FLAG],["partialRight",WRAP_PARTIAL_RIGHT_FLAG],["rearg",WRAP_REARG_FLAG]];var argsTag="[object Arguments]",arrayTag="[object Array]",asyncTag="[object AsyncFunction]",boolTag="[object Boolean]",dateTag="[object Date]",domExcTag="[object DOMException]",errorTag="[object Error]",funcTag="[object Function]",genTag="[object GeneratorFunction]",
mapTag="[object Map]",numberTag="[object Number]",nullTag="[object Null]",objectTag="[object Object]",promiseTag="[object Promise]",proxyTag="[object Proxy]",regexpTag="[object RegExp]",setTag="[object Set]",stringTag="[object String]",symbolTag="[object Symbol]",undefinedTag="[object Undefined]",weakMapTag="[object WeakMap]",weakSetTag="[object WeakSet]";var arrayBufferTag="[object ArrayBuffer]",dataViewTag="[object DataView]",float32Tag="[object Float32Array]",float64Tag="[object Float64Array]",
int8Tag="[object Int8Array]",int16Tag="[object Int16Array]",int32Tag="[object Int32Array]",uint8Tag="[object Uint8Array]",uint8ClampedTag="[object Uint8ClampedArray]",uint16Tag="[object Uint16Array]",uint32Tag="[object Uint32Array]";var reEmptyStringLeading=/\b__p \+= '';/g,reEmptyStringMiddle=/\b(__p \+=) '' \+/g,reEmptyStringTrailing=/(__e\(.*?\)|\b__t\)) \+\n'';/g;var reEscapedHtml=/&(?:amp|lt|gt|quot|#39);/g,reUnescapedHtml=/[&<>"']/g,reHasEscapedHtml=RegExp(reEscapedHtml.source),reHasUnescapedHtml=
RegExp(reUnescapedHtml.source);var reEscape=/<%-([\s\S]+?)%>/g,reEvaluate=/<%([\s\S]+?)%>/g,reInterpolate=/<%=([\s\S]+?)%>/g;var reIsDeepProp=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,reIsPlainProp=/^\w*$/,rePropName=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;var reRegExpChar=/[\\^$.*+?()[\]{}|]/g,reHasRegExpChar=RegExp(reRegExpChar.source);var reTrim=/^\s+|\s+$/g,reTrimStart=/^\s+/,reTrimEnd=/\s+$/;var reWrapComment=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
reWrapDetails=/\{\n\/\* \[wrapped with (.+)\] \*/,reSplitDetails=/,? & /;var reAsciiWord=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;var reEscapeChar=/\\(\\)?/g;var reEsTemplate=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;var reFlags=/\w*$/;var reIsBadHex=/^[-+]0x[0-9a-f]+$/i;var reIsBinary=/^0b[01]+$/i;var reIsHostCtor=/^\[object .+?Constructor\]$/;var reIsOctal=/^0o[0-7]+$/i;var reIsUint=/^(?:0|[1-9]\d*)$/;var reLatin=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;var reNoMatch=/($^)/;var reUnescapedString=
/['\n\r\u2028\u2029\\]/g;var rsAstralRange="\\ud800-\\udfff",rsComboMarksRange="\\u0300-\\u036f",reComboHalfMarksRange="\\ufe20-\\ufe2f",rsComboSymbolsRange="\\u20d0-\\u20ff",rsComboRange=rsComboMarksRange+reComboHalfMarksRange+rsComboSymbolsRange,rsDingbatRange="\\u2700-\\u27bf",rsLowerRange="a-z\\xdf-\\xf6\\xf8-\\xff",rsMathOpRange="\\xac\\xb1\\xd7\\xf7",rsNonCharRange="\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf",rsPunctuationRange="\\u2000-\\u206f",rsSpaceRange=" \\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",
rsUpperRange="A-Z\\xc0-\\xd6\\xd8-\\xde",rsVarRange="\\ufe0e\\ufe0f",rsBreakRange=rsMathOpRange+rsNonCharRange+rsPunctuationRange+rsSpaceRange;var rsApos="['\u2019]",rsAstral="["+rsAstralRange+"]",rsBreak="["+rsBreakRange+"]",rsCombo="["+rsComboRange+"]",rsDigits="\\d+",rsDingbat="["+rsDingbatRange+"]",rsLower="["+rsLowerRange+"]",rsMisc="[^"+rsAstralRange+rsBreakRange+rsDigits+rsDingbatRange+rsLowerRange+rsUpperRange+"]",rsFitz="\\ud83c[\\udffb-\\udfff]",rsModifier="(?:"+rsCombo+"|"+rsFitz+")",rsNonAstral=
"[^"+rsAstralRange+"]",rsRegional="(?:\\ud83c[\\udde6-\\uddff]){2}",rsSurrPair="[\\ud800-\\udbff][\\udc00-\\udfff]",rsUpper="["+rsUpperRange+"]",rsZWJ="\\u200d";var rsMiscLower="(?:"+rsLower+"|"+rsMisc+")",rsMiscUpper="(?:"+rsUpper+"|"+rsMisc+")",rsOptContrLower="(?:"+rsApos+"(?:d|ll|m|re|s|t|ve))?",rsOptContrUpper="(?:"+rsApos+"(?:D|LL|M|RE|S|T|VE))?",reOptMod=rsModifier+"?",rsOptVar="["+rsVarRange+"]?",rsOptJoin="(?:"+rsZWJ+"(?:"+[rsNonAstral,rsRegional,rsSurrPair].join("|")+")"+rsOptVar+reOptMod+
")*",rsOrdLower="\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?\x3d\\b|[A-Z_])",rsOrdUpper="\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?\x3d\\b|[a-z_])",rsSeq=rsOptVar+reOptMod+rsOptJoin,rsEmoji="(?:"+[rsDingbat,rsRegional,rsSurrPair].join("|")+")"+rsSeq,rsSymbol="(?:"+[rsNonAstral+rsCombo+"?",rsCombo,rsRegional,rsSurrPair,rsAstral].join("|")+")";var reApos=RegExp(rsApos,"g");var reComboMark=RegExp(rsCombo,"g");var reUnicode=RegExp(rsFitz+"(?\x3d"+rsFitz+")|"+rsSymbol+rsSeq,"g");var reUnicodeWord=RegExp([rsUpper+"?"+
rsLower+"+"+rsOptContrLower+"(?\x3d"+[rsBreak,rsUpper,"$"].join("|")+")",rsMiscUpper+"+"+rsOptContrUpper+"(?\x3d"+[rsBreak,rsUpper+rsMiscLower,"$"].join("|")+")",rsUpper+"?"+rsMiscLower+"+"+rsOptContrLower,rsUpper+"+"+rsOptContrUpper,rsOrdUpper,rsOrdLower,rsDigits,rsEmoji].join("|"),"g");var reHasUnicode=RegExp("["+rsZWJ+rsAstralRange+rsComboRange+rsVarRange+"]");var reHasUnicodeWord=/[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;var contextProps=["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"];var templateCounter=-1;var typedArrayTags={};typedArrayTags[float32Tag]=typedArrayTags[float64Tag]=typedArrayTags[int8Tag]=typedArrayTags[int16Tag]=typedArrayTags[int32Tag]=typedArrayTags[uint8Tag]=typedArrayTags[uint8ClampedTag]=
typedArrayTags[uint16Tag]=typedArrayTags[uint32Tag]=true;typedArrayTags[argsTag]=typedArrayTags[arrayTag]=typedArrayTags[arrayBufferTag]=typedArrayTags[boolTag]=typedArrayTags[dataViewTag]=typedArrayTags[dateTag]=typedArrayTags[errorTag]=typedArrayTags[funcTag]=typedArrayTags[mapTag]=typedArrayTags[numberTag]=typedArrayTags[objectTag]=typedArrayTags[regexpTag]=typedArrayTags[setTag]=typedArrayTags[stringTag]=typedArrayTags[weakMapTag]=false;var cloneableTags={};cloneableTags[argsTag]=cloneableTags[arrayTag]=
cloneableTags[arrayBufferTag]=cloneableTags[dataViewTag]=cloneableTags[boolTag]=cloneableTags[dateTag]=cloneableTags[float32Tag]=cloneableTags[float64Tag]=cloneableTags[int8Tag]=cloneableTags[int16Tag]=cloneableTags[int32Tag]=cloneableTags[mapTag]=cloneableTags[numberTag]=cloneableTags[objectTag]=cloneableTags[regexpTag]=cloneableTags[setTag]=cloneableTags[stringTag]=cloneableTags[symbolTag]=cloneableTags[uint8Tag]=cloneableTags[uint8ClampedTag]=cloneableTags[uint16Tag]=cloneableTags[uint32Tag]=true;
cloneableTags[errorTag]=cloneableTags[funcTag]=cloneableTags[weakMapTag]=false;var deburredLetters={"\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"};var htmlEscapes={"\x26":"\x26amp;","\x3c":"\x26lt;","\x3e":"\x26gt;",'"':"\x26quot;","'":"\x26#39;"};var htmlUnescapes={"\x26amp;":"\x26","\x26lt;":"\x3c","\x26gt;":"\x3e","\x26quot;":'"',"\x26#39;":"'"};var stringEscapes={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"};var freeParseFloat=parseFloat,freeParseInt=parseInt;var freeGlobal=typeof global=="object"&&global&&global.Object===Object&&global;var freeSelf=typeof self=="object"&&
self&&self.Object===Object&&self;var root=freeGlobal||freeSelf||Function("return this")();var freeExports=typeof exports=="object"&&exports&&!exports.nodeType&&exports;var freeModule=freeExports&&typeof module=="object"&&module&&!module.nodeType&&module;var moduleExports=freeModule&&freeModule.exports===freeExports;var freeProcess=moduleExports&&freeGlobal.process;var nodeUtil=function(){try{return freeProcess&&freeProcess.binding&&freeProcess.binding("util")}catch(e){}}();var nodeIsArrayBuffer=nodeUtil&&
nodeUtil.isArrayBuffer,nodeIsDate=nodeUtil&&nodeUtil.isDate,nodeIsMap=nodeUtil&&nodeUtil.isMap,nodeIsRegExp=nodeUtil&&nodeUtil.isRegExp,nodeIsSet=nodeUtil&&nodeUtil.isSet,nodeIsTypedArray=nodeUtil&&nodeUtil.isTypedArray;function apply(func,thisArg,args){switch(args.length){case 0:return func.call(thisArg);case 1:return func.call(thisArg,args[0]);case 2:return func.call(thisArg,args[0],args[1]);case 3:return func.call(thisArg,args[0],args[1],args[2])}return func.apply(thisArg,args)}function arrayAggregator(array,
setter,iteratee,accumulator){var index=-1,length=array==null?0:array.length;while(++index<length){var value=array[index];setter(accumulator,value,iteratee(value),array)}return accumulator}function arrayEach(array,iteratee){var index=-1,length=array==null?0:array.length;while(++index<length)if(iteratee(array[index],index,array)===false)break;return array}function arrayEachRight(array,iteratee){var length=array==null?0:array.length;while(length--)if(iteratee(array[length],length,array)===false)break;
return array}function arrayEvery(array,predicate){var index=-1,length=array==null?0:array.length;while(++index<length)if(!predicate(array[index],index,array))return false;return true}function arrayFilter(array,predicate){var index=-1,length=array==null?0:array.length,resIndex=0,result=[];while(++index<length){var value=array[index];if(predicate(value,index,array))result[resIndex++]=value}return result}function arrayIncludes(array,value){var length=array==null?0:array.length;return!!length&&baseIndexOf(array,
value,0)>-1}function arrayIncludesWith(array,value,comparator){var index=-1,length=array==null?0:array.length;while(++index<length)if(comparator(value,array[index]))return true;return false}function arrayMap(array,iteratee){var index=-1,length=array==null?0:array.length,result=Array(length);while(++index<length)result[index]=iteratee(array[index],index,array);return result}function arrayPush(array,values){var index=-1,length=values.length,offset=array.length;while(++index<length)array[offset+index]=
values[index];return array}function arrayReduce(array,iteratee,accumulator,initAccum){var index=-1,length=array==null?0:array.length;if(initAccum&&length)accumulator=array[++index];while(++index<length)accumulator=iteratee(accumulator,array[index],index,array);return accumulator}function arrayReduceRight(array,iteratee,accumulator,initAccum){var length=array==null?0:array.length;if(initAccum&&length)accumulator=array[--length];while(length--)accumulator=iteratee(accumulator,array[length],length,array);
return accumulator}function arraySome(array,predicate){var index=-1,length=array==null?0:array.length;while(++index<length)if(predicate(array[index],index,array))return true;return false}var asciiSize=baseProperty("length");function asciiToArray(string){return string.split("")}function asciiWords(string){return string.match(reAsciiWord)||[]}function baseFindKey(collection,predicate,eachFunc){var result;eachFunc(collection,function(value,key,collection){if(predicate(value,key,collection)){result=key;
return false}});return result}function baseFindIndex(array,predicate,fromIndex,fromRight){var length=array.length,index=fromIndex+(fromRight?1:-1);while(fromRight?index--:++index<length)if(predicate(array[index],index,array))return index;return-1}function baseIndexOf(array,value,fromIndex){return value===value?strictIndexOf(array,value,fromIndex):baseFindIndex(array,baseIsNaN,fromIndex)}function baseIndexOfWith(array,value,fromIndex,comparator){var index=fromIndex-1,length=array.length;while(++index<
length)if(comparator(array[index],value))return index;return-1}function baseIsNaN(value){return value!==value}function baseMean(array,iteratee){var length=array==null?0:array.length;return length?baseSum(array,iteratee)/length:NAN}function baseProperty(key){return function(object){return object==null?undefined:object[key]}}function basePropertyOf(object){return function(key){return object==null?undefined:object[key]}}function baseReduce(collection,iteratee,accumulator,initAccum,eachFunc){eachFunc(collection,
function(value,index,collection){accumulator=initAccum?(initAccum=false,value):iteratee(accumulator,value,index,collection)});return accumulator}function baseSortBy(array,comparer){var length=array.length;array.sort(comparer);while(length--)array[length]=array[length].value;return array}function baseSum(array,iteratee){var result,index=-1,length=array.length;while(++index<length){var current=iteratee(array[index]);if(current!==undefined)result=result===undefined?current:result+current}return result}
function baseTimes(n,iteratee){var index=-1,result=Array(n);while(++index<n)result[index]=iteratee(index);return result}function baseToPairs(object,props){return arrayMap(props,function(key){return[key,object[key]]})}function baseUnary(func){return function(value){return func(value)}}function baseValues(object,props){return arrayMap(props,function(key){return object[key]})}function cacheHas(cache,key){return cache.has(key)}function charsStartIndex(strSymbols,chrSymbols){var index=-1,length=strSymbols.length;
while(++index<length&&baseIndexOf(chrSymbols,strSymbols[index],0)>-1);return index}function charsEndIndex(strSymbols,chrSymbols){var index=strSymbols.length;while(index--&&baseIndexOf(chrSymbols,strSymbols[index],0)>-1);return index}function countHolders(array,placeholder){var length=array.length,result=0;while(length--)if(array[length]===placeholder)++result;return result}var deburrLetter=basePropertyOf(deburredLetters);var escapeHtmlChar=basePropertyOf(htmlEscapes);function escapeStringChar(chr){return"\\"+
stringEscapes[chr]}function getValue(object,key){return object==null?undefined:object[key]}function hasUnicode(string){return reHasUnicode.test(string)}function hasUnicodeWord(string){return reHasUnicodeWord.test(string)}function iteratorToArray(iterator){var data,result=[];while(!(data=iterator.next()).done)result.push(data.value);return result}function mapToArray(map){var index=-1,result=Array(map.size);map.forEach(function(value,key){result[++index]=[key,value]});return result}function overArg(func,
transform){return function(arg){return func(transform(arg))}}function replaceHolders(array,placeholder){var index=-1,length=array.length,resIndex=0,result=[];while(++index<length){var value=array[index];if(value===placeholder||value===PLACEHOLDER){array[index]=PLACEHOLDER;result[resIndex++]=index}}return result}function safeGet(object,key){return key=="__proto__"?undefined:object[key]}function setToArray(set){var index=-1,result=Array(set.size);set.forEach(function(value){result[++index]=value});
return result}function setToPairs(set){var index=-1,result=Array(set.size);set.forEach(function(value){result[++index]=[value,value]});return result}function strictIndexOf(array,value,fromIndex){var index=fromIndex-1,length=array.length;while(++index<length)if(array[index]===value)return index;return-1}function strictLastIndexOf(array,value,fromIndex){var index=fromIndex+1;while(index--)if(array[index]===value)return index;return index}function stringSize(string){return hasUnicode(string)?unicodeSize(string):
asciiSize(string)}function stringToArray(string){return hasUnicode(string)?unicodeToArray(string):asciiToArray(string)}var unescapeHtmlChar=basePropertyOf(htmlUnescapes);function unicodeSize(string){var result=reUnicode.lastIndex=0;while(reUnicode.test(string))++result;return result}function unicodeToArray(string){return string.match(reUnicode)||[]}function unicodeWords(string){return string.match(reUnicodeWord)||[]}var runInContext=function runInContext(context){context=context==null?root:_.defaults(root.Object(),
context,_.pick(root,contextProps));var Array=context.Array,Date=context.Date,Error=context.Error,Function=context.Function,Math=context.Math,Object=context.Object,RegExp=context.RegExp,String=context.String,TypeError=context.TypeError;var arrayProto=Array.prototype,funcProto=Function.prototype,objectProto=Object.prototype;var coreJsData=context["__core-js_shared__"];var funcToString=funcProto.toString;var hasOwnProperty=objectProto.hasOwnProperty;var idCounter=0;var maskSrcKey=function(){var uid=
/[^.]+$/.exec(coreJsData&&coreJsData.keys&&coreJsData.keys.IE_PROTO||"");return uid?"Symbol(src)_1."+uid:""}();var nativeObjectToString=objectProto.toString;var objectCtorString=funcToString.call(Object);var oldDash=root._;var reIsNative=RegExp("^"+funcToString.call(hasOwnProperty).replace(reRegExpChar,"\\$\x26").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");var Buffer=moduleExports?context.Buffer:undefined,Symbol=context.Symbol,Uint8Array=context.Uint8Array,allocUnsafe=
Buffer?Buffer.allocUnsafe:undefined,getPrototype=overArg(Object.getPrototypeOf,Object),objectCreate=Object.create,propertyIsEnumerable=objectProto.propertyIsEnumerable,splice=arrayProto.splice,spreadableSymbol=Symbol?Symbol.isConcatSpreadable:undefined,symIterator=Symbol?Symbol.iterator:undefined,symToStringTag=Symbol?Symbol.toStringTag:undefined;var defineProperty=function(){try{var func=getNative(Object,"defineProperty");func({},"",{});return func}catch(e){}}();var ctxClearTimeout=context.clearTimeout!==
root.clearTimeout&&context.clearTimeout,ctxNow=Date&&Date.now!==root.Date.now&&Date.now,ctxSetTimeout=context.setTimeout!==root.setTimeout&&context.setTimeout;var nativeCeil=Math.ceil,nativeFloor=Math.floor,nativeGetSymbols=Object.getOwnPropertySymbols,nativeIsBuffer=Buffer?Buffer.isBuffer:undefined,nativeIsFinite=context.isFinite,nativeJoin=arrayProto.join,nativeKeys=overArg(Object.keys,Object),nativeMax=Math.max,nativeMin=Math.min,nativeNow=Date.now,nativeParseInt=context.parseInt,nativeRandom=
Math.random,nativeReverse=arrayProto.reverse;var DataView=getNative(context,"DataView"),Map=getNative(context,"Map"),Promise=getNative(context,"Promise"),Set=getNative(context,"Set"),WeakMap=getNative(context,"WeakMap"),nativeCreate=getNative(Object,"create");var metaMap=WeakMap&&new WeakMap;var realNames={};var dataViewCtorString=toSource(DataView),mapCtorString=toSource(Map),promiseCtorString=toSource(Promise),setCtorString=toSource(Set),weakMapCtorString=toSource(WeakMap);var symbolProto=Symbol?
Symbol.prototype:undefined,symbolValueOf=symbolProto?symbolProto.valueOf:undefined,symbolToString=symbolProto?symbolProto.toString:undefined;function lodash(value){if(isObjectLike(value)&&!isArray(value)&&!(value instanceof LazyWrapper)){if(value instanceof LodashWrapper)return value;if(hasOwnProperty.call(value,"__wrapped__"))return wrapperClone(value)}return new LodashWrapper(value)}var baseCreate=function(){function object(){}return function(proto){if(!isObject(proto))return{};if(objectCreate)return objectCreate(proto);
object.prototype=proto;var result=new object;object.prototype=undefined;return result}}();function baseLodash(){}function LodashWrapper(value,chainAll){this.__wrapped__=value;this.__actions__=[];this.__chain__=!!chainAll;this.__index__=0;this.__values__=undefined}lodash.templateSettings={"escape":reEscape,"evaluate":reEvaluate,"interpolate":reInterpolate,"variable":"","imports":{"_":lodash}};lodash.prototype=baseLodash.prototype;lodash.prototype.constructor=lodash;LodashWrapper.prototype=baseCreate(baseLodash.prototype);
LodashWrapper.prototype.constructor=LodashWrapper;function LazyWrapper(value){this.__wrapped__=value;this.__actions__=[];this.__dir__=1;this.__filtered__=false;this.__iteratees__=[];this.__takeCount__=MAX_ARRAY_LENGTH;this.__views__=[]}function lazyClone(){var result=new LazyWrapper(this.__wrapped__);result.__actions__=copyArray(this.__actions__);result.__dir__=this.__dir__;result.__filtered__=this.__filtered__;result.__iteratees__=copyArray(this.__iteratees__);result.__takeCount__=this.__takeCount__;
result.__views__=copyArray(this.__views__);return result}function lazyReverse(){if(this.__filtered__){var result=new LazyWrapper(this);result.__dir__=-1;result.__filtered__=true}else{result=this.clone();result.__dir__*=-1}return result}function lazyValue(){var array=this.__wrapped__.value(),dir=this.__dir__,isArr=isArray(array),isRight=dir<0,arrLength=isArr?array.length:0,view=getView(0,arrLength,this.__views__),start=view.start,end=view.end,length=end-start,index=isRight?end:start-1,iteratees=this.__iteratees__,
iterLength=iteratees.length,resIndex=0,takeCount=nativeMin(length,this.__takeCount__);if(!isArr||!isRight&&arrLength==length&&takeCount==length)return baseWrapperValue(array,this.__actions__);var result=[];outer:while(length--&&resIndex<takeCount){index+=dir;var iterIndex=-1,value=array[index];while(++iterIndex<iterLength){var data=iteratees[iterIndex],iteratee=data.iteratee,type=data.type,computed=iteratee(value);if(type==LAZY_MAP_FLAG)value=computed;else if(!computed)if(type==LAZY_FILTER_FLAG)continue outer;
else break outer}result[resIndex++]=value}return result}LazyWrapper.prototype=baseCreate(baseLodash.prototype);LazyWrapper.prototype.constructor=LazyWrapper;function Hash(entries){var index=-1,length=entries==null?0:entries.length;this.clear();while(++index<length){var entry=entries[index];this.set(entry[0],entry[1])}}function hashClear(){this.__data__=nativeCreate?nativeCreate(null):{};this.size=0}function hashDelete(key){var result=this.has(key)&&delete this.__data__[key];this.size-=result?1:0;
return result}function hashGet(key){var data=this.__data__;if(nativeCreate){var result=data[key];return result===HASH_UNDEFINED?undefined:result}return hasOwnProperty.call(data,key)?data[key]:undefined}function hashHas(key){var data=this.__data__;return nativeCreate?data[key]!==undefined:hasOwnProperty.call(data,key)}function hashSet(key,value){var data=this.__data__;this.size+=this.has(key)?0:1;data[key]=nativeCreate&&value===undefined?HASH_UNDEFINED:value;return this}Hash.prototype.clear=hashClear;
Hash.prototype["delete"]=hashDelete;Hash.prototype.get=hashGet;Hash.prototype.has=hashHas;Hash.prototype.set=hashSet;function ListCache(entries){var index=-1,length=entries==null?0:entries.length;this.clear();while(++index<length){var entry=entries[index];this.set(entry[0],entry[1])}}function listCacheClear(){this.__data__=[];this.size=0}function listCacheDelete(key){var data=this.__data__,index=assocIndexOf(data,key);if(index<0)return false;var lastIndex=data.length-1;if(index==lastIndex)data.pop();
else splice.call(data,index,1);--this.size;return true}function listCacheGet(key){var data=this.__data__,index=assocIndexOf(data,key);return index<0?undefined:data[index][1]}function listCacheHas(key){return assocIndexOf(this.__data__,key)>-1}function listCacheSet(key,value){var data=this.__data__,index=assocIndexOf(data,key);if(index<0){++this.size;data.push([key,value])}else data[index][1]=value;return this}ListCache.prototype.clear=listCacheClear;ListCache.prototype["delete"]=listCacheDelete;ListCache.prototype.get=
listCacheGet;ListCache.prototype.has=listCacheHas;ListCache.prototype.set=listCacheSet;function MapCache(entries){var index=-1,length=entries==null?0:entries.length;this.clear();while(++index<length){var entry=entries[index];this.set(entry[0],entry[1])}}function mapCacheClear(){this.size=0;this.__data__={"hash":new Hash,"map":new (Map||ListCache),"string":new Hash}}function mapCacheDelete(key){var result=getMapData(this,key)["delete"](key);this.size-=result?1:0;return result}function mapCacheGet(key){return getMapData(this,
key).get(key)}function mapCacheHas(key){return getMapData(this,key).has(key)}function mapCacheSet(key,value){var data=getMapData(this,key),size=data.size;data.set(key,value);this.size+=data.size==size?0:1;return this}MapCache.prototype.clear=mapCacheClear;MapCache.prototype["delete"]=mapCacheDelete;MapCache.prototype.get=mapCacheGet;MapCache.prototype.has=mapCacheHas;MapCache.prototype.set=mapCacheSet;function SetCache(values){var index=-1,length=values==null?0:values.length;this.__data__=new MapCache;
while(++index<length)this.add(values[index])}function setCacheAdd(value){this.__data__.set(value,HASH_UNDEFINED);return this}function setCacheHas(value){return this.__data__.has(value)}SetCache.prototype.add=SetCache.prototype.push=setCacheAdd;SetCache.prototype.has=setCacheHas;function Stack(entries){var data=this.__data__=new ListCache(entries);this.size=data.size}function stackClear(){this.__data__=new ListCache;this.size=0}function stackDelete(key){var data=this.__data__,result=data["delete"](key);
this.size=data.size;return result}function stackGet(key){return this.__data__.get(key)}function stackHas(key){return this.__data__.has(key)}function stackSet(key,value){var data=this.__data__;if(data instanceof ListCache){var pairs=data.__data__;if(!Map||pairs.length<LARGE_ARRAY_SIZE-1){pairs.push([key,value]);this.size=++data.size;return this}data=this.__data__=new MapCache(pairs)}data.set(key,value);this.size=data.size;return this}Stack.prototype.clear=stackClear;Stack.prototype["delete"]=stackDelete;
Stack.prototype.get=stackGet;Stack.prototype.has=stackHas;Stack.prototype.set=stackSet;function arrayLikeKeys(value,inherited){var isArr=isArray(value),isArg=!isArr&&isArguments(value),isBuff=!isArr&&!isArg&&isBuffer(value),isType=!isArr&&!isArg&&!isBuff&&isTypedArray(value),skipIndexes=isArr||isArg||isBuff||isType,result=skipIndexes?baseTimes(value.length,String):[],length=result.length;for(var key in value)if((inherited||hasOwnProperty.call(value,key))&&!(skipIndexes&&(key=="length"||isBuff&&(key==
"offset"||key=="parent")||isType&&(key=="buffer"||key=="byteLength"||key=="byteOffset")||isIndex(key,length))))result.push(key);return result}function arraySample(array){var length=array.length;return length?array[baseRandom(0,length-1)]:undefined}function arraySampleSize(array,n){return shuffleSelf(copyArray(array),baseClamp(n,0,array.length))}function arrayShuffle(array){return shuffleSelf(copyArray(array))}function assignMergeValue(object,key,value){if(value!==undefined&&!eq(object[key],value)||
value===undefined&&!(key in object))baseAssignValue(object,key,value)}function assignValue(object,key,value){var objValue=object[key];if(!(hasOwnProperty.call(object,key)&&eq(objValue,value))||value===undefined&&!(key in object))baseAssignValue(object,key,value)}function assocIndexOf(array,key){var length=array.length;while(length--)if(eq(array[length][0],key))return length;return-1}function baseAggregator(collection,setter,iteratee,accumulator){baseEach(collection,function(value,key,collection){setter(accumulator,
value,iteratee(value),collection)});return accumulator}function baseAssign(object,source){return object&&copyObject(source,keys(source),object)}function baseAssignIn(object,source){return object&&copyObject(source,keysIn(source),object)}function baseAssignValue(object,key,value){if(key=="__proto__"&&defineProperty)defineProperty(object,key,{"configurable":true,"enumerable":true,"value":value,"writable":true});else object[key]=value}function baseAt(object,paths){var index=-1,length=paths.length,result=
Array(length),skip=object==null;while(++index<length)result[index]=skip?undefined:get(object,paths[index]);return result}function baseClamp(number,lower,upper){if(number===number){if(upper!==undefined)number=number<=upper?number:upper;if(lower!==undefined)number=number>=lower?number:lower}return number}function baseClone(value,bitmask,customizer,key,object,stack){var result,isDeep=bitmask&CLONE_DEEP_FLAG,isFlat=bitmask&CLONE_FLAT_FLAG,isFull=bitmask&CLONE_SYMBOLS_FLAG;if(customizer)result=object?
customizer(value,key,object,stack):customizer(value);if(result!==undefined)return result;if(!isObject(value))return value;var isArr=isArray(value);if(isArr){result=initCloneArray(value);if(!isDeep)return copyArray(value,result)}else{var tag=getTag(value),isFunc=tag==funcTag||tag==genTag;if(isBuffer(value))return cloneBuffer(value,isDeep);if(tag==objectTag||tag==argsTag||isFunc&&!object){result=isFlat||isFunc?{}:initCloneObject(value);if(!isDeep)return isFlat?copySymbolsIn(value,baseAssignIn(result,
value)):copySymbols(value,baseAssign(result,value))}else{if(!cloneableTags[tag])return object?value:{};result=initCloneByTag(value,tag,isDeep)}}stack||(stack=new Stack);var stacked=stack.get(value);if(stacked)return stacked;stack.set(value,result);if(isSet(value)){value.forEach(function(subValue){result.add(baseClone(subValue,bitmask,customizer,subValue,value,stack))});return result}if(isMap(value)){value.forEach(function(subValue,key){result.set(key,baseClone(subValue,bitmask,customizer,key,value,
stack))});return result}var keysFunc=isFull?isFlat?getAllKeysIn:getAllKeys:isFlat?keysIn:keys;var props=isArr?undefined:keysFunc(value);arrayEach(props||value,function(subValue,key){if(props){key=subValue;subValue=value[key]}assignValue(result,key,baseClone(subValue,bitmask,customizer,key,value,stack))});return result}function baseConforms(source){var props=keys(source);return function(object){return baseConformsTo(object,source,props)}}function baseConformsTo(object,source,props){var length=props.length;
if(object==null)return!length;object=Object(object);while(length--){var key=props[length],predicate=source[key],value=object[key];if(value===undefined&&!(key in object)||!predicate(value))return false}return true}function baseDelay(func,wait,args){if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);return setTimeout(function(){func.apply(undefined,args)},wait)}function baseDifference(array,values,iteratee,comparator){var index=-1,includes=arrayIncludes,isCommon=true,length=array.length,
result=[],valuesLength=values.length;if(!length)return result;if(iteratee)values=arrayMap(values,baseUnary(iteratee));if(comparator){includes=arrayIncludesWith;isCommon=false}else if(values.length>=LARGE_ARRAY_SIZE){includes=cacheHas;isCommon=false;values=new SetCache(values)}outer:while(++index<length){var value=array[index],computed=iteratee==null?value:iteratee(value);value=comparator||value!==0?value:0;if(isCommon&&computed===computed){var valuesIndex=valuesLength;while(valuesIndex--)if(values[valuesIndex]===
computed)continue outer;result.push(value)}else if(!includes(values,computed,comparator))result.push(value)}return result}var baseEach=createBaseEach(baseForOwn);var baseEachRight=createBaseEach(baseForOwnRight,true);function baseEvery(collection,predicate){var result=true;baseEach(collection,function(value,index,collection){result=!!predicate(value,index,collection);return result});return result}function baseExtremum(array,iteratee,comparator){var index=-1,length=array.length;while(++index<length){var value=
array[index],current=iteratee(value);if(current!=null&&(computed===undefined?current===current&&!isSymbol(current):comparator(current,computed)))var computed=current,result=value}return result}function baseFill(array,value,start,end){var length=array.length;start=toInteger(start);if(start<0)start=-start>length?0:length+start;end=end===undefined||end>length?length:toInteger(end);if(end<0)end+=length;end=start>end?0:toLength(end);while(start<end)array[start++]=value;return array}function baseFilter(collection,
predicate){var result=[];baseEach(collection,function(value,index,collection){if(predicate(value,index,collection))result.push(value)});return result}function baseFlatten(array,depth,predicate,isStrict,result){var index=-1,length=array.length;predicate||(predicate=isFlattenable);result||(result=[]);while(++index<length){var value=array[index];if(depth>0&&predicate(value))if(depth>1)baseFlatten(value,depth-1,predicate,isStrict,result);else arrayPush(result,value);else if(!isStrict)result[result.length]=
value}return result}var baseFor=createBaseFor();var baseForRight=createBaseFor(true);function baseForOwn(object,iteratee){return object&&baseFor(object,iteratee,keys)}function baseForOwnRight(object,iteratee){return object&&baseForRight(object,iteratee,keys)}function baseFunctions(object,props){return arrayFilter(props,function(key){return isFunction(object[key])})}function baseGet(object,path){path=castPath(path,object);var index=0,length=path.length;while(object!=null&&index<length)object=object[toKey(path[index++])];
return index&&index==length?object:undefined}function baseGetAllKeys(object,keysFunc,symbolsFunc){var result=keysFunc(object);return isArray(object)?result:arrayPush(result,symbolsFunc(object))}function baseGetTag(value){if(value==null)return value===undefined?undefinedTag:nullTag;return symToStringTag&&symToStringTag in Object(value)?getRawTag(value):objectToString(value)}function baseGt(value,other){return value>other}function baseHas(object,key){return object!=null&&hasOwnProperty.call(object,
key)}function baseHasIn(object,key){return object!=null&&key in Object(object)}function baseInRange(number,start,end){return number>=nativeMin(start,end)&&number<nativeMax(start,end)}function baseIntersection(arrays,iteratee,comparator){var includes=comparator?arrayIncludesWith:arrayIncludes,length=arrays[0].length,othLength=arrays.length,othIndex=othLength,caches=Array(othLength),maxLength=Infinity,result=[];while(othIndex--){var array=arrays[othIndex];if(othIndex&&iteratee)array=arrayMap(array,
baseUnary(iteratee));maxLength=nativeMin(array.length,maxLength);caches[othIndex]=!comparator&&(iteratee||length>=120&&array.length>=120)?new SetCache(othIndex&&array):undefined}array=arrays[0];var index=-1,seen=caches[0];outer:while(++index<length&&result.length<maxLength){var value=array[index],computed=iteratee?iteratee(value):value;value=comparator||value!==0?value:0;if(!(seen?cacheHas(seen,computed):includes(result,computed,comparator))){othIndex=othLength;while(--othIndex){var cache=caches[othIndex];
if(!(cache?cacheHas(cache,computed):includes(arrays[othIndex],computed,comparator)))continue outer}if(seen)seen.push(computed);result.push(value)}}return result}function baseInverter(object,setter,iteratee,accumulator){baseForOwn(object,function(value,key,object){setter(accumulator,iteratee(value),key,object)});return accumulator}function baseInvoke(object,path,args){path=castPath(path,object);object=parent(object,path);var func=object==null?object:object[toKey(last(path))];return func==null?undefined:
apply(func,object,args)}function baseIsArguments(value){return isObjectLike(value)&&baseGetTag(value)==argsTag}function baseIsArrayBuffer(value){return isObjectLike(value)&&baseGetTag(value)==arrayBufferTag}function baseIsDate(value){return isObjectLike(value)&&baseGetTag(value)==dateTag}function baseIsEqual(value,other,bitmask,customizer,stack){if(value===other)return true;if(value==null||other==null||!isObjectLike(value)&&!isObjectLike(other))return value!==value&&other!==other;return baseIsEqualDeep(value,
other,bitmask,customizer,baseIsEqual,stack)}function baseIsEqualDeep(object,other,bitmask,customizer,equalFunc,stack){var objIsArr=isArray(object),othIsArr=isArray(other),objTag=objIsArr?arrayTag:getTag(object),othTag=othIsArr?arrayTag:getTag(other);objTag=objTag==argsTag?objectTag:objTag;othTag=othTag==argsTag?objectTag:othTag;var objIsObj=objTag==objectTag,othIsObj=othTag==objectTag,isSameTag=objTag==othTag;if(isSameTag&&isBuffer(object)){if(!isBuffer(other))return false;objIsArr=true;objIsObj=
false}if(isSameTag&&!objIsObj){stack||(stack=new Stack);return objIsArr||isTypedArray(object)?equalArrays(object,other,bitmask,customizer,equalFunc,stack):equalByTag(object,other,objTag,bitmask,customizer,equalFunc,stack)}if(!(bitmask&COMPARE_PARTIAL_FLAG)){var objIsWrapped=objIsObj&&hasOwnProperty.call(object,"__wrapped__"),othIsWrapped=othIsObj&&hasOwnProperty.call(other,"__wrapped__");if(objIsWrapped||othIsWrapped){var objUnwrapped=objIsWrapped?object.value():object,othUnwrapped=othIsWrapped?other.value():
other;stack||(stack=new Stack);return equalFunc(objUnwrapped,othUnwrapped,bitmask,customizer,stack)}}if(!isSameTag)return false;stack||(stack=new Stack);return equalObjects(object,other,bitmask,customizer,equalFunc,stack)}function baseIsMap(value){return isObjectLike(value)&&getTag(value)==mapTag}function baseIsMatch(object,source,matchData,customizer){var index=matchData.length,length=index,noCustomizer=!customizer;if(object==null)return!length;object=Object(object);while(index--){var data=matchData[index];
if(noCustomizer&&data[2]?data[1]!==object[data[0]]:!(data[0]in object))return false}while(++index<length){data=matchData[index];var key=data[0],objValue=object[key],srcValue=data[1];if(noCustomizer&&data[2]){if(objValue===undefined&&!(key in object))return false}else{var stack=new Stack;if(customizer)var result=customizer(objValue,srcValue,key,object,source,stack);if(!(result===undefined?baseIsEqual(srcValue,objValue,COMPARE_PARTIAL_FLAG|COMPARE_UNORDERED_FLAG,customizer,stack):result))return false}}return true}
function baseIsNative(value){if(!isObject(value)||isMasked(value))return false;var pattern=isFunction(value)?reIsNative:reIsHostCtor;return pattern.test(toSource(value))}function baseIsRegExp(value){return isObjectLike(value)&&baseGetTag(value)==regexpTag}function baseIsSet(value){return isObjectLike(value)&&getTag(value)==setTag}function baseIsTypedArray(value){return isObjectLike(value)&&isLength(value.length)&&!!typedArrayTags[baseGetTag(value)]}function baseIteratee(value){if(typeof value=="function")return value;
if(value==null)return identity;if(typeof value=="object")return isArray(value)?baseMatchesProperty(value[0],value[1]):baseMatches(value);return property(value)}function baseKeys(object){if(!isPrototype(object))return nativeKeys(object);var result=[];for(var key in Object(object))if(hasOwnProperty.call(object,key)&&key!="constructor")result.push(key);return result}function baseKeysIn(object){if(!isObject(object))return nativeKeysIn(object);var isProto=isPrototype(object),result=[];for(var key in object)if(!(key==
"constructor"&&(isProto||!hasOwnProperty.call(object,key))))result.push(key);return result}function baseLt(value,other){return value<other}function baseMap(collection,iteratee){var index=-1,result=isArrayLike(collection)?Array(collection.length):[];baseEach(collection,function(value,key,collection){result[++index]=iteratee(value,key,collection)});return result}function baseMatches(source){var matchData=getMatchData(source);if(matchData.length==1&&matchData[0][2])return matchesStrictComparable(matchData[0][0],
matchData[0][1]);return function(object){return object===source||baseIsMatch(object,source,matchData)}}function baseMatchesProperty(path,srcValue){if(isKey(path)&&isStrictComparable(srcValue))return matchesStrictComparable(toKey(path),srcValue);return function(object){var objValue=get(object,path);return objValue===undefined&&objValue===srcValue?hasIn(object,path):baseIsEqual(srcValue,objValue,COMPARE_PARTIAL_FLAG|COMPARE_UNORDERED_FLAG)}}function baseMerge(object,source,srcIndex,customizer,stack){if(object===
source)return;baseFor(source,function(srcValue,key){if(isObject(srcValue)){stack||(stack=new Stack);baseMergeDeep(object,source,key,srcIndex,baseMerge,customizer,stack)}else{var newValue=customizer?customizer(safeGet(object,key),srcValue,key+"",object,source,stack):undefined;if(newValue===undefined)newValue=srcValue;assignMergeValue(object,key,newValue)}},keysIn)}function baseMergeDeep(object,source,key,srcIndex,mergeFunc,customizer,stack){var objValue=safeGet(object,key),srcValue=safeGet(source,
key),stacked=stack.get(srcValue);if(stacked){assignMergeValue(object,key,stacked);return}var newValue=customizer?customizer(objValue,srcValue,key+"",object,source,stack):undefined;var isCommon=newValue===undefined;if(isCommon){var isArr=isArray(srcValue),isBuff=!isArr&&isBuffer(srcValue),isTyped=!isArr&&!isBuff&&isTypedArray(srcValue);newValue=srcValue;if(isArr||isBuff||isTyped)if(isArray(objValue))newValue=objValue;else if(isArrayLikeObject(objValue))newValue=copyArray(objValue);else if(isBuff){isCommon=
false;newValue=cloneBuffer(srcValue,true)}else if(isTyped){isCommon=false;newValue=cloneTypedArray(srcValue,true)}else newValue=[];else if(isPlainObject(srcValue)||isArguments(srcValue)){newValue=objValue;if(isArguments(objValue))newValue=toPlainObject(objValue);else if(!isObject(objValue)||srcIndex&&isFunction(objValue))newValue=initCloneObject(srcValue)}else isCommon=false}if(isCommon){stack.set(srcValue,newValue);mergeFunc(newValue,srcValue,srcIndex,customizer,stack);stack["delete"](srcValue)}assignMergeValue(object,
key,newValue)}function baseNth(array,n){var length=array.length;if(!length)return;n+=n<0?length:0;return isIndex(n,length)?array[n]:undefined}function baseOrderBy(collection,iteratees,orders){var index=-1;iteratees=arrayMap(iteratees.length?iteratees:[identity],baseUnary(getIteratee()));var result=baseMap(collection,function(value,key,collection){var criteria=arrayMap(iteratees,function(iteratee){return iteratee(value)});return{"criteria":criteria,"index":++index,"value":value}});return baseSortBy(result,
function(object,other){return compareMultiple(object,other,orders)})}function basePick(object,paths){return basePickBy(object,paths,function(value,path){return hasIn(object,path)})}function basePickBy(object,paths,predicate){var index=-1,length=paths.length,result={};while(++index<length){var path=paths[index],value=baseGet(object,path);if(predicate(value,path))baseSet(result,castPath(path,object),value)}return result}function basePropertyDeep(path){return function(object){return baseGet(object,path)}}
function basePullAll(array,values,iteratee,comparator){var indexOf=comparator?baseIndexOfWith:baseIndexOf,index=-1,length=values.length,seen=array;if(array===values)values=copyArray(values);if(iteratee)seen=arrayMap(array,baseUnary(iteratee));while(++index<length){var fromIndex=0,value=values[index],computed=iteratee?iteratee(value):value;while((fromIndex=indexOf(seen,computed,fromIndex,comparator))>-1){if(seen!==array)splice.call(seen,fromIndex,1);splice.call(array,fromIndex,1)}}return array}function basePullAt(array,
indexes){var length=array?indexes.length:0,lastIndex=length-1;while(length--){var index=indexes[length];if(length==lastIndex||index!==previous){var previous=index;if(isIndex(index))splice.call(array,index,1);else baseUnset(array,index)}}return array}function baseRandom(lower,upper){return lower+nativeFloor(nativeRandom()*(upper-lower+1))}function baseRange(start,end,step,fromRight){var index=-1,length=nativeMax(nativeCeil((end-start)/(step||1)),0),result=Array(length);while(length--){result[fromRight?
length:++index]=start;start+=step}return result}function baseRepeat(string,n){var result="";if(!string||n<1||n>MAX_SAFE_INTEGER)return result;do{if(n%2)result+=string;n=nativeFloor(n/2);if(n)string+=string}while(n);return result}function baseRest(func,start){return setToString(overRest(func,start,identity),func+"")}function baseSample(collection){return arraySample(values(collection))}function baseSampleSize(collection,n){var array=values(collection);return shuffleSelf(array,baseClamp(n,0,array.length))}
function baseSet(object,path,value,customizer){if(!isObject(object))return object;path=castPath(path,object);var index=-1,length=path.length,lastIndex=length-1,nested=object;while(nested!=null&&++index<length){var key=toKey(path[index]),newValue=value;if(index!=lastIndex){var objValue=nested[key];newValue=customizer?customizer(objValue,key,nested):undefined;if(newValue===undefined)newValue=isObject(objValue)?objValue:isIndex(path[index+1])?[]:{}}assignValue(nested,key,newValue);nested=nested[key]}return object}
var baseSetData=!metaMap?identity:function(func,data){metaMap.set(func,data);return func};var baseSetToString=!defineProperty?identity:function(func,string){return defineProperty(func,"toString",{"configurable":true,"enumerable":false,"value":constant(string),"writable":true})};function baseShuffle(collection){return shuffleSelf(values(collection))}function baseSlice(array,start,end){var index=-1,length=array.length;if(start<0)start=-start>length?0:length+start;end=end>length?length:end;if(end<0)end+=
length;length=start>end?0:end-start>>>0;start>>>=0;var result=Array(length);while(++index<length)result[index]=array[index+start];return result}function baseSome(collection,predicate){var result;baseEach(collection,function(value,index,collection){result=predicate(value,index,collection);return!result});return!!result}function baseSortedIndex(array,value,retHighest){var low=0,high=array==null?low:array.length;if(typeof value=="number"&&value===value&&high<=HALF_MAX_ARRAY_LENGTH){while(low<high){var mid=
low+high>>>1,computed=array[mid];if(computed!==null&&!isSymbol(computed)&&(retHighest?computed<=value:computed<value))low=mid+1;else high=mid}return high}return baseSortedIndexBy(array,value,identity,retHighest)}function baseSortedIndexBy(array,value,iteratee,retHighest){value=iteratee(value);var low=0,high=array==null?0:array.length,valIsNaN=value!==value,valIsNull=value===null,valIsSymbol=isSymbol(value),valIsUndefined=value===undefined;while(low<high){var mid=nativeFloor((low+high)/2),computed=
iteratee(array[mid]),othIsDefined=computed!==undefined,othIsNull=computed===null,othIsReflexive=computed===computed,othIsSymbol=isSymbol(computed);if(valIsNaN)var setLow=retHighest||othIsReflexive;else if(valIsUndefined)setLow=othIsReflexive&&(retHighest||othIsDefined);else if(valIsNull)setLow=othIsReflexive&&othIsDefined&&(retHighest||!othIsNull);else if(valIsSymbol)setLow=othIsReflexive&&othIsDefined&&!othIsNull&&(retHighest||!othIsSymbol);else if(othIsNull||othIsSymbol)setLow=false;else setLow=
retHighest?computed<=value:computed<value;if(setLow)low=mid+1;else high=mid}return nativeMin(high,MAX_ARRAY_INDEX)}function baseSortedUniq(array,iteratee){var index=-1,length=array.length,resIndex=0,result=[];while(++index<length){var value=array[index],computed=iteratee?iteratee(value):value;if(!index||!eq(computed,seen)){var seen=computed;result[resIndex++]=value===0?0:value}}return result}function baseToNumber(value){if(typeof value=="number")return value;if(isSymbol(value))return NAN;return+value}
function baseToString(value){if(typeof value=="string")return value;if(isArray(value))return arrayMap(value,baseToString)+"";if(isSymbol(value))return symbolToString?symbolToString.call(value):"";var result=value+"";return result=="0"&&1/value==-INFINITY?"-0":result}function baseUniq(array,iteratee,comparator){var index=-1,includes=arrayIncludes,length=array.length,isCommon=true,result=[],seen=result;if(comparator){isCommon=false;includes=arrayIncludesWith}else if(length>=LARGE_ARRAY_SIZE){var set=
iteratee?null:createSet(array);if(set)return setToArray(set);isCommon=false;includes=cacheHas;seen=new SetCache}else seen=iteratee?[]:result;outer:while(++index<length){var value=array[index],computed=iteratee?iteratee(value):value;value=comparator||value!==0?value:0;if(isCommon&&computed===computed){var seenIndex=seen.length;while(seenIndex--)if(seen[seenIndex]===computed)continue outer;if(iteratee)seen.push(computed);result.push(value)}else if(!includes(seen,computed,comparator)){if(seen!==result)seen.push(computed);
result.push(value)}}return result}function baseUnset(object,path){path=castPath(path,object);object=parent(object,path);return object==null||delete object[toKey(last(path))]}function baseUpdate(object,path,updater,customizer){return baseSet(object,path,updater(baseGet(object,path)),customizer)}function baseWhile(array,predicate,isDrop,fromRight){var length=array.length,index=fromRight?length:-1;while((fromRight?index--:++index<length)&&predicate(array[index],index,array));return isDrop?baseSlice(array,
fromRight?0:index,fromRight?index+1:length):baseSlice(array,fromRight?index+1:0,fromRight?length:index)}function baseWrapperValue(value,actions){var result=value;if(result instanceof LazyWrapper)result=result.value();return arrayReduce(actions,function(result,action){return action.func.apply(action.thisArg,arrayPush([result],action.args))},result)}function baseXor(arrays,iteratee,comparator){var length=arrays.length;if(length<2)return length?baseUniq(arrays[0]):[];var index=-1,result=Array(length);
while(++index<length){var array=arrays[index],othIndex=-1;while(++othIndex<length)if(othIndex!=index)result[index]=baseDifference(result[index]||array,arrays[othIndex],iteratee,comparator)}return baseUniq(baseFlatten(result,1),iteratee,comparator)}function baseZipObject(props,values,assignFunc){var index=-1,length=props.length,valsLength=values.length,result={};while(++index<length){var value=index<valsLength?values[index]:undefined;assignFunc(result,props[index],value)}return result}function castArrayLikeObject(value){return isArrayLikeObject(value)?
value:[]}function castFunction(value){return typeof value=="function"?value:identity}function castPath(value,object){if(isArray(value))return value;return isKey(value,object)?[value]:stringToPath(toString(value))}var castRest=baseRest;function castSlice(array,start,end){var length=array.length;end=end===undefined?length:end;return!start&&end>=length?array:baseSlice(array,start,end)}var clearTimeout=ctxClearTimeout||function(id){return root.clearTimeout(id)};function cloneBuffer(buffer,isDeep){if(isDeep)return buffer.slice();
var length=buffer.length,result=allocUnsafe?allocUnsafe(length):new buffer.constructor(length);buffer.copy(result);return result}function cloneArrayBuffer(arrayBuffer){var result=new arrayBuffer.constructor(arrayBuffer.byteLength);(new Uint8Array(result)).set(new Uint8Array(arrayBuffer));return result}function cloneDataView(dataView,isDeep){var buffer=isDeep?cloneArrayBuffer(dataView.buffer):dataView.buffer;return new dataView.constructor(buffer,dataView.byteOffset,dataView.byteLength)}function cloneRegExp(regexp){var result=
new regexp.constructor(regexp.source,reFlags.exec(regexp));result.lastIndex=regexp.lastIndex;return result}function cloneSymbol(symbol){return symbolValueOf?Object(symbolValueOf.call(symbol)):{}}function cloneTypedArray(typedArray,isDeep){var buffer=isDeep?cloneArrayBuffer(typedArray.buffer):typedArray.buffer;return new typedArray.constructor(buffer,typedArray.byteOffset,typedArray.length)}function compareAscending(value,other){if(value!==other){var valIsDefined=value!==undefined,valIsNull=value===
null,valIsReflexive=value===value,valIsSymbol=isSymbol(value);var othIsDefined=other!==undefined,othIsNull=other===null,othIsReflexive=other===other,othIsSymbol=isSymbol(other);if(!othIsNull&&!othIsSymbol&&!valIsSymbol&&value>other||valIsSymbol&&othIsDefined&&othIsReflexive&&!othIsNull&&!othIsSymbol||valIsNull&&othIsDefined&&othIsReflexive||!valIsDefined&&othIsReflexive||!valIsReflexive)return 1;if(!valIsNull&&!valIsSymbol&&!othIsSymbol&&value<other||othIsSymbol&&valIsDefined&&valIsReflexive&&!valIsNull&&
!valIsSymbol||othIsNull&&valIsDefined&&valIsReflexive||!othIsDefined&&valIsReflexive||!othIsReflexive)return-1}return 0}function compareMultiple(object,other,orders){var index=-1,objCriteria=object.criteria,othCriteria=other.criteria,length=objCriteria.length,ordersLength=orders.length;while(++index<length){var result=compareAscending(objCriteria[index],othCriteria[index]);if(result){if(index>=ordersLength)return result;var order=orders[index];return result*(order=="desc"?-1:1)}}return object.index-
other.index}function composeArgs(args,partials,holders,isCurried){var argsIndex=-1,argsLength=args.length,holdersLength=holders.length,leftIndex=-1,leftLength=partials.length,rangeLength=nativeMax(argsLength-holdersLength,0),result=Array(leftLength+rangeLength),isUncurried=!isCurried;while(++leftIndex<leftLength)result[leftIndex]=partials[leftIndex];while(++argsIndex<holdersLength)if(isUncurried||argsIndex<argsLength)result[holders[argsIndex]]=args[argsIndex];while(rangeLength--)result[leftIndex++]=
args[argsIndex++];return result}function composeArgsRight(args,partials,holders,isCurried){var argsIndex=-1,argsLength=args.length,holdersIndex=-1,holdersLength=holders.length,rightIndex=-1,rightLength=partials.length,rangeLength=nativeMax(argsLength-holdersLength,0),result=Array(rangeLength+rightLength),isUncurried=!isCurried;while(++argsIndex<rangeLength)result[argsIndex]=args[argsIndex];var offset=argsIndex;while(++rightIndex<rightLength)result[offset+rightIndex]=partials[rightIndex];while(++holdersIndex<
holdersLength)if(isUncurried||argsIndex<argsLength)result[offset+holders[holdersIndex]]=args[argsIndex++];return result}function copyArray(source,array){var index=-1,length=source.length;array||(array=Array(length));while(++index<length)array[index]=source[index];return array}function copyObject(source,props,object,customizer){var isNew=!object;object||(object={});var index=-1,length=props.length;while(++index<length){var key=props[index];var newValue=customizer?customizer(object[key],source[key],
key,object,source):undefined;if(newValue===undefined)newValue=source[key];if(isNew)baseAssignValue(object,key,newValue);else assignValue(object,key,newValue)}return object}function copySymbols(source,object){return copyObject(source,getSymbols(source),object)}function copySymbolsIn(source,object){return copyObject(source,getSymbolsIn(source),object)}function createAggregator(setter,initializer){return function(collection,iteratee){var func=isArray(collection)?arrayAggregator:baseAggregator,accumulator=
initializer?initializer():{};return func(collection,setter,getIteratee(iteratee,2),accumulator)}}function createAssigner(assigner){return baseRest(function(object,sources){var index=-1,length=sources.length,customizer=length>1?sources[length-1]:undefined,guard=length>2?sources[2]:undefined;customizer=assigner.length>3&&typeof customizer=="function"?(length--,customizer):undefined;if(guard&&isIterateeCall(sources[0],sources[1],guard)){customizer=length<3?undefined:customizer;length=1}object=Object(object);
while(++index<length){var source=sources[index];if(source)assigner(object,source,index,customizer)}return object})}function createBaseEach(eachFunc,fromRight){return function(collection,iteratee){if(collection==null)return collection;if(!isArrayLike(collection))return eachFunc(collection,iteratee);var length=collection.length,index=fromRight?length:-1,iterable=Object(collection);while(fromRight?index--:++index<length)if(iteratee(iterable[index],index,iterable)===false)break;return collection}}function createBaseFor(fromRight){return function(object,
iteratee,keysFunc){var index=-1,iterable=Object(object),props=keysFunc(object),length=props.length;while(length--){var key=props[fromRight?length:++index];if(iteratee(iterable[key],key,iterable)===false)break}return object}}function createBind(func,bitmask,thisArg){var isBind=bitmask&WRAP_BIND_FLAG,Ctor=createCtor(func);function wrapper(){var fn=this&&this!==root&&this instanceof wrapper?Ctor:func;return fn.apply(isBind?thisArg:this,arguments)}return wrapper}function createCaseFirst(methodName){return function(string){string=
toString(string);var strSymbols=hasUnicode(string)?stringToArray(string):undefined;var chr=strSymbols?strSymbols[0]:string.charAt(0);var trailing=strSymbols?castSlice(strSymbols,1).join(""):string.slice(1);return chr[methodName]()+trailing}}function createCompounder(callback){return function(string){return arrayReduce(words(deburr(string).replace(reApos,"")),callback,"")}}function createCtor(Ctor){return function(){var args=arguments;switch(args.length){case 0:return new Ctor;case 1:return new Ctor(args[0]);
case 2:return new Ctor(args[0],args[1]);case 3:return new Ctor(args[0],args[1],args[2]);case 4:return new Ctor(args[0],args[1],args[2],args[3]);case 5:return new Ctor(args[0],args[1],args[2],args[3],args[4]);case 6:return new Ctor(args[0],args[1],args[2],args[3],args[4],args[5]);case 7:return new Ctor(args[0],args[1],args[2],args[3],args[4],args[5],args[6])}var thisBinding=baseCreate(Ctor.prototype),result=Ctor.apply(thisBinding,args);return isObject(result)?result:thisBinding}}function createCurry(func,
bitmask,arity){var Ctor=createCtor(func);function wrapper(){var length=arguments.length,args=Array(length),index=length,placeholder=getHolder(wrapper);while(index--)args[index]=arguments[index];var holders=length<3&&args[0]!==placeholder&&args[length-1]!==placeholder?[]:replaceHolders(args,placeholder);length-=holders.length;if(length<arity)return createRecurry(func,bitmask,createHybrid,wrapper.placeholder,undefined,args,holders,undefined,undefined,arity-length);var fn=this&&this!==root&&this instanceof
wrapper?Ctor:func;return apply(fn,this,args)}return wrapper}function createFind(findIndexFunc){return function(collection,predicate,fromIndex){var iterable=Object(collection);if(!isArrayLike(collection)){var iteratee=getIteratee(predicate,3);collection=keys(collection);predicate=function(key){return iteratee(iterable[key],key,iterable)}}var index=findIndexFunc(collection,predicate,fromIndex);return index>-1?iterable[iteratee?collection[index]:index]:undefined}}function createFlow(fromRight){return flatRest(function(funcs){var length=
funcs.length,index=length,prereq=LodashWrapper.prototype.thru;if(fromRight)funcs.reverse();while(index--){var func=funcs[index];if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);if(prereq&&!wrapper&&getFuncName(func)=="wrapper")var wrapper=new LodashWrapper([],true)}index=wrapper?index:length;while(++index<length){func=funcs[index];var funcName=getFuncName(func),data=funcName=="wrapper"?getData(func):undefined;if(data&&isLaziable(data[0])&&data[1]==(WRAP_ARY_FLAG|WRAP_CURRY_FLAG|WRAP_PARTIAL_FLAG|
WRAP_REARG_FLAG)&&!data[4].length&&data[9]==1)wrapper=wrapper[getFuncName(data[0])].apply(wrapper,data[3]);else wrapper=func.length==1&&isLaziable(func)?wrapper[funcName]():wrapper.thru(func)}return function(){var args=arguments,value=args[0];if(wrapper&&args.length==1&&isArray(value))return wrapper.plant(value).value();var index=0,result=length?funcs[index].apply(this,args):value;while(++index<length)result=funcs[index].call(this,result);return result}})}function createHybrid(func,bitmask,thisArg,
partials,holders,partialsRight,holdersRight,argPos,ary,arity){var isAry=bitmask&WRAP_ARY_FLAG,isBind=bitmask&WRAP_BIND_FLAG,isBindKey=bitmask&WRAP_BIND_KEY_FLAG,isCurried=bitmask&(WRAP_CURRY_FLAG|WRAP_CURRY_RIGHT_FLAG),isFlip=bitmask&WRAP_FLIP_FLAG,Ctor=isBindKey?undefined:createCtor(func);function wrapper(){var length=arguments.length,args=Array(length),index=length;while(index--)args[index]=arguments[index];if(isCurried)var placeholder=getHolder(wrapper),holdersCount=countHolders(args,placeholder);
if(partials)args=composeArgs(args,partials,holders,isCurried);if(partialsRight)args=composeArgsRight(args,partialsRight,holdersRight,isCurried);length-=holdersCount;if(isCurried&&length<arity){var newHolders=replaceHolders(args,placeholder);return createRecurry(func,bitmask,createHybrid,wrapper.placeholder,thisArg,args,newHolders,argPos,ary,arity-length)}var thisBinding=isBind?thisArg:this,fn=isBindKey?thisBinding[func]:func;length=args.length;if(argPos)args=reorder(args,argPos);else if(isFlip&&length>
1)args.reverse();if(isAry&&ary<length)args.length=ary;if(this&&this!==root&&this instanceof wrapper)fn=Ctor||createCtor(fn);return fn.apply(thisBinding,args)}return wrapper}function createInverter(setter,toIteratee){return function(object,iteratee){return baseInverter(object,setter,toIteratee(iteratee),{})}}function createMathOperation(operator,defaultValue){return function(value,other){var result;if(value===undefined&&other===undefined)return defaultValue;if(value!==undefined)result=value;if(other!==
undefined){if(result===undefined)return other;if(typeof value=="string"||typeof other=="string"){value=baseToString(value);other=baseToString(other)}else{value=baseToNumber(value);other=baseToNumber(other)}result=operator(value,other)}return result}}function createOver(arrayFunc){return flatRest(function(iteratees){iteratees=arrayMap(iteratees,baseUnary(getIteratee()));return baseRest(function(args){var thisArg=this;return arrayFunc(iteratees,function(iteratee){return apply(iteratee,thisArg,args)})})})}
function createPadding(length,chars){chars=chars===undefined?" ":baseToString(chars);var charsLength=chars.length;if(charsLength<2)return charsLength?baseRepeat(chars,length):chars;var result=baseRepeat(chars,nativeCeil(length/stringSize(chars)));return hasUnicode(chars)?castSlice(stringToArray(result),0,length).join(""):result.slice(0,length)}function createPartial(func,bitmask,thisArg,partials){var isBind=bitmask&WRAP_BIND_FLAG,Ctor=createCtor(func);function wrapper(){var argsIndex=-1,argsLength=
arguments.length,leftIndex=-1,leftLength=partials.length,args=Array(leftLength+argsLength),fn=this&&this!==root&&this instanceof wrapper?Ctor:func;while(++leftIndex<leftLength)args[leftIndex]=partials[leftIndex];while(argsLength--)args[leftIndex++]=arguments[++argsIndex];return apply(fn,isBind?thisArg:this,args)}return wrapper}function createRange(fromRight){return function(start,end,step){if(step&&typeof step!="number"&&isIterateeCall(start,end,step))end=step=undefined;start=toFinite(start);if(end===
undefined){end=start;start=0}else end=toFinite(end);step=step===undefined?start<end?1:-1:toFinite(step);return baseRange(start,end,step,fromRight)}}function createRelationalOperation(operator){return function(value,other){if(!(typeof value=="string"&&typeof other=="string")){value=toNumber(value);other=toNumber(other)}return operator(value,other)}}function createRecurry(func,bitmask,wrapFunc,placeholder,thisArg,partials,holders,argPos,ary,arity){var isCurry=bitmask&WRAP_CURRY_FLAG,newHolders=isCurry?
holders:undefined,newHoldersRight=isCurry?undefined:holders,newPartials=isCurry?partials:undefined,newPartialsRight=isCurry?undefined:partials;bitmask|=isCurry?WRAP_PARTIAL_FLAG:WRAP_PARTIAL_RIGHT_FLAG;bitmask&=~(isCurry?WRAP_PARTIAL_RIGHT_FLAG:WRAP_PARTIAL_FLAG);if(!(bitmask&WRAP_CURRY_BOUND_FLAG))bitmask&=~(WRAP_BIND_FLAG|WRAP_BIND_KEY_FLAG);var newData=[func,bitmask,thisArg,newPartials,newHolders,newPartialsRight,newHoldersRight,argPos,ary,arity];var result=wrapFunc.apply(undefined,newData);if(isLaziable(func))setData(result,
newData);result.placeholder=placeholder;return setWrapToString(result,func,bitmask)}function createRound(methodName){var func=Math[methodName];return function(number,precision){number=toNumber(number);precision=precision==null?0:nativeMin(toInteger(precision),292);if(precision){var pair=(toString(number)+"e").split("e"),value=func(pair[0]+"e"+(+pair[1]+precision));pair=(toString(value)+"e").split("e");return+(pair[0]+"e"+(+pair[1]-precision))}return func(number)}}var createSet=!(Set&&1/setToArray(new Set([,
-0]))[1]==INFINITY)?noop:function(values){return new Set(values)};function createToPairs(keysFunc){return function(object){var tag=getTag(object);if(tag==mapTag)return mapToArray(object);if(tag==setTag)return setToPairs(object);return baseToPairs(object,keysFunc(object))}}function createWrap(func,bitmask,thisArg,partials,holders,argPos,ary,arity){var isBindKey=bitmask&WRAP_BIND_KEY_FLAG;if(!isBindKey&&typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);var length=partials?partials.length:
0;if(!length){bitmask&=~(WRAP_PARTIAL_FLAG|WRAP_PARTIAL_RIGHT_FLAG);partials=holders=undefined}ary=ary===undefined?ary:nativeMax(toInteger(ary),0);arity=arity===undefined?arity:toInteger(arity);length-=holders?holders.length:0;if(bitmask&WRAP_PARTIAL_RIGHT_FLAG){var partialsRight=partials,holdersRight=holders;partials=holders=undefined}var data=isBindKey?undefined:getData(func);var newData=[func,bitmask,thisArg,partials,holders,partialsRight,holdersRight,argPos,ary,arity];if(data)mergeData(newData,
data);func=newData[0];bitmask=newData[1];thisArg=newData[2];partials=newData[3];holders=newData[4];arity=newData[9]=newData[9]===undefined?isBindKey?0:func.length:nativeMax(newData[9]-length,0);if(!arity&&bitmask&(WRAP_CURRY_FLAG|WRAP_CURRY_RIGHT_FLAG))bitmask&=~(WRAP_CURRY_FLAG|WRAP_CURRY_RIGHT_FLAG);if(!bitmask||bitmask==WRAP_BIND_FLAG)var result=createBind(func,bitmask,thisArg);else if(bitmask==WRAP_CURRY_FLAG||bitmask==WRAP_CURRY_RIGHT_FLAG)result=createCurry(func,bitmask,arity);else if((bitmask==
WRAP_PARTIAL_FLAG||bitmask==(WRAP_BIND_FLAG|WRAP_PARTIAL_FLAG))&&!holders.length)result=createPartial(func,bitmask,thisArg,partials);else result=createHybrid.apply(undefined,newData);var setter=data?baseSetData:setData;return setWrapToString(setter(result,newData),func,bitmask)}function customDefaultsAssignIn(objValue,srcValue,key,object){if(objValue===undefined||eq(objValue,objectProto[key])&&!hasOwnProperty.call(object,key))return srcValue;return objValue}function customDefaultsMerge(objValue,srcValue,
key,object,source,stack){if(isObject(objValue)&&isObject(srcValue)){stack.set(srcValue,objValue);baseMerge(objValue,srcValue,undefined,customDefaultsMerge,stack);stack["delete"](srcValue)}return objValue}function customOmitClone(value){return isPlainObject(value)?undefined:value}function equalArrays(array,other,bitmask,customizer,equalFunc,stack){var isPartial=bitmask&COMPARE_PARTIAL_FLAG,arrLength=array.length,othLength=other.length;if(arrLength!=othLength&&!(isPartial&&othLength>arrLength))return false;
var stacked=stack.get(array);if(stacked&&stack.get(other))return stacked==other;var index=-1,result=true,seen=bitmask&COMPARE_UNORDERED_FLAG?new SetCache:undefined;stack.set(array,other);stack.set(other,array);while(++index<arrLength){var arrValue=array[index],othValue=other[index];if(customizer)var compared=isPartial?customizer(othValue,arrValue,index,other,array,stack):customizer(arrValue,othValue,index,array,other,stack);if(compared!==undefined){if(compared)continue;result=false;break}if(seen){if(!arraySome(other,
function(othValue,othIndex){if(!cacheHas(seen,othIndex)&&(arrValue===othValue||equalFunc(arrValue,othValue,bitmask,customizer,stack)))return seen.push(othIndex)})){result=false;break}}else if(!(arrValue===othValue||equalFunc(arrValue,othValue,bitmask,customizer,stack))){result=false;break}}stack["delete"](array);stack["delete"](other);return result}function equalByTag(object,other,tag,bitmask,customizer,equalFunc,stack){switch(tag){case dataViewTag:if(object.byteLength!=other.byteLength||object.byteOffset!=
other.byteOffset)return false;object=object.buffer;other=other.buffer;case arrayBufferTag:if(object.byteLength!=other.byteLength||!equalFunc(new Uint8Array(object),new Uint8Array(other)))return false;return true;case boolTag:case dateTag:case numberTag:return eq(+object,+other);case errorTag:return object.name==other.name&&object.message==other.message;case regexpTag:case stringTag:return object==other+"";case mapTag:var convert=mapToArray;case setTag:var isPartial=bitmask&COMPARE_PARTIAL_FLAG;convert||
(convert=setToArray);if(object.size!=other.size&&!isPartial)return false;var stacked=stack.get(object);if(stacked)return stacked==other;bitmask|=COMPARE_UNORDERED_FLAG;stack.set(object,other);var result=equalArrays(convert(object),convert(other),bitmask,customizer,equalFunc,stack);stack["delete"](object);return result;case symbolTag:if(symbolValueOf)return symbolValueOf.call(object)==symbolValueOf.call(other)}return false}function equalObjects(object,other,bitmask,customizer,equalFunc,stack){var isPartial=
bitmask&COMPARE_PARTIAL_FLAG,objProps=getAllKeys(object),objLength=objProps.length,othProps=getAllKeys(other),othLength=othProps.length;if(objLength!=othLength&&!isPartial)return false;var index=objLength;while(index--){var key=objProps[index];if(!(isPartial?key in other:hasOwnProperty.call(other,key)))return false}var stacked=stack.get(object);if(stacked&&stack.get(other))return stacked==other;var result=true;stack.set(object,other);stack.set(other,object);var skipCtor=isPartial;while(++index<objLength){key=
objProps[index];var objValue=object[key],othValue=other[key];if(customizer)var compared=isPartial?customizer(othValue,objValue,key,other,object,stack):customizer(objValue,othValue,key,object,other,stack);if(!(compared===undefined?objValue===othValue||equalFunc(objValue,othValue,bitmask,customizer,stack):compared)){result=false;break}skipCtor||(skipCtor=key=="constructor")}if(result&&!skipCtor){var objCtor=object.constructor,othCtor=other.constructor;if(objCtor!=othCtor&&("constructor"in object&&"constructor"in
other)&&!(typeof objCtor=="function"&&objCtor instanceof objCtor&&typeof othCtor=="function"&&othCtor instanceof othCtor))result=false}stack["delete"](object);stack["delete"](other);return result}function flatRest(func){return setToString(overRest(func,undefined,flatten),func+"")}function getAllKeys(object){return baseGetAllKeys(object,keys,getSymbols)}function getAllKeysIn(object){return baseGetAllKeys(object,keysIn,getSymbolsIn)}var getData=!metaMap?noop:function(func){return metaMap.get(func)};
function getFuncName(func){var result=func.name+"",array=realNames[result],length=hasOwnProperty.call(realNames,result)?array.length:0;while(length--){var data=array[length],otherFunc=data.func;if(otherFunc==null||otherFunc==func)return data.name}return result}function getHolder(func){var object=hasOwnProperty.call(lodash,"placeholder")?lodash:func;return object.placeholder}function getIteratee(){var result=lodash.iteratee||iteratee;result=result===iteratee?baseIteratee:result;return arguments.length?
result(arguments[0],arguments[1]):result}function getMapData(map,key){var data=map.__data__;return isKeyable(key)?data[typeof key=="string"?"string":"hash"]:data.map}function getMatchData(object){var result=keys(object),length=result.length;while(length--){var key=result[length],value=object[key];result[length]=[key,value,isStrictComparable(value)]}return result}function getNative(object,key){var value=getValue(object,key);return baseIsNative(value)?value:undefined}function getRawTag(value){var isOwn=
hasOwnProperty.call(value,symToStringTag),tag=value[symToStringTag];try{value[symToStringTag]=undefined;var unmasked=true}catch(e){}var result=nativeObjectToString.call(value);if(unmasked)if(isOwn)value[symToStringTag]=tag;else delete value[symToStringTag];return result}var getSymbols=!nativeGetSymbols?stubArray:function(object){if(object==null)return[];object=Object(object);return arrayFilter(nativeGetSymbols(object),function(symbol){return propertyIsEnumerable.call(object,symbol)})};var getSymbolsIn=
!nativeGetSymbols?stubArray:function(object){var result=[];while(object){arrayPush(result,getSymbols(object));object=getPrototype(object)}return result};var getTag=baseGetTag;if(DataView&&getTag(new DataView(new ArrayBuffer(1)))!=dataViewTag||Map&&getTag(new Map)!=mapTag||Promise&&getTag(Promise.resolve())!=promiseTag||Set&&getTag(new Set)!=setTag||WeakMap&&getTag(new WeakMap)!=weakMapTag)getTag=function(value){var result=baseGetTag(value),Ctor=result==objectTag?value.constructor:undefined,ctorString=
Ctor?toSource(Ctor):"";if(ctorString)switch(ctorString){case dataViewCtorString:return dataViewTag;case mapCtorString:return mapTag;case promiseCtorString:return promiseTag;case setCtorString:return setTag;case weakMapCtorString:return weakMapTag}return result};function getView(start,end,transforms){var index=-1,length=transforms.length;while(++index<length){var data=transforms[index],size=data.size;switch(data.type){case "drop":start+=size;break;case "dropRight":end-=size;break;case "take":end=nativeMin(end,
start+size);break;case "takeRight":start=nativeMax(start,end-size);break}}return{"start":start,"end":end}}function getWrapDetails(source){var match=source.match(reWrapDetails);return match?match[1].split(reSplitDetails):[]}function hasPath(object,path,hasFunc){path=castPath(path,object);var index=-1,length=path.length,result=false;while(++index<length){var key=toKey(path[index]);if(!(result=object!=null&&hasFunc(object,key)))break;object=object[key]}if(result||++index!=length)return result;length=
object==null?0:object.length;return!!length&&isLength(length)&&isIndex(key,length)&&(isArray(object)||isArguments(object))}function initCloneArray(array){var length=array.length,result=new array.constructor(length);if(length&&typeof array[0]=="string"&&hasOwnProperty.call(array,"index")){result.index=array.index;result.input=array.input}return result}function initCloneObject(object){return typeof object.constructor=="function"&&!isPrototype(object)?baseCreate(getPrototype(object)):{}}function initCloneByTag(object,
tag,isDeep){var Ctor=object.constructor;switch(tag){case arrayBufferTag:return cloneArrayBuffer(object);case boolTag:case dateTag:return new Ctor(+object);case dataViewTag:return cloneDataView(object,isDeep);case float32Tag:case float64Tag:case int8Tag:case int16Tag:case int32Tag:case uint8Tag:case uint8ClampedTag:case uint16Tag:case uint32Tag:return cloneTypedArray(object,isDeep);case mapTag:return new Ctor;case numberTag:case stringTag:return new Ctor(object);case regexpTag:return cloneRegExp(object);
case setTag:return new Ctor;case symbolTag:return cloneSymbol(object)}}function insertWrapDetails(source,details){var length=details.length;if(!length)return source;var lastIndex=length-1;details[lastIndex]=(length>1?"\x26 ":"")+details[lastIndex];details=details.join(length>2?", ":" ");return source.replace(reWrapComment,"{\n/* [wrapped with "+details+"] */\n")}function isFlattenable(value){return isArray(value)||isArguments(value)||!!(spreadableSymbol&&value&&value[spreadableSymbol])}function isIndex(value,
length){var type=typeof value;length=length==null?MAX_SAFE_INTEGER:length;return!!length&&(type=="number"||type!="symbol"&&reIsUint.test(value))&&(value>-1&&value%1==0&&value<length)}function isIterateeCall(value,index,object){if(!isObject(object))return false;var type=typeof index;if(type=="number"?isArrayLike(object)&&isIndex(index,object.length):type=="string"&&index in object)return eq(object[index],value);return false}function isKey(value,object){if(isArray(value))return false;var type=typeof value;
if(type=="number"||type=="symbol"||type=="boolean"||value==null||isSymbol(value))return true;return reIsPlainProp.test(value)||!reIsDeepProp.test(value)||object!=null&&value in Object(object)}function isKeyable(value){var type=typeof value;return type=="string"||type=="number"||type=="symbol"||type=="boolean"?value!=="__proto__":value===null}function isLaziable(func){var funcName=getFuncName(func),other=lodash[funcName];if(typeof other!="function"||!(funcName in LazyWrapper.prototype))return false;
if(func===other)return true;var data=getData(other);return!!data&&func===data[0]}function isMasked(func){return!!maskSrcKey&&maskSrcKey in func}var isMaskable=coreJsData?isFunction:stubFalse;function isPrototype(value){var Ctor=value&&value.constructor,proto=typeof Ctor=="function"&&Ctor.prototype||objectProto;return value===proto}function isStrictComparable(value){return value===value&&!isObject(value)}function matchesStrictComparable(key,srcValue){return function(object){if(object==null)return false;
return object[key]===srcValue&&(srcValue!==undefined||key in Object(object))}}function memoizeCapped(func){var result=memoize(func,function(key){if(cache.size===MAX_MEMOIZE_SIZE)cache.clear();return key});var cache=result.cache;return result}function mergeData(data,source){var bitmask=data[1],srcBitmask=source[1],newBitmask=bitmask|srcBitmask,isCommon=newBitmask<(WRAP_BIND_FLAG|WRAP_BIND_KEY_FLAG|WRAP_ARY_FLAG);var isCombo=srcBitmask==WRAP_ARY_FLAG&&bitmask==WRAP_CURRY_FLAG||srcBitmask==WRAP_ARY_FLAG&&
bitmask==WRAP_REARG_FLAG&&data[7].length<=source[8]||srcBitmask==(WRAP_ARY_FLAG|WRAP_REARG_FLAG)&&source[7].length<=source[8]&&bitmask==WRAP_CURRY_FLAG;if(!(isCommon||isCombo))return data;if(srcBitmask&WRAP_BIND_FLAG){data[2]=source[2];newBitmask|=bitmask&WRAP_BIND_FLAG?0:WRAP_CURRY_BOUND_FLAG}var value=source[3];if(value){var partials=data[3];data[3]=partials?composeArgs(partials,value,source[4]):value;data[4]=partials?replaceHolders(data[3],PLACEHOLDER):source[4]}value=source[5];if(value){partials=
data[5];data[5]=partials?composeArgsRight(partials,value,source[6]):value;data[6]=partials?replaceHolders(data[5],PLACEHOLDER):source[6]}value=source[7];if(value)data[7]=value;if(srcBitmask&WRAP_ARY_FLAG)data[8]=data[8]==null?source[8]:nativeMin(data[8],source[8]);if(data[9]==null)data[9]=source[9];data[0]=source[0];data[1]=newBitmask;return data}function nativeKeysIn(object){var result=[];if(object!=null)for(var key in Object(object))result.push(key);return result}function objectToString(value){return nativeObjectToString.call(value)}
function overRest(func,start,transform){start=nativeMax(start===undefined?func.length-1:start,0);return function(){var args=arguments,index=-1,length=nativeMax(args.length-start,0),array=Array(length);while(++index<length)array[index]=args[start+index];index=-1;var otherArgs=Array(start+1);while(++index<start)otherArgs[index]=args[index];otherArgs[start]=transform(array);return apply(func,this,otherArgs)}}function parent(object,path){return path.length<2?object:baseGet(object,baseSlice(path,0,-1))}
function reorder(array,indexes){var arrLength=array.length,length=nativeMin(indexes.length,arrLength),oldArray=copyArray(array);while(length--){var index=indexes[length];array[length]=isIndex(index,arrLength)?oldArray[index]:undefined}return array}var setData=shortOut(baseSetData);var setTimeout=ctxSetTimeout||function(func,wait){return root.setTimeout(func,wait)};var setToString=shortOut(baseSetToString);function setWrapToString(wrapper,reference,bitmask){var source=reference+"";return setToString(wrapper,
insertWrapDetails(source,updateWrapDetails(getWrapDetails(source),bitmask)))}function shortOut(func){var count=0,lastCalled=0;return function(){var stamp=nativeNow(),remaining=HOT_SPAN-(stamp-lastCalled);lastCalled=stamp;if(remaining>0){if(++count>=HOT_COUNT)return arguments[0]}else count=0;return func.apply(undefined,arguments)}}function shuffleSelf(array,size){var index=-1,length=array.length,lastIndex=length-1;size=size===undefined?length:size;while(++index<size){var rand=baseRandom(index,lastIndex),
value=array[rand];array[rand]=array[index];array[index]=value}array.length=size;return array}var stringToPath=memoizeCapped(function(string){var result=[];if(string.charCodeAt(0)===46)result.push("");string.replace(rePropName,function(match,number,quote,subString){result.push(quote?subString.replace(reEscapeChar,"$1"):number||match)});return result});function toKey(value){if(typeof value=="string"||isSymbol(value))return value;var result=value+"";return result=="0"&&1/value==-INFINITY?"-0":result}
function toSource(func){if(func!=null){try{return funcToString.call(func)}catch(e){}try{return func+""}catch(e$0){}}return""}function updateWrapDetails(details,bitmask){arrayEach(wrapFlags,function(pair){var value="_."+pair[0];if(bitmask&pair[1]&&!arrayIncludes(details,value))details.push(value)});return details.sort()}function wrapperClone(wrapper){if(wrapper instanceof LazyWrapper)return wrapper.clone();var result=new LodashWrapper(wrapper.__wrapped__,wrapper.__chain__);result.__actions__=copyArray(wrapper.__actions__);
result.__index__=wrapper.__index__;result.__values__=wrapper.__values__;return result}function chunk(array,size,guard){if(guard?isIterateeCall(array,size,guard):size===undefined)size=1;else size=nativeMax(toInteger(size),0);var length=array==null?0:array.length;if(!length||size<1)return[];var index=0,resIndex=0,result=Array(nativeCeil(length/size));while(index<length)result[resIndex++]=baseSlice(array,index,index+=size);return result}function compact(array){var index=-1,length=array==null?0:array.length,
resIndex=0,result=[];while(++index<length){var value=array[index];if(value)result[resIndex++]=value}return result}function concat(){var length=arguments.length;if(!length)return[];var args=Array(length-1),array=arguments[0],index=length;while(index--)args[index-1]=arguments[index];return arrayPush(isArray(array)?copyArray(array):[array],baseFlatten(args,1))}var difference=baseRest(function(array,values){return isArrayLikeObject(array)?baseDifference(array,baseFlatten(values,1,isArrayLikeObject,true)):
[]});var differenceBy=baseRest(function(array,values){var iteratee=last(values);if(isArrayLikeObject(iteratee))iteratee=undefined;return isArrayLikeObject(array)?baseDifference(array,baseFlatten(values,1,isArrayLikeObject,true),getIteratee(iteratee,2)):[]});var differenceWith=baseRest(function(array,values){var comparator=last(values);if(isArrayLikeObject(comparator))comparator=undefined;return isArrayLikeObject(array)?baseDifference(array,baseFlatten(values,1,isArrayLikeObject,true),undefined,comparator):
[]});function drop(array,n,guard){var length=array==null?0:array.length;if(!length)return[];n=guard||n===undefined?1:toInteger(n);return baseSlice(array,n<0?0:n,length)}function dropRight(array,n,guard){var length=array==null?0:array.length;if(!length)return[];n=guard||n===undefined?1:toInteger(n);n=length-n;return baseSlice(array,0,n<0?0:n)}function dropRightWhile(array,predicate){return array&&array.length?baseWhile(array,getIteratee(predicate,3),true,true):[]}function dropWhile(array,predicate){return array&&
array.length?baseWhile(array,getIteratee(predicate,3),true):[]}function fill(array,value,start,end){var length=array==null?0:array.length;if(!length)return[];if(start&&typeof start!="number"&&isIterateeCall(array,value,start)){start=0;end=length}return baseFill(array,value,start,end)}function findIndex(array,predicate,fromIndex){var length=array==null?0:array.length;if(!length)return-1;var index=fromIndex==null?0:toInteger(fromIndex);if(index<0)index=nativeMax(length+index,0);return baseFindIndex(array,
getIteratee(predicate,3),index)}function findLastIndex(array,predicate,fromIndex){var length=array==null?0:array.length;if(!length)return-1;var index=length-1;if(fromIndex!==undefined){index=toInteger(fromIndex);index=fromIndex<0?nativeMax(length+index,0):nativeMin(index,length-1)}return baseFindIndex(array,getIteratee(predicate,3),index,true)}function flatten(array){var length=array==null?0:array.length;return length?baseFlatten(array,1):[]}function flattenDeep(array){var length=array==null?0:array.length;
return length?baseFlatten(array,INFINITY):[]}function flattenDepth(array,depth){var length=array==null?0:array.length;if(!length)return[];depth=depth===undefined?1:toInteger(depth);return baseFlatten(array,depth)}function fromPairs(pairs){var index=-1,length=pairs==null?0:pairs.length,result={};while(++index<length){var pair=pairs[index];result[pair[0]]=pair[1]}return result}function head(array){return array&&array.length?array[0]:undefined}function indexOf(array,value,fromIndex){var length=array==
null?0:array.length;if(!length)return-1;var index=fromIndex==null?0:toInteger(fromIndex);if(index<0)index=nativeMax(length+index,0);return baseIndexOf(array,value,index)}function initial(array){var length=array==null?0:array.length;return length?baseSlice(array,0,-1):[]}var intersection=baseRest(function(arrays){var mapped=arrayMap(arrays,castArrayLikeObject);return mapped.length&&mapped[0]===arrays[0]?baseIntersection(mapped):[]});var intersectionBy=baseRest(function(arrays){var iteratee=last(arrays),
mapped=arrayMap(arrays,castArrayLikeObject);if(iteratee===last(mapped))iteratee=undefined;else mapped.pop();return mapped.length&&mapped[0]===arrays[0]?baseIntersection(mapped,getIteratee(iteratee,2)):[]});var intersectionWith=baseRest(function(arrays){var comparator=last(arrays),mapped=arrayMap(arrays,castArrayLikeObject);comparator=typeof comparator=="function"?comparator:undefined;if(comparator)mapped.pop();return mapped.length&&mapped[0]===arrays[0]?baseIntersection(mapped,undefined,comparator):
[]});function join(array,separator){return array==null?"":nativeJoin.call(array,separator)}function last(array){var length=array==null?0:array.length;return length?array[length-1]:undefined}function lastIndexOf(array,value,fromIndex){var length=array==null?0:array.length;if(!length)return-1;var index=length;if(fromIndex!==undefined){index=toInteger(fromIndex);index=index<0?nativeMax(length+index,0):nativeMin(index,length-1)}return value===value?strictLastIndexOf(array,value,index):baseFindIndex(array,
baseIsNaN,index,true)}function nth(array,n){return array&&array.length?baseNth(array,toInteger(n)):undefined}var pull=baseRest(pullAll);function pullAll(array,values){return array&&array.length&&values&&values.length?basePullAll(array,values):array}function pullAllBy(array,values,iteratee){return array&&array.length&&values&&values.length?basePullAll(array,values,getIteratee(iteratee,2)):array}function pullAllWith(array,values,comparator){return array&&array.length&&values&&values.length?basePullAll(array,
values,undefined,comparator):array}var pullAt=flatRest(function(array,indexes){var length=array==null?0:array.length,result=baseAt(array,indexes);basePullAt(array,arrayMap(indexes,function(index){return isIndex(index,length)?+index:index}).sort(compareAscending));return result});function remove(array,predicate){var result=[];if(!(array&&array.length))return result;var index=-1,indexes=[],length=array.length;predicate=getIteratee(predicate,3);while(++index<length){var value=array[index];if(predicate(value,
index,array)){result.push(value);indexes.push(index)}}basePullAt(array,indexes);return result}function reverse(array){return array==null?array:nativeReverse.call(array)}function slice(array,start,end){var length=array==null?0:array.length;if(!length)return[];if(end&&typeof end!="number"&&isIterateeCall(array,start,end)){start=0;end=length}else{start=start==null?0:toInteger(start);end=end===undefined?length:toInteger(end)}return baseSlice(array,start,end)}function sortedIndex(array,value){return baseSortedIndex(array,
value)}function sortedIndexBy(array,value,iteratee){return baseSortedIndexBy(array,value,getIteratee(iteratee,2))}function sortedIndexOf(array,value){var length=array==null?0:array.length;if(length){var index=baseSortedIndex(array,value);if(index<length&&eq(array[index],value))return index}return-1}function sortedLastIndex(array,value){return baseSortedIndex(array,value,true)}function sortedLastIndexBy(array,value,iteratee){return baseSortedIndexBy(array,value,getIteratee(iteratee,2),true)}function sortedLastIndexOf(array,
value){var length=array==null?0:array.length;if(length){var index=baseSortedIndex(array,value,true)-1;if(eq(array[index],value))return index}return-1}function sortedUniq(array){return array&&array.length?baseSortedUniq(array):[]}function sortedUniqBy(array,iteratee){return array&&array.length?baseSortedUniq(array,getIteratee(iteratee,2)):[]}function tail(array){var length=array==null?0:array.length;return length?baseSlice(array,1,length):[]}function take(array,n,guard){if(!(array&&array.length))return[];
n=guard||n===undefined?1:toInteger(n);return baseSlice(array,0,n<0?0:n)}function takeRight(array,n,guard){var length=array==null?0:array.length;if(!length)return[];n=guard||n===undefined?1:toInteger(n);n=length-n;return baseSlice(array,n<0?0:n,length)}function takeRightWhile(array,predicate){return array&&array.length?baseWhile(array,getIteratee(predicate,3),false,true):[]}function takeWhile(array,predicate){return array&&array.length?baseWhile(array,getIteratee(predicate,3)):[]}var union=baseRest(function(arrays){return baseUniq(baseFlatten(arrays,
1,isArrayLikeObject,true))});var unionBy=baseRest(function(arrays){var iteratee=last(arrays);if(isArrayLikeObject(iteratee))iteratee=undefined;return baseUniq(baseFlatten(arrays,1,isArrayLikeObject,true),getIteratee(iteratee,2))});var unionWith=baseRest(function(arrays){var comparator=last(arrays);comparator=typeof comparator=="function"?comparator:undefined;return baseUniq(baseFlatten(arrays,1,isArrayLikeObject,true),undefined,comparator)});function uniq(array){return array&&array.length?baseUniq(array):
[]}function uniqBy(array,iteratee){return array&&array.length?baseUniq(array,getIteratee(iteratee,2)):[]}function uniqWith(array,comparator){comparator=typeof comparator=="function"?comparator:undefined;return array&&array.length?baseUniq(array,undefined,comparator):[]}function unzip(array){if(!(array&&array.length))return[];var length=0;array=arrayFilter(array,function(group){if(isArrayLikeObject(group)){length=nativeMax(group.length,length);return true}});return baseTimes(length,function(index){return arrayMap(array,
baseProperty(index))})}function unzipWith(array,iteratee){if(!(array&&array.length))return[];var result=unzip(array);if(iteratee==null)return result;return arrayMap(result,function(group){return apply(iteratee,undefined,group)})}var without=baseRest(function(array,values){return isArrayLikeObject(array)?baseDifference(array,values):[]});var xor=baseRest(function(arrays){return baseXor(arrayFilter(arrays,isArrayLikeObject))});var xorBy=baseRest(function(arrays){var iteratee=last(arrays);if(isArrayLikeObject(iteratee))iteratee=
undefined;return baseXor(arrayFilter(arrays,isArrayLikeObject),getIteratee(iteratee,2))});var xorWith=baseRest(function(arrays){var comparator=last(arrays);comparator=typeof comparator=="function"?comparator:undefined;return baseXor(arrayFilter(arrays,isArrayLikeObject),undefined,comparator)});var zip=baseRest(unzip);function zipObject(props,values){return baseZipObject(props||[],values||[],assignValue)}function zipObjectDeep(props,values){return baseZipObject(props||[],values||[],baseSet)}var zipWith=
baseRest(function(arrays){var length=arrays.length,iteratee=length>1?arrays[length-1]:undefined;iteratee=typeof iteratee=="function"?(arrays.pop(),iteratee):undefined;return unzipWith(arrays,iteratee)});function chain(value){var result=lodash(value);result.__chain__=true;return result}function tap(value,interceptor){interceptor(value);return value}function thru(value,interceptor){return interceptor(value)}var wrapperAt=flatRest(function(paths){var length=paths.length,start=length?paths[0]:0,value=
this.__wrapped__,interceptor=function(object){return baseAt(object,paths)};if(length>1||this.__actions__.length||!(value instanceof LazyWrapper)||!isIndex(start))return this.thru(interceptor);value=value.slice(start,+start+(length?1:0));value.__actions__.push({"func":thru,"args":[interceptor],"thisArg":undefined});return(new LodashWrapper(value,this.__chain__)).thru(function(array){if(length&&!array.length)array.push(undefined);return array})});function wrapperChain(){return chain(this)}function wrapperCommit(){return new LodashWrapper(this.value(),
this.__chain__)}function wrapperNext(){if(this.__values__===undefined)this.__values__=toArray(this.value());var done=this.__index__>=this.__values__.length,value=done?undefined:this.__values__[this.__index__++];return{"done":done,"value":value}}function wrapperToIterator(){return this}function wrapperPlant(value){var result,parent=this;while(parent instanceof baseLodash){var clone=wrapperClone(parent);clone.__index__=0;clone.__values__=undefined;if(result)previous.__wrapped__=clone;else result=clone;
var previous=clone;parent=parent.__wrapped__}previous.__wrapped__=value;return result}function wrapperReverse(){var value=this.__wrapped__;if(value instanceof LazyWrapper){var wrapped=value;if(this.__actions__.length)wrapped=new LazyWrapper(this);wrapped=wrapped.reverse();wrapped.__actions__.push({"func":thru,"args":[reverse],"thisArg":undefined});return new LodashWrapper(wrapped,this.__chain__)}return this.thru(reverse)}function wrapperValue(){return baseWrapperValue(this.__wrapped__,this.__actions__)}
var countBy=createAggregator(function(result,value,key){if(hasOwnProperty.call(result,key))++result[key];else baseAssignValue(result,key,1)});function every(collection,predicate,guard){var func=isArray(collection)?arrayEvery:baseEvery;if(guard&&isIterateeCall(collection,predicate,guard))predicate=undefined;return func(collection,getIteratee(predicate,3))}function filter(collection,predicate){var func=isArray(collection)?arrayFilter:baseFilter;return func(collection,getIteratee(predicate,3))}var find=
createFind(findIndex);var findLast=createFind(findLastIndex);function flatMap(collection,iteratee){return baseFlatten(map(collection,iteratee),1)}function flatMapDeep(collection,iteratee){return baseFlatten(map(collection,iteratee),INFINITY)}function flatMapDepth(collection,iteratee,depth){depth=depth===undefined?1:toInteger(depth);return baseFlatten(map(collection,iteratee),depth)}function forEach(collection,iteratee){var func=isArray(collection)?arrayEach:baseEach;return func(collection,getIteratee(iteratee,
3))}function forEachRight(collection,iteratee){var func=isArray(collection)?arrayEachRight:baseEachRight;return func(collection,getIteratee(iteratee,3))}var groupBy=createAggregator(function(result,value,key){if(hasOwnProperty.call(result,key))result[key].push(value);else baseAssignValue(result,key,[value])});function includes(collection,value,fromIndex,guard){collection=isArrayLike(collection)?collection:values(collection);fromIndex=fromIndex&&!guard?toInteger(fromIndex):0;var length=collection.length;
if(fromIndex<0)fromIndex=nativeMax(length+fromIndex,0);return isString(collection)?fromIndex<=length&&collection.indexOf(value,fromIndex)>-1:!!length&&baseIndexOf(collection,value,fromIndex)>-1}var invokeMap=baseRest(function(collection,path,args){var index=-1,isFunc=typeof path=="function",result=isArrayLike(collection)?Array(collection.length):[];baseEach(collection,function(value){result[++index]=isFunc?apply(path,value,args):baseInvoke(value,path,args)});return result});var keyBy=createAggregator(function(result,
value,key){baseAssignValue(result,key,value)});function map(collection,iteratee){var func=isArray(collection)?arrayMap:baseMap;return func(collection,getIteratee(iteratee,3))}function orderBy(collection,iteratees,orders,guard){if(collection==null)return[];if(!isArray(iteratees))iteratees=iteratees==null?[]:[iteratees];orders=guard?undefined:orders;if(!isArray(orders))orders=orders==null?[]:[orders];return baseOrderBy(collection,iteratees,orders)}var partition=createAggregator(function(result,value,
key){result[key?0:1].push(value)},function(){return[[],[]]});function reduce(collection,iteratee,accumulator){var func=isArray(collection)?arrayReduce:baseReduce,initAccum=arguments.length<3;return func(collection,getIteratee(iteratee,4),accumulator,initAccum,baseEach)}function reduceRight(collection,iteratee,accumulator){var func=isArray(collection)?arrayReduceRight:baseReduce,initAccum=arguments.length<3;return func(collection,getIteratee(iteratee,4),accumulator,initAccum,baseEachRight)}function reject(collection,
predicate){var func=isArray(collection)?arrayFilter:baseFilter;return func(collection,negate(getIteratee(predicate,3)))}function sample(collection){var func=isArray(collection)?arraySample:baseSample;return func(collection)}function sampleSize(collection,n,guard){if(guard?isIterateeCall(collection,n,guard):n===undefined)n=1;else n=toInteger(n);var func=isArray(collection)?arraySampleSize:baseSampleSize;return func(collection,n)}function shuffle(collection){var func=isArray(collection)?arrayShuffle:
baseShuffle;return func(collection)}function size(collection){if(collection==null)return 0;if(isArrayLike(collection))return isString(collection)?stringSize(collection):collection.length;var tag=getTag(collection);if(tag==mapTag||tag==setTag)return collection.size;return baseKeys(collection).length}function some(collection,predicate,guard){var func=isArray(collection)?arraySome:baseSome;if(guard&&isIterateeCall(collection,predicate,guard))predicate=undefined;return func(collection,getIteratee(predicate,
3))}var sortBy=baseRest(function(collection,iteratees){if(collection==null)return[];var length=iteratees.length;if(length>1&&isIterateeCall(collection,iteratees[0],iteratees[1]))iteratees=[];else if(length>2&&isIterateeCall(iteratees[0],iteratees[1],iteratees[2]))iteratees=[iteratees[0]];return baseOrderBy(collection,baseFlatten(iteratees,1),[])});var now=ctxNow||function(){return root.Date.now()};function after(n,func){if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);n=toInteger(n);
return function(){if(--n<1)return func.apply(this,arguments)}}function ary(func,n,guard){n=guard?undefined:n;n=func&&n==null?func.length:n;return createWrap(func,WRAP_ARY_FLAG,undefined,undefined,undefined,undefined,n)}function before(n,func){var result;if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);n=toInteger(n);return function(){if(--n>0)result=func.apply(this,arguments);if(n<=1)func=undefined;return result}}var bind=baseRest(function(func,thisArg,partials){var bitmask=WRAP_BIND_FLAG;
if(partials.length){var holders=replaceHolders(partials,getHolder(bind));bitmask|=WRAP_PARTIAL_FLAG}return createWrap(func,bitmask,thisArg,partials,holders)});var bindKey=baseRest(function(object,key,partials){var bitmask=WRAP_BIND_FLAG|WRAP_BIND_KEY_FLAG;if(partials.length){var holders=replaceHolders(partials,getHolder(bindKey));bitmask|=WRAP_PARTIAL_FLAG}return createWrap(key,bitmask,object,partials,holders)});function curry(func,arity,guard){arity=guard?undefined:arity;var result=createWrap(func,
WRAP_CURRY_FLAG,undefined,undefined,undefined,undefined,undefined,arity);result.placeholder=curry.placeholder;return result}function curryRight(func,arity,guard){arity=guard?undefined:arity;var result=createWrap(func,WRAP_CURRY_RIGHT_FLAG,undefined,undefined,undefined,undefined,undefined,arity);result.placeholder=curryRight.placeholder;return result}function debounce(func,wait,options){var lastArgs,lastThis,maxWait,result,timerId,lastCallTime,lastInvokeTime=0,leading=false,maxing=false,trailing=true;
if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);wait=toNumber(wait)||0;if(isObject(options)){leading=!!options.leading;maxing="maxWait"in options;maxWait=maxing?nativeMax(toNumber(options.maxWait)||0,wait):maxWait;trailing="trailing"in options?!!options.trailing:trailing}function invokeFunc(time){var args=lastArgs,thisArg=lastThis;lastArgs=lastThis=undefined;lastInvokeTime=time;result=func.apply(thisArg,args);return result}function leadingEdge(time){lastInvokeTime=time;timerId=setTimeout(timerExpired,
wait);return leading?invokeFunc(time):result}function remainingWait(time){var timeSinceLastCall=time-lastCallTime,timeSinceLastInvoke=time-lastInvokeTime,timeWaiting=wait-timeSinceLastCall;return maxing?nativeMin(timeWaiting,maxWait-timeSinceLastInvoke):timeWaiting}function shouldInvoke(time){var timeSinceLastCall=time-lastCallTime,timeSinceLastInvoke=time-lastInvokeTime;return lastCallTime===undefined||timeSinceLastCall>=wait||timeSinceLastCall<0||maxing&&timeSinceLastInvoke>=maxWait}function timerExpired(){var time=
now();if(shouldInvoke(time))return trailingEdge(time);timerId=setTimeout(timerExpired,remainingWait(time))}function trailingEdge(time){timerId=undefined;if(trailing&&lastArgs)return invokeFunc(time);lastArgs=lastThis=undefined;return result}function cancel(){if(timerId!==undefined)clearTimeout(timerId);lastInvokeTime=0;lastArgs=lastCallTime=lastThis=timerId=undefined}function flush(){return timerId===undefined?result:trailingEdge(now())}function debounced(){var time=now(),isInvoking=shouldInvoke(time);
lastArgs=arguments;lastThis=this;lastCallTime=time;if(isInvoking){if(timerId===undefined)return leadingEdge(lastCallTime);if(maxing){timerId=setTimeout(timerExpired,wait);return invokeFunc(lastCallTime)}}if(timerId===undefined)timerId=setTimeout(timerExpired,wait);return result}debounced.cancel=cancel;debounced.flush=flush;return debounced}var defer=baseRest(function(func,args){return baseDelay(func,1,args)});var delay=baseRest(function(func,wait,args){return baseDelay(func,toNumber(wait)||0,args)});
function flip(func){return createWrap(func,WRAP_FLIP_FLAG)}function memoize(func,resolver){if(typeof func!="function"||resolver!=null&&typeof resolver!="function")throw new TypeError(FUNC_ERROR_TEXT);var memoized=function(){var args=arguments,key=resolver?resolver.apply(this,args):args[0],cache=memoized.cache;if(cache.has(key))return cache.get(key);var result=func.apply(this,args);memoized.cache=cache.set(key,result)||cache;return result};memoized.cache=new (memoize.Cache||MapCache);return memoized}
memoize.Cache=MapCache;function negate(predicate){if(typeof predicate!="function")throw new TypeError(FUNC_ERROR_TEXT);return function(){var args=arguments;switch(args.length){case 0:return!predicate.call(this);case 1:return!predicate.call(this,args[0]);case 2:return!predicate.call(this,args[0],args[1]);case 3:return!predicate.call(this,args[0],args[1],args[2])}return!predicate.apply(this,args)}}function once(func){return before(2,func)}var overArgs=castRest(function(func,transforms){transforms=transforms.length==
1&&isArray(transforms[0])?arrayMap(transforms[0],baseUnary(getIteratee())):arrayMap(baseFlatten(transforms,1),baseUnary(getIteratee()));var funcsLength=transforms.length;return baseRest(function(args){var index=-1,length=nativeMin(args.length,funcsLength);while(++index<length)args[index]=transforms[index].call(this,args[index]);return apply(func,this,args)})});var partial=baseRest(function(func,partials){var holders=replaceHolders(partials,getHolder(partial));return createWrap(func,WRAP_PARTIAL_FLAG,
undefined,partials,holders)});var partialRight=baseRest(function(func,partials){var holders=replaceHolders(partials,getHolder(partialRight));return createWrap(func,WRAP_PARTIAL_RIGHT_FLAG,undefined,partials,holders)});var rearg=flatRest(function(func,indexes){return createWrap(func,WRAP_REARG_FLAG,undefined,undefined,undefined,indexes)});function rest(func,start){if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);start=start===undefined?start:toInteger(start);return baseRest(func,start)}
function spread(func,start){if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);start=start==null?0:nativeMax(toInteger(start),0);return baseRest(function(args){var array=args[start],otherArgs=castSlice(args,0,start);if(array)arrayPush(otherArgs,array);return apply(func,this,otherArgs)})}function throttle(func,wait,options){var leading=true,trailing=true;if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);if(isObject(options)){leading="leading"in options?!!options.leading:
leading;trailing="trailing"in options?!!options.trailing:trailing}return debounce(func,wait,{"leading":leading,"maxWait":wait,"trailing":trailing})}function unary(func){return ary(func,1)}function wrap(value,wrapper){return partial(castFunction(wrapper),value)}function castArray(){if(!arguments.length)return[];var value=arguments[0];return isArray(value)?value:[value]}function clone(value){return baseClone(value,CLONE_SYMBOLS_FLAG)}function cloneWith(value,customizer){customizer=typeof customizer==
"function"?customizer:undefined;return baseClone(value,CLONE_SYMBOLS_FLAG,customizer)}function cloneDeep(value){return baseClone(value,CLONE_DEEP_FLAG|CLONE_SYMBOLS_FLAG)}function cloneDeepWith(value,customizer){customizer=typeof customizer=="function"?customizer:undefined;return baseClone(value,CLONE_DEEP_FLAG|CLONE_SYMBOLS_FLAG,customizer)}function conformsTo(object,source){return source==null||baseConformsTo(object,source,keys(source))}function eq(value,other){return value===other||value!==value&&
other!==other}var gt=createRelationalOperation(baseGt);var gte=createRelationalOperation(function(value,other){return value>=other});var isArguments=baseIsArguments(function(){return arguments}())?baseIsArguments:function(value){return isObjectLike(value)&&hasOwnProperty.call(value,"callee")&&!propertyIsEnumerable.call(value,"callee")};var isArray=Array.isArray;var isArrayBuffer=nodeIsArrayBuffer?baseUnary(nodeIsArrayBuffer):baseIsArrayBuffer;function isArrayLike(value){return value!=null&&isLength(value.length)&&
!isFunction(value)}function isArrayLikeObject(value){return isObjectLike(value)&&isArrayLike(value)}function isBoolean(value){return value===true||value===false||isObjectLike(value)&&baseGetTag(value)==boolTag}var isBuffer=nativeIsBuffer||stubFalse;var isDate=nodeIsDate?baseUnary(nodeIsDate):baseIsDate;function isElement(value){return isObjectLike(value)&&value.nodeType===1&&!isPlainObject(value)}function isEmpty(value){if(value==null)return true;if(isArrayLike(value)&&(isArray(value)||typeof value==
"string"||typeof value.splice=="function"||isBuffer(value)||isTypedArray(value)||isArguments(value)))return!value.length;var tag=getTag(value);if(tag==mapTag||tag==setTag)return!value.size;if(isPrototype(value))return!baseKeys(value).length;for(var key in value)if(hasOwnProperty.call(value,key))return false;return true}function isEqual(value,other){return baseIsEqual(value,other)}function isEqualWith(value,other,customizer){customizer=typeof customizer=="function"?customizer:undefined;var result=
customizer?customizer(value,other):undefined;return result===undefined?baseIsEqual(value,other,undefined,customizer):!!result}function isError(value){if(!isObjectLike(value))return false;var tag=baseGetTag(value);return tag==errorTag||tag==domExcTag||typeof value.message=="string"&&typeof value.name=="string"&&!isPlainObject(value)}function isFinite(value){return typeof value=="number"&&nativeIsFinite(value)}function isFunction(value){if(!isObject(value))return false;var tag=baseGetTag(value);return tag==
funcTag||tag==genTag||tag==asyncTag||tag==proxyTag}function isInteger(value){return typeof value=="number"&&value==toInteger(value)}function isLength(value){return typeof value=="number"&&value>-1&&value%1==0&&value<=MAX_SAFE_INTEGER}function isObject(value){var type=typeof value;return value!=null&&(type=="object"||type=="function")}function isObjectLike(value){return value!=null&&typeof value=="object"}var isMap=nodeIsMap?baseUnary(nodeIsMap):baseIsMap;function isMatch(object,source){return object===
source||baseIsMatch(object,source,getMatchData(source))}function isMatchWith(object,source,customizer){customizer=typeof customizer=="function"?customizer:undefined;return baseIsMatch(object,source,getMatchData(source),customizer)}function isNaN(value){return isNumber(value)&&value!=+value}function isNative(value){if(isMaskable(value))throw new Error(CORE_ERROR_TEXT);return baseIsNative(value)}function isNull(value){return value===null}function isNil(value){return value==null}function isNumber(value){return typeof value==
"number"||isObjectLike(value)&&baseGetTag(value)==numberTag}function isPlainObject(value){if(!isObjectLike(value)||baseGetTag(value)!=objectTag)return false;var proto=getPrototype(value);if(proto===null)return true;var Ctor=hasOwnProperty.call(proto,"constructor")&&proto.constructor;return typeof Ctor=="function"&&Ctor instanceof Ctor&&funcToString.call(Ctor)==objectCtorString}var isRegExp=nodeIsRegExp?baseUnary(nodeIsRegExp):baseIsRegExp;function isSafeInteger(value){return isInteger(value)&&value>=
-MAX_SAFE_INTEGER&&value<=MAX_SAFE_INTEGER}var isSet=nodeIsSet?baseUnary(nodeIsSet):baseIsSet;function isString(value){return typeof value=="string"||!isArray(value)&&isObjectLike(value)&&baseGetTag(value)==stringTag}function isSymbol(value){return typeof value=="symbol"||isObjectLike(value)&&baseGetTag(value)==symbolTag}var isTypedArray=nodeIsTypedArray?baseUnary(nodeIsTypedArray):baseIsTypedArray;function isUndefined(value){return value===undefined}function isWeakMap(value){return isObjectLike(value)&&
getTag(value)==weakMapTag}function isWeakSet(value){return isObjectLike(value)&&baseGetTag(value)==weakSetTag}var lt=createRelationalOperation(baseLt);var lte=createRelationalOperation(function(value,other){return value<=other});function toArray(value){if(!value)return[];if(isArrayLike(value))return isString(value)?stringToArray(value):copyArray(value);if(symIterator&&value[symIterator])return iteratorToArray(value[symIterator]());var tag=getTag(value),func=tag==mapTag?mapToArray:tag==setTag?setToArray:
values;return func(value)}function toFinite(value){if(!value)return value===0?value:0;value=toNumber(value);if(value===INFINITY||value===-INFINITY){var sign=value<0?-1:1;return sign*MAX_INTEGER}return value===value?value:0}function toInteger(value){var result=toFinite(value),remainder=result%1;return result===result?remainder?result-remainder:result:0}function toLength(value){return value?baseClamp(toInteger(value),0,MAX_ARRAY_LENGTH):0}function toNumber(value){if(typeof value=="number")return value;
if(isSymbol(value))return NAN;if(isObject(value)){var other=typeof value.valueOf=="function"?value.valueOf():value;value=isObject(other)?other+"":other}if(typeof value!="string")return value===0?value:+value;value=value.replace(reTrim,"");var isBinary=reIsBinary.test(value);return isBinary||reIsOctal.test(value)?freeParseInt(value.slice(2),isBinary?2:8):reIsBadHex.test(value)?NAN:+value}function toPlainObject(value){return copyObject(value,keysIn(value))}function toSafeInteger(value){return value?
baseClamp(toInteger(value),-MAX_SAFE_INTEGER,MAX_SAFE_INTEGER):value===0?value:0}function toString(value){return value==null?"":baseToString(value)}var assign=createAssigner(function(object,source){if(isPrototype(source)||isArrayLike(source)){copyObject(source,keys(source),object);return}for(var key in source)if(hasOwnProperty.call(source,key))assignValue(object,key,source[key])});var assignIn=createAssigner(function(object,source){copyObject(source,keysIn(source),object)});var assignInWith=createAssigner(function(object,
source,srcIndex,customizer){copyObject(source,keysIn(source),object,customizer)});var assignWith=createAssigner(function(object,source,srcIndex,customizer){copyObject(source,keys(source),object,customizer)});var at=flatRest(baseAt);function create(prototype,properties){var result=baseCreate(prototype);return properties==null?result:baseAssign(result,properties)}var defaults=baseRest(function(object,sources){object=Object(object);var index=-1;var length=sources.length;var guard=length>2?sources[2]:
undefined;if(guard&&isIterateeCall(sources[0],sources[1],guard))length=1;while(++index<length){var source=sources[index];var props=keysIn(source);var propsIndex=-1;var propsLength=props.length;while(++propsIndex<propsLength){var key=props[propsIndex];var value=object[key];if(value===undefined||eq(value,objectProto[key])&&!hasOwnProperty.call(object,key))object[key]=source[key]}}return object});var defaultsDeep=baseRest(function(args){args.push(undefined,customDefaultsMerge);return apply(mergeWith,
undefined,args)});function findKey(object,predicate){return baseFindKey(object,getIteratee(predicate,3),baseForOwn)}function findLastKey(object,predicate){return baseFindKey(object,getIteratee(predicate,3),baseForOwnRight)}function forIn(object,iteratee){return object==null?object:baseFor(object,getIteratee(iteratee,3),keysIn)}function forInRight(object,iteratee){return object==null?object:baseForRight(object,getIteratee(iteratee,3),keysIn)}function forOwn(object,iteratee){return object&&baseForOwn(object,
getIteratee(iteratee,3))}function forOwnRight(object,iteratee){return object&&baseForOwnRight(object,getIteratee(iteratee,3))}function functions(object){return object==null?[]:baseFunctions(object,keys(object))}function functionsIn(object){return object==null?[]:baseFunctions(object,keysIn(object))}function get(object,path,defaultValue){var result=object==null?undefined:baseGet(object,path);return result===undefined?defaultValue:result}function has(object,path){return object!=null&&hasPath(object,
path,baseHas)}function hasIn(object,path){return object!=null&&hasPath(object,path,baseHasIn)}var invert=createInverter(function(result,value,key){if(value!=null&&typeof value.toString!="function")value=nativeObjectToString.call(value);result[value]=key},constant(identity));var invertBy=createInverter(function(result,value,key){if(value!=null&&typeof value.toString!="function")value=nativeObjectToString.call(value);if(hasOwnProperty.call(result,value))result[value].push(key);else result[value]=[key]},
getIteratee);var invoke=baseRest(baseInvoke);function keys(object){return isArrayLike(object)?arrayLikeKeys(object):baseKeys(object)}function keysIn(object){return isArrayLike(object)?arrayLikeKeys(object,true):baseKeysIn(object)}function mapKeys(object,iteratee){var result={};iteratee=getIteratee(iteratee,3);baseForOwn(object,function(value,key,object){baseAssignValue(result,iteratee(value,key,object),value)});return result}function mapValues(object,iteratee){var result={};iteratee=getIteratee(iteratee,
3);baseForOwn(object,function(value,key,object){baseAssignValue(result,key,iteratee(value,key,object))});return result}var merge=createAssigner(function(object,source,srcIndex){baseMerge(object,source,srcIndex)});var mergeWith=createAssigner(function(object,source,srcIndex,customizer){baseMerge(object,source,srcIndex,customizer)});var omit=flatRest(function(object,paths){var result={};if(object==null)return result;var isDeep=false;paths=arrayMap(paths,function(path){path=castPath(path,object);isDeep||
(isDeep=path.length>1);return path});copyObject(object,getAllKeysIn(object),result);if(isDeep)result=baseClone(result,CLONE_DEEP_FLAG|CLONE_FLAT_FLAG|CLONE_SYMBOLS_FLAG,customOmitClone);var length=paths.length;while(length--)baseUnset(result,paths[length]);return result});function omitBy(object,predicate){return pickBy(object,negate(getIteratee(predicate)))}var pick=flatRest(function(object,paths){return object==null?{}:basePick(object,paths)});function pickBy(object,predicate){if(object==null)return{};
var props=arrayMap(getAllKeysIn(object),function(prop){return[prop]});predicate=getIteratee(predicate);return basePickBy(object,props,function(value,path){return predicate(value,path[0])})}function result(object,path,defaultValue){path=castPath(path,object);var index=-1,length=path.length;if(!length){length=1;object=undefined}while(++index<length){var value=object==null?undefined:object[toKey(path[index])];if(value===undefined){index=length;value=defaultValue}object=isFunction(value)?value.call(object):
value}return object}function set(object,path,value){return object==null?object:baseSet(object,path,value)}function setWith(object,path,value,customizer){customizer=typeof customizer=="function"?customizer:undefined;return object==null?object:baseSet(object,path,value,customizer)}var toPairs=createToPairs(keys);var toPairsIn=createToPairs(keysIn);function transform(object,iteratee,accumulator){var isArr=isArray(object),isArrLike=isArr||isBuffer(object)||isTypedArray(object);iteratee=getIteratee(iteratee,
4);if(accumulator==null){var Ctor=object&&object.constructor;if(isArrLike)accumulator=isArr?new Ctor:[];else if(isObject(object))accumulator=isFunction(Ctor)?baseCreate(getPrototype(object)):{};else accumulator={}}(isArrLike?arrayEach:baseForOwn)(object,function(value,index,object){return iteratee(accumulator,value,index,object)});return accumulator}function unset(object,path){return object==null?true:baseUnset(object,path)}function update(object,path,updater){return object==null?object:baseUpdate(object,
path,castFunction(updater))}function updateWith(object,path,updater,customizer){customizer=typeof customizer=="function"?customizer:undefined;return object==null?object:baseUpdate(object,path,castFunction(updater),customizer)}function values(object){return object==null?[]:baseValues(object,keys(object))}function valuesIn(object){return object==null?[]:baseValues(object,keysIn(object))}function clamp(number,lower,upper){if(upper===undefined){upper=lower;lower=undefined}if(upper!==undefined){upper=
toNumber(upper);upper=upper===upper?upper:0}if(lower!==undefined){lower=toNumber(lower);lower=lower===lower?lower:0}return baseClamp(toNumber(number),lower,upper)}function inRange(number,start,end){start=toFinite(start);if(end===undefined){end=start;start=0}else end=toFinite(end);number=toNumber(number);return baseInRange(number,start,end)}function random(lower,upper,floating){if(floating&&typeof floating!="boolean"&&isIterateeCall(lower,upper,floating))upper=floating=undefined;if(floating===undefined)if(typeof upper==
"boolean"){floating=upper;upper=undefined}else if(typeof lower=="boolean"){floating=lower;lower=undefined}if(lower===undefined&&upper===undefined){lower=0;upper=1}else{lower=toFinite(lower);if(upper===undefined){upper=lower;lower=0}else upper=toFinite(upper)}if(lower>upper){var temp=lower;lower=upper;upper=temp}if(floating||lower%1||upper%1){var rand=nativeRandom();return nativeMin(lower+rand*(upper-lower+freeParseFloat("1e-"+((rand+"").length-1))),upper)}return baseRandom(lower,upper)}var camelCase=
createCompounder(function(result,word,index){word=word.toLowerCase();return result+(index?capitalize(word):word)});function capitalize(string){return upperFirst(toString(string).toLowerCase())}function deburr(string){string=toString(string);return string&&string.replace(reLatin,deburrLetter).replace(reComboMark,"")}function endsWith(string,target,position){string=toString(string);target=baseToString(target);var length=string.length;position=position===undefined?length:baseClamp(toInteger(position),
0,length);var end=position;position-=target.length;return position>=0&&string.slice(position,end)==target}function escape(string){string=toString(string);return string&&reHasUnescapedHtml.test(string)?string.replace(reUnescapedHtml,escapeHtmlChar):string}function escapeRegExp(string){string=toString(string);return string&&reHasRegExpChar.test(string)?string.replace(reRegExpChar,"\\$\x26"):string}var kebabCase=createCompounder(function(result,word,index){return result+(index?"-":"")+word.toLowerCase()});
var lowerCase=createCompounder(function(result,word,index){return result+(index?" ":"")+word.toLowerCase()});var lowerFirst=createCaseFirst("toLowerCase");function pad(string,length,chars){string=toString(string);length=toInteger(length);var strLength=length?stringSize(string):0;if(!length||strLength>=length)return string;var mid=(length-strLength)/2;return createPadding(nativeFloor(mid),chars)+string+createPadding(nativeCeil(mid),chars)}function padEnd(string,length,chars){string=toString(string);
length=toInteger(length);var strLength=length?stringSize(string):0;return length&&strLength<length?string+createPadding(length-strLength,chars):string}function padStart(string,length,chars){string=toString(string);length=toInteger(length);var strLength=length?stringSize(string):0;return length&&strLength<length?createPadding(length-strLength,chars)+string:string}function parseInt(string,radix,guard){if(guard||radix==null)radix=0;else if(radix)radix=+radix;return nativeParseInt(toString(string).replace(reTrimStart,
""),radix||0)}function repeat(string,n,guard){if(guard?isIterateeCall(string,n,guard):n===undefined)n=1;else n=toInteger(n);return baseRepeat(toString(string),n)}function replace(){var args=arguments,string=toString(args[0]);return args.length<3?string:string.replace(args[1],args[2])}var snakeCase=createCompounder(function(result,word,index){return result+(index?"_":"")+word.toLowerCase()});function split(string,separator,limit){if(limit&&typeof limit!="number"&&isIterateeCall(string,separator,limit))separator=
limit=undefined;limit=limit===undefined?MAX_ARRAY_LENGTH:limit>>>0;if(!limit)return[];string=toString(string);if(string&&(typeof separator=="string"||separator!=null&&!isRegExp(separator))){separator=baseToString(separator);if(!separator&&hasUnicode(string))return castSlice(stringToArray(string),0,limit)}return string.split(separator,limit)}var startCase=createCompounder(function(result,word,index){return result+(index?" ":"")+upperFirst(word)});function startsWith(string,target,position){string=
toString(string);position=position==null?0:baseClamp(toInteger(position),0,string.length);target=baseToString(target);return string.slice(position,position+target.length)==target}function template(string,options,guard){var settings=lodash.templateSettings;if(guard&&isIterateeCall(string,options,guard))options=undefined;string=toString(string);options=assignInWith({},options,settings,customDefaultsAssignIn);var imports=assignInWith({},options.imports,settings.imports,customDefaultsAssignIn),importsKeys=
keys(imports),importsValues=baseValues(imports,importsKeys);var isEscaping,isEvaluating,index=0,interpolate=options.interpolate||reNoMatch,source="__p +\x3d '";var reDelimiters=RegExp((options.escape||reNoMatch).source+"|"+interpolate.source+"|"+(interpolate===reInterpolate?reEsTemplate:reNoMatch).source+"|"+(options.evaluate||reNoMatch).source+"|$","g");var sourceURL="//# sourceURL\x3d"+("sourceURL"in options?options.sourceURL:"lodash.templateSources["+ ++templateCounter+"]")+"\n";string.replace(reDelimiters,
function(match,escapeValue,interpolateValue,esTemplateValue,evaluateValue,offset){interpolateValue||(interpolateValue=esTemplateValue);source+=string.slice(index,offset).replace(reUnescapedString,escapeStringChar);if(escapeValue){isEscaping=true;source+="' +\n__e("+escapeValue+") +\n'"}if(evaluateValue){isEvaluating=true;source+="';\n"+evaluateValue+";\n__p +\x3d '"}if(interpolateValue)source+="' +\n((__t \x3d ("+interpolateValue+")) \x3d\x3d null ? '' : __t) +\n'";index=offset+match.length;return match});
source+="';\n";var variable=options.variable;if(!variable)source="with (obj) {\n"+source+"\n}\n";source=(isEvaluating?source.replace(reEmptyStringLeading,""):source).replace(reEmptyStringMiddle,"$1").replace(reEmptyStringTrailing,"$1;");source="function("+(variable||"obj")+") {\n"+(variable?"":"obj || (obj \x3d {});\n")+"var __t, __p \x3d ''"+(isEscaping?", __e \x3d _.escape":"")+(isEvaluating?", __j \x3d Array.prototype.join;\n"+"function print() { __p +\x3d __j.call(arguments, '') }\n":";\n")+source+
"return __p\n}";var result=attempt(function(){return Function(importsKeys,sourceURL+"return "+source).apply(undefined,importsValues)});result.source=source;if(isError(result))throw result;return result}function toLower(value){return toString(value).toLowerCase()}function toUpper(value){return toString(value).toUpperCase()}function trim(string,chars,guard){string=toString(string);if(string&&(guard||chars===undefined))return string.replace(reTrim,"");if(!string||!(chars=baseToString(chars)))return string;
var strSymbols=stringToArray(string),chrSymbols=stringToArray(chars),start=charsStartIndex(strSymbols,chrSymbols),end=charsEndIndex(strSymbols,chrSymbols)+1;return castSlice(strSymbols,start,end).join("")}function trimEnd(string,chars,guard){string=toString(string);if(string&&(guard||chars===undefined))return string.replace(reTrimEnd,"");if(!string||!(chars=baseToString(chars)))return string;var strSymbols=stringToArray(string),end=charsEndIndex(strSymbols,stringToArray(chars))+1;return castSlice(strSymbols,
0,end).join("")}function trimStart(string,chars,guard){string=toString(string);if(string&&(guard||chars===undefined))return string.replace(reTrimStart,"");if(!string||!(chars=baseToString(chars)))return string;var strSymbols=stringToArray(string),start=charsStartIndex(strSymbols,stringToArray(chars));return castSlice(strSymbols,start).join("")}function truncate(string,options){var length=DEFAULT_TRUNC_LENGTH,omission=DEFAULT_TRUNC_OMISSION;if(isObject(options)){var separator="separator"in options?
options.separator:separator;length="length"in options?toInteger(options.length):length;omission="omission"in options?baseToString(options.omission):omission}string=toString(string);var strLength=string.length;if(hasUnicode(string)){var strSymbols=stringToArray(string);strLength=strSymbols.length}if(length>=strLength)return string;var end=length-stringSize(omission);if(end<1)return omission;var result=strSymbols?castSlice(strSymbols,0,end).join(""):string.slice(0,end);if(separator===undefined)return result+
omission;if(strSymbols)end+=result.length-end;if(isRegExp(separator)){if(string.slice(end).search(separator)){var match,substring=result;if(!separator.global)separator=RegExp(separator.source,toString(reFlags.exec(separator))+"g");separator.lastIndex=0;while(match=separator.exec(substring))var newEnd=match.index;result=result.slice(0,newEnd===undefined?end:newEnd)}}else if(string.indexOf(baseToString(separator),end)!=end){var index=result.lastIndexOf(separator);if(index>-1)result=result.slice(0,index)}return result+
omission}function unescape(string){string=toString(string);return string&&reHasEscapedHtml.test(string)?string.replace(reEscapedHtml,unescapeHtmlChar):string}var upperCase=createCompounder(function(result,word,index){return result+(index?" ":"")+word.toUpperCase()});var upperFirst=createCaseFirst("toUpperCase");function words(string,pattern,guard){string=toString(string);pattern=guard?undefined:pattern;if(pattern===undefined)return hasUnicodeWord(string)?unicodeWords(string):asciiWords(string);return string.match(pattern)||
[]}var attempt=baseRest(function(func,args){try{return apply(func,undefined,args)}catch(e){return isError(e)?e:new Error(e)}});var bindAll=flatRest(function(object,methodNames){arrayEach(methodNames,function(key){key=toKey(key);baseAssignValue(object,key,bind(object[key],object))});return object});function cond(pairs){var length=pairs==null?0:pairs.length,toIteratee=getIteratee();pairs=!length?[]:arrayMap(pairs,function(pair){if(typeof pair[1]!="function")throw new TypeError(FUNC_ERROR_TEXT);return[toIteratee(pair[0]),
pair[1]]});return baseRest(function(args){var index=-1;while(++index<length){var pair=pairs[index];if(apply(pair[0],this,args))return apply(pair[1],this,args)}})}function conforms(source){return baseConforms(baseClone(source,CLONE_DEEP_FLAG))}function constant(value){return function(){return value}}function defaultTo(value,defaultValue){return value==null||value!==value?defaultValue:value}var flow=createFlow();var flowRight=createFlow(true);function identity(value){return value}function iteratee(func){return baseIteratee(typeof func==
"function"?func:baseClone(func,CLONE_DEEP_FLAG))}function matches(source){return baseMatches(baseClone(source,CLONE_DEEP_FLAG))}function matchesProperty(path,srcValue){return baseMatchesProperty(path,baseClone(srcValue,CLONE_DEEP_FLAG))}var method=baseRest(function(path,args){return function(object){return baseInvoke(object,path,args)}});var methodOf=baseRest(function(object,args){return function(path){return baseInvoke(object,path,args)}});function mixin(object,source,options){var props=keys(source),
methodNames=baseFunctions(source,props);if(options==null&&!(isObject(source)&&(methodNames.length||!props.length))){options=source;source=object;object=this;methodNames=baseFunctions(source,keys(source))}var chain=!(isObject(options)&&"chain"in options)||!!options.chain,isFunc=isFunction(object);arrayEach(methodNames,function(methodName){var func=source[methodName];object[methodName]=func;if(isFunc)object.prototype[methodName]=function(){var chainAll=this.__chain__;if(chain||chainAll){var result=
object(this.__wrapped__),actions=result.__actions__=copyArray(this.__actions__);actions.push({"func":func,"args":arguments,"thisArg":object});result.__chain__=chainAll;return result}return func.apply(object,arrayPush([this.value()],arguments))}});return object}function noConflict(){if(root._===this)root._=oldDash;return this}function noop(){}function nthArg(n){n=toInteger(n);return baseRest(function(args){return baseNth(args,n)})}var over=createOver(arrayMap);var overEvery=createOver(arrayEvery);
var overSome=createOver(arraySome);function property(path){return isKey(path)?baseProperty(toKey(path)):basePropertyDeep(path)}function propertyOf(object){return function(path){return object==null?undefined:baseGet(object,path)}}var range=createRange();var rangeRight=createRange(true);function stubArray(){return[]}function stubFalse(){return false}function stubObject(){return{}}function stubString(){return""}function stubTrue(){return true}function times(n,iteratee){n=toInteger(n);if(n<1||n>MAX_SAFE_INTEGER)return[];
var index=MAX_ARRAY_LENGTH,length=nativeMin(n,MAX_ARRAY_LENGTH);iteratee=getIteratee(iteratee);n-=MAX_ARRAY_LENGTH;var result=baseTimes(length,iteratee);while(++index<n)iteratee(index);return result}function toPath(value){if(isArray(value))return arrayMap(value,toKey);return isSymbol(value)?[value]:copyArray(stringToPath(toString(value)))}function uniqueId(prefix){var id=++idCounter;return toString(prefix)+id}var add=createMathOperation(function(augend,addend){return augend+addend},0);var ceil=createRound("ceil");
var divide=createMathOperation(function(dividend,divisor){return dividend/divisor},1);var floor=createRound("floor");function max(array){return array&&array.length?baseExtremum(array,identity,baseGt):undefined}function maxBy(array,iteratee){return array&&array.length?baseExtremum(array,getIteratee(iteratee,2),baseGt):undefined}function mean(array){return baseMean(array,identity)}function meanBy(array,iteratee){return baseMean(array,getIteratee(iteratee,2))}function min(array){return array&&array.length?
baseExtremum(array,identity,baseLt):undefined}function minBy(array,iteratee){return array&&array.length?baseExtremum(array,getIteratee(iteratee,2),baseLt):undefined}var multiply=createMathOperation(function(multiplier,multiplicand){return multiplier*multiplicand},1);var round=createRound("round");var subtract=createMathOperation(function(minuend,subtrahend){return minuend-subtrahend},0);function sum(array){return array&&array.length?baseSum(array,identity):0}function sumBy(array,iteratee){return array&&
array.length?baseSum(array,getIteratee(iteratee,2)):0}lodash.after=after;lodash.ary=ary;lodash.assign=assign;lodash.assignIn=assignIn;lodash.assignInWith=assignInWith;lodash.assignWith=assignWith;lodash.at=at;lodash.before=before;lodash.bind=bind;lodash.bindAll=bindAll;lodash.bindKey=bindKey;lodash.castArray=castArray;lodash.chain=chain;lodash.chunk=chunk;lodash.compact=compact;lodash.concat=concat;lodash.cond=cond;lodash.conforms=conforms;lodash.constant=constant;lodash.countBy=countBy;lodash.create=
create;lodash.curry=curry;lodash.curryRight=curryRight;lodash.debounce=debounce;lodash.defaults=defaults;lodash.defaultsDeep=defaultsDeep;lodash.defer=defer;lodash.delay=delay;lodash.difference=difference;lodash.differenceBy=differenceBy;lodash.differenceWith=differenceWith;lodash.drop=drop;lodash.dropRight=dropRight;lodash.dropRightWhile=dropRightWhile;lodash.dropWhile=dropWhile;lodash.fill=fill;lodash.filter=filter;lodash.flatMap=flatMap;lodash.flatMapDeep=flatMapDeep;lodash.flatMapDepth=flatMapDepth;
lodash.flatten=flatten;lodash.flattenDeep=flattenDeep;lodash.flattenDepth=flattenDepth;lodash.flip=flip;lodash.flow=flow;lodash.flowRight=flowRight;lodash.fromPairs=fromPairs;lodash.functions=functions;lodash.functionsIn=functionsIn;lodash.groupBy=groupBy;lodash.initial=initial;lodash.intersection=intersection;lodash.intersectionBy=intersectionBy;lodash.intersectionWith=intersectionWith;lodash.invert=invert;lodash.invertBy=invertBy;lodash.invokeMap=invokeMap;lodash.iteratee=iteratee;lodash.keyBy=
keyBy;lodash.keys=keys;lodash.keysIn=keysIn;lodash.map=map;lodash.mapKeys=mapKeys;lodash.mapValues=mapValues;lodash.matches=matches;lodash.matchesProperty=matchesProperty;lodash.memoize=memoize;lodash.merge=merge;lodash.mergeWith=mergeWith;lodash.method=method;lodash.methodOf=methodOf;lodash.mixin=mixin;lodash.negate=negate;lodash.nthArg=nthArg;lodash.omit=omit;lodash.omitBy=omitBy;lodash.once=once;lodash.orderBy=orderBy;lodash.over=over;lodash.overArgs=overArgs;lodash.overEvery=overEvery;lodash.overSome=
overSome;lodash.partial=partial;lodash.partialRight=partialRight;lodash.partition=partition;lodash.pick=pick;lodash.pickBy=pickBy;lodash.property=property;lodash.propertyOf=propertyOf;lodash.pull=pull;lodash.pullAll=pullAll;lodash.pullAllBy=pullAllBy;lodash.pullAllWith=pullAllWith;lodash.pullAt=pullAt;lodash.range=range;lodash.rangeRight=rangeRight;lodash.rearg=rearg;lodash.reject=reject;lodash.remove=remove;lodash.rest=rest;lodash.reverse=reverse;lodash.sampleSize=sampleSize;lodash.set=set;lodash.setWith=
setWith;lodash.shuffle=shuffle;lodash.slice=slice;lodash.sortBy=sortBy;lodash.sortedUniq=sortedUniq;lodash.sortedUniqBy=sortedUniqBy;lodash.split=split;lodash.spread=spread;lodash.tail=tail;lodash.take=take;lodash.takeRight=takeRight;lodash.takeRightWhile=takeRightWhile;lodash.takeWhile=takeWhile;lodash.tap=tap;lodash.throttle=throttle;lodash.thru=thru;lodash.toArray=toArray;lodash.toPairs=toPairs;lodash.toPairsIn=toPairsIn;lodash.toPath=toPath;lodash.toPlainObject=toPlainObject;lodash.transform=
transform;lodash.unary=unary;lodash.union=union;lodash.unionBy=unionBy;lodash.unionWith=unionWith;lodash.uniq=uniq;lodash.uniqBy=uniqBy;lodash.uniqWith=uniqWith;lodash.unset=unset;lodash.unzip=unzip;lodash.unzipWith=unzipWith;lodash.update=update;lodash.updateWith=updateWith;lodash.values=values;lodash.valuesIn=valuesIn;lodash.without=without;lodash.words=words;lodash.wrap=wrap;lodash.xor=xor;lodash.xorBy=xorBy;lodash.xorWith=xorWith;lodash.zip=zip;lodash.zipObject=zipObject;lodash.zipObjectDeep=
zipObjectDeep;lodash.zipWith=zipWith;lodash.entries=toPairs;lodash.entriesIn=toPairsIn;lodash.extend=assignIn;lodash.extendWith=assignInWith;mixin(lodash,lodash);lodash.add=add;lodash.attempt=attempt;lodash.camelCase=camelCase;lodash.capitalize=capitalize;lodash.ceil=ceil;lodash.clamp=clamp;lodash.clone=clone;lodash.cloneDeep=cloneDeep;lodash.cloneDeepWith=cloneDeepWith;lodash.cloneWith=cloneWith;lodash.conformsTo=conformsTo;lodash.deburr=deburr;lodash.defaultTo=defaultTo;lodash.divide=divide;lodash.endsWith=
endsWith;lodash.eq=eq;lodash.escape=escape;lodash.escapeRegExp=escapeRegExp;lodash.every=every;lodash.find=find;lodash.findIndex=findIndex;lodash.findKey=findKey;lodash.findLast=findLast;lodash.findLastIndex=findLastIndex;lodash.findLastKey=findLastKey;lodash.floor=floor;lodash.forEach=forEach;lodash.forEachRight=forEachRight;lodash.forIn=forIn;lodash.forInRight=forInRight;lodash.forOwn=forOwn;lodash.forOwnRight=forOwnRight;lodash.get=get;lodash.gt=gt;lodash.gte=gte;lodash.has=has;lodash.hasIn=hasIn;
lodash.head=head;lodash.identity=identity;lodash.includes=includes;lodash.indexOf=indexOf;lodash.inRange=inRange;lodash.invoke=invoke;lodash.isArguments=isArguments;lodash.isArray=isArray;lodash.isArrayBuffer=isArrayBuffer;lodash.isArrayLike=isArrayLike;lodash.isArrayLikeObject=isArrayLikeObject;lodash.isBoolean=isBoolean;lodash.isBuffer=isBuffer;lodash.isDate=isDate;lodash.isElement=isElement;lodash.isEmpty=isEmpty;lodash.isEqual=isEqual;lodash.isEqualWith=isEqualWith;lodash.isError=isError;lodash.isFinite=
isFinite;lodash.isFunction=isFunction;lodash.isInteger=isInteger;lodash.isLength=isLength;lodash.isMap=isMap;lodash.isMatch=isMatch;lodash.isMatchWith=isMatchWith;lodash.isNaN=isNaN;lodash.isNative=isNative;lodash.isNil=isNil;lodash.isNull=isNull;lodash.isNumber=isNumber;lodash.isObject=isObject;lodash.isObjectLike=isObjectLike;lodash.isPlainObject=isPlainObject;lodash.isRegExp=isRegExp;lodash.isSafeInteger=isSafeInteger;lodash.isSet=isSet;lodash.isString=isString;lodash.isSymbol=isSymbol;lodash.isTypedArray=
isTypedArray;lodash.isUndefined=isUndefined;lodash.isWeakMap=isWeakMap;lodash.isWeakSet=isWeakSet;lodash.join=join;lodash.kebabCase=kebabCase;lodash.last=last;lodash.lastIndexOf=lastIndexOf;lodash.lowerCase=lowerCase;lodash.lowerFirst=lowerFirst;lodash.lt=lt;lodash.lte=lte;lodash.max=max;lodash.maxBy=maxBy;lodash.mean=mean;lodash.meanBy=meanBy;lodash.min=min;lodash.minBy=minBy;lodash.stubArray=stubArray;lodash.stubFalse=stubFalse;lodash.stubObject=stubObject;lodash.stubString=stubString;lodash.stubTrue=
stubTrue;lodash.multiply=multiply;lodash.nth=nth;lodash.noConflict=noConflict;lodash.noop=noop;lodash.now=now;lodash.pad=pad;lodash.padEnd=padEnd;lodash.padStart=padStart;lodash.parseInt=parseInt;lodash.random=random;lodash.reduce=reduce;lodash.reduceRight=reduceRight;lodash.repeat=repeat;lodash.replace=replace;lodash.result=result;lodash.round=round;lodash.runInContext=runInContext;lodash.sample=sample;lodash.size=size;lodash.snakeCase=snakeCase;lodash.some=some;lodash.sortedIndex=sortedIndex;lodash.sortedIndexBy=
sortedIndexBy;lodash.sortedIndexOf=sortedIndexOf;lodash.sortedLastIndex=sortedLastIndex;lodash.sortedLastIndexBy=sortedLastIndexBy;lodash.sortedLastIndexOf=sortedLastIndexOf;lodash.startCase=startCase;lodash.startsWith=startsWith;lodash.subtract=subtract;lodash.sum=sum;lodash.sumBy=sumBy;lodash.template=template;lodash.times=times;lodash.toFinite=toFinite;lodash.toInteger=toInteger;lodash.toLength=toLength;lodash.toLower=toLower;lodash.toNumber=toNumber;lodash.toSafeInteger=toSafeInteger;lodash.toString=
toString;lodash.toUpper=toUpper;lodash.trim=trim;lodash.trimEnd=trimEnd;lodash.trimStart=trimStart;lodash.truncate=truncate;lodash.unescape=unescape;lodash.uniqueId=uniqueId;lodash.upperCase=upperCase;lodash.upperFirst=upperFirst;lodash.each=forEach;lodash.eachRight=forEachRight;lodash.first=head;mixin(lodash,function(){var source={};baseForOwn(lodash,function(func,methodName){if(!hasOwnProperty.call(lodash.prototype,methodName))source[methodName]=func});return source}(),{"chain":false});lodash.VERSION=
VERSION;arrayEach(["bind","bindKey","curry","curryRight","partial","partialRight"],function(methodName){lodash[methodName].placeholder=lodash});arrayEach(["drop","take"],function(methodName,index){LazyWrapper.prototype[methodName]=function(n){n=n===undefined?1:nativeMax(toInteger(n),0);var result=this.__filtered__&&!index?new LazyWrapper(this):this.clone();if(result.__filtered__)result.__takeCount__=nativeMin(n,result.__takeCount__);else result.__views__.push({"size":nativeMin(n,MAX_ARRAY_LENGTH),
"type":methodName+(result.__dir__<0?"Right":"")});return result};LazyWrapper.prototype[methodName+"Right"]=function(n){return this.reverse()[methodName](n).reverse()}});arrayEach(["filter","map","takeWhile"],function(methodName,index){var type=index+1,isFilter=type==LAZY_FILTER_FLAG||type==LAZY_WHILE_FLAG;LazyWrapper.prototype[methodName]=function(iteratee){var result=this.clone();result.__iteratees__.push({"iteratee":getIteratee(iteratee,3),"type":type});result.__filtered__=result.__filtered__||
isFilter;return result}});arrayEach(["head","last"],function(methodName,index){var takeName="take"+(index?"Right":"");LazyWrapper.prototype[methodName]=function(){return this[takeName](1).value()[0]}});arrayEach(["initial","tail"],function(methodName,index){var dropName="drop"+(index?"":"Right");LazyWrapper.prototype[methodName]=function(){return this.__filtered__?new LazyWrapper(this):this[dropName](1)}});LazyWrapper.prototype.compact=function(){return this.filter(identity)};LazyWrapper.prototype.find=
function(predicate){return this.filter(predicate).head()};LazyWrapper.prototype.findLast=function(predicate){return this.reverse().find(predicate)};LazyWrapper.prototype.invokeMap=baseRest(function(path,args){if(typeof path=="function")return new LazyWrapper(this);return this.map(function(value){return baseInvoke(value,path,args)})});LazyWrapper.prototype.reject=function(predicate){return this.filter(negate(getIteratee(predicate)))};LazyWrapper.prototype.slice=function(start,end){start=toInteger(start);
var result=this;if(result.__filtered__&&(start>0||end<0))return new LazyWrapper(result);if(start<0)result=result.takeRight(-start);else if(start)result=result.drop(start);if(end!==undefined){end=toInteger(end);result=end<0?result.dropRight(-end):result.take(end-start)}return result};LazyWrapper.prototype.takeRightWhile=function(predicate){return this.reverse().takeWhile(predicate).reverse()};LazyWrapper.prototype.toArray=function(){return this.take(MAX_ARRAY_LENGTH)};baseForOwn(LazyWrapper.prototype,
function(func,methodName){var checkIteratee=/^(?:filter|find|map|reject)|While$/.test(methodName),isTaker=/^(?:head|last)$/.test(methodName),lodashFunc=lodash[isTaker?"take"+(methodName=="last"?"Right":""):methodName],retUnwrapped=isTaker||/^find/.test(methodName);if(!lodashFunc)return;lodash.prototype[methodName]=function(){var value=this.__wrapped__,args=isTaker?[1]:arguments,isLazy=value instanceof LazyWrapper,iteratee=args[0],useLazy=isLazy||isArray(value);var interceptor=function(value){var result=
lodashFunc.apply(lodash,arrayPush([value],args));return isTaker&&chainAll?result[0]:result};if(useLazy&&checkIteratee&&typeof iteratee=="function"&&iteratee.length!=1)isLazy=useLazy=false;var chainAll=this.__chain__,isHybrid=!!this.__actions__.length,isUnwrapped=retUnwrapped&&!chainAll,onlyLazy=isLazy&&!isHybrid;if(!retUnwrapped&&useLazy){value=onlyLazy?value:new LazyWrapper(this);var result=func.apply(value,args);result.__actions__.push({"func":thru,"args":[interceptor],"thisArg":undefined});return new LodashWrapper(result,
chainAll)}if(isUnwrapped&&onlyLazy)return func.apply(this,args);result=this.thru(interceptor);return isUnwrapped?isTaker?result.value()[0]:result.value():result}});arrayEach(["pop","push","shift","sort","splice","unshift"],function(methodName){var func=arrayProto[methodName],chainName=/^(?:push|sort|unshift)$/.test(methodName)?"tap":"thru",retUnwrapped=/^(?:pop|shift)$/.test(methodName);lodash.prototype[methodName]=function(){var args=arguments;if(retUnwrapped&&!this.__chain__){var value=this.value();
return func.apply(isArray(value)?value:[],args)}return this[chainName](function(value){return func.apply(isArray(value)?value:[],args)})}});baseForOwn(LazyWrapper.prototype,function(func,methodName){var lodashFunc=lodash[methodName];if(lodashFunc){var key=lodashFunc.name+"",names=realNames[key]||(realNames[key]=[]);names.push({"name":methodName,"func":lodashFunc})}});realNames[createHybrid(undefined,WRAP_BIND_KEY_FLAG).name]=[{"name":"wrapper","func":undefined}];LazyWrapper.prototype.clone=lazyClone;
LazyWrapper.prototype.reverse=lazyReverse;LazyWrapper.prototype.value=lazyValue;lodash.prototype.at=wrapperAt;lodash.prototype.chain=wrapperChain;lodash.prototype.commit=wrapperCommit;lodash.prototype.next=wrapperNext;lodash.prototype.plant=wrapperPlant;lodash.prototype.reverse=wrapperReverse;lodash.prototype.toJSON=lodash.prototype.valueOf=lodash.prototype.value=wrapperValue;lodash.prototype.first=lodash.prototype.head;if(symIterator)lodash.prototype[symIterator]=wrapperToIterator;return lodash};
var _=runInContext();if(typeof define=="function"&&typeof define.amd=="object"&&define.amd){root._=_;define(function(){return _})}else if(freeModule){(freeModule.exports=_)._=_;freeExports._=_}else root._=_}).call(this);
//# sourceURL=build://vz-sorting/sorting.js
var rc;
(function(b){function d(k,t){let l;(function(m){m[m.NATURAL=0]="NATURAL";m[m.REAL=1]="REAL";m[m.EXPONENT_SIGN=2]="EXPONENT_SIGN";m[m.EXPONENT=3]="EXPONENT"})(l||(l={}));let p=l.NATURAL;for(;t<k.length;t++)if(p===l.NATURAL)if("."===k[t])p=l.REAL;else if("e"===k[t]||"E"===k[t])p=l.EXPONENT_SIGN;else{if(!f(k[t]))break}else if(p===l.REAL)if("e"===k[t]||"E"===k[t])p=l.EXPONENT_SIGN;else{if(!f(k[t]))break}else if(p===l.EXPONENT_SIGN)if(f(k[t])||"+"===k[t]||"-"===k[t])p=l.EXPONENT;else break;else if(p===l.EXPONENT&&
!f(k[t]))break;return t}function f(k){return"0"<=k&&"9">=k}function h(k){return"/"===k||"_"===k||f(k)}b.compareTagNames=function(k,t){let l=0,p=0;for(;;){if(l===k.length)return p===t.length?0:-1;if(p===t.length)return 1;if(f(k[l])&&f(t[p])){var m=l,n=p;l=d(k,l+1);p=d(t,p+1);m=parseFloat(k.slice(m,l));n=parseFloat(t.slice(n,p));if(m<n)return-1;if(m>n)return 1}else{if(h(k[l])){if(!h(t[p]))return-1}else{if(h(t[p]))return 1;if(k[l]<t[p])return-1;if(k[l]>t[p])return 1}l++;p++}}}})(rc||(rc={}));

//# sourceURL=build://tf-backend/requestManager.js
var vc;
(function(b){function d(q,u,x,A){const y=new XMLHttpRequest;y.open(q,u);x&&(y.withCredentials=x);A&&y.setRequestHeader("Content-Type",A);return y}function f(q){const u=new m;if(!q)return u.methodType=p.GET,u;u.methodType=p.POST;u.body=h(q);return u}function h(q){const u=new FormData;for(let x in q)x&&u.append(x,q[x]);return u}class k extends Error{constructor(){super(...arguments);this.name="RequestCancellationError"}}b.RequestCancellationError=k;class t extends Error{constructor(q){super(q);this.name=
"InvalidRequestOptionsError";Object.setPrototypeOf(this,t.prototype)}}b.InvalidRequestOptionsError=t;class l extends Error{constructor(q,u){super();this.message=`RequestNetworkError: ${q.status} at ${u}`;this.name="RequestNetworkError";this.req=q;this.url=u}}b.RequestNetworkError=l;let p;(function(q){q.GET="GET";q.POST="POST"})(p=b.HttpMethodType||(b.HttpMethodType={}));class m{validate(){if(this.methodType===p.GET&&this.body)throw new t("body must be missing for a GET request.");}}b.RequestOptions=
m;class n{constructor(q=1E3,u=3){this._queue=[];this._nActiveRequests=0;this._nSimultaneousRequests=q;this._maxRetries=u}request(q,u){u=f(u);return this.requestWithOptions(q,u)}requestWithOptions(q,u){u.validate();return(new Promise((x,A)=>{this._queue.push({resolve:x,reject:A});this.launchRequests()})).then(()=>this.promiseWithRetries(q,this._maxRetries,u)).then(x=>{this._nActiveRequests--;this.launchRequests();return x},x=>{"RequestNetworkError"===x.name&&(this._nActiveRequests--,this.launchRequests());
return Promise.reject(x)})}fetch(q,u){return(new Promise((x,A)=>{this._queue.push({resolve:x,reject:A});this.launchRequests()})).then(()=>{let x=1;return new Promise(A=>{const y=()=>{fetch(q,u).then(w=>{!w.ok&&this._maxRetries>x?(x++,y()):(A(w),this._nActiveRequests--,this.launchRequests())})};y()})})}clearQueue(){for(;0<this._queue.length;)this._queue.pop().reject(new k("Request cancelled by clearQueue"))}activeRequests(){return this._nActiveRequests}outstandingRequests(){return this._nActiveRequests+
this._queue.length}launchRequests(){for(;this._nActiveRequests<this._nSimultaneousRequests&&0<this._queue.length;)this._nActiveRequests++,this._queue.pop().resolve()}promiseWithRetries(q,u,x){return this._promiseFromUrl(q,x).then(A=>A,A=>0<u?this.promiseWithRetries(q,u-1,x):Promise.reject(A))}_promiseFromUrl(q,u){return new Promise((x,A)=>{const y=d(u.methodType,q,u.withCredentials,u.contentType);y.onload=function(){200===y.status?x(JSON.parse(y.responseText)):A(new l(y,q))};y.onerror=function(){A(new l(y,
q))};u.body?y.send(u.body):y.send()})}}b.RequestManager=n})(vc||(vc={}));

//# sourceURL=build://tf-backend/urlPathHelpers.js
(function(b){function d(f){return encodeURIComponent(f).replace(/\(/g,"%28").replace(/\)/g,"%29")}b.addParams=function(f,h){var k=Object.keys(h).sort().filter(l=>void 0!==h[l]);if(!k.length)return f;const t=-1!==f.indexOf("?")?"\x26":"?";k=[].concat(...k.map(l=>{const p=h[l];return(Array.isArray(p)?p:[p]).map(m=>`${l}=${d(m)}`)})).join("\x26");return f+t+k}})(vc||(vc={}));

//# sourceURL=build://tf-backend/router.js
(function(b){function d(t="data",l=new URLSearchParams(window.location.search)){"/"===t[t.length-1]&&(t=t.slice(0,t.length-1));return{environment:()=>f(t,"/environment"),experiments:()=>f(t,"/experiments"),pluginRoute:(p,m,n)=>f(t+"/plugin",`/${p}${m}`,n),pluginsListing:()=>f(t,"/plugins_listing",h({["experimentalPlugin"]:l.getAll("experimentalPlugin")})),runs:()=>f(t,"/runs"),runsForExperiment:p=>f(t,"/experiment_runs",h({experiment:String(p)}))}}function f(t,l,p=new URLSearchParams){t+=l;String(p)&&
(l=l.includes("?")?"\x26":"?",t+=l+String(p));return t}function h(t={}){const l=Object.keys(t).sort().filter(m=>t[m]),p=new URLSearchParams;l.forEach(m=>{const n=t[m];(Array.isArray(n)?n:[n]).forEach(q=>p.append(m,q))});return p}let k=d();b.createRouter=d;b.getRouter=function(){return k};b.setRouter=function(t){if(null==t)throw Error("Router required, but got: "+t);k=t};b.createSearchParam=h})(vc||(vc={}));

//# sourceURL=build://tf-backend/baseStore.js
(function(b){class d{constructor(h){this.listener=h}}b.ListenKey=d;class f{constructor(){this.requestManager=new b.RequestManager(1);this._listeners=new Set;this.initialized=!1}refresh(){return this.load().then(()=>{this.initialized=!0})}addListener(h){h=new d(h);this._listeners.add(h);return h}removeListenerByKey(h){this._listeners.delete(h)}emitChange(){this._listeners.forEach(h=>{try{h.listener()}catch(k){}})}}b.BaseStore=f})(vc||(vc={}));

//# sourceURL=build://tf-backend/environmentStore.js
(function(b){class d extends b.BaseStore{load(){const f=b.getRouter().environment();return this.requestManager.request(f).then(h=>{const k={dataLocation:h.data_location,windowTitle:h.window_title};void 0!==h.experiment_name&&(k.experimentName=h.experiment_name);void 0!==h.experiment_description&&(k.experimentDescription=h.experiment_description);void 0!==h.creation_time&&(k.creationTime=h.creation_time);_.isEqual(this.environment,k)||(this.environment=k,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}}b.EnvironmentStore=d;b.environmentStore=new d})(vc||(vc={}));

//# sourceURL=build://tf-backend/experimentsStore.js
(function(b){class d extends b.BaseStore{constructor(){super(...arguments);this._experiments=[]}load(){const f=b.getRouter().experiments();return this.requestManager.request(f).then(h=>{_.isEqual(this._experiments,h)||(this._experiments=h,this.emitChange())})}getExperiments(){return this._experiments.slice()}}b.ExperimentsStore=d;b.experimentsStore=new d})(vc||(vc={}));

//# sourceURL=build://tf-backend/runsStore.js
(function(b){class d extends b.BaseStore{constructor(){super(...arguments);this._runs=[]}load(){const f=b.getRouter().runs();return this.requestManager.request(f).then(h=>{_.isEqual(this._runs,h)||(this._runs=h,this.emitChange())})}getRuns(){return this._runs.slice()}}b.RunsStore=d;b.runsStore=new d})(vc||(vc={}));

//# sourceURL=build://tf-backend/backend.js
(function(b){b.TYPES=[];b.getRunsNamed=function(d){return _.keys(d).sort(rc.compareTagNames)};b.getTags=function(d){return _.union.apply(null,_.values(d)).sort(rc.compareTagNames)};b.filterTags=function(d,f){let h=[];f.forEach(k=>h=h.concat(d[k]));return _.uniq(h).sort(rc.compareTagNames)}})(vc||(vc={}));

//# sourceURL=build://tf-backend/canceller.js
(function(b){class d{constructor(){this.cancellationCount=0}cancellable(f){const h=this.cancellationCount;return k=>f({value:k,cancelled:this.cancellationCount!==h})}cancelAll(){this.cancellationCount++}}b.Canceller=d})(vc||(vc={}));

//# sourceURL=build://tf-backend/tf-backend-polymer.js
(function(b){Polymer({is:"tf-backend",_template:null,tf_backend:b})})(vc||(vc={}));

//# sourceURL=build://tf-categorization-utils/categorizationUtils.js
var $c;
(function(b){function d(m,n){const q=(()=>{try{return new RegExp(n)}catch(u){return null}})();return{name:n,metadata:{type:p.SEARCH_RESULTS,validRegex:!!q,universalRegex:".*"===n},items:q?m.filter(u=>u.match(q)):[]}}function f(m,n="/"){const q=[],u={};m.forEach(x=>{var A=x.indexOf(n);A=0<=A?x.slice(0,A):x;if(!u[A]){const y={name:A,metadata:{type:p.PREFIX_GROUP},items:[]};u[A]=y;q.push(y)}u[A].items.push(x)});return q}function h(m,n=""){n=[d(m,n)];m=f(m);return[].concat(n,m)}function k(m,n,q){const u=
vc.getTags(m);q=h(u,q);const x=t(_.pick(m,n));return q.map(({name:A,metadata:y,items:w})=>({name:A,metadata:y,items:w.map(C=>({tag:C,runs:(x.get(C)||[]).slice()}))}))}function t(m){const n=new Map;Object.keys(m).forEach(q=>{m[q].forEach(u=>{const x=n.get(u)||[];x.push(q);n.set(u,x)})});return n}function l(m,n){const q=rc.compareTagNames(m.tag,n.tag);return 0!=q?q:rc.compareTagNames(m.run,n.run)}let p;(function(m){m[m.SEARCH_RESULTS=0]="SEARCH_RESULTS";m[m.PREFIX_GROUP=1]="PREFIX_GROUP"})(p=b.CategoryType||
(b.CategoryType={}));b.categorizeBySearchQuery=d;b.categorizeByPrefix=f;b.categorize=h;b.categorizeTags=k;b.categorizeRunTagCombinations=function(m,n,q){return k(m,n,q).map(function(u){const x=_.flatten(u.items.map(({tag:A,runs:y})=>y.map(w=>({tag:A,run:w}))));x.sort(l);return{name:u.name,metadata:u.metadata,items:x}})}})($c||($c={}));

//# sourceURL=build://tf-globals/globals.js
var ad;(function(b){let d=!1;b.setUseHash=function(h){d=h};b.useHash=function(){return d};let f="";b.setFakeHash=function(h){f=h};b.getFakeHash=function(){return f}})(ad||(ad={}));

//# sourceURL=build://tf-globals/globals-polymer.js
(function(b){Polymer({is:"tf-globals",_template:null,tf_globals:b})})(ad||(ad={}));

//# sourceURL=build://tf-storage/listeners.js
var pd;
(function(b){class d{constructor(k){this.listener=k}}b.ListenKey=d;const f=new Set,h=new Set;window.addEventListener("hashchange",()=>{f.forEach(k=>k.listener())});window.addEventListener("storage",()=>{h.forEach(k=>k.listener())});b.addHashListener=function(k){k=new d(k);f.add(k);return k};b.addStorageListener=function(k){k=new d(k);h.add(k);return k};b.fireStorageChanged=function(){h.forEach(k=>k.listener())};b.removeHashListenerByKey=function(k){f.delete(k)};b.removeStorageListenerByKey=function(k){h.delete(k)}})(pd||
(pd={}));

//# sourceURL=build://tf-storage/storage.js
(function(b){function d(n,q){function u(w,C={}){const {defaultValue:G,useLocalStorage:D=!1}=C;w=D?window.localStorage.getItem(w):l(h())[w];return void 0==w?_.cloneDeep(G):n(w)}function x(w,C,G={}){const {defaultValue:D,useLocalStorage:B=!1,useLocationReplace:I=!1}=G;G=q(C);B?(window.localStorage.setItem(w,G),b.fireStorageChanged()):_.isEqual(C,u(w,{useLocalStorage:B}))||(_.isEqual(C,D)?p(w):(C=l(h()),C[w]=G,k(t(C),I)))}const A=[],y=[];return{get:u,set:x,getInitializer:function(w,C){const G=Object.assign({defaultValue:C.defaultValue,
polymerProperty:w,useLocalStorage:!1},C);return function(){const D=f(this,w),B=()=>{const N=u(D,G);_.isEqual(N,this[G.polymerProperty])||(this[G.polymerProperty]=N)},I=(G.useLocalStorage?b.addStorageListener:b.addHashListener)(()=>B());G.useLocalStorage?y.push(I):A.push(I);B();return this[G.polymerProperty]}},getObserver:function(w,C){const G=Object.assign({defaultValue:C.defaultValue,polymerProperty:w,useLocalStorage:!1},C);return function(){const D=f(this,w);x(D,this[G.polymerProperty],G)}},disposeBinding:function(){A.forEach(w=>
b.removeHashListenerByKey(w));y.forEach(w=>b.removeStorageListenerByKey(w))}}}function f(n,q){n=n[b.DISAMBIGUATOR];return(null==n?[q]:[n,q]).join(".")}function h(){return ad.useHash()?window.location.hash.slice(1):ad.getFakeHash()}function k(n,q=!1){ad.useHash()?q?window.location.replace("#"+n):window.location.hash=n:ad.setFakeHash(n)}function t(n){let q="";void 0!==n[b.TAB]&&(q+=n[b.TAB]);const u=Object.keys(n).map(x=>[x,n[x]]).filter(x=>x[0]!==b.TAB).map(x=>encodeURIComponent(x[0])+"\x3d"+encodeURIComponent(x[1])).join("\x26");
return 0<u.length?q+"\x26"+u:q}function l(n){const q={};n.split("\x26").forEach(u=>{u=u.split("\x3d");1===u.length?q[b.TAB]=u[0]:2===u.length&&(q[decodeURIComponent(u[0])]=decodeURIComponent(u[1]))});return q}function p(n){const q=l(h());delete q[n];k(t(q))}b.TAB="__tab__";b.DISAMBIGUATOR="disambiguator";b.urlDict=l(h());b.addHashListener(()=>{b.urlDict=l(h())});var m=d(n=>n,n=>n);b.getString=m.get;b.setString=m.set;b.getStringInitializer=m.getInitializer;b.getStringObserver=m.getObserver;b.disposeStringBinding=
m.disposeBinding;m=d(n=>"true"===n?!0:"false"===n?!1:void 0,n=>n.toString());b.getBoolean=m.get;b.setBoolean=m.set;b.getBooleanInitializer=m.getInitializer;b.getBooleanObserver=m.getObserver;b.disposeBooleanBinding=m.disposeBinding;m=d(n=>+n,n=>n.toString());b.getNumber=m.get;b.setNumber=m.set;b.getNumberInitializer=m.getInitializer;b.getNumberObserver=m.getObserver;b.disposeNumberBinding=m.disposeBinding;m=d(n=>JSON.parse(atob(n)),n=>btoa(JSON.stringify(n)));b.getObject=m.get;b.setObject=m.set;b.getObjectInitializer=
m.getInitializer;b.getObjectObserver=m.getObserver;b.disposeObjectBinding=m.disposeBinding;b.makeBindings=d;b.migrateLegacyURLScheme=function(){const n=new Set("examplesPath hideModelPane2 modelName1 modelName2 inferenceAddress1 inferenceAddress2 modelType modelVersion1 modelVersion2 modelSignature1 modelSignature2 maxExamples labelVocabPath multiClass sequenceExamples maxClassesToDisplay samplingOdds usePredictApi predictInputTensor predictOutputTensor".split(" ")),q=l(h());if("whatif"===q[b.TAB])for(let u of n)u in
q&&(q[`p.whatif.${u}`]=q[u]);k(t(q));this.urlDict=q}})(pd||(pd={}));

//# sourceURL=build://tf-storage/tf-storage-polymer.js
(function(b){Polymer({is:"tf-storage",_template:null,tf_storage:b})})(pd||(pd={}));

//# sourceURL=build://tf-categorization-utils/tf-tag-filterer.html.js
Polymer({is:"tf-tag-filterer",properties:{tagFilter:{type:String,notify:!0,computed:"_computeTagFilter(_tagFilter)"},_tagFilter:{type:String,value:pd.getStringInitializer("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"}),observer:"_tagFilterObserver"}},_tagFilterObserver:pd.getStringObserver("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"}),_computeTagFilter(){return this._tagFilter}});

//# sourceURL=build://tf-dashboard-common/array-update-helper.js
var qd;(function(b){b.ArrayUpdateHelper={updateArrayProp(d,f,h){let k=this.get(d);if(!Array.isArray(f))throw RangeError(`Expected new value to '${d}' to be an array.`);Array.isArray(k)||(k=[],this.set(d,k));const t=new Set(f.map((m,n)=>h(m,n)));let l=0,p=0;for(;l<k.length&&p<f.length;)t.has(h(k[l],l))?(h(k[l],l)==h(f[p],p)?this.set(`${d}.${l}`,f[p]):this.splice(d,l,0,f[p]),p++,l++):this.splice(d,l,1);l<k.length&&this.splice(d,l);p<f.length&&this.push(d,...f.slice(p))}}})(qd||(qd={}));

//# sourceURL=build://tf-dashboard-common/tf-dashboard-layout.html.js
Polymer({is:"tf-dashboard-layout"});

//# sourceURL=build://tf-dashboard-common/tf-option-selector.html.js
Polymer({is:"tf-option-selector",properties:{name:String,selectedId:{type:String,notify:!0,observer:"_selectedIdChanged"}},attached:function(){this.async(function(){this.getEffectiveChildren().forEach(function(b){this.listen(b,"tap","_selectTarget")}.bind(this))})},_selectTarget:function(b){this.selectedId=b.currentTarget.id},_selectedIdChanged:function(){var b=this.queryEffectiveChildren("#"+this.selectedId);b&&(this.getEffectiveChildren().forEach(function(d){d.classList.remove("selected")}),b.classList.add("selected"))}});

//# sourceURL=build://iron-collapse/iron-collapse.html.js
Polymer({is:"iron-collapse",behaviors:[Polymer.IronResizableBehavior],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(b,d){b="auto"===b?"":b;d=d&&!this.noAnimation&&this.isAttached&&this._desiredSize!==b;this._desiredSize=b;this._updateTransition(!1);d&&(d=this._calcSize(),""===b&&(this.style[this._dimensionMax]="",b=this._calcSize()),this.style[this._dimensionMax]=d,this.scrollTop=
this.scrollTop,this._updateTransition(!0),d=b!==d);this.style[this._dimensionMax]=b;d||this._transitionEnd()},enableTransition:function(b){Polymer.Base._warn("`enableTransition()` is deprecated, use `noAnimation` instead.");this.noAnimation=!b},_updateTransition:function(b){this.style.transitionDuration=b&&!this.noAnimation?"":"0s"},_horizontalChanged:function(){this.style.transitionProperty=this._dimensionMaxCss;this.style["maxWidth"===this._dimensionMax?"maxHeight":"maxWidth"]="";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(b){Polymer.dom(b).rootTarget===this&&this._transitionEnd()},_calcSize:function(){return this.getBoundingClientRect()[this.dimension]+"px"}});

//# sourceURL=build://tf-paginated-view/tf-dom-repeat.html.js
var Jd;
(function(b){b.TfDomRepeatBehavior=[qd.ArrayUpdateHelper,{properties:{as:{type:String,value:"item"},_contentActive:{type:Boolean,value:!0},_domBootstrapped:{type:Boolean,value:!1},_ctor:{type:Function,value:()=>null},_renderedItems:{type:Array,value:()=>[]},_renderedTemplateInst:{type:Object,value:()=>new Map},_lruCachedItems:{type:Object,value:()=>new Map},_cacheSize:{type:Number,value:10},_getItemKey:{type:Function,value:()=>d=>JSON.stringify(d)}},observers:["_bootstrapDom(_itemsRendered, isAttached)","_updateDom(_renderedItems.*, _domBootstrapped)",
"_updateActive(_contentActive)","_trimCache(_cacheSize)"],setCacheSize(d){this._cacheSize=d},setGetItemKey(d){this._getItemKey=d},updateDom(d){this.updateArrayProp("_renderedItems",d,this._getItemKey)},_ensureTemplatized(){if(!this.isAttached)return!1;this._ctor||(this._ctor=Polymer.Templatize.templatize(this.querySelector("template"),this,{parentModel:!0,instanceProps:{[this.as]:!0,active:this._contentActive},forwardHostProp:function(d,f){this._renderedTemplateInst.forEach(h=>{h.forwardHostProp(d,
f)})}}));return!0},_bootstrapDom(){this._itemsRendered&&this._ensureTemplatized()&&!this._domBootstrapped&&(Array.from(this.children).forEach(d=>{Polymer.dom(this).removeChild(d)}),this._lruCachedItems.clear(),this._renderedItems.forEach((d,f)=>this._insertItem(d,f)),this._domBootstrapped=!0)},_updateActive(){this._domBootstrapped&&Array.from(this._renderedTemplateInst.values()).forEach(d=>{d.notifyPath("active",this._contentActive)})},_updateDom(d){if(this._domBootstrapped&&"_renderedItems"!=d.path&&
"_renderedItems.length"!=d.path)if("_renderedItems.splices"===d.path)d.value.indexSplices.forEach(f=>{const h=f.index,k=f.addedCount,t=f.object;f.removed.forEach(l=>{this._removeItem(l,this.children[h])});t.slice(h,h+k).forEach((l,p)=>this._insertItem(l,h+p));this._trimCache()});else{const f=this._getItemKey(d.value);this._renderedTemplateInst.has(f)?this._renderedTemplateInst.get(f).notifyPath(this.as,d.value):console.warn(`Expected '${f}' to exist in the DOM but `+"could not find one.")}},_insertItem(d,
f){if(!this._ensureTemplatized())throw Error("Expected templatized before inserting an item");const h=this._getItemKey(d);if(this._lruCachedItems.has(h))d=this._lruCachedItems.get(h),this._lruCachedItems.delete(h),this._renderedTemplateInst.get(h).notifyPath("active",this._contentActive);else{const k=new this._ctor({[this.as]:d,active:this._contentActive});d=k.root;this._renderedTemplateInst.set(h,k)}this.children[f]?Polymer.dom(this).insertBefore(d,this.children[f]):((d.nodeType==Node.DOCUMENT_FRAGMENT_NODE?
Array.from(d.children):[d]).forEach(k=>k.setAttribute("slot","items")),Polymer.dom(this).appendChild(d))},_removeItem(d,f){Polymer.dom(f.parentNode).removeChild(f);d=this._getItemKey(d);this._lruCachedItems.set(d,f);this._renderedTemplateInst.get(d).notifyPath("active",!1)},_trimCache(){for(;this._lruCachedItems.size>this._cacheSize;){const [d]=this._lruCachedItems.keys();this._lruCachedItems.delete(d);this._renderedTemplateInst.delete(d)}}}]})(Jd||(Jd={}));

//# sourceURL=build://tf-paginated-view/paginatedViewStore.js
var ne;
(function(b){let d=null;const f=new Set;b.addLimitListener=function(h){f.add(h)};b.removeLimitListener=function(h){f.delete(h)};b.getLimit=function(){null==d&&(d=pd.getNumber("TF.TensorBoard.PaginatedView.limit",{useLocalStorage:!0}),null==d||!isFinite(d)||0>=d)&&(d=12);return d};b.setLimit=function(h){if(h!==Math.floor(h))throw Error(`limit must be an integer, but got: ${h}`);if(0>=h)throw Error(`limit must be positive, but got: ${h}`);h!==d&&(d=h,pd.setNumber("TF.TensorBoard.PaginatedView.limit",d,
{useLocalStorage:!0}),f.forEach(k=>{k()}))}})(ne||(ne={}));

//# sourceURL=build://tf-paginated-view/tf-paginated-view-store.html.js
Polymer({is:"tf-paginated-view-store",_template:null,tf_paginated_view:ne});

//# sourceURL=build://tf-paginated-view/tf-category-paginated-view.html.js
Polymer({is:"tf-category-paginated-view",properties:{category:Object,initialOpened:Boolean,opened:{type:Boolean,notify:!0,readOnly:!0},_contentActive:{type:Boolean,computed:"_computeContentActive(opened)"},disablePagination:{type:Boolean,value:!1},_count:{type:Number,computed:"_computeCount(category.items.*)"},_hasMultiple:{type:Boolean,computed:"_computeHasMultiple(_count)"},_paneRendered:{type:Boolean,computed:"_computePaneRendered(category)",observer:"_onPaneRenderedChanged"},_itemsRendered:{type:Boolean,
computed:"_computeItemsRendered(opened, _paneRendered)"},_isSearchResults:{type:Boolean,computed:"_computeIsSearchResults(category.metadata.type)"},_isInvalidSearchResults:{type:Boolean,computed:"_computeIsInvalidSearchResults(category.metadata)"},_isUniversalSearchQuery:{type:Boolean,computed:"_computeIsUniversalSearchQuery(category.metadata)"},getCategoryItemKey:{type:Function,value:()=>b=>JSON.stringify(b),observer:"_getCategoryItemKeyChanged"},_limit:{type:Number,value:12,observer:"_limitChanged"},
_activeIndex:{type:Number,value:0},_currentPage:{type:Number,computed:"_computeCurrentPage(_limit, _activeIndex)"},_pageCount:{type:Number,computed:"_computePageCount(category.items.*, _limit)"},_multiplePagesExist:{type:Boolean,computed:"_computeMultiplePagesExist(_pageCount, disablePagination)"},_hasPreviousPage:{type:Boolean,computed:"_computeHasPreviousPage(_currentPage)"},_hasNextPage:{type:Boolean,computed:"_computeHasNextPage(_currentPage, _pageCount)"},_inputWidth:{type:String,computed:"_computeInputWidth(_pageCount)",
observer:"_updateInputWidth"},_pageInputValue:{type:String,computed:"_computePageInputValue(_pageInputFocused, _pageInputRawValue, _currentPage)",observer:"_updatePageInputValue"},_pageInputRawValue:{type:String,value:""},_pageInputFocused:{type:Boolean,value:!1}},observers:["_clampActiveIndex(category.items.*)","_updateRenderedItems(_itemsRendered, category.items.*, _limit, _activeIndex, _pageCount, disablePagination)"],behaviors:[Jd.TfDomRepeatBehavior],_computeCount(){return this.category.items.length},
_computeHasMultiple(){return 1<this._count},_togglePane(){this._setOpened(!this.opened)},_computeContentActive(){return this.opened},_onPaneRenderedChanged(b,d){b&&b!==d&&this.$.ifRendered.render()},_computePaneRendered(b){return!(b.metadata.type===$c.CategoryType.SEARCH_RESULTS&&""===b.name)},_computeItemsRendered(){return this._paneRendered&&this.opened},_computeIsSearchResults(b){return b===$c.CategoryType.SEARCH_RESULTS},_computeIsInvalidSearchResults(b){return b.type===$c.CategoryType.SEARCH_RESULTS&&
!b.validRegex},_computeIsUniversalSearchQuery(b){return b.type===$c.CategoryType.SEARCH_RESULTS&&b.universalRegex},_isCompositeSearch(){const b=this.category.metadata.type;return this.category.metadata.compositeSearch&&b===$c.CategoryType.SEARCH_RESULTS},ready(){this._setOpened(null==this.initialOpened?!0:this.initialOpened);this._limitListener=()=>{this.set("_limit",ne.getLimit())};ne.addLimitListener(this._limitListener);this._limitListener()},detached(){ne.removeLimitListener(this._limitListener)},
_updateRenderedItems(b,d,f,h,k,t){b&&(b=Math.floor(h/f),d=this.category.items||[],this.updateDom(t?d:d.slice(b*f,(b+1)*f),this.getCategoryItemKey))},_limitChanged(b){this.setCacheSize(2*b)},_getCategoryItemKeyChanged(){this.setGetItemKey(this.getCategoryItemKey)},_computeCurrentPage(b,d){return Math.floor(d/b)+1},_computePageCount(b,d){return this.category?Math.ceil(this.category.items.length/d):0},_computeMultiplePagesExist(b,d){return!d&&1<b},_computeHasPreviousPage(b){return 1<b},_computeHasNextPage(b,
d){return b<d},_computeInputWidth(b){return`calc(${b.toString().length}em + 20px)`},_setActiveIndex(b){const d=(this.category.items||[]).length-1;b>d&&(b=d);0>b&&(b=0);this.set("_activeIndex",b)},_clampActiveIndex(){this._setActiveIndex(this._activeIndex)},_performPreviousPage(){this._setActiveIndex(this._activeIndex-this._limit)},_performNextPage(){this._setActiveIndex(this._activeIndex+this._limit)},_computePageInputValue(b,d,f){return b?d:f.toString()},_handlePageInputEvent(b){this.set("_pageInputRawValue",
b.target.value);b=Number(b.target.value||NaN);isNaN(b)||this._setActiveIndex(this._limit*(Math.max(1,Math.min(b,this._pageCount))-1))},_handlePageChangeEvent(){this.set("_pageInputRawValue",this._currentPage.toString())},_handlePageFocusEvent(){this.set("_pageInputRawValue",this._pageInputValue);this.set("_pageInputFocused",!0)},_handlePageBlurEvent(){this.set("_pageInputFocused",!1)},_updatePageInputValue(b){const d=this.$$("#page-input input");d&&(d.value=b)},_updateInputWidth(){this.updateStyles({"--tf-category-paginated-view-page-input-width":this._inputWidth})}});

//# sourceURL=build://paper-dialog-behavior/paper-dialog-behavior.html.js
(function(){Polymer.PaperDialogBehaviorImpl={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(b,d){d&&(b?(this.__prevNoCancelOnOutsideClick=
this.noCancelOnOutsideClick,this.__prevNoCancelOnEscKey=this.noCancelOnEscKey,this.__prevWithBackdrop=this.withBackdrop,this.withBackdrop=this.noCancelOnEscKey=this.noCancelOnOutsideClick=!0):(this.noCancelOnOutsideClick=this.noCancelOnOutsideClick&&this.__prevNoCancelOnOutsideClick,this.noCancelOnEscKey=this.noCancelOnEscKey&&this.__prevNoCancelOnEscKey,this.withBackdrop=this.withBackdrop&&this.__prevWithBackdrop))},_updateClosingReasonConfirmed:function(b){this.closingReason=this.closingReason||
{};this.closingReason.confirmed=b},_onDialogClick:function(b){for(var d=Polymer.dom(b).path,f=0,h=d.indexOf(this);f<h;f++){var k=d[f];if(k.hasAttribute&&(k.hasAttribute("dialog-dismiss")||k.hasAttribute("dialog-confirm"))){this._updateClosingReasonConfirmed(k.hasAttribute("dialog-confirm"));this.close();b.stopPropagation();break}}}};Polymer.PaperDialogBehavior=[Polymer.IronOverlayBehavior,Polymer.PaperDialogBehaviorImpl]})();

//# sourceURL=build://paper-dialog/paper-dialog.html.js
Polymer({is:"paper-dialog",behaviors:[Polymer.PaperDialogBehavior,Polymer.NeonAnimationRunnerBehavior],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()}});

// https://d3js.org v5.7.0 Copyright 2018 Mike Bostock
!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n(t.d3=t.d3||{})}(this,function(t){"use strict";function n(t,n){return t<n?-1:t>n?1:t>=n?0:NaN}function e(t){var e;return 1===t.length&&(e=t,t=function(t,r){return n(e(t),r)}),{left:function(n,e,r,i){for(null==r&&(r=0),null==i&&(i=n.length);r<i;){var o=r+i>>>1;t(n[o],e)<0?r=o+1:i=o}return r},right:function(n,e,r,i){for(null==r&&(r=0),null==i&&(i=n.length);r<i;){var o=r+i>>>1;t(n[o],e)>0?i=o:r=o+1}return r}}}var r=e(n),i=r.right,o=r.left;function a(t,n){return[t,n]}function u(t){return null===t?NaN:+t}function f(t,n){var e,r,i=t.length,o=0,a=-1,f=0,c=0;if(null==n)for(;++a<i;)isNaN(e=u(t[a]))||(c+=(r=e-f)*(e-(f+=r/++o)));else for(;++a<i;)isNaN(e=u(n(t[a],a,t)))||(c+=(r=e-f)*(e-(f+=r/++o)));if(o>1)return c/(o-1)}function c(t,n){var e=f(t,n);return e?Math.sqrt(e):e}function s(t,n){var e,r,i,o=t.length,a=-1;if(null==n){for(;++a<o;)if(null!=(e=t[a])&&e>=e)for(r=i=e;++a<o;)null!=(e=t[a])&&(r>e&&(r=e),i<e&&(i=e))}else for(;++a<o;)if(null!=(e=n(t[a],a,t))&&e>=e)for(r=i=e;++a<o;)null!=(e=n(t[a],a,t))&&(r>e&&(r=e),i<e&&(i=e));return[r,i]}var l=Array.prototype,h=l.slice,d=l.map;function p(t){return function(){return t}}function v(t){return t}function g(t,n,e){t=+t,n=+n,e=(i=arguments.length)<2?(n=t,t=0,1):i<3?1:+e;for(var r=-1,i=0|Math.max(0,Math.ceil((n-t)/e)),o=new Array(i);++r<i;)o[r]=t+r*e;return o}var y=Math.sqrt(50),_=Math.sqrt(10),b=Math.sqrt(2);function m(t,n,e){var r,i,o,a,u=-1;if(e=+e,(t=+t)===(n=+n)&&e>0)return[t];if((r=n<t)&&(i=t,t=n,n=i),0===(a=x(t,n,e))||!isFinite(a))return[];if(a>0)for(t=Math.ceil(t/a),n=Math.floor(n/a),o=new Array(i=Math.ceil(n-t+1));++u<i;)o[u]=(t+u)*a;else for(t=Math.floor(t*a),n=Math.ceil(n*a),o=new Array(i=Math.ceil(t-n+1));++u<i;)o[u]=(t-u)/a;return r&&o.reverse(),o}function x(t,n,e){var r=(n-t)/Math.max(0,e),i=Math.floor(Math.log(r)/Math.LN10),o=r/Math.pow(10,i);return i>=0?(o>=y?10:o>=_?5:o>=b?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=y?10:o>=_?5:o>=b?2:1)}function w(t,n,e){var r=Math.abs(n-t)/Math.max(0,e),i=Math.pow(10,Math.floor(Math.log(r)/Math.LN10)),o=r/i;return o>=y?i*=10:o>=_?i*=5:o>=b&&(i*=2),n<t?-i:i}function M(t){return Math.ceil(Math.log(t.length)/Math.LN2)+1}function A(t,n,e){if(null==e&&(e=u),r=t.length){if((n=+n)<=0||r<2)return+e(t[0],0,t);if(n>=1)return+e(t[r-1],r-1,t);var r,i=(r-1)*n,o=Math.floor(i),a=+e(t[o],o,t);return a+(+e(t[o+1],o+1,t)-a)*(i-o)}}function T(t,n){var e,r,i=t.length,o=-1;if(null==n){for(;++o<i;)if(null!=(e=t[o])&&e>=e)for(r=e;++o<i;)null!=(e=t[o])&&e>r&&(r=e)}else for(;++o<i;)if(null!=(e=n(t[o],o,t))&&e>=e)for(r=e;++o<i;)null!=(e=n(t[o],o,t))&&e>r&&(r=e);return r}function N(t){for(var n,e,r,i=t.length,o=-1,a=0;++o<i;)a+=t[o].length;for(e=new Array(a);--i>=0;)for(n=(r=t[i]).length;--n>=0;)e[--a]=r[n];return e}function S(t,n){var e,r,i=t.length,o=-1;if(null==n){for(;++o<i;)if(null!=(e=t[o])&&e>=e)for(r=e;++o<i;)null!=(e=t[o])&&r>e&&(r=e)}else for(;++o<i;)if(null!=(e=n(t[o],o,t))&&e>=e)for(r=e;++o<i;)null!=(e=n(t[o],o,t))&&r>e&&(r=e);return r}function E(t){if(!(i=t.length))return[];for(var n=-1,e=S(t,k),r=new Array(e);++n<e;)for(var i,o=-1,a=r[n]=new Array(i);++o<i;)a[o]=t[o][n];return r}function k(t){return t.length}var C=Array.prototype.slice;function P(t){return t}var z=1,R=2,L=3,D=4,U=1e-6;function q(t){return"translate("+(t+.5)+",0)"}function O(t){return"translate(0,"+(t+.5)+")"}function Y(){return!this.__axis}function B(t,n){var e=[],r=null,i=null,o=6,a=6,u=3,f=t===z||t===D?-1:1,c=t===D||t===R?"x":"y",s=t===z||t===L?q:O;function l(l){var h=null==r?n.ticks?n.ticks.apply(n,e):n.domain():r,d=null==i?n.tickFormat?n.tickFormat.apply(n,e):P:i,p=Math.max(o,0)+u,v=n.range(),g=+v[0]+.5,y=+v[v.length-1]+.5,_=(n.bandwidth?function(t){var n=Math.max(0,t.bandwidth()-1)/2;return t.round()&&(n=Math.round(n)),function(e){return+t(e)+n}}:function(t){return function(n){return+t(n)}})(n.copy()),b=l.selection?l.selection():l,m=b.selectAll(".domain").data([null]),x=b.selectAll(".tick").data(h,n).order(),w=x.exit(),M=x.enter().append("g").attr("class","tick"),A=x.select("line"),T=x.select("text");m=m.merge(m.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),x=x.merge(M),A=A.merge(M.append("line").attr("stroke","currentColor").attr(c+"2",f*o)),T=T.merge(M.append("text").attr("fill","currentColor").attr(c,f*p).attr("dy",t===z?"0em":t===L?"0.71em":"0.32em")),l!==b&&(m=m.transition(l),x=x.transition(l),A=A.transition(l),T=T.transition(l),w=w.transition(l).attr("opacity",U).attr("transform",function(t){return isFinite(t=_(t))?s(t):this.getAttribute("transform")}),M.attr("opacity",U).attr("transform",function(t){var n=this.parentNode.__axis;return s(n&&isFinite(n=n(t))?n:_(t))})),w.remove(),m.attr("d",t===D||t==R?a?"M"+f*a+","+g+"H0.5V"+y+"H"+f*a:"M0.5,"+g+"V"+y:a?"M"+g+","+f*a+"V0.5H"+y+"V"+f*a:"M"+g+",0.5H"+y),x.attr("opacity",1).attr("transform",function(t){return s(_(t))}),A.attr(c+"2",f*o),T.attr(c,f*p).text(d),b.filter(Y).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",t===R?"start":t===D?"end":"middle"),b.each(function(){this.__axis=_})}return l.scale=function(t){return arguments.length?(n=t,l):n},l.ticks=function(){return e=C.call(arguments),l},l.tickArguments=function(t){return arguments.length?(e=null==t?[]:C.call(t),l):e.slice()},l.tickValues=function(t){return arguments.length?(r=null==t?null:C.call(t),l):r&&r.slice()},l.tickFormat=function(t){return arguments.length?(i=t,l):i},l.tickSize=function(t){return arguments.length?(o=a=+t,l):o},l.tickSizeInner=function(t){return arguments.length?(o=+t,l):o},l.tickSizeOuter=function(t){return arguments.length?(a=+t,l):a},l.tickPadding=function(t){return arguments.length?(u=+t,l):u},l}var F={value:function(){}};function I(){for(var t,n=0,e=arguments.length,r={};n<e;++n){if(!(t=arguments[n]+"")||t in r)throw new Error("illegal type: "+t);r[t]=[]}return new H(r)}function H(t){this._=t}function j(t,n){for(var e,r=0,i=t.length;r<i;++r)if((e=t[r]).name===n)return e.value}function X(t,n,e){for(var r=0,i=t.length;r<i;++r)if(t[r].name===n){t[r]=F,t=t.slice(0,r).concat(t.slice(r+1));break}return null!=e&&t.push({name:n,value:e}),t}H.prototype=I.prototype={constructor:H,on:function(t,n){var e,r,i=this._,o=(r=i,(t+"").trim().split(/^|\s+/).map(function(t){var n="",e=t.indexOf(".");if(e>=0&&(n=t.slice(e+1),t=t.slice(0,e)),t&&!r.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:n}})),a=-1,u=o.length;if(!(arguments.length<2)){if(null!=n&&"function"!=typeof n)throw new Error("invalid callback: "+n);for(;++a<u;)if(e=(t=o[a]).type)i[e]=X(i[e],t.name,n);else if(null==n)for(e in i)i[e]=X(i[e],t.name,null);return this}for(;++a<u;)if((e=(t=o[a]).type)&&(e=j(i[e],t.name)))return e},copy:function(){var t={},n=this._;for(var e in n)t[e]=n[e].slice();return new H(t)},call:function(t,n){if((e=arguments.length-2)>0)for(var e,r,i=new Array(e),o=0;o<e;++o)i[o]=arguments[o+2];if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(o=0,e=(r=this._[t]).length;o<e;++o)r[o].value.apply(n,i)},apply:function(t,n,e){if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(var r=this._[t],i=0,o=r.length;i<o;++i)r[i].value.apply(n,e)}};var G="http://www.w3.org/1999/xhtml",V={svg:"http://www.w3.org/2000/svg",xhtml:G,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function $(t){var n=t+="",e=n.indexOf(":");return e>=0&&"xmlns"!==(n=t.slice(0,e))&&(t=t.slice(e+1)),V.hasOwnProperty(n)?{space:V[n],local:t}:t}function W(t){var n=$(t);return(n.local?function(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}:function(t){return function(){var n=this.ownerDocument,e=this.namespaceURI;return e===G&&n.documentElement.namespaceURI===G?n.createElement(t):n.createElementNS(e,t)}})(n)}function Z(){}function Q(t){return null==t?Z:function(){return this.querySelector(t)}}function J(){return[]}function K(t){return null==t?J:function(){return this.querySelectorAll(t)}}var tt=function(t){return function(){return this.matches(t)}};if("undefined"!=typeof document){var nt=document.documentElement;if(!nt.matches){var et=nt.webkitMatchesSelector||nt.msMatchesSelector||nt.mozMatchesSelector||nt.oMatchesSelector;tt=function(t){return function(){return et.call(this,t)}}}}var rt=tt;function it(t){return new Array(t.length)}function ot(t,n){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=n}ot.prototype={constructor:ot,appendChild:function(t){return this._parent.insertBefore(t,this._next)},insertBefore:function(t,n){return this._parent.insertBefore(t,n)},querySelector:function(t){return this._parent.querySelector(t)},querySelectorAll:function(t){return this._parent.querySelectorAll(t)}};var at="$";function ut(t,n,e,r,i,o){for(var a,u=0,f=n.length,c=o.length;u<c;++u)(a=n[u])?(a.__data__=o[u],r[u]=a):e[u]=new ot(t,o[u]);for(;u<f;++u)(a=n[u])&&(i[u]=a)}function ft(t,n,e,r,i,o,a){var u,f,c,s={},l=n.length,h=o.length,d=new Array(l);for(u=0;u<l;++u)(f=n[u])&&(d[u]=c=at+a.call(f,f.__data__,u,n),c in s?i[u]=f:s[c]=f);for(u=0;u<h;++u)(f=s[c=at+a.call(t,o[u],u,o)])?(r[u]=f,f.__data__=o[u],s[c]=null):e[u]=new ot(t,o[u]);for(u=0;u<l;++u)(f=n[u])&&s[d[u]]===f&&(i[u]=f)}function ct(t,n){return t<n?-1:t>n?1:t>=n?0:NaN}function st(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function lt(t,n){return t.style.getPropertyValue(n)||st(t).getComputedStyle(t,null).getPropertyValue(n)}function ht(t){return t.trim().split(/^|\s+/)}function dt(t){return t.classList||new pt(t)}function pt(t){this._node=t,this._names=ht(t.getAttribute("class")||"")}function vt(t,n){for(var e=dt(t),r=-1,i=n.length;++r<i;)e.add(n[r])}function gt(t,n){for(var e=dt(t),r=-1,i=n.length;++r<i;)e.remove(n[r])}function yt(){this.textContent=""}function _t(){this.innerHTML=""}function bt(){this.nextSibling&&this.parentNode.appendChild(this)}function mt(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function xt(){return null}function wt(){var t=this.parentNode;t&&t.removeChild(this)}function Mt(){return this.parentNode.insertBefore(this.cloneNode(!1),this.nextSibling)}function At(){return this.parentNode.insertBefore(this.cloneNode(!0),this.nextSibling)}pt.prototype={add:function(t){this._names.indexOf(t)<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var n=this._names.indexOf(t);n>=0&&(this._names.splice(n,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var Tt={};(t.event=null,"undefined"!=typeof document)&&("onmouseenter"in document.documentElement||(Tt={mouseenter:"mouseover",mouseleave:"mouseout"}));function Nt(t,n,e){return t=St(t,n,e),function(n){var e=n.relatedTarget;e&&(e===this||8&e.compareDocumentPosition(this))||t.call(this,n)}}function St(n,e,r){return function(i){var o=t.event;t.event=i;try{n.call(this,this.__data__,e,r)}finally{t.event=o}}}function Et(t){return function(){var n=this.__on;if(n){for(var e,r=0,i=-1,o=n.length;r<o;++r)e=n[r],t.type&&e.type!==t.type||e.name!==t.name?n[++i]=e:this.removeEventListener(e.type,e.listener,e.capture);++i?n.length=i:delete this.__on}}}function kt(t,n,e){var r=Tt.hasOwnProperty(t.type)?Nt:St;return function(i,o,a){var u,f=this.__on,c=r(n,o,a);if(f)for(var s=0,l=f.length;s<l;++s)if((u=f[s]).type===t.type&&u.name===t.name)return this.removeEventListener(u.type,u.listener,u.capture),this.addEventListener(u.type,u.listener=c,u.capture=e),void(u.value=n);this.addEventListener(t.type,c,e),u={type:t.type,name:t.name,value:n,listener:c,capture:e},f?f.push(u):this.__on=[u]}}function Ct(n,e,r,i){var o=t.event;n.sourceEvent=t.event,t.event=n;try{return e.apply(r,i)}finally{t.event=o}}function Pt(t,n,e){var r=st(t),i=r.CustomEvent;"function"==typeof i?i=new i(n,e):(i=r.document.createEvent("Event"),e?(i.initEvent(n,e.bubbles,e.cancelable),i.detail=e.detail):i.initEvent(n,!1,!1)),t.dispatchEvent(i)}var zt=[null];function Rt(t,n){this._groups=t,this._parents=n}function Lt(){return new Rt([[document.documentElement]],zt)}function Dt(t){return"string"==typeof t?new Rt([[document.querySelector(t)]],[document.documentElement]):new Rt([[t]],zt)}Rt.prototype=Lt.prototype={constructor:Rt,select:function(t){"function"!=typeof t&&(t=Q(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i<e;++i)for(var o,a,u=n[i],f=u.length,c=r[i]=new Array(f),s=0;s<f;++s)(o=u[s])&&(a=t.call(o,o.__data__,s,u))&&("__data__"in o&&(a.__data__=o.__data__),c[s]=a);return new Rt(r,this._parents)},selectAll:function(t){"function"!=typeof t&&(t=K(t));for(var n=this._groups,e=n.length,r=[],i=[],o=0;o<e;++o)for(var a,u=n[o],f=u.length,c=0;c<f;++c)(a=u[c])&&(r.push(t.call(a,a.__data__,c,u)),i.push(a));return new Rt(r,i)},filter:function(t){"function"!=typeof t&&(t=rt(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i<e;++i)for(var o,a=n[i],u=a.length,f=r[i]=[],c=0;c<u;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&f.push(o);return new Rt(r,this._parents)},data:function(t,n){if(!t)return p=new Array(this.size()),s=-1,this.each(function(t){p[++s]=t}),p;var e,r=n?ft:ut,i=this._parents,o=this._groups;"function"!=typeof t&&(e=t,t=function(){return e});for(var a=o.length,u=new Array(a),f=new Array(a),c=new Array(a),s=0;s<a;++s){var l=i[s],h=o[s],d=h.length,p=t.call(l,l&&l.__data__,s,i),v=p.length,g=f[s]=new Array(v),y=u[s]=new Array(v);r(l,h,g,y,c[s]=new Array(d),p,n);for(var _,b,m=0,x=0;m<v;++m)if(_=g[m]){for(m>=x&&(x=m+1);!(b=y[x])&&++x<v;);_._next=b||null}}return(u=new Rt(u,i))._enter=f,u._exit=c,u},enter:function(){return new Rt(this._enter||this._groups.map(it),this._parents)},exit:function(){return new Rt(this._exit||this._groups.map(it),this._parents)},merge:function(t){for(var n=this._groups,e=t._groups,r=n.length,i=e.length,o=Math.min(r,i),a=new Array(r),u=0;u<o;++u)for(var f,c=n[u],s=e[u],l=c.length,h=a[u]=new Array(l),d=0;d<l;++d)(f=c[d]||s[d])&&(h[d]=f);for(;u<r;++u)a[u]=n[u];return new Rt(a,this._parents)},order:function(){for(var t=this._groups,n=-1,e=t.length;++n<e;)for(var r,i=t[n],o=i.length-1,a=i[o];--o>=0;)(r=i[o])&&(a&&a!==r.nextSibling&&a.parentNode.insertBefore(r,a),a=r);return this},sort:function(t){function n(n,e){return n&&e?t(n.__data__,e.__data__):!n-!e}t||(t=ct);for(var e=this._groups,r=e.length,i=new Array(r),o=0;o<r;++o){for(var a,u=e[o],f=u.length,c=i[o]=new Array(f),s=0;s<f;++s)(a=u[s])&&(c[s]=a);c.sort(n)}return new Rt(i,this._parents).order()},call:function(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this},nodes:function(){var t=new Array(this.size()),n=-1;return this.each(function(){t[++n]=this}),t},node:function(){for(var t=this._groups,n=0,e=t.length;n<e;++n)for(var r=t[n],i=0,o=r.length;i<o;++i){var a=r[i];if(a)return a}return null},size:function(){var t=0;return this.each(function(){++t}),t},empty:function(){return!this.node()},each:function(t){for(var n=this._groups,e=0,r=n.length;e<r;++e)for(var i,o=n[e],a=0,u=o.length;a<u;++a)(i=o[a])&&t.call(i,i.__data__,a,o);return this},attr:function(t,n){var e=$(t);if(arguments.length<2){var r=this.node();return e.local?r.getAttributeNS(e.space,e.local):r.getAttribute(e)}return this.each((null==n?e.local?function(t){return function(){this.removeAttributeNS(t.space,t.local)}}:function(t){return function(){this.removeAttribute(t)}}:"function"==typeof n?e.local?function(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,e)}}:function(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttribute(t):this.setAttribute(t,e)}}:e.local?function(t,n){return function(){this.setAttributeNS(t.space,t.local,n)}}:function(t,n){return function(){this.setAttribute(t,n)}})(e,n))},style:function(t,n,e){return arguments.length>1?this.each((null==n?function(t){return function(){this.style.removeProperty(t)}}:"function"==typeof n?function(t,n,e){return function(){var r=n.apply(this,arguments);null==r?this.style.removeProperty(t):this.style.setProperty(t,r,e)}}:function(t,n,e){return function(){this.style.setProperty(t,n,e)}})(t,n,null==e?"":e)):lt(this.node(),t)},property:function(t,n){return arguments.length>1?this.each((null==n?function(t){return function(){delete this[t]}}:"function"==typeof n?function(t,n){return function(){var e=n.apply(this,arguments);null==e?delete this[t]:this[t]=e}}:function(t,n){return function(){this[t]=n}})(t,n)):this.node()[t]},classed:function(t,n){var e=ht(t+"");if(arguments.length<2){for(var r=dt(this.node()),i=-1,o=e.length;++i<o;)if(!r.contains(e[i]))return!1;return!0}return this.each(("function"==typeof n?function(t,n){return function(){(n.apply(this,arguments)?vt:gt)(this,t)}}:n?function(t){return function(){vt(this,t)}}:function(t){return function(){gt(this,t)}})(e,n))},text:function(t){return arguments.length?this.each(null==t?yt:("function"==typeof t?function(t){return function(){var n=t.apply(this,arguments);this.textContent=null==n?"":n}}:function(t){return function(){this.textContent=t}})(t)):this.node().textContent},html:function(t){return arguments.length?this.each(null==t?_t:("function"==typeof t?function(t){return function(){var n=t.apply(this,arguments);this.innerHTML=null==n?"":n}}:function(t){return function(){this.innerHTML=t}})(t)):this.node().innerHTML},raise:function(){return this.each(bt)},lower:function(){return this.each(mt)},append:function(t){var n="function"==typeof t?t:W(t);return this.select(function(){return this.appendChild(n.apply(this,arguments))})},insert:function(t,n){var e="function"==typeof t?t:W(t),r=null==n?xt:"function"==typeof n?n:Q(n);return this.select(function(){return this.insertBefore(e.apply(this,arguments),r.apply(this,arguments)||null)})},remove:function(){return this.each(wt)},clone:function(t){return this.select(t?At:Mt)},datum:function(t){return arguments.length?this.property("__data__",t):this.node().__data__},on:function(t,n,e){var r,i,o=function(t){return t.trim().split(/^|\s+/).map(function(t){var n="",e=t.indexOf(".");return e>=0&&(n=t.slice(e+1),t=t.slice(0,e)),{type:t,name:n}})}(t+""),a=o.length;if(!(arguments.length<2)){for(u=n?kt:Et,null==e&&(e=!1),r=0;r<a;++r)this.each(u(o[r],n,e));return this}var u=this.node().__on;if(u)for(var f,c=0,s=u.length;c<s;++c)for(r=0,f=u[c];r<a;++r)if((i=o[r]).type===f.type&&i.name===f.name)return f.value},dispatch:function(t,n){return this.each(("function"==typeof n?function(t,n){return function(){return Pt(this,t,n.apply(this,arguments))}}:function(t,n){return function(){return Pt(this,t,n)}})(t,n))}};var Ut=0;function qt(){return new Ot}function Ot(){this._="@"+(++Ut).toString(36)}function Yt(){for(var n,e=t.event;n=e.sourceEvent;)e=n;return e}function Bt(t,n){var e=t.ownerSVGElement||t;if(e.createSVGPoint){var r=e.createSVGPoint();return r.x=n.clientX,r.y=n.clientY,[(r=r.matrixTransform(t.getScreenCTM().inverse())).x,r.y]}var i=t.getBoundingClientRect();return[n.clientX-i.left-t.clientLeft,n.clientY-i.top-t.clientTop]}function Ft(t){var n=Yt();return n.changedTouches&&(n=n.changedTouches[0]),Bt(t,n)}function It(t,n,e){arguments.length<3&&(e=n,n=Yt().changedTouches);for(var r,i=0,o=n?n.length:0;i<o;++i)if((r=n[i]).identifier===e)return Bt(t,r);return null}function Ht(){t.event.stopImmediatePropagation()}function jt(){t.event.preventDefault(),t.event.stopImmediatePropagation()}function Xt(t){var n=t.document.documentElement,e=Dt(t).on("dragstart.drag",jt,!0);"onselectstart"in n?e.on("selectstart.drag",jt,!0):(n.__noselect=n.style.MozUserSelect,n.style.MozUserSelect="none")}function Gt(t,n){var e=t.document.documentElement,r=Dt(t).on("dragstart.drag",null);n&&(r.on("click.drag",jt,!0),setTimeout(function(){r.on("click.drag",null)},0)),"onselectstart"in e?r.on("selectstart.drag",null):(e.style.MozUserSelect=e.__noselect,delete e.__noselect)}function Vt(t){return function(){return t}}function $t(t,n,e,r,i,o,a,u,f,c){this.target=t,this.type=n,this.subject=e,this.identifier=r,this.active=i,this.x=o,this.y=a,this.dx=u,this.dy=f,this._=c}function Wt(){return!t.event.button}function Zt(){return this.parentNode}function Qt(n){return null==n?{x:t.event.x,y:t.event.y}:n}function Jt(){return"ontouchstart"in this}function Kt(t,n,e){t.prototype=n.prototype=e,e.constructor=t}function tn(t,n){var e=Object.create(t.prototype);for(var r in n)e[r]=n[r];return e}function nn(){}Ot.prototype=qt.prototype={constructor:Ot,get:function(t){for(var n=this._;!(n in t);)if(!(t=t.parentNode))return;return t[n]},set:function(t,n){return t[this._]=n},remove:function(t){return this._ in t&&delete t[this._]},toString:function(){return this._}},$t.prototype.on=function(){var t=this._.on.apply(this._,arguments);return t===this._?this:t};var en="\\s*([+-]?\\d+)\\s*",rn="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",on="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",an=/^#([0-9a-f]{3})$/,un=/^#([0-9a-f]{6})$/,fn=new RegExp("^rgb\\("+[en,en,en]+"\\)$"),cn=new RegExp("^rgb\\("+[on,on,on]+"\\)$"),sn=new RegExp("^rgba\\("+[en,en,en,rn]+"\\)$"),ln=new RegExp("^rgba\\("+[on,on,on,rn]+"\\)$"),hn=new RegExp("^hsl\\("+[rn,on,on]+"\\)$"),dn=new RegExp("^hsla\\("+[rn,on,on,rn]+"\\)$"),pn={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 vn(t){var n;return t=(t+"").trim().toLowerCase(),(n=an.exec(t))?new mn((n=parseInt(n[1],16))>>8&15|n>>4&240,n>>4&15|240&n,(15&n)<<4|15&n,1):(n=un.exec(t))?gn(parseInt(n[1],16)):(n=fn.exec(t))?new mn(n[1],n[2],n[3],1):(n=cn.exec(t))?new mn(255*n[1]/100,255*n[2]/100,255*n[3]/100,1):(n=sn.exec(t))?yn(n[1],n[2],n[3],n[4]):(n=ln.exec(t))?yn(255*n[1]/100,255*n[2]/100,255*n[3]/100,n[4]):(n=hn.exec(t))?wn(n[1],n[2]/100,n[3]/100,1):(n=dn.exec(t))?wn(n[1],n[2]/100,n[3]/100,n[4]):pn.hasOwnProperty(t)?gn(pn[t]):"transparent"===t?new mn(NaN,NaN,NaN,0):null}function gn(t){return new mn(t>>16&255,t>>8&255,255&t,1)}function yn(t,n,e,r){return r<=0&&(t=n=e=NaN),new mn(t,n,e,r)}function _n(t){return t instanceof nn||(t=vn(t)),t?new mn((t=t.rgb()).r,t.g,t.b,t.opacity):new mn}function bn(t,n,e,r){return 1===arguments.length?_n(t):new mn(t,n,e,null==r?1:r)}function mn(t,n,e,r){this.r=+t,this.g=+n,this.b=+e,this.opacity=+r}function xn(t){return((t=Math.max(0,Math.min(255,Math.round(t)||0)))<16?"0":"")+t.toString(16)}function wn(t,n,e,r){return r<=0?t=n=e=NaN:e<=0||e>=1?t=n=NaN:n<=0&&(t=NaN),new An(t,n,e,r)}function Mn(t,n,e,r){return 1===arguments.length?function(t){if(t instanceof An)return new An(t.h,t.s,t.l,t.opacity);if(t instanceof nn||(t=vn(t)),!t)return new An;if(t instanceof An)return t;var n=(t=t.rgb()).r/255,e=t.g/255,r=t.b/255,i=Math.min(n,e,r),o=Math.max(n,e,r),a=NaN,u=o-i,f=(o+i)/2;return u?(a=n===o?(e-r)/u+6*(e<r):e===o?(r-n)/u+2:(n-e)/u+4,u/=f<.5?o+i:2-o-i,a*=60):u=f>0&&f<1?0:a,new An(a,u,f,t.opacity)}(t):new An(t,n,e,null==r?1:r)}function An(t,n,e,r){this.h=+t,this.s=+n,this.l=+e,this.opacity=+r}function Tn(t,n,e){return 255*(t<60?n+(e-n)*t/60:t<180?e:t<240?n+(e-n)*(240-t)/60:n)}Kt(nn,vn,{displayable:function(){return this.rgb().displayable()},hex:function(){return this.rgb().hex()},toString:function(){return this.rgb()+""}}),Kt(mn,bn,tn(nn,{brighter:function(t){return t=null==t?1/.7:Math.pow(1/.7,t),new mn(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?.7:Math.pow(.7,t),new mn(this.r*t,this.g*t,this.b*t,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},hex:function(){return"#"+xn(this.r)+xn(this.g)+xn(this.b)},toString:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"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===t?")":", "+t+")")}})),Kt(An,Mn,tn(nn,{brighter:function(t){return t=null==t?1/.7:Math.pow(1/.7,t),new An(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?.7:Math.pow(.7,t),new An(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),n=isNaN(t)||isNaN(this.s)?0:this.s,e=this.l,r=e+(e<.5?e:1-e)*n,i=2*e-r;return new mn(Tn(t>=240?t-240:t+120,i,r),Tn(t,i,r),Tn(t<120?t+240:t-120,i,r),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 Nn=Math.PI/180,Sn=180/Math.PI,En=.96422,kn=1,Cn=.82521,Pn=4/29,zn=6/29,Rn=3*zn*zn,Ln=zn*zn*zn;function Dn(t){if(t instanceof qn)return new qn(t.l,t.a,t.b,t.opacity);if(t instanceof jn){if(isNaN(t.h))return new qn(t.l,0,0,t.opacity);var n=t.h*Nn;return new qn(t.l,Math.cos(n)*t.c,Math.sin(n)*t.c,t.opacity)}t instanceof mn||(t=_n(t));var e,r,i=Fn(t.r),o=Fn(t.g),a=Fn(t.b),u=On((.2225045*i+.7168786*o+.0606169*a)/kn);return i===o&&o===a?e=r=u:(e=On((.4360747*i+.3850649*o+.1430804*a)/En),r=On((.0139322*i+.0971045*o+.7141733*a)/Cn)),new qn(116*u-16,500*(e-u),200*(u-r),t.opacity)}function Un(t,n,e,r){return 1===arguments.length?Dn(t):new qn(t,n,e,null==r?1:r)}function qn(t,n,e,r){this.l=+t,this.a=+n,this.b=+e,this.opacity=+r}function On(t){return t>Ln?Math.pow(t,1/3):t/Rn+Pn}function Yn(t){return t>zn?t*t*t:Rn*(t-Pn)}function Bn(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function Fn(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function In(t){if(t instanceof jn)return new jn(t.h,t.c,t.l,t.opacity);if(t instanceof qn||(t=Dn(t)),0===t.a&&0===t.b)return new jn(NaN,0,t.l,t.opacity);var n=Math.atan2(t.b,t.a)*Sn;return new jn(n<0?n+360:n,Math.sqrt(t.a*t.a+t.b*t.b),t.l,t.opacity)}function Hn(t,n,e,r){return 1===arguments.length?In(t):new jn(t,n,e,null==r?1:r)}function jn(t,n,e,r){this.h=+t,this.c=+n,this.l=+e,this.opacity=+r}Kt(qn,Un,tn(nn,{brighter:function(t){return new qn(this.l+18*(null==t?1:t),this.a,this.b,this.opacity)},darker:function(t){return new qn(this.l-18*(null==t?1:t),this.a,this.b,this.opacity)},rgb:function(){var t=(this.l+16)/116,n=isNaN(this.a)?t:t+this.a/500,e=isNaN(this.b)?t:t-this.b/200;return new mn(Bn(3.1338561*(n=En*Yn(n))-1.6168667*(t=kn*Yn(t))-.4906146*(e=Cn*Yn(e))),Bn(-.9787684*n+1.9161415*t+.033454*e),Bn(.0719453*n-.2289914*t+1.4052427*e),this.opacity)}})),Kt(jn,Hn,tn(nn,{brighter:function(t){return new jn(this.h,this.c,this.l+18*(null==t?1:t),this.opacity)},darker:function(t){return new jn(this.h,this.c,this.l-18*(null==t?1:t),this.opacity)},rgb:function(){return Dn(this).rgb()}}));var Xn=-.14861,Gn=1.78277,Vn=-.29227,$n=-.90649,Wn=1.97294,Zn=Wn*$n,Qn=Wn*Gn,Jn=Gn*Vn-$n*Xn;function Kn(t,n,e,r){return 1===arguments.length?function(t){if(t instanceof te)return new te(t.h,t.s,t.l,t.opacity);t instanceof mn||(t=_n(t));var n=t.r/255,e=t.g/255,r=t.b/255,i=(Jn*r+Zn*n-Qn*e)/(Jn+Zn-Qn),o=r-i,a=(Wn*(e-i)-Vn*o)/$n,u=Math.sqrt(a*a+o*o)/(Wn*i*(1-i)),f=u?Math.atan2(a,o)*Sn-120:NaN;return new te(f<0?f+360:f,u,i,t.opacity)}(t):new te(t,n,e,null==r?1:r)}function te(t,n,e,r){this.h=+t,this.s=+n,this.l=+e,this.opacity=+r}function ne(t,n,e,r,i){var o=t*t,a=o*t;return((1-3*t+3*o-a)*n+(4-6*o+3*a)*e+(1+3*t+3*o-3*a)*r+a*i)/6}function ee(t){var n=t.length-1;return function(e){var r=e<=0?e=0:e>=1?(e=1,n-1):Math.floor(e*n),i=t[r],o=t[r+1],a=r>0?t[r-1]:2*i-o,u=r<n-1?t[r+2]:2*o-i;return ne((e-r/n)*n,a,i,o,u)}}function re(t){var n=t.length;return function(e){var r=Math.floor(((e%=1)<0?++e:e)*n),i=t[(r+n-1)%n],o=t[r%n],a=t[(r+1)%n],u=t[(r+2)%n];return ne((e-r/n)*n,i,o,a,u)}}function ie(t){return function(){return t}}function oe(t,n){return function(e){return t+e*n}}function ae(t,n){var e=n-t;return e?oe(t,e>180||e<-180?e-360*Math.round(e/360):e):ie(isNaN(t)?n:t)}function ue(t){return 1==(t=+t)?fe:function(n,e){return e-n?function(t,n,e){return t=Math.pow(t,e),n=Math.pow(n,e)-t,e=1/e,function(r){return Math.pow(t+r*n,e)}}(n,e,t):ie(isNaN(n)?e:n)}}function fe(t,n){var e=n-t;return e?oe(t,e):ie(isNaN(t)?n:t)}Kt(te,Kn,tn(nn,{brighter:function(t){return t=null==t?1/.7:Math.pow(1/.7,t),new te(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?.7:Math.pow(.7,t),new te(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=isNaN(this.h)?0:(this.h+120)*Nn,n=+this.l,e=isNaN(this.s)?0:this.s*n*(1-n),r=Math.cos(t),i=Math.sin(t);return new mn(255*(n+e*(Xn*r+Gn*i)),255*(n+e*(Vn*r+$n*i)),255*(n+e*(Wn*r)),this.opacity)}}));var ce=function t(n){var e=ue(n);function r(t,n){var r=e((t=bn(t)).r,(n=bn(n)).r),i=e(t.g,n.g),o=e(t.b,n.b),a=fe(t.opacity,n.opacity);return function(n){return t.r=r(n),t.g=i(n),t.b=o(n),t.opacity=a(n),t+""}}return r.gamma=t,r}(1);function se(t){return function(n){var e,r,i=n.length,o=new Array(i),a=new Array(i),u=new Array(i);for(e=0;e<i;++e)r=bn(n[e]),o[e]=r.r||0,a[e]=r.g||0,u[e]=r.b||0;return o=t(o),a=t(a),u=t(u),r.opacity=1,function(t){return r.r=o(t),r.g=a(t),r.b=u(t),r+""}}}var le=se(ee),he=se(re);function de(t,n){var e,r=n?n.length:0,i=t?Math.min(r,t.length):0,o=new Array(i),a=new Array(r);for(e=0;e<i;++e)o[e]=me(t[e],n[e]);for(;e<r;++e)a[e]=n[e];return function(t){for(e=0;e<i;++e)a[e]=o[e](t);return a}}function pe(t,n){var e=new Date;return n-=t=+t,function(r){return e.setTime(t+n*r),e}}function ve(t,n){return n-=t=+t,function(e){return t+n*e}}function ge(t,n){var e,r={},i={};for(e in null!==t&&"object"==typeof t||(t={}),null!==n&&"object"==typeof n||(n={}),n)e in t?r[e]=me(t[e],n[e]):i[e]=n[e];return function(t){for(e in r)i[e]=r[e](t);return i}}var ye=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,_e=new RegExp(ye.source,"g");function be(t,n){var e,r,i,o=ye.lastIndex=_e.lastIndex=0,a=-1,u=[],f=[];for(t+="",n+="";(e=ye.exec(t))&&(r=_e.exec(n));)(i=r.index)>o&&(i=n.slice(o,i),u[a]?u[a]+=i:u[++a]=i),(e=e[0])===(r=r[0])?u[a]?u[a]+=r:u[++a]=r:(u[++a]=null,f.push({i:a,x:ve(e,r)})),o=_e.lastIndex;return o<n.length&&(i=n.slice(o),u[a]?u[a]+=i:u[++a]=i),u.length<2?f[0]?function(t){return function(n){return t(n)+""}}(f[0].x):function(t){return function(){return t}}(n):(n=f.length,function(t){for(var e,r=0;r<n;++r)u[(e=f[r]).i]=e.x(t);return u.join("")})}function me(t,n){var e,r=typeof n;return null==n||"boolean"===r?ie(n):("number"===r?ve:"string"===r?(e=vn(n))?(n=e,ce):be:n instanceof vn?ce:n instanceof Date?pe:Array.isArray(n)?de:"function"!=typeof n.valueOf&&"function"!=typeof n.toString||isNaN(n)?ge:ve)(t,n)}function xe(t,n){return n-=t=+t,function(e){return Math.round(t+n*e)}}var we,Me,Ae,Te,Ne=180/Math.PI,Se={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function Ee(t,n,e,r,i,o){var a,u,f;return(a=Math.sqrt(t*t+n*n))&&(t/=a,n/=a),(f=t*e+n*r)&&(e-=t*f,r-=n*f),(u=Math.sqrt(e*e+r*r))&&(e/=u,r/=u,f/=u),t*r<n*e&&(t=-t,n=-n,f=-f,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(n,t)*Ne,skewX:Math.atan(f)*Ne,scaleX:a,scaleY:u}}function ke(t,n,e,r){function i(t){return t.length?t.pop()+" ":""}return function(o,a){var u=[],f=[];return o=t(o),a=t(a),function(t,r,i,o,a,u){if(t!==i||r!==o){var f=a.push("translate(",null,n,null,e);u.push({i:f-4,x:ve(t,i)},{i:f-2,x:ve(r,o)})}else(i||o)&&a.push("translate("+i+n+o+e)}(o.translateX,o.translateY,a.translateX,a.translateY,u,f),function(t,n,e,o){t!==n?(t-n>180?n+=360:n-t>180&&(t+=360),o.push({i:e.push(i(e)+"rotate(",null,r)-2,x:ve(t,n)})):n&&e.push(i(e)+"rotate("+n+r)}(o.rotate,a.rotate,u,f),function(t,n,e,o){t!==n?o.push({i:e.push(i(e)+"skewX(",null,r)-2,x:ve(t,n)}):n&&e.push(i(e)+"skewX("+n+r)}(o.skewX,a.skewX,u,f),function(t,n,e,r,o,a){if(t!==e||n!==r){var u=o.push(i(o)+"scale(",null,",",null,")");a.push({i:u-4,x:ve(t,e)},{i:u-2,x:ve(n,r)})}else 1===e&&1===r||o.push(i(o)+"scale("+e+","+r+")")}(o.scaleX,o.scaleY,a.scaleX,a.scaleY,u,f),o=a=null,function(t){for(var n,e=-1,r=f.length;++e<r;)u[(n=f[e]).i]=n.x(t);return u.join("")}}}var Ce=ke(function(t){return"none"===t?Se:(we||(we=document.createElement("DIV"),Me=document.documentElement,Ae=document.defaultView),we.style.transform=t,t=Ae.getComputedStyle(Me.appendChild(we),null).getPropertyValue("transform"),Me.removeChild(we),Ee(+(t=t.slice(7,-1).split(","))[0],+t[1],+t[2],+t[3],+t[4],+t[5]))},"px, ","px)","deg)"),Pe=ke(function(t){return null==t?Se:(Te||(Te=document.createElementNS("http://www.w3.org/2000/svg","g")),Te.setAttribute("transform",t),(t=Te.transform.baseVal.consolidate())?Ee((t=t.matrix).a,t.b,t.c,t.d,t.e,t.f):Se)},", ",")",")"),ze=Math.SQRT2,Re=2,Le=4,De=1e-12;function Ue(t){return((t=Math.exp(t))+1/t)/2}function qe(t,n){var e,r,i=t[0],o=t[1],a=t[2],u=n[0],f=n[1],c=n[2],s=u-i,l=f-o,h=s*s+l*l;if(h<De)r=Math.log(c/a)/ze,e=function(t){return[i+t*s,o+t*l,a*Math.exp(ze*t*r)]};else{var d=Math.sqrt(h),p=(c*c-a*a+Le*h)/(2*a*Re*d),v=(c*c-a*a-Le*h)/(2*c*Re*d),g=Math.log(Math.sqrt(p*p+1)-p),y=Math.log(Math.sqrt(v*v+1)-v);r=(y-g)/ze,e=function(t){var n,e=t*r,u=Ue(g),f=a/(Re*d)*(u*(n=ze*e+g,((n=Math.exp(2*n))-1)/(n+1))-function(t){return((t=Math.exp(t))-1/t)/2}(g));return[i+f*s,o+f*l,a*u/Ue(ze*e+g)]}}return e.duration=1e3*r,e}function Oe(t){return function(n,e){var r=t((n=Mn(n)).h,(e=Mn(e)).h),i=fe(n.s,e.s),o=fe(n.l,e.l),a=fe(n.opacity,e.opacity);return function(t){return n.h=r(t),n.s=i(t),n.l=o(t),n.opacity=a(t),n+""}}}var Ye=Oe(ae),Be=Oe(fe);function Fe(t){return function(n,e){var r=t((n=Hn(n)).h,(e=Hn(e)).h),i=fe(n.c,e.c),o=fe(n.l,e.l),a=fe(n.opacity,e.opacity);return function(t){return n.h=r(t),n.c=i(t),n.l=o(t),n.opacity=a(t),n+""}}}var Ie=Fe(ae),He=Fe(fe);function je(t){return function n(e){function r(n,r){var i=t((n=Kn(n)).h,(r=Kn(r)).h),o=fe(n.s,r.s),a=fe(n.l,r.l),u=fe(n.opacity,r.opacity);return function(t){return n.h=i(t),n.s=o(t),n.l=a(Math.pow(t,e)),n.opacity=u(t),n+""}}return e=+e,r.gamma=n,r}(1)}var Xe=je(ae),Ge=je(fe);var Ve,$e,We=0,Ze=0,Qe=0,Je=1e3,Ke=0,tr=0,nr=0,er="object"==typeof performance&&performance.now?performance:Date,rr="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(t){setTimeout(t,17)};function ir(){return tr||(rr(or),tr=er.now()+nr)}function or(){tr=0}function ar(){this._call=this._time=this._next=null}function ur(t,n,e){var r=new ar;return r.restart(t,n,e),r}function fr(){ir(),++We;for(var t,n=Ve;n;)(t=tr-n._time)>=0&&n._call.call(null,t),n=n._next;--We}function cr(){tr=(Ke=er.now())+nr,We=Ze=0;try{fr()}finally{We=0,function(){var t,n,e=Ve,r=1/0;for(;e;)e._call?(r>e._time&&(r=e._time),t=e,e=e._next):(n=e._next,e._next=null,e=t?t._next=n:Ve=n);$e=t,lr(r)}(),tr=0}}function sr(){var t=er.now(),n=t-Ke;n>Je&&(nr-=n,Ke=t)}function lr(t){We||(Ze&&(Ze=clearTimeout(Ze)),t-tr>24?(t<1/0&&(Ze=setTimeout(cr,t-er.now()-nr)),Qe&&(Qe=clearInterval(Qe))):(Qe||(Ke=er.now(),Qe=setInterval(sr,Je)),We=1,rr(cr)))}function hr(t,n,e){var r=new ar;return n=null==n?0:+n,r.restart(function(e){r.stop(),t(e+n)},n,e),r}ar.prototype=ur.prototype={constructor:ar,restart:function(t,n,e){if("function"!=typeof t)throw new TypeError("callback is not a function");e=(null==e?ir():+e)+(null==n?0:+n),this._next||$e===this||($e?$e._next=this:Ve=this,$e=this),this._call=t,this._time=e,lr()},stop:function(){this._call&&(this._call=null,this._time=1/0,lr())}};var dr=I("start","end","interrupt"),pr=[],vr=0,gr=1,yr=2,_r=3,br=4,mr=5,xr=6;function wr(t,n,e,r,i,o){var a=t.__transition;if(a){if(e in a)return}else t.__transition={};!function(t,n,e){var r,i=t.__transition;function o(f){var c,s,l,h;if(e.state!==gr)return u();for(c in i)if((h=i[c]).name===e.name){if(h.state===_r)return hr(o);h.state===br?(h.state=xr,h.timer.stop(),h.on.call("interrupt",t,t.__data__,h.index,h.group),delete i[c]):+c<n&&(h.state=xr,h.timer.stop(),delete i[c])}if(hr(function(){e.state===_r&&(e.state=br,e.timer.restart(a,e.delay,e.time),a(f))}),e.state=yr,e.on.call("start",t,t.__data__,e.index,e.group),e.state===yr){for(e.state=_r,r=new Array(l=e.tween.length),c=0,s=-1;c<l;++c)(h=e.tween[c].value.call(t,t.__data__,e.index,e.group))&&(r[++s]=h);r.length=s+1}}function a(n){for(var i=n<e.duration?e.ease.call(null,n/e.duration):(e.timer.restart(u),e.state=mr,1),o=-1,a=r.length;++o<a;)r[o].call(null,i);e.state===mr&&(e.on.call("end",t,t.__data__,e.index,e.group),u())}function u(){for(var r in e.state=xr,e.timer.stop(),delete i[n],i)return;delete t.__transition}i[n]=e,e.timer=ur(function(t){e.state=gr,e.timer.restart(o,e.delay,e.time),e.delay<=t&&o(t-e.delay)},0,e.time)}(t,e,{name:n,index:r,group:i,on:dr,tween:pr,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:vr})}function Mr(t,n){var e=Tr(t,n);if(e.state>vr)throw new Error("too late; already scheduled");return e}function Ar(t,n){var e=Tr(t,n);if(e.state>yr)throw new Error("too late; already started");return e}function Tr(t,n){var e=t.__transition;if(!e||!(e=e[n]))throw new Error("transition not found");return e}function Nr(t,n){var e,r,i,o=t.__transition,a=!0;if(o){for(i in n=null==n?null:n+"",o)(e=o[i]).name===n?(r=e.state>yr&&e.state<mr,e.state=xr,e.timer.stop(),r&&e.on.call("interrupt",t,t.__data__,e.index,e.group),delete o[i]):a=!1;a&&delete t.__transition}}function Sr(t,n,e){var r=t._id;return t.each(function(){var t=Ar(this,r);(t.value||(t.value={}))[n]=e.apply(this,arguments)}),function(t){return Tr(t,r).value[n]}}function Er(t,n){var e;return("number"==typeof n?ve:n instanceof vn?ce:(e=vn(n))?(n=e,ce):be)(t,n)}var kr=Lt.prototype.constructor;var Cr=0;function Pr(t,n,e,r){this._groups=t,this._parents=n,this._name=e,this._id=r}function zr(t){return Lt().transition(t)}function Rr(){return++Cr}var Lr=Lt.prototype;function Dr(t){return((t*=2)<=1?t*t:--t*(2-t)+1)/2}function Ur(t){return((t*=2)<=1?t*t*t:(t-=2)*t*t+2)/2}Pr.prototype=zr.prototype={constructor:Pr,select:function(t){var n=this._name,e=this._id;"function"!=typeof t&&(t=Q(t));for(var r=this._groups,i=r.length,o=new Array(i),a=0;a<i;++a)for(var u,f,c=r[a],s=c.length,l=o[a]=new Array(s),h=0;h<s;++h)(u=c[h])&&(f=t.call(u,u.__data__,h,c))&&("__data__"in u&&(f.__data__=u.__data__),l[h]=f,wr(l[h],n,e,h,l,Tr(u,e)));return new Pr(o,this._parents,n,e)},selectAll:function(t){var n=this._name,e=this._id;"function"!=typeof t&&(t=K(t));for(var r=this._groups,i=r.length,o=[],a=[],u=0;u<i;++u)for(var f,c=r[u],s=c.length,l=0;l<s;++l)if(f=c[l]){for(var h,d=t.call(f,f.__data__,l,c),p=Tr(f,e),v=0,g=d.length;v<g;++v)(h=d[v])&&wr(h,n,e,v,d,p);o.push(d),a.push(f)}return new Pr(o,a,n,e)},filter:function(t){"function"!=typeof t&&(t=rt(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i<e;++i)for(var o,a=n[i],u=a.length,f=r[i]=[],c=0;c<u;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&f.push(o);return new Pr(r,this._parents,this._name,this._id)},merge:function(t){if(t._id!==this._id)throw new Error;for(var n=this._groups,e=t._groups,r=n.length,i=e.length,o=Math.min(r,i),a=new Array(r),u=0;u<o;++u)for(var f,c=n[u],s=e[u],l=c.length,h=a[u]=new Array(l),d=0;d<l;++d)(f=c[d]||s[d])&&(h[d]=f);for(;u<r;++u)a[u]=n[u];return new Pr(a,this._parents,this._name,this._id)},selection:function(){return new kr(this._groups,this._parents)},transition:function(){for(var t=this._name,n=this._id,e=Rr(),r=this._groups,i=r.length,o=0;o<i;++o)for(var a,u=r[o],f=u.length,c=0;c<f;++c)if(a=u[c]){var s=Tr(a,n);wr(a,t,e,c,u,{time:s.time+s.delay+s.duration,delay:0,duration:s.duration,ease:s.ease})}return new Pr(r,this._parents,t,e)},call:Lr.call,nodes:Lr.nodes,node:Lr.node,size:Lr.size,empty:Lr.empty,each:Lr.each,on:function(t,n){var e=this._id;return arguments.length<2?Tr(this.node(),e).on.on(t):this.each(function(t,n,e){var r,i,o=function(t){return(t+"").trim().split(/^|\s+/).every(function(t){var n=t.indexOf(".");return n>=0&&(t=t.slice(0,n)),!t||"start"===t})}(n)?Mr:Ar;return function(){var a=o(this,t),u=a.on;u!==r&&(i=(r=u).copy()).on(n,e),a.on=i}}(e,t,n))},attr:function(t,n){var e=$(t),r="transform"===e?Pe:Er;return this.attrTween(t,"function"==typeof n?(e.local?function(t,n,e){var r,i,o;return function(){var a,u=e(this);if(null!=u)return(a=this.getAttributeNS(t.space,t.local))===u?null:a===r&&u===i?o:o=n(r=a,i=u);this.removeAttributeNS(t.space,t.local)}}:function(t,n,e){var r,i,o;return function(){var a,u=e(this);if(null!=u)return(a=this.getAttribute(t))===u?null:a===r&&u===i?o:o=n(r=a,i=u);this.removeAttribute(t)}})(e,r,Sr(this,"attr."+t,n)):null==n?(e.local?function(t){return function(){this.removeAttributeNS(t.space,t.local)}}:function(t){return function(){this.removeAttribute(t)}})(e):(e.local?function(t,n,e){var r,i;return function(){var o=this.getAttributeNS(t.space,t.local);return o===e?null:o===r?i:i=n(r=o,e)}}:function(t,n,e){var r,i;return function(){var o=this.getAttribute(t);return o===e?null:o===r?i:i=n(r=o,e)}})(e,r,n+""))},attrTween:function(t,n){var e="attr."+t;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(null==n)return this.tween(e,null);if("function"!=typeof n)throw new Error;var r=$(t);return this.tween(e,(r.local?function(t,n){function e(){var e=this,r=n.apply(e,arguments);return r&&function(n){e.setAttributeNS(t.space,t.local,r(n))}}return e._value=n,e}:function(t,n){function e(){var e=this,r=n.apply(e,arguments);return r&&function(n){e.setAttribute(t,r(n))}}return e._value=n,e})(r,n))},style:function(t,n,e){var r="transform"==(t+="")?Ce:Er;return null==n?this.styleTween(t,function(t,n){var e,r,i;return function(){var o=lt(this,t),a=(this.style.removeProperty(t),lt(this,t));return o===a?null:o===e&&a===r?i:i=n(e=o,r=a)}}(t,r)).on("end.style."+t,function(t){return function(){this.style.removeProperty(t)}}(t)):this.styleTween(t,"function"==typeof n?function(t,n,e){var r,i,o;return function(){var a=lt(this,t),u=e(this);return null==u&&(this.style.removeProperty(t),u=lt(this,t)),a===u?null:a===r&&u===i?o:o=n(r=a,i=u)}}(t,r,Sr(this,"style."+t,n)):function(t,n,e){var r,i;return function(){var o=lt(this,t);return o===e?null:o===r?i:i=n(r=o,e)}}(t,r,n+""),e)},styleTween:function(t,n,e){var r="style."+(t+="");if(arguments.length<2)return(r=this.tween(r))&&r._value;if(null==n)return this.tween(r,null);if("function"!=typeof n)throw new Error;return this.tween(r,function(t,n,e){function r(){var r=this,i=n.apply(r,arguments);return i&&function(n){r.style.setProperty(t,i(n),e)}}return r._value=n,r}(t,n,null==e?"":e))},text:function(t){return this.tween("text","function"==typeof t?function(t){return function(){var n=t(this);this.textContent=null==n?"":n}}(Sr(this,"text",t)):function(t){return function(){this.textContent=t}}(null==t?"":t+""))},remove:function(){return this.on("end.remove",(t=this._id,function(){var n=this.parentNode;for(var e in this.__transition)if(+e!==t)return;n&&n.removeChild(this)}));var t},tween:function(t,n){var e=this._id;if(t+="",arguments.length<2){for(var r,i=Tr(this.node(),e).tween,o=0,a=i.length;o<a;++o)if((r=i[o]).name===t)return r.value;return null}return this.each((null==n?function(t,n){var e,r;return function(){var i=Ar(this,t),o=i.tween;if(o!==e)for(var a=0,u=(r=e=o).length;a<u;++a)if(r[a].name===n){(r=r.slice()).splice(a,1);break}i.tween=r}}:function(t,n,e){var r,i;if("function"!=typeof e)throw new Error;return function(){var o=Ar(this,t),a=o.tween;if(a!==r){i=(r=a).slice();for(var u={name:n,value:e},f=0,c=i.length;f<c;++f)if(i[f].name===n){i[f]=u;break}f===c&&i.push(u)}o.tween=i}})(e,t,n))},delay:function(t){var n=this._id;return arguments.length?this.each(("function"==typeof t?function(t,n){return function(){Mr(this,t).delay=+n.apply(this,arguments)}}:function(t,n){return n=+n,function(){Mr(this,t).delay=n}})(n,t)):Tr(this.node(),n).delay},duration:function(t){var n=this._id;return arguments.length?this.each(("function"==typeof t?function(t,n){return function(){Ar(this,t).duration=+n.apply(this,arguments)}}:function(t,n){return n=+n,function(){Ar(this,t).duration=n}})(n,t)):Tr(this.node(),n).duration},ease:function(t){var n=this._id;return arguments.length?this.each(function(t,n){if("function"!=typeof n)throw new Error;return function(){Ar(this,t).ease=n}}(n,t)):Tr(this.node(),n).ease}};var qr=function t(n){function e(t){return Math.pow(t,n)}return n=+n,e.exponent=t,e}(3),Or=function t(n){function e(t){return 1-Math.pow(1-t,n)}return n=+n,e.exponent=t,e}(3),Yr=function t(n){function e(t){return((t*=2)<=1?Math.pow(t,n):2-Math.pow(2-t,n))/2}return n=+n,e.exponent=t,e}(3),Br=Math.PI,Fr=Br/2;function Ir(t){return(1-Math.cos(Br*t))/2}function Hr(t){return((t*=2)<=1?Math.pow(2,10*t-10):2-Math.pow(2,10-10*t))/2}function jr(t){return((t*=2)<=1?1-Math.sqrt(1-t*t):Math.sqrt(1-(t-=2)*t)+1)/2}var Xr=4/11,Gr=6/11,Vr=8/11,$r=.75,Wr=9/11,Zr=10/11,Qr=.9375,Jr=21/22,Kr=63/64,ti=1/Xr/Xr;function ni(t){return(t=+t)<Xr?ti*t*t:t<Vr?ti*(t-=Gr)*t+$r:t<Zr?ti*(t-=Wr)*t+Qr:ti*(t-=Jr)*t+Kr}var ei=function t(n){function e(t){return t*t*((n+1)*t-n)}return n=+n,e.overshoot=t,e}(1.70158),ri=function t(n){function e(t){return--t*t*((n+1)*t+n)+1}return n=+n,e.overshoot=t,e}(1.70158),ii=function t(n){function e(t){return((t*=2)<1?t*t*((n+1)*t-n):(t-=2)*t*((n+1)*t+n)+2)/2}return n=+n,e.overshoot=t,e}(1.70158),oi=2*Math.PI,ai=function t(n,e){var r=Math.asin(1/(n=Math.max(1,n)))*(e/=oi);function i(t){return n*Math.pow(2,10*--t)*Math.sin((r-t)/e)}return i.amplitude=function(n){return t(n,e*oi)},i.period=function(e){return t(n,e)},i}(1,.3),ui=function t(n,e){var r=Math.asin(1/(n=Math.max(1,n)))*(e/=oi);function i(t){return 1-n*Math.pow(2,-10*(t=+t))*Math.sin((t+r)/e)}return i.amplitude=function(n){return t(n,e*oi)},i.period=function(e){return t(n,e)},i}(1,.3),fi=function t(n,e){var r=Math.asin(1/(n=Math.max(1,n)))*(e/=oi);function i(t){return((t=2*t-1)<0?n*Math.pow(2,10*t)*Math.sin((r-t)/e):2-n*Math.pow(2,-10*t)*Math.sin((r+t)/e))/2}return i.amplitude=function(n){return t(n,e*oi)},i.period=function(e){return t(n,e)},i}(1,.3),ci={time:null,delay:0,duration:250,ease:Ur};function si(t,n){for(var e;!(e=t.__transition)||!(e=e[n]);)if(!(t=t.parentNode))return ci.time=ir(),ci;return e}Lt.prototype.interrupt=function(t){return this.each(function(){Nr(this,t)})},Lt.prototype.transition=function(t){var n,e;t instanceof Pr?(n=t._id,t=t._name):(n=Rr(),(e=ci).time=ir(),t=null==t?null:t+"");for(var r=this._groups,i=r.length,o=0;o<i;++o)for(var a,u=r[o],f=u.length,c=0;c<f;++c)(a=u[c])&&wr(a,t,n,c,u,e||si(a,n));return new Pr(r,this._parents,t,n)};var li=[null];function hi(t){return function(){return t}}function di(t,n,e){this.target=t,this.type=n,this.selection=e}function pi(){t.event.stopImmediatePropagation()}function vi(){t.event.preventDefault(),t.event.stopImmediatePropagation()}var gi={name:"drag"},yi={name:"space"},_i={name:"handle"},bi={name:"center"},mi={name:"x",handles:["e","w"].map(Ei),input:function(t,n){return t&&[[t[0],n[0][1]],[t[1],n[1][1]]]},output:function(t){return t&&[t[0][0],t[1][0]]}},xi={name:"y",handles:["n","s"].map(Ei),input:function(t,n){return t&&[[n[0][0],t[0]],[n[1][0],t[1]]]},output:function(t){return t&&[t[0][1],t[1][1]]}},wi={name:"xy",handles:["n","e","s","w","nw","ne","se","sw"].map(Ei),input:function(t){return t},output:function(t){return t}},Mi={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"},Ai={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},Ti={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},Ni={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},Si={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function Ei(t){return{type:t}}function ki(){return!t.event.button}function Ci(){var t=this.ownerSVGElement||this;return[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]}function Pi(t){for(;!t.__brush;)if(!(t=t.parentNode))return;return t.__brush}function zi(t){return t[0][0]===t[1][0]||t[0][1]===t[1][1]}function Ri(n){var e,r=Ci,i=ki,o=I(u,"start","brush","end"),a=6;function u(t){var e=t.property("__brush",h).selectAll(".overlay").data([Ei("overlay")]);e.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",Mi.overlay).merge(e).each(function(){var t=Pi(this).extent;Dt(this).attr("x",t[0][0]).attr("y",t[0][1]).attr("width",t[1][0]-t[0][0]).attr("height",t[1][1]-t[0][1])}),t.selectAll(".selection").data([Ei("selection")]).enter().append("rect").attr("class","selection").attr("cursor",Mi.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var r=t.selectAll(".handle").data(n.handles,function(t){return t.type});r.exit().remove(),r.enter().append("rect").attr("class",function(t){return"handle handle--"+t.type}).attr("cursor",function(t){return Mi[t.type]}),t.each(f).attr("fill","none").attr("pointer-events","all").style("-webkit-tap-highlight-color","rgba(0,0,0,0)").on("mousedown.brush touchstart.brush",l)}function f(){var t=Dt(this),n=Pi(this).selection;n?(t.selectAll(".selection").style("display",null).attr("x",n[0][0]).attr("y",n[0][1]).attr("width",n[1][0]-n[0][0]).attr("height",n[1][1]-n[0][1]),t.selectAll(".handle").style("display",null).attr("x",function(t){return"e"===t.type[t.type.length-1]?n[1][0]-a/2:n[0][0]-a/2}).attr("y",function(t){return"s"===t.type[0]?n[1][1]-a/2:n[0][1]-a/2}).attr("width",function(t){return"n"===t.type||"s"===t.type?n[1][0]-n[0][0]+a:a}).attr("height",function(t){return"e"===t.type||"w"===t.type?n[1][1]-n[0][1]+a:a})):t.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function c(t,n){return t.__brush.emitter||new s(t,n)}function s(t,n){this.that=t,this.args=n,this.state=t.__brush,this.active=0}function l(){if(t.event.touches){if(t.event.changedTouches.length<t.event.touches.length)return vi()}else if(e)return;if(i.apply(this,arguments)){var r,o,a,u,s,l,h,d,p,v,g,y,_,b=this,m=t.event.target.__data__.type,x="selection"===(t.event.metaKey?m="overlay":m)?gi:t.event.altKey?bi:_i,w=n===xi?null:Ni[m],M=n===mi?null:Si[m],A=Pi(b),T=A.extent,N=A.selection,S=T[0][0],E=T[0][1],k=T[1][0],C=T[1][1],P=w&&M&&t.event.shiftKey,z=Ft(b),R=z,L=c(b,arguments).beforestart();"overlay"===m?A.selection=N=[[r=n===xi?S:z[0],a=n===mi?E:z[1]],[s=n===xi?k:r,h=n===mi?C:a]]:(r=N[0][0],a=N[0][1],s=N[1][0],h=N[1][1]),o=r,u=a,l=s,d=h;var D=Dt(b).attr("pointer-events","none"),U=D.selectAll(".overlay").attr("cursor",Mi[m]);if(t.event.touches)D.on("touchmove.brush",O,!0).on("touchend.brush touchcancel.brush",B,!0);else{var q=Dt(t.event.view).on("keydown.brush",function(){switch(t.event.keyCode){case 16:P=w&&M;break;case 18:x===_i&&(w&&(s=l-p*w,r=o+p*w),M&&(h=d-v*M,a=u+v*M),x=bi,Y());break;case 32:x!==_i&&x!==bi||(w<0?s=l-p:w>0&&(r=o-p),M<0?h=d-v:M>0&&(a=u-v),x=yi,U.attr("cursor",Mi.selection),Y());break;default:return}vi()},!0).on("keyup.brush",function(){switch(t.event.keyCode){case 16:P&&(y=_=P=!1,Y());break;case 18:x===bi&&(w<0?s=l:w>0&&(r=o),M<0?h=d:M>0&&(a=u),x=_i,Y());break;case 32:x===yi&&(t.event.altKey?(w&&(s=l-p*w,r=o+p*w),M&&(h=d-v*M,a=u+v*M),x=bi):(w<0?s=l:w>0&&(r=o),M<0?h=d:M>0&&(a=u),x=_i),U.attr("cursor",Mi[m]),Y());break;default:return}vi()},!0).on("mousemove.brush",O,!0).on("mouseup.brush",B,!0);Xt(t.event.view)}pi(),Nr(b),f.call(b),L.start()}function O(){var t=Ft(b);!P||y||_||(Math.abs(t[0]-R[0])>Math.abs(t[1]-R[1])?_=!0:y=!0),R=t,g=!0,vi(),Y()}function Y(){var t;switch(p=R[0]-z[0],v=R[1]-z[1],x){case yi:case gi:w&&(p=Math.max(S-r,Math.min(k-s,p)),o=r+p,l=s+p),M&&(v=Math.max(E-a,Math.min(C-h,v)),u=a+v,d=h+v);break;case _i:w<0?(p=Math.max(S-r,Math.min(k-r,p)),o=r+p,l=s):w>0&&(p=Math.max(S-s,Math.min(k-s,p)),o=r,l=s+p),M<0?(v=Math.max(E-a,Math.min(C-a,v)),u=a+v,d=h):M>0&&(v=Math.max(E-h,Math.min(C-h,v)),u=a,d=h+v);break;case bi:w&&(o=Math.max(S,Math.min(k,r-p*w)),l=Math.max(S,Math.min(k,s+p*w))),M&&(u=Math.max(E,Math.min(C,a-v*M)),d=Math.max(E,Math.min(C,h+v*M)))}l<o&&(w*=-1,t=r,r=s,s=t,t=o,o=l,l=t,m in Ai&&U.attr("cursor",Mi[m=Ai[m]])),d<u&&(M*=-1,t=a,a=h,h=t,t=u,u=d,d=t,m in Ti&&U.attr("cursor",Mi[m=Ti[m]])),A.selection&&(N=A.selection),y&&(o=N[0][0],l=N[1][0]),_&&(u=N[0][1],d=N[1][1]),N[0][0]===o&&N[0][1]===u&&N[1][0]===l&&N[1][1]===d||(A.selection=[[o,u],[l,d]],f.call(b),L.brush())}function B(){if(pi(),t.event.touches){if(t.event.touches.length)return;e&&clearTimeout(e),e=setTimeout(function(){e=null},500),D.on("touchmove.brush touchend.brush touchcancel.brush",null)}else Gt(t.event.view,g),q.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);D.attr("pointer-events","all"),U.attr("cursor",Mi.overlay),A.selection&&(N=A.selection),zi(N)&&(A.selection=null,f.call(b)),L.end()}}function h(){var t=this.__brush||{selection:null};return t.extent=r.apply(this,arguments),t.dim=n,t}return u.move=function(t,e){t.selection?t.on("start.brush",function(){c(this,arguments).beforestart().start()}).on("interrupt.brush end.brush",function(){c(this,arguments).end()}).tween("brush",function(){var t=this,r=t.__brush,i=c(t,arguments),o=r.selection,a=n.input("function"==typeof e?e.apply(this,arguments):e,r.extent),u=me(o,a);function s(n){r.selection=1===n&&zi(a)?null:u(n),f.call(t),i.brush()}return o&&a?s:s(1)}):t.each(function(){var t=arguments,r=this.__brush,i=n.input("function"==typeof e?e.apply(this,t):e,r.extent),o=c(this,t).beforestart();Nr(this),r.selection=null==i||zi(i)?null:i,f.call(this),o.start().brush().end()})},s.prototype={beforestart:function(){return 1==++this.active&&(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 0==--this.active&&(delete this.state.emitter,this.emit("end")),this},emit:function(t){Ct(new di(u,t,n.output(this.state.selection)),o.apply,o,[t,this.that,this.args])}},u.extent=function(t){return arguments.length?(r="function"==typeof t?t:hi([[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]]),u):r},u.filter=function(t){return arguments.length?(i="function"==typeof t?t:hi(!!t),u):i},u.handleSize=function(t){return arguments.length?(a=+t,u):a},u.on=function(){var t=o.on.apply(o,arguments);return t===o?u:t},u}var Li=Math.cos,Di=Math.sin,Ui=Math.PI,qi=Ui/2,Oi=2*Ui,Yi=Math.max;var Bi=Array.prototype.slice;function Fi(t){return function(){return t}}var Ii=Math.PI,Hi=2*Ii,ji=Hi-1e-6;function Xi(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function Gi(){return new Xi}function Vi(t){return t.source}function $i(t){return t.target}function Wi(t){return t.radius}function Zi(t){return t.startAngle}function Qi(t){return t.endAngle}Xi.prototype=Gi.prototype={constructor:Xi,moveTo:function(t,n){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+n)},closePath:function(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(t,n){this._+="L"+(this._x1=+t)+","+(this._y1=+n)},quadraticCurveTo:function(t,n,e,r){this._+="Q"+ +t+","+ +n+","+(this._x1=+e)+","+(this._y1=+r)},bezierCurveTo:function(t,n,e,r,i,o){this._+="C"+ +t+","+ +n+","+ +e+","+ +r+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(t,n,e,r,i){t=+t,n=+n,e=+e,r=+r,i=+i;var o=this._x1,a=this._y1,u=e-t,f=r-n,c=o-t,s=a-n,l=c*c+s*s;if(i<0)throw new Error("negative radius: "+i);if(null===this._x1)this._+="M"+(this._x1=t)+","+(this._y1=n);else if(l>1e-6)if(Math.abs(s*u-f*c)>1e-6&&i){var h=e-o,d=r-a,p=u*u+f*f,v=h*h+d*d,g=Math.sqrt(p),y=Math.sqrt(l),_=i*Math.tan((Ii-Math.acos((p+l-v)/(2*g*y)))/2),b=_/y,m=_/g;Math.abs(b-1)>1e-6&&(this._+="L"+(t+b*c)+","+(n+b*s)),this._+="A"+i+","+i+",0,0,"+ +(s*h>c*d)+","+(this._x1=t+m*u)+","+(this._y1=n+m*f)}else this._+="L"+(this._x1=t)+","+(this._y1=n);else;},arc:function(t,n,e,r,i,o){t=+t,n=+n;var a=(e=+e)*Math.cos(r),u=e*Math.sin(r),f=t+a,c=n+u,s=1^o,l=o?r-i:i-r;if(e<0)throw new Error("negative radius: "+e);null===this._x1?this._+="M"+f+","+c:(Math.abs(this._x1-f)>1e-6||Math.abs(this._y1-c)>1e-6)&&(this._+="L"+f+","+c),e&&(l<0&&(l=l%Hi+Hi),l>ji?this._+="A"+e+","+e+",0,1,"+s+","+(t-a)+","+(n-u)+"A"+e+","+e+",0,1,"+s+","+(this._x1=f)+","+(this._y1=c):l>1e-6&&(this._+="A"+e+","+e+",0,"+ +(l>=Ii)+","+s+","+(this._x1=t+e*Math.cos(i))+","+(this._y1=n+e*Math.sin(i))))},rect:function(t,n,e,r){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+n)+"h"+ +e+"v"+ +r+"h"+-e+"Z"},toString:function(){return this._}};function Ji(){}function Ki(t,n){var e=new Ji;if(t instanceof Ji)t.each(function(t,n){e.set(n,t)});else if(Array.isArray(t)){var r,i=-1,o=t.length;if(null==n)for(;++i<o;)e.set(i,t[i]);else for(;++i<o;)e.set(n(r=t[i],i,t),r)}else if(t)for(var a in t)e.set(a,t[a]);return e}function to(){return{}}function no(t,n,e){t[n]=e}function eo(){return Ki()}function ro(t,n,e){t.set(n,e)}function io(){}Ji.prototype=Ki.prototype={constructor:Ji,has:function(t){return"$"+t in this},get:function(t){return this["$"+t]},set:function(t,n){return this["$"+t]=n,this},remove:function(t){var n="$"+t;return n in this&&delete this[n]},clear:function(){for(var t in this)"$"===t[0]&&delete this[t]},keys:function(){var t=[];for(var n in this)"$"===n[0]&&t.push(n.slice(1));return t},values:function(){var t=[];for(var n in this)"$"===n[0]&&t.push(this[n]);return t},entries:function(){var t=[];for(var n in this)"$"===n[0]&&t.push({key:n.slice(1),value:this[n]});return t},size:function(){var t=0;for(var n in this)"$"===n[0]&&++t;return t},empty:function(){for(var t in this)if("$"===t[0])return!1;return!0},each:function(t){for(var n in this)"$"===n[0]&&t(this[n],n.slice(1),this)}};var oo=Ki.prototype;function ao(t,n){var e=new io;if(t instanceof io)t.each(function(t){e.add(t)});else if(t){var r=-1,i=t.length;if(null==n)for(;++r<i;)e.add(t[r]);else for(;++r<i;)e.add(n(t[r],r,t))}return e}io.prototype=ao.prototype={constructor:io,has:oo.has,add:function(t){return this["$"+(t+="")]=t,this},remove:oo.remove,clear:oo.clear,values:oo.keys,size:oo.size,empty:oo.empty,each:oo.each};var uo=Array.prototype.slice;function fo(t,n){return t-n}function co(t){return function(){return t}}function so(t,n){for(var e,r=-1,i=n.length;++r<i;)if(e=lo(t,n[r]))return e;return 0}function lo(t,n){for(var e=n[0],r=n[1],i=-1,o=0,a=t.length,u=a-1;o<a;u=o++){var f=t[o],c=f[0],s=f[1],l=t[u],h=l[0],d=l[1];if(ho(f,l,n))return 0;s>r!=d>r&&e<(h-c)*(r-s)/(d-s)+c&&(i=-i)}return i}function ho(t,n,e){var r,i,o,a;return function(t,n,e){return(n[0]-t[0])*(e[1]-t[1])==(e[0]-t[0])*(n[1]-t[1])}(t,n,e)&&(i=t[r=+(t[0]===n[0])],o=e[r],a=n[r],i<=o&&o<=a||a<=o&&o<=i)}function po(){}var vo=[[],[[[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 go(){var t=1,n=1,e=M,r=u;function i(t){var n=e(t);if(Array.isArray(n))n=n.slice().sort(fo);else{var r=s(t),i=r[0],a=r[1];n=w(i,a,n),n=g(Math.floor(i/n)*n,Math.floor(a/n)*n,n)}return n.map(function(n){return o(t,n)})}function o(e,i){var o=[],u=[];return function(e,r,i){var o,u,f,c,s,l,h=new Array,d=new Array;o=u=-1,c=e[0]>=r,vo[c<<1].forEach(p);for(;++o<t-1;)f=c,c=e[o+1]>=r,vo[f|c<<1].forEach(p);vo[c<<0].forEach(p);for(;++u<n-1;){for(o=-1,c=e[u*t+t]>=r,s=e[u*t]>=r,vo[c<<1|s<<2].forEach(p);++o<t-1;)f=c,c=e[u*t+t+o+1]>=r,l=s,s=e[u*t+o+1]>=r,vo[f|c<<1|s<<2|l<<3].forEach(p);vo[c|s<<3].forEach(p)}o=-1,s=e[u*t]>=r,vo[s<<2].forEach(p);for(;++o<t-1;)l=s,s=e[u*t+o+1]>=r,vo[s<<2|l<<3].forEach(p);function p(t){var n,e,r=[t[0][0]+o,t[0][1]+u],f=[t[1][0]+o,t[1][1]+u],c=a(r),s=a(f);(n=d[c])?(e=h[s])?(delete d[n.end],delete h[e.start],n===e?(n.ring.push(f),i(n.ring)):h[n.start]=d[e.end]={start:n.start,end:e.end,ring:n.ring.concat(e.ring)}):(delete d[n.end],n.ring.push(f),d[n.end=s]=n):(n=h[s])?(e=d[c])?(delete h[n.start],delete d[e.end],n===e?(n.ring.push(f),i(n.ring)):h[e.start]=d[n.end]={start:e.start,end:n.end,ring:e.ring.concat(n.ring)}):(delete h[n.start],n.ring.unshift(r),h[n.start=c]=n):h[c]=d[s]={start:c,end:s,ring:[r,f]}}vo[s<<3].forEach(p)}(e,i,function(t){r(t,e,i),function(t){for(var n=0,e=t.length,r=t[e-1][1]*t[0][0]-t[e-1][0]*t[0][1];++n<e;)r+=t[n-1][1]*t[n][0]-t[n-1][0]*t[n][1];return r}(t)>0?o.push([t]):u.push(t)}),u.forEach(function(t){for(var n,e=0,r=o.length;e<r;++e)if(-1!==so((n=o[e])[0],t))return void n.push(t)}),{type:"MultiPolygon",value:i,coordinates:o}}function a(n){return 2*n[0]+n[1]*(t+1)*4}function u(e,r,i){e.forEach(function(e){var o,a=e[0],u=e[1],f=0|a,c=0|u,s=r[c*t+f];a>0&&a<t&&f===a&&(o=r[c*t+f-1],e[0]=a+(i-o)/(s-o)-.5),u>0&&u<n&&c===u&&(o=r[(c-1)*t+f],e[1]=u+(i-o)/(s-o)-.5)})}return i.contour=o,i.size=function(e){if(!arguments.length)return[t,n];var r=Math.ceil(e[0]),o=Math.ceil(e[1]);if(!(r>0&&o>0))throw new Error("invalid size");return t=r,n=o,i},i.thresholds=function(t){return arguments.length?(e="function"==typeof t?t:Array.isArray(t)?co(uo.call(t)):co(t),i):e},i.smooth=function(t){return arguments.length?(r=t?u:po,i):r===u},i}function yo(t,n,e){for(var r=t.width,i=t.height,o=1+(e<<1),a=0;a<i;++a)for(var u=0,f=0;u<r+e;++u)u<r&&(f+=t.data[u+a*r]),u>=e&&(u>=o&&(f-=t.data[u-o+a*r]),n.data[u-e+a*r]=f/Math.min(u+1,r-1+o-u,o))}function _o(t,n,e){for(var r=t.width,i=t.height,o=1+(e<<1),a=0;a<r;++a)for(var u=0,f=0;u<i+e;++u)u<i&&(f+=t.data[a+u*r]),u>=e&&(u>=o&&(f-=t.data[a+(u-o)*r]),n.data[a+(u-e)*r]=f/Math.min(u+1,i-1+o-u,o))}function bo(t){return t[0]}function mo(t){return t[1]}function xo(){return 1}var wo={},Mo={},Ao=34,To=10,No=13;function So(t){return new Function("d","return {"+t.map(function(t,n){return JSON.stringify(t)+": d["+n+"]"}).join(",")+"}")}function Eo(t){var n=new RegExp('["'+t+"\n\r]"),e=t.charCodeAt(0);function r(t,n){var r,i=[],o=t.length,a=0,u=0,f=o<=0,c=!1;function s(){if(f)return Mo;if(c)return c=!1,wo;var n,r,i=a;if(t.charCodeAt(i)===Ao){for(;a++<o&&t.charCodeAt(a)!==Ao||t.charCodeAt(++a)===Ao;);return(n=a)>=o?f=!0:(r=t.charCodeAt(a++))===To?c=!0:r===No&&(c=!0,t.charCodeAt(a)===To&&++a),t.slice(i+1,n-1).replace(/""/g,'"')}for(;a<o;){if((r=t.charCodeAt(n=a++))===To)c=!0;else if(r===No)c=!0,t.charCodeAt(a)===To&&++a;else if(r!==e)continue;return t.slice(i,n)}return f=!0,t.slice(i,o)}for(t.charCodeAt(o-1)===To&&--o,t.charCodeAt(o-1)===No&&--o;(r=s())!==Mo;){for(var l=[];r!==wo&&r!==Mo;)l.push(r),r=s();n&&null==(l=n(l,u++))||i.push(l)}return i}function i(n){return n.map(o).join(t)}function o(t){return null==t?"":n.test(t+="")?'"'+t.replace(/"/g,'""')+'"':t}return{parse:function(t,n){var e,i,o=r(t,function(t,r){if(e)return e(t,r-1);i=t,e=n?function(t,n){var e=So(t);return function(r,i){return n(e(r),i,t)}}(t,n):So(t)});return o.columns=i||[],o},parseRows:r,format:function(n,e){return null==e&&(e=function(t){var n=Object.create(null),e=[];return t.forEach(function(t){for(var r in t)r in n||e.push(n[r]=r)}),e}(n)),[e.map(o).join(t)].concat(n.map(function(n){return e.map(function(t){return o(n[t])}).join(t)})).join("\n")},formatRows:function(t){return t.map(i).join("\n")}}}var ko=Eo(","),Co=ko.parse,Po=ko.parseRows,zo=ko.format,Ro=ko.formatRows,Lo=Eo("\t"),Do=Lo.parse,Uo=Lo.parseRows,qo=Lo.format,Oo=Lo.formatRows;function Yo(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.blob()}function Bo(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.arrayBuffer()}function Fo(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.text()}function Io(t,n){return fetch(t,n).then(Fo)}function Ho(t){return function(n,e,r){return 2===arguments.length&&"function"==typeof e&&(r=e,e=void 0),Io(n,e).then(function(n){return t(n,r)})}}var jo=Ho(Co),Xo=Ho(Do);function Go(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.json()}function Vo(t){return function(n,e){return Io(n,e).then(function(n){return(new DOMParser).parseFromString(n,t)})}}var $o=Vo("application/xml"),Wo=Vo("text/html"),Zo=Vo("image/svg+xml");function Qo(t){return function(){return t}}function Jo(){return 1e-6*(Math.random()-.5)}function Ko(t,n,e,r){if(isNaN(n)||isNaN(e))return t;var i,o,a,u,f,c,s,l,h,d=t._root,p={data:r},v=t._x0,g=t._y0,y=t._x1,_=t._y1;if(!d)return t._root=p,t;for(;d.length;)if((c=n>=(o=(v+y)/2))?v=o:y=o,(s=e>=(a=(g+_)/2))?g=a:_=a,i=d,!(d=d[l=s<<1|c]))return i[l]=p,t;if(u=+t._x.call(null,d.data),f=+t._y.call(null,d.data),n===u&&e===f)return p.next=d,i?i[l]=p:t._root=p,t;do{i=i?i[l]=new Array(4):t._root=new Array(4),(c=n>=(o=(v+y)/2))?v=o:y=o,(s=e>=(a=(g+_)/2))?g=a:_=a}while((l=s<<1|c)==(h=(f>=a)<<1|u>=o));return i[h]=d,i[l]=p,t}function ta(t,n,e,r,i){this.node=t,this.x0=n,this.y0=e,this.x1=r,this.y1=i}function na(t){return t[0]}function ea(t){return t[1]}function ra(t,n,e){var r=new ia(null==n?na:n,null==e?ea:e,NaN,NaN,NaN,NaN);return null==t?r:r.addAll(t)}function ia(t,n,e,r,i,o){this._x=t,this._y=n,this._x0=e,this._y0=r,this._x1=i,this._y1=o,this._root=void 0}function oa(t){for(var n={data:t.data},e=n;t=t.next;)e=e.next={data:t.data};return n}var aa=ra.prototype=ia.prototype;function ua(t){return t.x+t.vx}function fa(t){return t.y+t.vy}function ca(t){return t.index}function sa(t,n){var e=t.get(n);if(!e)throw new Error("missing: "+n);return e}function la(t){return t.x}function ha(t){return t.y}aa.copy=function(){var t,n,e=new ia(this._x,this._y,this._x0,this._y0,this._x1,this._y1),r=this._root;if(!r)return e;if(!r.length)return e._root=oa(r),e;for(t=[{source:r,target:e._root=new Array(4)}];r=t.pop();)for(var i=0;i<4;++i)(n=r.source[i])&&(n.length?t.push({source:n,target:r.target[i]=new Array(4)}):r.target[i]=oa(n));return e},aa.add=function(t){var n=+this._x.call(null,t),e=+this._y.call(null,t);return Ko(this.cover(n,e),n,e,t)},aa.addAll=function(t){var n,e,r,i,o=t.length,a=new Array(o),u=new Array(o),f=1/0,c=1/0,s=-1/0,l=-1/0;for(e=0;e<o;++e)isNaN(r=+this._x.call(null,n=t[e]))||isNaN(i=+this._y.call(null,n))||(a[e]=r,u[e]=i,r<f&&(f=r),r>s&&(s=r),i<c&&(c=i),i>l&&(l=i));for(s<f&&(f=this._x0,s=this._x1),l<c&&(c=this._y0,l=this._y1),this.cover(f,c).cover(s,l),e=0;e<o;++e)Ko(this,a[e],u[e],t[e]);return this},aa.cover=function(t,n){if(isNaN(t=+t)||isNaN(n=+n))return this;var e=this._x0,r=this._y0,i=this._x1,o=this._y1;if(isNaN(e))i=(e=Math.floor(t))+1,o=(r=Math.floor(n))+1;else{if(!(e>t||t>i||r>n||n>o))return this;var a,u,f=i-e,c=this._root;switch(u=(n<(r+o)/2)<<1|t<(e+i)/2){case 0:do{(a=new Array(4))[u]=c,c=a}while(o=r+(f*=2),t>(i=e+f)||n>o);break;case 1:do{(a=new Array(4))[u]=c,c=a}while(o=r+(f*=2),(e=i-f)>t||n>o);break;case 2:do{(a=new Array(4))[u]=c,c=a}while(r=o-(f*=2),t>(i=e+f)||r>n);break;case 3:do{(a=new Array(4))[u]=c,c=a}while(r=o-(f*=2),(e=i-f)>t||r>n)}this._root&&this._root.length&&(this._root=c)}return this._x0=e,this._y0=r,this._x1=i,this._y1=o,this},aa.data=function(){var t=[];return this.visit(function(n){if(!n.length)do{t.push(n.data)}while(n=n.next)}),t},aa.extent=function(t){return arguments.length?this.cover(+t[0][0],+t[0][1]).cover(+t[1][0],+t[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]},aa.find=function(t,n,e){var r,i,o,a,u,f,c,s=this._x0,l=this._y0,h=this._x1,d=this._y1,p=[],v=this._root;for(v&&p.push(new ta(v,s,l,h,d)),null==e?e=1/0:(s=t-e,l=n-e,h=t+e,d=n+e,e*=e);f=p.pop();)if(!(!(v=f.node)||(i=f.x0)>h||(o=f.y0)>d||(a=f.x1)<s||(u=f.y1)<l))if(v.length){var g=(i+a)/2,y=(o+u)/2;p.push(new ta(v[3],g,y,a,u),new ta(v[2],i,y,g,u),new ta(v[1],g,o,a,y),new ta(v[0],i,o,g,y)),(c=(n>=y)<<1|t>=g)&&(f=p[p.length-1],p[p.length-1]=p[p.length-1-c],p[p.length-1-c]=f)}else{var _=t-+this._x.call(null,v.data),b=n-+this._y.call(null,v.data),m=_*_+b*b;if(m<e){var x=Math.sqrt(e=m);s=t-x,l=n-x,h=t+x,d=n+x,r=v.data}}return r},aa.remove=function(t){if(isNaN(o=+this._x.call(null,t))||isNaN(a=+this._y.call(null,t)))return this;var n,e,r,i,o,a,u,f,c,s,l,h,d=this._root,p=this._x0,v=this._y0,g=this._x1,y=this._y1;if(!d)return this;if(d.length)for(;;){if((c=o>=(u=(p+g)/2))?p=u:g=u,(s=a>=(f=(v+y)/2))?v=f:y=f,n=d,!(d=d[l=s<<1|c]))return this;if(!d.length)break;(n[l+1&3]||n[l+2&3]||n[l+3&3])&&(e=n,h=l)}for(;d.data!==t;)if(r=d,!(d=d.next))return this;return(i=d.next)&&delete d.next,r?(i?r.next=i:delete r.next,this):n?(i?n[l]=i:delete n[l],(d=n[0]||n[1]||n[2]||n[3])&&d===(n[3]||n[2]||n[1]||n[0])&&!d.length&&(e?e[h]=d:this._root=d),this):(this._root=i,this)},aa.removeAll=function(t){for(var n=0,e=t.length;n<e;++n)this.remove(t[n]);return this},aa.root=function(){return this._root},aa.size=function(){var t=0;return this.visit(function(n){if(!n.length)do{++t}while(n=n.next)}),t},aa.visit=function(t){var n,e,r,i,o,a,u=[],f=this._root;for(f&&u.push(new ta(f,this._x0,this._y0,this._x1,this._y1));n=u.pop();)if(!t(f=n.node,r=n.x0,i=n.y0,o=n.x1,a=n.y1)&&f.length){var c=(r+o)/2,s=(i+a)/2;(e=f[3])&&u.push(new ta(e,c,s,o,a)),(e=f[2])&&u.push(new ta(e,r,s,c,a)),(e=f[1])&&u.push(new ta(e,c,i,o,s)),(e=f[0])&&u.push(new ta(e,r,i,c,s))}return this},aa.visitAfter=function(t){var n,e=[],r=[];for(this._root&&e.push(new ta(this._root,this._x0,this._y0,this._x1,this._y1));n=e.pop();){var i=n.node;if(i.length){var o,a=n.x0,u=n.y0,f=n.x1,c=n.y1,s=(a+f)/2,l=(u+c)/2;(o=i[0])&&e.push(new ta(o,a,u,s,l)),(o=i[1])&&e.push(new ta(o,s,u,f,l)),(o=i[2])&&e.push(new ta(o,a,l,s,c)),(o=i[3])&&e.push(new ta(o,s,l,f,c))}r.push(n)}for(;n=r.pop();)t(n.node,n.x0,n.y0,n.x1,n.y1);return this},aa.x=function(t){return arguments.length?(this._x=t,this):this._x},aa.y=function(t){return arguments.length?(this._y=t,this):this._y};var da=10,pa=Math.PI*(3-Math.sqrt(5));function va(t,n){if((e=(t=n?t.toExponential(n-1):t.toExponential()).indexOf("e"))<0)return null;var e,r=t.slice(0,e);return[r.length>1?r[0]+r.slice(2):r,+t.slice(e+1)]}function ga(t){return(t=va(Math.abs(t)))?t[1]:NaN}var ya,_a=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function ba(t){return new ma(t)}function ma(t){if(!(n=_a.exec(t)))throw new Error("invalid format: "+t);var n;this.fill=n[1]||" ",this.align=n[2]||">",this.sign=n[3]||"-",this.symbol=n[4]||"",this.zero=!!n[5],this.width=n[6]&&+n[6],this.comma=!!n[7],this.precision=n[8]&&+n[8].slice(1),this.trim=!!n[9],this.type=n[10]||""}function xa(t,n){var e=va(t,n);if(!e)return t+"";var r=e[0],i=e[1];return i<0?"0."+new Array(-i).join("0")+r:r.length>i+1?r.slice(0,i+1)+"."+r.slice(i+1):r+new Array(i-r.length+2).join("0")}ba.prototype=ma.prototype,ma.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(null==this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(null==this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var wa={"%":function(t,n){return(100*t).toFixed(n)},b:function(t){return Math.round(t).toString(2)},c:function(t){return t+""},d:function(t){return Math.round(t).toString(10)},e:function(t,n){return t.toExponential(n)},f:function(t,n){return t.toFixed(n)},g:function(t,n){return t.toPrecision(n)},o:function(t){return Math.round(t).toString(8)},p:function(t,n){return xa(100*t,n)},r:xa,s:function(t,n){var e=va(t,n);if(!e)return t+"";var r=e[0],i=e[1],o=i-(ya=3*Math.max(-8,Math.min(8,Math.floor(i/3))))+1,a=r.length;return o===a?r:o>a?r+new Array(o-a+1).join("0"):o>0?r.slice(0,o)+"."+r.slice(o):"0."+new Array(1-o).join("0")+va(t,Math.max(0,n+o-1))[0]},X:function(t){return Math.round(t).toString(16).toUpperCase()},x:function(t){return Math.round(t).toString(16)}};function Ma(t){return t}var Aa,Ta=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function Na(t){var n,e,r=t.grouping&&t.thousands?(n=t.grouping,e=t.thousands,function(t,r){for(var i=t.length,o=[],a=0,u=n[0],f=0;i>0&&u>0&&(f+u+1>r&&(u=Math.max(1,r-f)),o.push(t.substring(i-=u,i+u)),!((f+=u+1)>r));)u=n[a=(a+1)%n.length];return o.reverse().join(e)}):Ma,i=t.currency,o=t.decimal,a=t.numerals?function(t){return function(n){return n.replace(/[0-9]/g,function(n){return t[+n]})}}(t.numerals):Ma,u=t.percent||"%";function f(t){var n=(t=ba(t)).fill,e=t.align,f=t.sign,c=t.symbol,s=t.zero,l=t.width,h=t.comma,d=t.precision,p=t.trim,v=t.type;"n"===v?(h=!0,v="g"):wa[v]||(null==d&&(d=12),p=!0,v="g"),(s||"0"===n&&"="===e)&&(s=!0,n="0",e="=");var g="$"===c?i[0]:"#"===c&&/[boxX]/.test(v)?"0"+v.toLowerCase():"",y="$"===c?i[1]:/[%p]/.test(v)?u:"",_=wa[v],b=/[defgprs%]/.test(v);function m(t){var i,u,c,m=g,x=y;if("c"===v)x=_(t)+x,t="";else{var w=(t=+t)<0;if(t=_(Math.abs(t),d),p&&(t=function(t){t:for(var n,e=t.length,r=1,i=-1;r<e;++r)switch(t[r]){case".":i=n=r;break;case"0":0===i&&(i=r),n=r;break;default:if(i>0){if(!+t[r])break t;i=0}}return i>0?t.slice(0,i)+t.slice(n+1):t}(t)),w&&0==+t&&(w=!1),m=(w?"("===f?f:"-":"-"===f||"("===f?"":f)+m,x=("s"===v?Ta[8+ya/3]:"")+x+(w&&"("===f?")":""),b)for(i=-1,u=t.length;++i<u;)if(48>(c=t.charCodeAt(i))||c>57){x=(46===c?o+t.slice(i+1):t.slice(i))+x,t=t.slice(0,i);break}}h&&!s&&(t=r(t,1/0));var M=m.length+t.length+x.length,A=M<l?new Array(l-M+1).join(n):"";switch(h&&s&&(t=r(A+t,A.length?l-x.length:1/0),A=""),e){case"<":t=m+t+x+A;break;case"=":t=m+A+t+x;break;case"^":t=A.slice(0,M=A.length>>1)+m+t+x+A.slice(M);break;default:t=A+m+t+x}return a(t)}return d=null==d?6:/[gprs]/.test(v)?Math.max(1,Math.min(21,d)):Math.max(0,Math.min(20,d)),m.toString=function(){return t+""},m}return{format:f,formatPrefix:function(t,n){var e=f(((t=ba(t)).type="f",t)),r=3*Math.max(-8,Math.min(8,Math.floor(ga(n)/3))),i=Math.pow(10,-r),o=Ta[8+r/3];return function(t){return e(i*t)+o}}}}function Sa(n){return Aa=Na(n),t.format=Aa.format,t.formatPrefix=Aa.formatPrefix,Aa}function Ea(t){return Math.max(0,-ga(Math.abs(t)))}function ka(t,n){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(ga(n)/3)))-ga(Math.abs(t)))}function Ca(t,n){return t=Math.abs(t),n=Math.abs(n)-t,Math.max(0,ga(n)-ga(t))+1}function Pa(){return new za}function za(){this.reset()}Sa({decimal:".",thousands:",",grouping:[3],currency:["$",""]}),za.prototype={constructor:za,reset:function(){this.s=this.t=0},add:function(t){La(Ra,t,this.t),La(this,Ra.s,this.s),this.s?this.t+=Ra.t:this.s=Ra.t},valueOf:function(){return this.s}};var Ra=new za;function La(t,n,e){var r=t.s=n+e,i=r-n,o=r-i;t.t=n-o+(e-i)}var Da=1e-6,Ua=1e-12,qa=Math.PI,Oa=qa/2,Ya=qa/4,Ba=2*qa,Fa=180/qa,Ia=qa/180,Ha=Math.abs,ja=Math.atan,Xa=Math.atan2,Ga=Math.cos,Va=Math.ceil,$a=Math.exp,Wa=Math.log,Za=Math.pow,Qa=Math.sin,Ja=Math.sign||function(t){return t>0?1:t<0?-1:0},Ka=Math.sqrt,tu=Math.tan;function nu(t){return t>1?0:t<-1?qa:Math.acos(t)}function eu(t){return t>1?Oa:t<-1?-Oa:Math.asin(t)}function ru(t){return(t=Qa(t/2))*t}function iu(){}function ou(t,n){t&&uu.hasOwnProperty(t.type)&&uu[t.type](t,n)}var au={Feature:function(t,n){ou(t.geometry,n)},FeatureCollection:function(t,n){for(var e=t.features,r=-1,i=e.length;++r<i;)ou(e[r].geometry,n)}},uu={Sphere:function(t,n){n.sphere()},Point:function(t,n){t=t.coordinates,n.point(t[0],t[1],t[2])},MultiPoint:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)t=e[r],n.point(t[0],t[1],t[2])},LineString:function(t,n){fu(t.coordinates,n,0)},MultiLineString:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)fu(e[r],n,0)},Polygon:function(t,n){cu(t.coordinates,n)},MultiPolygon:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)cu(e[r],n)},GeometryCollection:function(t,n){for(var e=t.geometries,r=-1,i=e.length;++r<i;)ou(e[r],n)}};function fu(t,n,e){var r,i=-1,o=t.length-e;for(n.lineStart();++i<o;)r=t[i],n.point(r[0],r[1],r[2]);n.lineEnd()}function cu(t,n){var e=-1,r=t.length;for(n.polygonStart();++e<r;)fu(t[e],n,1);n.polygonEnd()}function su(t,n){t&&au.hasOwnProperty(t.type)?au[t.type](t,n):ou(t,n)}var lu,hu,du,pu,vu,gu=Pa(),yu=Pa(),_u={point:iu,lineStart:iu,lineEnd:iu,polygonStart:function(){gu.reset(),_u.lineStart=bu,_u.lineEnd=mu},polygonEnd:function(){var t=+gu;yu.add(t<0?Ba+t:t),this.lineStart=this.lineEnd=this.point=iu},sphere:function(){yu.add(Ba)}};function bu(){_u.point=xu}function mu(){wu(lu,hu)}function xu(t,n){_u.point=wu,lu=t,hu=n,du=t*=Ia,pu=Ga(n=(n*=Ia)/2+Ya),vu=Qa(n)}function wu(t,n){var e=(t*=Ia)-du,r=e>=0?1:-1,i=r*e,o=Ga(n=(n*=Ia)/2+Ya),a=Qa(n),u=vu*a,f=pu*o+u*Ga(i),c=u*r*Qa(i);gu.add(Xa(c,f)),du=t,pu=o,vu=a}function Mu(t){return[Xa(t[1],t[0]),eu(t[2])]}function Au(t){var n=t[0],e=t[1],r=Ga(e);return[r*Ga(n),r*Qa(n),Qa(e)]}function Tu(t,n){return t[0]*n[0]+t[1]*n[1]+t[2]*n[2]}function Nu(t,n){return[t[1]*n[2]-t[2]*n[1],t[2]*n[0]-t[0]*n[2],t[0]*n[1]-t[1]*n[0]]}function Su(t,n){t[0]+=n[0],t[1]+=n[1],t[2]+=n[2]}function Eu(t,n){return[t[0]*n,t[1]*n,t[2]*n]}function ku(t){var n=Ka(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]);t[0]/=n,t[1]/=n,t[2]/=n}var Cu,Pu,zu,Ru,Lu,Du,Uu,qu,Ou,Yu,Bu,Fu,Iu,Hu,ju,Xu,Gu,Vu,$u,Wu,Zu,Qu,Ju,Ku,tf,nf,ef=Pa(),rf={point:of,lineStart:uf,lineEnd:ff,polygonStart:function(){rf.point=cf,rf.lineStart=sf,rf.lineEnd=lf,ef.reset(),_u.polygonStart()},polygonEnd:function(){_u.polygonEnd(),rf.point=of,rf.lineStart=uf,rf.lineEnd=ff,gu<0?(Cu=-(zu=180),Pu=-(Ru=90)):ef>Da?Ru=90:ef<-Da&&(Pu=-90),Yu[0]=Cu,Yu[1]=zu}};function of(t,n){Ou.push(Yu=[Cu=t,zu=t]),n<Pu&&(Pu=n),n>Ru&&(Ru=n)}function af(t,n){var e=Au([t*Ia,n*Ia]);if(qu){var r=Nu(qu,e),i=Nu([r[1],-r[0],0],r);ku(i),i=Mu(i);var o,a=t-Lu,u=a>0?1:-1,f=i[0]*Fa*u,c=Ha(a)>180;c^(u*Lu<f&&f<u*t)?(o=i[1]*Fa)>Ru&&(Ru=o):c^(u*Lu<(f=(f+360)%360-180)&&f<u*t)?(o=-i[1]*Fa)<Pu&&(Pu=o):(n<Pu&&(Pu=n),n>Ru&&(Ru=n)),c?t<Lu?hf(Cu,t)>hf(Cu,zu)&&(zu=t):hf(t,zu)>hf(Cu,zu)&&(Cu=t):zu>=Cu?(t<Cu&&(Cu=t),t>zu&&(zu=t)):t>Lu?hf(Cu,t)>hf(Cu,zu)&&(zu=t):hf(t,zu)>hf(Cu,zu)&&(Cu=t)}else Ou.push(Yu=[Cu=t,zu=t]);n<Pu&&(Pu=n),n>Ru&&(Ru=n),qu=e,Lu=t}function uf(){rf.point=af}function ff(){Yu[0]=Cu,Yu[1]=zu,rf.point=of,qu=null}function cf(t,n){if(qu){var e=t-Lu;ef.add(Ha(e)>180?e+(e>0?360:-360):e)}else Du=t,Uu=n;_u.point(t,n),af(t,n)}function sf(){_u.lineStart()}function lf(){cf(Du,Uu),_u.lineEnd(),Ha(ef)>Da&&(Cu=-(zu=180)),Yu[0]=Cu,Yu[1]=zu,qu=null}function hf(t,n){return(n-=t)<0?n+360:n}function df(t,n){return t[0]-n[0]}function pf(t,n){return t[0]<=t[1]?t[0]<=n&&n<=t[1]:n<t[0]||t[1]<n}var vf={sphere:iu,point:gf,lineStart:_f,lineEnd:xf,polygonStart:function(){vf.lineStart=wf,vf.lineEnd=Mf},polygonEnd:function(){vf.lineStart=_f,vf.lineEnd=xf}};function gf(t,n){t*=Ia;var e=Ga(n*=Ia);yf(e*Ga(t),e*Qa(t),Qa(n))}function yf(t,n,e){Iu+=(t-Iu)/++Bu,Hu+=(n-Hu)/Bu,ju+=(e-ju)/Bu}function _f(){vf.point=bf}function bf(t,n){t*=Ia;var e=Ga(n*=Ia);Ku=e*Ga(t),tf=e*Qa(t),nf=Qa(n),vf.point=mf,yf(Ku,tf,nf)}function mf(t,n){t*=Ia;var e=Ga(n*=Ia),r=e*Ga(t),i=e*Qa(t),o=Qa(n),a=Xa(Ka((a=tf*o-nf*i)*a+(a=nf*r-Ku*o)*a+(a=Ku*i-tf*r)*a),Ku*r+tf*i+nf*o);Fu+=a,Xu+=a*(Ku+(Ku=r)),Gu+=a*(tf+(tf=i)),Vu+=a*(nf+(nf=o)),yf(Ku,tf,nf)}function xf(){vf.point=gf}function wf(){vf.point=Af}function Mf(){Tf(Qu,Ju),vf.point=gf}function Af(t,n){Qu=t,Ju=n,t*=Ia,n*=Ia,vf.point=Tf;var e=Ga(n);Ku=e*Ga(t),tf=e*Qa(t),nf=Qa(n),yf(Ku,tf,nf)}function Tf(t,n){t*=Ia;var e=Ga(n*=Ia),r=e*Ga(t),i=e*Qa(t),o=Qa(n),a=tf*o-nf*i,u=nf*r-Ku*o,f=Ku*i-tf*r,c=Ka(a*a+u*u+f*f),s=eu(c),l=c&&-s/c;$u+=l*a,Wu+=l*u,Zu+=l*f,Fu+=s,Xu+=s*(Ku+(Ku=r)),Gu+=s*(tf+(tf=i)),Vu+=s*(nf+(nf=o)),yf(Ku,tf,nf)}function Nf(t){return function(){return t}}function Sf(t,n){function e(e,r){return e=t(e,r),n(e[0],e[1])}return t.invert&&n.invert&&(e.invert=function(e,r){return(e=n.invert(e,r))&&t.invert(e[0],e[1])}),e}function Ef(t,n){return[t>qa?t-Ba:t<-qa?t+Ba:t,n]}function kf(t,n,e){return(t%=Ba)?n||e?Sf(Pf(t),zf(n,e)):Pf(t):n||e?zf(n,e):Ef}function Cf(t){return function(n,e){return[(n+=t)>qa?n-Ba:n<-qa?n+Ba:n,e]}}function Pf(t){var n=Cf(t);return n.invert=Cf(-t),n}function zf(t,n){var e=Ga(t),r=Qa(t),i=Ga(n),o=Qa(n);function a(t,n){var a=Ga(n),u=Ga(t)*a,f=Qa(t)*a,c=Qa(n),s=c*e+u*r;return[Xa(f*i-s*o,u*e-c*r),eu(s*i+f*o)]}return a.invert=function(t,n){var a=Ga(n),u=Ga(t)*a,f=Qa(t)*a,c=Qa(n),s=c*i-f*o;return[Xa(f*i+c*o,u*e+s*r),eu(s*e-u*r)]},a}function Rf(t){function n(n){return(n=t(n[0]*Ia,n[1]*Ia))[0]*=Fa,n[1]*=Fa,n}return t=kf(t[0]*Ia,t[1]*Ia,t.length>2?t[2]*Ia:0),n.invert=function(n){return(n=t.invert(n[0]*Ia,n[1]*Ia))[0]*=Fa,n[1]*=Fa,n},n}function Lf(t,n,e,r,i,o){if(e){var a=Ga(n),u=Qa(n),f=r*e;null==i?(i=n+r*Ba,o=n-f/2):(i=Df(a,i),o=Df(a,o),(r>0?i<o:i>o)&&(i+=r*Ba));for(var c,s=i;r>0?s>o:s<o;s-=f)c=Mu([a,-u*Ga(s),-u*Qa(s)]),t.point(c[0],c[1])}}function Df(t,n){(n=Au(n))[0]-=t,ku(n);var e=nu(-n[1]);return((-n[2]<0?-e:e)+Ba-Da)%Ba}function Uf(){var t,n=[];return{point:function(n,e){t.push([n,e])},lineStart:function(){n.push(t=[])},lineEnd:iu,rejoin:function(){n.length>1&&n.push(n.pop().concat(n.shift()))},result:function(){var e=n;return n=[],t=null,e}}}function qf(t,n){return Ha(t[0]-n[0])<Da&&Ha(t[1]-n[1])<Da}function Of(t,n,e,r){this.x=t,this.z=n,this.o=e,this.e=r,this.v=!1,this.n=this.p=null}function Yf(t,n,e,r,i){var o,a,u=[],f=[];if(t.forEach(function(t){if(!((n=t.length-1)<=0)){var n,e,r=t[0],a=t[n];if(qf(r,a)){for(i.lineStart(),o=0;o<n;++o)i.point((r=t[o])[0],r[1]);i.lineEnd()}else u.push(e=new Of(r,t,null,!0)),f.push(e.o=new Of(r,null,e,!1)),u.push(e=new Of(a,t,null,!1)),f.push(e.o=new Of(a,null,e,!0))}}),u.length){for(f.sort(n),Bf(u),Bf(f),o=0,a=f.length;o<a;++o)f[o].e=e=!e;for(var c,s,l=u[0];;){for(var h=l,d=!0;h.v;)if((h=h.n)===l)return;c=h.z,i.lineStart();do{if(h.v=h.o.v=!0,h.e){if(d)for(o=0,a=c.length;o<a;++o)i.point((s=c[o])[0],s[1]);else r(h.x,h.n.x,1,i);h=h.n}else{if(d)for(c=h.p.z,o=c.length-1;o>=0;--o)i.point((s=c[o])[0],s[1]);else r(h.x,h.p.x,-1,i);h=h.p}c=(h=h.o).z,d=!d}while(!h.v);i.lineEnd()}}}function Bf(t){if(n=t.length){for(var n,e,r=0,i=t[0];++r<n;)i.n=e=t[r],e.p=i,i=e;i.n=e=t[0],e.p=i}}Ef.invert=Ef;var Ff=Pa();function If(t,n){var e=n[0],r=n[1],i=Qa(r),o=[Qa(e),-Ga(e),0],a=0,u=0;Ff.reset(),1===i?r=Oa+Da:-1===i&&(r=-Oa-Da);for(var f=0,c=t.length;f<c;++f)if(l=(s=t[f]).length)for(var s,l,h=s[l-1],d=h[0],p=h[1]/2+Ya,v=Qa(p),g=Ga(p),y=0;y<l;++y,d=b,v=x,g=w,h=_){var _=s[y],b=_[0],m=_[1]/2+Ya,x=Qa(m),w=Ga(m),M=b-d,A=M>=0?1:-1,T=A*M,N=T>qa,S=v*x;if(Ff.add(Xa(S*A*Qa(T),g*w+S*Ga(T))),a+=N?M+A*Ba:M,N^d>=e^b>=e){var E=Nu(Au(h),Au(_));ku(E);var k=Nu(o,E);ku(k);var C=(N^M>=0?-1:1)*eu(k[2]);(r>C||r===C&&(E[0]||E[1]))&&(u+=N^M>=0?1:-1)}}return(a<-Da||a<Da&&Ff<-Da)^1&u}function Hf(t,n,e,r){return function(i){var o,a,u,f=n(i),c=Uf(),s=n(c),l=!1,h={point:d,lineStart:v,lineEnd:g,polygonStart:function(){h.point=y,h.lineStart=_,h.lineEnd=b,a=[],o=[]},polygonEnd:function(){h.point=d,h.lineStart=v,h.lineEnd=g,a=N(a);var t=If(o,r);a.length?(l||(i.polygonStart(),l=!0),Yf(a,Xf,t,e,i)):t&&(l||(i.polygonStart(),l=!0),i.lineStart(),e(null,null,1,i),i.lineEnd()),l&&(i.polygonEnd(),l=!1),a=o=null},sphere:function(){i.polygonStart(),i.lineStart(),e(null,null,1,i),i.lineEnd(),i.polygonEnd()}};function d(n,e){t(n,e)&&i.point(n,e)}function p(t,n){f.point(t,n)}function v(){h.point=p,f.lineStart()}function g(){h.point=d,f.lineEnd()}function y(t,n){u.push([t,n]),s.point(t,n)}function _(){s.lineStart(),u=[]}function b(){y(u[0][0],u[0][1]),s.lineEnd();var t,n,e,r,f=s.clean(),h=c.result(),d=h.length;if(u.pop(),o.push(u),u=null,d)if(1&f){if((n=(e=h[0]).length-1)>0){for(l||(i.polygonStart(),l=!0),i.lineStart(),t=0;t<n;++t)i.point((r=e[t])[0],r[1]);i.lineEnd()}}else d>1&&2&f&&h.push(h.pop().concat(h.shift())),a.push(h.filter(jf))}return h}}function jf(t){return t.length>1}function Xf(t,n){return((t=t.x)[0]<0?t[1]-Oa-Da:Oa-t[1])-((n=n.x)[0]<0?n[1]-Oa-Da:Oa-n[1])}var Gf=Hf(function(){return!0},function(t){var n,e=NaN,r=NaN,i=NaN;return{lineStart:function(){t.lineStart(),n=1},point:function(o,a){var u=o>0?qa:-qa,f=Ha(o-e);Ha(f-qa)<Da?(t.point(e,r=(r+a)/2>0?Oa:-Oa),t.point(i,r),t.lineEnd(),t.lineStart(),t.point(u,r),t.point(o,r),n=0):i!==u&&f>=qa&&(Ha(e-i)<Da&&(e-=i*Da),Ha(o-u)<Da&&(o-=u*Da),r=function(t,n,e,r){var i,o,a=Qa(t-e);return Ha(a)>Da?ja((Qa(n)*(o=Ga(r))*Qa(e)-Qa(r)*(i=Ga(n))*Qa(t))/(i*o*a)):(n+r)/2}(e,r,o,a),t.point(i,r),t.lineEnd(),t.lineStart(),t.point(u,r),n=0),t.point(e=o,r=a),i=u},lineEnd:function(){t.lineEnd(),e=r=NaN},clean:function(){return 2-n}}},function(t,n,e,r){var i;if(null==t)i=e*Oa,r.point(-qa,i),r.point(0,i),r.point(qa,i),r.point(qa,0),r.point(qa,-i),r.point(0,-i),r.point(-qa,-i),r.point(-qa,0),r.point(-qa,i);else if(Ha(t[0]-n[0])>Da){var o=t[0]<n[0]?qa:-qa;i=e*o/2,r.point(-o,i),r.point(0,i),r.point(o,i)}else r.point(n[0],n[1])},[-qa,-Oa]);function Vf(t){var n=Ga(t),e=6*Ia,r=n>0,i=Ha(n)>Da;function o(t,e){return Ga(t)*Ga(e)>n}function a(t,e,r){var i=[1,0,0],o=Nu(Au(t),Au(e)),a=Tu(o,o),u=o[0],f=a-u*u;if(!f)return!r&&t;var c=n*a/f,s=-n*u/f,l=Nu(i,o),h=Eu(i,c);Su(h,Eu(o,s));var d=l,p=Tu(h,d),v=Tu(d,d),g=p*p-v*(Tu(h,h)-1);if(!(g<0)){var y=Ka(g),_=Eu(d,(-p-y)/v);if(Su(_,h),_=Mu(_),!r)return _;var b,m=t[0],x=e[0],w=t[1],M=e[1];x<m&&(b=m,m=x,x=b);var A=x-m,T=Ha(A-qa)<Da;if(!T&&M<w&&(b=w,w=M,M=b),T||A<Da?T?w+M>0^_[1]<(Ha(_[0]-m)<Da?w:M):w<=_[1]&&_[1]<=M:A>qa^(m<=_[0]&&_[0]<=x)){var N=Eu(d,(-p+y)/v);return Su(N,h),[_,Mu(N)]}}}function u(n,e){var i=r?t:qa-t,o=0;return n<-i?o|=1:n>i&&(o|=2),e<-i?o|=4:e>i&&(o|=8),o}return Hf(o,function(t){var n,e,f,c,s;return{lineStart:function(){c=f=!1,s=1},point:function(l,h){var d,p=[l,h],v=o(l,h),g=r?v?0:u(l,h):v?u(l+(l<0?qa:-qa),h):0;if(!n&&(c=f=v)&&t.lineStart(),v!==f&&(!(d=a(n,p))||qf(n,d)||qf(p,d))&&(p[0]+=Da,p[1]+=Da,v=o(p[0],p[1])),v!==f)s=0,v?(t.lineStart(),d=a(p,n),t.point(d[0],d[1])):(d=a(n,p),t.point(d[0],d[1]),t.lineEnd()),n=d;else if(i&&n&&r^v){var y;g&e||!(y=a(p,n,!0))||(s=0,r?(t.lineStart(),t.point(y[0][0],y[0][1]),t.point(y[1][0],y[1][1]),t.lineEnd()):(t.point(y[1][0],y[1][1]),t.lineEnd(),t.lineStart(),t.point(y[0][0],y[0][1])))}!v||n&&qf(n,p)||t.point(p[0],p[1]),n=p,f=v,e=g},lineEnd:function(){f&&t.lineEnd(),n=null},clean:function(){return s|(c&&f)<<1}}},function(n,r,i,o){Lf(o,t,e,i,n,r)},r?[0,-t]:[-qa,t-qa])}var $f=1e9,Wf=-$f;function Zf(t,n,e,r){function i(i,o){return t<=i&&i<=e&&n<=o&&o<=r}function o(i,o,u,c){var s=0,l=0;if(null==i||(s=a(i,u))!==(l=a(o,u))||f(i,o)<0^u>0)do{c.point(0===s||3===s?t:e,s>1?r:n)}while((s=(s+u+4)%4)!==l);else c.point(o[0],o[1])}function a(r,i){return Ha(r[0]-t)<Da?i>0?0:3:Ha(r[0]-e)<Da?i>0?2:1:Ha(r[1]-n)<Da?i>0?1:0:i>0?3:2}function u(t,n){return f(t.x,n.x)}function f(t,n){var e=a(t,1),r=a(n,1);return e!==r?e-r:0===e?n[1]-t[1]:1===e?t[0]-n[0]:2===e?t[1]-n[1]:n[0]-t[0]}return function(a){var f,c,s,l,h,d,p,v,g,y,_,b=a,m=Uf(),x={point:w,lineStart:function(){x.point=M,c&&c.push(s=[]);y=!0,g=!1,p=v=NaN},lineEnd:function(){f&&(M(l,h),d&&g&&m.rejoin(),f.push(m.result()));x.point=w,g&&b.lineEnd()},polygonStart:function(){b=m,f=[],c=[],_=!0},polygonEnd:function(){var n=function(){for(var n=0,e=0,i=c.length;e<i;++e)for(var o,a,u=c[e],f=1,s=u.length,l=u[0],h=l[0],d=l[1];f<s;++f)o=h,a=d,l=u[f],h=l[0],d=l[1],a<=r?d>r&&(h-o)*(r-a)>(d-a)*(t-o)&&++n:d<=r&&(h-o)*(r-a)<(d-a)*(t-o)&&--n;return n}(),e=_&&n,i=(f=N(f)).length;(e||i)&&(a.polygonStart(),e&&(a.lineStart(),o(null,null,1,a),a.lineEnd()),i&&Yf(f,u,n,o,a),a.polygonEnd());b=a,f=c=s=null}};function w(t,n){i(t,n)&&b.point(t,n)}function M(o,a){var u=i(o,a);if(c&&s.push([o,a]),y)l=o,h=a,d=u,y=!1,u&&(b.lineStart(),b.point(o,a));else if(u&&g)b.point(o,a);else{var f=[p=Math.max(Wf,Math.min($f,p)),v=Math.max(Wf,Math.min($f,v))],m=[o=Math.max(Wf,Math.min($f,o)),a=Math.max(Wf,Math.min($f,a))];!function(t,n,e,r,i,o){var a,u=t[0],f=t[1],c=0,s=1,l=n[0]-u,h=n[1]-f;if(a=e-u,l||!(a>0)){if(a/=l,l<0){if(a<c)return;a<s&&(s=a)}else if(l>0){if(a>s)return;a>c&&(c=a)}if(a=i-u,l||!(a<0)){if(a/=l,l<0){if(a>s)return;a>c&&(c=a)}else if(l>0){if(a<c)return;a<s&&(s=a)}if(a=r-f,h||!(a>0)){if(a/=h,h<0){if(a<c)return;a<s&&(s=a)}else if(h>0){if(a>s)return;a>c&&(c=a)}if(a=o-f,h||!(a<0)){if(a/=h,h<0){if(a>s)return;a>c&&(c=a)}else if(h>0){if(a<c)return;a<s&&(s=a)}return c>0&&(t[0]=u+c*l,t[1]=f+c*h),s<1&&(n[0]=u+s*l,n[1]=f+s*h),!0}}}}}(f,m,t,n,e,r)?u&&(b.lineStart(),b.point(o,a),_=!1):(g||(b.lineStart(),b.point(f[0],f[1])),b.point(m[0],m[1]),u||b.lineEnd(),_=!1)}p=o,v=a,g=u}return x}}var Qf,Jf,Kf,tc=Pa(),nc={sphere:iu,point:iu,lineStart:function(){nc.point=rc,nc.lineEnd=ec},lineEnd:iu,polygonStart:iu,polygonEnd:iu};function ec(){nc.point=nc.lineEnd=iu}function rc(t,n){Qf=t*=Ia,Jf=Qa(n*=Ia),Kf=Ga(n),nc.point=ic}function ic(t,n){t*=Ia;var e=Qa(n*=Ia),r=Ga(n),i=Ha(t-Qf),o=Ga(i),a=r*Qa(i),u=Kf*e-Jf*r*o,f=Jf*e+Kf*r*o;tc.add(Xa(Ka(a*a+u*u),f)),Qf=t,Jf=e,Kf=r}function oc(t){return tc.reset(),su(t,nc),+tc}var ac=[null,null],uc={type:"LineString",coordinates:ac};function fc(t,n){return ac[0]=t,ac[1]=n,oc(uc)}var cc={Feature:function(t,n){return lc(t.geometry,n)},FeatureCollection:function(t,n){for(var e=t.features,r=-1,i=e.length;++r<i;)if(lc(e[r].geometry,n))return!0;return!1}},sc={Sphere:function(){return!0},Point:function(t,n){return hc(t.coordinates,n)},MultiPoint:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)if(hc(e[r],n))return!0;return!1},LineString:function(t,n){return dc(t.coordinates,n)},MultiLineString:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)if(dc(e[r],n))return!0;return!1},Polygon:function(t,n){return pc(t.coordinates,n)},MultiPolygon:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)if(pc(e[r],n))return!0;return!1},GeometryCollection:function(t,n){for(var e=t.geometries,r=-1,i=e.length;++r<i;)if(lc(e[r],n))return!0;return!1}};function lc(t,n){return!(!t||!sc.hasOwnProperty(t.type))&&sc[t.type](t,n)}function hc(t,n){return 0===fc(t,n)}function dc(t,n){var e=fc(t[0],t[1]);return fc(t[0],n)+fc(n,t[1])<=e+Da}function pc(t,n){return!!If(t.map(vc),gc(n))}function vc(t){return(t=t.map(gc)).pop(),t}function gc(t){return[t[0]*Ia,t[1]*Ia]}function yc(t,n,e){var r=g(t,n-Da,e).concat(n);return function(t){return r.map(function(n){return[t,n]})}}function _c(t,n,e){var r=g(t,n-Da,e).concat(n);return function(t){return r.map(function(n){return[n,t]})}}function bc(){var t,n,e,r,i,o,a,u,f,c,s,l,h=10,d=h,p=90,v=360,y=2.5;function _(){return{type:"MultiLineString",coordinates:b()}}function b(){return g(Va(r/p)*p,e,p).map(s).concat(g(Va(u/v)*v,a,v).map(l)).concat(g(Va(n/h)*h,t,h).filter(function(t){return Ha(t%p)>Da}).map(f)).concat(g(Va(o/d)*d,i,d).filter(function(t){return Ha(t%v)>Da}).map(c))}return _.lines=function(){return b().map(function(t){return{type:"LineString",coordinates:t}})},_.outline=function(){return{type:"Polygon",coordinates:[s(r).concat(l(a).slice(1),s(e).reverse().slice(1),l(u).reverse().slice(1))]}},_.extent=function(t){return arguments.length?_.extentMajor(t).extentMinor(t):_.extentMinor()},_.extentMajor=function(t){return arguments.length?(r=+t[0][0],e=+t[1][0],u=+t[0][1],a=+t[1][1],r>e&&(t=r,r=e,e=t),u>a&&(t=u,u=a,a=t),_.precision(y)):[[r,u],[e,a]]},_.extentMinor=function(e){return arguments.length?(n=+e[0][0],t=+e[1][0],o=+e[0][1],i=+e[1][1],n>t&&(e=n,n=t,t=e),o>i&&(e=o,o=i,i=e),_.precision(y)):[[n,o],[t,i]]},_.step=function(t){return arguments.length?_.stepMajor(t).stepMinor(t):_.stepMinor()},_.stepMajor=function(t){return arguments.length?(p=+t[0],v=+t[1],_):[p,v]},_.stepMinor=function(t){return arguments.length?(h=+t[0],d=+t[1],_):[h,d]},_.precision=function(h){return arguments.length?(y=+h,f=yc(o,i,90),c=_c(n,t,y),s=yc(u,a,90),l=_c(r,e,y),_):y},_.extentMajor([[-180,-90+Da],[180,90-Da]]).extentMinor([[-180,-80-Da],[180,80+Da]])}function mc(t){return t}var xc,wc,Mc,Ac,Tc=Pa(),Nc=Pa(),Sc={point:iu,lineStart:iu,lineEnd:iu,polygonStart:function(){Sc.lineStart=Ec,Sc.lineEnd=Pc},polygonEnd:function(){Sc.lineStart=Sc.lineEnd=Sc.point=iu,Tc.add(Ha(Nc)),Nc.reset()},result:function(){var t=Tc/2;return Tc.reset(),t}};function Ec(){Sc.point=kc}function kc(t,n){Sc.point=Cc,xc=Mc=t,wc=Ac=n}function Cc(t,n){Nc.add(Ac*t-Mc*n),Mc=t,Ac=n}function Pc(){Cc(xc,wc)}var zc=1/0,Rc=zc,Lc=-zc,Dc=Lc,Uc={point:function(t,n){t<zc&&(zc=t);t>Lc&&(Lc=t);n<Rc&&(Rc=n);n>Dc&&(Dc=n)},lineStart:iu,lineEnd:iu,polygonStart:iu,polygonEnd:iu,result:function(){var t=[[zc,Rc],[Lc,Dc]];return Lc=Dc=-(Rc=zc=1/0),t}};var qc,Oc,Yc,Bc,Fc=0,Ic=0,Hc=0,jc=0,Xc=0,Gc=0,Vc=0,$c=0,Wc=0,Zc={point:Qc,lineStart:Jc,lineEnd:ns,polygonStart:function(){Zc.lineStart=es,Zc.lineEnd=rs},polygonEnd:function(){Zc.point=Qc,Zc.lineStart=Jc,Zc.lineEnd=ns},result:function(){var t=Wc?[Vc/Wc,$c/Wc]:Gc?[jc/Gc,Xc/Gc]:Hc?[Fc/Hc,Ic/Hc]:[NaN,NaN];return Fc=Ic=Hc=jc=Xc=Gc=Vc=$c=Wc=0,t}};function Qc(t,n){Fc+=t,Ic+=n,++Hc}function Jc(){Zc.point=Kc}function Kc(t,n){Zc.point=ts,Qc(Yc=t,Bc=n)}function ts(t,n){var e=t-Yc,r=n-Bc,i=Ka(e*e+r*r);jc+=i*(Yc+t)/2,Xc+=i*(Bc+n)/2,Gc+=i,Qc(Yc=t,Bc=n)}function ns(){Zc.point=Qc}function es(){Zc.point=is}function rs(){os(qc,Oc)}function is(t,n){Zc.point=os,Qc(qc=Yc=t,Oc=Bc=n)}function os(t,n){var e=t-Yc,r=n-Bc,i=Ka(e*e+r*r);jc+=i*(Yc+t)/2,Xc+=i*(Bc+n)/2,Gc+=i,Vc+=(i=Bc*t-Yc*n)*(Yc+t),$c+=i*(Bc+n),Wc+=3*i,Qc(Yc=t,Bc=n)}function as(t){this._context=t}as.prototype={_radius:4.5,pointRadius:function(t){return this._radius=t,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._context.closePath(),this._point=NaN},point:function(t,n){switch(this._point){case 0:this._context.moveTo(t,n),this._point=1;break;case 1:this._context.lineTo(t,n);break;default:this._context.moveTo(t+this._radius,n),this._context.arc(t,n,this._radius,0,Ba)}},result:iu};var us,fs,cs,ss,ls,hs=Pa(),ds={point:iu,lineStart:function(){ds.point=ps},lineEnd:function(){us&&vs(fs,cs),ds.point=iu},polygonStart:function(){us=!0},polygonEnd:function(){us=null},result:function(){var t=+hs;return hs.reset(),t}};function ps(t,n){ds.point=vs,fs=ss=t,cs=ls=n}function vs(t,n){ss-=t,ls-=n,hs.add(Ka(ss*ss+ls*ls)),ss=t,ls=n}function gs(){this._string=[]}function ys(t){return"m0,"+t+"a"+t+","+t+" 0 1,1 0,"+-2*t+"a"+t+","+t+" 0 1,1 0,"+2*t+"z"}function _s(t){return function(n){var e=new bs;for(var r in t)e[r]=t[r];return e.stream=n,e}}function bs(){}function ms(t,n,e){var r=t.clipExtent&&t.clipExtent();return t.scale(150).translate([0,0]),null!=r&&t.clipExtent(null),su(e,t.stream(Uc)),n(Uc.result()),null!=r&&t.clipExtent(r),t}function xs(t,n,e){return ms(t,function(e){var r=n[1][0]-n[0][0],i=n[1][1]-n[0][1],o=Math.min(r/(e[1][0]-e[0][0]),i/(e[1][1]-e[0][1])),a=+n[0][0]+(r-o*(e[1][0]+e[0][0]))/2,u=+n[0][1]+(i-o*(e[1][1]+e[0][1]))/2;t.scale(150*o).translate([a,u])},e)}function ws(t,n,e){return xs(t,[[0,0],n],e)}function Ms(t,n,e){return ms(t,function(e){var r=+n,i=r/(e[1][0]-e[0][0]),o=(r-i*(e[1][0]+e[0][0]))/2,a=-i*e[0][1];t.scale(150*i).translate([o,a])},e)}function As(t,n,e){return ms(t,function(e){var r=+n,i=r/(e[1][1]-e[0][1]),o=-i*e[0][0],a=(r-i*(e[1][1]+e[0][1]))/2;t.scale(150*i).translate([o,a])},e)}gs.prototype={_radius:4.5,_circle:ys(4.5),pointRadius:function(t){return(t=+t)!==this._radius&&(this._radius=t,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._string.push("Z"),this._point=NaN},point:function(t,n){switch(this._point){case 0:this._string.push("M",t,",",n),this._point=1;break;case 1:this._string.push("L",t,",",n);break;default:null==this._circle&&(this._circle=ys(this._radius)),this._string.push("M",t,",",n,this._circle)}},result:function(){if(this._string.length){var t=this._string.join("");return this._string=[],t}return null}},bs.prototype={constructor:bs,point:function(t,n){this.stream.point(t,n)},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()}};var Ts=16,Ns=Ga(30*Ia);function Ss(t,n){return+n?function(t,n){function e(r,i,o,a,u,f,c,s,l,h,d,p,v,g){var y=c-r,_=s-i,b=y*y+_*_;if(b>4*n&&v--){var m=a+h,x=u+d,w=f+p,M=Ka(m*m+x*x+w*w),A=eu(w/=M),T=Ha(Ha(w)-1)<Da||Ha(o-l)<Da?(o+l)/2:Xa(x,m),N=t(T,A),S=N[0],E=N[1],k=S-r,C=E-i,P=_*k-y*C;(P*P/b>n||Ha((y*k+_*C)/b-.5)>.3||a*h+u*d+f*p<Ns)&&(e(r,i,o,a,u,f,S,E,T,m/=M,x/=M,w,v,g),g.point(S,E),e(S,E,T,m,x,w,c,s,l,h,d,p,v,g))}}return function(n){var r,i,o,a,u,f,c,s,l,h,d,p,v={point:g,lineStart:y,lineEnd:b,polygonStart:function(){n.polygonStart(),v.lineStart=m},polygonEnd:function(){n.polygonEnd(),v.lineStart=y}};function g(e,r){e=t(e,r),n.point(e[0],e[1])}function y(){s=NaN,v.point=_,n.lineStart()}function _(r,i){var o=Au([r,i]),a=t(r,i);e(s,l,c,h,d,p,s=a[0],l=a[1],c=r,h=o[0],d=o[1],p=o[2],Ts,n),n.point(s,l)}function b(){v.point=g,n.lineEnd()}function m(){y(),v.point=x,v.lineEnd=w}function x(t,n){_(r=t,n),i=s,o=l,a=h,u=d,f=p,v.point=_}function w(){e(s,l,c,h,d,p,i,o,r,a,u,f,Ts,n),v.lineEnd=b,b()}return v}}(t,n):function(t){return _s({point:function(n,e){n=t(n,e),this.stream.point(n[0],n[1])}})}(t)}var Es=_s({point:function(t,n){this.stream.point(t*Ia,n*Ia)}});function ks(t,n,e,r){var i=Ga(r),o=Qa(r),a=i*t,u=o*t,f=i/t,c=o/t,s=(o*e-i*n)/t,l=(o*n+i*e)/t;function h(t,r){return[a*t-u*r+n,e-u*t-a*r]}return h.invert=function(t,n){return[f*t-c*n+s,l-c*t-f*n]},h}function Cs(t){return Ps(function(){return t})()}function Ps(t){var n,e,r,i,o,a,u,f,c,s,l=150,h=480,d=250,p=0,v=0,g=0,y=0,_=0,b=0,m=null,x=Gf,w=null,M=mc,A=.5;function T(t){return f(t[0]*Ia,t[1]*Ia)}function N(t){return(t=f.invert(t[0],t[1]))&&[t[0]*Fa,t[1]*Fa]}function S(){var t=ks(l,0,0,b).apply(null,n(p,v)),r=(b?ks:function(t,n,e){function r(r,i){return[n+t*r,e-t*i]}return r.invert=function(r,i){return[(r-n)/t,(e-i)/t]},r})(l,h-t[0],d-t[1],b);return e=kf(g,y,_),u=Sf(n,r),f=Sf(e,u),a=Ss(u,A),E()}function E(){return c=s=null,T}return T.stream=function(t){return c&&s===t?c:c=Es(function(t){return _s({point:function(n,e){var r=t(n,e);return this.stream.point(r[0],r[1])}})}(e)(x(a(M(s=t)))))},T.preclip=function(t){return arguments.length?(x=t,m=void 0,E()):x},T.postclip=function(t){return arguments.length?(M=t,w=r=i=o=null,E()):M},T.clipAngle=function(t){return arguments.length?(x=+t?Vf(m=t*Ia):(m=null,Gf),E()):m*Fa},T.clipExtent=function(t){return arguments.length?(M=null==t?(w=r=i=o=null,mc):Zf(w=+t[0][0],r=+t[0][1],i=+t[1][0],o=+t[1][1]),E()):null==w?null:[[w,r],[i,o]]},T.scale=function(t){return arguments.length?(l=+t,S()):l},T.translate=function(t){return arguments.length?(h=+t[0],d=+t[1],S()):[h,d]},T.center=function(t){return arguments.length?(p=t[0]%360*Ia,v=t[1]%360*Ia,S()):[p*Fa,v*Fa]},T.rotate=function(t){return arguments.length?(g=t[0]%360*Ia,y=t[1]%360*Ia,_=t.length>2?t[2]%360*Ia:0,S()):[g*Fa,y*Fa,_*Fa]},T.angle=function(t){return arguments.length?(b=t%360*Ia,S()):b*Fa},T.precision=function(t){return arguments.length?(a=Ss(u,A=t*t),E()):Ka(A)},T.fitExtent=function(t,n){return xs(T,t,n)},T.fitSize=function(t,n){return ws(T,t,n)},T.fitWidth=function(t,n){return Ms(T,t,n)},T.fitHeight=function(t,n){return As(T,t,n)},function(){return n=t.apply(this,arguments),T.invert=n.invert&&N,S()}}function zs(t){var n=0,e=qa/3,r=Ps(t),i=r(n,e);return i.parallels=function(t){return arguments.length?r(n=t[0]*Ia,e=t[1]*Ia):[n*Fa,e*Fa]},i}function Rs(t,n){var e=Qa(t),r=(e+Qa(n))/2;if(Ha(r)<Da)return function(t){var n=Ga(t);function e(t,e){return[t*n,Qa(e)/n]}return e.invert=function(t,e){return[t/n,eu(e*n)]},e}(t);var i=1+e*(2*r-e),o=Ka(i)/r;function a(t,n){var e=Ka(i-2*r*Qa(n))/r;return[e*Qa(t*=r),o-e*Ga(t)]}return a.invert=function(t,n){var e=o-n;return[Xa(t,Ha(e))/r*Ja(e),eu((i-(t*t+e*e)*r*r)/(2*r))]},a}function Ls(){return zs(Rs).scale(155.424).center([0,33.6442])}function Ds(){return Ls().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}function Us(t){return function(n,e){var r=Ga(n),i=Ga(e),o=t(r*i);return[o*i*Qa(n),o*Qa(e)]}}function qs(t){return function(n,e){var r=Ka(n*n+e*e),i=t(r),o=Qa(i),a=Ga(i);return[Xa(n*o,r*a),eu(r&&e*o/r)]}}var Os=Us(function(t){return Ka(2/(1+t))});Os.invert=qs(function(t){return 2*eu(t/2)});var Ys=Us(function(t){return(t=nu(t))&&t/Qa(t)});function Bs(t,n){return[t,Wa(tu((Oa+n)/2))]}function Fs(t){var n,e,r,i=Cs(t),o=i.center,a=i.scale,u=i.translate,f=i.clipExtent,c=null;function s(){var o=qa*a(),u=i(Rf(i.rotate()).invert([0,0]));return f(null==c?[[u[0]-o,u[1]-o],[u[0]+o,u[1]+o]]:t===Bs?[[Math.max(u[0]-o,c),n],[Math.min(u[0]+o,e),r]]:[[c,Math.max(u[1]-o,n)],[e,Math.min(u[1]+o,r)]])}return i.scale=function(t){return arguments.length?(a(t),s()):a()},i.translate=function(t){return arguments.length?(u(t),s()):u()},i.center=function(t){return arguments.length?(o(t),s()):o()},i.clipExtent=function(t){return arguments.length?(null==t?c=n=e=r=null:(c=+t[0][0],n=+t[0][1],e=+t[1][0],r=+t[1][1]),s()):null==c?null:[[c,n],[e,r]]},s()}function Is(t){return tu((Oa+t)/2)}function Hs(t,n){var e=Ga(t),r=t===n?Qa(t):Wa(e/Ga(n))/Wa(Is(n)/Is(t)),i=e*Za(Is(t),r)/r;if(!r)return Bs;function o(t,n){i>0?n<-Oa+Da&&(n=-Oa+Da):n>Oa-Da&&(n=Oa-Da);var e=i/Za(Is(n),r);return[e*Qa(r*t),i-e*Ga(r*t)]}return o.invert=function(t,n){var e=i-n,o=Ja(r)*Ka(t*t+e*e);return[Xa(t,Ha(e))/r*Ja(e),2*ja(Za(i/o,1/r))-Oa]},o}function js(t,n){return[t,n]}function Xs(t,n){var e=Ga(t),r=t===n?Qa(t):(e-Ga(n))/(n-t),i=e/r+t;if(Ha(r)<Da)return js;function o(t,n){var e=i-n,o=r*t;return[e*Qa(o),i-e*Ga(o)]}return o.invert=function(t,n){var e=i-n;return[Xa(t,Ha(e))/r*Ja(e),i-Ja(r)*Ka(t*t+e*e)]},o}Ys.invert=qs(function(t){return t}),Bs.invert=function(t,n){return[t,2*ja($a(n))-Oa]},js.invert=js;var Gs=1.340264,Vs=-.081106,$s=893e-6,Ws=.003796,Zs=Ka(3)/2;function Qs(t,n){var e=eu(Zs*Qa(n)),r=e*e,i=r*r*r;return[t*Ga(e)/(Zs*(Gs+3*Vs*r+i*(7*$s+9*Ws*r))),e*(Gs+Vs*r+i*($s+Ws*r))]}function Js(t,n){var e=Ga(n),r=Ga(t)*e;return[e*Qa(t)/r,Qa(n)/r]}function Ks(t,n,e,r){return 1===t&&1===n&&0===e&&0===r?mc:_s({point:function(i,o){this.stream.point(i*t+e,o*n+r)}})}function tl(t,n){var e=n*n,r=e*e;return[t*(.8707-.131979*e+r*(r*(.003971*e-.001529*r)-.013791)),n*(1.007226+e*(.015085+r*(.028874*e-.044475-.005916*r)))]}function nl(t,n){return[Ga(n)*Qa(t),Qa(n)]}function el(t,n){var e=Ga(n),r=1+Ga(t)*e;return[e*Qa(t)/r,Qa(n)/r]}function rl(t,n){return[Wa(tu((Oa+n)/2)),-t]}function il(t,n){return t.parent===n.parent?1:2}function ol(t,n){return t+n.x}function al(t,n){return Math.max(t,n.y)}function ul(t){var n=0,e=t.children,r=e&&e.length;if(r)for(;--r>=0;)n+=e[r].value;else n=1;t.value=n}function fl(t,n){var e,r,i,o,a,u=new hl(t),f=+t.value&&(u.value=t.value),c=[u];for(null==n&&(n=cl);e=c.pop();)if(f&&(e.value=+e.data.value),(i=n(e.data))&&(a=i.length))for(e.children=new Array(a),o=a-1;o>=0;--o)c.push(r=e.children[o]=new hl(i[o])),r.parent=e,r.depth=e.depth+1;return u.eachBefore(ll)}function cl(t){return t.children}function sl(t){t.data=t.data.data}function ll(t){var n=0;do{t.height=n}while((t=t.parent)&&t.height<++n)}function hl(t){this.data=t,this.depth=this.height=0,this.parent=null}Qs.invert=function(t,n){for(var e,r=n,i=r*r,o=i*i*i,a=0;a<12&&(o=(i=(r-=e=(r*(Gs+Vs*i+o*($s+Ws*i))-n)/(Gs+3*Vs*i+o*(7*$s+9*Ws*i)))*r)*i*i,!(Ha(e)<Ua));++a);return[Zs*t*(Gs+3*Vs*i+o*(7*$s+9*Ws*i))/Ga(r),eu(Qa(r)/Zs)]},Js.invert=qs(ja),tl.invert=function(t,n){var e,r=n,i=25;do{var o=r*r,a=o*o;r-=e=(r*(1.007226+o*(.015085+a*(.028874*o-.044475-.005916*a)))-n)/(1.007226+o*(.045255+a*(.259866*o-.311325-.005916*11*a)))}while(Ha(e)>Da&&--i>0);return[t/(.8707+(o=r*r)*(o*(o*o*o*(.003971-.001529*o)-.013791)-.131979)),r]},nl.invert=qs(eu),el.invert=qs(function(t){return 2*ja(t)}),rl.invert=function(t,n){return[-n,2*ja($a(t))-Oa]},hl.prototype=fl.prototype={constructor:hl,count:function(){return this.eachAfter(ul)},each:function(t){var n,e,r,i,o=this,a=[o];do{for(n=a.reverse(),a=[];o=n.pop();)if(t(o),e=o.children)for(r=0,i=e.length;r<i;++r)a.push(e[r])}while(a.length);return this},eachAfter:function(t){for(var n,e,r,i=this,o=[i],a=[];i=o.pop();)if(a.push(i),n=i.children)for(e=0,r=n.length;e<r;++e)o.push(n[e]);for(;i=a.pop();)t(i);return this},eachBefore:function(t){for(var n,e,r=this,i=[r];r=i.pop();)if(t(r),n=r.children)for(e=n.length-1;e>=0;--e)i.push(n[e]);return this},sum:function(t){return this.eachAfter(function(n){for(var e=+t(n.data)||0,r=n.children,i=r&&r.length;--i>=0;)e+=r[i].value;n.value=e})},sort:function(t){return this.eachBefore(function(n){n.children&&n.children.sort(t)})},path:function(t){for(var n=this,e=function(t,n){if(t===n)return t;var e=t.ancestors(),r=n.ancestors(),i=null;for(t=e.pop(),n=r.pop();t===n;)i=t,t=e.pop(),n=r.pop();return i}(n,t),r=[n];n!==e;)n=n.parent,r.push(n);for(var i=r.length;t!==e;)r.splice(i,0,t),t=t.parent;return r},ancestors:function(){for(var t=this,n=[t];t=t.parent;)n.push(t);return n},descendants:function(){var t=[];return this.each(function(n){t.push(n)}),t},leaves:function(){var t=[];return this.eachBefore(function(n){n.children||t.push(n)}),t},links:function(){var t=this,n=[];return t.each(function(e){e!==t&&n.push({source:e.parent,target:e})}),n},copy:function(){return fl(this).eachBefore(sl)}};var dl=Array.prototype.slice;function pl(t){for(var n,e,r=0,i=(t=function(t){for(var n,e,r=t.length;r;)e=Math.random()*r--|0,n=t[r],t[r]=t[e],t[e]=n;return t}(dl.call(t))).length,o=[];r<i;)n=t[r],e&&yl(e,n)?++r:(e=bl(o=vl(o,n)),r=0);return e}function vl(t,n){var e,r;if(_l(n,t))return[n];for(e=0;e<t.length;++e)if(gl(n,t[e])&&_l(ml(t[e],n),t))return[t[e],n];for(e=0;e<t.length-1;++e)for(r=e+1;r<t.length;++r)if(gl(ml(t[e],t[r]),n)&&gl(ml(t[e],n),t[r])&&gl(ml(t[r],n),t[e])&&_l(xl(t[e],t[r],n),t))return[t[e],t[r],n];throw new Error}function gl(t,n){var e=t.r-n.r,r=n.x-t.x,i=n.y-t.y;return e<0||e*e<r*r+i*i}function yl(t,n){var e=t.r-n.r+1e-6,r=n.x-t.x,i=n.y-t.y;return e>0&&e*e>r*r+i*i}function _l(t,n){for(var e=0;e<n.length;++e)if(!yl(t,n[e]))return!1;return!0}function bl(t){switch(t.length){case 1:return{x:(n=t[0]).x,y:n.y,r:n.r};case 2:return ml(t[0],t[1]);case 3:return xl(t[0],t[1],t[2])}var n}function ml(t,n){var e=t.x,r=t.y,i=t.r,o=n.x,a=n.y,u=n.r,f=o-e,c=a-r,s=u-i,l=Math.sqrt(f*f+c*c);return{x:(e+o+f/l*s)/2,y:(r+a+c/l*s)/2,r:(l+i+u)/2}}function xl(t,n,e){var r=t.x,i=t.y,o=t.r,a=n.x,u=n.y,f=n.r,c=e.x,s=e.y,l=e.r,h=r-a,d=r-c,p=i-u,v=i-s,g=f-o,y=l-o,_=r*r+i*i-o*o,b=_-a*a-u*u+f*f,m=_-c*c-s*s+l*l,x=d*p-h*v,w=(p*m-v*b)/(2*x)-r,M=(v*g-p*y)/x,A=(d*b-h*m)/(2*x)-i,T=(h*y-d*g)/x,N=M*M+T*T-1,S=2*(o+w*M+A*T),E=w*w+A*A-o*o,k=-(N?(S+Math.sqrt(S*S-4*N*E))/(2*N):E/S);return{x:r+w+M*k,y:i+A+T*k,r:k}}function wl(t,n,e){var r,i,o,a,u=t.x-n.x,f=t.y-n.y,c=u*u+f*f;c?(i=n.r+e.r,i*=i,a=t.r+e.r,i>(a*=a)?(r=(c+a-i)/(2*c),o=Math.sqrt(Math.max(0,a/c-r*r)),e.x=t.x-r*u-o*f,e.y=t.y-r*f+o*u):(r=(c+i-a)/(2*c),o=Math.sqrt(Math.max(0,i/c-r*r)),e.x=n.x+r*u-o*f,e.y=n.y+r*f+o*u)):(e.x=n.x+e.r,e.y=n.y)}function Ml(t,n){var e=t.r+n.r-1e-6,r=n.x-t.x,i=n.y-t.y;return e>0&&e*e>r*r+i*i}function Al(t){var n=t._,e=t.next._,r=n.r+e.r,i=(n.x*e.r+e.x*n.r)/r,o=(n.y*e.r+e.y*n.r)/r;return i*i+o*o}function Tl(t){this._=t,this.next=null,this.previous=null}function Nl(t){if(!(i=t.length))return 0;var n,e,r,i,o,a,u,f,c,s,l;if((n=t[0]).x=0,n.y=0,!(i>1))return n.r;if(e=t[1],n.x=-e.r,e.x=n.r,e.y=0,!(i>2))return n.r+e.r;wl(e,n,r=t[2]),n=new Tl(n),e=new Tl(e),r=new Tl(r),n.next=r.previous=e,e.next=n.previous=r,r.next=e.previous=n;t:for(u=3;u<i;++u){wl(n._,e._,r=t[u]),r=new Tl(r),f=e.next,c=n.previous,s=e._.r,l=n._.r;do{if(s<=l){if(Ml(f._,r._)){e=f,n.next=e,e.previous=n,--u;continue t}s+=f._.r,f=f.next}else{if(Ml(c._,r._)){(n=c).next=e,e.previous=n,--u;continue t}l+=c._.r,c=c.previous}}while(f!==c.next);for(r.previous=n,r.next=e,n.next=e.previous=e=r,o=Al(n);(r=r.next)!==e;)(a=Al(r))<o&&(n=r,o=a);e=n.next}for(n=[e._],r=e;(r=r.next)!==e;)n.push(r._);for(r=pl(n),u=0;u<i;++u)(n=t[u]).x-=r.x,n.y-=r.y;return r.r}function Sl(t){if("function"!=typeof t)throw new Error;return t}function El(){return 0}function kl(t){return function(){return t}}function Cl(t){return Math.sqrt(t.value)}function Pl(t){return function(n){n.children||(n.r=Math.max(0,+t(n)||0))}}function zl(t,n){return function(e){if(r=e.children){var r,i,o,a=r.length,u=t(e)*n||0;if(u)for(i=0;i<a;++i)r[i].r+=u;if(o=Nl(r),u)for(i=0;i<a;++i)r[i].r-=u;e.r=o+u}}}function Rl(t){return function(n){var e=n.parent;n.r*=t,e&&(n.x=e.x+t*n.x,n.y=e.y+t*n.y)}}function Ll(t){t.x0=Math.round(t.x0),t.y0=Math.round(t.y0),t.x1=Math.round(t.x1),t.y1=Math.round(t.y1)}function Dl(t,n,e,r,i){for(var o,a=t.children,u=-1,f=a.length,c=t.value&&(r-n)/t.value;++u<f;)(o=a[u]).y0=e,o.y1=i,o.x0=n,o.x1=n+=o.value*c}var Ul="$",ql={depth:-1},Ol={};function Yl(t){return t.id}function Bl(t){return t.parentId}function Fl(t,n){return t.parent===n.parent?1:2}function Il(t){var n=t.children;return n?n[0]:t.t}function Hl(t){var n=t.children;return n?n[n.length-1]:t.t}function jl(t,n,e){var r=e/(n.i-t.i);n.c-=r,n.s+=e,t.c+=r,n.z+=e,n.m+=e}function Xl(t,n,e){return t.a.parent===n.parent?t.a:e}function Gl(t,n){this._=t,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=n}function Vl(t,n,e,r,i){for(var o,a=t.children,u=-1,f=a.length,c=t.value&&(i-e)/t.value;++u<f;)(o=a[u]).x0=n,o.x1=r,o.y0=e,o.y1=e+=o.value*c}Gl.prototype=Object.create(hl.prototype);var $l=(1+Math.sqrt(5))/2;function Wl(t,n,e,r,i,o){for(var a,u,f,c,s,l,h,d,p,v,g,y=[],_=n.children,b=0,m=0,x=_.length,w=n.value;b<x;){f=i-e,c=o-r;do{s=_[m++].value}while(!s&&m<x);for(l=h=s,g=s*s*(v=Math.max(c/f,f/c)/(w*t)),p=Math.max(h/g,g/l);m<x;++m){if(s+=u=_[m].value,u<l&&(l=u),u>h&&(h=u),g=s*s*v,(d=Math.max(h/g,g/l))>p){s-=u;break}p=d}y.push(a={value:s,dice:f<c,children:_.slice(b,m)}),a.dice?Dl(a,e,r,i,w?r+=c*s/w:o):Vl(a,e,r,w?e+=f*s/w:i,o),w-=s,b=m}return y}var Zl=function t(n){function e(t,e,r,i,o){Wl(n,t,e,r,i,o)}return e.ratio=function(n){return t((n=+n)>1?n:1)},e}($l);var Ql=function t(n){function e(t,e,r,i,o){if((a=t._squarify)&&a.ratio===n)for(var a,u,f,c,s,l=-1,h=a.length,d=t.value;++l<h;){for(f=(u=a[l]).children,c=u.value=0,s=f.length;c<s;++c)u.value+=f[c].value;u.dice?Dl(u,e,r,i,r+=(o-r)*u.value/d):Vl(u,e,r,e+=(i-e)*u.value/d,o),d-=u.value}else t._squarify=a=Wl(n,t,e,r,i,o),a.ratio=n}return e.ratio=function(n){return t((n=+n)>1?n:1)},e}($l);function Jl(t,n){return t[0]-n[0]||t[1]-n[1]}function Kl(t){for(var n,e,r,i=t.length,o=[0,1],a=2,u=2;u<i;++u){for(;a>1&&(n=t[o[a-2]],e=t[o[a-1]],r=t[u],(e[0]-n[0])*(r[1]-n[1])-(e[1]-n[1])*(r[0]-n[0])<=0);)--a;o[a++]=u}return o.slice(0,a)}function th(){return Math.random()}var nh=function t(n){function e(t,e){return t=null==t?0:+t,e=null==e?1:+e,1===arguments.length?(e=t,t=0):e-=t,function(){return n()*e+t}}return e.source=t,e}(th),eh=function t(n){function e(t,e){var r,i;return t=null==t?0:+t,e=null==e?1:+e,function(){var o;if(null!=r)o=r,r=null;else do{r=2*n()-1,o=2*n()-1,i=r*r+o*o}while(!i||i>1);return t+e*o*Math.sqrt(-2*Math.log(i)/i)}}return e.source=t,e}(th),rh=function t(n){function e(){var t=eh.source(n).apply(this,arguments);return function(){return Math.exp(t())}}return e.source=t,e}(th),ih=function t(n){function e(t){return function(){for(var e=0,r=0;r<t;++r)e+=n();return e}}return e.source=t,e}(th),oh=function t(n){function e(t){var e=ih.source(n)(t);return function(){return e()/t}}return e.source=t,e}(th),ah=function t(n){function e(t){return function(){return-Math.log(1-n())/t}}return e.source=t,e}(th),uh=Array.prototype,fh=uh.map,ch=uh.slice,sh={name:"implicit"};function lh(t){var n=Ki(),e=[],r=sh;function i(i){var o=i+"",a=n.get(o);if(!a){if(r!==sh)return r;n.set(o,a=e.push(i))}return t[(a-1)%t.length]}return t=null==t?[]:ch.call(t),i.domain=function(t){if(!arguments.length)return e.slice();e=[],n=Ki();for(var r,o,a=-1,u=t.length;++a<u;)n.has(o=(r=t[a])+"")||n.set(o,e.push(r));return i},i.range=function(n){return arguments.length?(t=ch.call(n),i):t.slice()},i.unknown=function(t){return arguments.length?(r=t,i):r},i.copy=function(){return lh().domain(e).range(t).unknown(r)},i}function hh(){var t,n,e=lh().unknown(void 0),r=e.domain,i=e.range,o=[0,1],a=!1,u=0,f=0,c=.5;function s(){var e=r().length,s=o[1]<o[0],l=o[s-0],h=o[1-s];t=(h-l)/Math.max(1,e-u+2*f),a&&(t=Math.floor(t)),l+=(h-l-t*(e-u))*c,n=t*(1-u),a&&(l=Math.round(l),n=Math.round(n));var d=g(e).map(function(n){return l+t*n});return i(s?d.reverse():d)}return delete e.unknown,e.domain=function(t){return arguments.length?(r(t),s()):r()},e.range=function(t){return arguments.length?(o=[+t[0],+t[1]],s()):o.slice()},e.rangeRound=function(t){return o=[+t[0],+t[1]],a=!0,s()},e.bandwidth=function(){return n},e.step=function(){return t},e.round=function(t){return arguments.length?(a=!!t,s()):a},e.padding=function(t){return arguments.length?(u=f=Math.max(0,Math.min(1,t)),s()):u},e.paddingInner=function(t){return arguments.length?(u=Math.max(0,Math.min(1,t)),s()):u},e.paddingOuter=function(t){return arguments.length?(f=Math.max(0,Math.min(1,t)),s()):f},e.align=function(t){return arguments.length?(c=Math.max(0,Math.min(1,t)),s()):c},e.copy=function(){return hh().domain(r()).range(o).round(a).paddingInner(u).paddingOuter(f).align(c)},s()}function dh(t){return function(){return t}}function ph(t){return+t}var vh=[0,1];function gh(t,n){return(n-=t=+t)?function(e){return(e-t)/n}:dh(n)}function yh(t,n,e,r){var i=t[0],o=t[1],a=n[0],u=n[1];return o<i?(i=e(o,i),a=r(u,a)):(i=e(i,o),a=r(a,u)),function(t){return a(i(t))}}function _h(t,n,e,r){var o=Math.min(t.length,n.length)-1,a=new Array(o),u=new Array(o),f=-1;for(t[o]<t[0]&&(t=t.slice().reverse(),n=n.slice().reverse());++f<o;)a[f]=e(t[f],t[f+1]),u[f]=r(n[f],n[f+1]);return function(n){var e=i(t,n,1,o)-1;return u[e](a[e](n))}}function bh(t,n){return n.domain(t.domain()).range(t.range()).interpolate(t.interpolate()).clamp(t.clamp())}function mh(t,n){var e,r,i,o=vh,a=vh,u=me,f=!1;function c(){return e=Math.min(o.length,a.length)>2?_h:yh,r=i=null,s}function s(n){return(r||(r=e(o,a,f?function(t){return function(n,e){var r=t(n=+n,e=+e);return function(t){return t<=n?0:t>=e?1:r(t)}}}(t):t,u)))(+n)}return s.invert=function(t){return(i||(i=e(a,o,gh,f?function(t){return function(n,e){var r=t(n=+n,e=+e);return function(t){return t<=0?n:t>=1?e:r(t)}}}(n):n)))(+t)},s.domain=function(t){return arguments.length?(o=fh.call(t,ph),c()):o.slice()},s.range=function(t){return arguments.length?(a=ch.call(t),c()):a.slice()},s.rangeRound=function(t){return a=ch.call(t),u=xe,c()},s.clamp=function(t){return arguments.length?(f=!!t,c()):f},s.interpolate=function(t){return arguments.length?(u=t,c()):u},c()}function xh(n){var e=n.domain;return n.ticks=function(t){var n=e();return m(n[0],n[n.length-1],null==t?10:t)},n.tickFormat=function(n,r){return function(n,e,r){var i,o=n[0],a=n[n.length-1],u=w(o,a,null==e?10:e);switch((r=ba(null==r?",f":r)).type){case"s":var f=Math.max(Math.abs(o),Math.abs(a));return null!=r.precision||isNaN(i=ka(u,f))||(r.precision=i),t.formatPrefix(r,f);case"":case"e":case"g":case"p":case"r":null!=r.precision||isNaN(i=Ca(u,Math.max(Math.abs(o),Math.abs(a))))||(r.precision=i-("e"===r.type));break;case"f":case"%":null!=r.precision||isNaN(i=Ea(u))||(r.precision=i-2*("%"===r.type))}return t.format(r)}(e(),n,r)},n.nice=function(t){null==t&&(t=10);var r,i=e(),o=0,a=i.length-1,u=i[o],f=i[a];return f<u&&(r=u,u=f,f=r,r=o,o=a,a=r),(r=x(u,f,t))>0?r=x(u=Math.floor(u/r)*r,f=Math.ceil(f/r)*r,t):r<0&&(r=x(u=Math.ceil(u*r)/r,f=Math.floor(f*r)/r,t)),r>0?(i[o]=Math.floor(u/r)*r,i[a]=Math.ceil(f/r)*r,e(i)):r<0&&(i[o]=Math.ceil(u*r)/r,i[a]=Math.floor(f*r)/r,e(i)),n},n}function wh(t,n){var e,r=0,i=(t=t.slice()).length-1,o=t[r],a=t[i];return a<o&&(e=r,r=i,i=e,e=o,o=a,a=e),t[r]=n.floor(o),t[i]=n.ceil(a),t}function Mh(t,n){return(n=Math.log(n/t))?function(e){return Math.log(e/t)/n}:dh(n)}function Ah(t,n){return t<0?function(e){return-Math.pow(-n,e)*Math.pow(-t,1-e)}:function(e){return Math.pow(n,e)*Math.pow(t,1-e)}}function Th(t){return isFinite(t)?+("1e"+t):t<0?0:t}function Nh(t){return 10===t?Th:t===Math.E?Math.exp:function(n){return Math.pow(t,n)}}function Sh(t){return t===Math.E?Math.log:10===t&&Math.log10||2===t&&Math.log2||(t=Math.log(t),function(n){return Math.log(n)/t})}function Eh(t){return function(n){return-t(-n)}}function kh(t,n){return t<0?-Math.pow(-t,n):Math.pow(t,n)}function Ch(){var t=1,n=mh(function(n,e){return(e=kh(e,t)-(n=kh(n,t)))?function(r){return(kh(r,t)-n)/e}:dh(e)},function(n,e){return e=kh(e,t)-(n=kh(n,t)),function(r){return kh(n+e*r,1/t)}}),e=n.domain;return n.exponent=function(n){return arguments.length?(t=+n,e(e())):t},n.copy=function(){return bh(n,Ch().exponent(t))},xh(n)}var Ph=new Date,zh=new Date;function Rh(t,n,e,r){function i(n){return t(n=new Date(+n)),n}return i.floor=i,i.ceil=function(e){return t(e=new Date(e-1)),n(e,1),t(e),e},i.round=function(t){var n=i(t),e=i.ceil(t);return t-n<e-t?n:e},i.offset=function(t,e){return n(t=new Date(+t),null==e?1:Math.floor(e)),t},i.range=function(e,r,o){var a,u=[];if(e=i.ceil(e),o=null==o?1:Math.floor(o),!(e<r&&o>0))return u;do{u.push(a=new Date(+e)),n(e,o),t(e)}while(a<e&&e<r);return u},i.filter=function(e){return Rh(function(n){if(n>=n)for(;t(n),!e(n);)n.setTime(n-1)},function(t,r){if(t>=t)if(r<0)for(;++r<=0;)for(;n(t,-1),!e(t););else for(;--r>=0;)for(;n(t,1),!e(t););})},e&&(i.count=function(n,r){return Ph.setTime(+n),zh.setTime(+r),t(Ph),t(zh),Math.floor(e(Ph,zh))},i.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?i.filter(r?function(n){return r(n)%t==0}:function(n){return i.count(0,n)%t==0}):i:null}),i}var Lh=Rh(function(){},function(t,n){t.setTime(+t+n)},function(t,n){return n-t});Lh.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?Rh(function(n){n.setTime(Math.floor(n/t)*t)},function(n,e){n.setTime(+n+e*t)},function(n,e){return(e-n)/t}):Lh:null};var Dh=Lh.range,Uh=6e4,qh=6048e5,Oh=Rh(function(t){t.setTime(1e3*Math.floor(t/1e3))},function(t,n){t.setTime(+t+1e3*n)},function(t,n){return(n-t)/1e3},function(t){return t.getUTCSeconds()}),Yh=Oh.range,Bh=Rh(function(t){t.setTime(Math.floor(t/Uh)*Uh)},function(t,n){t.setTime(+t+n*Uh)},function(t,n){return(n-t)/Uh},function(t){return t.getMinutes()}),Fh=Bh.range,Ih=Rh(function(t){var n=t.getTimezoneOffset()*Uh%36e5;n<0&&(n+=36e5),t.setTime(36e5*Math.floor((+t-n)/36e5)+n)},function(t,n){t.setTime(+t+36e5*n)},function(t,n){return(n-t)/36e5},function(t){return t.getHours()}),Hh=Ih.range,jh=Rh(function(t){t.setHours(0,0,0,0)},function(t,n){t.setDate(t.getDate()+n)},function(t,n){return(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*Uh)/864e5},function(t){return t.getDate()-1}),Xh=jh.range;function Gh(t){return Rh(function(n){n.setDate(n.getDate()-(n.getDay()+7-t)%7),n.setHours(0,0,0,0)},function(t,n){t.setDate(t.getDate()+7*n)},function(t,n){return(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*Uh)/qh})}var Vh=Gh(0),$h=Gh(1),Wh=Gh(2),Zh=Gh(3),Qh=Gh(4),Jh=Gh(5),Kh=Gh(6),td=Vh.range,nd=$h.range,ed=Wh.range,rd=Zh.range,id=Qh.range,od=Jh.range,ad=Kh.range,ud=Rh(function(t){t.setDate(1),t.setHours(0,0,0,0)},function(t,n){t.setMonth(t.getMonth()+n)},function(t,n){return n.getMonth()-t.getMonth()+12*(n.getFullYear()-t.getFullYear())},function(t){return t.getMonth()}),fd=ud.range,cd=Rh(function(t){t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,n){t.setFullYear(t.getFullYear()+n)},function(t,n){return n.getFullYear()-t.getFullYear()},function(t){return t.getFullYear()});cd.every=function(t){return isFinite(t=Math.floor(t))&&t>0?Rh(function(n){n.setFullYear(Math.floor(n.getFullYear()/t)*t),n.setMonth(0,1),n.setHours(0,0,0,0)},function(n,e){n.setFullYear(n.getFullYear()+e*t)}):null};var sd=cd.range,ld=Rh(function(t){t.setUTCSeconds(0,0)},function(t,n){t.setTime(+t+n*Uh)},function(t,n){return(n-t)/Uh},function(t){return t.getUTCMinutes()}),hd=ld.range,dd=Rh(function(t){t.setUTCMinutes(0,0,0)},function(t,n){t.setTime(+t+36e5*n)},function(t,n){return(n-t)/36e5},function(t){return t.getUTCHours()}),pd=dd.range,vd=Rh(function(t){t.setUTCHours(0,0,0,0)},function(t,n){t.setUTCDate(t.getUTCDate()+n)},function(t,n){return(n-t)/864e5},function(t){return t.getUTCDate()-1}),gd=vd.range;function yd(t){return Rh(function(n){n.setUTCDate(n.getUTCDate()-(n.getUTCDay()+7-t)%7),n.setUTCHours(0,0,0,0)},function(t,n){t.setUTCDate(t.getUTCDate()+7*n)},function(t,n){return(n-t)/qh})}var _d=yd(0),bd=yd(1),md=yd(2),xd=yd(3),wd=yd(4),Md=yd(5),Ad=yd(6),Td=_d.range,Nd=bd.range,Sd=md.range,Ed=xd.range,kd=wd.range,Cd=Md.range,Pd=Ad.range,zd=Rh(function(t){t.setUTCDate(1),t.setUTCHours(0,0,0,0)},function(t,n){t.setUTCMonth(t.getUTCMonth()+n)},function(t,n){return n.getUTCMonth()-t.getUTCMonth()+12*(n.getUTCFullYear()-t.getUTCFullYear())},function(t){return t.getUTCMonth()}),Rd=zd.range,Ld=Rh(function(t){t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,n){t.setUTCFullYear(t.getUTCFullYear()+n)},function(t,n){return n.getUTCFullYear()-t.getUTCFullYear()},function(t){return t.getUTCFullYear()});Ld.every=function(t){return isFinite(t=Math.floor(t))&&t>0?Rh(function(n){n.setUTCFullYear(Math.floor(n.getUTCFullYear()/t)*t),n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)},function(n,e){n.setUTCFullYear(n.getUTCFullYear()+e*t)}):null};var Dd=Ld.range;function Ud(t){if(0<=t.y&&t.y<100){var n=new Date(-1,t.m,t.d,t.H,t.M,t.S,t.L);return n.setFullYear(t.y),n}return new Date(t.y,t.m,t.d,t.H,t.M,t.S,t.L)}function qd(t){if(0<=t.y&&t.y<100){var n=new Date(Date.UTC(-1,t.m,t.d,t.H,t.M,t.S,t.L));return n.setUTCFullYear(t.y),n}return new Date(Date.UTC(t.y,t.m,t.d,t.H,t.M,t.S,t.L))}function Od(t){return{y:t,m:0,d:1,H:0,M:0,S:0,L:0}}function Yd(t){var n=t.dateTime,e=t.date,r=t.time,i=t.periods,o=t.days,a=t.shortDays,u=t.months,f=t.shortMonths,c=Vd(i),s=$d(i),l=Vd(o),h=$d(o),d=Vd(a),p=$d(a),v=Vd(u),g=$d(u),y=Vd(f),_=$d(f),b={a:function(t){return a[t.getDay()]},A:function(t){return o[t.getDay()]},b:function(t){return f[t.getMonth()]},B:function(t){return u[t.getMonth()]},c:null,d:pp,e:pp,f:bp,H:vp,I:gp,j:yp,L:_p,m:mp,M:xp,p:function(t){return i[+(t.getHours()>=12)]},Q:Wp,s:Zp,S:wp,u:Mp,U:Ap,V:Tp,w:Np,W:Sp,x:null,X:null,y:Ep,Y:kp,Z:Cp,"%":$p},m={a:function(t){return a[t.getUTCDay()]},A:function(t){return o[t.getUTCDay()]},b:function(t){return f[t.getUTCMonth()]},B:function(t){return u[t.getUTCMonth()]},c:null,d:Pp,e:Pp,f:Up,H:zp,I:Rp,j:Lp,L:Dp,m:qp,M:Op,p:function(t){return i[+(t.getUTCHours()>=12)]},Q:Wp,s:Zp,S:Yp,u:Bp,U:Fp,V:Ip,w:Hp,W:jp,x:null,X:null,y:Xp,Y:Gp,Z:Vp,"%":$p},x={a:function(t,n,e){var r=d.exec(n.slice(e));return r?(t.w=p[r[0].toLowerCase()],e+r[0].length):-1},A:function(t,n,e){var r=l.exec(n.slice(e));return r?(t.w=h[r[0].toLowerCase()],e+r[0].length):-1},b:function(t,n,e){var r=y.exec(n.slice(e));return r?(t.m=_[r[0].toLowerCase()],e+r[0].length):-1},B:function(t,n,e){var r=v.exec(n.slice(e));return r?(t.m=g[r[0].toLowerCase()],e+r[0].length):-1},c:function(t,e,r){return A(t,n,e,r)},d:ip,e:ip,f:sp,H:ap,I:ap,j:op,L:cp,m:rp,M:up,p:function(t,n,e){var r=c.exec(n.slice(e));return r?(t.p=s[r[0].toLowerCase()],e+r[0].length):-1},Q:hp,s:dp,S:fp,u:Zd,U:Qd,V:Jd,w:Wd,W:Kd,x:function(t,n,r){return A(t,e,n,r)},X:function(t,n,e){return A(t,r,n,e)},y:np,Y:tp,Z:ep,"%":lp};function w(t,n){return function(e){var r,i,o,a=[],u=-1,f=0,c=t.length;for(e instanceof Date||(e=new Date(+e));++u<c;)37===t.charCodeAt(u)&&(a.push(t.slice(f,u)),null!=(i=Fd[r=t.charAt(++u)])?r=t.charAt(++u):i="e"===r?" ":"0",(o=n[r])&&(r=o(e,i)),a.push(r),f=u+1);return a.push(t.slice(f,u)),a.join("")}}function M(t,n){return function(e){var r,i,o=Od(1900);if(A(o,t,e+="",0)!=e.length)return null;if("Q"in o)return new Date(o.Q);if("p"in o&&(o.H=o.H%12+12*o.p),"V"in o){if(o.V<1||o.V>53)return null;"w"in o||(o.w=1),"Z"in o?(i=(r=qd(Od(o.y))).getUTCDay(),r=i>4||0===i?bd.ceil(r):bd(r),r=vd.offset(r,7*(o.V-1)),o.y=r.getUTCFullYear(),o.m=r.getUTCMonth(),o.d=r.getUTCDate()+(o.w+6)%7):(i=(r=n(Od(o.y))).getDay(),r=i>4||0===i?$h.ceil(r):$h(r),r=jh.offset(r,7*(o.V-1)),o.y=r.getFullYear(),o.m=r.getMonth(),o.d=r.getDate()+(o.w+6)%7)}else("W"in o||"U"in o)&&("w"in o||(o.w="u"in o?o.u%7:"W"in o?1:0),i="Z"in o?qd(Od(o.y)).getUTCDay():n(Od(o.y)).getDay(),o.m=0,o.d="W"in o?(o.w+6)%7+7*o.W-(i+5)%7:o.w+7*o.U-(i+6)%7);return"Z"in o?(o.H+=o.Z/100|0,o.M+=o.Z%100,qd(o)):n(o)}}function A(t,n,e,r){for(var i,o,a=0,u=n.length,f=e.length;a<u;){if(r>=f)return-1;if(37===(i=n.charCodeAt(a++))){if(i=n.charAt(a++),!(o=x[i in Fd?n.charAt(a++):i])||(r=o(t,e,r))<0)return-1}else if(i!=e.charCodeAt(r++))return-1}return r}return b.x=w(e,b),b.X=w(r,b),b.c=w(n,b),m.x=w(e,m),m.X=w(r,m),m.c=w(n,m),{format:function(t){var n=w(t+="",b);return n.toString=function(){return t},n},parse:function(t){var n=M(t+="",Ud);return n.toString=function(){return t},n},utcFormat:function(t){var n=w(t+="",m);return n.toString=function(){return t},n},utcParse:function(t){var n=M(t,qd);return n.toString=function(){return t},n}}}var Bd,Fd={"-":"",_:" ",0:"0"},Id=/^\s*\d+/,Hd=/^%/,jd=/[\\^$*+?|[\]().{}]/g;function Xd(t,n,e){var r=t<0?"-":"",i=(r?-t:t)+"",o=i.length;return r+(o<e?new Array(e-o+1).join(n)+i:i)}function Gd(t){return t.replace(jd,"\\$&")}function Vd(t){return new RegExp("^(?:"+t.map(Gd).join("|")+")","i")}function $d(t){for(var n={},e=-1,r=t.length;++e<r;)n[t[e].toLowerCase()]=e;return n}function Wd(t,n,e){var r=Id.exec(n.slice(e,e+1));return r?(t.w=+r[0],e+r[0].length):-1}function Zd(t,n,e){var r=Id.exec(n.slice(e,e+1));return r?(t.u=+r[0],e+r[0].length):-1}function Qd(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.U=+r[0],e+r[0].length):-1}function Jd(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.V=+r[0],e+r[0].length):-1}function Kd(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.W=+r[0],e+r[0].length):-1}function tp(t,n,e){var r=Id.exec(n.slice(e,e+4));return r?(t.y=+r[0],e+r[0].length):-1}function np(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.y=+r[0]+(+r[0]>68?1900:2e3),e+r[0].length):-1}function ep(t,n,e){var r=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(n.slice(e,e+6));return r?(t.Z=r[1]?0:-(r[2]+(r[3]||"00")),e+r[0].length):-1}function rp(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.m=r[0]-1,e+r[0].length):-1}function ip(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.d=+r[0],e+r[0].length):-1}function op(t,n,e){var r=Id.exec(n.slice(e,e+3));return r?(t.m=0,t.d=+r[0],e+r[0].length):-1}function ap(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.H=+r[0],e+r[0].length):-1}function up(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.M=+r[0],e+r[0].length):-1}function fp(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.S=+r[0],e+r[0].length):-1}function cp(t,n,e){var r=Id.exec(n.slice(e,e+3));return r?(t.L=+r[0],e+r[0].length):-1}function sp(t,n,e){var r=Id.exec(n.slice(e,e+6));return r?(t.L=Math.floor(r[0]/1e3),e+r[0].length):-1}function lp(t,n,e){var r=Hd.exec(n.slice(e,e+1));return r?e+r[0].length:-1}function hp(t,n,e){var r=Id.exec(n.slice(e));return r?(t.Q=+r[0],e+r[0].length):-1}function dp(t,n,e){var r=Id.exec(n.slice(e));return r?(t.Q=1e3*+r[0],e+r[0].length):-1}function pp(t,n){return Xd(t.getDate(),n,2)}function vp(t,n){return Xd(t.getHours(),n,2)}function gp(t,n){return Xd(t.getHours()%12||12,n,2)}function yp(t,n){return Xd(1+jh.count(cd(t),t),n,3)}function _p(t,n){return Xd(t.getMilliseconds(),n,3)}function bp(t,n){return _p(t,n)+"000"}function mp(t,n){return Xd(t.getMonth()+1,n,2)}function xp(t,n){return Xd(t.getMinutes(),n,2)}function wp(t,n){return Xd(t.getSeconds(),n,2)}function Mp(t){var n=t.getDay();return 0===n?7:n}function Ap(t,n){return Xd(Vh.count(cd(t),t),n,2)}function Tp(t,n){var e=t.getDay();return t=e>=4||0===e?Qh(t):Qh.ceil(t),Xd(Qh.count(cd(t),t)+(4===cd(t).getDay()),n,2)}function Np(t){return t.getDay()}function Sp(t,n){return Xd($h.count(cd(t),t),n,2)}function Ep(t,n){return Xd(t.getFullYear()%100,n,2)}function kp(t,n){return Xd(t.getFullYear()%1e4,n,4)}function Cp(t){var n=t.getTimezoneOffset();return(n>0?"-":(n*=-1,"+"))+Xd(n/60|0,"0",2)+Xd(n%60,"0",2)}function Pp(t,n){return Xd(t.getUTCDate(),n,2)}function zp(t,n){return Xd(t.getUTCHours(),n,2)}function Rp(t,n){return Xd(t.getUTCHours()%12||12,n,2)}function Lp(t,n){return Xd(1+vd.count(Ld(t),t),n,3)}function Dp(t,n){return Xd(t.getUTCMilliseconds(),n,3)}function Up(t,n){return Dp(t,n)+"000"}function qp(t,n){return Xd(t.getUTCMonth()+1,n,2)}function Op(t,n){return Xd(t.getUTCMinutes(),n,2)}function Yp(t,n){return Xd(t.getUTCSeconds(),n,2)}function Bp(t){var n=t.getUTCDay();return 0===n?7:n}function Fp(t,n){return Xd(_d.count(Ld(t),t),n,2)}function Ip(t,n){var e=t.getUTCDay();return t=e>=4||0===e?wd(t):wd.ceil(t),Xd(wd.count(Ld(t),t)+(4===Ld(t).getUTCDay()),n,2)}function Hp(t){return t.getUTCDay()}function jp(t,n){return Xd(bd.count(Ld(t),t),n,2)}function Xp(t,n){return Xd(t.getUTCFullYear()%100,n,2)}function Gp(t,n){return Xd(t.getUTCFullYear()%1e4,n,4)}function Vp(){return"+0000"}function $p(){return"%"}function Wp(t){return+t}function Zp(t){return Math.floor(+t/1e3)}function Qp(n){return Bd=Yd(n),t.timeFormat=Bd.format,t.timeParse=Bd.parse,t.utcFormat=Bd.utcFormat,t.utcParse=Bd.utcParse,Bd}Qp({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 Jp=Date.prototype.toISOString?function(t){return t.toISOString()}:t.utcFormat("%Y-%m-%dT%H:%M:%S.%LZ");var Kp=+new Date("2000-01-01T00:00:00.000Z")?function(t){var n=new Date(t);return isNaN(n)?null:n}:t.utcParse("%Y-%m-%dT%H:%M:%S.%LZ"),tv=1e3,nv=60*tv,ev=60*nv,rv=24*ev,iv=7*rv,ov=30*rv,av=365*rv;function uv(t){return new Date(t)}function fv(t){return t instanceof Date?+t:+new Date(+t)}function cv(t,n,r,i,o,a,u,f,c){var s=mh(gh,ve),l=s.invert,h=s.domain,d=c(".%L"),p=c(":%S"),v=c("%I:%M"),g=c("%I %p"),y=c("%a %d"),_=c("%b %d"),b=c("%B"),m=c("%Y"),x=[[u,1,tv],[u,5,5*tv],[u,15,15*tv],[u,30,30*tv],[a,1,nv],[a,5,5*nv],[a,15,15*nv],[a,30,30*nv],[o,1,ev],[o,3,3*ev],[o,6,6*ev],[o,12,12*ev],[i,1,rv],[i,2,2*rv],[r,1,iv],[n,1,ov],[n,3,3*ov],[t,1,av]];function M(e){return(u(e)<e?d:a(e)<e?p:o(e)<e?v:i(e)<e?g:n(e)<e?r(e)<e?y:_:t(e)<e?b:m)(e)}function A(n,r,i,o){if(null==n&&(n=10),"number"==typeof n){var a=Math.abs(i-r)/n,u=e(function(t){return t[2]}).right(x,a);u===x.length?(o=w(r/av,i/av,n),n=t):u?(o=(u=x[a/x[u-1][2]<x[u][2]/a?u-1:u])[1],n=u[0]):(o=Math.max(w(r,i,n),1),n=f)}return null==o?n:n.every(o)}return s.invert=function(t){return new Date(l(t))},s.domain=function(t){return arguments.length?h(fh.call(t,fv)):h().map(uv)},s.ticks=function(t,n){var e,r=h(),i=r[0],o=r[r.length-1],a=o<i;return a&&(e=i,i=o,o=e),e=(e=A(t,i,o,n))?e.range(i,o+1):[],a?e.reverse():e},s.tickFormat=function(t,n){return null==n?M:c(n)},s.nice=function(t,n){var e=h();return(t=A(t,e[0],e[e.length-1],n))?h(wh(e,t)):s},s.copy=function(){return bh(s,cv(t,n,r,i,o,a,u,f,c))},s}function sv(t){for(var n=t.length/6|0,e=new Array(n),r=0;r<n;)e[r]="#"+t.slice(6*r,6*++r);return e}var lv=sv("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"),hv=sv("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666"),dv=sv("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666"),pv=sv("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928"),vv=sv("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2"),gv=sv("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc"),yv=sv("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999"),_v=sv("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3"),bv=sv("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f");function mv(t){return le(t[t.length-1])}var xv=new Array(3).concat("d8b365f5f5f55ab4ac","a6611adfc27d80cdc1018571","a6611adfc27df5f5f580cdc1018571","8c510ad8b365f6e8c3c7eae55ab4ac01665e","8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e","8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e","8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e","5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30","5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(sv),wv=mv(xv),Mv=new Array(3).concat("af8dc3f7f7f77fbf7b","7b3294c2a5cfa6dba0008837","7b3294c2a5cff7f7f7a6dba0008837","762a83af8dc3e7d4e8d9f0d37fbf7b1b7837","762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837","762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837","762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837","40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b","40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(sv),Av=mv(Mv),Tv=new Array(3).concat("e9a3c9f7f7f7a1d76a","d01c8bf1b6dab8e1864dac26","d01c8bf1b6daf7f7f7b8e1864dac26","c51b7de9a3c9fde0efe6f5d0a1d76a4d9221","c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221","c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221","c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221","8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419","8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(sv),Nv=mv(Tv),Sv=new Array(3).concat("998ec3f7f7f7f1a340","5e3c99b2abd2fdb863e66101","5e3c99b2abd2f7f7f7fdb863e66101","542788998ec3d8daebfee0b6f1a340b35806","542788998ec3d8daebf7f7f7fee0b6f1a340b35806","5427888073acb2abd2d8daebfee0b6fdb863e08214b35806","5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806","2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08","2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(sv),Ev=mv(Sv),kv=new Array(3).concat("ef8a62f7f7f767a9cf","ca0020f4a58292c5de0571b0","ca0020f4a582f7f7f792c5de0571b0","b2182bef8a62fddbc7d1e5f067a9cf2166ac","b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac","b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac","b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac","67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061","67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(sv),Cv=mv(kv),Pv=new Array(3).concat("ef8a62ffffff999999","ca0020f4a582bababa404040","ca0020f4a582ffffffbababa404040","b2182bef8a62fddbc7e0e0e09999994d4d4d","b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d","b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d","b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d","67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a","67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(sv),zv=mv(Pv),Rv=new Array(3).concat("fc8d59ffffbf91bfdb","d7191cfdae61abd9e92c7bb6","d7191cfdae61ffffbfabd9e92c7bb6","d73027fc8d59fee090e0f3f891bfdb4575b4","d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4","d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4","d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4","a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695","a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(sv),Lv=mv(Rv),Dv=new Array(3).concat("fc8d59ffffbf91cf60","d7191cfdae61a6d96a1a9641","d7191cfdae61ffffbfa6d96a1a9641","d73027fc8d59fee08bd9ef8b91cf601a9850","d73027fc8d59fee08bffffbfd9ef8b91cf601a9850","d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850","d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850","a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837","a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(sv),Uv=mv(Dv),qv=new Array(3).concat("fc8d59ffffbf99d594","d7191cfdae61abdda42b83ba","d7191cfdae61ffffbfabdda42b83ba","d53e4ffc8d59fee08be6f59899d5943288bd","d53e4ffc8d59fee08bffffbfe6f59899d5943288bd","d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd","d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd","9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2","9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(sv),Ov=mv(qv),Yv=new Array(3).concat("e5f5f999d8c92ca25f","edf8fbb2e2e266c2a4238b45","edf8fbb2e2e266c2a42ca25f006d2c","edf8fbccece699d8c966c2a42ca25f006d2c","edf8fbccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(sv),Bv=mv(Yv),Fv=new Array(3).concat("e0ecf49ebcda8856a7","edf8fbb3cde38c96c688419d","edf8fbb3cde38c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(sv),Iv=mv(Fv),Hv=new Array(3).concat("e0f3dba8ddb543a2ca","f0f9e8bae4bc7bccc42b8cbe","f0f9e8bae4bc7bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(sv),jv=mv(Hv),Xv=new Array(3).concat("fee8c8fdbb84e34a33","fef0d9fdcc8afc8d59d7301f","fef0d9fdcc8afc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(sv),Gv=mv(Xv),Vv=new Array(3).concat("ece2f0a6bddb1c9099","f6eff7bdc9e167a9cf02818a","f6eff7bdc9e167a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(sv),$v=mv(Vv),Wv=new Array(3).concat("ece7f2a6bddb2b8cbe","f1eef6bdc9e174a9cf0570b0","f1eef6bdc9e174a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(sv),Zv=mv(Wv),Qv=new Array(3).concat("e7e1efc994c7dd1c77","f1eef6d7b5d8df65b0ce1256","f1eef6d7b5d8df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(sv),Jv=mv(Qv),Kv=new Array(3).concat("fde0ddfa9fb5c51b8a","feebe2fbb4b9f768a1ae017e","feebe2fbb4b9f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(sv),tg=mv(Kv),ng=new Array(3).concat("edf8b17fcdbb2c7fb8","ffffcca1dab441b6c4225ea8","ffffcca1dab441b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(sv),eg=mv(ng),rg=new Array(3).concat("f7fcb9addd8e31a354","ffffccc2e69978c679238443","ffffccc2e69978c67931a354006837","ffffccd9f0a3addd8e78c67931a354006837","ffffccd9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(sv),ig=mv(rg),og=new Array(3).concat("fff7bcfec44fd95f0e","ffffd4fed98efe9929cc4c02","ffffd4fed98efe9929d95f0e993404","ffffd4fee391fec44ffe9929d95f0e993404","ffffd4fee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(sv),ag=mv(og),ug=new Array(3).concat("ffeda0feb24cf03b20","ffffb2fecc5cfd8d3ce31a1c","ffffb2fecc5cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(sv),fg=mv(ug),cg=new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(sv),sg=mv(cg),lg=new Array(3).concat("e5f5e0a1d99b31a354","edf8e9bae4b374c476238b45","edf8e9bae4b374c47631a354006d2c","edf8e9c7e9c0a1d99b74c47631a354006d2c","edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(sv),hg=mv(lg),dg=new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(sv),pg=mv(dg),vg=new Array(3).concat("efedf5bcbddc756bb1","f2f0f7cbc9e29e9ac86a51a3","f2f0f7cbc9e29e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(sv),gg=mv(vg),yg=new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(sv),_g=mv(yg),bg=new Array(3).concat("fee6cefdae6be6550d","feeddefdbe85fd8d3cd94701","feeddefdbe85fd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(sv),mg=mv(bg),xg=Ge(Kn(300,.5,0),Kn(-240,.5,1)),wg=Ge(Kn(-100,.75,.35),Kn(80,1.5,.8)),Mg=Ge(Kn(260,.75,.35),Kn(80,1.5,.8)),Ag=Kn();var Tg=bn(),Ng=Math.PI/3,Sg=2*Math.PI/3;function Eg(t){var n=t.length;return function(e){return t[Math.max(0,Math.min(n-1,Math.floor(e*n)))]}}var kg=Eg(sv("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),Cg=Eg(sv("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),Pg=Eg(sv("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),zg=Eg(sv("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"));function Rg(t){return function(){return t}}var Lg=Math.abs,Dg=Math.atan2,Ug=Math.cos,qg=Math.max,Og=Math.min,Yg=Math.sin,Bg=Math.sqrt,Fg=1e-12,Ig=Math.PI,Hg=Ig/2,jg=2*Ig;function Xg(t){return t>=1?Hg:t<=-1?-Hg:Math.asin(t)}function Gg(t){return t.innerRadius}function Vg(t){return t.outerRadius}function $g(t){return t.startAngle}function Wg(t){return t.endAngle}function Zg(t){return t&&t.padAngle}function Qg(t,n,e,r,i,o,a){var u=t-e,f=n-r,c=(a?o:-o)/Bg(u*u+f*f),s=c*f,l=-c*u,h=t+s,d=n+l,p=e+s,v=r+l,g=(h+p)/2,y=(d+v)/2,_=p-h,b=v-d,m=_*_+b*b,x=i-o,w=h*v-p*d,M=(b<0?-1:1)*Bg(qg(0,x*x*m-w*w)),A=(w*b-_*M)/m,T=(-w*_-b*M)/m,N=(w*b+_*M)/m,S=(-w*_+b*M)/m,E=A-g,k=T-y,C=N-g,P=S-y;return E*E+k*k>C*C+P*P&&(A=N,T=S),{cx:A,cy:T,x01:-s,y01:-l,x11:A*(i/x-1),y11:T*(i/x-1)}}function Jg(t){this._context=t}function Kg(t){return new Jg(t)}function ty(t){return t[0]}function ny(t){return t[1]}function ey(){var t=ty,n=ny,e=Rg(!0),r=null,i=Kg,o=null;function a(a){var u,f,c,s=a.length,l=!1;for(null==r&&(o=i(c=Gi())),u=0;u<=s;++u)!(u<s&&e(f=a[u],u,a))===l&&((l=!l)?o.lineStart():o.lineEnd()),l&&o.point(+t(f,u,a),+n(f,u,a));if(c)return o=null,c+""||null}return a.x=function(n){return arguments.length?(t="function"==typeof n?n:Rg(+n),a):t},a.y=function(t){return arguments.length?(n="function"==typeof t?t:Rg(+t),a):n},a.defined=function(t){return arguments.length?(e="function"==typeof t?t:Rg(!!t),a):e},a.curve=function(t){return arguments.length?(i=t,null!=r&&(o=i(r)),a):i},a.context=function(t){return arguments.length?(null==t?r=o=null:o=i(r=t),a):r},a}function ry(){var t=ty,n=null,e=Rg(0),r=ny,i=Rg(!0),o=null,a=Kg,u=null;function f(f){var c,s,l,h,d,p=f.length,v=!1,g=new Array(p),y=new Array(p);for(null==o&&(u=a(d=Gi())),c=0;c<=p;++c){if(!(c<p&&i(h=f[c],c,f))===v)if(v=!v)s=c,u.areaStart(),u.lineStart();else{for(u.lineEnd(),u.lineStart(),l=c-1;l>=s;--l)u.point(g[l],y[l]);u.lineEnd(),u.areaEnd()}v&&(g[c]=+t(h,c,f),y[c]=+e(h,c,f),u.point(n?+n(h,c,f):g[c],r?+r(h,c,f):y[c]))}if(d)return u=null,d+""||null}function c(){return ey().defined(i).curve(a).context(o)}return f.x=function(e){return arguments.length?(t="function"==typeof e?e:Rg(+e),n=null,f):t},f.x0=function(n){return arguments.length?(t="function"==typeof n?n:Rg(+n),f):t},f.x1=function(t){return arguments.length?(n=null==t?null:"function"==typeof t?t:Rg(+t),f):n},f.y=function(t){return arguments.length?(e="function"==typeof t?t:Rg(+t),r=null,f):e},f.y0=function(t){return arguments.length?(e="function"==typeof t?t:Rg(+t),f):e},f.y1=function(t){return arguments.length?(r=null==t?null:"function"==typeof t?t:Rg(+t),f):r},f.lineX0=f.lineY0=function(){return c().x(t).y(e)},f.lineY1=function(){return c().x(t).y(r)},f.lineX1=function(){return c().x(n).y(e)},f.defined=function(t){return arguments.length?(i="function"==typeof t?t:Rg(!!t),f):i},f.curve=function(t){return arguments.length?(a=t,null!=o&&(u=a(o)),f):a},f.context=function(t){return arguments.length?(null==t?o=u=null:u=a(o=t),f):o},f}function iy(t,n){return n<t?-1:n>t?1:n>=t?0:NaN}function oy(t){return t}Jg.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:this._context.lineTo(t,n)}}};var ay=fy(Kg);function uy(t){this._curve=t}function fy(t){function n(n){return new uy(t(n))}return n._curve=t,n}function cy(t){var n=t.curve;return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t.curve=function(t){return arguments.length?n(fy(t)):n()._curve},t}function sy(){return cy(ey().curve(ay))}function ly(){var t=ry().curve(ay),n=t.curve,e=t.lineX0,r=t.lineX1,i=t.lineY0,o=t.lineY1;return t.angle=t.x,delete t.x,t.startAngle=t.x0,delete t.x0,t.endAngle=t.x1,delete t.x1,t.radius=t.y,delete t.y,t.innerRadius=t.y0,delete t.y0,t.outerRadius=t.y1,delete t.y1,t.lineStartAngle=function(){return cy(e())},delete t.lineX0,t.lineEndAngle=function(){return cy(r())},delete t.lineX1,t.lineInnerRadius=function(){return cy(i())},delete t.lineY0,t.lineOuterRadius=function(){return cy(o())},delete t.lineY1,t.curve=function(t){return arguments.length?n(fy(t)):n()._curve},t}function hy(t,n){return[(n=+n)*Math.cos(t-=Math.PI/2),n*Math.sin(t)]}uy.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(t,n){this._curve.point(n*Math.sin(t),n*-Math.cos(t))}};var dy=Array.prototype.slice;function py(t){return t.source}function vy(t){return t.target}function gy(t){var n=py,e=vy,r=ty,i=ny,o=null;function a(){var a,u=dy.call(arguments),f=n.apply(this,u),c=e.apply(this,u);if(o||(o=a=Gi()),t(o,+r.apply(this,(u[0]=f,u)),+i.apply(this,u),+r.apply(this,(u[0]=c,u)),+i.apply(this,u)),a)return o=null,a+""||null}return a.source=function(t){return arguments.length?(n=t,a):n},a.target=function(t){return arguments.length?(e=t,a):e},a.x=function(t){return arguments.length?(r="function"==typeof t?t:Rg(+t),a):r},a.y=function(t){return arguments.length?(i="function"==typeof t?t:Rg(+t),a):i},a.context=function(t){return arguments.length?(o=null==t?null:t,a):o},a}function yy(t,n,e,r,i){t.moveTo(n,e),t.bezierCurveTo(n=(n+r)/2,e,n,i,r,i)}function _y(t,n,e,r,i){t.moveTo(n,e),t.bezierCurveTo(n,e=(e+i)/2,r,e,r,i)}function by(t,n,e,r,i){var o=hy(n,e),a=hy(n,e=(e+i)/2),u=hy(r,e),f=hy(r,i);t.moveTo(o[0],o[1]),t.bezierCurveTo(a[0],a[1],u[0],u[1],f[0],f[1])}var my={draw:function(t,n){var e=Math.sqrt(n/Ig);t.moveTo(e,0),t.arc(0,0,e,0,jg)}},xy={draw:function(t,n){var e=Math.sqrt(n/5)/2;t.moveTo(-3*e,-e),t.lineTo(-e,-e),t.lineTo(-e,-3*e),t.lineTo(e,-3*e),t.lineTo(e,-e),t.lineTo(3*e,-e),t.lineTo(3*e,e),t.lineTo(e,e),t.lineTo(e,3*e),t.lineTo(-e,3*e),t.lineTo(-e,e),t.lineTo(-3*e,e),t.closePath()}},wy=Math.sqrt(1/3),My=2*wy,Ay={draw:function(t,n){var e=Math.sqrt(n/My),r=e*wy;t.moveTo(0,-e),t.lineTo(r,0),t.lineTo(0,e),t.lineTo(-r,0),t.closePath()}},Ty=Math.sin(Ig/10)/Math.sin(7*Ig/10),Ny=Math.sin(jg/10)*Ty,Sy=-Math.cos(jg/10)*Ty,Ey={draw:function(t,n){var e=Math.sqrt(.8908130915292852*n),r=Ny*e,i=Sy*e;t.moveTo(0,-e),t.lineTo(r,i);for(var o=1;o<5;++o){var a=jg*o/5,u=Math.cos(a),f=Math.sin(a);t.lineTo(f*e,-u*e),t.lineTo(u*r-f*i,f*r+u*i)}t.closePath()}},ky={draw:function(t,n){var e=Math.sqrt(n),r=-e/2;t.rect(r,r,e,e)}},Cy=Math.sqrt(3),Py={draw:function(t,n){var e=-Math.sqrt(n/(3*Cy));t.moveTo(0,2*e),t.lineTo(-Cy*e,-e),t.lineTo(Cy*e,-e),t.closePath()}},zy=Math.sqrt(3)/2,Ry=1/Math.sqrt(12),Ly=3*(Ry/2+1),Dy={draw:function(t,n){var e=Math.sqrt(n/Ly),r=e/2,i=e*Ry,o=r,a=e*Ry+e,u=-o,f=a;t.moveTo(r,i),t.lineTo(o,a),t.lineTo(u,f),t.lineTo(-.5*r-zy*i,zy*r+-.5*i),t.lineTo(-.5*o-zy*a,zy*o+-.5*a),t.lineTo(-.5*u-zy*f,zy*u+-.5*f),t.lineTo(-.5*r+zy*i,-.5*i-zy*r),t.lineTo(-.5*o+zy*a,-.5*a-zy*o),t.lineTo(-.5*u+zy*f,-.5*f-zy*u),t.closePath()}},Uy=[my,xy,Ay,ky,Ey,Py,Dy];function qy(){}function Oy(t,n,e){t._context.bezierCurveTo((2*t._x0+t._x1)/3,(2*t._y0+t._y1)/3,(t._x0+2*t._x1)/3,(t._y0+2*t._y1)/3,(t._x0+4*t._x1+n)/6,(t._y0+4*t._y1+e)/6)}function Yy(t){this._context=t}function By(t){this._context=t}function Fy(t){this._context=t}function Iy(t,n){this._basis=new Yy(t),this._beta=n}Yy.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:Oy(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);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:Oy(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},By.prototype={areaStart:qy,areaEnd:qy,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)}},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._x2=t,this._y2=n;break;case 1:this._point=2,this._x3=t,this._y3=n;break;case 2:this._point=3,this._x4=t,this._y4=n,this._context.moveTo((this._x0+4*this._x1+t)/6,(this._y0+4*this._y1+n)/6);break;default:Oy(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},Fy.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||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var e=(this._x0+4*this._x1+t)/6,r=(this._y0+4*this._y1+n)/6;this._line?this._context.lineTo(e,r):this._context.moveTo(e,r);break;case 3:this._point=4;default:Oy(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},Iy.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var t=this._x,n=this._y,e=t.length-1;if(e>0)for(var r,i=t[0],o=n[0],a=t[e]-i,u=n[e]-o,f=-1;++f<=e;)r=f/e,this._basis.point(this._beta*t[f]+(1-this._beta)*(i+r*a),this._beta*n[f]+(1-this._beta)*(o+r*u));this._x=this._y=null,this._basis.lineEnd()},point:function(t,n){this._x.push(+t),this._y.push(+n)}};var Hy=function t(n){function e(t){return 1===n?new Yy(t):new Iy(t,n)}return e.beta=function(n){return t(+n)},e}(.85);function jy(t,n,e){t._context.bezierCurveTo(t._x1+t._k*(t._x2-t._x0),t._y1+t._k*(t._y2-t._y0),t._x2+t._k*(t._x1-n),t._y2+t._k*(t._y1-e),t._x2,t._y2)}function Xy(t,n){this._context=t,this._k=(1-n)/6}Xy.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:jy(this,this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2,this._x1=t,this._y1=n;break;case 2:this._point=3;default:jy(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Gy=function t(n){function e(t){return new Xy(t,n)}return e.tension=function(n){return t(+n)},e}(0);function Vy(t,n){this._context=t,this._k=(1-n)/6}Vy.prototype={areaStart:qy,areaEnd:qy,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)}},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._x3=t,this._y3=n;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=n);break;case 2:this._point=3,this._x5=t,this._y5=n;break;default:jy(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var $y=function t(n){function e(t){return new Vy(t,n)}return e.tension=function(n){return t(+n)},e}(0);function Wy(t,n){this._context=t,this._k=(1-n)/6}Wy.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||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,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:jy(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Zy=function t(n){function e(t){return new Wy(t,n)}return e.tension=function(n){return t(+n)},e}(0);function Qy(t,n,e){var r=t._x1,i=t._y1,o=t._x2,a=t._y2;if(t._l01_a>Fg){var u=2*t._l01_2a+3*t._l01_a*t._l12_a+t._l12_2a,f=3*t._l01_a*(t._l01_a+t._l12_a);r=(r*u-t._x0*t._l12_2a+t._x2*t._l01_2a)/f,i=(i*u-t._y0*t._l12_2a+t._y2*t._l01_2a)/f}if(t._l23_a>Fg){var c=2*t._l23_2a+3*t._l23_a*t._l12_a+t._l12_2a,s=3*t._l23_a*(t._l23_a+t._l12_a);o=(o*c+t._x1*t._l23_2a-n*t._l12_2a)/s,a=(a*c+t._y1*t._l23_2a-e*t._l12_2a)/s}t._context.bezierCurveTo(r,i,o,a,t._x2,t._y2)}function Jy(t,n){this._context=t,this._alpha=n}Jy.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)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3;default:Qy(this,t,n)}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=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Ky=function t(n){function e(t){return n?new Jy(t,n):new Xy(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function t_(t,n){this._context=t,this._alpha=n}t_.prototype={areaStart:qy,areaEnd:qy,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)}},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=t,this._y3=n;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=n);break;case 2:this._point=3,this._x5=t,this._y5=n;break;default:Qy(this,t,n)}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=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var n_=function t(n){function e(t){return n?new t_(t,n):new Vy(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function e_(t,n){this._context=t,this._alpha=n}e_.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||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,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:Qy(this,t,n)}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=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var r_=function t(n){function e(t){return n?new e_(t,n):new Wy(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function i_(t){this._context=t}function o_(t){return t<0?-1:1}function a_(t,n,e){var r=t._x1-t._x0,i=n-t._x1,o=(t._y1-t._y0)/(r||i<0&&-0),a=(e-t._y1)/(i||r<0&&-0),u=(o*i+a*r)/(r+i);return(o_(o)+o_(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(u))||0}function u_(t,n){var e=t._x1-t._x0;return e?(3*(t._y1-t._y0)/e-n)/2:n}function f_(t,n,e){var r=t._x0,i=t._y0,o=t._x1,a=t._y1,u=(o-r)/3;t._context.bezierCurveTo(r+u,i+u*n,o-u,a-u*e,o,a)}function c_(t){this._context=t}function s_(t){this._context=new l_(t)}function l_(t){this._context=t}function h_(t){this._context=t}function d_(t){var n,e,r=t.length-1,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=t[0]+2*t[1],n=1;n<r-1;++n)i[n]=1,o[n]=4,a[n]=4*t[n]+2*t[n+1];for(i[r-1]=2,o[r-1]=7,a[r-1]=8*t[r-1]+t[r],n=1;n<r;++n)e=i[n]/o[n-1],o[n]-=e,a[n]-=e*a[n-1];for(i[r-1]=a[r-1]/o[r-1],n=r-2;n>=0;--n)i[n]=(a[n]-i[n+1])/o[n];for(o[r-1]=(t[r]+i[r-1])/2,n=0;n<r-1;++n)o[n]=2*t[n+1]-i[n+1];return[i,o]}function p_(t,n){this._context=t,this._t=n}function v_(t,n){if((i=t.length)>1)for(var e,r,i,o=1,a=t[n[0]],u=a.length;o<i;++o)for(r=a,a=t[n[o]],e=0;e<u;++e)a[e][1]+=a[e][0]=isNaN(r[e][1])?r[e][0]:r[e][1]}function g_(t){for(var n=t.length,e=new Array(n);--n>=0;)e[n]=n;return e}function y_(t,n){return t[n]}function __(t){var n=t.map(b_);return g_(t).sort(function(t,e){return n[t]-n[e]})}function b_(t){for(var n,e=0,r=-1,i=t.length;++r<i;)(n=+t[r][1])&&(e+=n);return e}function m_(t){return function(){return t}}function x_(t){return t[0]}function w_(t){return t[1]}function M_(){this._=null}function A_(t){t.U=t.C=t.L=t.R=t.P=t.N=null}function T_(t,n){var e=n,r=n.R,i=e.U;i?i.L===e?i.L=r:i.R=r:t._=r,r.U=i,e.U=r,e.R=r.L,e.R&&(e.R.U=e),r.L=e}function N_(t,n){var e=n,r=n.L,i=e.U;i?i.L===e?i.L=r:i.R=r:t._=r,r.U=i,e.U=r,e.L=r.R,e.L&&(e.L.U=e),r.R=e}function S_(t){for(;t.L;)t=t.L;return t}function E_(t,n,e,r){var i=[null,null],o=J_.push(i)-1;return i.left=t,i.right=n,e&&C_(i,t,n,e),r&&C_(i,n,t,r),Z_[t.index].halfedges.push(o),Z_[n.index].halfedges.push(o),i}function k_(t,n,e){var r=[n,e];return r.left=t,r}function C_(t,n,e,r){t[0]||t[1]?t.left===e?t[1]=r:t[0]=r:(t[0]=r,t.left=n,t.right=e)}function P_(t,n,e,r,i){var o,a=t[0],u=t[1],f=a[0],c=a[1],s=0,l=1,h=u[0]-f,d=u[1]-c;if(o=n-f,h||!(o>0)){if(o/=h,h<0){if(o<s)return;o<l&&(l=o)}else if(h>0){if(o>l)return;o>s&&(s=o)}if(o=r-f,h||!(o<0)){if(o/=h,h<0){if(o>l)return;o>s&&(s=o)}else if(h>0){if(o<s)return;o<l&&(l=o)}if(o=e-c,d||!(o>0)){if(o/=d,d<0){if(o<s)return;o<l&&(l=o)}else if(d>0){if(o>l)return;o>s&&(s=o)}if(o=i-c,d||!(o<0)){if(o/=d,d<0){if(o>l)return;o>s&&(s=o)}else if(d>0){if(o<s)return;o<l&&(l=o)}return!(s>0||l<1)||(s>0&&(t[0]=[f+s*h,c+s*d]),l<1&&(t[1]=[f+l*h,c+l*d]),!0)}}}}}function z_(t,n,e,r,i){var o=t[1];if(o)return!0;var a,u,f=t[0],c=t.left,s=t.right,l=c[0],h=c[1],d=s[0],p=s[1],v=(l+d)/2,g=(h+p)/2;if(p===h){if(v<n||v>=r)return;if(l>d){if(f){if(f[1]>=i)return}else f=[v,e];o=[v,i]}else{if(f){if(f[1]<e)return}else f=[v,i];o=[v,e]}}else if(u=g-(a=(l-d)/(p-h))*v,a<-1||a>1)if(l>d){if(f){if(f[1]>=i)return}else f=[(e-u)/a,e];o=[(i-u)/a,i]}else{if(f){if(f[1]<e)return}else f=[(i-u)/a,i];o=[(e-u)/a,e]}else if(h<p){if(f){if(f[0]>=r)return}else f=[n,a*n+u];o=[r,a*r+u]}else{if(f){if(f[0]<n)return}else f=[r,a*r+u];o=[n,a*n+u]}return t[0]=f,t[1]=o,!0}function R_(t,n){var e=t.site,r=n.left,i=n.right;return e===i&&(i=r,r=e),i?Math.atan2(i[1]-r[1],i[0]-r[0]):(e===r?(r=n[1],i=n[0]):(r=n[0],i=n[1]),Math.atan2(r[0]-i[0],i[1]-r[1]))}function L_(t,n){return n[+(n.left!==t.site)]}function D_(t,n){return n[+(n.left===t.site)]}i_.prototype={areaStart:qy,areaEnd:qy,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(t,n){t=+t,n=+n,this._point?this._context.lineTo(t,n):(this._point=1,this._context.moveTo(t,n))}},c_.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:f_(this,this._t0,u_(this,this._t0))}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){var e=NaN;if(n=+n,(t=+t)!==this._x1||n!==this._y1){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3,f_(this,u_(this,e=a_(this,t,n)),e);break;default:f_(this,this._t0,e=a_(this,t,n))}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n,this._t0=e}}},(s_.prototype=Object.create(c_.prototype)).point=function(t,n){c_.prototype.point.call(this,n,t)},l_.prototype={moveTo:function(t,n){this._context.moveTo(n,t)},closePath:function(){this._context.closePath()},lineTo:function(t,n){this._context.lineTo(n,t)},bezierCurveTo:function(t,n,e,r,i,o){this._context.bezierCurveTo(n,t,r,e,o,i)}},h_.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var t=this._x,n=this._y,e=t.length;if(e)if(this._line?this._context.lineTo(t[0],n[0]):this._context.moveTo(t[0],n[0]),2===e)this._context.lineTo(t[1],n[1]);else for(var r=d_(t),i=d_(n),o=0,a=1;a<e;++o,++a)this._context.bezierCurveTo(r[0][o],i[0][o],r[1][o],i[1][o],t[a],n[a]);(this._line||0!==this._line&&1===e)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(t,n){this._x.push(+t),this._y.push(+n)}},p_.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&&2===this._point&&this._context.lineTo(this._x,this._y),(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:if(this._t<=0)this._context.lineTo(this._x,n),this._context.lineTo(t,n);else{var e=this._x*(1-this._t)+t*this._t;this._context.lineTo(e,this._y),this._context.lineTo(e,n)}}this._x=t,this._y=n}},M_.prototype={constructor:M_,insert:function(t,n){var e,r,i;if(t){if(n.P=t,n.N=t.N,t.N&&(t.N.P=n),t.N=n,t.R){for(t=t.R;t.L;)t=t.L;t.L=n}else t.R=n;e=t}else this._?(t=S_(this._),n.P=null,n.N=t,t.P=t.L=n,e=t):(n.P=n.N=null,this._=n,e=null);for(n.L=n.R=null,n.U=e,n.C=!0,t=n;e&&e.C;)e===(r=e.U).L?(i=r.R)&&i.C?(e.C=i.C=!1,r.C=!0,t=r):(t===e.R&&(T_(this,e),e=(t=e).U),e.C=!1,r.C=!0,N_(this,r)):(i=r.L)&&i.C?(e.C=i.C=!1,r.C=!0,t=r):(t===e.L&&(N_(this,e),e=(t=e).U),e.C=!1,r.C=!0,T_(this,r)),e=t.U;this._.C=!1},remove:function(t){t.N&&(t.N.P=t.P),t.P&&(t.P.N=t.N),t.N=t.P=null;var n,e,r,i=t.U,o=t.L,a=t.R;if(e=o?a?S_(a):o:a,i?i.L===t?i.L=e:i.R=e:this._=e,o&&a?(r=e.C,e.C=t.C,e.L=o,o.U=e,e!==a?(i=e.U,e.U=t.U,t=e.R,i.L=t,e.R=a,a.U=e):(e.U=i,i=e,t=e.R)):(r=t.C,t=e),t&&(t.U=i),!r)if(t&&t.C)t.C=!1;else{do{if(t===this._)break;if(t===i.L){if((n=i.R).C&&(n.C=!1,i.C=!0,T_(this,i),n=i.R),n.L&&n.L.C||n.R&&n.R.C){n.R&&n.R.C||(n.L.C=!1,n.C=!0,N_(this,n),n=i.R),n.C=i.C,i.C=n.R.C=!1,T_(this,i),t=this._;break}}else if((n=i.L).C&&(n.C=!1,i.C=!0,N_(this,i),n=i.L),n.L&&n.L.C||n.R&&n.R.C){n.L&&n.L.C||(n.R.C=!1,n.C=!0,T_(this,n),n=i.L),n.C=i.C,i.C=n.L.C=!1,N_(this,i),t=this._;break}n.C=!0,t=i,i=i.U}while(!t.C);t&&(t.C=!1)}}};var U_,q_=[];function O_(){A_(this),this.x=this.y=this.arc=this.site=this.cy=null}function Y_(t){var n=t.P,e=t.N;if(n&&e){var r=n.site,i=t.site,o=e.site;if(r!==o){var a=i[0],u=i[1],f=r[0]-a,c=r[1]-u,s=o[0]-a,l=o[1]-u,h=2*(f*l-c*s);if(!(h>=-tb)){var d=f*f+c*c,p=s*s+l*l,v=(l*d-c*p)/h,g=(f*p-s*d)/h,y=q_.pop()||new O_;y.arc=t,y.site=i,y.x=v+a,y.y=(y.cy=g+u)+Math.sqrt(v*v+g*g),t.circle=y;for(var _=null,b=Q_._;b;)if(y.y<b.y||y.y===b.y&&y.x<=b.x){if(!b.L){_=b.P;break}b=b.L}else{if(!b.R){_=b;break}b=b.R}Q_.insert(_,y),_||(U_=y)}}}}function B_(t){var n=t.circle;n&&(n.P||(U_=n.N),Q_.remove(n),q_.push(n),A_(n),t.circle=null)}var F_=[];function I_(){A_(this),this.edge=this.site=this.circle=null}function H_(t){var n=F_.pop()||new I_;return n.site=t,n}function j_(t){B_(t),W_.remove(t),F_.push(t),A_(t)}function X_(t){var n=t.circle,e=n.x,r=n.cy,i=[e,r],o=t.P,a=t.N,u=[t];j_(t);for(var f=o;f.circle&&Math.abs(e-f.circle.x)<K_&&Math.abs(r-f.circle.cy)<K_;)o=f.P,u.unshift(f),j_(f),f=o;u.unshift(f),B_(f);for(var c=a;c.circle&&Math.abs(e-c.circle.x)<K_&&Math.abs(r-c.circle.cy)<K_;)a=c.N,u.push(c),j_(c),c=a;u.push(c),B_(c);var s,l=u.length;for(s=1;s<l;++s)c=u[s],f=u[s-1],C_(c.edge,f.site,c.site,i);f=u[0],(c=u[l-1]).edge=E_(f.site,c.site,null,i),Y_(f),Y_(c)}function G_(t){for(var n,e,r,i,o=t[0],a=t[1],u=W_._;u;)if((r=V_(u,a)-o)>K_)u=u.L;else{if(!((i=o-$_(u,a))>K_)){r>-K_?(n=u.P,e=u):i>-K_?(n=u,e=u.N):n=e=u;break}if(!u.R){n=u;break}u=u.R}!function(t){Z_[t.index]={site:t,halfedges:[]}}(t);var f=H_(t);if(W_.insert(n,f),n||e){if(n===e)return B_(n),e=H_(n.site),W_.insert(f,e),f.edge=e.edge=E_(n.site,f.site),Y_(n),void Y_(e);if(e){B_(n),B_(e);var c=n.site,s=c[0],l=c[1],h=t[0]-s,d=t[1]-l,p=e.site,v=p[0]-s,g=p[1]-l,y=2*(h*g-d*v),_=h*h+d*d,b=v*v+g*g,m=[(g*_-d*b)/y+s,(h*b-v*_)/y+l];C_(e.edge,c,p,m),f.edge=E_(c,t,null,m),e.edge=E_(t,p,null,m),Y_(n),Y_(e)}else f.edge=E_(n.site,f.site)}}function V_(t,n){var e=t.site,r=e[0],i=e[1],o=i-n;if(!o)return r;var a=t.P;if(!a)return-1/0;var u=(e=a.site)[0],f=e[1],c=f-n;if(!c)return u;var s=u-r,l=1/o-1/c,h=s/c;return l?(-h+Math.sqrt(h*h-2*l*(s*s/(-2*c)-f+c/2+i-o/2)))/l+r:(r+u)/2}function $_(t,n){var e=t.N;if(e)return V_(e,n);var r=t.site;return r[1]===n?r[0]:1/0}var W_,Z_,Q_,J_,K_=1e-6,tb=1e-12;function nb(t,n){return n[1]-t[1]||n[0]-t[0]}function eb(t,n){var e,r,i,o=t.sort(nb).pop();for(J_=[],Z_=new Array(t.length),W_=new M_,Q_=new M_;;)if(i=U_,o&&(!i||o[1]<i.y||o[1]===i.y&&o[0]<i.x))o[0]===e&&o[1]===r||(G_(o),e=o[0],r=o[1]),o=t.pop();else{if(!i)break;X_(i.arc)}if(function(){for(var t,n,e,r,i=0,o=Z_.length;i<o;++i)if((t=Z_[i])&&(r=(n=t.halfedges).length)){var a=new Array(r),u=new Array(r);for(e=0;e<r;++e)a[e]=e,u[e]=R_(t,J_[n[e]]);for(a.sort(function(t,n){return u[n]-u[t]}),e=0;e<r;++e)u[e]=n[a[e]];for(e=0;e<r;++e)n[e]=u[e]}}(),n){var a=+n[0][0],u=+n[0][1],f=+n[1][0],c=+n[1][1];!function(t,n,e,r){for(var i,o=J_.length;o--;)z_(i=J_[o],t,n,e,r)&&P_(i,t,n,e,r)&&(Math.abs(i[0][0]-i[1][0])>K_||Math.abs(i[0][1]-i[1][1])>K_)||delete J_[o]}(a,u,f,c),function(t,n,e,r){var i,o,a,u,f,c,s,l,h,d,p,v,g=Z_.length,y=!0;for(i=0;i<g;++i)if(o=Z_[i]){for(a=o.site,u=(f=o.halfedges).length;u--;)J_[f[u]]||f.splice(u,1);for(u=0,c=f.length;u<c;)p=(d=D_(o,J_[f[u]]))[0],v=d[1],l=(s=L_(o,J_[f[++u%c]]))[0],h=s[1],(Math.abs(p-l)>K_||Math.abs(v-h)>K_)&&(f.splice(u,0,J_.push(k_(a,d,Math.abs(p-t)<K_&&r-v>K_?[t,Math.abs(l-t)<K_?h:r]:Math.abs(v-r)<K_&&e-p>K_?[Math.abs(h-r)<K_?l:e,r]:Math.abs(p-e)<K_&&v-n>K_?[e,Math.abs(l-e)<K_?h:n]:Math.abs(v-n)<K_&&p-t>K_?[Math.abs(h-n)<K_?l:t,n]:null))-1),++c);c&&(y=!1)}if(y){var _,b,m,x=1/0;for(i=0,y=null;i<g;++i)(o=Z_[i])&&(m=(_=(a=o.site)[0]-t)*_+(b=a[1]-n)*b)<x&&(x=m,y=o);if(y){var w=[t,n],M=[t,r],A=[e,r],T=[e,n];y.halfedges.push(J_.push(k_(a=y.site,w,M))-1,J_.push(k_(a,M,A))-1,J_.push(k_(a,A,T))-1,J_.push(k_(a,T,w))-1)}}for(i=0;i<g;++i)(o=Z_[i])&&(o.halfedges.length||delete Z_[i])}(a,u,f,c)}this.edges=J_,this.cells=Z_,W_=Q_=J_=Z_=null}function rb(t){return function(){return t}}function ib(t,n,e){this.target=t,this.type=n,this.transform=e}function ob(t,n,e){this.k=t,this.x=n,this.y=e}eb.prototype={constructor:eb,polygons:function(){var t=this.edges;return this.cells.map(function(n){var e=n.halfedges.map(function(e){return L_(n,t[e])});return e.data=n.site.data,e})},triangles:function(){var t=[],n=this.edges;return this.cells.forEach(function(e,r){if(o=(i=e.halfedges).length)for(var i,o,a,u,f,c,s=e.site,l=-1,h=n[i[o-1]],d=h.left===s?h.right:h.left;++l<o;)a=d,d=(h=n[i[l]]).left===s?h.right:h.left,a&&d&&r<a.index&&r<d.index&&(f=a,c=d,((u=s)[0]-c[0])*(f[1]-u[1])-(u[0]-f[0])*(c[1]-u[1])<0)&&t.push([s.data,a.data,d.data])}),t},links:function(){return this.edges.filter(function(t){return t.right}).map(function(t){return{source:t.left.data,target:t.right.data}})},find:function(t,n,e){for(var r,i,o=this,a=o._found||0,u=o.cells.length;!(i=o.cells[a]);)if(++a>=u)return null;var f=t-i.site[0],c=n-i.site[1],s=f*f+c*c;do{i=o.cells[r=a],a=null,i.halfedges.forEach(function(e){var r=o.edges[e],u=r.left;if(u!==i.site&&u||(u=r.right)){var f=t-u[0],c=n-u[1],l=f*f+c*c;l<s&&(s=l,a=u.index)}})}while(null!==a);return o._found=r,null==e||s<=e*e?i.site:null}},ob.prototype={constructor:ob,scale:function(t){return 1===t?this:new ob(this.k*t,this.x,this.y)},translate:function(t,n){return 0===t&0===n?this:new ob(this.k,this.x+this.k*t,this.y+this.k*n)},apply:function(t){return[t[0]*this.k+this.x,t[1]*this.k+this.y]},applyX:function(t){return t*this.k+this.x},applyY:function(t){return t*this.k+this.y},invert:function(t){return[(t[0]-this.x)/this.k,(t[1]-this.y)/this.k]},invertX:function(t){return(t-this.x)/this.k},invertY:function(t){return(t-this.y)/this.k},rescaleX:function(t){return t.copy().domain(t.range().map(this.invertX,this).map(t.invert,t))},rescaleY:function(t){return t.copy().domain(t.range().map(this.invertY,this).map(t.invert,t))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var ab=new ob(1,0,0);function ub(t){return t.__zoom||ab}function fb(){t.event.stopImmediatePropagation()}function cb(){t.event.preventDefault(),t.event.stopImmediatePropagation()}function sb(){return!t.event.button}function lb(){var t,n,e=this;return e instanceof SVGElement?(t=(e=e.ownerSVGElement||e).width.baseVal.value,n=e.height.baseVal.value):(t=e.clientWidth,n=e.clientHeight),[[0,0],[t,n]]}function hb(){return this.__zoom||ab}function db(){return-t.event.deltaY*(t.event.deltaMode?120:1)/500}function pb(){return"ontouchstart"in this}function vb(t,n,e){var r=t.invertX(n[0][0])-e[0][0],i=t.invertX(n[1][0])-e[1][0],o=t.invertY(n[0][1])-e[0][1],a=t.invertY(n[1][1])-e[1][1];return t.translate(i>r?(r+i)/2:Math.min(0,r)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}ub.prototype=ob.prototype,t.version="5.7.0",t.bisect=i,t.bisectRight=i,t.bisectLeft=o,t.ascending=n,t.bisector=e,t.cross=function(t,n,e){var r,i,o,u,f=t.length,c=n.length,s=new Array(f*c);for(null==e&&(e=a),r=o=0;r<f;++r)for(u=t[r],i=0;i<c;++i,++o)s[o]=e(u,n[i]);return s},t.descending=function(t,n){return n<t?-1:n>t?1:n>=t?0:NaN},t.deviation=c,t.extent=s,t.histogram=function(){var t=v,n=s,e=M;function r(r){var o,a,u=r.length,f=new Array(u);for(o=0;o<u;++o)f[o]=t(r[o],o,r);var c=n(f),s=c[0],l=c[1],h=e(f,s,l);Array.isArray(h)||(h=w(s,l,h),h=g(Math.ceil(s/h)*h,l,h));for(var d=h.length;h[0]<=s;)h.shift(),--d;for(;h[d-1]>l;)h.pop(),--d;var p,v=new Array(d+1);for(o=0;o<=d;++o)(p=v[o]=[]).x0=o>0?h[o-1]:s,p.x1=o<d?h[o]:l;for(o=0;o<u;++o)s<=(a=f[o])&&a<=l&&v[i(h,a,0,d)].push(r[o]);return v}return r.value=function(n){return arguments.length?(t="function"==typeof n?n:p(n),r):t},r.domain=function(t){return arguments.length?(n="function"==typeof t?t:p([t[0],t[1]]),r):n},r.thresholds=function(t){return arguments.length?(e="function"==typeof t?t:Array.isArray(t)?p(h.call(t)):p(t),r):e},r},t.thresholdFreedmanDiaconis=function(t,e,r){return t=d.call(t,u).sort(n),Math.ceil((r-e)/(2*(A(t,.75)-A(t,.25))*Math.pow(t.length,-1/3)))},t.thresholdScott=function(t,n,e){return Math.ceil((e-n)/(3.5*c(t)*Math.pow(t.length,-1/3)))},t.thresholdSturges=M,t.max=T,t.mean=function(t,n){var e,r=t.length,i=r,o=-1,a=0;if(null==n)for(;++o<r;)isNaN(e=u(t[o]))?--i:a+=e;else for(;++o<r;)isNaN(e=u(n(t[o],o,t)))?--i:a+=e;if(i)return a/i},t.median=function(t,e){var r,i=t.length,o=-1,a=[];if(null==e)for(;++o<i;)isNaN(r=u(t[o]))||a.push(r);else for(;++o<i;)isNaN(r=u(e(t[o],o,t)))||a.push(r);return A(a.sort(n),.5)},t.merge=N,t.min=S,t.pairs=function(t,n){null==n&&(n=a);for(var e=0,r=t.length-1,i=t[0],o=new Array(r<0?0:r);e<r;)o[e]=n(i,i=t[++e]);return o},t.permute=function(t,n){for(var e=n.length,r=new Array(e);e--;)r[e]=t[n[e]];return r},t.quantile=A,t.range=g,t.scan=function(t,e){if(r=t.length){var r,i,o=0,a=0,u=t[a];for(null==e&&(e=n);++o<r;)(e(i=t[o],u)<0||0!==e(u,u))&&(u=i,a=o);return 0===e(u,u)?a:void 0}},t.shuffle=function(t,n,e){for(var r,i,o=(null==e?t.length:e)-(n=null==n?0:+n);o;)i=Math.random()*o--|0,r=t[o+n],t[o+n]=t[i+n],t[i+n]=r;return t},t.sum=function(t,n){var e,r=t.length,i=-1,o=0;if(null==n)for(;++i<r;)(e=+t[i])&&(o+=e);else for(;++i<r;)(e=+n(t[i],i,t))&&(o+=e);return o},t.ticks=m,t.tickIncrement=x,t.tickStep=w,t.transpose=E,t.variance=f,t.zip=function(){return E(arguments)},t.axisTop=function(t){return B(z,t)},t.axisRight=function(t){return B(R,t)},t.axisBottom=function(t){return B(L,t)},t.axisLeft=function(t){return B(D,t)},t.brush=function(){return Ri(wi)},t.brushX=function(){return Ri(mi)},t.brushY=function(){return Ri(xi)},t.brushSelection=function(t){var n=t.__brush;return n?n.dim.output(n.selection):null},t.chord=function(){var t=0,n=null,e=null,r=null;function i(i){var o,a,u,f,c,s,l=i.length,h=[],d=g(l),p=[],v=[],y=v.groups=new Array(l),_=new Array(l*l);for(o=0,c=-1;++c<l;){for(a=0,s=-1;++s<l;)a+=i[c][s];h.push(a),p.push(g(l)),o+=a}for(n&&d.sort(function(t,e){return n(h[t],h[e])}),e&&p.forEach(function(t,n){t.sort(function(t,r){return e(i[n][t],i[n][r])})}),f=(o=Yi(0,Oi-t*l)/o)?t:Oi/l,a=0,c=-1;++c<l;){for(u=a,s=-1;++s<l;){var b=d[c],m=p[b][s],x=i[b][m],w=a,M=a+=x*o;_[m*l+b]={index:b,subindex:m,startAngle:w,endAngle:M,value:x}}y[b]={index:b,startAngle:u,endAngle:a,value:h[b]},a+=f}for(c=-1;++c<l;)for(s=c-1;++s<l;){var A=_[s*l+c],T=_[c*l+s];(A.value||T.value)&&v.push(A.value<T.value?{source:T,target:A}:{source:A,target:T})}return r?v.sort(r):v}return i.padAngle=function(n){return arguments.length?(t=Yi(0,n),i):t},i.sortGroups=function(t){return arguments.length?(n=t,i):n},i.sortSubgroups=function(t){return arguments.length?(e=t,i):e},i.sortChords=function(t){return arguments.length?(null==t?r=null:(n=t,r=function(t,e){return n(t.source.value+t.target.value,e.source.value+e.target.value)})._=t,i):r&&r._;var n},i},t.ribbon=function(){var t=Vi,n=$i,e=Wi,r=Zi,i=Qi,o=null;function a(){var a,u=Bi.call(arguments),f=t.apply(this,u),c=n.apply(this,u),s=+e.apply(this,(u[0]=f,u)),l=r.apply(this,u)-qi,h=i.apply(this,u)-qi,d=s*Li(l),p=s*Di(l),v=+e.apply(this,(u[0]=c,u)),g=r.apply(this,u)-qi,y=i.apply(this,u)-qi;if(o||(o=a=Gi()),o.moveTo(d,p),o.arc(0,0,s,l,h),l===g&&h===y||(o.quadraticCurveTo(0,0,v*Li(g),v*Di(g)),o.arc(0,0,v,g,y)),o.quadraticCurveTo(0,0,d,p),o.closePath(),a)return o=null,a+""||null}return a.radius=function(t){return arguments.length?(e="function"==typeof t?t:Fi(+t),a):e},a.startAngle=function(t){return arguments.length?(r="function"==typeof t?t:Fi(+t),a):r},a.endAngle=function(t){return arguments.length?(i="function"==typeof t?t:Fi(+t),a):i},a.source=function(n){return arguments.length?(t=n,a):t},a.target=function(t){return arguments.length?(n=t,a):n},a.context=function(t){return arguments.length?(o=null==t?null:t,a):o},a},t.nest=function(){var t,n,e,r=[],i=[];function o(e,i,a,u){if(i>=r.length)return null!=t&&e.sort(t),null!=n?n(e):e;for(var f,c,s,l=-1,h=e.length,d=r[i++],p=Ki(),v=a();++l<h;)(s=p.get(f=d(c=e[l])+""))?s.push(c):p.set(f,[c]);return p.each(function(t,n){u(v,n,o(t,i,a,u))}),v}return e={object:function(t){return o(t,0,to,no)},map:function(t){return o(t,0,eo,ro)},entries:function(t){return function t(e,o){if(++o>r.length)return e;var a,u=i[o-1];return null!=n&&o>=r.length?a=e.entries():(a=[],e.each(function(n,e){a.push({key:e,values:t(n,o)})})),null!=u?a.sort(function(t,n){return u(t.key,n.key)}):a}(o(t,0,eo,ro),0)},key:function(t){return r.push(t),e},sortKeys:function(t){return i[r.length-1]=t,e},sortValues:function(n){return t=n,e},rollup:function(t){return n=t,e}}},t.set=ao,t.map=Ki,t.keys=function(t){var n=[];for(var e in t)n.push(e);return n},t.values=function(t){var n=[];for(var e in t)n.push(t[e]);return n},t.entries=function(t){var n=[];for(var e in t)n.push({key:e,value:t[e]});return n},t.color=vn,t.rgb=bn,t.hsl=Mn,t.lab=Un,t.hcl=Hn,t.lch=function(t,n,e,r){return 1===arguments.length?In(t):new jn(e,n,t,null==r?1:r)},t.gray=function(t,n){return new qn(t,0,0,null==n?1:n)},t.cubehelix=Kn,t.contours=go,t.contourDensity=function(){var t=bo,n=mo,e=xo,r=960,i=500,o=20,a=2,u=3*o,f=r+2*u>>a,c=i+2*u>>a,s=co(20);function l(r){var i=new Float32Array(f*c),l=new Float32Array(f*c);r.forEach(function(r,o,s){var l=+t(r,o,s)+u>>a,h=+n(r,o,s)+u>>a,d=+e(r,o,s);l>=0&&l<f&&h>=0&&h<c&&(i[l+h*f]+=d)}),yo({width:f,height:c,data:i},{width:f,height:c,data:l},o>>a),_o({width:f,height:c,data:l},{width:f,height:c,data:i},o>>a),yo({width:f,height:c,data:i},{width:f,height:c,data:l},o>>a),_o({width:f,height:c,data:l},{width:f,height:c,data:i},o>>a),yo({width:f,height:c,data:i},{width:f,height:c,data:l},o>>a),_o({width:f,height:c,data:l},{width:f,height:c,data:i},o>>a);var d=s(i);if(!Array.isArray(d)){var p=T(i);d=w(0,p,d),(d=g(0,Math.floor(p/d)*d,d)).shift()}return go().thresholds(d).size([f,c])(i).map(h)}function h(t){return t.value*=Math.pow(2,-2*a),t.coordinates.forEach(d),t}function d(t){t.forEach(p)}function p(t){t.forEach(v)}function v(t){t[0]=t[0]*Math.pow(2,a)-u,t[1]=t[1]*Math.pow(2,a)-u}function y(){return f=r+2*(u=3*o)>>a,c=i+2*u>>a,l}return l.x=function(n){return arguments.length?(t="function"==typeof n?n:co(+n),l):t},l.y=function(t){return arguments.length?(n="function"==typeof t?t:co(+t),l):n},l.weight=function(t){return arguments.length?(e="function"==typeof t?t:co(+t),l):e},l.size=function(t){if(!arguments.length)return[r,i];var n=Math.ceil(t[0]),e=Math.ceil(t[1]);if(!(n>=0||n>=0))throw new Error("invalid size");return r=n,i=e,y()},l.cellSize=function(t){if(!arguments.length)return 1<<a;if(!((t=+t)>=1))throw new Error("invalid cell size");return a=Math.floor(Math.log(t)/Math.LN2),y()},l.thresholds=function(t){return arguments.length?(s="function"==typeof t?t:Array.isArray(t)?co(uo.call(t)):co(t),l):s},l.bandwidth=function(t){if(!arguments.length)return Math.sqrt(o*(o+1));if(!((t=+t)>=0))throw new Error("invalid bandwidth");return o=Math.round((Math.sqrt(4*t*t+1)-1)/2),y()},l},t.dispatch=I,t.drag=function(){var n,e,r,i,o=Wt,a=Zt,u=Qt,f=Jt,c={},s=I("start","drag","end"),l=0,h=0;function d(t){t.on("mousedown.drag",p).filter(f).on("touchstart.drag",y).on("touchmove.drag",_).on("touchend.drag touchcancel.drag",b).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function p(){if(!i&&o.apply(this,arguments)){var u=m("mouse",a.apply(this,arguments),Ft,this,arguments);u&&(Dt(t.event.view).on("mousemove.drag",v,!0).on("mouseup.drag",g,!0),Xt(t.event.view),Ht(),r=!1,n=t.event.clientX,e=t.event.clientY,u("start"))}}function v(){if(jt(),!r){var i=t.event.clientX-n,o=t.event.clientY-e;r=i*i+o*o>h}c.mouse("drag")}function g(){Dt(t.event.view).on("mousemove.drag mouseup.drag",null),Gt(t.event.view,r),jt(),c.mouse("end")}function y(){if(o.apply(this,arguments)){var n,e,r=t.event.changedTouches,i=a.apply(this,arguments),u=r.length;for(n=0;n<u;++n)(e=m(r[n].identifier,i,It,this,arguments))&&(Ht(),e("start"))}}function _(){var n,e,r=t.event.changedTouches,i=r.length;for(n=0;n<i;++n)(e=c[r[n].identifier])&&(jt(),e("drag"))}function b(){var n,e,r=t.event.changedTouches,o=r.length;for(i&&clearTimeout(i),i=setTimeout(function(){i=null},500),n=0;n<o;++n)(e=c[r[n].identifier])&&(Ht(),e("end"))}function m(n,e,r,i,o){var a,f,h,p=r(e,n),v=s.copy();if(Ct(new $t(d,"beforestart",a,n,l,p[0],p[1],0,0,v),function(){return null!=(t.event.subject=a=u.apply(i,o))&&(f=a.x-p[0]||0,h=a.y-p[1]||0,!0)}))return function t(u){var s,g=p;switch(u){case"start":c[n]=t,s=l++;break;case"end":delete c[n],--l;case"drag":p=r(e,n),s=l}Ct(new $t(d,u,a,n,s,p[0]+f,p[1]+h,p[0]-g[0],p[1]-g[1],v),v.apply,v,[u,i,o])}}return d.filter=function(t){return arguments.length?(o="function"==typeof t?t:Vt(!!t),d):o},d.container=function(t){return arguments.length?(a="function"==typeof t?t:Vt(t),d):a},d.subject=function(t){return arguments.length?(u="function"==typeof t?t:Vt(t),d):u},d.touchable=function(t){return arguments.length?(f="function"==typeof t?t:Vt(!!t),d):f},d.on=function(){var t=s.on.apply(s,arguments);return t===s?d:t},d.clickDistance=function(t){return arguments.length?(h=(t=+t)*t,d):Math.sqrt(h)},d},t.dragDisable=Xt,t.dragEnable=Gt,t.dsvFormat=Eo,t.csvParse=Co,t.csvParseRows=Po,t.csvFormat=zo,t.csvFormatRows=Ro,t.tsvParse=Do,t.tsvParseRows=Uo,t.tsvFormat=qo,t.tsvFormatRows=Oo,t.easeLinear=function(t){return+t},t.easeQuad=Dr,t.easeQuadIn=function(t){return t*t},t.easeQuadOut=function(t){return t*(2-t)},t.easeQuadInOut=Dr,t.easeCubic=Ur,t.easeCubicIn=function(t){return t*t*t},t.easeCubicOut=function(t){return--t*t*t+1},t.easeCubicInOut=Ur,t.easePoly=Yr,t.easePolyIn=qr,t.easePolyOut=Or,t.easePolyInOut=Yr,t.easeSin=Ir,t.easeSinIn=function(t){return 1-Math.cos(t*Fr)},t.easeSinOut=function(t){return Math.sin(t*Fr)},t.easeSinInOut=Ir,t.easeExp=Hr,t.easeExpIn=function(t){return Math.pow(2,10*t-10)},t.easeExpOut=function(t){return 1-Math.pow(2,-10*t)},t.easeExpInOut=Hr,t.easeCircle=jr,t.easeCircleIn=function(t){return 1-Math.sqrt(1-t*t)},t.easeCircleOut=function(t){return Math.sqrt(1- --t*t)},t.easeCircleInOut=jr,t.easeBounce=ni,t.easeBounceIn=function(t){return 1-ni(1-t)},t.easeBounceOut=ni,t.easeBounceInOut=function(t){return((t*=2)<=1?1-ni(1-t):ni(t-1)+1)/2},t.easeBack=ii,t.easeBackIn=ei,t.easeBackOut=ri,t.easeBackInOut=ii,t.easeElastic=ui,t.easeElasticIn=ai,t.easeElasticOut=ui,t.easeElasticInOut=fi,t.blob=function(t,n){return fetch(t,n).then(Yo)},t.buffer=function(t,n){return fetch(t,n).then(Bo)},t.dsv=function(t,n,e,r){3===arguments.length&&"function"==typeof e&&(r=e,e=void 0);var i=Eo(t);return Io(n,e).then(function(t){return i.parse(t,r)})},t.csv=jo,t.tsv=Xo,t.image=function(t,n){return new Promise(function(e,r){var i=new Image;for(var o in n)i[o]=n[o];i.onerror=r,i.onload=function(){e(i)},i.src=t})},t.json=function(t,n){return fetch(t,n).then(Go)},t.text=Io,t.xml=$o,t.html=Wo,t.svg=Zo,t.forceCenter=function(t,n){var e;function r(){var r,i,o=e.length,a=0,u=0;for(r=0;r<o;++r)a+=(i=e[r]).x,u+=i.y;for(a=a/o-t,u=u/o-n,r=0;r<o;++r)(i=e[r]).x-=a,i.y-=u}return null==t&&(t=0),null==n&&(n=0),r.initialize=function(t){e=t},r.x=function(n){return arguments.length?(t=+n,r):t},r.y=function(t){return arguments.length?(n=+t,r):n},r},t.forceCollide=function(t){var n,e,r=1,i=1;function o(){for(var t,o,u,f,c,s,l,h=n.length,d=0;d<i;++d)for(o=ra(n,ua,fa).visitAfter(a),t=0;t<h;++t)u=n[t],s=e[u.index],l=s*s,f=u.x+u.vx,c=u.y+u.vy,o.visit(p);function p(t,n,e,i,o){var a=t.data,h=t.r,d=s+h;if(!a)return n>f+d||i<f-d||e>c+d||o<c-d;if(a.index>u.index){var p=f-a.x-a.vx,v=c-a.y-a.vy,g=p*p+v*v;g<d*d&&(0===p&&(g+=(p=Jo())*p),0===v&&(g+=(v=Jo())*v),g=(d-(g=Math.sqrt(g)))/g*r,u.vx+=(p*=g)*(d=(h*=h)/(l+h)),u.vy+=(v*=g)*d,a.vx-=p*(d=1-d),a.vy-=v*d)}}}function a(t){if(t.data)return t.r=e[t.data.index];for(var n=t.r=0;n<4;++n)t[n]&&t[n].r>t.r&&(t.r=t[n].r)}function u(){if(n){var r,i,o=n.length;for(e=new Array(o),r=0;r<o;++r)i=n[r],e[i.index]=+t(i,r,n)}}return"function"!=typeof t&&(t=Qo(null==t?1:+t)),o.initialize=function(t){n=t,u()},o.iterations=function(t){return arguments.length?(i=+t,o):i},o.strength=function(t){return arguments.length?(r=+t,o):r},o.radius=function(n){return arguments.length?(t="function"==typeof n?n:Qo(+n),u(),o):t},o},t.forceLink=function(t){var n,e,r,i,o,a=ca,u=function(t){return 1/Math.min(i[t.source.index],i[t.target.index])},f=Qo(30),c=1;function s(r){for(var i=0,a=t.length;i<c;++i)for(var u,f,s,l,h,d,p,v=0;v<a;++v)f=(u=t[v]).source,l=(s=u.target).x+s.vx-f.x-f.vx||Jo(),h=s.y+s.vy-f.y-f.vy||Jo(),l*=d=((d=Math.sqrt(l*l+h*h))-e[v])/d*r*n[v],h*=d,s.vx-=l*(p=o[v]),s.vy-=h*p,f.vx+=l*(p=1-p),f.vy+=h*p}function l(){if(r){var u,f,c=r.length,s=t.length,l=Ki(r,a);for(u=0,i=new Array(c);u<s;++u)(f=t[u]).index=u,"object"!=typeof f.source&&(f.source=sa(l,f.source)),"object"!=typeof f.target&&(f.target=sa(l,f.target)),i[f.source.index]=(i[f.source.index]||0)+1,i[f.target.index]=(i[f.target.index]||0)+1;for(u=0,o=new Array(s);u<s;++u)f=t[u],o[u]=i[f.source.index]/(i[f.source.index]+i[f.target.index]);n=new Array(s),h(),e=new Array(s),d()}}function h(){if(r)for(var e=0,i=t.length;e<i;++e)n[e]=+u(t[e],e,t)}function d(){if(r)for(var n=0,i=t.length;n<i;++n)e[n]=+f(t[n],n,t)}return null==t&&(t=[]),s.initialize=function(t){r=t,l()},s.links=function(n){return arguments.length?(t=n,l(),s):t},s.id=function(t){return arguments.length?(a=t,s):a},s.iterations=function(t){return arguments.length?(c=+t,s):c},s.strength=function(t){return arguments.length?(u="function"==typeof t?t:Qo(+t),h(),s):u},s.distance=function(t){return arguments.length?(f="function"==typeof t?t:Qo(+t),d(),s):f},s},t.forceManyBody=function(){var t,n,e,r,i=Qo(-30),o=1,a=1/0,u=.81;function f(r){var i,o=t.length,a=ra(t,la,ha).visitAfter(s);for(e=r,i=0;i<o;++i)n=t[i],a.visit(l)}function c(){if(t){var n,e,o=t.length;for(r=new Array(o),n=0;n<o;++n)e=t[n],r[e.index]=+i(e,n,t)}}function s(t){var n,e,i,o,a,u=0,f=0;if(t.length){for(i=o=a=0;a<4;++a)(n=t[a])&&(e=Math.abs(n.value))&&(u+=n.value,f+=e,i+=e*n.x,o+=e*n.y);t.x=i/f,t.y=o/f}else{(n=t).x=n.data.x,n.y=n.data.y;do{u+=r[n.data.index]}while(n=n.next)}t.value=u}function l(t,i,f,c){if(!t.value)return!0;var s=t.x-n.x,l=t.y-n.y,h=c-i,d=s*s+l*l;if(h*h/u<d)return d<a&&(0===s&&(d+=(s=Jo())*s),0===l&&(d+=(l=Jo())*l),d<o&&(d=Math.sqrt(o*d)),n.vx+=s*t.value*e/d,n.vy+=l*t.value*e/d),!0;if(!(t.length||d>=a)){(t.data!==n||t.next)&&(0===s&&(d+=(s=Jo())*s),0===l&&(d+=(l=Jo())*l),d<o&&(d=Math.sqrt(o*d)));do{t.data!==n&&(h=r[t.data.index]*e/d,n.vx+=s*h,n.vy+=l*h)}while(t=t.next)}}return f.initialize=function(n){t=n,c()},f.strength=function(t){return arguments.length?(i="function"==typeof t?t:Qo(+t),c(),f):i},f.distanceMin=function(t){return arguments.length?(o=t*t,f):Math.sqrt(o)},f.distanceMax=function(t){return arguments.length?(a=t*t,f):Math.sqrt(a)},f.theta=function(t){return arguments.length?(u=t*t,f):Math.sqrt(u)},f},t.forceRadial=function(t,n,e){var r,i,o,a=Qo(.1);function u(t){for(var a=0,u=r.length;a<u;++a){var f=r[a],c=f.x-n||1e-6,s=f.y-e||1e-6,l=Math.sqrt(c*c+s*s),h=(o[a]-l)*i[a]*t/l;f.vx+=c*h,f.vy+=s*h}}function f(){if(r){var n,e=r.length;for(i=new Array(e),o=new Array(e),n=0;n<e;++n)o[n]=+t(r[n],n,r),i[n]=isNaN(o[n])?0:+a(r[n],n,r)}}return"function"!=typeof t&&(t=Qo(+t)),null==n&&(n=0),null==e&&(e=0),u.initialize=function(t){r=t,f()},u.strength=function(t){return arguments.length?(a="function"==typeof t?t:Qo(+t),f(),u):a},u.radius=function(n){return arguments.length?(t="function"==typeof n?n:Qo(+n),f(),u):t},u.x=function(t){return arguments.length?(n=+t,u):n},u.y=function(t){return arguments.length?(e=+t,u):e},u},t.forceSimulation=function(t){var n,e=1,r=.001,i=1-Math.pow(r,1/300),o=0,a=.6,u=Ki(),f=ur(s),c=I("tick","end");function s(){l(),c.call("tick",n),e<r&&(f.stop(),c.call("end",n))}function l(){var n,r,f=t.length;for(e+=(o-e)*i,u.each(function(t){t(e)}),n=0;n<f;++n)null==(r=t[n]).fx?r.x+=r.vx*=a:(r.x=r.fx,r.vx=0),null==r.fy?r.y+=r.vy*=a:(r.y=r.fy,r.vy=0)}function h(){for(var n,e=0,r=t.length;e<r;++e){if((n=t[e]).index=e,isNaN(n.x)||isNaN(n.y)){var i=da*Math.sqrt(e),o=e*pa;n.x=i*Math.cos(o),n.y=i*Math.sin(o)}(isNaN(n.vx)||isNaN(n.vy))&&(n.vx=n.vy=0)}}function d(n){return n.initialize&&n.initialize(t),n}return null==t&&(t=[]),h(),n={tick:l,restart:function(){return f.restart(s),n},stop:function(){return f.stop(),n},nodes:function(e){return arguments.length?(t=e,h(),u.each(d),n):t},alpha:function(t){return arguments.length?(e=+t,n):e},alphaMin:function(t){return arguments.length?(r=+t,n):r},alphaDecay:function(t){return arguments.length?(i=+t,n):+i},alphaTarget:function(t){return arguments.length?(o=+t,n):o},velocityDecay:function(t){return arguments.length?(a=1-t,n):1-a},force:function(t,e){return arguments.length>1?(null==e?u.remove(t):u.set(t,d(e)),n):u.get(t)},find:function(n,e,r){var i,o,a,u,f,c=0,s=t.length;for(null==r?r=1/0:r*=r,c=0;c<s;++c)(a=(i=n-(u=t[c]).x)*i+(o=e-u.y)*o)<r&&(f=u,r=a);return f},on:function(t,e){return arguments.length>1?(c.on(t,e),n):c.on(t)}}},t.forceX=function(t){var n,e,r,i=Qo(.1);function o(t){for(var i,o=0,a=n.length;o<a;++o)(i=n[o]).vx+=(r[o]-i.x)*e[o]*t}function a(){if(n){var o,a=n.length;for(e=new Array(a),r=new Array(a),o=0;o<a;++o)e[o]=isNaN(r[o]=+t(n[o],o,n))?0:+i(n[o],o,n)}}return"function"!=typeof t&&(t=Qo(null==t?0:+t)),o.initialize=function(t){n=t,a()},o.strength=function(t){return arguments.length?(i="function"==typeof t?t:Qo(+t),a(),o):i},o.x=function(n){return arguments.length?(t="function"==typeof n?n:Qo(+n),a(),o):t},o},t.forceY=function(t){var n,e,r,i=Qo(.1);function o(t){for(var i,o=0,a=n.length;o<a;++o)(i=n[o]).vy+=(r[o]-i.y)*e[o]*t}function a(){if(n){var o,a=n.length;for(e=new Array(a),r=new Array(a),o=0;o<a;++o)e[o]=isNaN(r[o]=+t(n[o],o,n))?0:+i(n[o],o,n)}}return"function"!=typeof t&&(t=Qo(null==t?0:+t)),o.initialize=function(t){n=t,a()},o.strength=function(t){return arguments.length?(i="function"==typeof t?t:Qo(+t),a(),o):i},o.y=function(n){return arguments.length?(t="function"==typeof n?n:Qo(+n),a(),o):t},o},t.formatDefaultLocale=Sa,t.formatLocale=Na,t.formatSpecifier=ba,t.precisionFixed=Ea,t.precisionPrefix=ka,t.precisionRound=Ca,t.geoArea=function(t){return yu.reset(),su(t,_u),2*yu},t.geoBounds=function(t){var n,e,r,i,o,a,u;if(Ru=zu=-(Cu=Pu=1/0),Ou=[],su(t,rf),e=Ou.length){for(Ou.sort(df),n=1,o=[r=Ou[0]];n<e;++n)pf(r,(i=Ou[n])[0])||pf(r,i[1])?(hf(r[0],i[1])>hf(r[0],r[1])&&(r[1]=i[1]),hf(i[0],r[1])>hf(r[0],r[1])&&(r[0]=i[0])):o.push(r=i);for(a=-1/0,n=0,r=o[e=o.length-1];n<=e;r=i,++n)i=o[n],(u=hf(r[1],i[0]))>a&&(a=u,Cu=i[0],zu=r[1])}return Ou=Yu=null,Cu===1/0||Pu===1/0?[[NaN,NaN],[NaN,NaN]]:[[Cu,Pu],[zu,Ru]]},t.geoCentroid=function(t){Bu=Fu=Iu=Hu=ju=Xu=Gu=Vu=$u=Wu=Zu=0,su(t,vf);var n=$u,e=Wu,r=Zu,i=n*n+e*e+r*r;return i<Ua&&(n=Xu,e=Gu,r=Vu,Fu<Da&&(n=Iu,e=Hu,r=ju),(i=n*n+e*e+r*r)<Ua)?[NaN,NaN]:[Xa(e,n)*Fa,eu(r/Ka(i))*Fa]},t.geoCircle=function(){var t,n,e=Nf([0,0]),r=Nf(90),i=Nf(6),o={point:function(e,r){t.push(e=n(e,r)),e[0]*=Fa,e[1]*=Fa}};function a(){var a=e.apply(this,arguments),u=r.apply(this,arguments)*Ia,f=i.apply(this,arguments)*Ia;return t=[],n=kf(-a[0]*Ia,-a[1]*Ia,0).invert,Lf(o,u,f,1),a={type:"Polygon",coordinates:[t]},t=n=null,a}return a.center=function(t){return arguments.length?(e="function"==typeof t?t:Nf([+t[0],+t[1]]),a):e},a.radius=function(t){return arguments.length?(r="function"==typeof t?t:Nf(+t),a):r},a.precision=function(t){return arguments.length?(i="function"==typeof t?t:Nf(+t),a):i},a},t.geoClipAntimeridian=Gf,t.geoClipCircle=Vf,t.geoClipExtent=function(){var t,n,e,r=0,i=0,o=960,a=500;return e={stream:function(e){return t&&n===e?t:t=Zf(r,i,o,a)(n=e)},extent:function(u){return arguments.length?(r=+u[0][0],i=+u[0][1],o=+u[1][0],a=+u[1][1],t=n=null,e):[[r,i],[o,a]]}}},t.geoClipRectangle=Zf,t.geoContains=function(t,n){return(t&&cc.hasOwnProperty(t.type)?cc[t.type]:lc)(t,n)},t.geoDistance=fc,t.geoGraticule=bc,t.geoGraticule10=function(){return bc()()},t.geoInterpolate=function(t,n){var e=t[0]*Ia,r=t[1]*Ia,i=n[0]*Ia,o=n[1]*Ia,a=Ga(r),u=Qa(r),f=Ga(o),c=Qa(o),s=a*Ga(e),l=a*Qa(e),h=f*Ga(i),d=f*Qa(i),p=2*eu(Ka(ru(o-r)+a*f*ru(i-e))),v=Qa(p),g=p?function(t){var n=Qa(t*=p)/v,e=Qa(p-t)/v,r=e*s+n*h,i=e*l+n*d,o=e*u+n*c;return[Xa(i,r)*Fa,Xa(o,Ka(r*r+i*i))*Fa]}:function(){return[e*Fa,r*Fa]};return g.distance=p,g},t.geoLength=oc,t.geoPath=function(t,n){var e,r,i=4.5;function o(t){return t&&("function"==typeof i&&r.pointRadius(+i.apply(this,arguments)),su(t,e(r))),r.result()}return o.area=function(t){return su(t,e(Sc)),Sc.result()},o.measure=function(t){return su(t,e(ds)),ds.result()},o.bounds=function(t){return su(t,e(Uc)),Uc.result()},o.centroid=function(t){return su(t,e(Zc)),Zc.result()},o.projection=function(n){return arguments.length?(e=null==n?(t=null,mc):(t=n).stream,o):t},o.context=function(t){return arguments.length?(r=null==t?(n=null,new gs):new as(n=t),"function"!=typeof i&&r.pointRadius(i),o):n},o.pointRadius=function(t){return arguments.length?(i="function"==typeof t?t:(r.pointRadius(+t),+t),o):i},o.projection(t).context(n)},t.geoAlbers=Ds,t.geoAlbersUsa=function(){var t,n,e,r,i,o,a=Ds(),u=Ls().rotate([154,0]).center([-2,58.5]).parallels([55,65]),f=Ls().rotate([157,0]).center([-3,19.9]).parallels([8,18]),c={point:function(t,n){o=[t,n]}};function s(t){var n=t[0],a=t[1];return o=null,e.point(n,a),o||(r.point(n,a),o)||(i.point(n,a),o)}function l(){return t=n=null,s}return s.invert=function(t){var n=a.scale(),e=a.translate(),r=(t[0]-e[0])/n,i=(t[1]-e[1])/n;return(i>=.12&&i<.234&&r>=-.425&&r<-.214?u:i>=.166&&i<.234&&r>=-.214&&r<-.115?f:a).invert(t)},s.stream=function(e){return t&&n===e?t:(r=[a.stream(n=e),u.stream(e),f.stream(e)],i=r.length,t={point:function(t,n){for(var e=-1;++e<i;)r[e].point(t,n)},sphere:function(){for(var t=-1;++t<i;)r[t].sphere()},lineStart:function(){for(var t=-1;++t<i;)r[t].lineStart()},lineEnd:function(){for(var t=-1;++t<i;)r[t].lineEnd()},polygonStart:function(){for(var t=-1;++t<i;)r[t].polygonStart()},polygonEnd:function(){for(var t=-1;++t<i;)r[t].polygonEnd()}});var r,i},s.precision=function(t){return arguments.length?(a.precision(t),u.precision(t),f.precision(t),l()):a.precision()},s.scale=function(t){return arguments.length?(a.scale(t),u.scale(.35*t),f.scale(t),s.translate(a.translate())):a.scale()},s.translate=function(t){if(!arguments.length)return a.translate();var n=a.scale(),o=+t[0],s=+t[1];return e=a.translate(t).clipExtent([[o-.455*n,s-.238*n],[o+.455*n,s+.238*n]]).stream(c),r=u.translate([o-.307*n,s+.201*n]).clipExtent([[o-.425*n+Da,s+.12*n+Da],[o-.214*n-Da,s+.234*n-Da]]).stream(c),i=f.translate([o-.205*n,s+.212*n]).clipExtent([[o-.214*n+Da,s+.166*n+Da],[o-.115*n-Da,s+.234*n-Da]]).stream(c),l()},s.fitExtent=function(t,n){return xs(s,t,n)},s.fitSize=function(t,n){return ws(s,t,n)},s.fitWidth=function(t,n){return Ms(s,t,n)},s.fitHeight=function(t,n){return As(s,t,n)},s.scale(1070)},t.geoAzimuthalEqualArea=function(){return Cs(Os).scale(124.75).clipAngle(179.999)},t.geoAzimuthalEqualAreaRaw=Os,t.geoAzimuthalEquidistant=function(){return Cs(Ys).scale(79.4188).clipAngle(179.999)},t.geoAzimuthalEquidistantRaw=Ys,t.geoConicConformal=function(){return zs(Hs).scale(109.5).parallels([30,30])},t.geoConicConformalRaw=Hs,t.geoConicEqualArea=Ls,t.geoConicEqualAreaRaw=Rs,t.geoConicEquidistant=function(){return zs(Xs).scale(131.154).center([0,13.9389])},t.geoConicEquidistantRaw=Xs,t.geoEqualEarth=function(){return Cs(Qs).scale(177.158)},t.geoEqualEarthRaw=Qs,t.geoEquirectangular=function(){return Cs(js).scale(152.63)},t.geoEquirectangularRaw=js,t.geoGnomonic=function(){return Cs(Js).scale(144.049).clipAngle(60)},t.geoGnomonicRaw=Js,t.geoIdentity=function(){var t,n,e,r,i,o,a=1,u=0,f=0,c=1,s=1,l=mc,h=null,d=mc;function p(){return r=i=null,o}return o={stream:function(t){return r&&i===t?r:r=l(d(i=t))},postclip:function(r){return arguments.length?(d=r,h=t=n=e=null,p()):d},clipExtent:function(r){return arguments.length?(d=null==r?(h=t=n=e=null,mc):Zf(h=+r[0][0],t=+r[0][1],n=+r[1][0],e=+r[1][1]),p()):null==h?null:[[h,t],[n,e]]},scale:function(t){return arguments.length?(l=Ks((a=+t)*c,a*s,u,f),p()):a},translate:function(t){return arguments.length?(l=Ks(a*c,a*s,u=+t[0],f=+t[1]),p()):[u,f]},reflectX:function(t){return arguments.length?(l=Ks(a*(c=t?-1:1),a*s,u,f),p()):c<0},reflectY:function(t){return arguments.length?(l=Ks(a*c,a*(s=t?-1:1),u,f),p()):s<0},fitExtent:function(t,n){return xs(o,t,n)},fitSize:function(t,n){return ws(o,t,n)},fitWidth:function(t,n){return Ms(o,t,n)},fitHeight:function(t,n){return As(o,t,n)}}},t.geoProjection=Cs,t.geoProjectionMutator=Ps,t.geoMercator=function(){return Fs(Bs).scale(961/Ba)},t.geoMercatorRaw=Bs,t.geoNaturalEarth1=function(){return Cs(tl).scale(175.295)},t.geoNaturalEarth1Raw=tl,t.geoOrthographic=function(){return Cs(nl).scale(249.5).clipAngle(90+Da)},t.geoOrthographicRaw=nl,t.geoStereographic=function(){return Cs(el).scale(250).clipAngle(142)},t.geoStereographicRaw=el,t.geoTransverseMercator=function(){var t=Fs(rl),n=t.center,e=t.rotate;return t.center=function(t){return arguments.length?n([-t[1],t[0]]):[(t=n())[1],-t[0]]},t.rotate=function(t){return arguments.length?e([t[0],t[1],t.length>2?t[2]+90:90]):[(t=e())[0],t[1],t[2]-90]},e([0,0,90]).scale(159.155)},t.geoTransverseMercatorRaw=rl,t.geoRotation=Rf,t.geoStream=su,t.geoTransform=function(t){return{stream:_s(t)}},t.cluster=function(){var t=il,n=1,e=1,r=!1;function i(i){var o,a=0;i.eachAfter(function(n){var e=n.children;e?(n.x=function(t){return t.reduce(ol,0)/t.length}(e),n.y=function(t){return 1+t.reduce(al,0)}(e)):(n.x=o?a+=t(n,o):0,n.y=0,o=n)});var u=function(t){for(var n;n=t.children;)t=n[0];return t}(i),f=function(t){for(var n;n=t.children;)t=n[n.length-1];return t}(i),c=u.x-t(u,f)/2,s=f.x+t(f,u)/2;return i.eachAfter(r?function(t){t.x=(t.x-i.x)*n,t.y=(i.y-t.y)*e}:function(t){t.x=(t.x-c)/(s-c)*n,t.y=(1-(i.y?t.y/i.y:1))*e})}return i.separation=function(n){return arguments.length?(t=n,i):t},i.size=function(t){return arguments.length?(r=!1,n=+t[0],e=+t[1],i):r?null:[n,e]},i.nodeSize=function(t){return arguments.length?(r=!0,n=+t[0],e=+t[1],i):r?[n,e]:null},i},t.hierarchy=fl,t.pack=function(){var t=null,n=1,e=1,r=El;function i(i){return i.x=n/2,i.y=e/2,t?i.eachBefore(Pl(t)).eachAfter(zl(r,.5)).eachBefore(Rl(1)):i.eachBefore(Pl(Cl)).eachAfter(zl(El,1)).eachAfter(zl(r,i.r/Math.min(n,e))).eachBefore(Rl(Math.min(n,e)/(2*i.r))),i}return i.radius=function(n){return arguments.length?(t=null==(e=n)?null:Sl(e),i):t;var e},i.size=function(t){return arguments.length?(n=+t[0],e=+t[1],i):[n,e]},i.padding=function(t){return arguments.length?(r="function"==typeof t?t:kl(+t),i):r},i},t.packSiblings=function(t){return Nl(t),t},t.packEnclose=pl,t.partition=function(){var t=1,n=1,e=0,r=!1;function i(i){var o=i.height+1;return i.x0=i.y0=e,i.x1=t,i.y1=n/o,i.eachBefore(function(t,n){return function(r){r.children&&Dl(r,r.x0,t*(r.depth+1)/n,r.x1,t*(r.depth+2)/n);var i=r.x0,o=r.y0,a=r.x1-e,u=r.y1-e;a<i&&(i=a=(i+a)/2),u<o&&(o=u=(o+u)/2),r.x0=i,r.y0=o,r.x1=a,r.y1=u}}(n,o)),r&&i.eachBefore(Ll),i}return i.round=function(t){return arguments.length?(r=!!t,i):r},i.size=function(e){return arguments.length?(t=+e[0],n=+e[1],i):[t,n]},i.padding=function(t){return arguments.length?(e=+t,i):e},i},t.stratify=function(){var t=Yl,n=Bl;function e(e){var r,i,o,a,u,f,c,s=e.length,l=new Array(s),h={};for(i=0;i<s;++i)r=e[i],u=l[i]=new hl(r),null!=(f=t(r,i,e))&&(f+="")&&(h[c=Ul+(u.id=f)]=c in h?Ol:u);for(i=0;i<s;++i)if(u=l[i],null!=(f=n(e[i],i,e))&&(f+="")){if(!(a=h[Ul+f]))throw new Error("missing: "+f);if(a===Ol)throw new Error("ambiguous: "+f);a.children?a.children.push(u):a.children=[u],u.parent=a}else{if(o)throw new Error("multiple roots");o=u}if(!o)throw new Error("no root");if(o.parent=ql,o.eachBefore(function(t){t.depth=t.parent.depth+1,--s}).eachBefore(ll),o.parent=null,s>0)throw new Error("cycle");return o}return e.id=function(n){return arguments.length?(t=Sl(n),e):t},e.parentId=function(t){return arguments.length?(n=Sl(t),e):n},e},t.tree=function(){var t=Fl,n=1,e=1,r=null;function i(i){var f=function(t){for(var n,e,r,i,o,a=new Gl(t,0),u=[a];n=u.pop();)if(r=n._.children)for(n.children=new Array(o=r.length),i=o-1;i>=0;--i)u.push(e=n.children[i]=new Gl(r[i],i)),e.parent=n;return(a.parent=new Gl(null,0)).children=[a],a}(i);if(f.eachAfter(o),f.parent.m=-f.z,f.eachBefore(a),r)i.eachBefore(u);else{var c=i,s=i,l=i;i.eachBefore(function(t){t.x<c.x&&(c=t),t.x>s.x&&(s=t),t.depth>l.depth&&(l=t)});var h=c===s?1:t(c,s)/2,d=h-c.x,p=n/(s.x+h+d),v=e/(l.depth||1);i.eachBefore(function(t){t.x=(t.x+d)*p,t.y=t.depth*v})}return i}function o(n){var e=n.children,r=n.parent.children,i=n.i?r[n.i-1]:null;if(e){!function(t){for(var n,e=0,r=0,i=t.children,o=i.length;--o>=0;)(n=i[o]).z+=e,n.m+=e,e+=n.s+(r+=n.c)}(n);var o=(e[0].z+e[e.length-1].z)/2;i?(n.z=i.z+t(n._,i._),n.m=n.z-o):n.z=o}else i&&(n.z=i.z+t(n._,i._));n.parent.A=function(n,e,r){if(e){for(var i,o=n,a=n,u=e,f=o.parent.children[0],c=o.m,s=a.m,l=u.m,h=f.m;u=Hl(u),o=Il(o),u&&o;)f=Il(f),(a=Hl(a)).a=n,(i=u.z+l-o.z-c+t(u._,o._))>0&&(jl(Xl(u,n,r),n,i),c+=i,s+=i),l+=u.m,c+=o.m,h+=f.m,s+=a.m;u&&!Hl(a)&&(a.t=u,a.m+=l-s),o&&!Il(f)&&(f.t=o,f.m+=c-h,r=n)}return r}(n,i,n.parent.A||r[0])}function a(t){t._.x=t.z+t.parent.m,t.m+=t.parent.m}function u(t){t.x*=n,t.y=t.depth*e}return i.separation=function(n){return arguments.length?(t=n,i):t},i.size=function(t){return arguments.length?(r=!1,n=+t[0],e=+t[1],i):r?null:[n,e]},i.nodeSize=function(t){return arguments.length?(r=!0,n=+t[0],e=+t[1],i):r?[n,e]:null},i},t.treemap=function(){var t=Zl,n=!1,e=1,r=1,i=[0],o=El,a=El,u=El,f=El,c=El;function s(t){return t.x0=t.y0=0,t.x1=e,t.y1=r,t.eachBefore(l),i=[0],n&&t.eachBefore(Ll),t}function l(n){var e=i[n.depth],r=n.x0+e,s=n.y0+e,l=n.x1-e,h=n.y1-e;l<r&&(r=l=(r+l)/2),h<s&&(s=h=(s+h)/2),n.x0=r,n.y0=s,n.x1=l,n.y1=h,n.children&&(e=i[n.depth+1]=o(n)/2,r+=c(n)-e,s+=a(n)-e,(l-=u(n)-e)<r&&(r=l=(r+l)/2),(h-=f(n)-e)<s&&(s=h=(s+h)/2),t(n,r,s,l,h))}return s.round=function(t){return arguments.length?(n=!!t,s):n},s.size=function(t){return arguments.length?(e=+t[0],r=+t[1],s):[e,r]},s.tile=function(n){return arguments.length?(t=Sl(n),s):t},s.padding=function(t){return arguments.length?s.paddingInner(t).paddingOuter(t):s.paddingInner()},s.paddingInner=function(t){return arguments.length?(o="function"==typeof t?t:kl(+t),s):o},s.paddingOuter=function(t){return arguments.length?s.paddingTop(t).paddingRight(t).paddingBottom(t).paddingLeft(t):s.paddingTop()},s.paddingTop=function(t){return arguments.length?(a="function"==typeof t?t:kl(+t),s):a},s.paddingRight=function(t){return arguments.length?(u="function"==typeof t?t:kl(+t),s):u},s.paddingBottom=function(t){return arguments.length?(f="function"==typeof t?t:kl(+t),s):f},s.paddingLeft=function(t){return arguments.length?(c="function"==typeof t?t:kl(+t),s):c},s},t.treemapBinary=function(t,n,e,r,i){var o,a,u=t.children,f=u.length,c=new Array(f+1);for(c[0]=a=o=0;o<f;++o)c[o+1]=a+=u[o].value;!function t(n,e,r,i,o,a,f){if(n>=e-1){var s=u[n];return s.x0=i,s.y0=o,s.x1=a,void(s.y1=f)}for(var l=c[n],h=r/2+l,d=n+1,p=e-1;d<p;){var v=d+p>>>1;c[v]<h?d=v+1:p=v}h-c[d-1]<c[d]-h&&n+1<d&&--d;var g=c[d]-l,y=r-g;if(a-i>f-o){var _=(i*y+a*g)/r;t(n,d,g,i,o,_,f),t(d,e,y,_,o,a,f)}else{var b=(o*y+f*g)/r;t(n,d,g,i,o,a,b),t(d,e,y,i,b,a,f)}}(0,f,t.value,n,e,r,i)},t.treemapDice=Dl,t.treemapSlice=Vl,t.treemapSliceDice=function(t,n,e,r,i){(1&t.depth?Vl:Dl)(t,n,e,r,i)},t.treemapSquarify=Zl,t.treemapResquarify=Ql,t.interpolate=me,t.interpolateArray=de,t.interpolateBasis=ee,t.interpolateBasisClosed=re,t.interpolateDate=pe,t.interpolateDiscrete=function(t){var n=t.length;return function(e){return t[Math.max(0,Math.min(n-1,Math.floor(e*n)))]}},t.interpolateHue=function(t,n){var e=ae(+t,+n);return function(t){var n=e(t);return n-360*Math.floor(n/360)}},t.interpolateNumber=ve,t.interpolateObject=ge,t.interpolateRound=xe,t.interpolateString=be,t.interpolateTransformCss=Ce,t.interpolateTransformSvg=Pe,t.interpolateZoom=qe,t.interpolateRgb=ce,t.interpolateRgbBasis=le,t.interpolateRgbBasisClosed=he,t.interpolateHsl=Ye,t.interpolateHslLong=Be,t.interpolateLab=function(t,n){var e=fe((t=Un(t)).l,(n=Un(n)).l),r=fe(t.a,n.a),i=fe(t.b,n.b),o=fe(t.opacity,n.opacity);return function(n){return t.l=e(n),t.a=r(n),t.b=i(n),t.opacity=o(n),t+""}},t.interpolateHcl=Ie,t.interpolateHclLong=He,t.interpolateCubehelix=Xe,t.interpolateCubehelixLong=Ge,t.piecewise=function(t,n){for(var e=0,r=n.length-1,i=n[0],o=new Array(r<0?0:r);e<r;)o[e]=t(i,i=n[++e]);return function(t){var n=Math.max(0,Math.min(r-1,Math.floor(t*=r)));return o[n](t-n)}},t.quantize=function(t,n){for(var e=new Array(n),r=0;r<n;++r)e[r]=t(r/(n-1));return e},t.path=Gi,t.polygonArea=function(t){for(var n,e=-1,r=t.length,i=t[r-1],o=0;++e<r;)n=i,i=t[e],o+=n[1]*i[0]-n[0]*i[1];return o/2},t.polygonCentroid=function(t){for(var n,e,r=-1,i=t.length,o=0,a=0,u=t[i-1],f=0;++r<i;)n=u,u=t[r],f+=e=n[0]*u[1]-u[0]*n[1],o+=(n[0]+u[0])*e,a+=(n[1]+u[1])*e;return[o/(f*=3),a/f]},t.polygonHull=function(t){if((e=t.length)<3)return null;var n,e,r=new Array(e),i=new Array(e);for(n=0;n<e;++n)r[n]=[+t[n][0],+t[n][1],n];for(r.sort(Jl),n=0;n<e;++n)i[n]=[r[n][0],-r[n][1]];var o=Kl(r),a=Kl(i),u=a[0]===o[0],f=a[a.length-1]===o[o.length-1],c=[];for(n=o.length-1;n>=0;--n)c.push(t[r[o[n]][2]]);for(n=+u;n<a.length-f;++n)c.push(t[r[a[n]][2]]);return c},t.polygonContains=function(t,n){for(var e,r,i=t.length,o=t[i-1],a=n[0],u=n[1],f=o[0],c=o[1],s=!1,l=0;l<i;++l)e=(o=t[l])[0],(r=o[1])>u!=c>u&&a<(f-e)*(u-r)/(c-r)+e&&(s=!s),f=e,c=r;return s},t.polygonLength=function(t){for(var n,e,r=-1,i=t.length,o=t[i-1],a=o[0],u=o[1],f=0;++r<i;)n=a,e=u,n-=a=(o=t[r])[0],e-=u=o[1],f+=Math.sqrt(n*n+e*e);return f},t.quadtree=ra,t.randomUniform=nh,t.randomNormal=eh,t.randomLogNormal=rh,t.randomBates=oh,t.randomIrwinHall=ih,t.randomExponential=ah,t.scaleBand=hh,t.scalePoint=function(){return function t(n){var e=n.copy;return n.padding=n.paddingOuter,delete n.paddingInner,delete n.paddingOuter,n.copy=function(){return t(e())},n}(hh().paddingInner(1))},t.scaleIdentity=function t(){var n=[0,1];function e(t){return+t}return e.invert=e,e.domain=e.range=function(t){return arguments.length?(n=fh.call(t,ph),e):n.slice()},e.copy=function(){return t().domain(n)},xh(e)},t.scaleLinear=function t(){var n=mh(gh,ve);return n.copy=function(){return bh(n,t())},xh(n)},t.scaleLog=function n(){var e=mh(Mh,Ah).domain([1,10]),r=e.domain,i=10,o=Sh(10),a=Nh(10);function u(){return o=Sh(i),a=Nh(i),r()[0]<0&&(o=Eh(o),a=Eh(a)),e}return e.base=function(t){return arguments.length?(i=+t,u()):i},e.domain=function(t){return arguments.length?(r(t),u()):r()},e.ticks=function(t){var n,e=r(),u=e[0],f=e[e.length-1];(n=f<u)&&(h=u,u=f,f=h);var c,s,l,h=o(u),d=o(f),p=null==t?10:+t,v=[];if(!(i%1)&&d-h<p){if(h=Math.round(h)-1,d=Math.round(d)+1,u>0){for(;h<d;++h)for(s=1,c=a(h);s<i;++s)if(!((l=c*s)<u)){if(l>f)break;v.push(l)}}else for(;h<d;++h)for(s=i-1,c=a(h);s>=1;--s)if(!((l=c*s)<u)){if(l>f)break;v.push(l)}}else v=m(h,d,Math.min(d-h,p)).map(a);return n?v.reverse():v},e.tickFormat=function(n,r){if(null==r&&(r=10===i?".0e":","),"function"!=typeof r&&(r=t.format(r)),n===1/0)return r;null==n&&(n=10);var u=Math.max(1,i*n/e.ticks().length);return function(t){var n=t/a(Math.round(o(t)));return n*i<i-.5&&(n*=i),n<=u?r(t):""}},e.nice=function(){return r(wh(r(),{floor:function(t){return a(Math.floor(o(t)))},ceil:function(t){return a(Math.ceil(o(t)))}}))},e.copy=function(){return bh(e,n().base(i))},e},t.scaleOrdinal=lh,t.scaleImplicit=sh,t.scalePow=Ch,t.scaleSqrt=function(){return Ch().exponent(.5)},t.scaleQuantile=function t(){var e=[],r=[],o=[];function a(){var t=0,n=Math.max(1,r.length);for(o=new Array(n-1);++t<n;)o[t-1]=A(e,t/n);return u}function u(t){if(!isNaN(t=+t))return r[i(o,t)]}return u.invertExtent=function(t){var n=r.indexOf(t);return n<0?[NaN,NaN]:[n>0?o[n-1]:e[0],n<o.length?o[n]:e[e.length-1]]},u.domain=function(t){if(!arguments.length)return e.slice();e=[];for(var r,i=0,o=t.length;i<o;++i)null==(r=t[i])||isNaN(r=+r)||e.push(r);return e.sort(n),a()},u.range=function(t){return arguments.length?(r=ch.call(t),a()):r.slice()},u.quantiles=function(){return o.slice()},u.copy=function(){return t().domain(e).range(r)},u},t.scaleQuantize=function t(){var n=0,e=1,r=1,o=[.5],a=[0,1];function u(t){if(t<=t)return a[i(o,t,0,r)]}function f(){var t=-1;for(o=new Array(r);++t<r;)o[t]=((t+1)*e-(t-r)*n)/(r+1);return u}return u.domain=function(t){return arguments.length?(n=+t[0],e=+t[1],f()):[n,e]},u.range=function(t){return arguments.length?(r=(a=ch.call(t)).length-1,f()):a.slice()},u.invertExtent=function(t){var i=a.indexOf(t);return i<0?[NaN,NaN]:i<1?[n,o[0]]:i>=r?[o[r-1],e]:[o[i-1],o[i]]},u.copy=function(){return t().domain([n,e]).range(a)},xh(u)},t.scaleThreshold=function t(){var n=[.5],e=[0,1],r=1;function o(t){if(t<=t)return e[i(n,t,0,r)]}return o.domain=function(t){return arguments.length?(n=ch.call(t),r=Math.min(n.length,e.length-1),o):n.slice()},o.range=function(t){return arguments.length?(e=ch.call(t),r=Math.min(n.length,e.length-1),o):e.slice()},o.invertExtent=function(t){var r=e.indexOf(t);return[n[r-1],n[r]]},o.copy=function(){return t().domain(n).range(e)},o},t.scaleTime=function(){return cv(cd,ud,Vh,jh,Ih,Bh,Oh,Lh,t.timeFormat).domain([new Date(2e3,0,1),new Date(2e3,0,2)])},t.scaleUtc=function(){return cv(Ld,zd,_d,vd,dd,ld,Oh,Lh,t.utcFormat).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)])},t.scaleSequential=function t(n){var e=0,r=1,i=1,o=!1;function a(t){var r=(t-e)*i;return n(o?Math.max(0,Math.min(1,r)):r)}return a.domain=function(t){return arguments.length?(e=+t[0],r=+t[1],i=e===r?0:1/(r-e),a):[e,r]},a.clamp=function(t){return arguments.length?(o=!!t,a):o},a.interpolator=function(t){return arguments.length?(n=t,a):n},a.copy=function(){return t(n).domain([e,r]).clamp(o)},xh(a)},t.scaleDiverging=function t(n){var e=0,r=.5,i=1,o=1,a=1,u=!1;function f(t){var e=.5+((t=+t)-r)*(t<r?o:a);return n(u?Math.max(0,Math.min(1,e)):e)}return f.domain=function(t){return arguments.length?(e=+t[0],r=+t[1],i=+t[2],o=e===r?0:.5/(r-e),a=r===i?0:.5/(i-r),f):[e,r,i]},f.clamp=function(t){return arguments.length?(u=!!t,f):u},f.interpolator=function(t){return arguments.length?(n=t,f):n},f.copy=function(){return t(n).domain([e,r,i]).clamp(u)},xh(f)},t.schemeCategory10=lv,t.schemeAccent=hv,t.schemeDark2=dv,t.schemePaired=pv,t.schemePastel1=vv,t.schemePastel2=gv,t.schemeSet1=yv,t.schemeSet2=_v,t.schemeSet3=bv,t.interpolateBrBG=wv,t.schemeBrBG=xv,t.interpolatePRGn=Av,t.schemePRGn=Mv,t.interpolatePiYG=Nv,t.schemePiYG=Tv,t.interpolatePuOr=Ev,t.schemePuOr=Sv,t.interpolateRdBu=Cv,t.schemeRdBu=kv,t.interpolateRdGy=zv,t.schemeRdGy=Pv,t.interpolateRdYlBu=Lv,t.schemeRdYlBu=Rv,t.interpolateRdYlGn=Uv,t.schemeRdYlGn=Dv,t.interpolateSpectral=Ov,t.schemeSpectral=qv,t.interpolateBuGn=Bv,t.schemeBuGn=Yv,t.interpolateBuPu=Iv,t.schemeBuPu=Fv,t.interpolateGnBu=jv,t.schemeGnBu=Hv,t.interpolateOrRd=Gv,t.schemeOrRd=Xv,t.interpolatePuBuGn=$v,t.schemePuBuGn=Vv,t.interpolatePuBu=Zv,t.schemePuBu=Wv,t.interpolatePuRd=Jv,t.schemePuRd=Qv,t.interpolateRdPu=tg,t.schemeRdPu=Kv,t.interpolateYlGnBu=eg,t.schemeYlGnBu=ng,t.interpolateYlGn=ig,t.schemeYlGn=rg,t.interpolateYlOrBr=ag,t.schemeYlOrBr=og,t.interpolateYlOrRd=fg,t.schemeYlOrRd=ug,t.interpolateBlues=sg,t.schemeBlues=cg,t.interpolateGreens=hg,t.schemeGreens=lg,t.interpolateGreys=pg,t.schemeGreys=dg,t.interpolatePurples=gg,t.schemePurples=vg,t.interpolateReds=_g,t.schemeReds=yg,t.interpolateOranges=mg,t.schemeOranges=bg,t.interpolateCubehelixDefault=xg,t.interpolateRainbow=function(t){(t<0||t>1)&&(t-=Math.floor(t));var n=Math.abs(t-.5);return Ag.h=360*t-100,Ag.s=1.5-1.5*n,Ag.l=.8-.9*n,Ag+""},t.interpolateWarm=wg,t.interpolateCool=Mg,t.interpolateSinebow=function(t){var n;return t=(.5-t)*Math.PI,Tg.r=255*(n=Math.sin(t))*n,Tg.g=255*(n=Math.sin(t+Ng))*n,Tg.b=255*(n=Math.sin(t+Sg))*n,Tg+""},t.interpolateViridis=kg,t.interpolateMagma=Cg,t.interpolateInferno=Pg,t.interpolatePlasma=zg,t.create=function(t){return Dt(W(t).call(document.documentElement))},t.creator=W,t.local=qt,t.matcher=rt,t.mouse=Ft,t.namespace=$,t.namespaces=V,t.clientPoint=Bt,t.select=Dt,t.selectAll=function(t){return"string"==typeof t?new Rt([document.querySelectorAll(t)],[document.documentElement]):new Rt([null==t?[]:t],zt)},t.selection=Lt,t.selector=Q,t.selectorAll=K,t.style=lt,t.touch=It,t.touches=function(t,n){null==n&&(n=Yt().touches);for(var e=0,r=n?n.length:0,i=new Array(r);e<r;++e)i[e]=Bt(t,n[e]);return i},t.window=st,t.customEvent=Ct,t.arc=function(){var t=Gg,n=Vg,e=Rg(0),r=null,i=$g,o=Wg,a=Zg,u=null;function f(){var f,c,s,l=+t.apply(this,arguments),h=+n.apply(this,arguments),d=i.apply(this,arguments)-Hg,p=o.apply(this,arguments)-Hg,v=Lg(p-d),g=p>d;if(u||(u=f=Gi()),h<l&&(c=h,h=l,l=c),h>Fg)if(v>jg-Fg)u.moveTo(h*Ug(d),h*Yg(d)),u.arc(0,0,h,d,p,!g),l>Fg&&(u.moveTo(l*Ug(p),l*Yg(p)),u.arc(0,0,l,p,d,g));else{var y,_,b=d,m=p,x=d,w=p,M=v,A=v,T=a.apply(this,arguments)/2,N=T>Fg&&(r?+r.apply(this,arguments):Bg(l*l+h*h)),S=Og(Lg(h-l)/2,+e.apply(this,arguments)),E=S,k=S;if(N>Fg){var C=Xg(N/l*Yg(T)),P=Xg(N/h*Yg(T));(M-=2*C)>Fg?(x+=C*=g?1:-1,w-=C):(M=0,x=w=(d+p)/2),(A-=2*P)>Fg?(b+=P*=g?1:-1,m-=P):(A=0,b=m=(d+p)/2)}var z=h*Ug(b),R=h*Yg(b),L=l*Ug(w),D=l*Yg(w);if(S>Fg){var U=h*Ug(m),q=h*Yg(m),O=l*Ug(x),Y=l*Yg(x);if(v<Ig){var B=M>Fg?function(t,n,e,r,i,o,a,u){var f=e-t,c=r-n,s=a-i,l=u-o,h=(s*(n-o)-l*(t-i))/(l*f-s*c);return[t+h*f,n+h*c]}(z,R,O,Y,U,q,L,D):[L,D],F=z-B[0],I=R-B[1],H=U-B[0],j=q-B[1],X=1/Yg(((s=(F*H+I*j)/(Bg(F*F+I*I)*Bg(H*H+j*j)))>1?0:s<-1?Ig:Math.acos(s))/2),G=Bg(B[0]*B[0]+B[1]*B[1]);E=Og(S,(l-G)/(X-1)),k=Og(S,(h-G)/(X+1))}}A>Fg?k>Fg?(y=Qg(O,Y,z,R,h,k,g),_=Qg(U,q,L,D,h,k,g),u.moveTo(y.cx+y.x01,y.cy+y.y01),k<S?u.arc(y.cx,y.cy,k,Dg(y.y01,y.x01),Dg(_.y01,_.x01),!g):(u.arc(y.cx,y.cy,k,Dg(y.y01,y.x01),Dg(y.y11,y.x11),!g),u.arc(0,0,h,Dg(y.cy+y.y11,y.cx+y.x11),Dg(_.cy+_.y11,_.cx+_.x11),!g),u.arc(_.cx,_.cy,k,Dg(_.y11,_.x11),Dg(_.y01,_.x01),!g))):(u.moveTo(z,R),u.arc(0,0,h,b,m,!g)):u.moveTo(z,R),l>Fg&&M>Fg?E>Fg?(y=Qg(L,D,U,q,l,-E,g),_=Qg(z,R,O,Y,l,-E,g),u.lineTo(y.cx+y.x01,y.cy+y.y01),E<S?u.arc(y.cx,y.cy,E,Dg(y.y01,y.x01),Dg(_.y01,_.x01),!g):(u.arc(y.cx,y.cy,E,Dg(y.y01,y.x01),Dg(y.y11,y.x11),!g),u.arc(0,0,l,Dg(y.cy+y.y11,y.cx+y.x11),Dg(_.cy+_.y11,_.cx+_.x11),g),u.arc(_.cx,_.cy,E,Dg(_.y11,_.x11),Dg(_.y01,_.x01),!g))):u.arc(0,0,l,w,x,g):u.lineTo(L,D)}else u.moveTo(0,0);if(u.closePath(),f)return u=null,f+""||null}return f.centroid=function(){var e=(+t.apply(this,arguments)+ +n.apply(this,arguments))/2,r=(+i.apply(this,arguments)+ +o.apply(this,arguments))/2-Ig/2;return[Ug(r)*e,Yg(r)*e]},f.innerRadius=function(n){return arguments.length?(t="function"==typeof n?n:Rg(+n),f):t},f.outerRadius=function(t){return arguments.length?(n="function"==typeof t?t:Rg(+t),f):n},f.cornerRadius=function(t){return arguments.length?(e="function"==typeof t?t:Rg(+t),f):e},f.padRadius=function(t){return arguments.length?(r=null==t?null:"function"==typeof t?t:Rg(+t),f):r},f.startAngle=function(t){return arguments.length?(i="function"==typeof t?t:Rg(+t),f):i},f.endAngle=function(t){return arguments.length?(o="function"==typeof t?t:Rg(+t),f):o},f.padAngle=function(t){return arguments.length?(a="function"==typeof t?t:Rg(+t),f):a},f.context=function(t){return arguments.length?(u=null==t?null:t,f):u},f},t.area=ry,t.line=ey,t.pie=function(){var t=oy,n=iy,e=null,r=Rg(0),i=Rg(jg),o=Rg(0);function a(a){var u,f,c,s,l,h=a.length,d=0,p=new Array(h),v=new Array(h),g=+r.apply(this,arguments),y=Math.min(jg,Math.max(-jg,i.apply(this,arguments)-g)),_=Math.min(Math.abs(y)/h,o.apply(this,arguments)),b=_*(y<0?-1:1);for(u=0;u<h;++u)(l=v[p[u]=u]=+t(a[u],u,a))>0&&(d+=l);for(null!=n?p.sort(function(t,e){return n(v[t],v[e])}):null!=e&&p.sort(function(t,n){return e(a[t],a[n])}),u=0,c=d?(y-h*b)/d:0;u<h;++u,g=s)f=p[u],s=g+((l=v[f])>0?l*c:0)+b,v[f]={data:a[f],index:u,value:l,startAngle:g,endAngle:s,padAngle:_};return v}return a.value=function(n){return arguments.length?(t="function"==typeof n?n:Rg(+n),a):t},a.sortValues=function(t){return arguments.length?(n=t,e=null,a):n},a.sort=function(t){return arguments.length?(e=t,n=null,a):e},a.startAngle=function(t){return arguments.length?(r="function"==typeof t?t:Rg(+t),a):r},a.endAngle=function(t){return arguments.length?(i="function"==typeof t?t:Rg(+t),a):i},a.padAngle=function(t){return arguments.length?(o="function"==typeof t?t:Rg(+t),a):o},a},t.areaRadial=ly,t.radialArea=ly,t.lineRadial=sy,t.radialLine=sy,t.pointRadial=hy,t.linkHorizontal=function(){return gy(yy)},t.linkVertical=function(){return gy(_y)},t.linkRadial=function(){var t=gy(by);return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t},t.symbol=function(){var t=Rg(my),n=Rg(64),e=null;function r(){var r;if(e||(e=r=Gi()),t.apply(this,arguments).draw(e,+n.apply(this,arguments)),r)return e=null,r+""||null}return r.type=function(n){return arguments.length?(t="function"==typeof n?n:Rg(n),r):t},r.size=function(t){return arguments.length?(n="function"==typeof t?t:Rg(+t),r):n},r.context=function(t){return arguments.length?(e=null==t?null:t,r):e},r},t.symbols=Uy,t.symbolCircle=my,t.symbolCross=xy,t.symbolDiamond=Ay,t.symbolSquare=ky,t.symbolStar=Ey,t.symbolTriangle=Py,t.symbolWye=Dy,t.curveBasisClosed=function(t){return new By(t)},t.curveBasisOpen=function(t){return new Fy(t)},t.curveBasis=function(t){return new Yy(t)},t.curveBundle=Hy,t.curveCardinalClosed=$y,t.curveCardinalOpen=Zy,t.curveCardinal=Gy,t.curveCatmullRomClosed=n_,t.curveCatmullRomOpen=r_,t.curveCatmullRom=Ky,t.curveLinearClosed=function(t){return new i_(t)},t.curveLinear=Kg,t.curveMonotoneX=function(t){return new c_(t)},t.curveMonotoneY=function(t){return new s_(t)},t.curveNatural=function(t){return new h_(t)},t.curveStep=function(t){return new p_(t,.5)},t.curveStepAfter=function(t){return new p_(t,1)},t.curveStepBefore=function(t){return new p_(t,0)},t.stack=function(){var t=Rg([]),n=g_,e=v_,r=y_;function i(i){var o,a,u=t.apply(this,arguments),f=i.length,c=u.length,s=new Array(c);for(o=0;o<c;++o){for(var l,h=u[o],d=s[o]=new Array(f),p=0;p<f;++p)d[p]=l=[0,+r(i[p],h,p,i)],l.data=i[p];d.key=h}for(o=0,a=n(s);o<c;++o)s[a[o]].index=o;return e(s,a),s}return i.keys=function(n){return arguments.length?(t="function"==typeof n?n:Rg(dy.call(n)),i):t},i.value=function(t){return arguments.length?(r="function"==typeof t?t:Rg(+t),i):r},i.order=function(t){return arguments.length?(n=null==t?g_:"function"==typeof t?t:Rg(dy.call(t)),i):n},i.offset=function(t){return arguments.length?(e=null==t?v_:t,i):e},i},t.stackOffsetExpand=function(t,n){if((r=t.length)>0){for(var e,r,i,o=0,a=t[0].length;o<a;++o){for(i=e=0;e<r;++e)i+=t[e][o][1]||0;if(i)for(e=0;e<r;++e)t[e][o][1]/=i}v_(t,n)}},t.stackOffsetDiverging=function(t,n){if((u=t.length)>1)for(var e,r,i,o,a,u,f=0,c=t[n[0]].length;f<c;++f)for(o=a=0,e=0;e<u;++e)(i=(r=t[n[e]][f])[1]-r[0])>=0?(r[0]=o,r[1]=o+=i):i<0?(r[1]=a,r[0]=a+=i):r[0]=o},t.stackOffsetNone=v_,t.stackOffsetSilhouette=function(t,n){if((e=t.length)>0){for(var e,r=0,i=t[n[0]],o=i.length;r<o;++r){for(var a=0,u=0;a<e;++a)u+=t[a][r][1]||0;i[r][1]+=i[r][0]=-u/2}v_(t,n)}},t.stackOffsetWiggle=function(t,n){if((i=t.length)>0&&(r=(e=t[n[0]]).length)>0){for(var e,r,i,o=0,a=1;a<r;++a){for(var u=0,f=0,c=0;u<i;++u){for(var s=t[n[u]],l=s[a][1]||0,h=(l-(s[a-1][1]||0))/2,d=0;d<u;++d){var p=t[n[d]];h+=(p[a][1]||0)-(p[a-1][1]||0)}f+=l,c+=h*l}e[a-1][1]+=e[a-1][0]=o,f&&(o-=c/f)}e[a-1][1]+=e[a-1][0]=o,v_(t,n)}},t.stackOrderAscending=__,t.stackOrderDescending=function(t){return __(t).reverse()},t.stackOrderInsideOut=function(t){var n,e,r=t.length,i=t.map(b_),o=g_(t).sort(function(t,n){return i[n]-i[t]}),a=0,u=0,f=[],c=[];for(n=0;n<r;++n)e=o[n],a<u?(a+=i[e],f.push(e)):(u+=i[e],c.push(e));return c.reverse().concat(f)},t.stackOrderNone=g_,t.stackOrderReverse=function(t){return g_(t).reverse()},t.timeInterval=Rh,t.timeMillisecond=Lh,t.timeMilliseconds=Dh,t.utcMillisecond=Lh,t.utcMilliseconds=Dh,t.timeSecond=Oh,t.timeSeconds=Yh,t.utcSecond=Oh,t.utcSeconds=Yh,t.timeMinute=Bh,t.timeMinutes=Fh,t.timeHour=Ih,t.timeHours=Hh,t.timeDay=jh,t.timeDays=Xh,t.timeWeek=Vh,t.timeWeeks=td,t.timeSunday=Vh,t.timeSundays=td,t.timeMonday=$h,t.timeMondays=nd,t.timeTuesday=Wh,t.timeTuesdays=ed,t.timeWednesday=Zh,t.timeWednesdays=rd,t.timeThursday=Qh,t.timeThursdays=id,t.timeFriday=Jh,t.timeFridays=od,t.timeSaturday=Kh,t.timeSaturdays=ad,t.timeMonth=ud,t.timeMonths=fd,t.timeYear=cd,t.timeYears=sd,t.utcMinute=ld,t.utcMinutes=hd,t.utcHour=dd,t.utcHours=pd,t.utcDay=vd,t.utcDays=gd,t.utcWeek=_d,t.utcWeeks=Td,t.utcSunday=_d,t.utcSundays=Td,t.utcMonday=bd,t.utcMondays=Nd,t.utcTuesday=md,t.utcTuesdays=Sd,t.utcWednesday=xd,t.utcWednesdays=Ed,t.utcThursday=wd,t.utcThursdays=kd,t.utcFriday=Md,t.utcFridays=Cd,t.utcSaturday=Ad,t.utcSaturdays=Pd,t.utcMonth=zd,t.utcMonths=Rd,t.utcYear=Ld,t.utcYears=Dd,t.timeFormatDefaultLocale=Qp,t.timeFormatLocale=Yd,t.isoFormat=Jp,t.isoParse=Kp,t.now=ir,t.timer=ur,t.timerFlush=fr,t.timeout=hr,t.interval=function(t,n,e){var r=new ar,i=n;return null==n?(r.restart(t,n,e),r):(n=+n,e=null==e?ir():+e,r.restart(function o(a){a+=i,r.restart(o,i+=n,e),t(a)},n,e),r)},t.transition=zr,t.active=function(t,n){var e,r,i=t.__transition;if(i)for(r in n=null==n?null:n+"",i)if((e=i[r]).state>gr&&e.name===n)return new Pr([[t]],li,n,+r);return null},t.interrupt=Nr,t.voronoi=function(){var t=x_,n=w_,e=null;function r(r){return new eb(r.map(function(e,i){var o=[Math.round(t(e,i,r)/K_)*K_,Math.round(n(e,i,r)/K_)*K_];return o.index=i,o.data=e,o}),e)}return r.polygons=function(t){return r(t).polygons()},r.links=function(t){return r(t).links()},r.triangles=function(t){return r(t).triangles()},r.x=function(n){return arguments.length?(t="function"==typeof n?n:m_(+n),r):t},r.y=function(t){return arguments.length?(n="function"==typeof t?t:m_(+t),r):n},r.extent=function(t){return arguments.length?(e=null==t?null:[[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]],r):e&&[[e[0][0],e[0][1]],[e[1][0],e[1][1]]]},r.size=function(t){return arguments.length?(e=null==t?null:[[0,0],[+t[0],+t[1]]],r):e&&[e[1][0]-e[0][0],e[1][1]-e[0][1]]},r},t.zoom=function(){var n,e,r=sb,i=lb,o=vb,a=db,u=pb,f=[0,1/0],c=[[-1/0,-1/0],[1/0,1/0]],s=250,l=qe,h=[],d=I("start","zoom","end"),p=500,v=150,g=0;function y(t){t.property("__zoom",hb).on("wheel.zoom",A).on("mousedown.zoom",T).on("dblclick.zoom",N).filter(u).on("touchstart.zoom",S).on("touchmove.zoom",E).on("touchend.zoom touchcancel.zoom",k).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function _(t,n){return(n=Math.max(f[0],Math.min(f[1],n)))===t.k?t:new ob(n,t.x,t.y)}function b(t,n,e){var r=n[0]-e[0]*t.k,i=n[1]-e[1]*t.k;return r===t.x&&i===t.y?t:new ob(t.k,r,i)}function m(t){return[(+t[0][0]+ +t[1][0])/2,(+t[0][1]+ +t[1][1])/2]}function x(t,n,e){t.on("start.zoom",function(){w(this,arguments).start()}).on("interrupt.zoom end.zoom",function(){w(this,arguments).end()}).tween("zoom",function(){var t=arguments,r=w(this,t),o=i.apply(this,t),a=e||m(o),u=Math.max(o[1][0]-o[0][0],o[1][1]-o[0][1]),f=this.__zoom,c="function"==typeof n?n.apply(this,t):n,s=l(f.invert(a).concat(u/f.k),c.invert(a).concat(u/c.k));return function(t){if(1===t)t=c;else{var n=s(t),e=u/n[2];t=new ob(e,a[0]-n[0]*e,a[1]-n[1]*e)}r.zoom(null,t)}})}function w(t,n){for(var e,r=0,i=h.length;r<i;++r)if((e=h[r]).that===t)return e;return new M(t,n)}function M(t,n){this.that=t,this.args=n,this.index=-1,this.active=0,this.extent=i.apply(t,n)}function A(){if(r.apply(this,arguments)){var t=w(this,arguments),n=this.__zoom,e=Math.max(f[0],Math.min(f[1],n.k*Math.pow(2,a.apply(this,arguments)))),i=Ft(this);if(t.wheel)t.mouse[0][0]===i[0]&&t.mouse[0][1]===i[1]||(t.mouse[1]=n.invert(t.mouse[0]=i)),clearTimeout(t.wheel);else{if(n.k===e)return;t.mouse=[i,n.invert(i)],Nr(this),t.start()}cb(),t.wheel=setTimeout(function(){t.wheel=null,t.end()},v),t.zoom("mouse",o(b(_(n,e),t.mouse[0],t.mouse[1]),t.extent,c))}}function T(){if(!e&&r.apply(this,arguments)){var n=w(this,arguments),i=Dt(t.event.view).on("mousemove.zoom",function(){if(cb(),!n.moved){var e=t.event.clientX-u,r=t.event.clientY-f;n.moved=e*e+r*r>g}n.zoom("mouse",o(b(n.that.__zoom,n.mouse[0]=Ft(n.that),n.mouse[1]),n.extent,c))},!0).on("mouseup.zoom",function(){i.on("mousemove.zoom mouseup.zoom",null),Gt(t.event.view,n.moved),cb(),n.end()},!0),a=Ft(this),u=t.event.clientX,f=t.event.clientY;Xt(t.event.view),fb(),n.mouse=[a,this.__zoom.invert(a)],Nr(this),n.start()}}function N(){if(r.apply(this,arguments)){var n=this.__zoom,e=Ft(this),a=n.invert(e),u=n.k*(t.event.shiftKey?.5:2),f=o(b(_(n,u),e,a),i.apply(this,arguments),c);cb(),s>0?Dt(this).transition().duration(s).call(x,f,e):Dt(this).call(y.transform,f)}}function S(){if(r.apply(this,arguments)){var e,i,o,a,u=w(this,arguments),f=t.event.changedTouches,c=f.length;for(fb(),i=0;i<c;++i)a=[a=It(this,f,(o=f[i]).identifier),this.__zoom.invert(a),o.identifier],u.touch0?u.touch1||(u.touch1=a):(u.touch0=a,e=!0);if(n&&(n=clearTimeout(n),!u.touch1))return u.end(),void((a=Dt(this).on("dblclick.zoom"))&&a.apply(this,arguments));e&&(n=setTimeout(function(){n=null},p),Nr(this),u.start())}}function E(){var e,r,i,a,u=w(this,arguments),f=t.event.changedTouches,s=f.length;for(cb(),n&&(n=clearTimeout(n)),e=0;e<s;++e)i=It(this,f,(r=f[e]).identifier),u.touch0&&u.touch0[2]===r.identifier?u.touch0[0]=i:u.touch1&&u.touch1[2]===r.identifier&&(u.touch1[0]=i);if(r=u.that.__zoom,u.touch1){var l=u.touch0[0],h=u.touch0[1],d=u.touch1[0],p=u.touch1[1],v=(v=d[0]-l[0])*v+(v=d[1]-l[1])*v,g=(g=p[0]-h[0])*g+(g=p[1]-h[1])*g;r=_(r,Math.sqrt(v/g)),i=[(l[0]+d[0])/2,(l[1]+d[1])/2],a=[(h[0]+p[0])/2,(h[1]+p[1])/2]}else{if(!u.touch0)return;i=u.touch0[0],a=u.touch0[1]}u.zoom("touch",o(b(r,i,a),u.extent,c))}function k(){var n,r,i=w(this,arguments),o=t.event.changedTouches,a=o.length;for(fb(),e&&clearTimeout(e),e=setTimeout(function(){e=null},p),n=0;n<a;++n)r=o[n],i.touch0&&i.touch0[2]===r.identifier?delete i.touch0:i.touch1&&i.touch1[2]===r.identifier&&delete i.touch1;i.touch1&&!i.touch0&&(i.touch0=i.touch1,delete i.touch1),i.touch0?i.touch0[1]=this.__zoom.invert(i.touch0[0]):i.end()}return y.transform=function(t,n){var e=t.selection?t.selection():t;e.property("__zoom",hb),t!==e?x(t,n):e.interrupt().each(function(){w(this,arguments).start().zoom(null,"function"==typeof n?n.apply(this,arguments):n).end()})},y.scaleBy=function(t,n){y.scaleTo(t,function(){return this.__zoom.k*("function"==typeof n?n.apply(this,arguments):n)})},y.scaleTo=function(t,n){y.transform(t,function(){var t=i.apply(this,arguments),e=this.__zoom,r=m(t),a=e.invert(r),u="function"==typeof n?n.apply(this,arguments):n;return o(b(_(e,u),r,a),t,c)})},y.translateBy=function(t,n,e){y.transform(t,function(){return o(this.__zoom.translate("function"==typeof n?n.apply(this,arguments):n,"function"==typeof e?e.apply(this,arguments):e),i.apply(this,arguments),c)})},y.translateTo=function(t,n,e){y.transform(t,function(){var t=i.apply(this,arguments),r=this.__zoom,a=m(t);return o(ab.translate(a[0],a[1]).scale(r.k).translate("function"==typeof n?-n.apply(this,arguments):-n,"function"==typeof e?-e.apply(this,arguments):-e),t,c)})},M.prototype={start:function(){return 1==++this.active&&(this.index=h.push(this)-1,this.emit("start")),this},zoom:function(t,n){return this.mouse&&"mouse"!==t&&(this.mouse[1]=n.invert(this.mouse[0])),this.touch0&&"touch"!==t&&(this.touch0[1]=n.invert(this.touch0[0])),this.touch1&&"touch"!==t&&(this.touch1[1]=n.invert(this.touch1[0])),this.that.__zoom=n,this.emit("zoom"),this},end:function(){return 0==--this.active&&(h.splice(this.index,1),this.index=-1,this.emit("end")),this},emit:function(t){Ct(new ib(y,t,this.that.__zoom),d.apply,d,[t,this.that,this.args])}},y.wheelDelta=function(t){return arguments.length?(a="function"==typeof t?t:rb(+t),y):a},y.filter=function(t){return arguments.length?(r="function"==typeof t?t:rb(!!t),y):r},y.touchable=function(t){return arguments.length?(u="function"==typeof t?t:rb(!!t),y):u},y.extent=function(t){return arguments.length?(i="function"==typeof t?t:rb([[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]]),y):i},y.scaleExtent=function(t){return arguments.length?(f[0]=+t[0],f[1]=+t[1],y):[f[0],f[1]]},y.translateExtent=function(t){return arguments.length?(c[0][0]=+t[0][0],c[1][0]=+t[1][0],c[0][1]=+t[0][1],c[1][1]=+t[1][1],y):[[c[0][0],c[0][1]],[c[1][0],c[1][1]]]},y.constrain=function(t){return arguments.length?(o=t,y):o},y.duration=function(t){return arguments.length?(s=+t,y):s},y.interpolate=function(t){return arguments.length?(l=t,y):l},y.on=function(){var t=d.on.apply(d,arguments);return t===d?y:t},y.clickDistance=function(t){return arguments.length?(g=(t=+t)*t,y):Math.sqrt(g)},y},t.zoomTransform=ub,t.zoomIdentity=ab,Object.defineProperty(t,"__esModule",{value:!0})});

//# sourceURL=build://tf-color-scale/palettes.js
var pf;
(function(b){b.palettes={googleStandard:"#db4437 #ff7043 #f4b400 #0f9d58 #00796b #00acc1 #4285f4 #5c6bc0 #ab47bc".split(" "),googleCool:"#9e9d24 #0f9d58 #00796b #00acc1 #4285f4 #5c6bc0 #607d8b".split(" "),googleWarm:"#795548 #ab47bc #f06292 #c2185b #db4437 #ff7043 #f4b400".split(" "),googleColorBlindAssist:"#ff7043 #00ACC1 #AB47BC #2A56C6 #0b8043 #F7CB4D #c0ca33 #5e35b1 #A52714".split(" "),tensorboardColorBlindAssist:"#ff7043 #0077bb #cc3311 #33bbee #ee3377 #009988 #bbbbbb".split(" "),colorBlindAssist1:"#4477aa #44aaaa #aaaa44 #aa7744 #aa4455 #aa4488".split(" "),colorBlindAssist2:"#88ccee #44aa99 #117733 #999933 #ddcc77 #cc6677 #882255 #aa4499".split(" "),
colorBlindAssist3:"#332288 #6699cc #88ccee #44aa99 #117733 #999933 #ddcc77 #cc6677 #aa4466 #882255 #661100 #aa4499".split(" "),colorBlindAssist4:"#4477aa #66ccee #228833 #ccbb44 #ee6677 #aa3377 #bbbbbb".split(" "),colorBlindAssist5:"#FF6DB6 #920000 #924900 #DBD100 #24FF24 #006DDB #490092".split(" "),mldash:"#E47EAD #F4640D #FAA300 #F5E636 #00A077 #0077B8 #00B7ED".split(" ")};b.standard=b.palettes.tensorboardColorBlindAssist})(pf||(pf={}));

//# sourceURL=build://tf-color-scale/colorScale.js
(function(b){function d(h,k){function t(){l.setDomain(k())}const l=new f;h.addListener(t);t();return p=>l.getColor(p)}class f{constructor(h=b.standard){this.palette=h;this.identifiers=d3.map()}setDomain(h){this.identifiers=d3.map();h.forEach((k,t)=>{this.identifiers.set(k,this.palette[t%this.palette.length])})}getColor(h){if(!this.identifiers.has(h))throw Error(`String ${h} was not in the domain.`);return this.identifiers.get(h)}}b.ColorScale=f;b.runsColorScale=d(vc.runsStore,()=>vc.runsStore.getRuns());
b.experimentsColorScale=d(vc.experimentsStore,()=>vc.experimentsStore.getExperiments().map(({name:h})=>h))})(pf||(pf={}));

//# sourceURL=build://paper-icon-button/paper-icon-button.html.js
Polymer({is:"paper-icon-button",hostAttributes:{role:"button",tabindex:"0"},behaviors:[Polymer.PaperInkyFocusBehavior],properties:{src:{type:String},icon:{type:String},alt:{type:String,observer:"_altChanged"}},_altChanged:function(b,d){var f=this.getAttribute("aria-label");f&&d!=f||this.setAttribute("aria-label",b)}});

//# sourceURL=build://tf-dashboard-common/tf-multi-checkbox.js
(function(){Polymer({is:"tf-multi-checkbox",properties:{names:{type:Array,value:()=>[]},coloring:{type:Object,value:{getColor:()=>""}},regex:{type:String,notify:!0,value:""},_regex:{type:Object,computed:"_makeRegex(regex)"},namesMatchingRegex:{type:Array,computed:"computeNamesMatchingRegex(names.*, _regex)"},selectionState:{type:Object,notify:!0,value:()=>({})},outSelected:{type:Array,notify:!0,computed:"computeOutSelected(namesMatchingRegex.*, selectionState.*)"},maxNamesToEnableByDefault:{type:Number,
value:40},_debouncedRegexChange:{type:Object,value:function(){var b=_.debounce(d=>{this.regex=d},150,{leading:!1});return function(){var d=this.$$("#names-regex").value;""==d?this.async(()=>{this.regex=d},30):b(d)}}}},observers:["_setIsolatorIcon(selectionState, names)"],_makeRegex:function(b){try{return new RegExp(b)}catch(d){return null}},_setIsolatorIcon:function(){var b=this.selectionState,d=_.filter(_.values(b)).length;Array.prototype.slice.call(this.root.querySelectorAll(".isolator")).forEach(function(f){f.icon=
1===d&&b[f.name]?"radio-button-checked":"radio-button-unchecked"})},computeNamesMatchingRegex:function(){const b=this._regex;return b?this.names.filter(d=>b.test(d)):this.names},computeOutSelected:function(){var b=this.selectionState,d=this.namesMatchingRegex.length<=this.maxNamesToEnableByDefault;return this.namesMatchingRegex.filter(f=>null==b[f]?d:b[f])},synchronizeColors:function(){this._setIsolatorIcon();this.root.querySelectorAll("paper-checkbox").forEach(b=>{const d=this.coloring.getColor(b.name);
b.updateStyles({"--paper-checkbox-checked-color":d,"--paper-checkbox-checked-ink-color":d,"--paper-checkbox-unchecked-color":d,"--paper-checkbox-unchecked-ink-color":d})});this.root.querySelectorAll(".isolator").forEach(b=>{const d=this.coloring.getColor(b.name);b.style.color=d});window.requestAnimationFrame(()=>{this.updateStyles()})},_isolateName:function(b){var d=Polymer.dom(b).localTarget.name,f={};this.names.forEach(function(h){f[h]=h==d});this.selectionState=f},_checkboxChange:function(b){b=
Polymer.dom(b).localTarget;const d=_.clone(this.selectionState);d[b.name]=b.checked;this.selectionState=d},_isChecked:function(b){return-1!=this.outSelected.indexOf(b)},toggleAll:function(){const b=this.namesMatchingRegex.some(f=>this.outSelected.includes(f)),d={};this.names.forEach(f=>{d[f]=!b});this.selectionState=d}})})(qd||(qd={}));

//# sourceURL=build://tf-runs-selector/tf-wbr-string.html.js
Polymer({is:"tf-wbr-string",properties:{value:String,_parts:{type:Array,computed:"_computeParts(value)"}},_computeParts(b){const d=[],f=/[/=_,-]/;for(null==b&&(b="");;){const h=b.search(f);if(-1===h){d.push(b);break}else d.push(b.slice(0,h+1)),b=b.slice(h+1)}return d}});

//# sourceURL=build://tf-runs-selector/tf-runs-selector.html.js
Polymer({is:"tf-runs-selector",properties:{runSelectionState:{type:Object,observer:"_storeRunSelectionState",value:pd.getObjectInitializer("runSelectionState",{defaultValue:{}})},regexInput:{type:String,value:pd.getStringInitializer("regexInput",{defaultValue:""}),observer:"_regexObserver"},selectedRuns:{type:Array,notify:!0},runs:Array,dataLocation:{type:String,notify:!0},_clippedDataLocation:{type:String,computed:"_getClippedDataLocation(dataLocation, _dataLocationClipLength)"},_dataLocationClipLength:{type:Number,
value:250,readOnly:!0},coloring:{type:Object,value:{getColor:pf.runsColorScale}}},attached(){this._runStoreListener=vc.runsStore.addListener(()=>{this.set("runs",vc.runsStore.getRuns())});this.set("runs",vc.runsStore.getRuns());this._envStoreListener=vc.environmentStore.addListener(()=>{this.set("dataLocation",vc.environmentStore.getDataLocation())});this.set("dataLocation",vc.environmentStore.getDataLocation())},detached(){vc.runsStore.removeListenerByKey(this._runStoreListener);vc.environmentStore.removeListenerByKey(this._envStoreListener)},
_toggleAll:function(){this.$.multiCheckbox.toggleAll()},_getClippedDataLocation:function(b,d){if(void 0!==b&&!(b.length>d))return b},_openDataLocationDialog:function(b){b.preventDefault();this.$$("#data-location-dialog").open()},_shouldShowExpandDataLocationButton(b,d){return b&&b.length>d},_storeRunSelectionState:pd.getObjectObserver("runSelectionState",{defaultValue:{}}),_regexObserver:pd.getStringObserver("regexInput",{defaultValue:""})});

//# sourceURL=build://tf-tensorboard/registry.js
var qf;
(function(b){(function(d){d.NOT_LOADED="NOT_LOADED";d.LOADED="LOADED";d.FAILED="FAILED"})(b.ActiveDashboardsLoadState||(b.ActiveDashboardsLoadState={}));b.dashboardRegistry={};b.registerDashboard=function(){var d={plugin:"beholder",elementName:"tf-beholder-dashboard",shouldRemoveDom:!0};if(!d.plugin)throw Error("Dashboard.plugin must be present");if(!d.elementName)throw Error("Dashboard.elementName must be present");if(d.plugin in b.dashboardRegistry)throw Error(`Plugin already registered: ${d.plugin}`);d.tabName||
(d.tabName=d.plugin);b.dashboardRegistry[d.plugin]=d}})(qf||(qf={}));

//# sourceURL=build://tf-utils/utils.js
var rf;
(function(b){function d(f,h,k){return 1===f?h:k}b.aggregateTagInfo=function(f,h){let k=void 0;const t={};Object.keys(f).forEach(p=>{const m=f[p];void 0===k&&(k=m.displayName);k!==m.displayName&&(k=null);void 0===t[m.description]&&(t[m.description]=[]);t[m.description].push(p)});h=null!=k?k:h;const l=(()=>{const p=Object.keys(t);return 0===p.length?"":1===p.length?p[0]:`${"\x3cp\x3e\x3cstrong\x3eMultiple descriptions:\x3c/strong\x3e\x3c/p\x3e"}<ul>${p.map(m=>{const n=t[m].map(u=>`<code>${u.replace(/</g,"\x26lt;").replace(/>/g,
"\x26gt;").replace(/&/g,"\x26amp;")}</code>`),q=2<n.length?n.slice(0,n.length-1).join(", ")+", and "+n[n.length-1]:n.join(" and ");return`<li><p>For ${d(n.length,"run","runs")} ${q}:</p>${m}</li>`}).join("")}</ul>`})();return{displayName:h,description:l}}})(rf||(rf={}));

//# sourceURL=build://paper-spinner/paper-spinner-behavior.html.js
Polymer.PaperSpinnerBehavior={properties:{active:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"__activeChanged"},alt:{type:String,value:"loading",observer:"__altChanged"},__coolingDown:{type:Boolean,value:!1}},__computeContainerClasses:function(b,d){return[b||d?"active":"",d?"cooldown":""].join(" ")},__activeChanged:function(b,d){this.__setAriaHidden(!b);this.__coolingDown=!b&&d},__altChanged:function(b){"loading"===b?this.alt=this.getAttribute("aria-label")||b:(this.__setAriaHidden(""===
b),this.setAttribute("aria-label",b))},__setAriaHidden:function(b){b?this.setAttribute("aria-hidden","true"):this.removeAttribute("aria-hidden")},__reset:function(){this.__coolingDown=this.active=!1}};

//# sourceURL=build://paper-spinner/paper-spinner-lite.html.js
Polymer({is:"paper-spinner-lite",behaviors:[Polymer.PaperSpinnerBehavior]});

//# sourceURL=build://tf-dashboard-common/data-loader-behavior.js
(function(b){let d;(function(f){f[f.LOADING=0]="LOADING";f[f.LOADED=1]="LOADED"})(d||(d={}));b.DataLoaderBehavior={properties:{active:{type:Boolean,observer:"_loadDataIfActive"},loadKey:{type:String,value:""},dataToLoad:{type:Array,value:()=>[]},getDataLoadName:{type:Function,value:()=>f=>String(f)},loadDataCallback:Function,requestData:{type:Function,value:function(){return f=>this.requestManager.request(this.getDataLoadUrl(f))}},getDataLoadUrl:Function,dataLoading:{type:Boolean,readOnly:!0,reflectToAttribute:!0,
value:!1},_dataLoadState:{type:Object,value:()=>new Map},_canceller:{type:Object,value:()=>new vc.Canceller},_loadDataAsync:{type:Number,value:null}},observers:["_dataToLoadChanged(isAttached, dataToLoad.*)"],onLoadFinish(){},reload(){this._dataLoadState.clear();this._loadData()},reset(){null!=this._loadDataAsync&&(this.cancelAsync(this._loadDataAsync),this._loadDataAsync=null);this._canceller&&this._canceller.cancelAll();this._dataLoadState&&this._dataLoadState.clear();this.isAttached&&this._loadData()},
_dataToLoadChanged(){this.isAttached&&this._loadData()},created(){this._loadData=_.throttle(this._loadDataImpl,100,{leading:!0,trailing:!0})},detached(){null!=this._loadDataAsync&&(this.cancelAsync(this._loadDataAsync),this._loadDataAsync=null)},_loadDataIfActive(){this.active&&this._loadData()},_loadDataImpl(){this.active&&(this.cancelAsync(this._loadDataAsync),this._loadDataAsync=this.async(this._canceller.cancellable(f=>{if(!f.cancelled)return this._setDataLoading(!0),f=this.dataToLoad.filter(h=>
{h=this.getDataLoadName(h);return!this._dataLoadState.has(h)}).map(h=>{const k=this.getDataLoadName(h);this._dataLoadState.set(k,d.LOADING);return this.requestData(h).then(this._canceller.cancellable(t=>{t.cancelled||(this._dataLoadState.set(k,d.LOADED),this.loadDataCallback(this,h,t.value));return k}))}),Promise.all(f).then(this._canceller.cancellable(h=>{if(!h.cancelled){const k=new Set(h.value);if(this.dataToLoad.some(t=>k.has(this.getDataLoadName(t))))this.onLoadFinish()}Array.from(this._dataLoadState.values()).some(k=>
k===d.LOADING)||this._setDataLoading(!1)}),()=>{}).then(this._canceller.cancellable(({cancelled:h})=>{h||(this._loadDataAsync=null)}))})))}}})(qd||(qd={}));

//# sourceURL=build://tf-imports/plottable.js
/*
 MIT
 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.
 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
 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.
 MIT
 @fileoverview Implements a function memoizer using the Signature API.
 Plottable 3.7.0 (https://github.com/palantir/plottable)
 Copyright 2014-2017 Palantir Technologies
 Licensed under MIT (https://github.com/palantir/plottable/blob/master/LICENSE)
 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.
*/
(function(b,d){"object"===typeof exports&&"object"===typeof module?module.exports=d(require("d3")):"function"===typeof define&&define.amd?define(["d3"],d):"object"===typeof exports?exports.Plottable=d(require("d3")):b.Plottable=d(b.d3)})(this,function(b){return function(d){function f(k){if(h[k])return h[k].exports;var t=h[k]={i:k,l:!1,exports:{}};d[k].call(t.exports,t,t.exports,f);t.l=!0;return t.exports}var h={};f.m=d;f.c=h;f.i=function(k){return k};f.d=function(k,t,l){f.o(k,t)||Object.defineProperty(k,
t,{configurable:!1,enumerable:!0,get:l})};f.n=function(k){var t=k&&k.__esModule?function(){return k["default"]}:function(){return k};f.d(t,"a",t);return t};f.o=function(k,t){return Object.prototype.hasOwnProperty.call(k,t)};f.p="";return f(f.s=140)}([function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}d=h(107);f.Array=d;d=h(110);f.Color=d;d=h(55);f.DOM=d;d=h(56);f.Math=d;d=h(113);f.Object=d;d=h(57);f.RTree=d;d=h(115);f.Stacking=d;d=h(35);f.Window=d;k(h(108));k(h(109));k(h(12));
k(h(111));k(h(112));k(h(58));k(h(116))},function(d){d.exports=b},function(d,f,h){function k(G,D,B){var I=D.accessor;D=D.scale;if(null==D)return[];var N=G.data();null!=B&&(N=N.filter(function(O,H){return B(O,H,G)}));N=N.map(function(O,H){return I(O,H,G)});return D.extentOfValues(N)}var t=this&&this.__extends||function(G,D){function B(){this.constructor=G}for(var I in D)D.hasOwnProperty(I)&&(G[I]=D[I]);G.prototype=null===D?Object.create(D):(B.prototype=D.prototype,new B)},l=h(1),p=h(7);d=h(4);var m=
h(18),n=h(6),q=h(9),u=h(20),x=h(0),A=h(12),y=h(10),w=h(51),C=h(52);f.Renderer=y.makeEnum(["svg","canvas"]);h=function(G){function D(){var B=G.call(this)||this;B._dataChanged=!1;B._attrExtents={};B._animate=!1;B._animators={};B._propertyExtents={};B._resetEntityStore=function(){B._cachedEntityStore=void 0};B._overflowHidden=!0;B.addClass("plot");B._datasetToDrawer=new x.Map;B._attrBindings=l.map();B._includedValuesProvider=function(N,O){return B._includedValuesForScale(N,O)};B._renderCallback=function(){return B.render()};
B._onDatasetUpdateCallback=function(){return B._onDatasetUpdate()};B._propertyBindings=l.map();var I=(new p.Easing).maxTotalDuration(D._ANIMATION_MAX_DURATION);B.animator(w.Animator.MAIN,I);B.animator(w.Animator.RESET,new p.Null);B._deferredResetEntityStore=x.Window.debounce(C.DeferredRenderer.DEFERRED_RENDERING_DELAY,B._resetEntityStore);return B}t(D,G);D.getTotalDrawTime=function(B,I){return I.reduce(function(N,O){return N+O.animator.totalTime(B.length)},0)};D.applyDrawSteps=function(B,I){return B.map(function(N){var O=
N.attrToProjector,H={};Object.keys(O).forEach(function(K){H[K]=function(M,L){return O[K](M,L,I)}});return{attrToAppliedProjector:H,animator:N.animator}})};D.prototype.anchor=function(B){B=A.coerceExternalD3(B);G.prototype.anchor.call(this,B);this._dataChanged=!0;this._resetEntityStore();this._updateExtents();return this};D.prototype._setup=function(){var B=this;this._isSetup||(G.prototype._setup.call(this),null!=this._canvas&&this._appendCanvasNode(),this._renderArea=this.content().append("g").classed("render-area",
!0),this.datasets().forEach(function(I){return B._createNodesForDataset(I)}))};D.prototype._appendCanvasNode=function(){var B=this.element().select(".plot-canvas-container");B.empty()&&(B=this.element().append("div").classed("plot-canvas-container",!0),B.node().appendChild(this._canvas.node()))};D.prototype.setBounds=function(B,I,N,O){G.prototype.setBounds.call(this,B,I,N,O);this._resetEntityStore();null!=this._canvas&&(this._bufferCanvas&&!this._bufferCanvasValid&&(this._bufferCanvas.attr("width",
this._canvas.attr("width")),this._bufferCanvas.attr("height",this._canvas.attr("height")),(N=this._bufferCanvas.node().getContext("2d"))&&N.drawImage(this._canvas.node(),0,0),this._bufferCanvasValid=!0),N=null!=window.devicePixelRatio?window.devicePixelRatio:1,this._canvas.attr("width",B*N),this._canvas.attr("height",I*N),O=this._canvas.node().getContext("2d"))&&(O.setTransform(N,0,0,N,0,0),this._bufferCanvas&&O.drawImage(this._bufferCanvas.node(),0,0,B,I))};D.prototype.destroy=function(){var B=this;
G.prototype.destroy.call(this);this._scales().forEach(function(I){return I.offUpdate(B._renderCallback)});this.datasets([])};D.prototype._createNodesForDataset=function(B){B=this._datasetToDrawer.get(B);"svg"===this.renderer()?B.useSVG(this._renderArea):B.useCanvas(this._canvas);return B};D.prototype._createDrawer=function(){return new n.ProxyDrawer(function(){return new q.SVGDrawer("path","")},function(B){return new m.CanvasDrawer(B,function(){})})};D.prototype._getAnimator=function(B){return this._animateOnNextRender()?
this._animators[B]||new p.Null:new p.Null};D.prototype._onDatasetUpdate=function(){this._updateExtents();this._dataChanged=!0;this._resetEntityStore();this.renderLowPriority()};D.prototype.attr=function(B,I,N){if(null==I)return this._attrBindings.get(B);this._bindAttr(B,I,N);this.render();return this};D.prototype._bindProperty=function(B,I,N,O){var H=this._propertyBindings.get(B);H=null!=H?H.scale:null;this._propertyBindings.set(B,{accessor:"function"===typeof I?I:function(){return I},scale:N,postScale:O});
null!=H&&this._uninstallScaleForKey(H,B);null!=N&&this._installScaleForKey(N,B);this._clearAttrToProjectorCache()};D.prototype._bindAttr=function(B,I,N){var O=this._attrBindings.get(B);O=null!=O?O.scale:null;this._attrBindings.set(B,{accessor:"function"===typeof I?I:function(){return I},scale:N});null!=O&&this._uninstallScaleForKey(O,B);null!=N&&this._installScaleForKey(N,B);this._clearAttrToProjectorCache()};D.prototype._clearAttrToProjectorCache=function(){delete this._cachedAttrToProjector};D.prototype._getAttrToProjector=
function(){null==this._cachedAttrToProjector&&(this._cachedAttrToProjector=this._generateAttrToProjector());return x.Object.assign({},this._cachedAttrToProjector)};D.prototype._generateAttrToProjector=function(){var B={};this._attrBindings.each(function(N,O){B[O]=D._scaledAccessor(N)});var I=this._propertyProjectors();Object.keys(I).forEach(function(N){null==B[N]&&(B[N]=I[N])});return B};D.prototype.renderImmediately=function(){G.prototype.renderImmediately.call(this);this._isAnchored&&(this._paint(),
this._dataChanged=!1);return this};D.prototype.renderLowPriority=function(){this._renderCallback()};D.prototype.animated=function(B){if(null==B)return this._animate;this._animate=B;return this};D.prototype.detach=function(){G.prototype.detach.call(this);this._updateExtents();return this};D.prototype._scales=function(){var B=[];this._attrBindings.each(function(I){I=I.scale;null!=I&&-1===B.indexOf(I)&&B.push(I)});this._propertyBindings.each(function(I){I=I.scale;null!=I&&-1===B.indexOf(I)&&B.push(I)});
return B};D.prototype._updateExtents=function(){var B=this;this._resetEntityStore();this._scales().forEach(function(I){return I.addIncludedValuesProvider(B._includedValuesProvider)})};D.prototype._filterForProperty=function(){return null};D.prototype.getExtentsForAttr=function(B){var I=this;null==this._attrExtents[B]&&(this._attrExtents[B]=u.memThunk(function(){return I.datasets()},function(){return I._attrBindings.get(B)},function(N,O){return null==O||null==O.accessor?null:N.map(function(H){return k(H,
O,null)})}));return this._attrExtents[B]()};D.prototype.getExtentsForProperty=function(B){var I=this;null==this._propertyExtents[B]&&(this._propertyExtents[B]=u.memThunk(function(){return I.datasets()},function(){return I._propertyBindings.get(B)},function(){return I._filterForProperty(B)},function(N,O,H){return null==O||null==O.accessor?null:N.map(function(K){return k(K,O,H)})}));return this._propertyExtents[B]()};D.prototype._includedValuesForScale=function(B,I){var N=this;if(!this._isAnchored&&
!I)return[];var O=[];this._attrBindings.each(function(H,K){H.scale===B&&(H=N.getExtentsForAttr(K),null!=H&&(O=O.concat(l.merge(H))))});this._propertyBindings.each(function(H,K){H.scale===B&&(H=N.getExtentsForProperty(K),null!=H&&(O=O.concat(l.merge(H))))});return O};D.prototype.animator=function(B,I){if(void 0===I)return this._animators[B];this._animators[B]=I;return this};D.prototype.renderer=function(){return null==this._canvas?"svg":"canvas"};D.prototype.addDataset=function(B){this._addDataset(B);
this._onDatasetUpdate()};D.prototype._addDataset=function(B){this._removeDataset(B);var I=this._createDrawer(B);this._datasetToDrawer.set(B,I);this._isSetup&&this._createNodesForDataset(B);B.onUpdate(this._onDatasetUpdateCallback);return this};D.prototype.removeDataset=function(B){this._removeDataset(B);this._onDatasetUpdate()};D.prototype._removeDataset=function(B){if(-1===this.datasets().indexOf(B))return this;this._removeDatasetNodes(B);B.offUpdate(this._onDatasetUpdateCallback);this._datasetToDrawer.delete(B);
return this};D.prototype._removeDatasetNodes=function(B){this._datasetToDrawer.get(B).remove()};D.prototype.datasets=function(B){var I=this,N=[];this._datasetToDrawer.forEach(function(O,H){return N.push(H)});if(null==B)return N;N.forEach(function(O){return I._removeDataset(O)});B.forEach(function(O){return I._addDataset(O)});this._onDatasetUpdate();return this};D.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new p.Null}]};D.prototype._additionalPaint=
function(){};D.prototype._buildLightweightPlotEntities=function(B){var I=this,N=[];B.forEach(function(O,H){var K=I._datasetToDrawer.get(O),M=0;O.data().forEach(function(L,Q){var T=I._pixelPoint(L,Q,O);x.Math.isNaN(T.x)||x.Math.isNaN(T.y)||(N.push({datum:L,get position(){return I._pixelPoint.call(I,L,Q,O)},index:Q,dataset:O,datasetIndex:H,component:I,drawer:K,validDatumIndex:M}),M++)})});return N};D.prototype._getDataToDraw=function(){var B=new x.Map;this.datasets().forEach(function(I){return B.set(I,
I.data())});return B};D.prototype._paint=function(){var B=this;delete this._cachedAttrToProjector;var I=this._generateDrawSteps(),N=this._getDataToDraw(),O=this.datasets().map(function(K){return B._datasetToDrawer.get(K)});if("canvas"===this.renderer()){var H=this._canvas.node();H.getContext("2d").clearRect(0,0,H.clientWidth,H.clientHeight);this._bufferCanvasValid=!1}this.datasets().forEach(function(K,M){var L=D.applyDrawSteps(I,K);O[M].draw(N.get(K),L)});H=this.datasets().map(function(K){return D.getTotalDrawTime(N.get(K),
I)});H=x.Math.max(H,0);this._additionalPaint(H)};D.prototype.selections=function(B){var I=this;void 0===B&&(B=this.datasets());if("canvas"===this.renderer())return l.selectAll();var N=[];B.forEach(function(O){O=I._datasetToDrawer.get(O);null!=O&&(O=O.getVisualPrimitives(),N.push.apply(N,O))});return l.selectAll(N)};D.prototype.entities=function(B){var I=this;return this._getEntityStore(B).entities().map(function(N){return I._lightweightPlotEntityToPlotEntity(N)})};D.prototype._getEntityStore=function(B){function I(H){return N._entityBounds(H)}
var N=this;if(void 0!==B){var O=new x.EntityStore;O.addAll(this._buildLightweightPlotEntities(B),I,this._localOriginBounds());return O}void 0===this._cachedEntityStore&&(O=new x.EntityStore,O.addAll(this._buildLightweightPlotEntities(this.datasets()),I,this._localOriginBounds()),this._cachedEntityStore=O);return this._cachedEntityStore};D.prototype._localOriginBounds=function(){return{topLeft:{x:0,y:0},bottomRight:{x:this.width(),y:this.height()}}};D.prototype._entityBounds=function(B){B=this._pixelPoint(B.datum,
B.index,B.dataset);return{x:B.x,y:B.y,width:0,height:0}};D.prototype._lightweightPlotEntityToPlotEntity=function(B){return{bounds:this._entityBounds(B),component:B.component,dataset:B.dataset,datasetIndex:B.datasetIndex,datum:B.datum,index:B.index,position:B.position,selection:l.select(B.drawer.getVisualPrimitives()[B.validDatumIndex])}};D.prototype.entitiesAt=function(){throw Error("plots must implement entitiesAt");};D.prototype.entityNearest=function(B){B=this._getEntityStore().entityNearest(B);
return void 0===B?void 0:this._lightweightPlotEntityToPlotEntity(B)};D.prototype.entitiesIn=function(B,I){return this.entitiesInBounds(null==I?{x:B.topLeft.x,y:B.topLeft.y,width:B.bottomRight.x-B.topLeft.x,height:B.bottomRight.y-B.topLeft.y}:{x:B.min,y:I.min,width:B.max-B.min,height:I.max-I.min})};D.prototype.entitiesInBounds=function(B){var I=this;if(B=this._getEntityStore().entitiesInBounds(B))return B.map(function(N){return I._lightweightPlotEntityToPlotEntity(N)})};D.prototype.entitiesInXBounds=
function(B){var I=this;if(B=this._getEntityStore().entitiesInXBounds(B))return B.map(function(N){return I._lightweightPlotEntityToPlotEntity(N)})};D.prototype.entitiesInYBounds=function(B){var I=this;if(B=this._getEntityStore().entitiesInYBounds(B))return B.map(function(N){return I._lightweightPlotEntityToPlotEntity(N)})};D.prototype._uninstallScaleForKey=function(B){B.offUpdate(this._renderCallback);B.offUpdate(this._deferredResetEntityStore);B.removeIncludedValuesProvider(this._includedValuesProvider)};
D.prototype._installScaleForKey=function(B){B.onUpdate(this._renderCallback);B.onUpdate(this._deferredResetEntityStore);B.addIncludedValuesProvider(this._includedValuesProvider)};D.prototype._propertyProjectors=function(){return{}};D._scaledAccessor=function(B){var I=B.scale,N=B.accessor,O=B.postScale,H=null==I?N:function(K,M,L){return I.scale(N(K,M,L))};return null==O?H:function(K,M,L){return O(H(K,M,L),K,M,L)}};D.prototype._pixelPoint=function(){return{x:0,y:0}};D.prototype._animateOnNextRender=
function(){return this._animate&&this._dataChanged};return D}(d.Component);h._ANIMATION_MAX_DURATION=600;f.Plot=h},function(d,f,h){function k(p){for(var m in p)f.hasOwnProperty(m)||(f[m]=p[m])}d=h(105);f.TickGenerators=d;k(h(54));k(h(101));k(h(102));k(h(103));k(h(104));k(h(106));var t=h(54),l=h(11);f.isTransformable=function(p){return p instanceof l.QuantitativeScale||p instanceof t.Category}},function(d,f,h){var k=h(1),t=h(30),l=h(0),p=h(12);d=h(10);f.XAlignment=d.makeEnum(["left","center","right"]);
f.YAlignment=d.makeEnum(["top","center","bottom"]);d=function(){function m(){this._overflowHidden=!1;this._origin={x:0,y:0};this._xAlignment="left";this._yAlignment="top";this._isAnchored=this._isSetup=!1;this._cssClasses=new l.Set;this._destroyed=!1;this._onAnchorCallbacks=new l.CallbackSet;this._onDetachCallbacks=new l.CallbackSet;this._cssClasses.add("component")}m.prototype.anchor=function(n){n=p.coerceExternalD3(n);if(this._destroyed)throw Error("Can't reuse destroy()-ed Components!");this.isRoot()&&
(this._rootElement=n,this._rootElement.classed("plottable",!0));null!=this._element?n.node().appendChild(this._element.node()):(this._element=n.append("div"),this._setup());this._isAnchored=!0;this._onAnchorCallbacks.callCallbacks(this);return this};m.prototype.onAnchor=function(n){this._isAnchored&&n(this);this._onAnchorCallbacks.add(n)};m.prototype.offAnchor=function(n){this._onAnchorCallbacks.delete(n)};m.prototype._setup=function(){var n=this;this._isSetup||(this._cssClasses.forEach(function(q){n._element.classed(q,
!0)}),this._cssClasses=new l.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)};m.prototype.requestedSpace=function(){return{minWidth:0,minHeight:0}};m.prototype.computeLayout=
function(n,q,u){if(null==n||null==q||null==u){if(null==this._element)throw Error("anchor() must be called before computeLayout()");if(null!=this._rootElement)n={x:0,y:0},u=this._rootElement.node(),q=l.DOM.elementWidth(u),u=l.DOM.elementHeight(u);else throw Error("null arguments cannot be passed to computeLayout() on a non-root, unanchored node");}var x=this._sizeFromOffer(q,u),A=x.height;x=x.width;this.setBounds(x,A,n.x+(q-x)*m._xAlignToProportion[this._xAlignment],n.y+(u-A)*m._yAlignToProportion[this._yAlignment]);
return this};m.prototype.setBounds=function(n,q,u,x){void 0===u&&(u=0);void 0===x&&(x=0);this._width=n;this._height=q;this._origin={x:u,y:x};null!=this._element&&this._element.styles({left:u+"px",height:q+"px",top:x+"px",width:n+"px"});null!=this._resizeHandler&&this._resizeHandler({width:n,height:q})};m.prototype._sizeFromOffer=function(n,q){var u=this.requestedSpace(n,q);return{width:this.fixedWidth()?Math.min(n,u.minWidth):n,height:this.fixedHeight()?Math.min(q,u.minHeight):q}};m.prototype.render=
function(){this._isAnchored&&this._isSetup&&0<=this.width()&&0<=this.height()&&t.registerToRender(this);return this};m.prototype.renderLowPriority=function(){this.render()};m.prototype._scheduleComputeLayout=function(){this._isAnchored&&this._isSetup&&t.registerToComputeLayoutAndRender(this)};m.prototype.onResize=function(n){this._resizeHandler=n;return this};m.prototype.renderImmediately=function(){return this};m.prototype.redraw=function(){this._isAnchored&&this._isSetup&&(this.isRoot()?this._scheduleComputeLayout():
this.parent().redraw());return this};m.prototype.invalidateCache=function(){};m.prototype.renderTo=function(n){this.detach();if(null!=n){n="string"===typeof n?k.select(n):n instanceof Element?k.select(n):p.coerceExternalD3(n);if(!n.node()||null==n.node().nodeName)throw Error("Plottable requires a valid Element to renderTo");if("svg"===n.node().nodeName)throw Error("Plottable 3.x and later can only renderTo an HTML component; pass a div instead!");this.anchor(n)}if(null==this._element)throw 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");
t.registerToComputeLayoutAndRender(this);t.flush()};m.prototype.xAlignment=function(n){if(null==n)return this._xAlignment;n=n.toLowerCase();if(null==m._xAlignToProportion[n])throw Error("Unsupported alignment: "+n);this._xAlignment=n;this.redraw();return this};m.prototype.yAlignment=function(n){if(null==n)return this._yAlignment;n=n.toLowerCase();if(null==m._yAlignToProportion[n])throw Error("Unsupported alignment: "+n);this._yAlignment=n;this.redraw();return this};m.prototype.hasClass=function(n){return null==
n?!1:null==this._element?this._cssClasses.has(n):this._element.classed(n)};m.prototype.addClass=function(n){null!=n&&(null==this._element?this._cssClasses.add(n):this._element.classed(n,!0))};m.prototype.removeClass=function(n){null!=n&&(null==this._element?this._cssClasses.delete(n):this._element.classed(n,!1))};m.prototype.fixedWidth=function(){return!1};m.prototype.fixedHeight=function(){return!1};m.prototype.detach=function(){this.parent(null);this._isAnchored&&this._element.remove();this._isAnchored=
!1;this._onDetachCallbacks.callCallbacks(this);return this};m.prototype.onDetach=function(n){this._onDetachCallbacks.add(n)};m.prototype.offDetach=function(n){this._onDetachCallbacks.delete(n)};m.prototype.parent=function(n){if(void 0===n)return this._parent;if(null!==n&&!n.has(this))throw Error("Passed invalid parent");this._parent=n;return this};m.prototype.bounds=function(){var n=this.origin();return{topLeft:n,bottomRight:{x:n.x+this.width(),y:n.y+this.height()}}};m.prototype.destroy=function(){this._destroyed=
!0;this.detach()};m.prototype.width=function(){return this._width};m.prototype.height=function(){return this._height};m.prototype.origin=function(){return{x:this._origin.x,y:this._origin.y}};m.prototype.originToRoot=function(){for(var n=this.origin(),q=this.parent();null!=q;){var u=q.origin();n.x+=u.x;n.y+=u.y;q=q.parent()}return n};m.prototype.root=function(){for(var n=this;!n.isRoot();)n=n.parent();return n};m.prototype.isRoot=function(){return null==this.parent()};m.prototype.foreground=function(){return this._foregroundContainer};
m.prototype.content=function(){return this._content};m.prototype.element=function(){return this._element};m.prototype.rootElement=function(){return this.root()._rootElement};m.prototype.background=function(){return this._backgroundContainer};return m}();d._xAlignToProportion={left:0,center:.5,right:1};d._yAlignToProportion={top:0,center:.5,bottom:1};f.Component=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(59));k(h(62));k(h(133));k(h(21));k(h(64));k(h(66))},
function(d,f){d=function(){function h(k,t){this._svgDrawerFactory=k;this._canvasDrawerFactory=t}h.prototype.useSVG=function(k){null!=this._currentDrawer&&this._currentDrawer.remove();var t=this._svgDrawerFactory();t.attachTo(k);this._currentDrawer=t};h.prototype.useCanvas=function(k){null!=this._currentDrawer&&this._currentDrawer.remove();this._currentDrawer=this._canvasDrawerFactory(k.node().getContext("2d"))};h.prototype.getDrawer=function(){return this._currentDrawer};h.prototype.remove=function(){null!=
this._currentDrawer&&this._currentDrawer.remove()};h.prototype.draw=function(k,t){this._currentDrawer.draw(k,t)};h.prototype.getVisualPrimitives=function(){return this._currentDrawer.getVisualPrimitives()};h.prototype.getVisualPrimitiveAtIndex=function(k){return this._currentDrawer.getVisualPrimitiveAtIndex(k)};return h}();f.ProxyDrawer=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(70));k(h(71))},function(d,f,h){function k(p){void 0===p&&(p=3);t(p);return function(m){return m.toFixed(p)}}
function t(p){if(0>p||20<p)throw new RangeError("Formatter precision must be between 0 and 20");if(p!==Math.floor(p))throw new RangeError("Formatter precision must be an integer");}var l=h(1);f.currency=function(p,m,n){void 0===p&&(p=2);void 0===m&&(m="$");void 0===n&&(n=!0);var q=k(p);return function(u){var x=q(Math.abs(u));""!==x&&(x=n?m+x:x+m,0>u&&(x="-"+x));return x}};f.fixed=k;f.general=function(){var p;void 0===p&&(p=3);t(p);return function(m){if("number"===typeof m){var n=Math.pow(10,p);return String(Math.round(m*
n)/n)}return String(m)}};f.identity=function(){return function(p){return String(p)}};f.percentage=function(p){void 0===p&&(p=0);var m=k(p);return function(n){var q=n.toString();q=Math.pow(10,q.length-(q.indexOf(".")+1));return m(parseInt((100*n*q).toString(),10)/q)+"%"}};f.siSuffix=function(p){void 0===p&&(p=3);t(p);return function(m){return l.format("."+p+"s")(m)}};f.shortScale=function(p){void 0===p&&(p=3);t(p);var m=l.format("."+p+"e"),n=l.format("."+p+"f"),q=Math.pow(10,18),u=Math.pow(10,-p);
return function(x){var A=Math.abs(x);if((A<u||A>=q)&&0!==A)return m(x);for(var y=-1;A>=Math.pow(1E3,y+2)&&4>y;)y++;A=-1===y?n(x):n(x/Math.pow(1E3,y+1))+"KMBTQ"[y];if(0<x&&"1000"===A.substr(0,4)||0>x&&"-1000"===A.substr(0,5))4>y?(y++,A=n(x/Math.pow(1E3,y+1))+"KMBTQ"[y]):A=m(x);return A}};f.multiTime=function(){var p=[{specifier:".%L",predicate:function(m){return 0!==m.getMilliseconds()}},{specifier:":%S",predicate:function(m){return 0!==m.getSeconds()}},{specifier:"%I:%M",predicate:function(m){return 0!==
m.getMinutes()}},{specifier:"%I %p",predicate:function(m){return 0!==m.getHours()}},{specifier:"%a %d",predicate:function(m){return 0!==m.getDay()&&1!==m.getDate()}},{specifier:"%b %d",predicate:function(m){return 1!==m.getDate()}},{specifier:"%b",predicate:function(m){return 0!==m.getMonth()}}];return function(m){var n=p.filter(function(q){return q.predicate(m)});return l.timeFormat(0<n.length?n[0].specifier:"%Y")(m)}};f.time=function(p){return l.timeFormat(p)}},function(d,f,h){var k=h(1),t=h(0);
d=function(){function l(p,m){this._root=k.select(document.createElementNS("http://www.w3.org/2000/svg","g"));this._className=m;this._svgElementName=p}l.prototype.draw=function(p,m){var n=this;this._createAndDestroyDOMElements(p);var q=0;m.forEach(function(u){t.Window.setTimeout(function(){return n._drawStep(u)},q);q+=u.animator.totalTime(p.length)})};l.prototype.getVisualPrimitives=function(){null==this._cachedVisualPrimitivesNodes&&(this._cachedVisualPrimitivesNodes=this._selection.nodes());return this._cachedVisualPrimitivesNodes};
l.prototype.getVisualPrimitiveAtIndex=function(p){return this.getVisualPrimitives()[p]};l.prototype.remove=function(){this._root.remove()};l.prototype.attachTo=function(p){p.node().appendChild(this._root.node())};l.prototype.getRoot=function(){return this._root};l.prototype.selector=function(){return this._svgElementName};l.prototype._applyDefaultAttributes=function(){};l.prototype._createAndDestroyDOMElements=function(p){p=p.filter(function(m){return null!=m});p=this._root.selectAll(this.selector()).data(p);
this._selection=p.enter().append(this._svgElementName).merge(p);p.exit().remove();this._cachedVisualPrimitivesNodes=null;null!=this._className&&this._selection.classed(this._className,!0);this._applyDefaultAttributes(this._selection)};l.prototype._drawStep=function(p){var m=this;["fill","stroke"].forEach(function(n){null!=p.attrToAppliedProjector[n]&&m._selection.attr(n,p.attrToAppliedProjector[n])});p.animator.animate(this._selection,p.attrToAppliedProjector);null!=this._className&&this._selection.classed(this._className,
!0)};return l}();f.SVGDrawer=d},function(d,f){f.makeEnum=function(h){return h.reduce(function(k,t){k[t]=t;return k},{})}},function(d,f,h){var k=this&&this.__extends||function(m,n){function q(){this.constructor=m}for(var u in n)n.hasOwnProperty(u)&&(m[u]=n[u]);m.prototype=null===n?Object.create(n):(q.prototype=n.prototype,new q)},t=h(1),l=h(26),p=h(0);d=function(m){function n(){var q=m.call(this)||this;q._tickGenerator=function(u){return u.defaultTicks()};q._padProportion=.05;q._snappingDomainEnabled=
!0;q._paddingExceptionsProviders=new p.Set;return q}k(n,m);n.prototype.autoDomain=function(){this._domainMax=this._domainMin=null;m.prototype.autoDomain.call(this)};n.prototype._autoDomainIfAutomaticMode=function(){if(null!=this._domainMin&&null!=this._domainMax)this._setDomain([this._domainMin,this._domainMax]);else{var q=this._getExtent();null!=this._domainMin?(q=q[1],this._domainMin>=q&&(q=this._expandSingleValueDomain([this._domainMin,this._domainMin])[1]),this._setDomain([this._domainMin,q])):
null!=this._domainMax?(q=q[0],this._domainMax<=q&&(q=this._expandSingleValueDomain([this._domainMax,this._domainMax])[0]),this._setDomain([q,this._domainMax])):m.prototype._autoDomainIfAutomaticMode.call(this)}};n.prototype._getUnboundedExtent=function(q){void 0===q&&(q=!1);q=this._getAllIncludedValues(q);var u=this._defaultExtent();0!==q.length&&(q=[p.Math.min(q,u[0]),p.Math.max(q,u[1])],u=this._padDomain(q));return u};n.prototype._getExtent=function(){var q=this._getUnboundedExtent();null!=this._domainMin&&
(q[0]=this._domainMin);null!=this._domainMax&&(q[1]=this._domainMax);return q};n.prototype.addPaddingExceptionsProvider=function(q){this._paddingExceptionsProviders.add(q);this._autoDomainIfAutomaticMode()};n.prototype.removePaddingExceptionsProvider=function(q){this._paddingExceptionsProviders.delete(q);this._autoDomainIfAutomaticMode()};n.prototype.padProportion=function(q){if(null==q)return this._padProportion;if(0>q)throw Error("padProportion must be non-negative");this._padProportion=q;this._autoDomainIfAutomaticMode();
return this};n.prototype._padDomain=function(q){var u=this;if(q[0].valueOf()===q[1].valueOf())return this._expandSingleValueDomain(q);if(0===this._padProportion)return q;var x=this._padProportion/2,A=q[0],y=q[1],w=!1,C=!1;this._paddingExceptionsProviders.forEach(function(D){D(u).forEach(function(B){B.valueOf()===A.valueOf()&&(w=!0);B.valueOf()===y.valueOf()&&(C=!0)})});var G=this._backingScaleDomain();this._backingScaleDomain(q);q=w?A:this.invert(this.scale(A)-(this.scale(y)-this.scale(A))*x);x=C?
y:this.invert(this.scale(y)+(this.scale(y)-this.scale(A))*x);this._backingScaleDomain(G);return this._snappingDomainEnabled?this._niceDomain([q,x]):[q,x]};n.prototype.snappingDomainEnabled=function(q){null!=q&&(this._snappingDomainEnabled=q,this._autoDomainIfAutomaticMode())};n.prototype._expandSingleValueDomain=function(q){return q};n.prototype.invert=function(){throw Error("Subclasses should override invert");};n.prototype.domain=function(q){null!=q&&(this._domainMin=q[0],this._domainMax=q[1]);
return m.prototype.domain.call(this,q)};n.prototype.domainMin=function(q){if(null==q)return this.domain()[0];this._domainMin=q;this._autoDomainIfAutomaticMode();return this};n.prototype.domainMax=function(q){if(null==q)return this.domain()[1];this._domainMax=q;this._autoDomainIfAutomaticMode();return this};n.prototype.extentOfValues=function(q){q=t.extent(q.filter(function(u){return p.Math.isValidNumber(+u)}));return null==q[0]||null==q[1]?[]:q};n.prototype.zoom=function(q,u){var x=this;this.domain(this.range().map(function(A){return x.invert(l.zoomOut(A,
q,u))}))};n.prototype.pan=function(q){var u=this;this.domain(this.range().map(function(x){return u.invert(x+q)}))};n.prototype.scaleTransformation=function(){throw Error("Subclasses should override scaleTransformation");};n.prototype.invertedTransformation=function(){throw Error("Subclasses should override invertedTransformation");};n.prototype.getTransformationExtent=function(){throw Error("Subclasses should override getTransformationExtent");};n.prototype.getTransformationDomain=function(){throw Error("Subclasses should override getTransformationDomain");
};n.prototype.setTransformationDomain=function(){throw Error("Subclasses should override setTransformationDomain");};n.prototype._setDomain=function(q){function u(x){return p.Math.isNaN(x)||Infinity===x||-Infinity===x}u(q[0])||u(q[1])?p.Window.warn("Warning: QuantitativeScales cannot take NaN or Infinity as a domain value. Ignoring."):m.prototype._setDomain.call(this,q)};n.prototype.defaultTicks=function(){throw Error("Subclasses should override _getDefaultTicks");};n.prototype.ticks=function(){return this._tickGenerator(this)};
n.prototype._niceDomain=function(){throw Error("Subclasses should override _niceDomain");};n.prototype._defaultExtent=function(){throw Error("Subclasses should override _defaultExtent");};n.prototype.tickGenerator=function(){var q=Plottable.Scales.TickGenerators.integerTickGenerator();null!=q&&(this._tickGenerator=q)};return n}(h(17).Scale);d._DEFAULT_NUM_TICKS=10;f.QuantitativeScale=d},function(d,f,h){var k=h(1);f.coerceExternalD3=function(t){if(null==t.attrs){if(null==t.nodes){var l=[];t.each(function(){l.push(this)});
return k.selectAll(l)}return k.selectAll(t.nodes())}return t}},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(83));k(h(84));k(h(85))},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(44));k(h(45));k(h(46));k(h(18));k(h(6));k(h(33));k(h(34));k(h(47));k(h(9));k(h(48))},function(d,f){d=function(){function h(){var k=this;this._anchorCallback=function(t){return k._anchor(t)};this._enabled=!0}h.prototype.attachTo=function(k){this._disconnect();
this._componentAttachedTo=k;this._connect();return this};h.prototype.detachFrom=function(){this.detach()};h.prototype.detach=function(){this._disconnect();this._componentAttachedTo=null;return this};h.prototype.enabled=function(k){if(null==k)return this._enabled;(this._enabled=k)?this._connect():this._disconnect();return this};h.prototype._anchor=function(){this._isAnchored=!0};h.prototype._unanchor=function(){this._isAnchored=!1};h.prototype._translateToComponentSpace=function(k){var t=this._componentAttachedTo.originToRoot();
return{x:k.x-t.x,y:k.y-t.y}};h.prototype._isInsideComponent=function(k){return 0<=k.x&&0<=k.y&&k.x<=this._componentAttachedTo.width()&&k.y<=this._componentAttachedTo.height()};h.prototype._connect=function(){if(this.enabled()&&null!=this._componentAttachedTo&&!this._isAnchored)this._componentAttachedTo.onAnchor(this._anchorCallback)};h.prototype._disconnect=function(){this._isAnchored&&this._unanchor();null!=this._componentAttachedTo&&this._componentAttachedTo.offAnchor(this._anchorCallback)};return h}();
f.Interaction=d},function(d,f,h){var k=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&(n[x]=q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},t=h(3),l=h(0),p=h(52),m=h(2);d=function(n){function q(){var u=n.call(this)||this;u._autoAdjustXScaleDomain=!1;u._autoAdjustYScaleDomain=!1;u._deferredRendering=!1;u._applyDeferredRenderingTransform=function(x,A,y,w){u._isAnchored&&(null!=u._renderArea&&u._renderArea.attr("transform",
"translate("+x+", "+A+") scale("+y+", "+w+")"),null!=u._canvas&&u._canvas.style("transform","translate("+x+"px, "+A+"px) scale("+y+", "+w+")"))};u.addClass("xy-plot");u._adjustYDomainOnChangeFromXCallback=function(){return u._adjustYDomainOnChangeFromX()};u._adjustXDomainOnChangeFromYCallback=function(){return u._adjustXDomainOnChangeFromY()};u._renderCallback=function(){if(u.deferredRendering()){var x=u.x()&&u.x().scale,A=u.y()&&u.y().scale;u._deferredRenderer.updateDomains(x,A)}else u.render()};
u._deferredRenderer=new p.DeferredRenderer(function(){return u.render()},u._applyDeferredRenderingTransform);return u}k(q,n);q.prototype.render=function(){this.deferredRendering()&&this._deferredRenderer.resetTransforms();return n.prototype.render.call(this)};q.prototype.deferredRendering=function(){return this._deferredRendering};q.prototype.x=function(u,x,A){if(null==u)return this._propertyBindings.get(q._X_KEY);this._bindProperty(q._X_KEY,u,x,A);u=this.width();null!=x&&null!=u&&x.range([0,u]);
this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain();this.render();return this};q.prototype.y=function(u,x,A){if(null==u)return this._propertyBindings.get(q._Y_KEY);this._bindProperty(q._Y_KEY,u,x,A);u=this.height();null!=x&&null!=u&&(x instanceof t.Category?x.range([0,u]):x.range([u,0]));this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain();this.render();return this};q.prototype._filterForProperty=function(u){return"x"===u&&this._autoAdjustXScaleDomain?this._makeFilterByProperty("y"):
"y"===u&&this._autoAdjustYScaleDomain?this._makeFilterByProperty("x"):null};q.prototype._makeFilterByProperty=function(u){u=this._propertyBindings.get(u);if(null!=u){var x=u.accessor,A=u.scale;if(null!=A)return function(y,w,C){var G=A.range();return l.Math.inRange(A.scale(x(y,w,C)),G[0],G[1])}}return null};q.prototype._uninstallScaleForKey=function(u,x){n.prototype._uninstallScaleForKey.call(this,u,x);u.offUpdate(x===q._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback)};
q.prototype._installScaleForKey=function(u,x){n.prototype._installScaleForKey.call(this,u,x);u.onUpdate(x===q._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback)};q.prototype.destroy=function(){n.prototype.destroy.call(this);this.x().scale&&this.x().scale.offUpdate(this._adjustYDomainOnChangeFromXCallback);this.y().scale&&this.y().scale.offUpdate(this._adjustXDomainOnChangeFromYCallback);return this};q.prototype.autorangeMode=function(u){if(null==u)return this._autoAdjustXScaleDomain?
"x":this._autoAdjustYScaleDomain?"y":"none";switch(u){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._autoAdjustYScaleDomain=this._autoAdjustXScaleDomain=!1;break;default:throw Error("Invalid scale name '"+u+"', must be 'x', 'y' or 'none'");}return this};q.prototype.computeLayout=function(u,x,A){n.prototype.computeLayout.call(this,
u,x,A);u=(u=this.x())&&u.scale;null!=u&&u.range([0,this.width()]);u=(u=this.y())&&u.scale;null!=u&&(u instanceof t.Category?u.range([0,this.height()]):u.range([this.height(),0]));return this};q.prototype._updateXExtentsAndAutodomain=function(){var u=this.x().scale;null!=u&&u.autoDomain()};q.prototype._updateYExtentsAndAutodomain=function(){var u=this.y().scale;null!=u&&u.autoDomain()};q.prototype.showAllData=function(){this._updateXExtentsAndAutodomain();this._updateYExtentsAndAutodomain();return this};
q.prototype._adjustYDomainOnChangeFromX=function(){this._projectorsReady()&&this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain()};q.prototype._adjustXDomainOnChangeFromY=function(){this._projectorsReady()&&this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain()};q.prototype._projectorsReady=function(){var u=this.x(),x=this.y();return null!=u&&null!=u.accessor&&null!=x&&null!=x.accessor};q.prototype._pixelPoint=function(u,x,A){var y=m.Plot._scaledAccessor(this.x()),w=m.Plot._scaledAccessor(this.y());
return{x:y(u,x,A),y:w(u,x,A)}};q.prototype._getDataToDraw=function(){function u(y,w,C){var G=m.Plot._scaledAccessor(x.x())(y,w,C);y=m.Plot._scaledAccessor(x.y())(y,w,C);return l.Math.isValidNumber(G)&&l.Math.isValidNumber(y)}var x=this,A=n.prototype._getDataToDraw.call(this);this.datasets().forEach(function(y){A.set(y,A.get(y).filter(function(w,C){return u(w,C,y)}))});return A};return q}(m.Plot);d._X_KEY="x";d._Y_KEY="y";f.XYPlot=d},function(d,f,h){var k=h(0);d=function(){function t(){this._autoDomainAutomatically=
!0;this._domainModificationInProgress=!1;this._updateId=0;this._callbacks=new k.CallbackSet;this._includedValuesProviders=new k.Set}t.prototype.extentOfValues=function(){return[]};t.prototype._getAllIncludedValues=function(l){var p=this;void 0===l&&(l=!1);var m=[];this._includedValuesProviders.forEach(function(n){n=n(p,l);m=m.concat(n)});return m};t.prototype._getExtent=function(){return[]};t.prototype.onUpdate=function(l){this._callbacks.add(l);return this};t.prototype.offUpdate=function(l){this._callbacks.delete(l);
return this};t.prototype._dispatchUpdate=function(){this._updateId++;this._callbacks.callCallbacks(this)};t.prototype.autoDomain=function(){this._autoDomainAutomatically=!0;this._setDomain(this._getExtent())};t.prototype._autoDomainIfAutomaticMode=function(){this._autoDomainAutomatically&&this.autoDomain()};t.prototype.scale=function(){throw Error("Subclasses should override scale");};t.prototype.ticks=function(){return this.domain()};t.prototype.domain=function(l){if(null==l)return this._getDomain();
this._autoDomainAutomatically=!1;this._setDomain(l);return this};t.prototype._getDomain=function(){throw Error("Subclasses should override _getDomain");};t.prototype._setDomain=function(l){this._domainModificationInProgress||(this._domainModificationInProgress=!0,this._backingScaleDomain(l),this._dispatchUpdate(),this._domainModificationInProgress=!1)};t.prototype._backingScaleDomain=function(){throw Error("Subclasses should override _backingDomain");};t.prototype.range=function(l){if(null==l)return this._getRange();
this._setRange(l);return this};t.prototype._getRange=function(){throw Error("Subclasses should override _getRange");};t.prototype._setRange=function(){throw Error("Subclasses should override _setRange");};t.prototype.addIncludedValuesProvider=function(l){this._includedValuesProviders.add(l);this._autoDomainIfAutomaticMode();return this};t.prototype.removeIncludedValuesProvider=function(l){this._includedValuesProviders.delete(l);this._autoDomainIfAutomaticMode()};t.prototype.updateId=function(){return this._updateId};
return t}();f.Scale=d},function(d,f,h){function k(q,u,x,A){for(var y={},w=0;w<u.length;w++){var C=u[w];q.hasOwnProperty(C)&&(y[C]=q[C](x,A))}return y}function t(q){return(null!=q["stroke-opacity"]?parseFloat(q["stroke-opacity"]):1)*(null!=q.opacity?parseFloat(q.opacity):1)}function l(q){return(null!=q["fill-opacity"]?parseFloat(q["fill-opacity"]):1)*(null!=q.opacity?parseFloat(q.opacity):1)}function p(q){return null!=q["stroke-width"]?parseFloat(q["stroke-width"]):1}function m(q,u){if(u.stroke){q.lineWidth=
p(u);var x=n.color(u.stroke);x.opacity*=t(u);q.strokeStyle=x.toString();q.stroke()}u.fill&&(x=n.color(u.fill),x.opacity*=l(u),q.fillStyle=x.toString(),q.fill())}var n=h(1);d=function(){function q(u,x){this._context=u;this._drawStep=x}q.prototype.getDrawStep=function(){return this._drawStep};q.prototype.draw=function(u,x){x=x[x.length-1].attrToAppliedProjector;this._context.save();this._drawStep(this._context,u,x);this._context.restore()};q.prototype.getVisualPrimitives=function(){return[]};q.prototype.getVisualPrimitiveAtIndex=
function(){return null};q.prototype.remove=function(){};return q}();f.CanvasDrawer=d;f.ContextStyleAttrs="fill-opacity fill opacity stroke-opacity stroke-width stroke".split(" ");f.resolveAttributesSubsetWithStyles=function(q,u,x,A){return k(q,f.ContextStyleAttrs.concat(u),x,A)};f.resolveAttributes=k;f.getStrokeWidth=p;f.renderArea=function(q,u,x,A){q.save();q.beginPath();u.context(q);u(x);q.lineJoin="round";m(q,A);q.restore()};f.renderLine=function(q,u,x,A){q.save();q.beginPath();u.context(q);u(x);
q.lineJoin="round";m(q,A);q.restore()};f.renderPathWithStyle=m},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(50));k(h(27));k(h(51));k(h(93));k(h(53));k(h(94));k(h(95));k(h(96));k(h(97));k(h(98));k(h(99));k(h(100))},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(92));k(h(91));d=h(49);f.sign=d.sign},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(134));k(h(135));k(h(136));k(h(137))},function(d,
f,h){var k=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&(n[x]=q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},t=h(1),l=h(5);d=h(4);var p=h(8),m=h(0);h=h(10);f.AxisOrientation=h.makeEnum(["bottom","left","right","top"]);h=function(n){function q(u,x){var A=n.call(this)||this;A._endTickLength=5;A._innerTickLength=5;A._tickLabelPadding=10;A._margin=15;A._showEndTickLabels=!1;A._annotationsEnabled=!1;A._annotationTierCount=
1;if(null==u||null==x)throw Error("Axis requires a scale and orientation");A._scale=u;A.orientation(x);A._setDefaultAlignment();A.addClass("axis");A.isHorizontal()?A.addClass("x-axis"):A.addClass("y-axis");A.formatter(p.identity());A._rescaleCallback=function(){return A._rescale()};A._scale.onUpdate(A._rescaleCallback);A._annotatedTicks=[];A._annotationFormatter=p.identity();return A}k(q,n);q.prototype.destroy=function(){n.prototype.destroy.call(this);this._scale.offUpdate(this._rescaleCallback)};
q.prototype.tickLabelDataOnElement=function(u){if(null!=u){for(var x;null!=u&&u.classList&&void 0===x;)u.classList.contains(q.TICK_LABEL_CLASS)?x=u:u=u.parentNode;return void 0===u?void 0:t.select(u).datum()}};q.prototype._computeWidth=function(){return this._maxLabelTickLength()};q.prototype._computeHeight=function(){return this._maxLabelTickLength()};q.prototype.requestedSpace=function(){var u=0,x=0;if(this.isHorizontal()){if(x=this._computeHeight()+this._margin,this.annotationsEnabled()){var A=
this._annotationMeasurer.measure().height+2*q._ANNOTATION_LABEL_PADDING;x+=A*this.annotationTierCount()}}else u=this._computeWidth()+this._margin,this.annotationsEnabled()&&(A=this._annotationMeasurer.measure().height+2*q._ANNOTATION_LABEL_PADDING,u+=A*this.annotationTierCount());return{minWidth:u,minHeight:x}};q.prototype.fixedHeight=function(){return this.isHorizontal()};q.prototype.fixedWidth=function(){return!this.isHorizontal()};q.prototype._rescale=function(){this.render()};q.prototype.computeLayout=
function(u,x,A){n.prototype.computeLayout.call(this,u,x,A);this.isHorizontal()?this._scale.range([0,this.width()]):this._scale.range([this.height(),0]);return this};q.prototype._sizeFromOffer=function(u,x){var A=this.requestedSpace(u,x);return this.isHorizontal()?{width:u,height:A.minHeight}:{height:x,width:A.minWidth}};q.prototype._setup=function(){n.prototype._setup.call(this);this._tickMarkContainer=this.content().append("g").classed(q.TICK_MARK_CLASS+"-container",!0);this._tickLabelContainer=
this.content().append("g").classed(q.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 u=this._annotationContainer.append("g").classed("annotation-label-container",
!0);u=new l.SvgContext(u.node());this._annotationMeasurer=new l.CacheMeasurer(u);this._annotationWriter=new l.Writer(this._annotationMeasurer,u)};q.prototype._getTickValues=function(){return[]};q.prototype.renderImmediately=function(){var u=this._getTickValues(),x=this._tickMarkContainer.selectAll("."+q.TICK_MARK_CLASS).data(u),A=x.enter().append("line").classed(q.TICK_MARK_CLASS,!0).merge(x);A.attrs(this._generateTickMarkAttrHash());t.select(A.nodes()[0]).classed(q.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0));
t.select(A.nodes()[u.length-1]).classed(q.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0));x.exit().remove();this._baseline.attrs(this._generateBaselineAttrHash());this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations();return this};q.prototype.annotatedTicks=function(){return this._annotatedTicks};q.prototype.annotationFormatter=function(u){if(null==u)return this._annotationFormatter;this._annotationFormatter=u;this.render();return this};q.prototype.annotationsEnabled=
function(){return this._annotationsEnabled};q.prototype.annotationTierCount=function(){return this._annotationTierCount};q.prototype._drawAnnotations=function(){function u(aa){switch(C.orientation()){case "bottom":case "right":return y(aa);case "top":case "left":return y(aa)-D.get(aa).height}}function x(aa){return O.has(aa)?"hidden":"visible"}function A(aa){return C._scale.scale(aa)}function y(aa){switch(C.orientation()){case "bottom":case "right":return N.get(aa)*I+K;case "top":case "left":return H-
K-N.get(aa)*I}}function w(aa,la,Z){aa=aa.selectAll("."+Z).data(B);la=aa.enter().append(la).classed(Z,!0).merge(aa);aa.exit().remove();return la}var C=this,G=q._ANNOTATION_LABEL_PADDING,D=new m.Map,B=this._annotatedTicksToRender();B.forEach(function(aa){var la=C._annotationMeasurer.measure(C.annotationFormatter()(aa));D.set(aa,{width:la.width+2*G,height:la.height+2*G})});var I=this._annotationMeasurer.measure().height+2*G,N=this._annotationToTier(D),O=new m.Set,H=this.isHorizontal()?this.height():
this.width(),K=this._coreSize(),M=Math.min(this.annotationTierCount(),Math.floor((H-K)/I));N.forEach(function(aa,la){(-1===aa||aa>=M)&&O.add(la)});switch(this.orientation()){case "bottom":case "right":var L=0;break;case "top":L=this.height();break;case "left":L=this.width()}var Q=this.isHorizontal();w(this._annotationContainer.select(".annotation-line-container"),"line",q.ANNOTATION_LINE_CLASS).attrs({x1:Q?A:L,x2:Q?A:y,y1:Q?L:A,y2:Q?y:A,visibility:x});w(this._annotationContainer.select(".annotation-circle-container"),
"circle",q.ANNOTATION_CIRCLE_CLASS).attrs({cx:Q?A:L,cy:Q?L:A,r:3});w(this._annotationContainer.select(".annotation-rect-container"),"rect",q.ANNOTATION_RECT_CLASS).attrs({x:Q?A:u,y:Q?u:A,width:Q?function(aa){return D.get(aa).width}:function(aa){return D.get(aa).height},height:Q?function(aa){return D.get(aa).height}:function(aa){return D.get(aa).width},visibility:x});var T=this._annotationWriter,X=this.annotationFormatter();L=w(this._annotationContainer.select(".annotation-label-container"),"g",q.ANNOTATION_LABEL_CLASS);
L.selectAll(".text-container").remove();L.attrs({transform:function(aa){var la=Q?A(aa):u(aa);aa=Q?u(aa):A(aa);return"translate("+la+","+aa+")"},visibility:x}).each(function(aa){T.write(X(aa),Q?D.get(aa).width:D.get(aa).height,Q?D.get(aa).height:D.get(aa).width,{xAlign:"center",yAlign:"center",textRotation:Q?0:90},t.select(this).node())})};q.prototype._annotatedTicksToRender=function(){var u=this,x=this._scale.range();return m.Array.uniq(this.annotatedTicks().filter(function(A){return null==A?!1:m.Math.inRange(u._scale.scale(A),
x[0],x[1])}))};q.prototype._coreSize=function(){var u=this.isHorizontal()?this.height():this.width(),x=this.isHorizontal()?this._computeHeight():this._computeWidth();return Math.min(x,u)};q.prototype._annotationTierHeight=function(){return this._annotationMeasurer.measure().height+2*q._ANNOTATION_LABEL_PADDING};q.prototype._annotationToTier=function(u){var x=this,A=[[]],y=new m.Map,w=this.isHorizontal()?this.width():this.height();this._annotatedTicksToRender().forEach(function(C){var G=x._scale.scale(C),
D=u.get(C).width;if(0>G||G+D>w)y.set(C,-1);else{for(var B=function(N){return A[N].some(function(O){var H=x._scale.scale(O);O=u.get(O).width;return G+D>=H&&G<=H+O})},I=0;B(I);)I++,A.length===I&&A.push([]);A[I].push(C);y.set(C,I)}});return y};q.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()};
q.prototype._generateBaselineAttrHash=function(){var u={x1:0,y1:0,x2:0,y2:0};switch(this._orientation){case "bottom":u.x2=this.width();break;case "top":u.x2=this.width();u.y1=this.height();u.y2=this.height();break;case "left":u.x1=this.width();u.x2=this.width();u.y2=this.height();break;case "right":u.y2=this.height()}return u};q.prototype._generateTickMarkAttrHash=function(u){function x(w){return A._scale.scale(w)}var A=this;void 0===u&&(u=!1);var y={x1:0,y1:0,x2:0,y2:0};this.isHorizontal()?(y.x1=
x,y.x2=x):(y.y1=x,y.y2=x);u=u?this._endTickLength:this._innerTickLength;switch(this._orientation){case "bottom":y.y2=u;break;case "top":y.y1=this.height();y.y2=this.height()-u;break;case "left":y.x1=this.width();y.x2=this.width()-u;break;case "right":y.x2=u}return y};q.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")}};
q.prototype.isHorizontal=function(){return"top"===this._orientation||"bottom"===this._orientation};q.prototype.getScale=function(){return this._scale};q.prototype.formatter=function(u){if(null==u)return this._formatter;this._formatter=u;this.redraw();return this};q.prototype.innerTickLength=function(){return this._innerTickLength};q.prototype.endTickLength=function(){return this._endTickLength};q.prototype._maxLabelTickLength=function(){return this.showEndTickLabels()?Math.max(this.innerTickLength(),
this.endTickLength()):this.innerTickLength()};q.prototype.tickLabelPadding=function(u){if(null==u)return this._tickLabelPadding;if(0>u)throw Error("tick label padding must be positive");this._tickLabelPadding=u;this.redraw();return this};q.prototype.margin=function(u){if(null==u)return this._margin;if(0>u)throw Error("margin size must be positive");this._margin=u;this.redraw();return this};q.prototype.orientation=function(u){if(null==u)return this._orientation;u=u.toLowerCase();if("top"!==u&&"bottom"!==
u&&"left"!==u&&"right"!==u)throw Error("unsupported orientation");this._orientation=u;this.redraw();return this};q.prototype.showEndTickLabels=function(){return this._showEndTickLabels};q.prototype._showAllTickMarks=function(){this._tickMarkContainer.selectAll("."+q.TICK_MARK_CLASS).each(function(){t.select(this).style("visibility","inherit")})};q.prototype._showAllTickLabels=function(){this._tickLabelContainer.selectAll("."+q.TICK_LABEL_CLASS).each(function(){t.select(this).style("visibility","inherit")})};
q.prototype._hideOverflowingTickLabels=function(){var u=this.element().node().getBoundingClientRect(),x=this._tickLabelContainer.selectAll("."+q.TICK_LABEL_CLASS);x.empty()||x.each(function(){m.DOM.clientRectInside(this.getBoundingClientRect(),u)||t.select(this).style("visibility","hidden")})};q.prototype._hideTickMarksWithoutLabel=function(){var u=this._tickMarkContainer.selectAll("."+q.TICK_MARK_CLASS),x=this._tickLabelContainer.selectAll("."+q.TICK_LABEL_CLASS).filter(function(){var A=t.select(this).style("visibility");
return"inherit"===A||"visible"===A}).data();u.each(function(A){-1===x.indexOf(A)&&t.select(this).style("visibility","hidden")})};q.prototype.invalidateCache=function(){n.prototype.invalidateCache.call(this);this._annotationMeasurer.reset()};return q}(d.Component);h.END_TICK_MARK_CLASS="end-tick-mark";h.TICK_MARK_CLASS="tick-mark";h.TICK_LABEL_CLASS="tick-label";h.ANNOTATION_LINE_CLASS="annotation-line";h.ANNOTATION_RECT_CLASS="annotation-rect";h.ANNOTATION_CIRCLE_CLASS="annotation-circle";h.ANNOTATION_LABEL_CLASS=
"annotation-label";h._ANNOTATION_LABEL_PADDING=4;f.Axis=h},function(d,f){f.SHOW_WARNINGS=!0;f.ADD_TITLE_ELEMENTS=!0},function(d,f,h){var k=h(0);d=function(){function t(){this._eventToProcessingFunction={};this._eventTarget=document;this._eventNameToCallbackSet={};this._connected=!1}t.prototype._hasNoCallbacks=function(){for(var l=Object.keys(this._eventNameToCallbackSet),p=0;p<l.length;p++)if(0!==this._eventNameToCallbackSet[l[p]].size)return!1;return!0};t.prototype._connect=function(){var l=this;
this._connected||(Object.keys(this._eventToProcessingFunction).forEach(function(p){l._eventTarget.addEventListener(p,l._eventToProcessingFunction[p])}),this._connected=!0)};t.prototype._disconnect=function(){var l=this;this._connected&&this._hasNoCallbacks()&&(Object.keys(this._eventToProcessingFunction).forEach(function(p){l._eventTarget.removeEventListener(p,l._eventToProcessingFunction[p])}),this._connected=!1)};t.prototype._addCallbackForEvent=function(l,p){null==this._eventNameToCallbackSet[l]&&
(this._eventNameToCallbackSet[l]=new k.CallbackSet);this._eventNameToCallbackSet[l].add(p);this._connect()};t.prototype._removeCallbackForEvent=function(l,p){null!=this._eventNameToCallbackSet[l]&&this._eventNameToCallbackSet[l].delete(p);this._disconnect()};t.prototype._callCallbacksForEvent=function(l){for(var p=[],m=1;m<arguments.length;m++)p[m-1]=arguments[m];m=this._eventNameToCallbackSet[l];null!=m&&m.callCallbacks.apply(m,p)};return t}();f.Dispatcher=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||
(f[l]=t[l])}k(h(87));k(h(88));k(h(40));k(h(89));k(h(90));d=h(26);f.zoomOut=d.zoomOut},function(d,f){function h(n,q,u){return u-(u-n)*q}function k(n,q,u){return(n*q-u)/(q-1)}function t(n,q,u,x){var A=1<q;u=A?x:u;if(null==u)return q;n=n.getTransformationDomain();return(A?Math.min:Math.max)(q,u/Math.abs(n[1]-n[0]))}function l(n,q,u,x,A){if(1>=q)return{centerPoint:u,zoomAmount:q};if(null==x&&null==A)return{centerPoint:u,zoomAmount:q};var y=p(n),w=m(n),C=w?Infinity:-Infinity;w=w?-Infinity:Infinity;x=null==
x?C:x;A=null==A?w:A;w=n.getTransformationDomain();C=w[0];w=w[1];A=n.scaleTransformation(A);w=n.scaleTransformation(w);var G=h(w,q,u);x=n.scaleTransformation(x);n=n.scaleTransformation(C);C=h(n,q,u);return Math.abs(G-C)>Math.abs(A-x)?(q=(A-x)/(w-n),1!==q?{centerPoint:k(w,q,A),zoomAmount:q}:{centerPoint:u,zoomAmount:q}):G>A!=y?{centerPoint:k(w,q,A),zoomAmount:q}:C<x!=y?{centerPoint:k(n,q,x),zoomAmount:q}:{centerPoint:u,zoomAmount:q}}function p(n){n=n.range();return n[1]<n[0]}function m(n){n=n.getTransformationDomain();
return n[1]<n[0]}f.zoomOut=h;f.constrainedZoom=function(n,q,u,x,A,y,w){q=t(n,q,x,A);return l(n,q,u,y,w)};f.constrainZoomExtents=t;f.constrainZoomValues=l;f.constrainedTranslation=function(n,q,u,x){var A=n.getTransformationDomain(),y=A[0],w=A[1];A=p(n);0<q!==A?(u=x,null!=u&&(y=n.scaleTransformation(w),n=n.scaleTransformation(u),q=(A?Math.max:Math.min)(y+q,n)-y)):null!=u&&(y=n.scaleTransformation(y),n=n.scaleTransformation(u),q=(A?Math.min:Math.max)(y+q,n)-y);return q}},function(d,f,h){function k(I,
N,O){var H=I.scale;if(H instanceof y.Category)O=H.rangeBand();else{var K=I.accessor;I=l.set(C.Array.flatten(N.map(function(M){return M.data().map(function(L,Q){return K(L,Q,M)}).filter(function(L){return null!=L}).map(function(L){return L.valueOf()})}))).values().map(function(M){return+M});I.sort(function(M,L){return M-L});I=I.map(function(M){return H.scale(M)});I=l.pairs(I);O=C.Math.min(I,function(M){return Math.abs(M[1]-M[0])},O*B._SINGLE_BAR_DIMENSION_RATIO);O*=B._BAR_THICKNESS_RATIO}return O}
var t=this&&this.__extends||function(I,N){function O(){this.constructor=I}for(var H in N)N.hasOwnProperty(H)&&(I[H]=N[H]);I.prototype=null===N?Object.create(N):(O.prototype=N.prototype,new O)},l=h(1),p=h(5),m=h(7),n=h(8),q=h(14),u=h(6),x=h(34),A=h(20),y=h(3),w=h(11),C=h(0);d=h(10);var G=h(19),D=h(2);h=h(16);f.BarOrientation=d.makeEnum(["vertical","horizontal"]);f.LabelsPosition=d.makeEnum(["start","middle","end","outside"]);f.BarAlignment=d.makeEnum(["start","middle","end"]);var B=function(I){function N(O){void 0===
O&&(O="vertical");var H=I.call(this)||this;H._labelFormatter=n.identity();H._labelsEnabled=!1;H._labelsPosition=f.LabelsPosition.end;H._hideBarsIfAnyAreTooWide=!0;H._barAlignment="middle";H._computeBarPixelThickness=A.memoize(k);H._fixedBarPixelThickness=!0;H.addClass("bar-plot");if("vertical"!==O&&"horizontal"!==O)throw Error(O+" is not a valid orientation for Plots.Bar");H._isVertical="vertical"===O;H.animator("baseline",new m.Null);H.attr("fill",(new y.Color).range()[0]);H.attr(N._BAR_THICKNESS_KEY,
function(){return H._barPixelThickness()});H._labelConfig=new C.Map;H._baselineValueProvider=function(){return[H.baselineValue()]};return H}t(N,I);N.prototype.computeLayout=function(O,H,K){I.prototype.computeLayout.call(this,O,H,K);this._updateExtents();return this};N.prototype.x=function(O,H){if(null==O)return I.prototype.x.call(this);null==H?I.prototype.x.call(this,O):I.prototype.x.call(this,O,H);this._updateThicknessAttr();this._updateLengthScale();return this};N.prototype.y=function(O,H){if(null==
O)return I.prototype.y.call(this);null==H?I.prototype.y.call(this,O):I.prototype.y.call(this,O,H);this._updateLengthScale();return this};N.prototype.length=function(){return this._isVertical?this.y():this.x()};N.prototype.position=function(){return this._isVertical?this.x():this.y()};N.prototype.barEnd=function(){return this._propertyBindings.get(N._BAR_END_KEY)};N.prototype.barAlignment=function(O){if(null==O)return this._barAlignment;this._barAlignment=O;this._clearAttrToProjectorCache();this.render();
return this};N.prototype.orientation=function(){return this._isVertical?"vertical":"horizontal"};N.prototype._createDrawer=function(){return new u.ProxyDrawer(function(){return new x.RectangleSVGDrawer(N._BAR_AREA_CLASS)},function(O){return new q.RectangleCanvasDrawer(O)})};N.prototype._setup=function(){I.prototype._setup.call(this);this._baseline=this._renderArea.append("line").classed("baseline",!0)};N.prototype.baselineValue=function(){if(null!=this._baselineValue)return this._baselineValue;if(!this._projectorsReady())return 0;
var O=this.length().scale;return O?O instanceof y.Time?new Date(0):0:0};N.prototype.addDataset=function(O){I.prototype.addDataset.call(this,O)};N.prototype._addDataset=function(O){I.prototype._addDataset.call(this,O);return this};N.prototype.removeDataset=function(O){I.prototype.removeDataset.call(this,O)};N.prototype._removeDataset=function(O){I.prototype._removeDataset.call(this,O);return this};N.prototype.datasets=function(O){if(null==O)return I.prototype.datasets.call(this);I.prototype.datasets.call(this,
O);return this};N.prototype.labelsEnabled=function(O,H){if(null==O)return this._labelsEnabled;this._labelsEnabled=O;null!=H&&(this._labelsPosition=H);this._clearAttrToProjectorCache();this.render();return this};N.prototype.labelFormatter=function(O){if(null==O)return this._labelFormatter;this._labelFormatter=O;this._clearAttrToProjectorCache();this.render();return this};N.prototype._createNodesForDataset=function(O){var H=I.prototype._createNodesForDataset.call(this,O),K=this._renderArea.append("g").classed(N._LABEL_AREA_CLASS,
!0),M=new p.SvgContext(K.node()),L=new p.CacheMeasurer(M);M=new p.Writer(L,M);this._labelConfig.set(O,{labelArea:K,measurer:L,writer:M});return H};N.prototype._removeDatasetNodes=function(O){I.prototype._removeDatasetNodes.call(this,O);var H=this._labelConfig.get(O);null!=H&&(H.labelArea.remove(),this._labelConfig.delete(O))};N.prototype.entityNearest=function(O){var H=this;return this._computeBarPixelThickness.doLocked(function(){function K(ca,ka,Y,Ea){return H._pixelPointBar(aa(ca,ka,Y),la,Ea)}
var M=H._isVertical?O.x:O.y,L=H._isVertical?O.y:O.x,Q=H.bounds(),T={min:0,max:Q.bottomRight.x-Q.topLeft.x},X={min:0,max:Q.bottomRight.y-Q.topLeft.y},aa=D.Plot._scaledAccessor(H.length()),la=H.length().scale.scale(H.baselineValue()),Z=Infinity,ba=Infinity,ea;H._getEntityStore().entities().forEach(function(ca){var ka=H._entityBounds(ca);if(C.DOM.intersectsBBox(T,X,ka)){var Y=0,Ea=0;if(!C.DOM.intersectsBBox(O.x,O.y,ka,.5)){Ea=K(ca.datum,ca.index,ca.dataset,ka);Y=Math.abs(M-(H._isVertical?Ea.x:Ea.y));
var va=H._isVertical?ka.y:ka.x;ka=va+(H._isVertical?ka.height:ka.width);Ea=L>=va-.5&&L<=ka+.5?0:Math.abs(L-(H._isVertical?Ea.y:Ea.x))}if(Y<Z||Y===Z&&Ea<ba)ea=ca,Z=Y,ba=Ea}});if(void 0!==ea)return H._lightweightPlotEntityToPlotEntity(ea)})};N.prototype.entitiesAt=function(O){return this._entitiesIntersecting(O.x,O.y)};N.prototype._entitiesIntersecting=function(O,H){var K=this,M=[];this._getEntityStore().entities().forEach(function(L){C.DOM.intersectsBBox(O,H,K._entityBounds(L))&&M.push(K._lightweightPlotEntityToPlotEntity(L))});
return M};N.prototype._updateLengthScale=function(){if(this._projectorsReady()){var O=this.length().scale;O instanceof w.QuantitativeScale&&(O.addPaddingExceptionsProvider(this._baselineValueProvider),O.addIncludedValuesProvider(this._baselineValueProvider))}};N.prototype.renderImmediately=function(){var O=this;this._barPixelThickness();return this._computeBarPixelThickness.doLocked(function(){return I.prototype.renderImmediately.call(O)})};N.prototype._additionalPaint=function(O){var H=this,K=this.length().scale.scale(this.baselineValue());
K={x1:this._isVertical?0:K,y1:this._isVertical?K:0,x2:this._isVertical?this.width():K,y2:this._isVertical?K:this.height()};this._getAnimator("baseline").animate(this._baseline,K);this.datasets().forEach(function(M){return H._labelConfig.get(M).labelArea.selectAll("g").remove()});this._labelsEnabled&&C.Window.setTimeout(function(){return H._drawLabels()},O)};N.prototype.getExtentsForProperty=function(O){var H=this,K=I.prototype.getExtentsForProperty.call(this,O);if("x"===O&&this._isVertical)O=this.x();
else{if("y"!==O||this._isVertical)return K;O=this.y()}if(!(O&&O.scale&&O.scale instanceof w.QuantitativeScale))return K;var M=O.scale,L=this._barPixelThickness();return K=K.map(function(Q){return l.extent([M.invert(H._getPositionAttr(M.scale(Q[0]),L)),M.invert(H._getPositionAttr(M.scale(Q[0]),L)+L),M.invert(H._getPositionAttr(M.scale(Q[1]),L)),M.invert(H._getPositionAttr(M.scale(Q[1]),L)+L)])})};N.prototype._getPositionAttr=function(O,H){this._isVertical||(O-=H,H*=-1);switch(this._barAlignment){case "start":return O;
case "end":return O-H;default:return O-H/2}};N.prototype._drawLabels=function(){var O=this,H=this._getDataToDraw(),K=this._getAttrToProjector(),M=this.datasets().some(function(L){return H.get(L).some(function(Q,T){return null==Q?!1:O._drawLabel(Q,T,L,K)})});this._hideBarsIfAnyAreTooWide&&M&&this.datasets().forEach(function(L){return O._labelConfig.get(L).labelArea.selectAll("g").remove()})};N.prototype._drawLabel=function(O,H,K,M){var L=this._labelConfig.get(K),Q=L.labelArea,T=L.measurer;L=L.writer;
var X=this.length().accessor,aa=X(O,H,K);X=this.length().scale;var la=null!=X?X.scale(aa):aa,Z=null!=X?X.scale(this.baselineValue()):this.baselineValue(),ba={x:M.x(O,H,K),y:M.y(O,H,K)};X={width:M.width(O,H,K),height:M.height(O,H,K)};aa=this._labelFormatter(aa,O,H,K);T=T.measure(aa);var ea=this._shouldShowLabelOnBar(ba,X,T);ba=this._calculateLabelProperties(ba,X,T,ea,this._isVertical?la<=Z:la<Z);la=ba.containerDimensions;Z=ba.labelContainerOrigin;ba=ba.alignment;O=M.fill(O,H,K);Q=this._createLabelContainer(Q,
Z,ea,O);L.write(aa,la.width,la.height,{xAlign:ba.x,yAlign:ba.y},Q.node());return this._isVertical?X.width<T.width:X.height<T.height};N.prototype._shouldShowLabelOnBar=function(O,H,K){if(this._labelsPosition===f.LabelsPosition.outside)return!1;O=this._isVertical?O.y:O.x;var M=this._isVertical?H.height:H.width;H=this._isVertical?this.height():this.width();K=this._isVertical?K.height:K.width;var L=O+M;L>H?M=H-O:0>O&&(M=L);return K+N._LABEL_MARGIN_INSIDE_BAR<=M};N.prototype._calculateLabelProperties=
function(O,H,K,M,L){function Q(ka){switch(ka){case "topLeft":Z=T._isVertical?"top":"left";ea+=N._LABEL_MARGIN_INSIDE_BAR;ca+=N._LABEL_MARGIN_INSIDE_BAR;break;case "center":ca+=(aa+la)/2;break;case "bottomRight":Z=T._isVertical?"bottom":"right",ea-=N._LABEL_MARGIN_INSIDE_BAR,ca+=ba-N._LABEL_MARGIN_INSIDE_BAR-la}}var T=this,X=this._isVertical?O.y:O.x,aa=this._isVertical?H.height:H.width,la=this._isVertical?K.height:K.width,Z="center",ba=aa,ea=X,ca=X;if(M)switch(this._labelsPosition){case f.LabelsPosition.start:L?
Q("bottomRight"):Q("topLeft");break;case f.LabelsPosition.middle:Q("center");break;case f.LabelsPosition.end:L?Q("topLeft"):Q("bottomRight")}else L?(Z=this._isVertical?"top":"left",ba=aa+N._LABEL_MARGIN_INSIDE_BAR+la,ea-=N._LABEL_MARGIN_INSIDE_BAR+la,ca-=N._LABEL_MARGIN_INSIDE_BAR+la):(Z=this._isVertical?"bottom":"right",ba=aa+N._LABEL_MARGIN_INSIDE_BAR+la,ca+=aa+N._LABEL_MARGIN_INSIDE_BAR);return{containerDimensions:{width:this._isVertical?H.width:ba,height:this._isVertical?ba:H.height},labelContainerOrigin:{x:this._isVertical?
O.x:ea,y:this._isVertical?ea:O.y},labelOrigin:{x:this._isVertical?O.x+H.width/2-K.width/2:ca,y:this._isVertical?ca:O.y+H.height/2-K.height/2},alignment:{x:this._isVertical?"center":Z,y:this._isVertical?Z:"center"}}};N.prototype._createLabelContainer=function(O,H,K,M){O=O.append("g").attr("transform","translate("+H.x+", "+H.y+")");K?(O.classed("on-bar-label",!0),K=1.6*C.Color.contrast("white",M)<C.Color.contrast("black",M),O.classed(K?"dark-label":"light-label",!0)):O.classed("off-bar-label",!0);return O};
N.prototype._generateDrawSteps=function(){var O=[];if(this._animateOnNextRender()){var H=this._getAttrToProjector(),K=this.length().scale.scale(this.baselineValue()),M=this._isVertical?"height":"width";H[this._isVertical?"y":"x"]=function(){return K};H[M]=function(){return 0};O.push({attrToProjector:H,animator:this._getAnimator(G.Animator.RESET)})}O.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(G.Animator.MAIN)});return O};N.prototype._generateAttrToProjector=function(){function O(ba,
ea,ca){return Math.abs(M-X(ba,ea,ca))}var H=this,K=I.prototype._generateAttrToProjector.call(this),M=this.length().scale.scale(this.baselineValue()),L=this._isVertical?"y":"x",Q=this._isVertical?"x":"y",T=D.Plot._scaledAccessor(this.position()),X=D.Plot._scaledAccessor(this.length()),aa=K[N._BAR_THICKNESS_KEY],la=K.gap,Z=null==la?aa:function(ba,ea,ca){return aa(ba,ea,ca)-la(ba,ea,ca)};K.width=this._isVertical?Z:O;K.height=this._isVertical?O:Z;K[L]=function(ba,ea,ca){ba=X(ba,ea,ca);return ba>M?M:ba};
K[Q]=function(ba,ea,ca){return H._getPositionAttr(T(ba,ea,ca),aa(ba,ea,ca))};return K};N.prototype._updateThicknessAttr=function(){var O=this,H=this.position(),K=this.barEnd();null!=H&&null!=K?(this._fixedBarPixelThickness=!1,this.attr(N._BAR_THICKNESS_KEY,function(M,L,Q){var T=H.accessor(M,L,Q);M=K.accessor(M,L,Q);T=H.scale?H.scale.scale(T):T;M=K.scale?K.scale.scale(M):M;return Math.abs(M-T)})):(this._fixedBarPixelThickness=!0,this.attr(N._BAR_THICKNESS_KEY,function(){return O._barPixelThickness()}))};
N.prototype._barPixelThickness=function(){return this._fixedBarPixelThickness?this._projectorsReady()?this._computeBarPixelThickness(this.position(),this.datasets(),this._isVertical?this.width():this.height()):0:0};N.prototype.entities=function(O){void 0===O&&(O=this.datasets());return this._projectorsReady()?I.prototype.entities.call(this,O):[]};N.prototype._entityBounds=function(O){return this._pixelBounds(O.datum,O.index,O.dataset)};N.prototype._pixelBounds=function(O,H,K){var M=this._getAttrToProjector();
return{x:M.x(O,H,K),y:M.y(O,H,K),width:M.width(O,H,K),height:M.height(O,H,K)}};N.prototype._pixelPoint=function(O,H,K){var M=this._pixelBounds(O,H,K);O=(this._isVertical?D.Plot._scaledAccessor(this.y()):D.Plot._scaledAccessor(this.x()))(O,H,K);H=(this._isVertical?this.y().scale:this.x().scale).scale(this.baselineValue());return this._pixelPointBar(O,H,M)};N.prototype._pixelPointBar=function(O,H,K){if(this._isVertical){var M=K.x+K.width/2;O=O<=H?K.y:K.y+K.height}else M=O>=H?K.x+K.width:K.x,O=K.y+K.height/
2;return{x:M,y:O}};N.prototype._uninstallScaleForKey=function(O,H){I.prototype._uninstallScaleForKey.call(this,O,H)};N.prototype._getDataToDraw=function(){var O=this,H=new C.Map,K=this._getAttrToProjector(),M=this.width(),L=this.height();this.datasets().forEach(function(Q){var T=Q.data().map(function(X,aa){return O._isDatumOnScreen(K,M,L,X,aa,Q)?X:null});H.set(Q,T)});return H};N.prototype._isDatumOnScreen=function(O,H,K,M,L,Q){var T=O.x(M,L,Q),X=O.y(M,L,Q),aa=O.width(M,L,Q);O=O.height(M,L,Q);return C.Math.isValidNumber(T)&&
C.Math.isValidNumber(X)&&C.Math.isValidNumber(aa)&&C.Math.isValidNumber(O)?C.Math.boundsIntersects(T,X,aa,O,H,K):!1};return N}(h.XYPlot);B._BAR_THICKNESS_RATIO=.95;B._SINGLE_BAR_DIMENSION_RATIO=.4;B._BAR_AREA_CLASS="bar-area";B._BAR_END_KEY="barEnd";B._BAR_THICKNESS_KEY="width";B._LABEL_AREA_CLASS="bar-label-text-area";B._LABEL_MARGIN_INSIDE_BAR=10;f.Bar=B},function(d,f,h){var k=this&&this.__extends||function(x,A){function y(){this.constructor=x}for(var w in A)A.hasOwnProperty(w)&&(x[w]=A[w]);x.prototype=
null===A?Object.create(A):(y.prototype=A.prototype,new y)},t=h(1),l=h(5),p=h(8),m=h(3),n=h(0);d=h(10);var q=h(22);f.TimeInterval=d.makeEnum("second minute hour day week month year".split(" "));f.TimeAxisOrientation=d.makeEnum(["top","bottom"]);f.TierLabelPosition=d.makeEnum(["between","center"]);h=function(x){function A(y,w){y=x.call(this,y,w)||this;y._maxTimeIntervalPrecision=null;y._tierLabelPositions=[];y.addClass("time-axis");y.tickLabelPadding(5);y.axisConfigurations(A._DEFAULT_TIME_AXIS_CONFIGURATIONS);
y.annotationFormatter(p.time("%a %b %d, %Y"));return y}k(A,x);A.prototype.tierLabelPositions=function(y){if(null==y)return this._tierLabelPositions;if(!y.every(function(w){return"between"===w.toLowerCase()||"center"===w.toLowerCase()}))throw Error("Unsupported position for tier labels");this._tierLabelPositions=y;this.redraw();return this};A.prototype.maxTimeIntervalPrecision=function(y){if(null==y)return this._maxTimeIntervalPrecision;this._maxTimeIntervalPrecision=y;this.redraw();return this};A.prototype.currentAxisConfiguration=
function(){return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex]};A.prototype.axisConfigurations=function(y){if(null!=y){this._possibleTimeAxisConfigurations=y;this._numTiers=n.Math.max(this._possibleTimeAxisConfigurations.map(function(G){return G.length}),0);this._isAnchored&&this._setupDomElements();y=this.tierLabelPositions();for(var w=[],C=0;C<this._numTiers;C++)w.push(y[C]||"between");this.tierLabelPositions(w);this.redraw()}};A.prototype._getMostPreciseConfigurationIndex=
function(){var y=this,w=this._possibleTimeAxisConfigurations.length;this._possibleTimeAxisConfigurations.forEach(function(C,G){G<w&&C.every(function(D){return y._checkTimeAxisTierConfiguration(D)})&&(w=G)});w===this._possibleTimeAxisConfigurations.length&&(n.Window.warn("zoomed out too far: could not find suitable interval to display labels"),--w);return w};A.prototype.orientation=function(y){if(y&&("right"===y.toLowerCase()||"left"===y.toLowerCase()))throw Error(y+" is not a supported orientation for TimeAxis - only horizontal orientations are supported");
return x.prototype.orientation.call(this,y)};A.prototype._computeHeight=function(){var y=this._measurer.measure().height;this._tierHeights=[];for(var w=0;w<this._numTiers;w++)this._tierHeights.push(y+this.tickLabelPadding()+("between"===this._tierLabelPositions[w]?0:this._maxLabelTickLength()));return t.sum(this._tierHeights)};A.prototype._getIntervalLength=function(y){var w=this._scale.domain()[0];y=m.Time.timeIntervalToD3Time(y.interval).offset(w,y.step);return y>this._scale.domain()[1]?this.width():
Math.abs(this._scale.scale(y)-this._scale.scale(w))};A.prototype._maxWidthForInterval=function(y){return this._measurer.measure(y.formatter(A._LONG_DATE)).width};A.prototype._checkTimeAxisTierConfiguration=function(y){if(null!=this._maxTimeIntervalPrecision){var w=A._SORTED_TIME_INTERVAL_INDEX[this._maxTimeIntervalPrecision],C=A._SORTED_TIME_INTERVAL_INDEX[y.interval];if(null!=w&&null!=C&&C<w)return!1}w=this._maxWidthForInterval(y)+2*this.tickLabelPadding();return Math.min(this._getIntervalLength(y),
this.width())>=w};A.prototype._sizeFromOffer=function(y,w){var C=x.prototype._sizeFromOffer.call(this,y,w);y=this._tierHeights.reduce(function(G,D){return G+D>C.height?G:G+D});w=this.margin()+(this.annotationsEnabled()?this.annotationTierCount()*this._annotationTierHeight():0);C.height=Math.min(C.height,y+w);return C};A.prototype._setup=function(){x.prototype._setup.call(this);this._setupDomElements()};A.prototype._setupDomElements=function(){this.content().selectAll("."+A.TIME_AXIS_TIER_CLASS).remove();
this._tierLabelContainers=[];this._tierMarkContainers=[];this._tierBaselines=[];this._tickLabelContainer.remove();this._baseline.remove();for(var y=0;y<this._numTiers;++y){var w=this.content().append("g").classed(A.TIME_AXIS_TIER_CLASS,!0);this._tierLabelContainers.push(w.append("g").classed(q.Axis.TICK_LABEL_CLASS+"-container",!0));this._tierMarkContainers.push(w.append("g").classed(q.Axis.TICK_MARK_CLASS+"-container",!0));this._tierBaselines.push(w.append("line").classed("baseline",!0))}y=new l.SvgContext(this._tierLabelContainers[0].node());
this._measurer=new l.CacheMeasurer(y)};A.prototype._getTickIntervalValues=function(y){return this._scale.tickInterval(y.interval,y.step)};A.prototype._getTickValues=function(){var y=this;return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex].reduce(function(w,C){return w.concat(y._getTickIntervalValues(C))},[])};A.prototype._cleanTiers=function(){for(var y=0;y<this._tierLabelContainers.length;y++)this._tierLabelContainers[y].selectAll("."+q.Axis.TICK_LABEL_CLASS).remove(),this._tierMarkContainers[y].selectAll("."+
q.Axis.TICK_MARK_CLASS).remove(),this._tierBaselines[y].style("visibility","hidden")};A.prototype._getTickValuesForConfiguration=function(y){y=this._scale.tickInterval(y.interval,y.step);var w=this._scale.domain(),C=y.map(function(G){return G.valueOf()});-1===C.indexOf(w[0].valueOf())&&y.unshift(w[0]);-1===C.indexOf(w[1].valueOf())&&y.push(w[1]);return y};A.prototype._renderTierLabels=function(y,w,C){var G=this,D=this._getTickValuesForConfiguration(w),B=[];"between"===this._tierLabelPositions[C]&&
1===w.step?D.map(function(K,M){M+1>=D.length||B.push(new Date((D[M+1].valueOf()-D[M].valueOf())/2+D[M].valueOf()))}):B=D;y=y.selectAll("."+q.Axis.TICK_LABEL_CLASS).data(B,function(K){return String(K.valueOf())});var I=y.enter().append("g").classed(q.Axis.TICK_LABEL_CLASS,!0);I.append("text");var N="center"===this._tierLabelPositions[C]||1===w.step?0:this.tickLabelPadding();var O="bottom"===this.orientation()?t.sum(this._tierHeights.slice(0,C+1))-this.tickLabelPadding():"center"===this._tierLabelPositions[C]?
this.height()-t.sum(this._tierHeights.slice(0,C))-this.tickLabelPadding()-this._maxLabelTickLength():this.height()-t.sum(this._tierHeights.slice(0,C))-this.tickLabelPadding();I=y.merge(I);var H=I.selectAll("text");0<H.size()&&H.attr("transform","translate("+N+","+O+")");y.exit().remove();I.attr("transform",function(K){return"translate("+G._scale.scale(K)+",0)"});C="center"===this._tierLabelPositions[C]||1===w.step?"middle":"start";I.selectAll("text").text(w.formatter).style("text-anchor",C)};A.prototype._renderTickMarks=
function(y,w){y=this._tierMarkContainers[w].selectAll("."+q.Axis.TICK_MARK_CLASS).data(y);var C=y.enter().append("line").classed(q.Axis.TICK_MARK_CLASS,!0).merge(y),G=this._generateTickMarkAttrHash(),D=this._tierHeights.slice(0,w).reduce(function(B,I){return B+I},0);"bottom"===this.orientation()?(G.y1=D,G.y2=D+("center"===this._tierLabelPositions[w]?this.innerTickLength():this._tierHeights[w])):(G.y1=this.height()-D,G.y2=this.height()-(D+("center"===this._tierLabelPositions[w]?this.innerTickLength():
this._tierHeights[w])));C.attrs(G);"bottom"===this.orientation()?(G.y1=D,G.y2=D+("center"===this._tierLabelPositions[w]?this.endTickLength():this._tierHeights[w])):(G.y1=this.height()-D,G.y2=this.height()-(D+("center"===this._tierLabelPositions[w]?this.endTickLength():this._tierHeights[w])));t.select(C.nodes()[0]).attrs(G);t.select(C.nodes()[C.size()-1]).attrs(G);t.select(C.nodes()[0]).classed(q.Axis.END_TICK_MARK_CLASS,!0);t.select(C.nodes()[C.size()-1]).classed(q.Axis.END_TICK_MARK_CLASS,!0);y.exit().remove()};
A.prototype._renderLabellessTickMarks=function(y){y=this._tickMarkContainer.selectAll("."+q.Axis.TICK_MARK_CLASS).data(y);var w=y.enter().append("line").classed(q.Axis.TICK_MARK_CLASS,!0).merge(y),C=this._generateTickMarkAttrHash();C.y2="bottom"===this.orientation()?this.tickLabelPadding():this.height()-this.tickLabelPadding();w.attrs(C);y.exit().remove()};A.prototype._generateLabellessTicks=function(){return 1>this._mostPreciseConfigIndex?[]:this._getTickIntervalValues(this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex-
1][0])};A.prototype.renderImmediately=function(){var y=this;this._mostPreciseConfigIndex=this._getMostPreciseConfigurationIndex();var w=this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex];this._cleanTiers();w.forEach(function(I,N){return y._renderTierLabels(y._tierLabelContainers[N],I,N)});for(var C=w.map(function(I){return y._getTickValuesForConfiguration(I)}),G=0,D=0;D<Math.max(w.length,1);++D){var B=this._generateBaselineAttrHash();B.y1+="bottom"===this.orientation()?G:-G;B.y2=B.y1;
this._tierBaselines[D].attrs(B).style("visibility","inherit");G+=this._tierHeights[D]}G=[];D=this._scale.domain();D=this._scale.scale(D[1])-this._scale.scale(D[0]);1.5*this._getIntervalLength(w[0])>=D&&(G=this._generateLabellessTicks());this._renderLabellessTickMarks(G);this._hideOverflowingTiers();for(D=0;D<w.length;++D)this._renderTickMarks(C[D],D),this._hideOverlappingAndCutOffLabels(D);this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations();return this};A.prototype._hideOverflowingTiers=
function(){var y=this,w=this.height(),C=0;this.content().selectAll("."+A.TIME_AXIS_TIER_CLASS).attr("visibility",function(G,D){C+=y._tierHeights[D];return C<=w?"inherit":"hidden"})};A.prototype._hideOverlappingAndCutOffLabels=function(y){function w(I){return Math.floor(G.left)<=Math.ceil(I.left)&&Math.floor(G.top)<=Math.ceil(I.top)&&Math.floor(I.right)<=Math.ceil(G.left+C.width())&&Math.floor(I.bottom)<=Math.ceil(G.top+C.height())}var C=this,G=this.element().node().getBoundingClientRect(),D=this._tierMarkContainers[y].selectAll("."+
q.Axis.TICK_MARK_CLASS).filter(function(){var I=t.select(this).style("visibility");return"visible"===I||"inherit"===I}).nodes().map(function(I){return I.getBoundingClientRect()}),B;this._tierLabelContainers[y].selectAll("."+q.Axis.TICK_LABEL_CLASS).filter(function(){var I=t.select(this).style("visibility");return"visible"===I||"inherit"===I}).each(function(I,N){I=this.getBoundingClientRect();var O=t.select(this),H=D[N],K=D[N+1];N=null!=B&&n.DOM.clientRectsOverlap(I,B);H=null!=H&&n.DOM.clientRectsOverlap(I,
H);K=null!=K&&n.DOM.clientRectsOverlap(I,K);!w(I)||N||H||K?O.style("visibility","hidden"):(B=I,O.style("visibility","inherit"))})};A.prototype.invalidateCache=function(){x.prototype.invalidateCache.call(this);this._measurer.reset()};return A}(q.Axis);h.TIME_AXIS_TIER_CLASS="time-axis-tier";h._SORTED_TIME_INTERVAL_INDEX=(u={},u[f.TimeInterval.second]=0,u[f.TimeInterval.minute]=1,u[f.TimeInterval.hour]=2,u[f.TimeInterval.day]=3,u[f.TimeInterval.week]=4,u[f.TimeInterval.month]=5,u[f.TimeInterval.year]=
6,u);h._DEFAULT_TIME_AXIS_CONFIGURATIONS=[[{interval:f.TimeInterval.second,step:1,formatter:p.time("%I:%M:%S %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.second,step:5,formatter:p.time("%I:%M:%S %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.second,step:10,formatter:p.time("%I:%M:%S %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.second,step:15,
formatter:p.time("%I:%M:%S %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.second,step:30,formatter:p.time("%I:%M:%S %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.minute,step:1,formatter:p.time("%I:%M %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.minute,step:5,formatter:p.time("%I:%M %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],
[{interval:f.TimeInterval.minute,step:10,formatter:p.time("%I:%M %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.minute,step:15,formatter:p.time("%I:%M %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.minute,step:30,formatter:p.time("%I:%M %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.hour,step:1,formatter:p.time("%I %p")},{interval:f.TimeInterval.day,
step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.hour,step:3,formatter:p.time("%I %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.hour,step:6,formatter:p.time("%I %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.hour,step:12,formatter:p.time("%I %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.day,step:1,formatter:p.time("%a %e")},
{interval:f.TimeInterval.month,step:1,formatter:p.time("%B %Y")}],[{interval:f.TimeInterval.day,step:1,formatter:p.time("%e")},{interval:f.TimeInterval.month,step:1,formatter:p.time("%B %Y")}],[{interval:f.TimeInterval.month,step:1,formatter:p.time("%B")},{interval:f.TimeInterval.year,step:1,formatter:p.time("%Y")}],[{interval:f.TimeInterval.month,step:1,formatter:p.time("%b")},{interval:f.TimeInterval.year,step:1,formatter:p.time("%Y")}],[{interval:f.TimeInterval.month,step:3,formatter:p.time("%b")},
{interval:f.TimeInterval.year,step:1,formatter:p.time("%Y")}],[{interval:f.TimeInterval.month,step:6,formatter:p.time("%b")},{interval:f.TimeInterval.year,step:1,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:1,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:1,formatter:p.time("%y")}],[{interval:f.TimeInterval.year,step:5,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:25,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:50,formatter:p.time("%Y")}],
[{interval:f.TimeInterval.year,step:100,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:200,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:500,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:1E3,formatter:p.time("%Y")}]];h._LONG_DATE=new Date(9999,8,29,12,59,9999);f.Time=h;var u},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=
p.prototype,new m)},t=h(12);d=function(l){function p(){var m=l.call(this)||this;m._detachCallback=function(n){return m.remove(n)};return m}k(p,l);p.prototype.anchor=function(m){var n=this;m=t.coerceExternalD3(m);l.prototype.anchor.call(this,m);this._forEach(function(q){return q.anchor(n.element())});return this};p.prototype.render=function(){this._forEach(function(m){return m.render()});return this};p.prototype.has=function(){throw Error("has() is not implemented on ComponentContainer");};p.prototype._adoptAndAnchor=
function(m){m.parent(this);m.onDetach(this._detachCallback);this._isAnchored&&m.anchor(this.element())};p.prototype.remove=function(m){this.has(m)&&(m.offDetach(this._detachCallback),this._remove(m),m.detach(),this.redraw());return this};p.prototype._remove=function(){};p.prototype._forEach=function(){throw Error("_forEach() is not implemented on ComponentContainer");};p.prototype.destroy=function(){l.prototype.destroy.call(this);this._forEach(function(m){return m.destroy()})};p.prototype.invalidateCache=
function(){this._forEach(function(m){return m.invalidateCache()})};return p}(h(4).Component);f.ComponentContainer=d},function(d,f,h){function k(A){n.add(A);m.add(A);t()}function t(){q||(q=!0,x.render())}var l=h(0);d=h(10);var p=h(39),m=new l.Set,n=new l.Set,q=!1,u=!1;f.Policy=d.makeEnum(["immediate","animationFrame","timeout"]);var x=new p.AnimationFrame;f.renderPolicy=function(A){if(null==A)return x;switch(A){case f.Policy.immediate:x=new p.Immediate;break;case f.Policy.animationFrame:x=new p.AnimationFrame;
break;case f.Policy.timeout:x=new p.Timeout;break;default:l.Window.warn("Unrecognized renderPolicy: "+A)}};f.registerToRender=function(A){u&&l.Window.warn("Registered to render while other components are flushing: request may be ignored");m.add(A);t()};f.registerToComputeLayoutAndRender=k;f.registerToComputeLayout=function(A){k(A)};f.flush=function(){if(q){n.forEach(function(y){return y.computeLayout()});m.forEach(function(y){return y.render()});u=!0;var A=new l.Set;m.forEach(function(y){try{y.renderImmediately()}catch(w){window.setTimeout(function(){throw w;
},0),A.add(y)}});n=new l.Set;m=A;u=q=!1}}},function(d,f,h){var k=h(1);f.circle=function(){return function(l){return k.symbol().type(k.symbolCircle).size(Math.PI*Math.pow(l/2,2))}};f.square=function(){return function(l){return k.symbol().type(k.symbolSquare).size(Math.pow(l,2))}};f.cross=function(){return function(l){return k.symbol().type(k.symbolCross).size(5/9*Math.pow(l,2))}};f.diamond=function(){return function(l){return k.symbol().type(k.symbolDiamond).size(Math.tan(Math.PI/6)*Math.pow(l,2)/
2)}};f.triangle=function(){return function(l){return k.symbol().type(k.symbolTriangle).size(Math.sqrt(3)*Math.pow(l/2,2))}};f.star=function(){return function(l){return k.symbol().type(k.symbolStar).size(.8908130915292852*Math.pow(l/2,2))}};var t=3*(1/Math.sqrt(12)/2+1);f.wye=function(){return function(l){return k.symbol().type(k.symbolWye).size(t*Math.pow(l/2.4,2))}}},function(d,f,h){var k=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&(n[x]=
q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},t=h(25),l=h(0),p=h(12),m=h(37);d=function(n){function q(){var u=n.call(this)||this;u._detectionRadius=3;u._resizable=!1;u._movable=!1;u._hasCorners=!0;u.addClass("drag-box-layer");u._dragInteraction=new t.Drag;u._setUpCallbacks();u._dragInteraction.attachTo(u);u._dragStartCallbacks=new l.CallbackSet;u._dragCallbacks=new l.CallbackSet;u._dragEndCallbacks=new l.CallbackSet;return u}k(q,n);q.prototype._setUpCallbacks=function(){function u(I,
N){0===B&&I.x===N.x&&I.y===N.y&&y.boxVisible(!1);y._dragEndCallbacks.callCallbacks(y.bounds())}function x(I,N){switch(B){case 0:G.x=N.x;G.y=N.y;break;case 1:w.bottom?G.y=N.y:w.top&&(C.y=N.y);w.right?G.x=N.x:w.left&&(C.x=N.x);break;case 2:I=N.x-D.x;var O=N.y-D.y;C.x+=I;C.y+=O;G.x+=I;G.y+=O;D=N}y._setBounds({topLeft:C,bottomRight:G});y._xBoundsMode===m.PropertyMode.VALUE&&null!=y.xScale()&&y._setXExtent([y.xScale().invert(C.x),y.xScale().invert(G.x)]);y._yBoundsMode===m.PropertyMode.VALUE&&null!=y.yScale()&&
y._setYExtent([y.yScale().invert(C.y),y.yScale().invert(G.y)]);y.render();y._dragCallbacks.callCallbacks(y.bounds())}function A(I){w=y._getResizingEdges(I);var N=y.bounds();N=N.topLeft.x<=I.x&&I.x<=N.bottomRight.x&&N.topLeft.y<=I.y&&I.y<=N.bottomRight.y;y.boxVisible()&&(w.top||w.bottom||w.left||w.right)?B=1:y.boxVisible()&&y.movable()&&N?B=2:(B=0,y._setBounds({topLeft:I,bottomRight:I}),y._xBoundsMode===m.PropertyMode.VALUE&&null!=y.xScale()&&y._setXExtent([y.xScale().invert(I.x),y.xScale().invert(I.x)]),
y._yBoundsMode===m.PropertyMode.VALUE&&null!=y.yScale()&&y._setYExtent([y.yScale().invert(I.y),y.yScale().invert(I.y)]),y.render());y.boxVisible(!0);N=y.bounds();C={x:N.topLeft.x,y:N.topLeft.y};G={x:N.bottomRight.x,y:N.bottomRight.y};D=I;y._dragStartCallbacks.callCallbacks(N)}var y=this,w,C,G,D,B=0;this._dragInteraction.onDragStart(A);this._dragInteraction.onDrag(x);this._dragInteraction.onDragEnd(u);this._disconnectInteraction=function(){y._dragInteraction.offDragStart(A);y._dragInteraction.offDrag(x);
y._dragInteraction.offDragEnd(u);y._dragInteraction.detach()}};q.prototype._setup=function(){function u(){return x._box.append("line").styles({opacity:0,stroke:"pink","pointer-events":"visibleStroke"})}var x=this;n.prototype._setup.call(this);this._detectionEdgeT=u().classed("drag-edge-tb",!0);this._detectionEdgeB=u().classed("drag-edge-tb",!0);this._detectionEdgeL=u().classed("drag-edge-lr",!0);this._detectionEdgeR=u().classed("drag-edge-lr",!0);if(this._hasCorners){var A=function(){return x._box.append("circle").styles({opacity:0,
fill:"pink","pointer-events":"visibleFill"})};this._detectionCornerTL=A().classed("drag-corner-tl",!0);this._detectionCornerTR=A().classed("drag-corner-tr",!0);this._detectionCornerBL=A().classed("drag-corner-bl",!0);this._detectionCornerBR=A().classed("drag-corner-br",!0)}};q.prototype._getResizingEdges=function(u){var x={top:!1,bottom:!1,left:!1,right:!1};if(!this.resizable())return x;var A=this.bounds(),y=A.topLeft.y,w=A.bottomRight.y,C=A.topLeft.x;A=A.bottomRight.x;var G=this._detectionRadius;
C-G<=u.x&&u.x<=A+G&&(x.top=y-G<=u.y&&u.y<=y+G,x.bottom=w-G<=u.y&&u.y<=w+G);y-G<=u.y&&u.y<=w+G&&(x.left=C-G<=u.x&&u.x<=C+G,x.right=A-G<=u.x&&u.x<=A+G);return x};q.prototype.renderImmediately=function(){n.prototype.renderImmediately.call(this);if(this.boxVisible()){var u=this.bounds(),x=u.topLeft.y,A=u.bottomRight.y,y=u.topLeft.x;u=u.bottomRight.x;this._detectionEdgeT.attrs({x1:y,y1:x,x2:u,y2:x,"stroke-width":2*this._detectionRadius});this._detectionEdgeB.attrs({x1:y,y1:A,x2:u,y2:A,"stroke-width":2*
this._detectionRadius});this._detectionEdgeL.attrs({x1:y,y1:x,x2:y,y2:A,"stroke-width":2*this._detectionRadius});this._detectionEdgeR.attrs({x1:u,y1:x,x2:u,y2:A,"stroke-width":2*this._detectionRadius});this._hasCorners&&(this._detectionCornerTL.attrs({cx:y,cy:x,r:this._detectionRadius}),this._detectionCornerTR.attrs({cx:u,cy:x,r:this._detectionRadius}),this._detectionCornerBL.attrs({cx:y,cy:A,r:this._detectionRadius}),this._detectionCornerBR.attrs({cx:u,cy:A,r:this._detectionRadius}))}return this};
q.prototype.detectionRadius=function(){return this._detectionRadius};q.prototype.resizable=function(u){if(null==u)return this._resizable;this._resizable=u;this._setResizableClasses(u);return this};q.prototype._setResizableClasses=function(u){u&&this.enabled()?(this.addClass("x-resizable"),this.addClass("y-resizable")):(this.removeClass("x-resizable"),this.removeClass("y-resizable"))};q.prototype.movable=function(){return this._movable};q.prototype._setMovableClass=function(){this.movable()&&this.enabled()?
this.addClass("movable"):this.removeClass("movable")};q.prototype.onDragStart=function(u){this._dragStartCallbacks.add(u)};q.prototype.offDragStart=function(u){this._dragStartCallbacks.delete(u)};q.prototype.onDrag=function(u){this._dragCallbacks.add(u);return this};q.prototype.offDrag=function(u){this._dragCallbacks.delete(u)};q.prototype.onDragEnd=function(u){this._dragEndCallbacks.add(u)};q.prototype.offDragEnd=function(u){this._dragEndCallbacks.delete(u)};q.prototype.dragInteraction=function(){return this._dragInteraction};
q.prototype.enabled=function(u){if(null==u)return this._dragInteraction.enabled();this._dragInteraction.enabled(u);this._setResizableClasses(this.resizable());this._setMovableClass();return this};q.prototype.destroy=function(){var u=this;n.prototype.destroy.call(this);this._dragStartCallbacks.forEach(function(x){return u._dragCallbacks.delete(x)});this._dragCallbacks.forEach(function(x){return u._dragCallbacks.delete(x)});this._dragEndCallbacks.forEach(function(x){return u._dragEndCallbacks.delete(x)});
this._disconnectInteraction()};q.prototype.detach=function(){this._resetState();this._dragInteraction.detach();n.prototype.detach.call(this);return this};q.prototype.anchor=function(u){u=p.coerceExternalD3(u);this._dragInteraction.attachTo(this);n.prototype.anchor.call(this,u);return this};q.prototype._resetState=function(){this.bounds({topLeft:{x:0,y:0},bottomRight:{x:0,y:0}})};return q}(h(43).SelectionBoxLayer);f.DragBoxLayer=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=
p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(18);d=function(p){function m(){return p.call(this,"path","line")||this}k(m,p);m.prototype._applyDefaultAttributes=function(n){n.style("fill","none")};m.prototype.getVisualPrimitiveAtIndex=function(){return p.prototype.getVisualPrimitiveAtIndex.call(this,0)};return m}(h(9).SVGDrawer);f.LineSVGDrawer=d;var l=["opacity","stroke-opacity","stroke-width","stroke"];f.makeLineCanvasDrawStep=
function(p){return function(m,n,q){q=t.resolveAttributes(q,l,n[0],0);t.renderLine(m,p(),n[0],q)}}},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(18);d=function(p){function m(n){void 0===n&&(n="");var q=p.call(this,"rect","")||this;q._rootClassName=n;q._root.classed(q._rootClassName,!0);return q}k(m,p);return m}(h(9).SVGDrawer);f.RectangleSVGDrawer=
d;var l=["x","y","width","height"];f.RectangleCanvasDrawStep=function(p,m,n){p.save();m.forEach(function(q,u){null!=q&&(q=t.resolveAttributesSubsetWithStyles(n,l,q,u),p.beginPath(),p.rect(q.x,q.y,q.width,q.height),t.renderPathWithStyle(p,q))});p.restore()};d=function(p){function m(n){return p.call(this,n,f.RectangleCanvasDrawStep)||this}k(m,p);return m}(t.CanvasDrawer);f.RectangleCanvasDrawer=d},function(d,f,h){function k(p){l.SHOW_WARNINGS&&console.warn(p)}function t(p,m){for(var n=[],q=2;q<arguments.length;q++)n[q-
2]=arguments[q];return 0===m?(p(n),-1):window.setTimeout(p,m,n)}var l=h(23);f.warn=k;f.setTimeout=t;f.debounce=function(p,m,n){function q(){m.apply(n,x)}var u=null,x=[];return function(){x=Array.prototype.slice.call(arguments);clearTimeout(u);u=t(q,p)}};f.deprecated=function(p,m,n){void 0===n&&(n="");k("Method "+p+" has been deprecated in version "+m+". Please refer to the release notes. "+n)}},function(d,f){d=function(){function h(k){this.ruler=null!=k.createRuler?k.createRuler():k}h.prototype.measure=
function(k){void 0===k&&(k=h.HEIGHT_TEXT);return this.ruler(k)};return h}();d.HEIGHT_TEXT="bdpql";f.AbstractMeasurer=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(32));k(h(74));k(h(75));k(h(41));k(h(42));k(h(76));k(h(77));k(h(78));k(h(79));k(h(43));k(h(80));k(h(81));k(h(82))},function(d,f,h){var k=h(0);d=function(){function t(l,p){void 0===l&&(l=[]);void 0===p&&(p={});this._updateId=0;this._data=l;this._metadata=p;this._callbacks=new k.CallbackSet}t.prototype.onUpdate=
function(l){this._callbacks.add(l);return this};t.prototype.offUpdate=function(l){this._callbacks.delete(l);return this};t.prototype.data=function(l){if(null==l)return this._data;this._data=l;this._dispatchUpdate();return this};t.prototype.metadata=function(l){if(null==l)return this._metadata;this._metadata=l;this._dispatchUpdate();return this};t.prototype.updateId=function(){return this._updateId};t.prototype._dispatchUpdate=function(){this._updateId++;this._callbacks.callCallbacks(this)};return t}();
f.Dataset=d},function(d,f,h){var k=h(0),t=h(30);d=function(){function l(){}l.prototype.render=function(){t.flush()};return l}();f.Immediate=d;d=function(){function l(){}l.prototype.render=function(){k.DOM.requestAnimationFramePolyfill(t.flush)};return l}();f.AnimationFrame=d;d=function(){function l(){this._timeoutMsec=k.DOM.SCREEN_REFRESH_RATE_MILLISECONDS}l.prototype.render=function(){setTimeout(t.flush,this._timeoutMsec)};return l}();f.Timeout=d},function(d,f,h){var k=this&&this.__extends||function(p,
m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(13),l=h(0);d=function(p){function m(){var n=null!==p&&p.apply(this,arguments)||this;n._keyPressCallbacks={};n._keyReleaseCallbacks={};n._mouseMoveCallback=function(){return!1};n._downedKeys=new l.Set;n._keyDownCallback=function(q,u){return n._handleKeyDownEvent(q,u)};n._keyUpCallback=function(q){return n._handleKeyUpEvent(q)};return n}k(m,p);
m.prototype._anchor=function(n){p.prototype._anchor.call(this,n);this._positionDispatcher=t.Mouse.getDispatcher(this._componentAttachedTo);this._positionDispatcher.onMouseMove(this._mouseMoveCallback);this._keyDispatcher=t.Key.getDispatcher();this._keyDispatcher.onKeyDown(this._keyDownCallback);this._keyDispatcher.onKeyUp(this._keyUpCallback)};m.prototype._unanchor=function(){p.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};m.prototype._handleKeyDownEvent=function(n,q){var u=this._translateToComponentSpace(this._positionDispatcher.lastMousePosition());this._isInsideComponent(u)&&!q.repeat&&(this._keyPressCallbacks[n]&&this._keyPressCallbacks[n].callCallbacks(n),this._downedKeys.add(n))};m.prototype._handleKeyUpEvent=function(n){this._downedKeys.has(n)&&this._keyReleaseCallbacks[n]&&this._keyReleaseCallbacks[n].callCallbacks(n);
this._downedKeys.delete(n)};m.prototype.onKeyPress=function(n,q){this._keyPressCallbacks[n]||(this._keyPressCallbacks[n]=new l.CallbackSet);this._keyPressCallbacks[n].add(q);return this};m.prototype.offKeyPress=function(n,q){this._keyPressCallbacks[n].delete(q);0===this._keyPressCallbacks[n].size&&delete this._keyPressCallbacks[n];return this};m.prototype.onKeyRelease=function(n,q){this._keyReleaseCallbacks[n]||(this._keyReleaseCallbacks[n]=new l.CallbackSet);this._keyReleaseCallbacks[n].add(q);return this};
m.prototype.offKeyRelease=function(n,q){this._keyReleaseCallbacks[n].delete(q);0===this._keyReleaseCallbacks[n].size&&delete this._keyReleaseCallbacks[n];return this};return m}(h(15).Interaction);f.Key=d},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(0);d=function(l){function p(m){void 0===m&&(m=[]);var n=l.call(this)||this;n._components=
[];n.addClass("component-group");m.forEach(function(q){return n.append(q)});return n}k(p,l);p.prototype._forEach=function(m){this.components().forEach(m)};p.prototype.has=function(m){return 0<=this._components.indexOf(m)};p.prototype.requestedSpace=function(m,n){var q=this._components.map(function(u){return u.requestedSpace(m,n)});return{minWidth:t.Math.max(q,function(u){return u.minWidth},0),minHeight:t.Math.max(q,function(u){return u.minHeight},0)}};p.prototype.computeLayout=function(m,n,q){var u=
this;l.prototype.computeLayout.call(this,m,n,q);this._forEach(function(x){x.computeLayout({x:0,y:0},u.width(),u.height())});return this};p.prototype._sizeFromOffer=function(m,n){return{width:m,height:n}};p.prototype.fixedWidth=function(){return this._components.every(function(m){return m.fixedWidth()})};p.prototype.fixedHeight=function(){return this._components.every(function(m){return m.fixedHeight()})};p.prototype.components=function(){return this._components.slice()};p.prototype.append=function(m){null==
m||this.has(m)||(m.detach(),this._components.push(m),this._adoptAndAnchor(m),this.redraw());return this};p.prototype._remove=function(m){m=this._components.indexOf(m);0<=m&&this._components.splice(m,1)};return p}(h(29).ComponentContainer);f.Group=d},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)};h(0);d=h(4);var t;(function(l){l[l.VALUE=0]=
"VALUE";l[l.PIXEL=1]="PIXEL"})(t||(t={}));d=function(l){function p(m){var n=l.call(this)||this;n._mode=t.VALUE;if(m!==p.ORIENTATION_VERTICAL&&m!==p.ORIENTATION_HORIZONTAL)throw Error(m+" is not a valid orientation for GuideLineLayer");n._orientation=m;n._overflowHidden=!0;n.addClass("guide-line-layer");n._isVertical()?n.addClass("vertical"):n.addClass("horizontal");n._scaleUpdateCallback=function(){n._syncPixelPositionAndValue();n.render()};return n}k(p,l);p.prototype._setup=function(){l.prototype._setup.call(this);
this._guideLine=this.content().append("line").classed("guide-line",!0)};p.prototype._sizeFromOffer=function(m,n){return{width:m,height:n}};p.prototype._isVertical=function(){return this._orientation===p.ORIENTATION_VERTICAL};p.prototype.fixedWidth=function(){return!0};p.prototype.fixedHeight=function(){return!0};p.prototype.computeLayout=function(m,n,q){l.prototype.computeLayout.call(this,m,n,q);null!=this.scale()&&(this._isVertical()?this.scale().range([0,this.width()]):this.scale().range([this.height(),
0]));return this};p.prototype.renderImmediately=function(){l.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()});return this};p.prototype._syncPixelPositionAndValue=function(){null!=this.scale()&&(this._mode===t.VALUE&&null!=this.value()?this._pixelPosition=
this.scale().scale(this.value()):this._mode===t.PIXEL&&null!=this.pixelPosition()&&(this._value=this.scale().invert(this.pixelPosition())))};p.prototype._setPixelPositionWithoutChangingMode=function(m){this._pixelPosition=m;null!=this.scale()&&(this._value=this.scale().invert(this.pixelPosition()));this.render()};p.prototype.scale=function(m){if(null==m)return this._scale;var n=this._scale;null!=n&&n.offUpdate(this._scaleUpdateCallback);this._scale=m;this._scale.onUpdate(this._scaleUpdateCallback);
this._syncPixelPositionAndValue();this.redraw();return this};p.prototype.value=function(m){if(null==m)return this._value;this._value=m;this._mode=t.VALUE;this._syncPixelPositionAndValue();this.render();return this};p.prototype.pixelPosition=function(){return this._pixelPosition};p.prototype.destroy=function(){l.prototype.destroy.call(this);null!=this.scale()&&this.scale().offUpdate(this._scaleUpdateCallback)};return p}(d.Component);d.ORIENTATION_VERTICAL="vertical";d.ORIENTATION_HORIZONTAL="horizontal";
f.GuideLineLayer=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(0);d=h(4);var l;(function(p){p[p.VALUE=0]="VALUE";p[p.PIXEL=1]="PIXEL"})(l=f.PropertyMode||(f.PropertyMode={}));d=function(p){function m(){var n=p.call(this)||this;n._boxVisible=!1;n._boxBounds={topLeft:{x:0,y:0},bottomRight:{x:0,y:0}};n._xBoundsMode=l.PIXEL;n._yBoundsMode=
l.PIXEL;n.addClass("selection-box-layer");n._adjustBoundsCallback=function(){n.render()};n._overflowHidden=!0;n._xExtent=[void 0,void 0];n._yExtent=[void 0,void 0];return n}k(m,p);m.prototype._setup=function(){p.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)};m.prototype._sizeFromOffer=function(n,q){return{width:n,height:q}};m.prototype.bounds=function(n){if(null==n)return this._getBounds();
this._setBounds(n);this._yBoundsMode=this._xBoundsMode=l.PIXEL;this.render();return this};m.prototype._setBounds=function(n){this._boxBounds={topLeft:{x:Math.min(n.topLeft.x,n.bottomRight.x),y:Math.min(n.topLeft.y,n.bottomRight.y)},bottomRight:{x:Math.max(n.topLeft.x,n.bottomRight.x),y:Math.max(n.topLeft.y,n.bottomRight.y)}}};m.prototype._getBounds=function(){return{topLeft:{x:this._xBoundsMode===l.PIXEL?this._boxBounds.topLeft.x:null==this._xScale?0:Math.min(this.xScale().scale(this.xExtent()[0]),
this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===l.PIXEL?this._boxBounds.topLeft.y:null==this._yScale?0:Math.min(this.yScale().scale(this.yExtent()[0]),this.yScale().scale(this.yExtent()[1]))},bottomRight:{x:this._xBoundsMode===l.PIXEL?this._boxBounds.bottomRight.x:null==this._xScale?0:Math.max(this.xScale().scale(this.xExtent()[0]),this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===l.PIXEL?this._boxBounds.bottomRight.y:null==this._yScale?0:Math.max(this.yScale().scale(this.yExtent()[0]),
this.yScale().scale(this.yExtent()[1]))}}};m.prototype.renderImmediately=function(){p.prototype.renderImmediately.call(this);if(this._boxVisible){var n=this.bounds(),q=n.topLeft.y,u=n.bottomRight.y,x=n.topLeft.x;n=n.bottomRight.x;if(!(t.Math.isValidNumber(q)&&t.Math.isValidNumber(u)&&t.Math.isValidNumber(x)&&t.Math.isValidNumber(n)))throw Error("bounds have not been properly set");this._boxArea.attrs({x,y:q,width:n-x,height:u-q});this.content().node().appendChild(this._box.node())}else this._box.remove();
return this};m.prototype.boxVisible=function(n){if(null==n)return this._boxVisible;this._boxVisible=n;this.render();return this};m.prototype.fixedWidth=function(){return!0};m.prototype.fixedHeight=function(){return!0};m.prototype.xScale=function(n){if(null==n)return this._xScale;null!=this._xScale&&this._xScale.offUpdate(this._adjustBoundsCallback);this._xScale=n;this._xBoundsMode=l.VALUE;this._xScale.onUpdate(this._adjustBoundsCallback);this.render();return this};m.prototype.yScale=function(n){if(null==
n)return this._yScale;null!=this._yScale&&this._yScale.offUpdate(this._adjustBoundsCallback);this._yScale=n;this._yBoundsMode=l.VALUE;this._yScale.onUpdate(this._adjustBoundsCallback);this.render();return this};m.prototype.xExtent=function(){return this._getXExtent()};m.prototype._getXExtent=function(){return this._xBoundsMode===l.VALUE?this._xExtent:null==this._xScale?[void 0,void 0]:[this._xScale.invert(this._boxBounds.topLeft.x),this._xScale.invert(this._boxBounds.bottomRight.x)]};m.prototype._setXExtent=
function(n){this._xExtent=n};m.prototype.yExtent=function(){return this._getYExtent()};m.prototype._getYExtent=function(){return this._yBoundsMode===l.VALUE?this._yExtent:null==this._yScale?[void 0,void 0]:[this._yScale.invert(this._boxBounds.topLeft.y),this._yScale.invert(this._boxBounds.bottomRight.y)]};m.prototype._setYExtent=function(n){this._yExtent=n};m.prototype.destroy=function(){p.prototype.destroy.call(this);null!=this._xScale&&this.xScale().offUpdate(this._adjustBoundsCallback);null!=this._yScale&&
this.yScale().offUpdate(this._adjustBoundsCallback)};return m}(d.Component);f.SelectionBoxLayer=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){return t.call(this,"path","arc fill")||this}k(l,t);l.prototype._applyDefaultAttributes=function(p){p.style("stroke","none")};return l}(h(9).SVGDrawer);f.ArcSVGDrawer=
d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){return t.call(this,"path","arc outline")||this}k(l,t);l.prototype._applyDefaultAttributes=function(p){p.style("fill","none")};return l}(h(9).SVGDrawer);f.ArcOutlineSVGDrawer=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=
p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(18);d=function(p){function m(){return p.call(this,"path","area")||this}k(m,p);m.prototype._applyDefaultAttributes=function(n){n.style("stroke","none")};m.prototype.getVisualPrimitiveAtIndex=function(){return p.prototype.getVisualPrimitiveAtIndex.call(this,0)};return m}(h(9).SVGDrawer);f.AreaSVGDrawer=d;var l=["fill","opacity","fill-opacity"];f.makeAreaCanvasDrawStep=function(p){return function(m,
n,q){q=t.resolveAttributes(q,l,n[0],0);t.renderArea(m,p(),n[0],q)}}},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){return t.call(this,"line","")||this}k(l,t);return l}(h(9).SVGDrawer);f.SegmentSVGDrawer=d},function(d,f,h){function k(n,q,u,x,A){return 0<=u+A&&u-A<=n&&0<=x+A&&x-A<=q}function t(n,q,u){if(null==n)return!1;
for(var x=0;x<u.length;x++){var A=u[x];if(n[A]!=q[A])return!1}return!0}var l=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&(n[x]=q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},p=h(86),m=h(18);d=function(n){function q(){return n.call(this,"path","symbol")||this}l(q,n);return q}(h(9).SVGDrawer);f.SymbolSVGDrawer=d;f.makeSymbolCanvasDrawStep=function(n,q,u){var x=this;return function(A,y,w){var C=A.canvas,G=C.clientWidth;
C=C.clientHeight;for(var D=new p.CanvasBuffer(0,0),B=q(),I=u(),N=null,O=null,H=null,K=0;K<y.length;K++){var M=y[K];if(null!=M){var L=m.resolveAttributesSubsetWithStyles(w,["x","y"],M,K),Q=I(M,K,n);if(k(G,C,L.x,L.y,Q)){var T=t(N,L,m.ContextStyleAttrs);M=B(M,K,x._dataset);T&&H==Q&&O==M||(N=m.getStrokeWidth(L),N=Q+N+1,(N>D.screenWidth||N>D.screenHeight)&&D.resize(N,N,!0),D.clear(),N=D.ctx,N.beginPath(),M(Q).context(N)(null),N.closePath(),m.renderPathWithStyle(N,L),O=M,H=Q,N=L);D.blitCenter(A,L.x,L.y)}}}}}},
function(d,f,h){function k(D){return D instanceof y?D:D instanceof Date?p(D.valueOf()):D instanceof A.Scale?t(D):D instanceof x.Dataset?l(D):u(D)?n(D):Array.isArray(D)?m(D):p(D)}function t(D){D={domain:D.domain(),range:D.range(),updateId:D.updateId(),ref:p(D)};return n(D)}function l(D){D={ref:p(D),updateId:D.updateId()};return n(D)}function p(D){return new C(D)}function m(D){return new w(D.map(function(B){return k(B)}))}function n(D){var B={},I;for(I in D)D.hasOwnProperty(I)&&(B[I]=k(D[I]));return new G(B)}
var q=this&&this.__extends||function(D,B){function I(){this.constructor=D}for(var N in B)B.hasOwnProperty(N)&&(D[N]=B[N]);D.prototype=null===B?Object.create(B):(I.prototype=B.prototype,new I)},u=h(128),x=h(38),A=h(17);f.sign=k;f.signScale=t;f.signDataset=l;f.signRef=p;f.signArray=m;f.signObj=n;var y=function(){function D(){}D.prototype.isDifferent=function(B){return B instanceof this.constructor?this.isSignatureDifferent(B):!0};return D}();f.Signature=y;var w=function(D){function B(I){var N=D.call(this)||
this;N.array=I;return N}q(B,D);B.prototype.isSignatureDifferent=function(I){if(I.array.length!==this.array.length)return!0;for(var N=0;N<this.array.length;N++)if(this.array[N].isDifferent(I.array[N]))return!0;return!1};return B}(y);f.ArraySignature=w;var C=function(D){function B(I){var N=D.call(this)||this;N.ref=I;return N}q(B,D);B.prototype.isSignatureDifferent=function(I){return this.ref!==I.ref};return B}(y);f.ReferenceSignature=C;var G=function(D){function B(I){var N=D.call(this)||this;N.obj=
I;return N}q(B,D);B.prototype.isSignatureDifferent=function(I){var N=Object.keys(this.obj),O=Object.keys(I.obj);if(N.length!==O.length)return!0;for(O=0;O<N.length;O++){var H=N[O];if(!I.obj.hasOwnProperty(H)||this.obj[H].isDifferent(I.obj[H]))return!0}return!1};return B}(y);f.ObjectSignature=G},function(d,f,h){var k=this&&this.__extends||function(y,w){function C(){this.constructor=y}for(var G in w)w.hasOwnProperty(G)&&(y[G]=w[G]);y.prototype=null===w?Object.create(w):(C.prototype=w.prototype,new C)},
t=h(1),l=h(3),p=h(0),m=h(14),n=h(46),q=h(6),u=h(33),x=h(19);d=h(53);var A=h(2);h=function(y){function w(){var C=y.call(this)||this;C.addClass("area-plot");C.y0(0);C.attr("fill-opacity",.25);C.attr("fill",(new l.Color).range()[0]);C._lineDrawers=new p.Map;return C}k(w,y);w.prototype.y=function(C,G){if(null==C)return y.prototype.y.call(this);null==G?y.prototype.y.call(this,C):y.prototype.y.call(this,C,G);null!=G&&(C=this.y0().accessor,null!=C&&this._bindProperty(w._Y0_KEY,C,G),this._updateYScale());
return this};w.prototype.y0=function(C){if(null==C)return this._propertyBindings.get(w._Y0_KEY);var G=this.y();this._bindProperty(w._Y0_KEY,C,G&&G.scale);this._updateYScale();this.render();return this};w.prototype._onDatasetUpdate=function(){y.prototype._onDatasetUpdate.call(this);this._updateYScale()};w.prototype._addDataset=function(C){var G=this;this._lineDrawers.set(C,new m.ProxyDrawer(function(){return new u.LineSVGDrawer},function(D){return new m.CanvasDrawer(D,u.makeLineCanvasDrawStep(function(){var B=
A.Plot._scaledAccessor(G.x()),I=A.Plot._scaledAccessor(G.y());return G._d3LineFactory(C,B,I)}))}));y.prototype._addDataset.call(this,C);return this};w.prototype._createNodesForDataset=function(C){y.prototype._createNodesForDataset.call(this,C);C=this._lineDrawers.get(C);"svg"===this.renderer()?C.useSVG(this._renderArea):C.useCanvas(this._canvas);return C};w.prototype._removeDatasetNodes=function(C){y.prototype._removeDatasetNodes.call(this,C);this._lineDrawers.get(C).remove()};w.prototype._additionalPaint=
function(){var C=this,G=this._generateLineDrawSteps(),D=this._getDataToDraw();this.datasets().forEach(function(B){var I=A.Plot.applyDrawSteps(G,B);C._lineDrawers.get(B).draw(D.get(B),I)})};w.prototype._generateLineDrawSteps=function(){var C=[];if(this._animateOnNextRender()){var G=this._generateLineAttrToProjector();G.d=this._constructLineProjector(A.Plot._scaledAccessor(this.x()),this._getResetYFunction());C.push({attrToProjector:G,animator:this._getAnimator(x.Animator.RESET)})}C.push({attrToProjector:this._generateLineAttrToProjector(),
animator:this._getAnimator(x.Animator.MAIN)});return C};w.prototype._generateLineAttrToProjector=function(){var C=this._getAttrToProjector();C.d=this._constructLineProjector(A.Plot._scaledAccessor(this.x()),A.Plot._scaledAccessor(this.y()));return C};w.prototype._createDrawer=function(C){var G=this;return new q.ProxyDrawer(function(){return new n.AreaSVGDrawer},function(D){return new m.CanvasDrawer(D,n.makeAreaCanvasDrawStep(function(){var B=A.Plot._scaledAccessor(G.x()),I=A.Plot._scaledAccessor(G.y()),
N=A.Plot._scaledAccessor(G.y0());return G._createAreaGenerator(B,I,N,G._createDefinedProjector(B,I),C)}))})};w.prototype._generateDrawSteps=function(){var C=[];if(this._animateOnNextRender()){var G=this._getAttrToProjector();G.d=this._constructAreaProjector(A.Plot._scaledAccessor(this.x()),this._getResetYFunction(),A.Plot._scaledAccessor(this.y0()));C.push({attrToProjector:G,animator:this._getAnimator(x.Animator.RESET)})}C.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(x.Animator.MAIN)});
return C};w.prototype._updateYScale=function(){var C=this.getExtentsForProperty("y0");C=p.Array.uniq(p.Array.flatten(C));var G=1===C.length?C[0]:null;C=(C=this.y())&&C.scale;null!=C&&(null!=this._constantBaselineValueProvider&&(C.removePaddingExceptionsProvider(this._constantBaselineValueProvider),this._constantBaselineValueProvider=null),null!=G&&(this._constantBaselineValueProvider=function(){return[G]},C.addPaddingExceptionsProvider(this._constantBaselineValueProvider)))};w.prototype._getResetYFunction=
function(){return A.Plot._scaledAccessor(this.y0())};w.prototype._propertyProjectors=function(){var C=y.prototype._propertyProjectors.call(this);C.d=this._constructAreaProjector(A.Plot._scaledAccessor(this.x()),A.Plot._scaledAccessor(this.y()),A.Plot._scaledAccessor(this.y0()));return C};w.prototype.selections=function(C){var G=this;void 0===C&&(C=this.datasets());if("canvas"===this.renderer())return t.selectAll();var D=y.prototype.selections.call(this,C).nodes();C.map(function(B){return G._lineDrawers.get(B)}).filter(function(B){return null!=
B}).forEach(function(B){return D.push.apply(D,B.getVisualPrimitives())});return t.selectAll(D)};w.prototype._constructAreaProjector=function(C,G,D){var B=this,I=this._createDefinedProjector(A.Plot._scaledAccessor(this.x()),A.Plot._scaledAccessor(this.y()));return function(N,O,H){return B._createAreaGenerator(C,G,D,I,H)(N)}};w.prototype._createDefinedProjector=function(C,G){return function(D,B,I){var N=C(D,B,I);D=G(D,B,I);return p.Math.isValidNumber(N)&&p.Math.isValidNumber(D)}};w.prototype._createAreaGenerator=
function(C,G,D,B,I){var N=this._getCurveFactory();return t.area().x(function(O,H){return C(O,H,I)}).y1(function(O,H){return G(O,H,I)}).y0(function(O,H){return D(O,H,I)}).curve(N).defined(function(O,H){return B(O,H,I)})};return w}(d.Line);h._Y0_KEY="y0";f.Area=h},function(d,f){(function(h){h.MAIN="main";h.RESET="reset"})(f.Animator||(f.Animator={}))},function(d,f){var h=function(){function k(){var t=this;this.translate=this.scale=0;this.cachedDomain=[null,null];this.lastSeenDomain=[null,null];this.updateDomain=
function(l){t.lastSeenDomain=l.getTransformationDomain();var p=l.scaleTransformation(t.cachedDomain[1])-l.scaleTransformation(t.cachedDomain[0]),m=l.scaleTransformation(t.lastSeenDomain[1])-l.scaleTransformation(t.lastSeenDomain[0]);t.scale=p/m||1;t.translate=l.scaleTransformation(t.cachedDomain[0])-l.scaleTransformation(t.lastSeenDomain[0])*t.scale||0}}k.prototype.reset=function(){this.scale=1;this.translate=0;this.cachedDomain=this.lastSeenDomain};k.prototype.setDomain=function(t){this.cachedDomain=
t.getTransformationDomain()};return k}();d=function(){function k(t,l){var p=this;this.renderCallback=t;this.applyTransformCallback=l;this.domainTransformX=new h;this.domainTransformY=new h;this.renderDeferred=function(){p.applyTransform();clearTimeout(p.timeoutToken);p.timeoutToken=setTimeout(function(){p.renderCallback()},k.DEFERRED_RENDERING_DELAY)}}k.prototype.setDomains=function(t,l){t&&this.domainTransformX.setDomain(t);l&&this.domainTransformY.setDomain(l);this.renderDeferred()};k.prototype.updateDomains=
function(t,l){t&&this.domainTransformX.updateDomain(t);l&&this.domainTransformY.updateDomain(l);this.renderDeferred()};k.prototype.resetTransforms=function(){this.domainTransformX.reset();this.domainTransformY.reset();this.applyTransform()};k.prototype.applyTransform=function(){this.applyTransformCallback(this.domainTransformX.translate,this.domainTransformY.translate,this.domainTransformX.scale,this.domainTransformY.scale)};return k}();d.DEFERRED_RENDERING_DELAY=200;f.DeferredRenderer=d},function(d,
f,h){var k=this&&this.__extends||function(C,G){function D(){this.constructor=C}for(var B in G)G.hasOwnProperty(B)&&(C[B]=G[B]);C.prototype=null===G?Object.create(G):(D.prototype=G.prototype,new D)},t=h(1),l=h(7),p=h(14),m=h(6),n=h(33),q=h(3),u=h(11),x=h(0);d=h(10);var A=h(19),y=h(2);h=h(16);var w={linear:t.curveLinear,linearClosed:t.curveLinearClosed,step:t.curveStep,stepBefore:t.curveStepBefore,stepAfter:t.curveStepAfter,basis:t.curveBasis,basisOpen:t.curveBasisOpen,basisClosed:t.curveBasisClosed,
bundle:t.curveBundle,cardinal:t.curveCardinal,cardinalOpen:t.curveCardinalOpen,cardinalClosed:t.curveCardinalClosed,monotone:t.curveMonotoneX};f.CurveName=d.makeEnum("linear linearClosed step stepBefore stepAfter basis basisOpen basisClosed bundle cardinal cardinalOpen cardinalClosed monotone".split(" "));h=function(C){function G(){var D=C.call(this)||this;D._curve="linear";D._autorangeSmooth=!1;D._croppedRenderingEnabled=!0;D._collapseDenseVerticalLinesEnabled=!1;D._downsamplingEnabled=!1;D.addClass("line-plot");
var B=new l.Easing;B.stepDuration(y.Plot._ANIMATION_MAX_DURATION);B.easingMode("expInOut");B.maxTotalDuration(y.Plot._ANIMATION_MAX_DURATION);D.animator(A.Animator.MAIN,B);D.attr("stroke",(new q.Color).range()[0]);D.attr("stroke-width","2px");return D}k(G,C);G.prototype.x=function(D,B,I){if(null==D)return C.prototype.x.call(this);C.prototype.x.call(this,D,B,I);this._setScaleSnapping();return this};G.prototype.y=function(D,B,I){if(null==D)return C.prototype.y.call(this);C.prototype.y.call(this,D,B,
I);this._setScaleSnapping();return this};G.prototype.autorangeMode=function(D){if(null==D)return C.prototype.autorangeMode.call(this);C.prototype.autorangeMode.call(this,D);this._setScaleSnapping();return this};G.prototype.autorangeSmooth=function(){return this._autorangeSmooth};G.prototype._setScaleSnapping=function(){"x"===this.autorangeMode()&&this.x()&&this.x().scale&&this.x().scale instanceof u.QuantitativeScale&&this.x().scale.snappingDomainEnabled(!this.autorangeSmooth());"y"===this.autorangeMode()&&
this.y()&&this.y().scale&&this.y().scale instanceof u.QuantitativeScale&&this.y().scale.snappingDomainEnabled(!this.autorangeSmooth())};G.prototype.curve=function(D){if(null==D)return this._curve;this._curve=D;this.render();return this};G.prototype.downsamplingEnabled=function(){return this._downsamplingEnabled};G.prototype.croppedRenderingEnabled=function(D){if(null==D)return this._croppedRenderingEnabled;this._croppedRenderingEnabled=D;this.render();return this};G.prototype.collapseDenseLinesEnabled=
function(D){if(null==D)return this._collapseDenseVerticalLinesEnabled;this._collapseDenseVerticalLinesEnabled=D;this.render();return this};G.prototype._createDrawer=function(D){var B=this;return new m.ProxyDrawer(function(){return new n.LineSVGDrawer},function(I){return new p.CanvasDrawer(I,n.makeLineCanvasDrawStep(function(){return B._d3LineFactory(D)}))})};G.prototype.getExtentsForProperty=function(D){var B=C.prototype.getExtentsForProperty.call(this,D);if(!this._autorangeSmooth||this.autorangeMode()!==
D||"x"!==this.autorangeMode()&&"y"!==this.autorangeMode())return B;D=this._getEdgeIntersectionPoints();var I="y"===this.autorangeMode()?D.left.concat(D.right).map(function(N){return N.y}):D.top.concat(D.bottom).map(function(N){return N.x});return B.map(function(N){return t.extent(t.merge([N,I]))})};G.prototype._getEdgeIntersectionPoints=function(){var D=this;if(!(this.y().scale instanceof u.QuantitativeScale&&this.x().scale instanceof u.QuantitativeScale))return{left:[],right:[],top:[],bottom:[]};
var B=this.y().scale,I=this.x().scale,N={left:[],right:[],top:[],bottom:[]},O=I.scale(I.domain()[0]),H=I.scale(I.domain()[1]),K=B.scale(B.domain()[0]),M=B.scale(B.domain()[1]);this.datasets().forEach(function(L){for(var Q=L.data(),T,X,aa,la,Z,ba,ea,ca=1;ca<Q.length;ca++)la=ba||I.scale(D.x().accessor(Q[ca-1],ca-1,L)),Z=ea||B.scale(D.y().accessor(Q[ca-1],ca-1,L)),ba=I.scale(D.x().accessor(Q[ca],ca,L)),ea=B.scale(D.y().accessor(Q[ca],ca,L)),la<O===O<=ba&&(T=O-la,X=ba-la,aa=ea-Z,T=T*aa/X,N.left.push({x:O,
y:B.invert(Z+T)})),la<H===H<=ba&&(T=H-la,X=ba-la,aa=ea-Z,T=T*aa/X,N.right.push({x:H,y:B.invert(Z+T)})),Z<M===M<=ea&&(X=ba-la,T=M-Z,aa=ea-Z,T=T*X/aa,N.top.push({x:I.invert(la+T),y:M})),Z<K===K<=ea&&(X=ba-la,T=K-Z,aa=ea-Z,T=T*X/aa,N.bottom.push({x:I.invert(la+T),y:K}))});return N};G.prototype._getResetYFunction=function(){var D=this.y().scale.domain(),B=Math.max(D[0],D[1]);D=Math.min(D[0],D[1]);B=0>B&&B||0<D&&D||0;var I=this.y().scale.scale(B);return function(){return I}};G.prototype._generateDrawSteps=
function(){var D=[];if(this._animateOnNextRender()){var B=this._getAttrToProjector();B.d=this._constructLineProjector(y.Plot._scaledAccessor(this.x()),this._getResetYFunction());D.push({attrToProjector:B,animator:this._getAnimator(A.Animator.RESET)})}D.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(A.Animator.MAIN)});return D};G.prototype._generateAttrToProjector=function(){var D=C.prototype._generateAttrToProjector.call(this);Object.keys(D).forEach(function(B){if("d"!==
B){var I=D[B];D[B]=function(N,O,H){return 0<N.length?I(N[0],O,H):null}}});return D};G.prototype.entitiesAt=function(D){D=this.entityNearestByXThenY(D);return null!=D?[D]:[]};G.prototype.entityNearestByXThenY=function(D){var B=Infinity,I=Infinity,N,O=this.bounds();this.entities().forEach(function(H){if(x.Math.within(H.position,O)){var K=Math.abs(D.x-H.position.x),M=Math.abs(D.y-H.position.y);if(K<B||K===B&&M<I)N=H,B=K,I=M}});return N};G.prototype._propertyProjectors=function(){var D=C.prototype._propertyProjectors.call(this);
D.d=this._constructLineProjector(y.Plot._scaledAccessor(this.x()),y.Plot._scaledAccessor(this.y()));return D};G.prototype._constructLineProjector=function(D,B){var I=this;return function(N,O,H){return I._d3LineFactory(H,D,B)(N)}};G.prototype._d3LineFactory=function(D,B,I){function N(O,H,K){var M=B(O,H,K);O=I(O,H,K);return x.Math.isValidNumber(M)&&x.Math.isValidNumber(O)}void 0===B&&(B=y.Plot._scaledAccessor(this.x()));void 0===I&&(I=y.Plot._scaledAccessor(this.y()));return t.line().x(function(O,H){return B(O,
H,D)}).y(function(O,H){return I(O,H,D)}).curve(this._getCurveFactory()).defined(function(O,H){return N(O,H,D)})};G.prototype._getCurveFactory=function(){var D=this.curve();return"string"===typeof D?(D=w[D],null==D?w.linear:D):D};G.prototype._getDataToDraw=function(){var D=this,B=new x.Map;this.datasets().forEach(function(I){var N=I.data();if(D._croppedRenderingEnabled||D._downsamplingEnabled){var O=N.map(function(H,K){return K});D._croppedRenderingEnabled&&(O=D._filterCroppedRendering(I,O));D._downsamplingEnabled&&
(O=D._filterDownsampling(I,O));D._collapseDenseVerticalLinesEnabled&&(O=D._filterDenseLines(I,O));B.set(I,[O.map(function(H){return N[H]})])}else B.set(I,[N])});return B};G.prototype._filterCroppedRendering=function(D,B){function I(aa,la){return x.Math.inRange(aa,0,N.width())&&x.Math.inRange(la,0,N.height())}for(var N=this,O=y.Plot._scaledAccessor(this.x()),H=y.Plot._scaledAccessor(this.y()),K=D.data(),M=[],L=0;L<B.length;L++){var Q=O(K[B[L]],B[L],D),T=H(K[B[L]],B[L],D);Q=I(Q,T);if(!Q&&null!=B[L-
1]&&null!=K[B[L-1]]){T=O(K[B[L-1]],B[L-1],D);var X=H(K[B[L-1]],B[L-1],D);Q=Q||I(T,X)}Q||null==B[L+1]||null==K[B[L+1]]||(T=O(K[B[L+1]],B[L+1],D),X=H(K[B[L+1]],B[L+1],D),Q=Q||I(T,X));Q&&M.push(B[L])}return M};G.prototype._filterDownsampling=function(D,B){function I(ea,ca){var ka=O(N[B[ea]],B[ea],D),Y=H(N[B[ea]],B[ea],D),Ea=O(N[B[ea+1]],B[ea+1],D);ea=H(N[B[ea+1]],B[ea+1],D);return Infinity===ca?Math.floor(ka)===Math.floor(Ea):Math.floor(ea)===Math.floor(Y+(Ea-ka)*ca)}if(0===B.length)return[];for(var N=
D.data(),O=y.Plot._scaledAccessor(this.x()),H=y.Plot._scaledAccessor(this.y()),K=[B[0]],M=0;M<B.length-1;){var L=B[M],Q=O(N[B[M]],B[M],D),T=H(N[B[M]],B[M],D),X=O(N[B[M+1]],B[M+1],D),aa=H(N[B[M+1]],B[M+1],D);aa=Math.floor(Q)===Math.floor(X)?Infinity:(aa-T)/(X-Q);X=B[M];T=Infinity===aa?T:Q;Q=X;for(var la=T,Z=!0;M<B.length-1&&(Z||I(M,aa));){M++;Z=!1;var ba=Infinity===aa?H(N[B[M]],B[M],D):O(N[B[M]],B[M],D);ba>la&&(la=ba,Q=B[M]);ba<T&&(T=ba,X=B[M])}aa=B[M];X!==L&&K.push(X);Q!==X&&Q!==L&&K.push(Q);aa!==
L&&aa!==X&&aa!==Q&&K.push(aa)}return K};G.prototype._filterDenseLines=function(D,B){if(0===B.length)return[];var I=D.data(),N=y.Plot._scaledAccessor(this.x()),O=y.Plot._scaledAccessor(this.y());return this._bucketByX(D,B,function(H){return N(I[H],H,D)},function(H){return O(I[H],H,D)})};G.prototype._bucketByX=function(D,B,I,N){var O=[];D=D.data();for(var H=null,K=0;K<=B.length;++K){var M=B[K];if(null!=D[M]){var L=Math.floor(I(M)),Q=N(M);null==H?H=new x.Bucket(M,L,Q):H.isInBucket(L)?H.addToBucket(Q,
M):(O.push.apply(O,H.getUniqueIndices()),H=new x.Bucket(M,L,Q))}}null!=H&&O.push.apply(O,H.getUniqueIndices());return O};return G}(h.XYPlot);f.Line=h},function(d,f,h){var k=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&(n[x]=q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},t=h(1),l=h(26),p=h(0),m=[0,1];d=function(n){function q(){var u=n.call(this)||this;u._range=[0,1];u._d3Scale=t.scaleBand();u._d3Scale.range(m);
u._d3TransformationScale=t.scaleLinear();u._d3TransformationScale.domain(m);u._innerPadding=q._convertToPlottableInnerPadding();u._outerPadding=q._convertToPlottableOuterPadding();return u}k(q,n);q.prototype.cloneWithoutProviders=function(){var u=(new q).domain(this.domain()).range(this.range()).innerPadding(this.innerPadding()).outerPadding(this.outerPadding());u._d3TransformationScale.domain(this._d3TransformationScale.domain());return u};q.prototype.extentOfValues=function(u){return p.Array.uniq(u)};
q.prototype._getExtent=function(){return p.Array.uniq(this._getAllIncludedValues())};q.prototype.domain=function(u){return n.prototype.domain.call(this,u)};q.prototype.invertRange=function(){var u,x=this;void 0===u&&(u=this.range());var A=this._d3Scale.bandwidth(),y=this.invertedTransformation(u[0]),w=this.invertedTransformation(u[1]);u=this._d3Scale.domain();var C=u.map(function(G){return x._d3Scale(G)+A/2});y=t.bisect(C,y);w=t.bisect(C,w);return u.slice(y,w)};q.prototype.range=function(u){return n.prototype.range.call(this,
u)};q._convertToPlottableInnerPadding=function(){return 1/.7-1};q._convertToPlottableOuterPadding=function(){return.5/.7};q.prototype._setBands=function(){var u=1-1/(1+this.innerPadding()),x=this.outerPadding()/(1+this.innerPadding());this._d3Scale.paddingInner(u);this._d3Scale.paddingOuter(x)};q.prototype.rangeBand=function(){return this._rescaleBand(this._d3Scale.bandwidth())};q.prototype.stepWidth=function(){return this._rescaleBand(this._d3Scale.bandwidth()*(1+this.innerPadding()))};q.prototype.ticks=
function(){return this.domain()};q.prototype.innerPadding=function(u){if(null==u)return this._innerPadding;this._innerPadding=u;this.range(this.range());this._dispatchUpdate();return this};q.prototype.outerPadding=function(u){if(null==u)return this._outerPadding;this._outerPadding=u;this.range(this.range());this._dispatchUpdate();return this};q.prototype.scale=function(u){u=this._d3Scale(u)+this._d3Scale.bandwidth()/2;return this._d3TransformationScale(u)};q.prototype.zoom=function(u,x){var A=this;
this._d3TransformationScale.domain(this._d3TransformationScale.range().map(function(y){return A._d3TransformationScale.invert(l.zoomOut(y,u,x))}));this._dispatchUpdate()};q.prototype.pan=function(u){var x=this;this._d3TransformationScale.domain(this._d3TransformationScale.range().map(function(A){return x._d3TransformationScale.invert(A+u)}));this._dispatchUpdate()};q.prototype.scaleTransformation=function(u){return this._d3TransformationScale(u)};q.prototype.invertedTransformation=function(u){return this._d3TransformationScale.invert(u)};
q.prototype.getTransformationExtent=function(){return m};q.prototype.getTransformationDomain=function(){return this._d3TransformationScale.domain()};q.prototype.setTransformationDomain=function(u){this._d3TransformationScale.domain(u);this._dispatchUpdate()};q.prototype._getDomain=function(){return this._backingScaleDomain()};q.prototype._backingScaleDomain=function(u){if(null==u)return this._d3Scale.domain();this._d3Scale.domain(u);this._setBands();return this};q.prototype._getRange=function(){return this._range};
q.prototype._setRange=function(u){this._range=u;this._d3TransformationScale.range(u);this._setBands()};q.prototype._rescaleBand=function(u){return Math.abs(this._d3TransformationScale(u)-this._d3TransformationScale(0))};return q}(h(17).Scale);f.Category=d},function(d,f,h){function k(w){try{var C=w.node().getBBox()}catch(G){C={x:0,y:0,width:0,height:0}}return C}function t(w){if("number"===typeof w)return{min:w,max:w};if(w instanceof Object&&"min"in w&&"max"in w)return w;throw Error("input '"+w+"' can't be parsed as an Range");
}function l(w,C){w=w.getPropertyValue(C);return parseFloat(w)||0}function p(w){if(null==w||"none"===w)return null;w=w.match(A);if(null==w||2>w.length)return null;w=w[1].split(y).map(function(C){return parseFloat(C)});return 6!=w.length?null:w}var m=h(1),n=Math;f.contains=function(w,C){for(;null!=C&&C!==w;)C=C.parentNode;return C===w};f.elementBBox=k;f.entityBounds=function(w){return w instanceof SVGElement?k(m.select(w)):w instanceof HTMLElement?(w=w.getBoundingClientRect(),{x:w.left,y:w.top,width:w.width,
height:w.height}):{x:0,y:0,width:0,height:0}};f.SCREEN_REFRESH_RATE_MILLISECONDS=1E3/60;f.requestAnimationFramePolyfill=function(w){null!=window.requestAnimationFrame?window.requestAnimationFrame(w):setTimeout(w,f.SCREEN_REFRESH_RATE_MILLISECONDS)};f.elementWidth=function(w){w=w instanceof m.selection?w.node():w;w=window.getComputedStyle(w);return l(w,"width")+l(w,"padding-left")+l(w,"padding-right")+l(w,"border-left-width")+l(w,"border-right-width")};f.elementHeight=function(w){w=w instanceof m.selection?
w.node():w;w=window.getComputedStyle(w);return l(w,"height")+l(w,"padding-top")+l(w,"padding-bottom")+l(w,"border-top-width")+l(w,"border-bottom-width")};var q=/translate\s*\(\s*((?:[-+]?[0-9]*\.?[0-9]+))(?:(?:(?:\s+,?\s*)|(?:,\s*))((?:[-+]?[0-9]*\.?[0-9]+)))?\s*\)/,u=/rotate\s*\(\s*((?:[-+]?[0-9]*\.?[0-9]+))\s*\)/,x=/scale\s*\(\s*((?:[-+]?[0-9]*\.?[0-9]+))(?:(?:(?:\s+,?\s*)|(?:,\s*))((?:[-+]?[0-9]*\.?[0-9]+)))?\s*\)/;f.getTranslateValues=function(w){w=q.exec(w.attr("transform"));if(null!=w){var C=
w[2];return[+w[1],+(void 0===C?0:C)]}return[0,0]};f.getRotate=function(w){w=u.exec(w.attr("transform"));return null!=w?+w[1]:0};f.getScaleValues=function(w){var C=x.exec(w.attr("transform"));return null!=C?(w=C[1],C=C[2],[+w,null==C?+w:+C]):[0,0]};f.clientRectsOverlap=function(w,C){return n.floor(w.right)<=n.ceil(C.left)||n.ceil(w.left)>=n.floor(C.right)||n.floor(w.bottom)<=n.ceil(C.top)||n.ceil(w.top)>=n.floor(C.bottom)?!1:!0};f.expandRect=function(w,C){return{left:w.left-C,top:w.top-C,right:w.right+
C,bottom:w.bottom+C,width:w.width+2*C,height:w.height+2*C}};f.clientRectInside=function(w,C){return n.floor(C.left)<=n.ceil(w.left)&&n.floor(C.top)<=n.ceil(w.top)&&n.floor(w.right)<=n.ceil(C.right)&&n.floor(w.bottom)<=n.ceil(C.bottom)};f.intersectsBBox=function(w,C,G,D){void 0===D&&(D=.5);w=t(w);C=t(C);return G.x+G.width>=w.min-D&&G.x<=w.max+D&&G.y+G.height>=C.min-D&&G.y<=C.max+D};f.getHtmlElementAncestors=function(w){for(var C=[];w&&w instanceof HTMLElement;)C.push(w),w=w.parentElement;return C};
f.getElementTransform=function(w){w=window.getComputedStyle(w,null);w=w.getPropertyValue("-webkit-transform")||w.getPropertyValue("-moz-transform")||w.getPropertyValue("-ms-transform")||w.getPropertyValue("-o-transform")||w.getPropertyValue("transform");return p(w)};var A=/^matrix\(([^)]+)\)$/,y=/[, ]+/},function(d,f,h){function k(u,x){return[u[0]*x[0]+u[2]*x[1],u[1]*x[0]+u[3]*x[1],u[0]*x[2]+u[2]*x[3],u[1]*x[2]+u[3]*x[3],u[0]*x[4]+u[2]*x[5]+u[4],u[1]*x[4]+u[3]*x[5]+u[5]]}function t(u,x){return[u[0],
u[1],u[2],u[3],u[0]*x[0]+u[2]*x[1]+u[4],u[1]*x[0]+u[3]*x[1]+u[5]]}function l(u){var x=u[0]*u[3]-u[1]*u[2];if(0===x)throw Error("singular matrix");x=1/x;return[x*u[3],x*-u[1],x*-u[2],x*u[0],x*(-u[3]*u[4]+u[2]*u[5]),x*(u[1]*u[4]+-u[0]*u[5])]}var p=h(1),m=h(55),n=Math,q=[1,0,0,1,0,0];f.inRange=function(u,x,A){return n.min(x,A)<=u&&u<=n.max(x,A)};f.clamp=function(u,x,A){return n.min(n.max(x,u),A)};f.max=function(u,x,A){var y="function"===typeof x?x:null;x=null==y?x:A;u=null==y?p.max(u):p.max(u,y);return void 0!==
u?u:x};f.min=function(u,x,A){var y="function"===typeof x?x:null;x=null==y?x:A;u=null==y?p.min(u):p.min(u,y);return void 0!==u?u:x};f.isNaN=function(u){return u!==u};f.isValidNumber=function(u){return"number"===typeof u&&1>u-u};f.range=function(u,x,A){void 0===A&&(A=1);if(0===A)throw Error("step cannot be 0");x=n.max(n.ceil((x-u)/A),0);for(var y=[],w=0;w<x;++w)y[w]=u+A*w;return y};f.distanceSquared=function(u,x){return n.pow(x.y-u.y,2)+n.pow(x.x-u.x,2)};f.degreesToRadians=function(u){return u/360*
n.PI*2};f.within=function(u,x){return x.topLeft.x<=u.x&&x.bottomRight.x>=u.x&&x.topLeft.y<=u.y&&x.bottomRight.y>=u.y};f.boundsIntersects=function(u,x,A,y,w,C){return u<=0+w&&0<=u+A&&x<=0+C&&0<=x+y};f.getCumulativeTransform=function(u){u=m.getHtmlElementAncestors(u);for(var x=q,A=null,y=0;y<u.length;y++){var w=u[y],C=m.getElementTransform(w);if(null!=C){var G=w.clientWidth/2,D=w.clientHeight/2;x=t(x,[G,D]);x=k(x,l(C));x=t(x,[-G,-D])}C=w.scrollLeft;G=w.scrollTop;if(null===A||w===A)C-=w.offsetLeft+w.clientLeft,
G-=w.offsetTop+w.clientTop,A=w.offsetParent;x=t(x,[C,G])}return x};f.multiplyMatrix=k;f.premultiplyTranslate=function(u,x){return[x[0],x[1],x[2],x[3],x[4]+u[0],x[5]+u[1]]};f.multiplyTranslate=t;f.invertMatrix=l;f.applyTransform=function(u,x){return{x:u[0]*x.x+u[2]*x.y+u[4],y:u[1]*x.x+u[3]*x.y+u[5]}}},function(d,f,h){var k=new (h(114).SplitStrategyLinear);d=function(){function p(m,n){void 0===m&&(m=5);void 0===n&&(n=k);this.maxNodeChildren=m;this.splitStrategy=n;this.root=new t(!0);this.size=0}p.prototype.getRoot=
function(){return this.root};p.prototype.clear=function(){this.root=new t(!0);this.size=0};p.prototype.insert=function(m,n){for(var q=this.root;!q.leaf;)q=q.subtree(m);m=t.valueNode(m,n);q.insert(m);for(this.size+=1;q.overflow(this.maxNodeChildren);)q=q.split(this.splitStrategy),null==q.parent&&(this.root=q)};p.prototype.locate=function(m){return this.query(function(n){return n.contains(m)})};p.prototype.intersect=function(m){return this.query(function(n){return l.isBoundsOverlapBounds(n,m)})};p.prototype.intersectX=
function(m){return this.query(function(n){return l.isBoundsOverlapX(n,m)})};p.prototype.intersectY=function(m){return this.query(function(n){return l.isBoundsOverlapY(n,m)})};p.prototype.query=function(m){var n=[];if(null!=this.root.bounds&&!m(this.root.bounds))return n;for(var q=[this.root];0<q.length;)for(var u=q.shift(),x=0;x<u.entries.length;x++){var A=u.entries[x];m(A.bounds)&&(u.leaf?n.push(A.value):q.push(A))}return n};return p}();f.RTree=d;var t=function(){function p(m){this.leaf=m;this.bounds=
null;this.entries=[];this.value=this.parent=null}p.valueNode=function(m,n){var q=new p(!0);q.bounds=m;q.value=n;return q};p.prototype.overflow=function(m){return this.entries.length>m};p.prototype.insert=function(m){this.entries.push(m);m.parent=this;for(var n=this;null!=n;)n.bounds=l.unionAll([n.bounds,m.bounds]),n=n.parent};p.prototype.remove=function(m){m=this.entries.indexOf(m);if(0<=m)for(this.entries.splice(m,1),m=this;null!=m;)m.bounds=l.unionAll(m.entries.map(function(n){return n.bounds})),
m=m.parent;return this};p.prototype.subtree=function(m){for(var n=null,q=0;q<this.entries.length;q++){var u=this.entries[q],x=u.unionAreaDifference(m);if(Infinity>x||Infinity===x&&null!=n&&u.entries.length<n.entries.length)n=u}return n};p.prototype.split=function(m){null!=this.parent&&this.parent.remove(this);var n=[new p(this.leaf),new p(this.leaf)];m.split(this.entries,n);m=null!=this.parent?this.parent:new p(!1);m.insert(n[0]);m.insert(n[1]);return m};p.prototype.unionAreaDifference=function(m){return Math.abs(l.union(this.bounds,
m).area()-this.bounds.area())};p.prototype.maxDepth=function(){return this.leaf?1:1+this.entries.map(function(m){return m.maxDepth()}).reduce(function(m,n){return Math.max(m,n)})};return p}();f.RTreeNode=t;var l=function(){function p(m,n,q,u){this.xl=m;this.yl=n;this.xh=q;this.yh=u;this.width=this.xh-this.xl;this.height=this.yh-this.yl}p.xywh=function(m,n,q,u){return new p(m,n,m+q,n+u)};p.entityBounds=function(m){return new p(m.x,m.y,m.x+m.width,m.y+m.height)};p.bounds=function(m){return p.pointPair(m.topLeft,
m.bottomRight)};p.pointPair=function(m,n){return new p(Math.min(m.x,n.x),Math.min(m.y,n.y),Math.max(m.x,n.x),Math.max(m.y,n.y))};p.points=function(m){if(2>m.length)throw Error("need at least 2 points to create bounds");var n=m.map(function(q){return q.x});m=m.map(function(q){return q.y});return new p(n.reduce(function(q,u){return Math.min(q,u)}),m.reduce(function(q,u){return Math.min(q,u)}),n.reduce(function(q,u){return Math.max(q,u)}),m.reduce(function(q,u){return Math.max(q,u)}))};p.union=function(m,
n){return new p(Math.min(m.xl,n.xl),Math.min(m.yl,n.yl),Math.max(m.xh,n.xh),Math.max(m.yh,n.yh))};p.unionAll=function(m){m=m.filter(function(n){return null!=n});return 0===m.length?null:m.reduce(function(n,q){return p.union(n,q)})};p.isBoundsOverlapBounds=function(m,n){return p.isBoundsOverlapX(m,n)&&p.isBoundsOverlapY(m,n)};p.isBoundsOverlapX=function(m,n){return!(m.xh<n.xl)&&!(m.xl>n.xh)};p.isBoundsOverlapY=function(m,n){return!(m.yh<n.yl)&&!(m.yl>n.yh)};p.prototype.area=function(){null==this.areaCached&&
(this.areaCached=(this.xh-this.xl)*(this.yh-this.yl));return this.areaCached};p.prototype.contains=function(m){return this.xl<=m.x&&this.xh>=m.x&&this.yl<=m.y&&this.yh>=m.y};return p}();f.RTreeBounds=l},function(d,f){d=function(){function h(){"function"===typeof window.Set?this._es6Set=new window.Set:this._values=[];this.size=0}h.prototype.add=function(k){if(null!=this._es6Set)return this._es6Set.add(k),this.size=this._es6Set.size,this;this.has(k)||(this._values.push(k),this.size=this._values.length);
return this};h.prototype.delete=function(k){if(null!=this._es6Set)return k=this._es6Set.delete(k),this.size=this._es6Set.size,k;k=this._values.indexOf(k);return-1!==k?(this._values.splice(k,1),this.size=this._values.length,!0):!1};h.prototype.has=function(k){return null!=this._es6Set?this._es6Set.has(k):-1!==this._values.indexOf(k)};h.prototype.forEach=function(k,t){var l=this;null!=this._es6Set?this._es6Set.forEach(function(p,m){return k.call(t,p,m,l)},t):this._values.forEach(function(p){k.call(t,
p,p,l)})};return h}();f.Set=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(131));k(h(130))},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(21);d=function(l){function p(m,n){var q=l.call(this,m,n)||this;q.cache=new t.Cache(function(u){return q._measureCharacterNotFromCache(u)});return q}k(p,l);p.prototype._measureCharacterNotFromCache=
function(m){return l.prototype._measureCharacter.call(this,m)};p.prototype._measureCharacter=function(m){return this.cache.get(m)};p.prototype.reset=function(){this.cache.clear()};return p}(h(61).CharacterMeasurer);f.CacheCharacterMeasurer=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){return t.apply(this,arguments)||
this}k(l,t);l.prototype._measureCharacter=function(p){return t.prototype._measureLine.call(this,p)};l.prototype._measureLine=function(p){var m=this;p=p.split("").map(function(n){return m._measureCharacter(n)});return{height:p.reduce(function(n,q){return Math.max(n,q.height)},0),width:p.reduce(function(n,q){return n+q.width},0)}};return l}(h(63).Measurer);f.CharacterMeasurer=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(36));k(h(60));k(h(132));k(h(61));k(h(63))},
function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(36);d=function(l){function p(m,n){void 0===n&&(n=!1);m=l.call(this,m)||this;m.useGuards=n;return m}k(p,l);p.prototype._addGuards=function(m){return t.AbstractMeasurer.HEIGHT_TEXT+m+t.AbstractMeasurer.HEIGHT_TEXT};p.prototype._measureLine=function(m){var n;void 0===n&&(n=!1);n=this.useGuards||
n||/^[\t ]$/.test(m);m=l.prototype.measure.call(this,n?this._addGuards(m):m);m.width-=n?2*this.getGuardWidth():0;return m};p.prototype.measure=function(m){var n=this;void 0===m&&(m=t.AbstractMeasurer.HEIGHT_TEXT);if(""===m.trim())return{width:0,height:0};m=m.trim().split("\n").map(function(q){return n._measureLine(q)});return{height:m.reduce(function(q,u){return q+u.height},0),width:m.reduce(function(q,u){return Math.max(q,u.width)},0)}};p.prototype.getGuardWidth=function(){null==this.guardWidth&&
(this.guardWidth=l.prototype.measure.call(this).width);return this.guardWidth};return p}(t.AbstractMeasurer);f.Measurer=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(138));k(h(65))},function(d,f,h){var k=h(21);d=function(){function t(){this.maxLines(Infinity);this.textTrimming();this.allowBreakingWords();this._tokenizer=new k.Tokenizer;this._breakingCharacter="-"}t.prototype.maxLines=function(l){if(null==l)return this._maxLines;this._maxLines=l;return this};
t.prototype.textTrimming=function(){this._textTrimming="ellipsis"};t.prototype.allowBreakingWords=function(){this._allowBreakingWords=!0};t.prototype.wrap=function(l,p,m,n){var q=this;void 0===n&&(n=Infinity);var u={noBrokeWords:0,noLines:0,originalText:l,truncatedText:"",wrappedText:""};m={availableLines:Math.min(Math.floor(n/p.measure().height),this._maxLines),availableWidth:m,canFitText:!0,currentLine:"",wrapping:u};var x=l.split("\n");return x.reduce(function(A,y,w){return q.breakLineToFitWidth(A,
y,w!==x.length-1,p)},m).wrapping};t.prototype.breakLineToFitWidth=function(l,p,m,n){var q=this;l.canFitText||""===l.wrapping.truncatedText||(l.wrapping.truncatedText+="\n");l=this._tokenizer.tokenize(p).reduce(function(u,x){return q.wrapNextToken(x,u,n)},l);p=k.StringMethods.trimEnd(l.currentLine);l.wrapping.noLines+=+(""!==p);l.wrapping.noLines===l.availableLines&&"none"!==this._textTrimming&&m?l.canFitText=!1:l.wrapping.wrappedText+=p;l.currentLine="\n";return l};t.prototype.canFitToken=function(l,
p,m){var n=this,q=this._allowBreakingWords?l.split("").map(function(u,x){return x!==l.length-1?u+n._breakingCharacter:u}):[l];return m.measure(l).width<=p||q.every(function(u){return m.measure(u).width<=p})};t.prototype.addEllipsis=function(l,p,m){if("none"===this._textTrimming)return{remainingToken:"",wrappedToken:l};var n=l.substring(0).trim(),q=m.measure(n).width,u=m.measure("...").width,x=0<l.length&&"\n"===l[0]?"\n":"";if(p<=u)return{remainingToken:l,wrappedToken:x+"...".substr(0,Math.floor(p/
(u/3)))};for(;q+u>p;)n=k.StringMethods.trimEnd(n.substr(0,n.length-1)),q=m.measure(n).width;return{remainingToken:k.StringMethods.trimEnd(l.substring(n.length),"-").trim(),wrappedToken:x+n+"..."}};t.prototype.wrapNextToken=function(l,p,m){if(!p.canFitText||p.availableLines===p.wrapping.noLines||!this.canFitToken(l,p.availableWidth,m))return this.finishWrapping(l,p,m);for(;l;){var n=this.breakTokenToFitInWidth(l,p.currentLine,p.availableWidth,m);p.currentLine=n.line;l=n.remainingToken;if(null!=l)if(p.wrapping.noBrokeWords+=
+n.breakWord,++p.wrapping.noLines,p.availableLines===p.wrapping.noLines){m=this.addEllipsis(p.currentLine,p.availableWidth,m);p.wrapping.wrappedText+=m.wrappedToken;p.wrapping.truncatedText+=m.remainingToken+l;p.currentLine="\n";break}else p.wrapping.wrappedText+=k.StringMethods.trimEnd(p.currentLine),p.currentLine="\n"}return p};t.prototype.finishWrapping=function(l,p,m){p.canFitText&&p.availableLines!==p.wrapping.noLines&&this._allowBreakingWords&&"none"!==this._textTrimming?(m=this.addEllipsis(p.currentLine+
l,p.availableWidth,m),p.wrapping.wrappedText+=m.wrappedToken,p.wrapping.truncatedText+=m.remainingToken,p.wrapping.noBrokeWords+=+(m.remainingToken.length<l.length),p.wrapping.noLines+=+(0<m.wrappedToken.length),p.currentLine=""):p.wrapping.truncatedText+=l;p.canFitText=!1;return p};t.prototype.breakTokenToFitInWidth=function(l,p,m,n){if(void 0===q)var q=this._breakingCharacter;if(n.measure(p+l).width<=m)return{breakWord:!1,line:p+l,remainingToken:null};if(""===l.trim())return{breakWord:!1,line:p,
remainingToken:""};if(!this._allowBreakingWords)return{breakWord:!1,line:p,remainingToken:l};for(var u=0;u<l.length;)if(n.measure(p+l.substring(0,u+1)+q).width<=m)++u;else break;m="";0<u&&(m=q);return{breakWord:0<u,line:p+l.substring(0,u)+m,remainingToken:l.substring(u)}};return t}();f.Wrapper=d},function(d,f,h){(function(k){for(var t in k)f.hasOwnProperty(t)||(f[t]=k[t])})(h(139))},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(72));k(h(73));k(h(28))},function(d,
f){f.version="3.7.0"},function(d,f,h){function k(w,C){return w.each(function(){var G=C.apply(this,arguments),D=y.select(this),B;for(B in G)D.attr(B,G[B])})}function t(w,C){for(var G in C)w.attr(G,C[G]);return w}function l(w,C,G){return w.each(function(){var D=C.apply(this,arguments),B=y.select(this),I;for(I in D)B.style(I,D[I],G)})}function p(w,C,G){for(var D in C)w.style(D,C[D],G);return w}function m(w,C){return w.each(function(){var G=C.apply(this,arguments),D=y.select(this),B;for(B in G)D.property(B,
G[B])})}function n(w,C){for(var G in C)w.property(G,C[G]);return w}function q(w,C){return w.each(function(){var G=C.apply(this,arguments),D=y.select(this).transition(w),B;for(B in G)D.attr(B,G[B])})}function u(w,C){for(var G in C)w.attr(G,C[G]);return w}function x(w,C,G){return w.each(function(){var D=C.apply(this,arguments),B=y.select(this).transition(w),I;for(I in D)B.style(I,D[I],G)})}function A(w,C,G){for(var D in C)w.style(D,C[D],G);return w}var y=d=h(1);y.selection.prototype.attrs=function(w){return("function"===
typeof w?k:t)(this,w)};y.selection.prototype.styles=function(w){return("function"===typeof w?l:p)(this,w,"")};y.selection.prototype.properties=function(w){return("function"===typeof w?m:n)(this,w)};d.transition.prototype.attrs=function(w){return("function"===typeof w?q:u)(this,w)};d.transition.prototype.styles=function(w){return("function"===typeof w?x:A)(this,w,"")}},function(d,f,h){d=h(117);var k=h(12);h=h(10);var t={linear:d.easeLinear,quad:d.easeQuad,quadIn:d.easeQuadIn,quadOut:d.easeQuadOut,
quadInOut:d.easeQuadInOut,cubic:d.easeCubic,cubicIn:d.easeCubicIn,cubicOut:d.easeCubicOut,cubicInOut:d.easeCubicInOut,poly:d.easePoly,polyIn:d.easePolyIn,polyOut:d.easePolyOut,polyInOut:d.easePolyInOut,sin:d.easeSin,sinIn:d.easeSinIn,sinOut:d.easeSinOut,sinInOut:d.easeSinInOut,exp:d.easeExp,expIn:d.easeExpIn,expOut:d.easeExpOut,expInOut:d.easeExpInOut,circle:d.easeCircle,circleIn:d.easeCircleIn,circleOut:d.easeCircleOut,circleInOut:d.easeCircleInOut,bounce:d.easeBounce,bounceIn:d.easeBounceIn,bounceOut:d.easeBounceOut,
bounceInOut:d.easeBounceInOut,back:d.easeBack,backIn:d.easeBackIn,backOut:d.easeBackOut,backInOut:d.easeBackInOut,elastic:d.easeElastic,elasticIn:d.easeElasticIn,elasticOut:d.easeElasticOut,elasticInOut:d.easeElasticInOut};f.EaseName=h.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".split(" "));
h=function(){function l(){this._startDelay=l._DEFAULT_START_DELAY_MILLISECONDS;this._stepDuration=l._DEFAULT_STEP_DURATION_MILLISECONDS;this._stepDelay=l._DEFAULT_ITERATIVE_DELAY_MILLISECONDS;this._maxTotalDuration=l._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS;this._easingMode=l._DEFAULT_EASING_MODE}l.prototype.totalTime=function(p){var m=this._getAdjustedIterativeDelay(p);return this.startDelay()+m*Math.max(p-1,0)+this.stepDuration()};l.prototype.animate=function(p,m){var n=this;p=k.coerceExternalD3(p);
var q=p.size(),u=this._getAdjustedIterativeDelay(q);return p.transition().ease(this._getEaseFactory()).duration(this.stepDuration()).delay(function(x,A){return n.startDelay()+u*A}).attrs(m)};l.prototype.startDelay=function(p){if(null==p)return this._startDelay;this._startDelay=p;return this};l.prototype.stepDuration=function(p){if(null==p)return Math.min(this._stepDuration,this._maxTotalDuration);this._stepDuration=p;return this};l.prototype.stepDelay=function(){return this._stepDelay};l.prototype.maxTotalDuration=
function(p){if(null==p)return this._maxTotalDuration;this._maxTotalDuration=p;return this};l.prototype.easingMode=function(p){if(null==p)return this._easingMode;this._easingMode=p;return this};l.prototype._getEaseFactory=function(){var p=this.easingMode();return"string"===typeof p?(p=t[p],null==p?t.linear:p):p};l.prototype._getAdjustedIterativeDelay=function(p){var m=this.maxTotalDuration()-this.stepDuration();m=Math.max(m,0);p=m/Math.max(p-1,1);return Math.min(this.stepDelay(),p)};return l}();h._DEFAULT_START_DELAY_MILLISECONDS=
0;h._DEFAULT_STEP_DURATION_MILLISECONDS=300;h._DEFAULT_ITERATIVE_DELAY_MILLISECONDS=15;h._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS=Infinity;h._DEFAULT_EASING_MODE="expOut";f.Easing=h},function(d,f,h){var k=h(12);d=function(){function t(){}t.prototype.totalTime=function(){return 0};t.prototype.animate=function(l,p){l=k.coerceExternalD3(l);return l.attrs(p)};return t}();f.Null=d},function(d,f,h){var k=this&&this.__extends||function(q,u){function x(){this.constructor=q}for(var A in u)u.hasOwnProperty(A)&&
(q[A]=u[A]);q.prototype=null===u?Object.create(u):(x.prototype=u.prototype,new x)},t=h(1),l=h(5),p=h(4),m=h(0),n=h(22);d=function(q){function u(x,A){void 0===A&&(A="bottom");x=q.call(this,x,A)||this;x._tickLabelAngle=0;x._tickLabelShearAngle=0;x.addClass("category-axis");return x}k(u,q);Object.defineProperty(u.prototype,"_wrapper",{get:function(){var x=new l.Wrapper;null!=this._tickLabelMaxLines&&x.maxLines(this._tickLabelMaxLines);return x},enumerable:!0,configurable:!0});Object.defineProperty(u.prototype,
"_writer",{get:function(){return new l.Writer(this._measurer,this._typesetterContext,this._wrapper)},enumerable:!0,configurable:!0});u.prototype._setup=function(){q.prototype._setup.call(this);this._typesetterContext=new l.SvgContext(this._tickLabelContainer.node());this._measurer=new l.CacheMeasurer(this._typesetterContext)};u.prototype._rescale=function(){return this.redraw()};u.prototype.requestedSpace=function(x,A){var y=this.isHorizontal()?0:this._tickSpaceRequired()+this.margin(),w=this.isHorizontal()?
this._tickSpaceRequired()+this.margin():0;if(0===this._scale.domain().length)return{minWidth:0,minHeight:0};if(this.annotationsEnabled()){var C=this._annotationTierHeight()*this.annotationTierCount();this.isHorizontal()?w+=C:y+=C}x=this._measureTickLabels(x,A);return{minWidth:x.usedWidth+y,minHeight:x.usedHeight+w}};u.prototype._coreSize=function(){var x=this.isHorizontal()?this.height():this.width(),A=this.isHorizontal()?this.requestedSpace(this.width(),this.height()).minHeight:this.requestedSpace(this.width(),
this.height()).minWidth,y=this.margin()+this._annotationTierHeight();return Math.min(A-y,x)};u.prototype._getTickValues=function(){return this.getDownsampleInfo().domain};u.prototype._sizeFromOffer=function(x,A){return p.Component.prototype._sizeFromOffer.call(this,x,A)};u.prototype.getDownsampleInfo=function(x){var A;void 0===x&&(x=this._scale);void 0===A&&(A=x.invertRange());var y=Math.ceil(u._MINIMUM_WIDTH_PER_LABEL_PX*(0===this._tickLabelAngle?1:1/Math.cos(this._tickLabelShearAngle/180*Math.PI))/
x.stepWidth());return{domain:A.filter(function(w,C){return 0===C%y}),stepWidth:y*x.stepWidth()}};u.prototype.tickLabelAngle=function(){return this._tickLabelAngle;throw Error("Angle undefined not supported; only 0, 90, and -90 are valid values");};u.prototype.tickLabelShearAngle=function(){return this._tickLabelShearAngle};u.prototype.tickLabelMaxWidth=function(x){if(0===arguments.length)return this._tickLabelMaxWidth;this._tickLabelMaxWidth=x;this.redraw();return this};u.prototype.tickLabelMaxLines=
function(x){if(0===arguments.length)return this._tickLabelMaxLines;this._tickLabelMaxLines=x;this.redraw();return this};u.prototype._tickSpaceRequired=function(){return this._maxLabelTickLength()+this.tickLabelPadding()};u.prototype._drawTicks=function(x,A){var y=this;switch(this.tickLabelAngle()){case 0:var w={left:"right",right:"left",top:"center",bottom:"center"};var C={left:"center",right:"center",top:"bottom",bottom:"top"};break;case 90:w={left:"center",right:"center",top:"right",bottom:"left"};
C={left:"top",right:"bottom",top:"center",bottom:"center"};break;case -90:w={left:"center",right:"center",top:"left",bottom:"right"},C={left:"bottom",right:"top",top:"center",bottom:"center"}}A.each(function(G){var D=t.select(this),B=y.isHorizontal()?x:y.width()-y._tickSpaceRequired(),I=y.isHorizontal()?y.height()-y._tickSpaceRequired():x,N={xAlign:w[y.orientation()],yAlign:C[y.orientation()],textRotation:y.tickLabelAngle(),textShear:y.tickLabelShearAngle()};if(null!=y._tickLabelMaxWidth){if("left"===
y.orientation()&&B>y._tickLabelMaxWidth){var O=B-y._tickLabelMaxWidth;O=D.attr("transform")+" translate("+O+", 0)";D.attr("transform",O)}B=Math.min(B,y._tickLabelMaxWidth)}y._writer.write(y.formatter()(G),B,I,N,D.node())})};u.prototype._measureTickLabels=function(x,A){var y=this,w=this._scale.cloneWithoutProviders().range([0,this.isHorizontal()?x:A]),C=this.getDownsampleInfo(w);w=C.domain;C=C.stepWidth;var G=x-this._tickSpaceRequired();this.isHorizontal()&&(G=C,0!==this._tickLabelAngle&&(G=A-this._tickSpaceRequired()),
G=Math.max(G,0));var D=C;this.isHorizontal()&&(D=A-this._tickSpaceRequired(),0!==this._tickLabelAngle&&(D=x-this._tickSpaceRequired()),D=Math.max(D,0));null!=this._tickLabelMaxWidth&&(G=Math.min(G,this._tickLabelMaxWidth));A=w.map(function(B){return y._wrapper.wrap(y.formatter()(B),y._measurer,G,D)});x=this.isHorizontal()&&0===this._tickLabelAngle?t.sum:m.Math.max;w=this.isHorizontal()&&0===this._tickLabelAngle?m.Math.max:t.sum;x=x(A,function(B){return y._measurer.measure(B.wrappedText).width},0);
A=w(A,function(B){return y._measurer.measure(B.wrappedText).height},0);0!==this._tickLabelAngle&&(A=[A,x],x=A[0],A=A[1]);return{usedWidth:x,usedHeight:A}};u.prototype.renderImmediately=function(){var x=this;q.prototype.renderImmediately.call(this);var A=this._scale,y=this.getDownsampleInfo(A),w=y.domain,C=y=y.stepWidth;this.isHorizontal()&&null!=this._tickLabelMaxWidth&&(C=Math.min(C,this._tickLabelMaxWidth));w=this._tickLabelContainer.selectAll("."+n.Axis.TICK_LABEL_CLASS).data(w);var G=w.enter().append("g").classed(n.Axis.TICK_LABEL_CLASS,
!0).merge(w);w.exit().remove();G.attr("transform",function(D){var B=A.scale(D)-C/2;D=x.isHorizontal()?B:0;B=x.isHorizontal()?0:B;return"translate("+D+","+B+")"});G.text("");this._drawTicks(y,G);y="right"===this.orientation()?this._tickSpaceRequired():0;w="bottom"===this.orientation()?this._tickSpaceRequired():0;this._tickLabelContainer.attr("transform","translate("+y+","+w+")");this._showAllTickMarks();this._showAllTickLabels();this._hideTickMarksWithoutLabel();return this};u.prototype.computeLayout=
function(x,A,y){q.prototype.computeLayout.call(this,x,A,y);this.isHorizontal()||this._scale.range([0,this.height()]);return this};u.prototype.invalidateCache=function(){q.prototype.invalidateCache.call(this);this._measurer.reset()};return u}(n.Axis);d._MINIMUM_WIDTH_PER_LABEL_PX=15;f.Category=d},function(d,f,h){var k=this&&this.__extends||function(q,u){function x(){this.constructor=q}for(var A in u)u.hasOwnProperty(A)&&(q[A]=u[A]);q.prototype=null===u?Object.create(u):(x.prototype=u.prototype,new x)},
t=h(1),l=h(5),p=h(8),m=h(0),n=h(22);d=function(q){function u(x,A){x=q.call(this,x,A)||this;x._tickLabelPositioning="center";x._usesTextWidthApproximation=!1;x.formatter(p.general());return x}k(u,q);u.prototype._setup=function(){q.prototype._setup.call(this);var x=new l.SvgContext(this._tickLabelContainer.node(),n.Axis.TICK_LABEL_CLASS);this._measurer=new l.CacheMeasurer(x);this._wrapper=(new l.Wrapper).maxLines(1)};u.prototype._computeWidth=function(){var x=this._usesTextWidthApproximation?this._computeApproximateTextWidth():
this._computeExactTextWidth();return"center"===this._tickLabelPositioning?this._maxLabelTickLength()+this.tickLabelPadding()+x:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+x)};u.prototype._computeExactTextWidth=function(){var x=this,A=this._getTickValues().map(function(y){y=x.formatter()(y);return x._measurer.measure(y).width});return m.Math.max(A,0)};u.prototype._computeApproximateTextWidth=function(){var x=this,A=this._getTickValues(),y=this._measurer.measure("M").width;A=A.map(function(w){return x.formatter()(w).length*
y});return m.Math.max(A,0)};u.prototype._computeHeight=function(){var x=this._measurer.measure().height;return"center"===this._tickLabelPositioning?this._maxLabelTickLength()+this.tickLabelPadding()+x:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+x)};u.prototype._getTickValues=function(){var x=this._scale,A=x.domain(),y=A[0]<=A[1]?A[0]:A[1],w=A[0]>=A[1]?A[0]:A[1];return x.ticks().filter(function(C){return C>=y&&C<=w})};u.prototype._rescale=function(){if(this._isSetup){if(!this.isHorizontal()){var x=
this._computeWidth();if(x>this.width()||x<this.width()-this.margin()){this.redraw();return}}this.render()}};u.prototype.renderImmediately=function(){var x=this;q.prototype.renderImmediately.call(this);var A={x:0,y:0,dx:"0em",dy:"0.3em"},y=this._maxLabelTickLength(),w=this.tickLabelPadding(),C="middle",G=0,D=0,B=0,I=0;if(this.isHorizontal())switch(this._tickLabelPositioning){case "left":C="end";G=-w;I=w;break;case "center":I=y+w;break;case "right":C="start",I=G=w}else switch(this._tickLabelPositioning){case "top":A.dy=
"-0.3em";B=w;D=-w;break;case "center":B=y+w;break;case "bottom":A.dy="1em",D=B=w}y=this._generateTickMarkAttrHash();switch(this.orientation()){case "bottom":A.x=y.x1;A.dy="0.95em";D=y.y1+I;break;case "top":A.x=y.x1;A.dy="-.25em";D=y.y1-I;break;case "left":C="end";G=y.x1-B;A.y=y.y1;break;case "right":C="start",G=y.x1+B,A.y=y.y1}B=this._getTickValues();B=this._tickLabelContainer.selectAll("."+n.Axis.TICK_LABEL_CLASS).data(B);B.exit().remove();B.enter().append("text").classed(n.Axis.TICK_LABEL_CLASS,
!0).merge(B).style("text-anchor",C).style("visibility","inherit").attrs(A).text(function(N){return x.formatter()(N)});this._tickLabelContainer.attr("transform","translate("+G+", "+D+")");this._showAllTickMarks();this.showEndTickLabels()||this._hideEndTickLabels();this._hideOverflowingTickLabels();this._hideOverlappingTickLabels();"center"!==this._tickLabelPositioning&&this._hideTickMarksWithoutLabel();return this};u.prototype.tickLabelPosition=function(x){if(null==x)return this._tickLabelPositioning;
x=x.toLowerCase();if(this.isHorizontal()){if("left"!==x&&"center"!==x&&"right"!==x)throw Error(x+" is not a valid tick label position for a horizontal NumericAxis");}else if("top"!==x&&"center"!==x&&"bottom"!==x)throw Error(x+" is not a valid tick label position for a vertical NumericAxis");this._tickLabelPositioning=x;this.redraw();return this};u.prototype.usesTextWidthApproximation=function(){this._usesTextWidthApproximation=!0};u.prototype._hideEndTickLabels=function(){var x=this.element().node().getBoundingClientRect(),
A=this._tickLabelContainer.selectAll("."+n.Axis.TICK_LABEL_CLASS);if(0!==A.size()){var y=A.nodes()[0];m.DOM.clientRectInside(y.getBoundingClientRect(),x)||t.select(y).style("visibility","hidden");A=A.nodes()[A.size()-1];m.DOM.clientRectInside(A.getBoundingClientRect(),x)||t.select(A).style("visibility","hidden")}};u.prototype._hideOverlappingTickLabels=function(){for(var x=this._tickLabelContainer.selectAll("."+n.Axis.TICK_LABEL_CLASS).filter(function(){var w=t.select(this).style("visibility");return"inherit"===
w||"visible"===w}),A=x.nodes().map(function(w){return w.getBoundingClientRect()}),y=1;!this._hasOverlapWithInterval(y,A)&&y<A.length;)y+=1;x.each(function(w,C){w=t.select(this);0!==C%y&&w.style("visibility","hidden")})};u.prototype._hasOverlapWithInterval=function(x,A){var y="center"===this._tickLabelPositioning?this.tickLabelPadding():3*this.tickLabelPadding();A=A.map(function(C){return m.DOM.expandRect(C,y)});for(var w=0;w<A.length-x;w+=x)if(m.DOM.clientRectsOverlap(A[w],A[w+x]))return!1;return!0};
u.prototype.invalidateCache=function(){q.prototype.invalidateCache.call(this);this._measurer.reset()};return u}(n.Axis);f.Numeric=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)};d=h(42);var t=h(25),l=h(0);h=function(p){function m(n){function q(){w&&(w=!1,y._dragEndCallbacks.callCallbacks(y))}function u(C,G){w&&(y._setPixelPositionWithoutChangingMode(y._isVertical()?
G.x:G.y),y._dragCallbacks.callCallbacks(y))}function x(C){A(C)&&(w=!0,y._dragStartCallbacks.callCallbacks(y))}function A(C){return y._isVertical()&&y.pixelPosition()-y.detectionRadius()<=C.x&&C.x<=y.pixelPosition()+y.detectionRadius()||!y._isVertical()&&y.pixelPosition()-y.detectionRadius()<=C.y&&C.y<=y.pixelPosition()+y.detectionRadius()}var y=p.call(this,n)||this;y._detectionRadius=3;y._enabled=!0;y.addClass("drag-line-layer");y.addClass("enabled");y._dragInteraction=new t.Drag;y._dragInteraction.attachTo(y);
var w=!1;y._dragInteraction.onDragStart(x);y._dragInteraction.onDrag(u);y._dragInteraction.onDragEnd(q);y._disconnectInteraction=function(){y._dragInteraction.offDragStart(x);y._dragInteraction.offDrag(u);y._dragInteraction.offDragEnd(q);y._dragInteraction.detach()};y._dragStartCallbacks=new l.CallbackSet;y._dragCallbacks=new l.CallbackSet;y._dragEndCallbacks=new l.CallbackSet;return y}k(m,p);m.prototype._setup=function(){p.prototype._setup.call(this);this._detectionEdge=this.content().append("line").styles({opacity:0,
stroke:"pink","pointer-events":"visibleStroke"}).classed("drag-edge",!0)};m.prototype.renderImmediately=function(){p.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":2*this._detectionRadius});return this};m.prototype.detectionRadius=function(){return this._detectionRadius};
m.prototype.enabled=function(n){if(null==n)return this._enabled;(this._enabled=n)?this.addClass("enabled"):this.removeClass("enabled");this._dragInteraction.enabled(n);return this};m.prototype.onDragStart=function(n){this._dragStartCallbacks.add(n)};m.prototype.offDragStart=function(n){this._dragStartCallbacks.delete(n)};m.prototype.onDrag=function(n){this._dragCallbacks.add(n);return this};m.prototype.offDrag=function(n){this._dragCallbacks.delete(n)};m.prototype.onDragEnd=function(n){this._dragEndCallbacks.add(n)};
m.prototype.offDragEnd=function(n){this._dragEndCallbacks.delete(n)};m.prototype.destroy=function(){var n=this;p.prototype.destroy.call(this);this._dragStartCallbacks.forEach(function(q){return n._dragStartCallbacks.delete(q)});this._dragCallbacks.forEach(function(q){return n._dragCallbacks.delete(q)});this._dragEndCallbacks.forEach(function(q){return n._dragEndCallbacks.delete(q)});this._disconnectInteraction()};return m}(d.GuideLineLayer);f.DragLineLayer=h},function(d,f,h){function k(l,p,m){var n=
{};if(void 0!==m)for(var q=0;q<m.length;q++)n[m[q]]=m[q-1];return function(u){var x=l.scale(u);if(!p)return x;var A;u=void 0===n[u]?void 0:l.scale(n[u]);void 0!==u&&(A=u+(x-u)/2);return A}}var t=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)};d=function(l){function p(m,n){var q=l.call(this)||this;q.addClass("gridlines");q._xScale=m;q._yScale=n;q._renderCallback=
function(){return q.render()};if(q._xScale)q._xScale.onUpdate(q._renderCallback);if(q._yScale)q._yScale.onUpdate(q._renderCallback);return q}t(p,l);p.prototype.betweenX=function(){return this._betweenX};p.prototype.betweenY=function(){return this._betweenY};p.prototype.destroy=function(){l.prototype.destroy.call(this);this._xScale&&this._xScale.offUpdate(this._renderCallback);this._yScale&&this._yScale.offUpdate(this._renderCallback);return this};p.prototype._setup=function(){l.prototype._setup.call(this);
this._xLinesContainer=this.content().append("g").classed("x-gridlines",!0);this._yLinesContainer=this.content().append("g").classed("y-gridlines",!0)};p.prototype.renderImmediately=function(){l.prototype.renderImmediately.call(this);this._redrawXLines();this._redrawYLines();return this};p.prototype.computeLayout=function(m,n,q){l.prototype.computeLayout.call(this,m,n,q);null!=this._xScale&&this._xScale.range([0,this.width()]);null!=this._yScale&&this._yScale.range([this.height(),0]);return this};
p.prototype._redrawXLines=function(){if(this._xScale){var m=this.betweenX(),n=this._xScale.ticks().slice(m?1:0);n=this._xLinesContainer.selectAll("line").data(n);n.enter().append("line").merge(n).attr("x1",k(this._xScale,m,this._xScale.ticks())).attr("y1",0).attr("x2",k(this._xScale,m,this._xScale.ticks())).attr("y2",this.height()).classed("betweenline",m).classed("zeroline",function(q){return 0===q});n.exit().remove()}};p.prototype._redrawYLines=function(){if(this._yScale){var m=this.betweenY(),
n=this._yScale.ticks().slice(m?1:0);n=this._yLinesContainer.selectAll("line").data(n);n.enter().append("line").merge(n).attr("x1",0).attr("y1",k(this._yScale,m,this._yScale.ticks())).attr("x2",this.width()).attr("y2",k(this._yScale,m,this._yScale.ticks())).classed("betweenline",m).classed("zeroline",function(q){return 0===q});n.exit().remove()}};return p}(h(4).Component);f.Gridlines=d},function(d,f,h){var k=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&
(n[x]=q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},t=h(5),l=h(23),p=h(8),m=h(0);d=function(n){function q(u){var x=n.call(this)||this;x._textPadding=5;if(null==u)throw Error("InterpolatedColorLegend requires a interpolatedColorScale");x._scale=u;x._redrawCallback=function(){return x.redraw()};x._scale.onUpdate(x._redrawCallback);x._formatter=p.general();x._orientation="horizontal";x._expands=!1;x.addClass("legend");x.addClass("interpolated-color-legend");return x}k(q,
n);q.prototype.destroy=function(){n.prototype.destroy.call(this);this._scale.offUpdate(this._redrawCallback)};q.prototype.formatter=function(u){if(void 0===u)return this._formatter;this._formatter=u;this.redraw();return this};q.prototype.expands=function(){return this._expands};q._ensureOrientation=function(u){u=u.toLowerCase();if("horizontal"===u||"left"===u||"right"===u)return u;throw Error('"'+u+'" is not a valid orientation for InterpolatedColorLegend');};q.prototype.orientation=function(u){if(null==
u)return this._orientation;this._orientation=q._ensureOrientation(u);this.redraw();return this};q.prototype.fixedWidth=function(){return!this.expands()||this._isVertical()};q.prototype.fixedHeight=function(){return!this.expands()||!this._isVertical()};q.prototype._generateTicks=function(u){void 0===u&&(u=q._DEFAULT_NUM_SWATCHES);var x=this._scale.domain();if(1===u)return[x[0]];for(var A=(x[1]-x[0])/(u-1),y=[],w=0;w<u;w++)y.push(x[0]+A*w);return y};q.prototype._setup=function(){n.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(q.LEGEND_LABEL_CLASS,!0);this._upperLabel=this.content().append("g").classed(q.LEGEND_LABEL_CLASS,!0);var u=new t.SvgContext(this.content().node());this._measurer=new t.Measurer(u);this._wrapper=new t.Wrapper;this._writer=new t.Writer(this._measurer,u,this._wrapper)};q.prototype.requestedSpace=
function(){var u=this,x=this._measurer.measure().height,A=this._scale.domain().map(function(C){return u._measurer.measure(u._formatter(C)).width}),y=q._DEFAULT_NUM_SWATCHES;if(this._isVertical()){var w=m.Math.max(A,0);A=x+x+this._textPadding+w+this._textPadding;w=y*x}else w=x+x+x,A=this._textPadding+A[0]+y*x+A[1]+this._textPadding;return{minWidth:A,minHeight:w}};q.prototype._isVertical=function(){return"horizontal"!==this._orientation};q.prototype.renderImmediately=function(){var u=this;n.prototype.renderImmediately.call(this);
var x=this._scale.domain(),A=this._formatter(x[0]),y=this._measurer.measure(A).width,w=this._formatter(x[1]);x=this._measurer.measure(w).width;var C=this._measurer.measure().height,G=this._textPadding,D=0,B=0,I=0,N=0,O={xAlign:"center",yAlign:"center",textRotation:0},H={xAlign:"center",yAlign:"center",textRotation:0},K={x:0,y:0,width:0,height:0};if(this._isVertical()){var M=Math.floor(this.height());var L=Math.max(y,x);var Q=(this.width()-L-2*this._textPadding)/2;x=Math.max(this.width()-Q-2*G-L,0);
C=1;var T=function(aa,la){return u.height()-(la+1)};H.yAlign="top";B=0;O.yAlign="bottom";N=0;if("left"===this._orientation){var X=function(){return G+L+G};H.xAlign="right";D=-(Q+x+G);O.xAlign="right";I=-(Q+x+G)}else X=function(){return Q},H.xAlign="left",D=Q+x+G,O.xAlign="left",I=Q+x+G;K.width=x;K.height=M*C}else Q=Math.max(G,(this.height()-C)/2),M=Math.max(Math.floor(this.width()-4*G-y-x),0),x=1,C=Math.max(this.height()-2*Q,0),X=function(aa,la){return Math.floor(y+2*G)+la},T=function(){return Q},
H.xAlign="right",D=-G,O.xAlign="left",I=G,K.y=Q,K.width=M*x,K.height=C;K.x=X(null,0);this._upperLabel.text("");this._writer.write(w,this.width(),this.height(),H,this._upperLabel.node());this._upperLabel.attr("transform","translate("+D+", "+B+")");this._lowerLabel.text("");this._writer.write(A,this.width(),this.height(),O,this._lowerLabel.node());this._lowerLabel.attr("transform","translate("+I+", "+N+")");this._swatchBoundingBox.attrs(K);A=this._generateTicks(M);A=this._swatchContainer.selectAll("rect.swatch").data(A);
w=A.enter().append("rect").classed("swatch",!0);D=A.merge(w);A.exit().remove();D.attrs({fill:function(aa){return u._scale.scale(aa)},width:x,height:C,x:X,y:T,"shape-rendering":"crispEdges"});l.ADD_TITLE_ELEMENTS&&w.append("title").text(function(aa){return u._formatter(aa)});return this};return q}(h(4).Component);d._DEFAULT_NUM_SWATCHES=11;d.LEGEND_LABEL_CLASS="legend-label";f.InterpolatedColorLegend=d},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&
(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(5);d=function(l){function p(m,n){void 0===m&&(m="");void 0===n&&(n=0);var q=l.call(this)||this;q.addClass("label");q.text(m);q.angle(n);q.xAlignment("center").yAlignment("center");q._padding=0;return q}k(p,l);p.prototype.requestedSpace=function(){var m=this._measurer.measure(this._text),n=(0===this.angle()?m.width:m.height)+2*this.padding();m=(0===this.angle()?m.height:m.width)+2*this.padding();return{minWidth:n,
minHeight:m}};p.prototype._setup=function(){l.prototype._setup.call(this);this._textContainer=this.content().append("g");var m=new t.SvgContext(this._textContainer.node());this._measurer=new t.CacheMeasurer(m);this._wrapper=new t.Wrapper;this._writer=new t.Writer(this._measurer,m,this._wrapper);this.text(this._text)};p.prototype.text=function(m){if(null==m)return this._text;if("string"!==typeof m)throw Error("Label.text() only takes strings as input");this._text=m;this.redraw();return this};p.prototype.angle=
function(m){if(null==m)return this._angle;m%=360;180<m?m-=360:-180>m&&(m+=360);if(-90===m||0===m||90===m)this._angle=m;else throw Error(m+" is not a valid angle for Label");this.redraw();return this};p.prototype.padding=function(m){if(null==m)return this._padding;m=+m;if(0>m)throw Error(m+" is not a valid padding value. Cannot be less than 0.");this._padding=m;this.redraw();return this};p.prototype.fixedWidth=function(){return!0};p.prototype.fixedHeight=function(){return!0};p.prototype.renderImmediately=
function(){l.prototype.renderImmediately.call(this);this._textContainer.selectAll("g").remove();var m=this._measurer.measure(this._text),n=Math.max(Math.min((this.height()-m.height)/2,this.padding()),0);m=Math.max(Math.min((this.width()-m.width)/2,this.padding()),0);this._textContainer.attr("transform","translate("+m+","+n+")");m=this.width()-2*m;n=this.height()-2*n;var q={xAlign:this.xAlignment(),yAlign:this.yAlignment(),textRotation:this.angle()};this._writer.write(this._text,m,n,q);return this};
p.prototype.invalidateCache=function(){l.prototype.invalidateCache.call(this);this._measurer.reset()};return p}(h(4).Component);f.Label=d;h=function(l){function p(m,n){m=l.call(this,m,n)||this;m.addClass(p.TITLE_LABEL_CLASS);return m}k(p,l);return p}(d);h.TITLE_LABEL_CLASS="title-label";f.TitleLabel=h;d=function(l){function p(m,n){m=l.call(this,m,n)||this;m.addClass(p.AXIS_LABEL_CLASS);return m}k(p,l);return p}(d);d.AXIS_LABEL_CLASS="axis-label";f.AxisLabel=d},function(d,f,h){var k=this&&this.__extends||
function(A,y){function w(){this.constructor=A}for(var C in y)y.hasOwnProperty(C)&&(A[C]=y[C]);A.prototype=null===y?Object.create(y):(w.prototype=y.prototype,new w)},t=h(1),l=h(5),p=h(23),m=h(8),n=h(31),q=h(0);d=h(4);var u=function(){function A(y,w,C){void 0===y&&(y=[]);void 0===w&&(w=0);void 0===C&&(C=Infinity);this.columns=y;this.bottomPadding=w;this.maxWidth=C}A.prototype.addColumn=function(y){var w=y.width,C=this.getWidthAvailable();y.width=Math.min(C,w);this.columns.push(y)};A.prototype.getBounds=
function(y){for(var w=this.columns[y],C=0,G=0;G<y;G++)C+=this.columns[G].width;return{topLeft:{x:C,y:0},bottomRight:{x:C+w.width,y:w.height}}};A.prototype.getHeight=function(){return q.Math.max(this.columns.map(function(y){return y.height}),0)+this.bottomPadding};A.prototype.getWidth=function(){return Math.min(this.columns.reduce(function(y,w){return y+w.width},0),this.maxWidth)};A.prototype.getWidthAvailable=function(){var y=this.getWidth();return Math.max(this.maxWidth-y,0)};return A}(),x=function(){function A(y,
w,C,G){void 0===y&&(y=Infinity);void 0===w&&(w=Infinity);void 0===C&&(C=0);void 0===G&&(G=[]);this.maxWidth=y;this.maxHeight=w;this.padding=C;this.rows=G}A.prototype.addRow=function(y){y.maxWidth=this.maxWidth-2*this.padding;this.rows.push(y)};A.prototype.getColumnBounds=function(y,w){var C=this.getRowBounds(y);y=this.rows[y].getBounds(w);y.topLeft.x+=C.topLeft.x;y.bottomRight.x+=C.topLeft.x;y.topLeft.y+=C.topLeft.y;y.bottomRight.y+=C.topLeft.y;return y};A.prototype.getRowBounds=function(y){for(var w=
this.padding,C=this.padding,G=0;G<y;G++)C+=this.rows[G].getHeight();return{topLeft:{x:w,y:C},bottomRight:{x:w+this.rows[y].getWidth(),y:C+this.rows[y].getHeight()}}};A.prototype.getHeight=function(){return Math.min(this.rows.reduce(function(y,w){return y+w.getHeight()},0)+2*this.padding,this.maxHeight)};A.prototype.getWidth=function(){return Math.min(q.Math.max(this.rows.map(function(y){return y.getWidth()}),0)+2*this.padding,this.maxWidth)};return A}();d=function(A){function y(w){var C=A.call(this)||
this;C._padding=5;C._rowBottomPadding=3;C.addClass("legend");C.maxEntriesPerRow(1);if(null==w)throw Error("Legend requires a colorScale");C._colorScale=w;C._redrawCallback=function(){return C.redraw()};C._colorScale.onUpdate(C._redrawCallback);C._formatter=m.identity();C.maxLinesPerEntry(1);C.xAlignment("right").yAlignment("top");C.comparator(function(G,D){var B=C._colorScale.domain().slice().map(function(I){return C._formatter(I)});return B.indexOf(G)-B.indexOf(D)});C._symbolFactoryAccessor=function(){return n.circle()};
C._symbolOpacityAccessor=function(){return 1};return C}k(y,A);y.prototype._setup=function(){A.prototype._setup.call(this);var w=this.content().append("g").classed(y.LEGEND_ROW_CLASS,!0);w.append("g").classed(y.LEGEND_ENTRY_CLASS,!0).append("text");w=new l.SvgContext(w.node(),null,p.ADD_TITLE_ELEMENTS);this._measurer=new l.CacheMeasurer(w);this._wrapper=(new l.Wrapper).maxLines(this.maxLinesPerEntry());this._writer=new l.Writer(this._measurer,w,this._wrapper)};y.prototype.formatter=function(w){if(null==
w)return this._formatter;this._formatter=w;this.redraw();return this};y.prototype.maxEntriesPerRow=function(w){if(null==w)return this._maxEntriesPerRow;this._maxEntriesPerRow=w;this.redraw();return this};y.prototype.maxLinesPerEntry=function(w){if(null==w)return this._maxLinesPerEntry;this._maxLinesPerEntry=w;this.redraw();return this};y.prototype.maxWidth=function(w){if(null==w)return this._maxWidth;this._maxWidth=w;this.redraw();return this};y.prototype.comparator=function(w){null!=w&&(this._comparator=
w,this.redraw())};y.prototype.colorScale=function(w){return null!=w?(this._colorScale.offUpdate(this._redrawCallback),this._colorScale=w,this._colorScale.onUpdate(this._redrawCallback),this.redraw(),this):this._colorScale};y.prototype.destroy=function(){A.prototype.destroy.call(this);this._colorScale.offUpdate(this._redrawCallback)};y.prototype._buildLegendTable=function(w,C){var G=this,D=this._measurer.measure().height,B=new x(w,C,this._padding);w=this._colorScale.domain().slice().sort(function(N,
O){return G._comparator(G._formatter(N),G._formatter(O))});var I=new u;B.addRow(I);I.bottomPadding=this._rowBottomPadding;w.forEach(function(N){I.columns.length/2===G.maxEntriesPerRow()&&(I=new u,I.bottomPadding=G._rowBottomPadding,B.addRow(I));var O=I.getWidthAvailable(),H=G._formatter(N),K=G._measurer.measure(H).width;0>O-D-K&&1<I.columns.length&&(I=new u,I.bottomPadding=G._rowBottomPadding,B.addRow(I));I.addColumn({width:D,height:D,data:{name:N,type:"symbol"}});O=I.getWidthAvailable();O=Math.min(O,
K);G._wrapper.maxLines(G.maxLinesPerEntry());H=G._wrapper.wrap(H,G._measurer,O).noLines*D;I.addColumn({width:O,height:H,data:{name:N,type:"text"}})});return B};y.prototype.requestedSpace=function(w,C){w=this._buildLegendTable(q.Math.min([this.maxWidth(),w],w),C);return{minHeight:w.getHeight(),minWidth:w.getWidth()}};y.prototype.entitiesAt=function(w){var C=this;if(!this._isSetup)return[];var G=this._buildLegendTable(this.width(),this.height());return G.rows.reduce(function(D,B,I){if(0!==D.length)return D;
var N=G.getRowBounds(I);return q.Math.within(w,N)?B.columns.reduce(function(O,H,K){var M=G.getColumnBounds(I,K);if(q.Math.within(w,M)){O=C.content().selectAll("."+y.LEGEND_ROW_CLASS).nodes()[I];K=t.select(O).selectAll("."+y.LEGEND_ENTRY_CLASS).nodes()[Math.floor(K/2)];var L=t.select(K).select("."+y.LEGEND_SYMBOL_CLASS);M=q.DOM.getTranslateValues(t.select(O));L=q.DOM.getTranslateValues(L);return[{bounds:q.DOM.elementBBox(t.select(O)),datum:H.data.name,position:{x:M[0]+L[0],y:M[1]+L[1]},selection:t.select(K),
component:C}]}return O},D):D},[])};y.prototype.renderImmediately=function(){A.prototype.renderImmediately.call(this);var w=this._buildLegendTable(this.width(),this.height());this.content().selectAll("*").remove();var C=this.content().selectAll("g."+y.LEGEND_ROW_CLASS).data(w.rows),G=C.enter().append("g").classed(y.LEGEND_ROW_CLASS,!0).merge(C);C.exit().remove();G.attr("transform",function(B,I){B=w.getRowBounds(I);return"translate("+B.topLeft.x+", "+B.topLeft.y+")"});var D=this;G.each(function(B,I){for(var N=
[],O=0;O<B.columns.length;O+=2)N.push([B.columns[O],B.columns[O+1]]);B=t.select(this).selectAll("g."+y.LEGEND_ENTRY_CLASS).data(N);N=B.enter().append("g").classed(y.LEGEND_ENTRY_CLASS,!0).merge(B);N.append("path").attr("d",function(H){H=H[0];return D.symbol()(H.data.name,I)(.6*H.height)(null)}).attr("transform",function(H){H=H[0];return"translate("+(w.getColumnBounds(I,w.rows[I].columns.indexOf(H)).topLeft.x+H.width/2)+", "+H.height/2+")"}).attr("fill",function(H){return D._colorScale.scale(H[0].data.name)}).attr("opacity",
function(H){return D.symbolOpacity()(H[0].data.name,I)}).classed(y.LEGEND_SYMBOL_CLASS,!0);N.append("g").classed("text-container",!0).attr("transform",function(H){return"translate("+w.getColumnBounds(I,w.rows[I].columns.indexOf(H[1])).topLeft.x+", 0)"}).each(function(H){var K=t.select(this);H=H[1];D._writer.write(D._formatter(H.data.name),H.width,D.height(),{xAlign:"left",yAlign:"top",textRotation:0},K.node())});B.exit().remove()});return this};y.prototype.symbol=function(w){if(null==w)return this._symbolFactoryAccessor;
this._symbolFactoryAccessor=w;this.render();return this};y.prototype.symbolOpacity=function(){return this._symbolOpacityAccessor};y.prototype.fixedWidth=function(){return!0};y.prototype.fixedHeight=function(){return!0};y.prototype.invalidateCache=function(){this._measurer.reset()};return y}(d.Component);d.LEGEND_ROW_CLASS="legend-row";d.LEGEND_ENTRY_CLASS="legend-entry";d.LEGEND_SYMBOL_CLASS="legend-symbol";f.Legend=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=
p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(2),l=h(0);d=function(p){function m(){return null!==p&&p.apply(this,arguments)||this}k(m,p);m.prototype.entityNearest=function(n){var q,u=Infinity;this.components().forEach(function(x){x=x.entityNearest(n);if(null!=x){var A=l.Math.distanceSquared(x.position,n);A<=u&&(u=A,q=x)}});return q};m.prototype.append=function(n){if(null!=n&&!(n instanceof t.Plot))throw Error("Plot Group only accepts plots");
p.prototype.append.call(this,n);return this};return m}(h(41).Group);f.PlotGroup=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(1),l=h(0);d=function(p){function m(n){void 0===n&&(n=[]);var q=p.call(this)||this;q._rowPadding=0;q._columnPadding=0;q._rows=[];q._rowWeights=[];q._columnWeights=[];q._nRows=0;q._nCols=0;q._calculatedLayout=
null;q.addClass("table");n.forEach(function(u,x){u.forEach(function(A,y){null!=A&&q.add(A,x,y)})});return q}k(m,p);m.prototype._forEach=function(n){for(var q=0;q<this._nRows;q++)for(var u=0;u<this._nCols;u++)null!=this._rows[q][u]&&n(this._rows[q][u])};m.prototype.has=function(n){for(var q=0;q<this._nRows;q++)for(var u=0;u<this._nCols;u++)if(this._rows[q][u]===n)return!0;return!1};m.prototype.componentAt=function(n,q){return 0>n||n>=this._nRows||0>q||q>=this._nCols?null:this._rows[n][q]};m.prototype.add=
function(n,q,u){if(null==n)throw Error("Cannot add null to a table cell");if(!this.has(n)){if(null!=(this._rows[q]&&this._rows[q][u]))throw Error("cell is occupied");n.detach();this._nRows=Math.max(q+1,this._nRows);this._nCols=Math.max(u+1,this._nCols);this._padTableToSize(this._nRows,this._nCols);this._rows[q][u]=n;this._adoptAndAnchor(n);this.redraw()}return this};m.prototype._remove=function(n){for(var q=0;q<this._nRows;q++)for(var u=0;u<this._nCols;u++)if(this._rows[q][u]===n){this._rows[q][u]=
null;return}};m.prototype._iterateLayout=function(n,q,u){void 0===u&&(u=!1);var x=this._rows,A=t.transpose(this._rows);n-=this._columnPadding*(this._nCols-1);q-=this._rowPadding*(this._nRows-1);x=m._calcComponentWeights(this._rowWeights,x,function(L){return null==L||L.fixedHeight()});A=m._calcComponentWeights(this._columnWeights,A,function(L){return null==L||L.fixedWidth()});var y=A.map(function(L){return 0===L?.5:L}),w=x.map(function(L){return 0===L?.5:L});y=m._calcProportionalSpace(y,n);var C=m._calcProportionalSpace(w,
q),G=l.Array.createFilledArray(0,this._nCols),D=l.Array.createFilledArray(0,this._nRows);w=0;for(var B,I,N;;){D=l.Array.add(D,C);y=l.Array.add(G,y);B=this._determineGuarantees(y,D,u);G=B.guaranteedWidths;D=B.guaranteedHeights;I=B.wantsWidthArr.some(function(L){return L});N=B.wantsHeightArr.some(function(L){return L});var O=K,H=M;var K=n-t.sum(B.guaranteedWidths);var M=q-t.sum(B.guaranteedHeights);y=void 0;I?(y=B.wantsWidthArr.map(function(L){return L?.1:0}),y=l.Array.add(y,A)):y=A;C=void 0;N?(C=B.wantsHeightArr.map(function(L){return L?
.1:0}),C=l.Array.add(C,x)):C=x;y=m._calcProportionalSpace(y,K);C=m._calcProportionalSpace(C,M);w++;H=0<M&&M!==H;if(!(0<K&&K!==O||H))break;if(5<w)break}K=n-t.sum(B.guaranteedWidths);M=q-t.sum(B.guaranteedHeights);y=m._calcProportionalSpace(A,K);C=m._calcProportionalSpace(x,M);return{colProportionalSpace:y,rowProportionalSpace:C,guaranteedWidths:B.guaranteedWidths,guaranteedHeights:B.guaranteedHeights,wantsWidth:I,wantsHeight:N}};m.prototype._determineGuarantees=function(n,q,u){void 0===u&&(u=!1);var x=
l.Array.createFilledArray(0,this._nCols),A=l.Array.createFilledArray(0,this._nRows),y=l.Array.createFilledArray(!1,this._nCols),w=l.Array.createFilledArray(!1,this._nRows);this._rows.forEach(function(C,G){C.forEach(function(D,B){D=null!=D?D.requestedSpace(n[B],q[G]):{minWidth:0,minHeight:0};x[B]=Math.max(x[B],u?Math.min(D.minWidth,n[B]):D.minWidth);A[G]=Math.max(A[G],u?Math.min(D.minHeight,q[G]):D.minHeight);var I=D.minWidth>n[B];y[B]=y[B]||I;B=D.minHeight>q[G];w[G]=w[G]||B})});return{guaranteedWidths:x,
guaranteedHeights:A,wantsWidthArr:y,wantsHeightArr:w}};m.prototype.requestedSpace=function(n,q){this._calculatedLayout=this._iterateLayout(n,q);return{minWidth:t.sum(this._calculatedLayout.guaranteedWidths),minHeight:t.sum(this._calculatedLayout.guaranteedHeights)}};m.prototype.computeLayout=function(n,q,u){var x=this;p.prototype.computeLayout.call(this,n,q,u);n=t.sum(this._calculatedLayout.guaranteedWidths);q=t.sum(this._calculatedLayout.guaranteedHeights);u=this._calculatedLayout;if(n>this.width()||
q>this.height())u=this._iterateLayout(this.width(),this.height(),!0);var A=0,y=l.Array.add(u.rowProportionalSpace,u.guaranteedHeights),w=l.Array.add(u.colProportionalSpace,u.guaranteedWidths);this._rows.forEach(function(C,G){var D=0;C.forEach(function(B,I){null!=B&&B.computeLayout({x:D,y:A},w[I],y[G]);D+=w[I]+x._columnPadding});A+=y[G]+x._rowPadding});return this};m.prototype.rowPadding=function(n){if(null==n)return this._rowPadding;if(!l.Math.isValidNumber(n)||0>n)throw Error("rowPadding must be a non-negative finite value");
this._rowPadding=n;this.redraw();return this};m.prototype.columnPadding=function(n){if(null==n)return this._columnPadding;if(!l.Math.isValidNumber(n)||0>n)throw Error("columnPadding must be a non-negative finite value");this._columnPadding=n;this.redraw();return this};m.prototype.rowWeight=function(n,q){if(null==q)return this._rowWeights[n];if(!l.Math.isValidNumber(q)||0>q)throw Error("rowWeight must be a non-negative finite value");this._rowWeights[n]=q;this.redraw();return this};m.prototype.columnWeight=
function(n,q){if(null==q)return this._columnWeights[n];if(!l.Math.isValidNumber(q)||0>q)throw Error("columnWeight must be a non-negative finite value");this._columnWeights[n]=q;this.redraw();return this};m.prototype.fixedWidth=function(){var n=t.transpose(this._rows);return m._fixedSpace(n,function(q){return null==q||q.fixedWidth()})};m.prototype.fixedHeight=function(){return m._fixedSpace(this._rows,function(n){return null==n||n.fixedHeight()})};m.prototype._padTableToSize=function(n,q){for(var u=
0;u<n;u++){void 0===this._rows[u]&&(this._rows[u]=[],this._rowWeights[u]=null);for(var x=0;x<q;x++)void 0===this._rows[u][x]&&(this._rows[u][x]=null)}for(x=0;x<q;x++)void 0===this._columnWeights[x]&&(this._columnWeights[x]=null)};m._calcComponentWeights=function(n,q,u){return n.map(function(x,A){return null!=x?x:q[A].map(u).reduce(function(y,w){return y&&w},!0)?0:1})};m._calcProportionalSpace=function(n,q){var u=t.sum(n);return 0===u?l.Array.createFilledArray(0,n.length):n.map(function(x){return q*
x/u})};m._fixedSpace=function(n,q){function u(x){return x.reduce(function(A,y){return A&&y},!0)}return u(n.map(function(x){return u(x.map(q))}))};return m}(h(29).ComponentContainer);f.Table=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){var p=t.call(this)||this;p.addClass("x-drag-box-layer");p._hasCorners=!1;
return p}k(l,t);l.prototype.computeLayout=function(p,m,n){t.prototype.computeLayout.call(this,p,m,n);this._setBounds(this.bounds());return this};l.prototype._setBounds=function(p){t.prototype._setBounds.call(this,{topLeft:{x:p.topLeft.x,y:0},bottomRight:{x:p.bottomRight.x,y:this.height()}})};l.prototype._setResizableClasses=function(p){p&&this.enabled()?this.addClass("x-resizable"):this.removeClass("x-resizable")};l.prototype.yScale=function(p){if(null==p)return t.prototype.yScale.call(this);throw Error("yScales cannot be set on an XDragBoxLayer");
};l.prototype.yExtent=function(){return t.prototype.yExtent.call(this);throw Error("XDragBoxLayer has no yExtent");};return l}(h(32).DragBoxLayer);f.XDragBoxLayer=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){var p=t.call(this)||this;p.addClass("y-drag-box-layer");p._hasCorners=!1;return p}k(l,t);l.prototype.computeLayout=
function(p,m,n){t.prototype.computeLayout.call(this,p,m,n);this._setBounds(this.bounds());return this};l.prototype._setBounds=function(p){t.prototype._setBounds.call(this,{topLeft:{x:0,y:p.topLeft.y},bottomRight:{x:this.width(),y:p.bottomRight.y}})};l.prototype._setResizableClasses=function(p){p&&this.enabled()?this.addClass("y-resizable"):this.removeClass("y-resizable")};l.prototype.xScale=function(p){if(null==p)return t.prototype.xScale.call(this);throw Error("xScales cannot be set on an YDragBoxLayer");
};l.prototype.xExtent=function(){return t.prototype.xExtent.call(this);throw Error("YDragBoxLayer has no xExtent");};return l}(h(32).DragBoxLayer);f.YDragBoxLayer=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){var p=t.call(this)||this;p._eventToProcessingFunction[l._KEYDOWN_EVENT_NAME]=function(m){return p._processKeydown(m)};
p._eventToProcessingFunction[l._KEYUP_EVENT_NAME]=function(m){return p._processKeyup(m)};return p}k(l,t);l.getDispatcher=function(){var p=document[l._DISPATCHER_KEY];null==p&&(p=new l,document[l._DISPATCHER_KEY]=p);return p};l.prototype._processKeydown=function(p){this._callCallbacksForEvent(l._KEYDOWN_EVENT_NAME,p.keyCode,p)};l.prototype._processKeyup=function(p){this._callCallbacksForEvent(l._KEYUP_EVENT_NAME,p.keyCode,p)};l.prototype.onKeyDown=function(p){this._addCallbackForEvent(l._KEYDOWN_EVENT_NAME,
p)};l.prototype.offKeyDown=function(p){this._removeCallbackForEvent(l._KEYDOWN_EVENT_NAME,p)};l.prototype.onKeyUp=function(p){this._addCallbackForEvent(l._KEYUP_EVENT_NAME,p)};l.prototype.offKeyUp=function(p){this._removeCallbackForEvent(l._KEYUP_EVENT_NAME,p)};return l}(h(24).Dispatcher);d._DISPATCHER_KEY="__Plottable_Dispatcher_Key";d._KEYDOWN_EVENT_NAME="keydown";d._KEYUP_EVENT_NAME="keyup";f.Key=d},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&
(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(0);d=function(l){function p(m){function n(u){return q._measureAndDispatch(m,u,p._MOUSEMOVE_EVENT_NAME,"page")}var q=l.call(this)||this;q._lastMousePosition={x:-1,y:-1};q._translator=t.getTranslator(m);q._eventToProcessingFunction[p._MOUSEOVER_EVENT_NAME]=n;q._eventToProcessingFunction[p._MOUSEMOVE_EVENT_NAME]=n;q._eventToProcessingFunction[p._MOUSEOUT_EVENT_NAME]=n;q._eventToProcessingFunction[p._MOUSEDOWN_EVENT_NAME]=
function(u){return q._measureAndDispatch(m,u,p._MOUSEDOWN_EVENT_NAME)};q._eventToProcessingFunction[p._MOUSEUP_EVENT_NAME]=function(u){return q._measureAndDispatch(m,u,p._MOUSEUP_EVENT_NAME,"page")};q._eventToProcessingFunction[p._WHEEL_EVENT_NAME]=function(u){return q._measureAndDispatch(m,u,p._WHEEL_EVENT_NAME)};q._eventToProcessingFunction[p._DBLCLICK_EVENT_NAME]=function(u){return q._measureAndDispatch(m,u,p._DBLCLICK_EVENT_NAME)};return q}k(p,l);p.getDispatcher=function(m){var n=m.root().rootElement(),
q=n[p._DISPATCHER_KEY];null==q&&(q=new p(m),n[p._DISPATCHER_KEY]=q);return q};p.prototype.onMouseMove=function(m){this._addCallbackForEvent(p._MOUSEMOVE_EVENT_NAME,m)};p.prototype.offMouseMove=function(m){this._removeCallbackForEvent(p._MOUSEMOVE_EVENT_NAME,m)};p.prototype.onMouseDown=function(m){this._addCallbackForEvent(p._MOUSEDOWN_EVENT_NAME,m)};p.prototype.offMouseDown=function(m){this._removeCallbackForEvent(p._MOUSEDOWN_EVENT_NAME,m)};p.prototype.onMouseUp=function(m){this._addCallbackForEvent(p._MOUSEUP_EVENT_NAME,
m)};p.prototype.offMouseUp=function(m){this._removeCallbackForEvent(p._MOUSEUP_EVENT_NAME,m)};p.prototype.onWheel=function(m){this._addCallbackForEvent(p._WHEEL_EVENT_NAME,m);return this};p.prototype.offWheel=function(m){this._removeCallbackForEvent(p._WHEEL_EVENT_NAME,m)};p.prototype.onDblClick=function(m){this._addCallbackForEvent(p._DBLCLICK_EVENT_NAME,m)};p.prototype.offDblClick=function(m){this._removeCallbackForEvent(p._DBLCLICK_EVENT_NAME,m)};p.prototype._measureAndDispatch=function(m,n,q,
u){void 0===u&&(u="element");if("page"!==u&&"element"!==u)throw Error("Invalid scope '"+u+"', must be 'element' or 'page'");if("page"===u||this.eventInside(m,n))this._lastMousePosition=this._translator.computePosition(n.clientX,n.clientY),this._callCallbacksForEvent(q,this.lastMousePosition(),n)};p.prototype.eventInside=function(m,n){return t.Translator.isEventInside(m,n)};p.prototype.lastMousePosition=function(){return this._lastMousePosition};return p}(h(24).Dispatcher);d._DISPATCHER_KEY="__Plottable_Dispatcher_Mouse";
d._MOUSEOVER_EVENT_NAME="mouseover";d._MOUSEMOVE_EVENT_NAME="mousemove";d._MOUSEOUT_EVENT_NAME="mouseout";d._MOUSEDOWN_EVENT_NAME="mousedown";d._MOUSEUP_EVENT_NAME="mouseup";d._WHEEL_EVENT_NAME="wheel";d._DBLCLICK_EVENT_NAME="dblclick";f.Mouse=d},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(0);d=function(l){function p(m){var n=l.call(this)||
this;n._translator=t.getTranslator(m);n._eventToProcessingFunction[p._TOUCHSTART_EVENT_NAME]=function(q){return n._measureAndDispatch(m,q,p._TOUCHSTART_EVENT_NAME,"page")};n._eventToProcessingFunction[p._TOUCHMOVE_EVENT_NAME]=function(q){return n._measureAndDispatch(m,q,p._TOUCHMOVE_EVENT_NAME,"page")};n._eventToProcessingFunction[p._TOUCHEND_EVENT_NAME]=function(q){return n._measureAndDispatch(m,q,p._TOUCHEND_EVENT_NAME,"page")};n._eventToProcessingFunction[p._TOUCHCANCEL_EVENT_NAME]=function(q){return n._measureAndDispatch(m,
q,p._TOUCHCANCEL_EVENT_NAME,"page")};return n}k(p,l);p.getDispatcher=function(m){var n=m.root().rootElement(),q=n[p._DISPATCHER_KEY];null==q&&(q=new p(m),n[p._DISPATCHER_KEY]=q);return q};p.prototype.onTouchStart=function(m){this._addCallbackForEvent(p._TOUCHSTART_EVENT_NAME,m)};p.prototype.offTouchStart=function(m){this._removeCallbackForEvent(p._TOUCHSTART_EVENT_NAME,m)};p.prototype.onTouchMove=function(m){this._addCallbackForEvent(p._TOUCHMOVE_EVENT_NAME,m)};p.prototype.offTouchMove=function(m){this._removeCallbackForEvent(p._TOUCHMOVE_EVENT_NAME,
m)};p.prototype.onTouchEnd=function(m){this._addCallbackForEvent(p._TOUCHEND_EVENT_NAME,m)};p.prototype.offTouchEnd=function(m){this._removeCallbackForEvent(p._TOUCHEND_EVENT_NAME,m)};p.prototype.onTouchCancel=function(m){this._addCallbackForEvent(p._TOUCHCANCEL_EVENT_NAME,m)};p.prototype.offTouchCancel=function(m){this._removeCallbackForEvent(p._TOUCHCANCEL_EVENT_NAME,m)};p.prototype._measureAndDispatch=function(m,n,q,u){void 0===u&&(u="element");if("page"!==u&&"element"!==u)throw Error("Invalid scope '"+
u+"', must be 'element' or 'page'");if("element"!==u||this.eventInside(m,n)){m=n.changedTouches;u={};for(var x=[],A=0;A<m.length;A++){var y=m[A],w=y.identifier;y=this._translator.computePosition(y.clientX,y.clientY);null!=y&&(u[w]=y,x.push(w))}0<x.length&&this._callCallbacksForEvent(q,x,u,n)}};p.prototype.eventInside=function(m,n){return t.Translator.isEventInside(m,n)};return p}(h(24).Dispatcher);d._DISPATCHER_KEY="__Plottable_Dispatcher_Touch";d._TOUCHSTART_EVENT_NAME="touchstart";d._TOUCHMOVE_EVENT_NAME=
"touchmove";d._TOUCHEND_EVENT_NAME="touchend";d._TOUCHCANCEL_EVENT_NAME="touchcancel";f.Touch=d},function(d,f){d=function(){function h(k,t,l){void 0===l&&(l=window.devicePixelRatio);this.screenWidth=k;this.screenHeight=t;this.devicePixelRatio=l;this.pixelWidth=k*l;this.pixelHeight=t*l;this.canvas=document.createElement("canvas");this.ctx=this.canvas.getContext("2d");h.sizePixels(this.ctx,k,t,l)}h.sizePixels=function(k,t,l,p){var m=k.canvas;m.width=t*p;m.height=l*p;m.style.width=t+"px";m.style.height=
l+"px";k.setTransform(1,0,0,1,0,0);k.scale(p,p)};h.prototype.blit=function(k,t,l){void 0===t&&(t=0);void 0===l&&(l=0);k.drawImage(this.canvas,t,l,this.screenWidth,this.screenHeight)};h.prototype.blitCenter=function(k,t,l){void 0===t&&(t=0);void 0===l&&(l=0);this.blit(k,Math.floor(t-this.screenWidth/2),Math.floor(l-this.screenHeight/2))};h.prototype.resize=function(k,t,l){void 0===l&&(l=!1);var p=this.devicePixelRatio;this.screenWidth=k;this.screenHeight=t;this.pixelWidth=k*p;this.pixelHeight=t*p;
h.sizePixels(this.ctx,k,t,p);l&&this.ctx.translate(k/2,k/2);return this};h.prototype.clear=function(k){var t=this.pixelWidth,l=this.pixelHeight,p=this.ctx;p.save();p.setTransform(1,0,0,1,0,0);null==k?p.clearRect(0,0,t,l):(p.fillStyle=k,p.fillRect(0,0,t,l));p.restore();return this};h.prototype.getImageData=function(){return this.ctx.getImageData(0,0,this.pixelWidth,this.pixelHeight)};return h}();f.CanvasBuffer=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=
p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(13),l=h(0);d=function(p){function m(){var n=null!==p&&p.apply(this,arguments)||this;n._clickedDown=!1;n._doubleClicking=!1;n._onClickCallbacks=new l.CallbackSet;n._onDoubleClickCallbacks=new l.CallbackSet;n._mouseDownCallback=function(q){return n._handleClickDown(q)};n._mouseUpCallback=function(q,u){return n._handleClickUp(q,u)};n._dblClickCallback=function(q,u){return n._handleDblClick(q,
u)};n._touchStartCallback=function(q,u){return n._handleClickDown(u[q[0]])};n._touchEndCallback=function(q,u,x){return n._handleClickUp(u[q[0]],x)};n._touchCancelCallback=function(){return n._clickedDown=!1};return n}k(m,p);m.prototype._anchor=function(n){p.prototype._anchor.call(this,n);this._mouseDispatcher=t.Mouse.getDispatcher(n);this._mouseDispatcher.onMouseDown(this._mouseDownCallback);this._mouseDispatcher.onMouseUp(this._mouseUpCallback);this._mouseDispatcher.onDblClick(this._dblClickCallback);
this._touchDispatcher=t.Touch.getDispatcher(n);this._touchDispatcher.onTouchStart(this._touchStartCallback);this._touchDispatcher.onTouchEnd(this._touchEndCallback);this._touchDispatcher.onTouchCancel(this._touchCancelCallback)};m.prototype._unanchor=function(){p.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};m.prototype._handleClickDown=function(n){n=this._translateToComponentSpace(n);this._isInsideComponent(n)&&(this._clickedDown=!0,this._clickedPoint=n)};m.prototype._handleClickUp=function(n,q){var u=this,x=this._translateToComponentSpace(n);this._clickedDown&&m._pointsEqual(x,this._clickedPoint)&&setTimeout(function(){u._doubleClicking||u._onClickCallbacks.callCallbacks(x,
q)},0);this._clickedDown=!1};m.prototype._handleDblClick=function(n,q){var u=this;n=this._translateToComponentSpace(n);this._doubleClicking=!0;this._onDoubleClickCallbacks.callCallbacks(n,q);setTimeout(function(){return u._doubleClicking=!1},0)};m._pointsEqual=function(n,q){return n.x===q.x&&n.y===q.y};m.prototype.onClick=function(n){this._onClickCallbacks.add(n);return this};m.prototype.offClick=function(n){this._onClickCallbacks.delete(n);return this};m.prototype.onDoubleClick=function(n){this._onDoubleClickCallbacks.add(n)};
m.prototype.offDoubleClick=function(n){this._onDoubleClickCallbacks.delete(n);return this};return m}(h(15).Interaction);f.Click=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(13),l=h(0);d=function(p){function m(){var n=null!==p&&p.apply(this,arguments)||this;n._dragging=!1;n._constrainedToComponent=!0;n._mouseFilter=m._DEFAULT_MOUSE_FILTER;
n._dragStartCallbacks=new l.CallbackSet;n._dragCallbacks=new l.CallbackSet;n._dragEndCallbacks=new l.CallbackSet;n._mouseDownCallback=function(q,u){return n._startDrag(q,u)};n._mouseMoveCallback=function(q){return n._doDrag(q)};n._mouseUpCallback=function(q,u){return n._endDrag(q,u)};n._touchStartCallback=function(q,u,x){return n._startDrag(u[q[0]],x)};n._touchMoveCallback=function(q,u){return n._doDrag(u[q[0]])};n._touchEndCallback=function(q,u,x){return n._endDrag(u[q[0]],x)};return n}k(m,p);m.prototype._anchor=
function(n){p.prototype._anchor.call(this,n);this._mouseDispatcher=t.Mouse.getDispatcher(this._componentAttachedTo);this._mouseDispatcher.onMouseDown(this._mouseDownCallback);this._mouseDispatcher.onMouseMove(this._mouseMoveCallback);this._mouseDispatcher.onMouseUp(this._mouseUpCallback);this._touchDispatcher=t.Touch.getDispatcher(this._componentAttachedTo);this._touchDispatcher.onTouchStart(this._touchStartCallback);this._touchDispatcher.onTouchMove(this._touchMoveCallback);this._touchDispatcher.onTouchEnd(this._touchEndCallback)};
m.prototype._unanchor=function(){p.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};m.prototype._translateAndConstrain=
function(n){n=this._translateToComponentSpace(n);return this._constrainedToComponent?{x:l.Math.clamp(n.x,0,this._componentAttachedTo.width()),y:l.Math.clamp(n.y,0,this._componentAttachedTo.height())}:n};m.prototype._startDrag=function(n,q){q instanceof MouseEvent&&!this._mouseFilter(q)||(n=this._translateToComponentSpace(n),this._isInsideComponent(n)&&(q.preventDefault(),this._dragging=!0,this._dragOrigin=n,this._dragStartCallbacks.callCallbacks(this._dragOrigin)))};m.prototype._doDrag=function(n){this._dragging&&
this._dragCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(n))};m.prototype._endDrag=function(n,q){q instanceof MouseEvent&&0!==q.button||!this._dragging||(this._dragging=!1,this._dragEndCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(n)))};m.prototype.constrainedToComponent=function(){this._constrainedToComponent=!1};m.prototype.mouseFilter=function(n){0!==arguments.length&&(this._mouseFilter=n)};m.prototype.onDragStart=function(n){this._dragStartCallbacks.add(n)};
m.prototype.offDragStart=function(n){this._dragStartCallbacks.delete(n)};m.prototype.onDrag=function(n){this._dragCallbacks.add(n);return this};m.prototype.offDrag=function(n){this._dragCallbacks.delete(n)};m.prototype.onDragEnd=function(n){this._dragEndCallbacks.add(n)};m.prototype.offDragEnd=function(n){this._dragEndCallbacks.delete(n)};return m}(h(15).Interaction);d._DEFAULT_MOUSE_FILTER=function(p){return 0===p.button};f.Drag=d},function(d,f,h){var k=this&&this.__extends||function(u,x){function A(){this.constructor=
u}for(var y in x)x.hasOwnProperty(y)&&(u[y]=x[y]);u.prototype=null===x?Object.create(x):(A.prototype=x.prototype,new A)},t=h(1),l=h(13),p=h(3),m=h(0),n=h(25);d=h(15);var q=h(26);h=function(u){function x(A,y){var w=u.call(this)||this;w._wheelFilter=function(){return!0};w._wheelCallback=function(C,G){return w._handleWheelEvent(C,G)};w._touchStartCallback=function(C,G){return w._handleTouchStart(C,G)};w._touchMoveCallback=function(C,G){return w._handlePinch(C,G)};w._touchEndCallback=function(C){return w._handleTouchEnd(C)};
w._touchCancelCallback=function(C){return w._handleTouchEnd(C)};w._panEndCallbacks=new m.CallbackSet;w._zoomEndCallbacks=new m.CallbackSet;w._panZoomUpdateCallbacks=new m.CallbackSet;w._xScales=new m.Set;w._yScales=new m.Set;w._dragInteraction=new n.Drag;w._setupDragInteraction();w._touchIds=t.map();w._minDomainExtents=new m.Map;w._maxDomainExtents=new m.Map;w._minDomainValues=new m.Map;w._maxDomainValues=new m.Map;null!=A&&w.addXScale(A);null!=y&&w.addYScale(y);return w}k(x,u);x.prototype.dragInteraction=
function(){return this._dragInteraction};x.prototype.wheelFilter=function(A){0!==arguments.length&&(this._wheelFilter=A)};x.prototype.pan=function(A){var y=this;this.xScales().forEach(function(w){w.pan(y._constrainedTranslation(w,A.x))});this.yScales().forEach(function(w){w.pan(y._constrainedTranslation(w,A.y))});this._panZoomUpdateCallbacks.callCallbacks()};x.prototype.zoom=function(A,y,w){var C=this;void 0===w&&(w=!0);if(null!=y){var G=y.x;var D=y.y;w&&(this.xScales().forEach(function(B){B=C._constrainedZoom(B,
A,G);G=B.centerPoint;A=B.zoomAmount}),this.yScales().forEach(function(B){B=C._constrainedZoom(B,A,D);D=B.centerPoint;A=B.zoomAmount}))}this.xScales().forEach(function(B){var I=B.range();B.zoom(A,null==G?(I[1]+I[0])/2:G)});this.yScales().forEach(function(B){var I=B.range();B.zoom(A,null==D?(I[1]+I[0])/2:D)});this._panZoomUpdateCallbacks.callCallbacks();return{zoomAmount:A,centerValue:{centerX:G,centerY:D}}};x.prototype._anchor=function(A){u.prototype._anchor.call(this,A);this._dragInteraction.attachTo(A);
this._mouseDispatcher=l.Mouse.getDispatcher(this._componentAttachedTo);this._mouseDispatcher.onWheel(this._wheelCallback);this._touchDispatcher=l.Touch.getDispatcher(this._componentAttachedTo);this._touchDispatcher.onTouchStart(this._touchStartCallback);this._touchDispatcher.onTouchMove(this._touchMoveCallback);this._touchDispatcher.onTouchEnd(this._touchEndCallback);this._touchDispatcher.onTouchCancel(this._touchCancelCallback)};x.prototype._unanchor=function(){u.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()};x.prototype._handleTouchStart=function(A,y){for(var w=0;w<A.length&&2>this._touchIds.size();w++){var C=A[w];this._touchIds.set(C.toString(),this._translateToComponentSpace(y[C]))}};
x.prototype._handlePinch=function(A,y){var w=this;if(!(2>this._touchIds.size())){var C=this._touchIds.values();if(this._isInsideComponent(this._translateToComponentSpace(C[0]))&&this._isInsideComponent(this._translateToComponentSpace(C[1]))){var G=x._pointDistance(C[0],C[1]);if(0!==G){A.forEach(function(O){w._touchIds.has(O.toString())&&w._touchIds.set(O.toString(),w._translateToComponentSpace(y[O]))});A=this._touchIds.values();var D=x._pointDistance(A[0],A[1]);if(0!==D){var B=G/D,I=A.map(function(O,
H){return{x:(O.x-C[H].x)/B,y:(O.y-C[H].y)/B}});G=x.centerPoint(C[0],C[1]);G=this.zoom(B,G);A=G.centerValue;var N=G.zoomAmount;G=A.centerX;A=A.centerY;D=C.map(function(O,H){return{x:I[H].x*N+O.x,y:I[H].y*N+O.y}});this.pan({x:G-(D[0].x+D[1].x)/2,y:A-(D[0].y+D[1].y)/2})}}}}};x.centerPoint=function(A,y){return{x:(Math.min(A.x,y.x)+Math.max(A.x,y.x))/2,y:(Math.max(A.y,y.y)+Math.min(A.y,y.y))/2}};x._pointDistance=function(A,y){return Math.sqrt(Math.pow(Math.max(A.x,y.x)-Math.min(A.x,y.x),2)+Math.pow(Math.max(A.y,
y.y)-Math.min(A.y,y.y),2))};x.prototype._handleTouchEnd=function(A){var y=this;A.forEach(function(w){y._touchIds.remove(w.toString())});0<this._touchIds.size()&&this._zoomEndCallbacks.callCallbacks()};x.prototype._handleWheelEvent=function(A,y){this._wheelFilter(y)&&(A=this._translateToComponentSpace(A),this._isInsideComponent(A)&&(y.preventDefault(),this.zoom(Math.pow(2,(0!==y.deltaY?y.deltaY:y.deltaX)*(y.deltaMode?x._PIXELS_PER_LINE:1)*.002),A),this._zoomEndCallbacks.callCallbacks()))};x.prototype._constrainedZoom=
function(A,y,w){return q.constrainedZoom(A,y,w,this.minDomainExtent(A),this.maxDomainExtent(A),this.minDomainValue(A),this.maxDomainValue(A))};x.prototype._constrainedTranslation=function(A,y){return q.constrainedTranslation(A,y,this.minDomainValue(A),this.maxDomainValue(A))};x.prototype._setupDragInteraction=function(){var A=this;this._dragInteraction.constrainedToComponent();var y;this._dragInteraction.onDragStart(function(){return y=null});this._dragInteraction.onDrag(function(w,C){2<=A._touchIds.size()||
(A.pan({x:(null==y?w.x:y.x)-C.x,y:(null==y?w.y:y.y)-C.y}),y=C)});this._dragInteraction.onDragEnd(function(){return A._panEndCallbacks.callCallbacks()})};x.prototype._nonLinearScaleWithExtents=function(A){return null!=this.minDomainExtent(A)&&null!=this.maxDomainExtent(A)&&!(A instanceof p.Linear)&&!(A instanceof p.Time)};x.prototype.xScales=function(){var A=[];this._xScales.forEach(function(y){A.push(y)});return A};x.prototype.yScales=function(){var A=[];this._yScales.forEach(function(y){A.push(y)});
return A};x.prototype.addXScale=function(A){this._xScales.add(A)};x.prototype.removeXScale=function(A){this._xScales.delete(A);this._minDomainExtents.delete(A);this._maxDomainExtents.delete(A);this._minDomainValues.delete(A);this._maxDomainValues.delete(A);return this};x.prototype.addYScale=function(A){this._yScales.add(A)};x.prototype.removeYScale=function(A){this._yScales.delete(A);this._minDomainExtents.delete(A);this._maxDomainExtents.delete(A);this._minDomainValues.delete(A);this._maxDomainValues.delete(A);
return this};x.prototype.minDomainExtent=function(A){return this._minDomainExtents.get(A)};x.prototype.maxDomainExtent=function(A){return this._maxDomainExtents.get(A)};x.prototype.minDomainValue=function(A,y){if(null==y)return this._minDomainValues.get(A);this._minDomainValues.set(A,y);return this};x.prototype.maxDomainValue=function(A,y){if(null==y)return this._maxDomainValues.get(A);this._maxDomainValues.set(A,y);return this};x.prototype.setMinMaxDomainValuesTo=function(A){this._minDomainValues.delete(A);
this._maxDomainValues.delete(A);var y=A.getTransformationDomain(),w=y[1];this.minDomainValue(A,y[0]);this.maxDomainValue(A,w);return this};x.prototype.onPanEnd=function(A){this._panEndCallbacks.add(A)};x.prototype.offPanEnd=function(A){this._panEndCallbacks.delete(A);return this};x.prototype.onZoomEnd=function(A){this._zoomEndCallbacks.add(A)};x.prototype.offZoomEnd=function(A){this._zoomEndCallbacks.delete(A);return this};x.prototype.onPanZoomUpdate=function(A){this._panZoomUpdateCallbacks.add(A);
return this};x.prototype.offPanZoomUpdate=function(A){this._panZoomUpdateCallbacks.delete(A);return this};return x}(d.Interaction);h._PIXELS_PER_LINE=120;f.PanZoom=h},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(13),l=h(0);d=function(p){function m(){var n=null!==p&&p.apply(this,arguments)||this;n._overComponent=!1;n._pointerEnterCallbacks=
new l.CallbackSet;n._pointerMoveCallbacks=new l.CallbackSet;n._pointerExitCallbacks=new l.CallbackSet;n._mouseMoveCallback=function(q,u){return n._handleMouseEvent(q,u)};n._touchStartCallback=function(q,u,x){return n._handleTouchEvent(u[q[0]],x)};return n}k(m,p);m.prototype._anchor=function(n){p.prototype._anchor.call(this,n);this._mouseDispatcher=t.Mouse.getDispatcher(this._componentAttachedTo);this._mouseDispatcher.onMouseMove(this._mouseMoveCallback);this._touchDispatcher=t.Touch.getDispatcher(this._componentAttachedTo);
this._touchDispatcher.onTouchStart(this._touchStartCallback)};m.prototype._unanchor=function(){p.prototype._unanchor.call(this);this._mouseDispatcher.offMouseMove(this._mouseMoveCallback);this._mouseDispatcher=null;this._touchDispatcher.offTouchStart(this._touchStartCallback);this._touchDispatcher=null};m.prototype._handleMouseEvent=function(n,q){q=this._mouseDispatcher.eventInside(this._componentAttachedTo,q);this._handlePointerEvent(n,q)};m.prototype._handleTouchEvent=function(n,q){q=this._touchDispatcher.eventInside(this._componentAttachedTo,
q);this._handlePointerEvent(n,q)};m.prototype._handlePointerEvent=function(n,q){n=this._translateToComponentSpace(n);var u=this._isInsideComponent(n);u&&q?(this._overComponent||this._pointerEnterCallbacks.callCallbacks(n),this._pointerMoveCallbacks.callCallbacks(n)):this._overComponent&&this._pointerExitCallbacks.callCallbacks(n);this._overComponent=u&&q};m.prototype.onPointerEnter=function(n){this._pointerEnterCallbacks.add(n);return this};m.prototype.offPointerEnter=function(n){this._pointerEnterCallbacks.delete(n);
return this};m.prototype.onPointerMove=function(n){this._pointerMoveCallbacks.add(n)};m.prototype.offPointerMove=function(n){this._pointerMoveCallbacks.delete(n);return this};m.prototype.onPointerExit=function(n){this._pointerExitCallbacks.add(n)};m.prototype.offPointerExit=function(n){this._pointerExitCallbacks.delete(n);return this};return m}(h(15).Interaction);f.Pointer=d},function(d,f,h){var k=h(20);f.memThunk=function(){for(var t=[],l=0;l<arguments.length;l++)t[l]=arguments[l];var p=t.slice(0,
-1),m=k.memoize(t[t.length-1]);return function(){var n=this,q=p.map(function(u){return u.apply(n)});return m.apply(void 0,q)}}},function(d,f,h){var k=h(49);f.memoize=function(t){function l(){for(var u=[],x=0;x<arguments.length;x++)u[x]=arguments[x];if(n)return m;x=k.signArray(u);void 0===p||p.isDifferent(x)?(q&&console.log("cache miss! computing"),p=x,m=t.apply(this,u)):q&&console.log("cache hit!");return m}var p=void 0,m,n=!1,q=!1;l.doLocked=function(u){if(n)throw Error("Locking an already locked memoize function!");
n=!0;u=u.apply(this);n=!1;return u};l.logPerformance=function(u){void 0===u&&(u=!0);q=u;return this};return l}},function(d,f,h){var k=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&(n[x]=q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},t=h(3),l=h(0),p=h(27),m=h(2);d=function(n){function q(u){void 0===u&&(u="vertical");u=n.call(this,u)||this;u._clusterOffsets=new l.Map;return u}k(q,n);q.prototype._generateAttrToProjector=
function(){function u(){return y.rangeBand()}var x=this,A=n.prototype._generateAttrToProjector.call(this),y=this._makeInnerScale();A.width=this._isVertical?u:A.width;A.height=this._isVertical?A.height:u;var w=A.x,C=A.y;A.x=this._isVertical?function(G,D,B){return w(G,D,B)+x._clusterOffsets.get(B)}:function(G,D,B){return w(G,D,B)};A.y=this._isVertical?function(G,D,B){return C(G,D,B)}:function(G,D,B){return C(G,D,B)+x._clusterOffsets.get(B)};return A};q.prototype._updateClusterPosition=function(){var u=
this,x=this._makeInnerScale();this.datasets().forEach(function(A,y){return u._clusterOffsets.set(A,x.scale(String(y))-x.rangeBand()/2)})};q.prototype._makeInnerScale=function(){var u=new t.Category;u.domain(this.datasets().map(function(A,y){return String(y)}));var x=m.Plot._scaledAccessor(this.attr(p.Bar._BAR_THICKNESS_KEY));u.range([0,x(null,0,null)]);return u};q.prototype._getDataToDraw=function(){this._updateClusterPosition();return n.prototype._getDataToDraw.call(this)};return q}(p.Bar);f.ClusteredBar=
d},function(d,f,h){var k=this&&this.__extends||function(C,G){function D(){this.constructor=C}for(var B in G)G.hasOwnProperty(B)&&(C[B]=G[B]);C.prototype=null===G?Object.create(G):(D.prototype=G.prototype,new D)},t=h(1),l=h(5),p=h(7),m=h(8),n=h(3),q=h(0),u=h(44),x=h(45),A=h(6),y=h(35),w=h(2);d=function(C){function G(){var D=C.call(this)||this;D._startAngle=0;D._endAngle=2*Math.PI;D._labelFormatter=m.identity();D._labelsEnabled=!1;D.innerRadius(0);D.outerRadius(function(){var B=D._pieCenter();return Math.min(Math.max(D.width()-
B.x,B.x),Math.max(D.height()-B.y,B.y))});D.addClass("pie-plot");D.attr("fill",function(B,I){return String(I)},new n.Color);D._strokeDrawers=new q.Map;return D}k(G,C);G.prototype._setup=function(){var D=this;C.prototype._setup.call(this);this._strokeDrawers.forEach(function(B){return B.attachTo(D._renderArea)})};G.prototype.computeLayout=function(D,B,I){C.prototype.computeLayout.call(this,D,B,I);D=this._pieCenter();this._renderArea.attr("transform","translate("+D.x+","+D.y+")");D=Math.min(Math.max(this.width()-
D.x,D.x),Math.max(this.height()-D.y,D.y));null!=this.innerRadius().scale&&this.innerRadius().scale.range([0,D]);null!=this.outerRadius().scale&&this.outerRadius().scale.range([0,D]);return this};G.prototype.addDataset=function(D){C.prototype.addDataset.call(this,D)};G.prototype._addDataset=function(D){if(1===this.datasets().length)return q.Window.warn("Only one dataset is supported in Pie plots"),this;this._updatePieAngles();var B=new x.ArcOutlineSVGDrawer;this._isSetup&&B.attachTo(this._renderArea);
this._strokeDrawers.set(D,B);C.prototype._addDataset.call(this,D);return this};G.prototype.removeDataset=function(D){C.prototype.removeDataset.call(this,D)};G.prototype._removeDatasetNodes=function(D){C.prototype._removeDatasetNodes.call(this,D);this._strokeDrawers.get(D).remove()};G.prototype._removeDataset=function(D){C.prototype._removeDataset.call(this,D);this._startAngles=[];this._endAngles=[];return this};G.prototype.selections=function(D){var B=this;void 0===D&&(D=this.datasets());var I=C.prototype.selections.call(this,
D).nodes();D.forEach(function(N){N=B._strokeDrawers.get(N);null!=N&&I.push.apply(I,N.getVisualPrimitives())});return t.selectAll(I)};G.prototype._onDatasetUpdate=function(){C.prototype._onDatasetUpdate.call(this);this._updatePieAngles();this.render()};G.prototype._createDrawer=function(){return new A.ProxyDrawer(function(){return new u.ArcSVGDrawer},function(){y.warn("canvas renderer is not supported on Pie Plot!");return null})};G.prototype.entities=function(D){var B=this;void 0===D&&(D=this.datasets());
return C.prototype.entities.call(this,D).map(function(I){I.position.x+=B.width()/2;I.position.y+=B.height()/2;var N=t.select(B._strokeDrawers.get(I.dataset).getVisualPrimitiveAtIndex(I.index));I.strokeSelection=N;return I})};G.prototype.sectorValue=function(){return this._propertyBindings.get(G._SECTOR_VALUE_KEY)};G.prototype.innerRadius=function(D,B){if(null==D)return this._propertyBindings.get(G._INNER_RADIUS_KEY);this._bindProperty(G._INNER_RADIUS_KEY,D,B);this.render();return this};G.prototype.outerRadius=
function(D,B){if(null==D)return this._propertyBindings.get(G._OUTER_RADIUS_KEY);this._bindProperty(G._OUTER_RADIUS_KEY,D,B);this.render();return this};G.prototype.startAngle=function(D){if(null==D)return this._startAngle;this._startAngle=D;this._updatePieAngles();this.render();return this};G.prototype.endAngle=function(D){if(null==D)return this._endAngle;this._endAngle=D;this._updatePieAngles();this.render();return this};G.prototype.labelsEnabled=function(D){if(null==D)return this._labelsEnabled;
this._labelsEnabled=D;this.render();return this};G.prototype.labelFormatter=function(D){if(null==D)return this._labelFormatter;this._labelFormatter=D;this.render();return this};G.prototype.entitiesAt=function(D){var B=this.width()/2,I=this.height()/2;D=this._sliceIndexForPoint({x:D.x-B,y:D.y-I});return null==D?[]:[this.entities()[D]]};G.prototype._propertyProjectors=function(){var D=this,B=C.prototype._propertyProjectors.call(this),I=w.Plot._scaledAccessor(this.innerRadius()),N=w.Plot._scaledAccessor(this.outerRadius());
B.d=function(O,H,K){return t.arc().innerRadius(I(O,H,K)).outerRadius(N(O,H,K)).startAngle(D._startAngles[H]).endAngle(D._endAngles[H])(O,H)};return B};G.prototype._updatePieAngles=function(){if(null!=this.sectorValue()&&0!==this.datasets().length){var D=w.Plot._scaledAccessor(this.sectorValue()),B=this.datasets()[0],I=this._getDataToDraw().get(B);I=t.pie().sort(null).startAngle(this._startAngle).endAngle(this._endAngle).value(function(N,O){return D(N,O,B)})(I);this._startAngles=I.map(function(N){return N.startAngle});
this._endAngles=I.map(function(N){return N.endAngle})}};G.prototype._pieCenter=function(){var D=this._startAngle<this._endAngle?this._startAngle:this._endAngle,B=this._startAngle<this._endAngle?this._endAngle:this._startAngle,I=Math.sin(D);D=Math.cos(D);var N=Math.sin(B);B=Math.cos(B);var O;if(0<=I&&0<=N)if(0<=D&&0<=B){var H=D;var K=O=0;var M=N}else 0>D&&0>B?(H=0,O=-B,K=0,M=I):0<=D&&0>B?(H=D,O=-B,K=0,M=I):0>D&&0<=B&&(K=O=H=1,M=Math.max(I,N));else 0<=I&&0>N?0<=D&&0<=B?(H=Math.max(D,B),M=K=O=1):0>D&&
0>B?(H=0,O=1,K=-N,M=I):0<=D&&0>B?(H=D,O=1,K=-N,M=1):0>D&&0<=B&&(H=B,K=O=1,M=I):0>I&&0<=N?0<=D&&0<=B?(H=1,O=0,K=-I,M=N):0>D&&0>B?(H=1,O=Math.max(-D,-B),M=K=1):0<=D&&0>B?(H=1,O=-B,K=-I,M=1):0>D&&0<=B&&(H=1,O=-D,K=1,M=N):0>I&&0>N&&(0<=D&&0<=B?(H=B,O=0,K=-I,M=0):0>D&&0>B?(H=0,O=-D,K=-N,M=0):0<=D&&0>B?(O=H=1,K=Math.max(D,-B),M=1):0>D&&0<=B&&(H=B,O=-D,K=1,M=0));return{x:0==K+M?0:K/(K+M)*this.width(),y:0==H+O?0:H/(H+O)*this.height()}};G.prototype._getDataToDraw=function(){var D=C.prototype._getDataToDraw.call(this);
if(0===this.datasets().length)return D;var B=w.Plot._scaledAccessor(this.sectorValue()),I=this.datasets()[0],N=D.get(I).filter(function(O,H){return G._isValidData(B(O,H,I))});D.set(I,N);return D};G._isValidData=function(D){return q.Math.isValidNumber(D)&&0<=D};G.prototype._pixelPoint=function(D,B,I){var N=w.Plot._scaledAccessor(this.sectorValue());if(!G._isValidData(N(D,B,I)))return{x:NaN,y:NaN};var O=w.Plot._scaledAccessor(this.innerRadius())(D,B,I);D=w.Plot._scaledAccessor(this.outerRadius())(D,
B,I);O=(O+D)/2;D=t.pie().sort(null).value(function(H,K){H=N(H,K,I);return G._isValidData(H)?H:0}).startAngle(this._startAngle).endAngle(this._endAngle)(I.data());B=(D[B].startAngle+D[B].endAngle)/2;return{x:O*Math.sin(B),y:-O*Math.cos(B)}};G.prototype._additionalPaint=function(D){var B=this;this._renderArea.select(".label-area").remove();this._labelsEnabled&&q.Window.setTimeout(function(){return B._drawLabels()},D);var I=this._generateStrokeDrawSteps(),N=this._getDataToDraw();this.datasets().forEach(function(O){var H=
w.Plot.applyDrawSteps(I,O);B._strokeDrawers.get(O).draw(N.get(O),H)})};G.prototype._generateStrokeDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new p.Null}]};G.prototype._sliceIndexForPoint=function(D){var B=Math.sqrt(Math.pow(D.x,2)+Math.pow(D.y,2)),I=Math.acos(-D.y/B);0>D.x&&(I=2*Math.PI-I);for(D=0;D<this._startAngles.length;D++)if(this._startAngles[D]<I&&this._endAngles[D]>I){var N=D;break}if(void 0!==N){D=this.datasets()[0];var O=D.data()[N];I=this.innerRadius().accessor(O,
N,D);D=this.outerRadius().accessor(O,N,D);if(B>I&&B<D)return N}return null};G.prototype._drawLabels=function(){var D=this,B=this._getAttrToProjector(),I=this._renderArea.append("g").classed("label-area",!0),N=new l.SvgContext(I.node()),O=new l.CacheMeasurer(N),H=new l.Writer(O,N),K=this.datasets()[0];this._getDataToDraw().get(K).forEach(function(M,L){var Q=D.sectorValue().accessor(M,L,K);if(q.Math.isValidNumber(Q)){Q=D._labelFormatter(Q,M,L,K);var T=O.measure(Q),X=(D._endAngles[L]+D._startAngles[L])/
2,aa=D.outerRadius().accessor(M,L,K);D.outerRadius().scale&&(aa=D.outerRadius().scale.scale(aa));var la=D.innerRadius().accessor(M,L,K);D.innerRadius().scale&&(la=D.innerRadius().scale.scale(la));la=(aa+la)/2;aa=Math.sin(X)*la-T.width/2;la=-Math.cos(X)*la-T.height/2;var Z=[{x:aa,y:la},{x:aa,y:la+T.height},{x:aa+T.width,y:la},{x:aa+T.width,y:la+T.height}];(X=Z.every(function(ba){return Math.abs(ba.x)<=D.width()/2&&Math.abs(ba.y)<=D.height()/2}))&&(X=Z.map(function(ba){return D._sliceIndexForPoint(ba)}).every(function(ba){return ba===
L}));M=B.fill(M,L,K);M=1.6*q.Color.contrast("white",M)<q.Color.contrast("black",M);aa=I.append("g").attr("transform","translate("+aa+","+la+")");aa.classed(M?"dark-label":"light-label",!0);aa.style("visibility",X?"inherit":"hidden");H.write(Q,T.width,T.height,{xAlign:"center",yAlign:"center"},aa.node())}})};return G}(w.Plot);d._INNER_RADIUS_KEY="inner-radius";d._OUTER_RADIUS_KEY="outer-radius";d._SECTOR_VALUE_KEY="sector-value";f.Pie=d},function(d,f,h){var k=this&&this.__extends||function(y,w){function C(){this.constructor=
y}for(var G in w)w.hasOwnProperty(G)&&(y[G]=w[G]);y.prototype=null===w?Object.create(w):(C.prototype=w.prototype,new C)},t=h(1),l=h(5),p=h(7),m=h(14),n=h(6),q=h(34),u=h(3),x=h(0),A=h(2);d=function(y){function w(){var C=y.call(this)||this;C._labelsEnabled=!1;C._label=null;C.animator("rectangles",new p.Null);C.addClass("rectangle-plot");C.attr("fill",(new u.Color).range()[0]);return C}k(w,y);w.prototype._createDrawer=function(){return new n.ProxyDrawer(function(){return new q.RectangleSVGDrawer},function(C){return new m.RectangleCanvasDrawer(C)})};
w.prototype._generateAttrToProjector=function(){var C=this,G=y.prototype._generateAttrToProjector.call(this),D=A.Plot._scaledAccessor(this.x()),B=G[w._X2_KEY],I=A.Plot._scaledAccessor(this.y()),N=G[w._Y2_KEY],O=this.x().scale,H=this.y().scale;null!=B?(G.width=function(K,M,L){return Math.abs(B(K,M,L)-D(K,M,L))},G.x=function(K,M,L){return Math.min(B(K,M,L),D(K,M,L))}):(G.width=function(){return C._rectangleWidth(O)},G.x=function(K,M,L){return D(K,M,L)-.5*G.width(K,M,L)});null!=N?(G.height=function(K,
M,L){return Math.abs(N(K,M,L)-I(K,M,L))},G.y=function(K,M,L){return Math.max(N(K,M,L),I(K,M,L))-G.height(K,M,L)}):(G.height=function(){return C._rectangleWidth(H)},G.y=function(K,M,L){return I(K,M,L)-.5*G.height(K,M,L)});delete G[w._X2_KEY];delete G[w._Y2_KEY];return G};w.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:this._getAnimator("rectangles")}]};w.prototype._filterForProperty=function(C){return"x2"===C?y.prototype._filterForProperty.call(this,
"x"):"y2"===C?y.prototype._filterForProperty.call(this,"y"):y.prototype._filterForProperty.call(this,C)};w.prototype.x=function(C,G,D){if(null==C)return y.prototype.x.call(this);null==G?y.prototype.x.call(this,C):y.prototype.x.call(this,C,G,D);null!=G&&(D=(C=this.x2())&&C.accessor,null!=D&&this._bindProperty(w._X2_KEY,D,G,C.postScale));G instanceof u.Category&&G.innerPadding(0).outerPadding(0);return this};w.prototype.x2=function(){return this._propertyBindings.get(w._X2_KEY)};w.prototype.y=function(C,
G,D){if(null==C)return y.prototype.y.call(this);null==G?y.prototype.y.call(this,C):y.prototype.y.call(this,C,G,D);null!=G&&(D=(C=this.y2())&&C.accessor,null!=D&&this._bindProperty(w._Y2_KEY,D,G,C.postScale));G instanceof u.Category&&G.innerPadding(0).outerPadding(0);return this};w.prototype.y2=function(){return this._propertyBindings.get(w._Y2_KEY)};w.prototype.entitiesAt=function(C){var G=this._getAttrToProjector();return this.entities().filter(function(D){var B=D.datum,I=D.index,N=D.dataset;D=G.x(B,
I,N);var O=G.y(B,I,N),H=G.width(B,I,N);B=G.height(B,I,N);return D<=C.x&&C.x<=D+H&&O<=C.y&&C.y<=O+B})};w.prototype._entityBounds=function(C){return this._entityBBox(C.datum,C.index,C.dataset,this._getAttrToProjector())};w.prototype._entityBBox=function(C,G,D,B){return{x:B.x(C,G,D),y:B.y(C,G,D),width:B.width(C,G,D),height:B.height(C,G,D)}};w.prototype.label=function(C){if(null==C)return this._label;this._label=C;this.render();return this};w.prototype.labelsEnabled=function(C){if(null==C)return this._labelsEnabled;
this._labelsEnabled=C;this.render();return this};w.prototype._propertyProjectors=function(){var C=y.prototype._propertyProjectors.call(this);null!=this.x2()&&(C.x2=A.Plot._scaledAccessor(this.x2()));null!=this.y2()&&(C.y2=A.Plot._scaledAccessor(this.y2()));return C};w.prototype._pixelPoint=function(C,G,D){var B=this._getAttrToProjector(),I=B.x(C,G,D),N=B.y(C,G,D),O=B.width(C,G,D);C=B.height(C,G,D);return{x:I+O/2,y:N+C/2}};w.prototype._rectangleWidth=function(C){if(C instanceof u.Category)return C.rangeBand();
var G=C===this.x().scale?this.x().accessor:this.y().accessor,D=t.set(x.Array.flatten(this.datasets().map(function(N){return N.data().map(function(O,H){return G(O,H,N).valueOf()})}))).values().map(function(N){return+N}),B=x.Math.min(D,0);D=x.Math.max(D,0);var I=C.scale(B);return(C.scale(D)-I)/Math.abs(D-B)};w.prototype._getDataToDraw=function(){var C=new x.Map,G=this._getAttrToProjector();this.datasets().forEach(function(D){var B=D.data().map(function(I,N){return x.Math.isValidNumber(G.x(I,N,D))&&
x.Math.isValidNumber(G.y(I,N,D))&&x.Math.isValidNumber(G.width(I,N,D))&&x.Math.isValidNumber(G.height(I,N,D))?I:null});C.set(D,B)});return C};w.prototype._additionalPaint=function(C){var G=this;this._renderArea.selectAll(".label-area").remove();this._labelsEnabled&&null!=this.label()&&x.Window.setTimeout(function(){return G._drawLabels()},C)};w.prototype._drawLabels=function(){var C=this,G=this._getDataToDraw();this.datasets().forEach(function(D,B){return C._drawLabel(G,D,B)})};w.prototype._drawLabel=
function(C,G,D){var B=this,I=this._getAttrToProjector(),N=this._renderArea.append("g").classed("label-area",!0),O=new l.SvgContext(N.node()),H=new l.CacheMeasurer(O),K=new l.Writer(H,O);O=this.x().scale.range();var M=this.y().scale.range(),L=Math.min.apply(null,O),Q=Math.max.apply(null,O),T=Math.min.apply(null,M),X=Math.max.apply(null,M);C.get(G).forEach(function(aa,la){if(null!=aa){var Z=""+B.label()(aa,la,G),ba=H.measure(Z),ea=I.x(aa,la,G),ca=I.y(aa,la,G),ka=I.width(aa,la,G),Y=I.height(aa,la,G);
ba.height<=Y&&ba.width<=ka&&(Y=(Y-ba.height)/2,ea+=(ka-ba.width)/2,ca+=Y,ka={min:ea,max:ea+ba.width},Y={min:ca,max:ca+ba.height},ka.min<L||ka.max>Q||Y.min<T||Y.max>X||B._overlayLabel(ka,Y,la,D,C)||(aa=I.fill(aa,la,G),aa=1.6*x.Color.contrast("white",aa)<x.Color.contrast("black",aa),ea=N.append("g").attr("transform","translate("+ea+","+ca+")"),ea.classed(aa?"dark-label":"light-label",!0),K.write(Z,ba.width,ba.height,{xAlign:"center",yAlign:"center"},ea.node())))}})};w.prototype._overlayLabel=function(C,
G,D,B,I){for(var N=this._getAttrToProjector(),O=this.datasets(),H=B;H<O.length;H++)for(var K=O[H],M=I.get(K),L=H===B?D+1:0;L<M.length;L++)if(x.DOM.intersectsBBox(C,G,this._entityBBox(M[L],L,K,N)))return!0;return!1};return w}(h(16).XYPlot);d._X2_KEY="x2";d._Y2_KEY="y2";f.Rectangle=d},function(d,f,h){var k=this&&this.__extends||function(y,w){function C(){this.constructor=y}for(var G in w)w.hasOwnProperty(G)&&(y[G]=w[G]);y.prototype=null===w?Object.create(w):(C.prototype=w.prototype,new C)},t=h(31),
l=h(6),p=h(48),m=h(7),n=h(14),q=h(3),u=h(0),x=h(19),A=h(2);d=function(y){function w(){var C=y.call(this)||this;C.addClass("scatter-plot");var G=new m.Easing;G.startDelay(5);G.stepDuration(250);G.maxTotalDuration(A.Plot._ANIMATION_MAX_DURATION);C.animator(x.Animator.MAIN,G);C.attr("opacity",.6);C.attr("fill",(new q.Color).range()[0]);C.size(6);var D=t.circle();C.symbol(function(){return D});return C}k(w,y);w.prototype._buildLightweightPlotEntities=function(C){var G=this;return y.prototype._buildLightweightPlotEntities.call(this,
C).map(function(D){var B=A.Plot._scaledAccessor(G.size())(D.datum,D.index,D.dataset);D.diameter=B;return D})};w.prototype._createDrawer=function(C){var G=this;return new l.ProxyDrawer(function(){return new p.SymbolSVGDrawer},function(D){return new n.CanvasDrawer(D,p.makeSymbolCanvasDrawStep(C,function(){return A.Plot._scaledAccessor(G.symbol())},function(){return A.Plot._scaledAccessor(G.size())}))})};w.prototype.size=function(C,G){if(null==C)return this._propertyBindings.get(w._SIZE_KEY);this._bindProperty(w._SIZE_KEY,
C,G);this.render();return this};w.prototype.symbol=function(C){if(null==C)return this._propertyBindings.get(w._SYMBOL_KEY);this._propertyBindings.set(w._SYMBOL_KEY,{accessor:C});this.render();return this};w.prototype._generateDrawSteps=function(){var C=[];if(this._animateOnNextRender()){var G=this._getAttrToProjector(),D=A.Plot._scaledAccessor(this.symbol());G.d=function(B,I,N){return D(B,I,N)(0)(null)};C.push({attrToProjector:G,animator:this._getAnimator(x.Animator.RESET)})}C.push({attrToProjector:this._getAttrToProjector(),
animator:this._getAnimator(x.Animator.MAIN)});return C};w.prototype._propertyProjectors=function(){var C=y.prototype._propertyProjectors.call(this),G=A.Plot._scaledAccessor(this.x()),D=A.Plot._scaledAccessor(this.y());C.x=G;C.y=D;C.transform=function(B,I,N){return"translate("+G(B,I,N)+","+D(B,I,N)+")"};C.d=this._constructSymbolGenerator();return C};w.prototype._constructSymbolGenerator=function(){var C=A.Plot._scaledAccessor(this.symbol()),G=A.Plot._scaledAccessor(this.size());return function(D,B,
I){return C(D,B,I)(G(D,B,I))(null)}};w.prototype._entityBounds=function(C){return{x:C.position.x-C.diameter/2,y:C.position.y-C.diameter/2,width:C.diameter,height:C.diameter}};w.prototype._entityVisibleOnPlot=function(C,G){var D={min:G.topLeft.x,max:G.bottomRight.x};G={min:G.topLeft.y,max:G.bottomRight.y};C=this._entityBounds(C);return u.DOM.intersectsBBox(D,G,C)};w.prototype.entitiesAt=function(C){var G=A.Plot._scaledAccessor(this.x()),D=A.Plot._scaledAccessor(this.y()),B=A.Plot._scaledAccessor(this.size());
return this.entities().filter(function(I){var N=I.datum,O=I.index,H=I.dataset;I=G(N,O,H);var K=D(N,O,H);N=B(N,O,H);return I-N/2<=C.x&&C.x<=I+N/2&&K-N/2<=C.y&&C.y<=K+N/2})};return w}(h(16).XYPlot);d._SIZE_KEY="size";d._SYMBOL_KEY="symbol";f.Scatter=d},function(d,f,h){var k=this&&this.__extends||function(u,x){function A(){this.constructor=u}for(var y in x)x.hasOwnProperty(y)&&(u[y]=x[y]);u.prototype=null===x?Object.create(x):(A.prototype=x.prototype,new A)},t=h(7),l=h(6),p=h(47),m=h(3),n=h(35),q=h(2);
d=function(u){function x(){var A=u.call(this)||this;A.addClass("segment-plot");A.attr("stroke",(new m.Color).range()[0]);A.attr("stroke-width","2px");return A}k(x,u);x.prototype._createDrawer=function(){return new l.ProxyDrawer(function(){return new p.SegmentSVGDrawer},function(){n.warn("canvas renderer is not supported on Segment Plot!");return null})};x.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new t.Null}]};x.prototype._filterForProperty=
function(A){return"x2"===A?u.prototype._filterForProperty.call(this,"x"):"y2"===A?u.prototype._filterForProperty.call(this,"y"):u.prototype._filterForProperty.call(this,A)};x.prototype.x=function(A,y){if(null==A)return u.prototype.x.call(this);null==y?u.prototype.x.call(this,A):(u.prototype.x.call(this,A,y),A=(A=this.x2())&&A.accessor,null!=A&&this._bindProperty(x._X2_KEY,A,y));return this};x.prototype.x2=function(){return this._propertyBindings.get(x._X2_KEY)};x.prototype.y=function(A,y){if(null==
A)return u.prototype.y.call(this);null==y?u.prototype.y.call(this,A):(u.prototype.y.call(this,A,y),A=(A=this.y2())&&A.accessor,null!=A&&this._bindProperty(x._Y2_KEY,A,y));return this};x.prototype.y2=function(){return this._propertyBindings.get(x._Y2_KEY)};x.prototype._propertyProjectors=function(){var A=u.prototype._propertyProjectors.call(this);A.x1=q.Plot._scaledAccessor(this.x());A.x2=null==this.x2()?q.Plot._scaledAccessor(this.x()):q.Plot._scaledAccessor(this.x2());A.y1=q.Plot._scaledAccessor(this.y());
A.y2=null==this.y2()?q.Plot._scaledAccessor(this.y()):q.Plot._scaledAccessor(this.y2());return A};x.prototype.entitiesAt=function(A){A=this.entityNearest(A);return null!=A?[A]:[]};x.prototype.entitiesIn=function(A,y){if(null==y){var w={min:A.topLeft.x,max:A.bottomRight.x};A={min:A.topLeft.y,max:A.bottomRight.y}}else w=A,A=y;return this._entitiesIntersecting(w,A)};x.prototype._entitiesIntersecting=function(A,y){var w=this,C=[],G=this._getAttrToProjector();this.entities().forEach(function(D){w._lineIntersectsBox(D,
A,y,G)&&C.push(D)});return C};x.prototype._lineIntersectsBox=function(A,y,w,C){var G=this,D=C.x1(A.datum,A.index,A.dataset),B=C.x2(A.datum,A.index,A.dataset),I=C.y1(A.datum,A.index,A.dataset);A=C.y2(A.datum,A.index,A.dataset);if(y.min<=D&&D<=y.max&&w.min<=I&&I<=w.max||y.min<=B&&B<=y.max&&w.min<=A&&A<=w.max)return!0;var N={x:D,y:I},O={x:B,y:A},H=[{x:y.min,y:w.min},{x:y.min,y:w.max},{x:y.max,y:w.max},{x:y.max,y:w.min}];return 0<H.filter(function(K,M){return 0!==M?G._lineIntersectsSegment(N,O,K,H[M-
1])&&G._lineIntersectsSegment(K,H[M-1],N,O):!1}).length};x.prototype._lineIntersectsSegment=function(A,y,w,C){function G(D,B,I){return(B.x-D.x)*(I.y-B.y)-(B.y-D.y)*(I.x-B.x)}return 0>G(A,y,w)*G(A,y,C)};return x}(h(16).XYPlot);d._X2_KEY="x2";d._Y2_KEY="y2";f.Segment=d},function(d,f,h){var k=this&&this.__extends||function(q,u){function x(){this.constructor=q}for(var A in u)u.hasOwnProperty(A)&&(q[A]=u[A]);q.prototype=null===u?Object.create(u):(x.prototype=u.prototype,new x)},t=h(1),l=h(7),p=h(20),m=
h(0);d=h(50);var n=h(2);h=function(q){function u(){var x=q.call(this)||this;x._stackingResult=p.memThunk(function(){return x.datasets()},function(){return x.x().accessor},function(){return x.y().accessor},function(){return x._stackingOrder},function(A,y,w,C){return m.Stacking.stack(A,y,w,C)});x._stackedExtent=p.memThunk(x._stackingResult,function(){return x.x().accessor},function(){return x._filterForProperty("y")},function(A,y,w){return m.Stacking.stackedExtent(A,y,w)});x._baselineValue=0;x._stackingOrder=
"bottomup";x.addClass("stacked-area-plot");x.attr("fill-opacity",1);x._baselineValueProvider=function(){return[x._baselineValue]};x.croppedRenderingEnabled(!1);return x}k(u,q);u.prototype.croppedRenderingEnabled=function(x){return null==x?q.prototype.croppedRenderingEnabled.call(this):x?(m.Window.warn("Warning: Stacked Area Plot does not support cropped rendering."),this):q.prototype.croppedRenderingEnabled.call(this,x)};u.prototype._getAnimator=function(){return new l.Null};u.prototype._setup=function(){q.prototype._setup.call(this);
this._baseline=this._renderArea.append("line").classed("baseline",!0)};u.prototype.x=function(x,A){if(null==x)return q.prototype.x.call(this);null==A?q.prototype.x.call(this,x):q.prototype.x.call(this,x,A);this._checkSameDomain();return this};u.prototype.y=function(x,A){if(null==x)return q.prototype.y.call(this);null==A?q.prototype.y.call(this,x):q.prototype.y.call(this,x,A);this._checkSameDomain();return this};u.prototype.stackingOrder=function(x){if(null==x)return this._stackingOrder;this._stackingOrder=
x;this._onDatasetUpdate();return this};u.prototype.downsamplingEnabled=function(){return q.prototype.downsamplingEnabled.call(this)};u.prototype._additionalPaint=function(){var x=this.y().scale.scale(this._baselineValue);x={x1:0,y1:x,x2:this.width(),y2:x};this._getAnimator("baseline").animate(this._baseline,x)};u.prototype._updateYScale=function(){var x=this.y();x=x&&x.scale;null!=x&&(x.addPaddingExceptionsProvider(this._baselineValueProvider),x.addIncludedValuesProvider(this._baselineValueProvider))};
u.prototype._onDatasetUpdate=function(){this._checkSameDomain();q.prototype._onDatasetUpdate.call(this);return this};u.prototype.getExtentsForProperty=function(x){return"y"===x?[this._stackedExtent()]:q.prototype.getExtentsForProperty.call(this,x)};u.prototype._checkSameDomain=function(){if(this._projectorsReady()){var x=this.datasets(),A=this.x().accessor,y=x.map(function(C){return t.set(C.data().map(function(G,D){return A(G,D,C).toString()})).values()}),w=u._domainKeys(x,A);y.some(function(C){return C.length!==
w.length})&&m.Window.warn("the domains across the datasets are not the same. Plot may produce unintended behavior.")}};u._domainKeys=function(x,A){var y=t.set();x.forEach(function(w){w.data().forEach(function(C,G){y.add(A(C,G,w))})});return y.values()};u.prototype._propertyProjectors=function(){function x(D,B,I){return m.Stacking.normalizeKey(C(D,B,I))}var A=this,y=q.prototype._propertyProjectors.call(this),w=this.y().accessor,C=this.x().accessor,G=this._stackingResult();y.d=this._constructAreaProjector(n.Plot._scaledAccessor(this.x()),
function(D,B,I){return A.y().scale.scale(+w(D,B,I)+G.get(I).get(x(D,B,I)).offset)},function(D,B,I){return A.y().scale.scale(G.get(I).get(x(D,B,I)).offset)});return y};u.prototype._pixelPoint=function(x,A,y){var w=q.prototype._pixelPoint.call(this,x,A,y),C=this.x().accessor(x,A,y);x=this.y().accessor(x,A,y);y=this.y().scale.scale(+x+this._stackingResult().get(y).get(m.Stacking.normalizeKey(C)).offset);return{x:w.x,y}};return u}(d.Area);f.StackedArea=h},function(d,f,h){var k=this&&this.__extends||function(u,
x){function A(){this.constructor=u}for(var y in x)x.hasOwnProperty(y)&&(u[y]=x[y]);u.prototype=null===x?Object.create(x):(A.prototype=x.prototype,new A)},t=h(5),l=h(8),p=h(20),m=h(0),n=h(27),q=h(2);d=function(u){function x(A){void 0===A&&(A="vertical");var y=u.call(this,A)||this;y._extremaFormatter=l.identity();y._stackingResult=p.memThunk(function(){return y.datasets()},function(){return y.position().accessor},function(){return y.length().accessor},function(){return y._stackingOrder},function(w,
C,G,D){return m.Stacking.stack(w,C,G,D)});y._stackedExtent=p.memThunk(y._stackingResult,function(){return y.position().accessor},function(){return y._filterForProperty(y._isVertical?"y":"x")},function(w,C,G){return m.Stacking.stackedExtent(w,C,G)});y.addClass("stacked-bar-plot");y._stackingOrder="bottomup";return y}k(x,u);x.prototype.stackingOrder=function(A){if(null==A)return this._stackingOrder;this._stackingOrder=A;this._onDatasetUpdate();return this};x.prototype.extremaFormatter=function(A){if(0===
arguments.length)return this._extremaFormatter;this._extremaFormatter=A;this.render();return this};x.prototype._setup=function(){u.prototype._setup.call(this);this._labelArea=this._renderArea.append("g").classed(n.Bar._LABEL_AREA_CLASS,!0);var A=new t.SvgContext(this._labelArea.node());this._measurer=new t.CacheMeasurer(A);this._writer=new t.Writer(this._measurer,A)};x.prototype._drawLabels=function(){function A(O,H){var K=w._generateAttrToProjector(),M=w.width(),L=w.height();O.forEach(function(Q){if(Q.extent!==
C){var T=w.extremaFormatter()(Q.extent),X=w._measurer.measure(T),aa=Q.stackedDatum,la=aa.originalDatum,Z=aa.originalIndex;aa=aa.originalDataset;w._isDatumOnScreen(K,M,L,la,Z,aa)&&(la=q.Plot._scaledAccessor(w.attr(n.Bar._BAR_THICKNESS_KEY))(la,Z,aa),Z=D.scale(Q.extent),Q=w._getPositionAttr(G.scale(Q.axisValue),la)+la/2,Q=H(w._isVertical?{x:Q,y:Z}:{x:Z,y:Q},X,la),T=y(T,{topLeft:Q,bottomRight:{x:Q.x+X.width,y:Q.y+X.height}},la),N.push(T))}})}function y(O,H,K){var M=H.topLeft,L=M.x,Q=M.y;M=H.bottomRight.x-
H.topLeft.x;H=H.bottomRight.y-H.topLeft.y;K=w._isVertical?M>K:H>K;K||(L=w._labelArea.append("g").attr("transform","translate("+L+", "+Q+")"),L.classed("stacked-bar-label",!0),w._writer.write(O,M,H,{xAlign:"center",yAlign:"center"},L.node()));return K}var w=this;u.prototype._drawLabels.call(this);this._labelArea.selectAll("g").remove();var C=+this.baselineValue(),G=this.position().scale,D=this.length().scale,B=m.Stacking.stackedExtents(this._stackingResult()),I=B.minimumExtents,N=[];A(B.maximumExtents,
function(O,H){var K=w._isVertical?H.width:H.height;H=w._isVertical?H.height:H.width;return{x:w._isVertical?O.x-K/2:O.x+x._EXTREMA_LABEL_MARGIN_FROM_BAR,y:w._isVertical?O.y-H:O.y-K/2}});A(I,function(O,H){var K=w._isVertical?H.width:H.height;H=w._isVertical?H.height:H.width;return{x:w._isVertical?O.x-K/2:O.x-H,y:w._isVertical?O.y+x._EXTREMA_LABEL_MARGIN_FROM_BAR:O.y-K/2}});N.some(function(O){return O})&&this._labelArea.selectAll("g").remove()};x.prototype._generateAttrToProjector=function(){function A(M,
L,Q){return 0>+O(M,L,Q)?C(M,L,Q):w(M,L,Q)}function y(M,L,Q){return Math.abs(w(M,L,Q)-C(M,L,Q))}function w(M,L,Q){return N.scale(+O(M,L,Q)+K.get(Q).get(G(M,L,Q)).offset)}function C(M,L,Q){return N.scale(K.get(Q).get(G(M,L,Q)).offset)}function G(M,L,Q){return m.Stacking.normalizeKey(H(M,L,Q))}var D=this,B=u.prototype._generateAttrToProjector.call(this),I=this._isVertical?"y":"x",N=this.length().scale,O=this.length().accessor,H=this.position().accessor,K=this._stackingResult();B[this._isVertical?"height":
"width"]=y;B[I]=function(M,L,Q){return D._isVertical?A(M,L,Q):A(M,L,Q)-y(M,L,Q)};return B};x.prototype.getExtentsForProperty=function(A){return A===(this._isVertical?"y":"x")?[this._stackedExtent()]:u.prototype.getExtentsForProperty.call(this,A)};x.prototype.invalidateCache=function(){u.prototype.invalidateCache.call(this);this._measurer.reset()};return x}(n.Bar);d._EXTREMA_LABEL_MARGIN_FROM_BAR=5;f.StackedBar=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=
p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(0);d=h(27);var l=h(2);h=function(p){function m(){var n=p.call(this)||this;n._connectorsEnabled=!1;n.addClass("waterfall-plot");return n}k(m,p);m.prototype.connectorsEnabled=function(n){if(null==n)return this._connectorsEnabled;this._connectorsEnabled=n;return this};m.prototype.total=function(n){if(null==n)return this._propertyBindings.get(m._TOTAL_KEY);this._bindProperty(m._TOTAL_KEY,
n,null);return this};m.prototype._additionalPaint=function(n){var q=this;this._connectorArea.selectAll("line").remove();this._connectorsEnabled&&t.Window.setTimeout(function(){return q._drawConnectors()},n)};m.prototype._createNodesForDataset=function(n){n=p.prototype._createNodesForDataset.call(this,n);this._connectorArea=this._renderArea.append("g").classed(m._CONNECTOR_AREA_CLASS,!0);return n};m.prototype.getExtentsForProperty=function(n){return"y"===n?[this._extent]:p.prototype.getExtentsForProperty.call(this,
n)};m.prototype._generateAttrToProjector=function(){var n=this,q=p.prototype._generateAttrToProjector.call(this),u=this.y().scale,x=l.Plot._scaledAccessor(this.total());null==this.attr("y")&&(q.y=function(A,y,w){var C=n.y().accessor(A,y,w);if(x(A,y,w))return Math.min(u.scale(C),u.scale(0));A=n._subtotals[y];if(0===y)return 0>C?u.scale(A-C):u.scale(A);y=n._subtotals[y-1];return A>y?u.scale(A):u.scale(y)});null==this.attr("height")&&(q.height=function(A,y,w){var C=x(A,y,w);A=n.y().accessor(A,y,w);if(C)return Math.abs(u.scale(A)-
u.scale(0));C=n._subtotals[y];if(0===y)return Math.abs(u.scale(C)-u.scale(C-A));y=n._subtotals[y-1];return Math.abs(u.scale(C)-u.scale(y))});q["class"]=function(A,y,w){var C="";null!=n.attr("class")&&(C=n.attr("class").accessor(A,y,w)+" ");if(x(A,y,w))return C+m._BAR_TOTAL_CLASS;A=n.y().accessor(A,y,w);return C+(0<A?m._BAR_GROWTH_CLASS:m._BAR_DECLINE_CLASS)};return q};m.prototype._onDatasetUpdate=function(){this._updateSubtotals();p.prototype._onDatasetUpdate.call(this);return this};m.prototype._calculateSubtotalsAndExtent=
function(n){var q=this,u=Number.MAX_VALUE,x=Number.MIN_VALUE,A=0,y=!1;n.data().forEach(function(w,C){var G=q.y().accessor(w,C,n);(w=q.total().accessor(w,C,n))&&0!==C||(A+=G);q._subtotals.push(A);A<u&&(u=A);A>x&&(x=A);w&&(G<u&&(u=G),G>x&&(x=G));if(!y&&w){C=G-A;for(G=0;G<q._subtotals.length;G++)q._subtotals[G]+=C;y=!0;A+=C;u+=C;x+=C}});this._extent=[u,x]};m.prototype._drawConnectors=function(){for(var n=this._getAttrToProjector(),q=this.datasets()[0],u=1;u<q.data().length;u++){var x=u-1,A=q.data()[u],
y=q.data()[x];y=n.x(y,x,q);var w=n.x(A,u,q)+n.width(A,u,q),C=n.y(A,u,q);if(0<this._subtotals[u]&&this._subtotals[u]>this._subtotals[x]||0>this._subtotals[u]&&this._subtotals[u]>=this._subtotals[x])C=n.y(A,u,q)+n.height(A,u,q);this._connectorArea.append("line").classed(m._CONNECTOR_CLASS,!0).attr("x1",y).attr("x2",w).attr("y1",C).attr("y2",C)}};m.prototype._updateSubtotals=function(){var n=this.datasets();0<n.length&&(n=n[n.length-1],this._subtotals=[],this._calculateSubtotalsAndExtent(n))};return m}(d.Bar);
h._BAR_DECLINE_CLASS="waterfall-decline";h._BAR_GROWTH_CLASS="waterfall-growth";h._BAR_TOTAL_CLASS="waterfall-total";h._CONNECTOR_CLASS="connector";h._CONNECTOR_AREA_CLASS="connector-area";h._TOTAL_KEY="total";f.Waterfall=h},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(1),l=h(0);d=function(p){function m(n){var q=p.call(this)||this;
switch(n){case null:case void 0:null==m._plottableColorCache&&(m._plottableColorCache=m._getPlottableColors());n=t.scaleOrdinal().range(m._plottableColorCache);break;case "Category10":case "category10":case "10":n=t.scaleOrdinal(t.schemeCategory10);break;case "Category20":case "category20":case "20":n=t.scaleOrdinal(t.schemeCategory20);break;case "Category20b":case "category20b":case "20b":n=t.scaleOrdinal(t.schemeCategory20b);break;case "Category20c":case "category20c":case "20c":n=t.scaleOrdinal(t.schemeCategory20c);
break;default:throw Error("Unsupported ColorScale type");}q._d3Scale=n;return q}k(m,p);m.prototype.extentOfValues=function(n){return l.Array.uniq(n)};m.prototype._getExtent=function(){return l.Array.uniq(this._getAllIncludedValues())};m.invalidateColorCache=function(){m._plottableColorCache=null};m._getPlottableColors=function(){for(var n=[],q=t.select("body").append("plottable-color-tester"),u=l.Color.colorTest(q,""),x=0,A=l.Color.colorTest(q,"plottable-colors-0");null!=A&&x<this._MAXIMUM_COLORS_FROM_CSS&&
(A!==u||A!==n[n.length-1]);)n.push(A),x++,A=l.Color.colorTest(q,"plottable-colors-"+x);q.remove();return n};m.prototype.scale=function(n){var q=this._d3Scale(n);n=this.domain().indexOf(n);n=Math.floor(n/this.range().length);return l.Color.lightenColor(q,Math.log(n*m._LOOP_LIGHTEN_FACTOR+1))};m.prototype._getDomain=function(){return this._backingScaleDomain()};m.prototype._backingScaleDomain=function(n){if(null==n)return this._d3Scale.domain();this._d3Scale.domain(n);return this};m.prototype._getRange=
function(){return this._d3Scale.range()};m.prototype._setRange=function(n){this._d3Scale.range(n)};return m}(h(17).Scale);d._LOOP_LIGHTEN_FACTOR=1.6;d._MAXIMUM_COLORS_FROM_CSS=256;f.Color=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(1),l=h(0);d=function(p){function m(n){void 0===n&&(n="linear");var q=p.call(this)||this;switch(n){case "linear":q._colorScale=
t.scaleLinear();break;case "log":q._colorScale=t.scaleLog();break;case "sqrt":q._colorScale=t.scaleSqrt();break;case "pow":q._colorScale=t.scalePow()}if(null==q._colorScale)throw Error("unknown QuantitativeScale scale type "+n);q.range(m.REDS);return q}k(m,p);m.prototype.extentOfValues=function(n){n=t.extent(n);return null==n[0]||null==n[1]?[]:n};m.prototype._d3InterpolatedScale=function(){return this._colorScale.range([0,1]).interpolate(this._interpolateColors())};m.prototype._interpolateColors=
function(){var n=this._colorRange;if(2>n.length)throw Error("Color scale arrays must have at least two elements.");return function(){return function(q){q=Math.max(0,Math.min(1,q));q*=n.length-1;var u=Math.floor(q),x=q-u;return t.interpolateLab(n[u],n[Math.ceil(q)])(x)}}};m.prototype._resetScale=function(){this._d3Scale=this._d3InterpolatedScale();this._autoDomainIfAutomaticMode();this._dispatchUpdate()};m.prototype.autoDomain=function(){var n=this._getAllIncludedValues();0<n.length&&this._setDomain([l.Math.min(n,
0),l.Math.max(n,0)])};m.prototype.scale=function(n){return this._d3Scale(n)};m.prototype._getDomain=function(){return this._backingScaleDomain()};m.prototype._backingScaleDomain=function(n){if(null==n)return this._d3Scale.domain();this._d3Scale.domain(n);return this};m.prototype._getRange=function(){return this._colorRange};m.prototype._setRange=function(n){this._colorRange=n;this._resetScale()};return m}(h(17).Scale);d.REDS="#FFFFFF #FFF6E1 #FEF4C0 #FED976 #FEB24C #FD8D3C #FC4E2A #E31A1C #B10026".split(" ");
d.BLUES="#FFFFFF #CCFFFF #A5FFFD #85F7FB #6ED3EF #55A7E0 #417FD0 #2545D3 #0B02E1".split(" ");d.POSNEG="#0B02E1 #2545D3 #417FD0 #55A7E0 #6ED3EF #85F7FB #A5FFFD #CCFFFF #FFFFFF #FFF6E1 #FEF4C0 #FED976 #FEB24C #FD8D3C #FC4E2A #E31A1C #B10026".split(" ");f.InterpolatedColor=d},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(1);d=function(l){function p(){var m=
l.call(this)||this;m._d3Scale=t.scaleLinear();return m}k(p,l);p.prototype._defaultExtent=function(){return[0,1]};p.prototype._expandSingleValueDomain=function(m){return m[0]===m[1]?[m[0]-1,m[1]+1]:m};p.prototype.scale=function(m){return this._d3Scale(m)};p.prototype.scaleTransformation=function(m){return this.scale(m)};p.prototype.invertedTransformation=function(m){return this.invert(m)};p.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)};p.prototype.getTransformationDomain=
function(){return this.domain()};p.prototype.setTransformationDomain=function(m){this.domain(m)};p.prototype._getDomain=function(){return this._backingScaleDomain()};p.prototype._backingScaleDomain=function(m){if(null==m)return this._d3Scale.domain();this._d3Scale.domain(m);return this};p.prototype._getRange=function(){return this._d3Scale.range()};p.prototype._setRange=function(m){this._d3Scale.range(m)};p.prototype.invert=function(m){return this._d3Scale.invert(m)};p.prototype.defaultTicks=function(){return this._d3Scale.ticks()};
p.prototype._niceDomain=function(m,n){return this._d3Scale.copy().domain(m).nice(n).domain()};return p}(h(11).QuantitativeScale);f.Linear=d},function(d,f,h){var k=this&&this.__extends||function(m,n){function q(){this.constructor=m}for(var u in n)n.hasOwnProperty(u)&&(m[u]=n[u]);m.prototype=null===n?Object.create(n):(q.prototype=n.prototype,new q)},t=h(1),l=h(0),p=h(3);d=function(m){function n(q){void 0===q&&(q=10);var u=m.call(this)||this;u._d3Scale=t.scaleLinear();u._base=q;u._pivot=u._base;u._setDomain(u._defaultExtent());
if(1>=q)throw Error("ModifiedLogScale: The base must be \x3e 1");return u}k(n,m);n.prototype._adjustedLog=function(q){var u=0>q?-1:1;q*=u;q<this._pivot&&(q+=(this._pivot-q)/this._pivot);q=Math.log(q)/Math.log(this._base);return q*u};n.prototype._invertedAdjustedLog=function(q){var u=0>q?-1:1;q=Math.pow(this._base,q*u);q<this._pivot&&(q=this._pivot*(q-1)/(this._pivot-1));return q*u};n.prototype.scale=function(q){return this._d3Scale(this._adjustedLog(q))};n.prototype.invert=function(q){return this._invertedAdjustedLog(this._d3Scale.invert(q))};
n.prototype.scaleTransformation=function(q){return this.scale(q)};n.prototype.invertedTransformation=function(q){return this.invert(q)};n.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)};n.prototype.getTransformationDomain=function(){return this.domain()};n.prototype.setTransformationDomain=function(q){this.domain(q)};n.prototype._getDomain=function(){return this._untransformedDomain};n.prototype._setDomain=function(q){this._untransformedDomain=q;m.prototype._setDomain.call(this,
[this._adjustedLog(q[0]),this._adjustedLog(q[1])])};n.prototype._backingScaleDomain=function(q){if(null==q)return this._d3Scale.domain();this._d3Scale.domain(q);return this};n.prototype.ticks=function(){function q(G,D,B){return[G,D,B].sort(function(I,N){return I-N})[1]}var u=l.Math.min(this._untransformedDomain,0),x=l.Math.max(this._untransformedDomain,0),A=q(u,x,-this._pivot),y=q(u,x,this._pivot);A=this._logTicks(-A,-u).map(function(G){return-G}).reverse();y=this._logTicks(y,x);var w=Math.max(u,
-this._pivot),C=Math.min(x,this._pivot);w=t.scaleLinear().domain([w,C]).ticks(this._howManyTicks(w,C));A=A.concat(w).concat(y);1>=A.length&&(A=t.scaleLinear().domain([u,x]).ticks());return A};n.prototype._logTicks=function(q,u){var x=this,A=this._howManyTicks(q,u);if(0===A)return[];var y=Math.floor(Math.log(q)/Math.log(this._base)),w=Math.ceil(Math.log(u)/Math.log(this._base));A=t.range(w,y,-Math.ceil((w-y)/A));y=t.range(this._base,1,-(this._base-1)).map(Math.floor);var C=l.Array.uniq(y);A=A.map(function(G){return C.map(function(D){return Math.pow(x._base,
G-1)*D})});return l.Array.flatten(A).filter(function(G){return q<=G&&G<=u}).sort(function(G,D){return G-D})};n.prototype._howManyTicks=function(q,u){var x=this._adjustedLog(l.Math.min(this._untransformedDomain,0)),A=this._adjustedLog(l.Math.max(this._untransformedDomain,0));return Math.ceil((this._adjustedLog(u)-this._adjustedLog(q))/(A-x)*p.ModifiedLog._DEFAULT_NUM_TICKS)};n.prototype._niceDomain=function(q){return q};n.prototype._defaultExtent=function(){return[0,this._base]};n.prototype._expandSingleValueDomain=
function(q){return q[0]===q[1]?(q=q[0],0<q?[q/this._base,q*this._base]:0===q?[-this._base,this._base]:[q*this._base,q/this._base]):q};n.prototype._getRange=function(){return this._d3Scale.range()};n.prototype._setRange=function(q){this._d3Scale.range(q)};n.prototype.defaultTicks=function(){return this._d3Scale.ticks()};return n}(h(11).QuantitativeScale);f.ModifiedLog=d},function(d,f,h){var k=h(0);f.intervalTickGenerator=function(t){if(0>=t)throw Error("interval must be positive number");return function(l){l=
l.domain();var p=Math.min(l[0],l[1]);l=Math.max(l[0],l[1]);var m=Math.ceil(p/t)*t;p=0===p%t?[]:[p];var n=k.Math.range(0,Math.floor((l-m)/t)+1).map(function(q){return m+q*t});return p.concat(n).concat(0===l%t?[]:[l])}};f.integerTickGenerator=function(){return function(t){var l=t.defaultTicks();return l.filter(function(p,m){return 0===p%1||0===m||m===l.length-1})}}},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);
p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(1),l=h(28);d=function(p){function m(){var n=p.call(this)||this;n._d3Scale=t.scaleTime();n.autoDomain();return n}k(m,p);m.prototype.tickInterval=function(n,q){void 0===q&&(q=1);var u=t.scaleTime();m.timeIntervalToD3Time(n).every(q);u.domain(this.domain());u.range(this.range());return u.ticks()};m.prototype._setDomain=function(n){if(n[1]<n[0])throw Error("Scale.Time domain values must be in chronological order");return p.prototype._setDomain.call(this,
n)};m.prototype._defaultExtent=function(){return[new Date("1970-01-01"),new Date("1970-01-02")]};m.prototype._expandSingleValueDomain=function(n){var q=n[0].getTime(),u=n[1].getTime();return q===u?(n=new Date(q),n.setDate(n.getDate()-1),u=new Date(u),u.setDate(u.getDate()+1),[n,u]):n};m.prototype.scale=function(n){return this._d3Scale(n)};m.prototype.scaleTransformation=function(n){return this.scale(new Date(n))};m.prototype.invertedTransformation=function(n){return this.invert(n).getTime()};m.prototype.getTransformationExtent=
function(){var n=this._getUnboundedExtent(!0);return[n[0].valueOf(),n[1].valueOf()]};m.prototype.getTransformationDomain=function(){var n=this.domain();return[n[0].valueOf(),n[1].valueOf()]};m.prototype.setTransformationDomain=function(n){this.domain([new Date(n[0]),new Date(n[1])])};m.prototype._getDomain=function(){return this._backingScaleDomain()};m.prototype._backingScaleDomain=function(n){if(null==n)return this._d3Scale.domain();this._d3Scale.domain(n);return this};m.prototype._getRange=function(){return this._d3Scale.range()};
m.prototype._setRange=function(n){this._d3Scale.range(n)};m.prototype.invert=function(n){return this._d3Scale.invert(n)};m.prototype.defaultTicks=function(){return this._d3Scale.ticks()};m.prototype._niceDomain=function(n){return this._d3Scale.copy().domain(n).nice().domain()};m.timeIntervalToD3Time=function(n){switch(n){case l.TimeInterval.second:return t.timeSecond;case l.TimeInterval.minute:return t.timeMinute;case l.TimeInterval.hour:return t.timeHour;case l.TimeInterval.day:return t.timeDay;
case l.TimeInterval.week:return t.timeWeek;case l.TimeInterval.month:return t.timeMonth;case l.TimeInterval.year:return t.timeYear;default:throw Error("TimeInterval specified does not exist: "+n);}};return m}(h(11).QuantitativeScale);f.Time=d},function(d,f,h){var k=h(1),t=Array;f.add=function(l,p){if(l.length!==p.length)throw Error("attempted to add arrays of unequal length");return l.map(function(m,n){return l[n]+p[n]})};f.uniq=function(l){var p=k.set(),m=[];l.forEach(function(n){p.has(String(n))||
(p.add(String(n)),m.push(n))});return m};f.flatten=function(l){return t.prototype.concat.apply([],l)};f.createFilledArray=function(l,p){for(var m=[],n=0;n<p;n++)m[n]="function"===typeof l?l(n):l;return m}},function(d,f){d=function(){function h(k,t,l){this.maxIndex=this.minIndex=this.exitIndex=this.entryIndex=k;this.bucketValue=t;this.maxValue=this.minValue=l}h.prototype.isInBucket=function(k){return k==this.bucketValue};h.prototype.addToBucket=function(k,t){k<this.minValue&&(this.minValue=k,this.minIndex=
t);k>this.maxValue&&(this.maxValue=k,this.maxIndex=t);this.exitIndex=t};h.prototype.getUniqueIndices=function(){var k=[this.entryIndex,this.maxIndex,this.minIndex,this.exitIndex];return k.filter(function(t,l){return 0==l||t!=k[l-1]})};return h}();f.Bucket=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){return null!==
t&&t.apply(this,arguments)||this}k(l,t);l.prototype.callCallbacks=function(){for(var p=this,m=[],n=0;n<arguments.length;n++)m[n]=arguments[n];this.forEach(function(q){q.apply(p,m)});return this};return l}(h(58).Set);f.CallbackSet=d},function(d,f,h){function k(p){function m(u){u/=255;return.03928>=u?u/12.92:l.pow((u+.055)/1.055,2.4)}var n=t.rgb(p);p=m(n.r);var q=m(n.g);n=m(n.b);return.2126*p+.7152*q+.0722*n}var t=h(1),l=Math;f.contrast=function(p,m){p=k(p)+.05;m=k(m)+.05;return p>m?p/m:m/p};f.lightenColor=
function(p,m){return t.color(p).brighter(m).rgb().toString()};f.colorTest=function(p,m){p.classed(m,!0);var n=p.style("background-color");if("transparent"===n)return null;n=/\((.+)\)/.exec(n);if(!n)return null;n=n[1].split(",").map(function(q){q=+q;var u=q.toString(16);return 16>q?"0"+u:u});if(4===n.length&&"00"===n[3])return null;n="#"+n.join("");p.classed(m,!1);return n}},function(d,f,h){var k=h(1),t=h(57);d=function(){function l(){this._entities=[];this._rtree=new t.RTree;this._tree=k.quadtree().x(function(p){return Math.floor(p.position.x)}).y(function(p){return Math.floor(p.position.y)})}
l.prototype.addAll=function(p,m,n){(x=this._entities).push.apply(x,p);if(void 0!==n)for(n=t.RTreeBounds.bounds(n),x=0;x<p.length;x++){var q=p[x],u=t.RTreeBounds.entityBounds(m(q));t.RTreeBounds.isBoundsOverlapBounds(n,u)&&(this._tree.add(q),this._rtree.insert(u,q))}else for(this._tree.addAll(p),x=0;x<p.length;x++)q=p[x],u=t.RTreeBounds.entityBounds(m(q)),this._rtree.insert(u,q);var x};l.prototype.entityNearest=function(p){return this._tree.find(p.x,p.y)};l.prototype.entitiesInBounds=function(p){return this._rtree.intersect(t.RTreeBounds.entityBounds(p))};
l.prototype.entitiesInXBounds=function(p){return this._rtree.intersectX(t.RTreeBounds.entityBounds(p))};l.prototype.entitiesInYBounds=function(p){return this._rtree.intersectY(t.RTreeBounds.entityBounds(p))};l.prototype.entities=function(){return this._entities};return l}();f.EntityStore=d},function(d,f,h){var k=h(56);d=function(){function t(){"function"===typeof window.Map?this._es6Map=new window.Map:this._keyValuePairs=[]}t.prototype.set=function(l,p){if(k.isNaN(l))throw Error("NaN may not be used as a key to the Map");
if(null!=this._es6Map)return this._es6Map.set(l,p),this;for(var m=0;m<this._keyValuePairs.length;m++)if(this._keyValuePairs[m].key===l)return this._keyValuePairs[m].value=p,this;this._keyValuePairs.push({key:l,value:p});return this};t.prototype.get=function(l){if(null!=this._es6Map)return this._es6Map.get(l);for(var p=0;p<this._keyValuePairs.length;p++)if(this._keyValuePairs[p].key===l)return this._keyValuePairs[p].value};t.prototype.has=function(l){if(null!=this._es6Map)return this._es6Map.has(l);
for(var p=0;p<this._keyValuePairs.length;p++)if(this._keyValuePairs[p].key===l)return!0;return!1};t.prototype.forEach=function(l,p){var m=this;null!=this._es6Map?this._es6Map.forEach(function(n,q){return l.call(p,n,q,m)},p):this._keyValuePairs.forEach(function(n){l.call(p,n.value,n.key,m)})};t.prototype.delete=function(l){if(null!=this._es6Map)return this._es6Map.delete(l);for(var p=0;p<this._keyValuePairs.length;p++)if(this._keyValuePairs[p].key===l)return this._keyValuePairs.splice(p,1),!0;return!1};
return t}();f.Map=d},function(d,f){f.assign=function(){for(var h=[],k=0;k<arguments.length;k++)h[k]=arguments[k];k={};for(var t=0;t<h.length;t++)for(var l=h[t],p=0,m=Object.keys(l);p<m.length;p++){var n=m[p];k[n]=l[n]}return k}},function(d,f){d=function(){function h(){}h.prototype.split=function(k,t){for(var l=Math.ceil(k.length/2),p=0;p<l;p++)t[0].insert(k[p]);for(p=l;p<k.length;p++)t[1].insert(k[p])};return h}();f.SplitStrategyTrivial=d;d=function(){function h(){}h.prototype.split=function(k,t){k=
k.slice();for(this.chooseFirstSplit(k,t);0<k.length;)this.addNext(k,t)};h.prototype.chooseFirstSplit=function(k,t){for(var l=0,p=0,m=k.length-1,n=k.length-1,q=1;q<k.length-1;q++){var u=k[q];u.bounds.xl>k[m].bounds.xl?m=q:u.bounds.xh<k[l].bounds.xh&&(l=q);u.bounds.yl>k[n].bounds.yl?n=q:u.bounds.yh<k[p].bounds.yh&&(p=q)}p=Math.abs(k[l].bounds.xh-k[m].bounds.xl)>Math.abs(k[p].bounds.yh-k[n].bounds.yl)?[l,m]:[p,n];l=p[0];p=p[1];l===p&&(l=0,p=k.length-1);t[0].insert(k.splice(Math.max(l,p),1)[0]);t[1].insert(k.splice(Math.min(l,
p),1)[0])};h.prototype.addNext=function(k,t){for(var l=null,p=null,m=null,n=0;n<k.length;n++){var q=k[n],u=t[0].unionAreaDifference(q.bounds);q=t[1].unionAreaDifference(q.bounds);if(u<p||null==l)l=n,p=u,m=t[0];q<p&&(l=n,p=q,m=t[1])}m.insert(k.splice(l,1)[0])};return h}();f.SplitStrategyLinear=d},function(d,f,h){function k(m){return String(m)}var t=h(1),l=h(0);d=h(10);f.IStackingOrder=d.makeEnum(["topdown","bottomup"]);var p=Math;f.stack=function(m,n,q,u){void 0===u&&(u="bottomup");var x=t.map(),A=
t.map(),y=new l.Map;"topdown"===u&&(m=m.slice(),m.reverse());m.forEach(function(w){var C=new l.Map;w.data().forEach(function(G,D){var B=k(n(G,D,w)),I=+q(G,D,w),N=0<=I?x:A;if(N.has(B)){var O=N.get(B);N.set(B,O+I)}else O=0,N.set(B,I);C.set(B,{offset:O,value:I,axisValue:n(G,D,w),originalDatum:G,originalDataset:w,originalIndex:D})});y.set(w,C)});return y};f.stackedExtents=function(m){var n=new l.Map,q=new l.Map;m.forEach(function(u){u.forEach(function(x,A){var y=l.Math.max([x.offset+x.value,x.offset],
x.offset),w=l.Math.min([x.offset+x.value,x.offset],x.offset),C=x.axisValue;n.has(A)?n.get(A).extent<y&&n.set(A,{extent:y,axisValue:C,stackedDatum:x}):n.set(A,{extent:y,axisValue:C,stackedDatum:x});q.has(A)?q.get(A).extent>w&&q.set(A,{extent:w,axisValue:C,stackedDatum:x}):q.set(A,{extent:w,axisValue:C,stackedDatum:x})})});return{maximumExtents:n,minimumExtents:q}};f.stackedExtent=function(m,n,q){var u=[];m.forEach(function(A,y){y.data().forEach(function(w,C){if(null==q||q(w,C,y))w=A.get(k(n(w,C,y))),
u.push(w.value+w.offset)})});m=l.Math.max(u,0);var x=l.Math.min(u,0);return[p.min(x,0),p.max(0,m)]};f.normalizeKey=k},function(d,f,h){var k=h(0);f.getTranslator=function(l){l=l.root().rootElement().node();var p=l.__Plottable_ClientTranslator;null==p&&(p=new t(l),l.__Plottable_ClientTranslator=p);return p};var t=function(){function l(p){this._rootElement=p}l.prototype.computePosition=function(p,m){p={x:p,y:m};m=k.Math.getCumulativeTransform(this._rootElement);return null==m?p:k.Math.applyTransform(m,
p)};l.isEventInside=function(p,m){return k.DOM.contains(p.root().rootElement().node(),m.target)};return l}();f.Translator=t},function(d,f,h){Object.defineProperty(f,"__esModule",{value:!0});var k=h(124);h.d(f,"easeLinear",function(){return k.a});var t=h(126);h.d(f,"easeQuad",function(){return t.a});h.d(f,"easeQuadIn",function(){return t.b});h.d(f,"easeQuadOut",function(){return t.c});h.d(f,"easeQuadInOut",function(){return t.a});var l=h(121);h.d(f,"easeCubic",function(){return l.a});h.d(f,"easeCubicIn",
function(){return l.b});h.d(f,"easeCubicOut",function(){return l.c});h.d(f,"easeCubicInOut",function(){return l.a});var p=h(125);h.d(f,"easePoly",function(){return p.a});h.d(f,"easePolyIn",function(){return p.b});h.d(f,"easePolyOut",function(){return p.c});h.d(f,"easePolyInOut",function(){return p.a});var m=h(127);h.d(f,"easeSin",function(){return m.a});h.d(f,"easeSinIn",function(){return m.b});h.d(f,"easeSinOut",function(){return m.c});h.d(f,"easeSinInOut",function(){return m.a});var n=h(123);h.d(f,
"easeExp",function(){return n.a});h.d(f,"easeExpIn",function(){return n.b});h.d(f,"easeExpOut",function(){return n.c});h.d(f,"easeExpInOut",function(){return n.a});var q=h(120);h.d(f,"easeCircle",function(){return q.a});h.d(f,"easeCircleIn",function(){return q.b});h.d(f,"easeCircleOut",function(){return q.c});h.d(f,"easeCircleInOut",function(){return q.a});var u=h(119);h.d(f,"easeBounce",function(){return u.a});h.d(f,"easeBounceIn",function(){return u.b});h.d(f,"easeBounceOut",function(){return u.a});
h.d(f,"easeBounceInOut",function(){return u.c});var x=h(118);h.d(f,"easeBack",function(){return x.a});h.d(f,"easeBackIn",function(){return x.b});h.d(f,"easeBackOut",function(){return x.c});h.d(f,"easeBackInOut",function(){return x.a});var A=h(122);h.d(f,"easeElastic",function(){return A.a});h.d(f,"easeElasticIn",function(){return A.b});h.d(f,"easeElasticOut",function(){return A.a});h.d(f,"easeElasticInOut",function(){return A.c})},function(d,f,h){h.d(f,"b",function(){return k});h.d(f,"c",function(){return t});
h.d(f,"a",function(){return l});var k=function n(m){function q(u){return u*u*((m+1)*u-m)}m=+m;q.overshoot=n;return q}(1.70158),t=function q(n){function u(x){return--x*x*((n+1)*x+n)+1}n=+n;u.overshoot=q;return u}(1.70158),l=function u(q){function x(A){return(1>(A*=2)?A*A*((q+1)*A-q):(A-=2)*A*((q+1)*A+q)+2)/2}q=+q;x.overshoot=u;return x}(1.70158)},function(d,f){function h(y){return(y=+y)<k?A*y*y:y<l?A*(y-=t)*y+p:y<n?A*(y-=m)*y+q:A*(y-=u)*y+x}f.b=function(y){return 1-h(1-y)};f.a=h;f.c=function(y){return(1>=
(y*=2)?1-h(1-y):h(y-1)+1)/2};var k=4/11,t=6/11,l=8/11,p=.75,m=9/11,n=10/11,q=.9375,u=21/22,x=.984375,A=1/k/k},function(d,f){f.b=function(h){return 1-Math.sqrt(1-h*h)};f.c=function(h){return Math.sqrt(1- --h*h)};f.a=function(h){return(1>=(h*=2)?1-Math.sqrt(1-h*h):Math.sqrt(1-(h-=2)*h)+1)/2}},function(d,f){f.b=function(h){return h*h*h};f.c=function(h){return--h*h*h+1};f.a=function(h){return(1>=(h*=2)?h*h*h:(h-=2)*h*h+2)/2}},function(d,f,h){h.d(f,"b",function(){return t});h.d(f,"a",function(){return l});
h.d(f,"c",function(){return p});var k=2*Math.PI,t=function u(n,q){function x(y){return n*Math.pow(2,10*--y)*Math.sin((A-y)/q)}var A=Math.asin(1/(n=Math.max(1,n)))*(q/=k);x.amplitude=function(y){return u(y,q*k)};x.period=function(y){return u(n,y)};return x}(1,.3),l=function x(q,u){function A(w){return 1-q*Math.pow(2,-10*(w=+w))*Math.sin((w+y)/u)}var y=Math.asin(1/(q=Math.max(1,q)))*(u/=k);A.amplitude=function(w){return x(w,u*k)};A.period=function(w){return x(q,w)};return A}(1,.3),p=function A(u,x){function y(C){return(0>
(C=2*C-1)?u*Math.pow(2,10*C)*Math.sin((w-C)/x):2-u*Math.pow(2,-10*C)*Math.sin((w+C)/x))/2}var w=Math.asin(1/(u=Math.max(1,u)))*(x/=k);y.amplitude=function(C){return A(C,x*k)};y.period=function(C){return A(u,C)};return y}(1,.3)},function(d,f){f.b=function(h){return Math.pow(2,10*h-10)};f.c=function(h){return 1-Math.pow(2,-10*h)};f.a=function(h){return(1>=(h*=2)?Math.pow(2,10*h-10):2-Math.pow(2,10-10*h))/2}},function(d,f){f.a=function(h){return+h}},function(d,f,h){h.d(f,"b",function(){return k});h.d(f,
"c",function(){return t});h.d(f,"a",function(){return l});var k=function n(m){function q(u){return Math.pow(u,m)}m=+m;q.exponent=n;return q}(3),t=function q(n){function u(x){return 1-Math.pow(1-x,n)}n=+n;u.exponent=q;return u}(3),l=function u(q){function x(A){return(1>=(A*=2)?Math.pow(A,q):2-Math.pow(2-A,q))/2}q=+q;x.exponent=u;return x}(3)},function(d,f){f.b=function(h){return h*h};f.c=function(h){return h*(2-h)};f.a=function(h){return(1>=(h*=2)?h*h:--h*(2-h)+1)/2}},function(d,f){f.b=function(t){return 1-
Math.cos(t*k)};f.c=function(t){return Math.sin(t*k)};f.a=function(t){return(1-Math.cos(h*t))/2};var h=Math.PI,k=h/2},function(d,f,h){function k(l){return!0===t(l)&&"[object Object]"===Object.prototype.toString.call(l)}var t=h(129);d.exports=function(l){if(!1===k(l))return!1;l=l.constructor;if("function"!==typeof l)return!1;l=l.prototype;return!1===k(l)||!1===l.hasOwnProperty("isPrototypeOf")?!1:!0}},function(d){d.exports=function(f){return null!=f&&"object"===typeof f&&!1===Array.isArray(f)}},function(d,
f){d=function(){function h(k,t,l){void 0===t&&(t=10);void 0===l&&(l={});var p=this;this.ctx=k;this.lineHeight=t;this.style=l;this.createRuler=function(){return function(m){p.ctx.font=p.style.font;return{width:p.ctx.measureText(m).width,height:p.lineHeight}}};this.createPen=function(m,n,q){null==q&&(q=p.ctx);q.save();q.translate(n.translate[0],n.translate[1]);q.rotate(n.rotate*Math.PI/180);return p.createCanvasPen(q)};void 0===this.style.fill&&(this.style.fill="#444")}h.prototype.createCanvasPen=function(k){var t=
this;return{destroy:function(){k.restore()},write:function(l,p,m,n){k.textAlign=p;null!=t.style.font&&(k.font=t.style.font);null!=t.style.fill&&(k.fillStyle=t.style.fill,k.fillText(l,m,n));null!=t.style.stroke&&(k.strokeStyle=t.style.fill,k.strokeText(l,m,n))}}};return h}();f.CanvasContext=d},function(d,f){var h=function(){function k(){}k.append=function(t,l){for(var p=[],m=2;m<arguments.length;m++)p[m-2]=arguments[m];p=k.create.apply(k,[l].concat(p));t.appendChild(p);return p};k.create=function(t){for(var l=
[],p=1;p<arguments.length;p++)l[p-1]=arguments[p];p=document.createElementNS(k.SVG_NS,t);k.addClasses.apply(k,[p].concat(l));return p};k.addClasses=function(t){for(var l=[],p=1;p<arguments.length;p++)l[p-1]=arguments[p];l=l.filter(function(m){return null!=m});null!=t.classList?l.forEach(function(m){t.classList.add(m)}):t.setAttribute("class",l.join(" "))};k.getDimensions=function(t){if(t.getBBox)try{var l=t.getBBox();return{width:l.width,height:l.height}}catch(p){}return{height:0,width:0}};return k}();
h.SVG_NS="http://www.w3.org/2000/svg";f.SvgUtils=h;d=function(){function k(t,l,p){void 0===p&&(p=!1);var m=this;this.element=t;this.className=l;this.addTitleElement=p;this.createRuler=function(){var n=m.getTextElements(m.element),q=n.parentElement,u=n.containerElement,x=n.textElement;return function(A){q.appendChild(u);x.textContent=A;A=h.getDimensions(x);q.removeChild(u);return A}};this.createPen=function(n,q,u){null==u&&(u=m.element);u=h.append(u,"g","text-container",m.className);m.addTitleElement&&
(h.append(u,"title").textContent=n,u.setAttribute("title",n));n=h.append(u,"g","text-area");n.setAttribute("transform","translate("+q.translate[0]+","+q.translate[1]+")rotate("+(q.rotate+")"));return m.createSvgLinePen(n)}}k.prototype.setAddTitleElement=function(t){this.addTitleElement=t};k.prototype.createSvgLinePen=function(t){return{write:function(l,p,m,n){var q=h.append(t,"text","text-line");q.textContent=l;q.setAttribute("text-anchor",p);q.setAttribute("transform","translate("+m+","+n+")");q.setAttribute("y",
"-0.25em")}}};k.prototype.getTextElements=function(t){if("text"===t.tagName){var l=t.parentElement;null==l&&(l=t.parentNode);l.removeChild(t);return{containerElement:t,parentElement:l,textElement:t}}var p=t.querySelector("text");if(null!=p)return l=t.parentElement,null==l&&(l=t.parentNode),l.removeChild(t),{containerElement:t,parentElement:l,textElement:p};l=h.create("text",this.className);return{containerElement:l,parentElement:t,textElement:l}};return k}();f.SvgContext=d},function(d,f,h){var k=
this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(21),l=h(36);d=function(p){function m(n){var q=p.call(this,n)||this;q.dimCache=new t.Cache(function(u){return q._measureNotFromCache(u)});return q}k(m,p);m.prototype._measureNotFromCache=function(n){return p.prototype.measure.call(this,n)};m.prototype.measure=function(n){void 0===n&&(n=l.AbstractMeasurer.HEIGHT_TEXT);
return this.dimCache.get(n)};m.prototype.reset=function(){this.dimCache.clear();p.prototype.reset.call(this)};return m}(h(60).CacheCharacterMeasurer);f.CacheMeasurer=d},function(d,f,h){var k=h(59),t=h(62),l=h(64),p=h(66);d=function(){function m(n){this.context=n;this.measurer=new t.CacheMeasurer(this.context);this.wrapper=new l.Wrapper;this.writer=new p.Writer(this.measurer,this.context,this.wrapper)}m.svg=function(n,q,u){return new m(new k.SvgContext(n,q,u))};m.canvas=function(n,q,u){return new m(new k.CanvasContext(n,
q,u))};m.prototype.write=function(n,q,u,x,A){this.writer.write(n,q,u,x,A)};m.prototype.clearMeasurerCache=function(){this.measurer.reset()};return m}();f.Typesetter=d},function(d,f){d=function(){function h(k){this.cache={};this.compute=k}h.prototype.get=function(k){this.cache.hasOwnProperty(k)||(this.cache[k]=this.compute(k));return this.cache[k]};h.prototype.clear=function(){this.cache={};return this};return h}();f.Cache=d},function(d,f){f.Methods=function(){function h(){}h.arrayEq=function(k,t){if(null==
k||null==t)return k===t;if(k.length!==t.length)return!1;for(var l=0;l<k.length;l++)if(k[l]!==t[l])return!1;return!0};h.objEq=function(k,t){if(null==k||null==t)return k===t;var l=Object.keys(k).sort(),p=Object.keys(t).sort(),m=l.map(function(q){return k[q]}),n=p.map(function(q){return t[q]});return h.arrayEq(l,p)&&h.arrayEq(m,n)};h.strictEq=function(k,t){return k===t};h.defaults=function(k){for(var t=[],l=1;l<arguments.length;l++)t[l-1]=arguments[l];if(null==k)throw new TypeError("Cannot convert undefined or null to object");
var p=Object(k);t.forEach(function(m){if(null!=m)for(var n in m)Object.prototype.hasOwnProperty.call(m,n)&&(p[n]=m[n])});return p};return h}()},function(d,f){f.StringMethods=function(){function h(){}h.combineWhitespace=function(k){return k.replace(/[ \t]+/g," ")};h.isNotEmptyString=function(k){return k&&""!==k.trim()};h.trimStart=function(k,t){if(!k)return k;k=k.split("");var l=t?function(p){return p.split(t).some(h.isNotEmptyString)}:h.isNotEmptyString;return k.reduce(function(p,m){return l(p+m)?
p+m:p},"")};h.trimEnd=function(k,t){if(!k)return k;k=k.split("");k.reverse();k=h.trimStart(k.join(""),t).split("");k.reverse();return k.join("")};return h}()},function(d,f){d=function(){function h(){this.WordDividerRegExp=/\W/;this.WhitespaceRegExp=/\s/}h.prototype.tokenize=function(k){var t=this;return k.split("").reduce(function(l,p){return l.slice(0,-1).concat(t.shouldCreateNewToken(l[l.length-1],p))},[""])};h.prototype.shouldCreateNewToken=function(k,t){if(!k)return[t];var l=k[k.length-1];return this.WhitespaceRegExp.test(l)&&
this.WhitespaceRegExp.test(t)?[k+t]:this.WhitespaceRegExp.test(l)||this.WhitespaceRegExp.test(t)?[k,t]:this.WordDividerRegExp.test(l)||this.WordDividerRegExp.test(t)?l===t?[k+t]:[k,t]:[k+t]};return h}();f.Tokenizer=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){return t.apply(this,arguments)||this}k(l,t);l.prototype.wrap=
function(p,m,n,q){function u(D){return t.prototype.wrap.call(x,p,m,D,q)}var x=this;void 0===q&&(q=Infinity);if(1<p.split("\n").length)throw Error("SingleLineWrapper is designed to work only on single line");var A=u(n);if(2>A.noLines)return A;for(var y=0,w=0;w<l.NO_WRAP_ITERATIONS&&n>y;++w){var C=(n+y)/2,G=u(C);this.areSameResults(A,G)?(n=C,A=G):y=C}return A};l.prototype.areSameResults=function(p,m){return p.noLines===m.noLines&&p.truncatedText===m.truncatedText};return l}(h(65).Wrapper);d.NO_WRAP_ITERATIONS=
5;f.SingleLineWrapper=d},function(d,f,h){var k=h(21),t={textRotation:0,textShear:0,xAlign:"left",yAlign:"top"};d=function(){function l(p,m,n){this._measurer=p;this._penFactory=m;this._wrapper=n}l.prototype.measurer=function(p){this._measurer=p;return this};l.prototype.wrapper=function(p){this._wrapper=p;return this};l.prototype.penFactory=function(p){this._penFactory=p;return this};l.prototype.write=function(p,m,n,q,u){void 0===q&&(q={});q=k.Methods.defaults({},t,q);if(-1===l.SupportedRotation.indexOf(q.textRotation))throw Error("unsupported rotation - "+
q.textRotation+". Supported rotations are "+l.SupportedRotation.join(", "));if(null!=q.textShear&&-80>q.textShear||80<q.textShear)throw Error("unsupported shear angle - "+q.textShear+". Must be between -80 and 80");var x=45<Math.abs(Math.abs(q.textRotation)-90),A=x?m:n,y=x?n:m,w=q.textShear,C=w*Math.PI/180;x=this._measurer.measure().height;var G=x*Math.tan(C);A=A/Math.cos(C)-Math.abs(G);var D=y*Math.cos(C);y=k.StringMethods.combineWhitespace(p);y=(this._wrapper?this._wrapper.wrap(y,this._measurer,
A,D).wrappedText:y).split("\n");C=l.XOffsetFactor[q.xAlign]*A*Math.sin(C)-l.YOffsetFactor[q.yAlign]*(D-y.length*x);w=q.textRotation+w;switch(q.textRotation){case 90:m=[m+C,0];break;case -90:m=[-C,n];break;case 180:m=[m,n+C];break;default:m=[0,-C]}p=this._penFactory.createPen(p,{translate:m,rotate:w},u);this.writeLines(y,p,A,x,G,q.xAlign);null!=p.destroy&&p.destroy()};l.prototype.writeLines=function(p,m,n,q,u,x){p.forEach(function(A,y){m.write(A,l.AnchorConverter[x],(0<u?(y+1)*u:y*u)+n*l.XOffsetFactor[x],
(y+1)*q)})};return l}();d.SupportedRotation=[-90,0,180,90];d.AnchorConverter={center:"middle",left:"start",right:"end"};d.XOffsetFactor={center:.5,left:0,right:1};d.YOffsetFactor={bottom:1,center:.5,top:0};f.Writer=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}h(69);d=h(7);f.Animators=d;d=h(67);f.Axes=d;d=h(37);f.Components=d;d=h(23);f.Configs=d;d=h(8);f.Formatters=d;d=h(30);f.RenderController=d;d=h(39);f.RenderPolicies=d;d=h(31);f.SymbolFactories=d;d=h(13);f.Dispatchers=
d;d=h(14);f.Drawers=d;d=h(25);f.Interactions=d;d=h(19);f.Plots=d;d=h(3);f.Scales=d;d=h(0);f.Utils=d;k(h(22));d=h(28);f.TimeInterval=d.TimeInterval;k(h(4));k(h(29));k(h(38));d=h(68);f.version=d.version;k(h(24));k(h(6));k(h(15));k(h(40));k(h(16));k(h(2));k(h(11));k(h(17))}])});

//# sourceURL=build://vz-chart-helpers/plottable-interactions.js
var rg;
(function(b){function d(m){const n=[];for(;m&&m instanceof HTMLElement;)if(n.push(m),m.assignedSlot)m=m.assignedSlot;else if(m.parentElement)m=m.parentElement;else{const q=m.parentNode;m=q instanceof DocumentFragment?q.host:q!==m?q:null}return n}function f(m){var n=d(m);m=h;let q=null;for(const x of n){n=Plottable.Utils.DOM.getElementTransform(x);if(null!=n){var u=x.clientWidth/2;const A=x.clientHeight/2;m=Plottable.Utils.Math.multiplyTranslate(m,[u,A]);m=Plottable.Utils.Math.multiplyMatrix(m,Plottable.Utils.Math.invertMatrix(n));
m=Plottable.Utils.Math.multiplyTranslate(m,[-u,-A])}n=x.scrollLeft;u=x.scrollTop;if(null===q||x===q)n-=x.offsetLeft+x.clientLeft,u-=x.offsetTop+x.clientTop,q=x.offsetParent;m=Plottable.Utils.Math.multiplyTranslate(m,[n,u])}return m}const h=[1,0,0,1,0,0];class k extends Plottable.Utils.Translator{computePosition(m,n){m={x:m,y:n};n=f(this._rootElement);return null==n?m:Plottable.Utils.Math.applyTransform(n,m)}}class t extends Plottable.Dispatchers.Mouse{constructor(m){super(m);this._eventTarget=m.root().rootElement().node();
this._translator=new k(m.root().rootElement().node())}static getDispatcher(m){const n=m.root().rootElement();let q=n[t._DISPATCHER_KEY];q||(q=new t(m),n[t._DISPATCHER_KEY]=q);return q}}class l extends Plottable.Dispatchers.Touch{constructor(m){super(m);this._eventTarget=m.root().rootElement().node();this._translator=new k(m.root().rootElement().node())}static getDispatcher(m){const n=m.root().rootElement();let q=n[l._DISPATCHER_KEY];q||(q=new l(m),n[l._DISPATCHER_KEY]=q);return q}}Plottable.Interaction.prototype._isInsideComponent=
function(m){return 0<=m.x&&0<=m.y&&m.x<this._componentAttachedTo.width()&&m.y<this._componentAttachedTo.height()};class p extends Plottable.Interactions.Pointer{_anchor(){this._isAnchored=!0;this._mouseDispatcher=t.getDispatcher(this._componentAttachedTo);this._mouseDispatcher.onMouseMove(this._mouseMoveCallback);this._touchDispatcher=l.getDispatcher(this._componentAttachedTo);this._touchDispatcher.onTouchStart(this._touchStartCallback)}}b.PointerInteraction=p})(rg||(rg={}));

//# sourceURL=build://vz-chart-helpers/vz-chart-helpers.js
(function(b){function d(){let t=new Plottable.Scales.Linear;t.tickGenerator();let l=new Plottable.Axes.Numeric(t,"bottom");l.formatter(b.stepFormatter);return{scale:t,axis:l,accessor:p=>p.step}}function f(){let t=new Plottable.Scales.Time;return{scale:t,axis:new Plottable.Axes.Time(t,"bottom"),accessor:l=>l.wall_time}}function h(){let t=new Plottable.Scales.Linear;return{scale:t,axis:new Plottable.Axes.Numeric(t,"bottom"),accessor:b.relativeAccessor}}b.SYMBOLS_LIST=[{character:"\u25fc",method:Plottable.SymbolFactories.square},
{character:"\u25c6",method:Plottable.SymbolFactories.diamond},{character:"\u25b2",method:Plottable.SymbolFactories.triangle},{character:"\u2605",method:Plottable.SymbolFactories.star},{character:"\u271a",method:Plottable.SymbolFactories.cross}];let k;(function(t){t.STEP="step";t.RELATIVE="relative";t.WALL_TIME="wall_time"})(k=b.XType||(b.XType={}));b.Y_TOOLTIP_FORMATTER_PRECISION=4;b.STEP_FORMATTER_PRECISION=4;b.Y_AXIS_FORMATTER_PRECISION=3;b.TOOLTIP_Y_PIXEL_OFFSET=20;b.TOOLTIP_CIRCLE_SIZE=4;b.NAN_SYMBOL_SIZE=
6;b.multiscaleFormatter=function(t){return l=>{let p=Math.abs(l);1E-15>p&&(p=0);return(1E4<=p?d3.format("."+t+"~e"):0<p&&.01>p?d3.format("."+t+"~e"):d3.format("."+t+"~g"))(l)}};b.computeDomain=function(t,l){t=t.filter(n=>isFinite(n));if(0===t.length)return[-.1,1.1];l?(t=_.sortBy(t),l=d3.quantile(t,.05),t=d3.quantile(t,.95)):(l=d3.min(t),t=d3.max(t));let p,m=t-l;p=0===m?1.1*Math.abs(l)+1.1:.2*m;l=[0<=l&&l<m?-.1*t:l-p,t+p];return l=d3.scaleLinear().domain(l).nice().domain()};b.accessorize=function(t){return l=>
l[t]};b.stepFormatter=d3.format(`.${b.STEP_FORMATTER_PRECISION}~s`);b.stepX=d;b.timeFormatter=Plottable.Formatters.time("%a %b %e, %H:%M:%S");b.wallX=f;b.relativeAccessor=(t,l,p)=>{if(null!=t.relative)return t.relative;l=p.data();return(+t.wall_time-(0<l.length?+l[0].wall_time:0))/36E5};b.relativeFormatter=t=>{let l="",p=Math.floor(t/24);t-=24*p;p&&(l+=p+"d ");let m=Math.floor(t);t=60*(t-m);if(m||p)l+=m+"h ";let n=Math.floor(t);t=60*(t-n);if(n||m||p)l+=n+"m ";return l+Math.floor(t)+"s"};b.relativeX=
h;b.getXComponents=function(t){switch(t){case k.STEP:return d();case k.WALL_TIME:return f();case k.RELATIVE:return h();default:throw Error("invalid xType: "+t);}}})(rg||(rg={}));

//# sourceURL=build://vz-chart-helpers/vz-chart-tooltip.js
var Eh;
(function(b){let d;(function(h){h.AUTO="auto";h.BOTTOM="bottom";h.RIGHT="right"})(d=b.TooltipPosition||(b.TooltipPosition={}));const f={boxShadow:"0 1px 4px rgba(0, 0, 0, .3)",opacity:0,position:"fixed",willChange:"transform",zIndex:5};Polymer({is:"vz-chart-tooltip",_template:null,properties:{contentComponentName:String,position:{type:String,value:d.AUTO},minDistFromEdge:{type:Number,value:15}},ready(){this._tunnel=this._raf=this._styleCache=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(){window.cancelAnimationFrame(this._raf);this._styleCache=null;this._tunnel.style.opacity=0},updateAndPosition(h){window.cancelAnimationFrame(this._raf);this._raf=window.requestAnimationFrame(()=>{this.isAttached&&this._repositionImpl(h)})},
_repositionImpl(h){const k=this._tunnel;h=h.getBoundingClientRect();const t=k.getBoundingClientRect(),l=window.innerHeight,p=document.body.clientWidth,m=h.top,n=m+h.height,q=t.height+rg.TOOLTIP_Y_PIXEL_OFFSET;let u=null,x=Math.max(this.minDistFromEdge,h.left),A=null,y=m;this.position==d.RIGHT?x=h.right:(y=n+rg.TOOLTIP_Y_PIXEL_OFFSET,p<x+t.width+this.minDistFromEdge&&(x=null,A=this.minDistFromEdge));this.position==d.AUTO&&0<h.top-q&&l<h.top+h.height+q&&(y=null,u=l-m+rg.TOOLTIP_Y_PIXEL_OFFSET);h={opacity:1,
left:x?`${x}px`:null,right:A?`${A}px`:null,top:y?`${y}px`:null,bottom:u?`${u}px`:null};_.isEqual(this._styleCache,h)||(Object.assign(k.style,h),this._styleCache=h)},_createTunnel(){if(!this.contentComponentName)throw new RangeError("Require `contentComponentName` to be a name of a Polymer component");const h=document.createElement(this.contentComponentName);Object.assign(h.style,f);document.body.appendChild(h);return h},_removeTunnel(h){document.body.removeChild(h)}})})(Eh||(Eh={}));

//# sourceURL=build://vz-line-chart/dragZoomInteraction.js
var Fh;
(function(b){class d extends Plottable.Components.SelectionBoxLayer{constructor(f,h,k){super();this.easeFn=d3.easeCubicInOut;this._animationTime=750;this.xScale(f);this.yScale(h);this._dragInteraction=new Plottable.Interactions.Drag;this._doubleClickInteraction=new Plottable.Interactions.Click;this.setupCallbacks();this.unzoomMethod=k;this.onDetach(()=>{this._doubleClickInteraction.detachFrom();this._dragInteraction.detachFrom()});this.onAnchor(()=>{this._doubleClickInteraction.attachTo(this);this._dragInteraction.attachTo(this)})}interactionStart(f){this.onStart=
f}interactionEnd(f){this.onEnd=f}dragInteraction(){return this._dragInteraction}setupCallbacks(){let f=!1;this._dragInteraction.onDragStart(h=>{this.bounds({topLeft:h,bottomRight:h});this.onStart()});this._dragInteraction.onDrag((h,k)=>{this.bounds({topLeft:h,bottomRight:k});this.boxVisible(!0);f=!0});this._dragInteraction.onDragEnd((h,k)=>{this.boxVisible(!1);this.bounds({topLeft:h,bottomRight:k});if(f)this.zoom();else this.onEnd();f=!1});this._doubleClickInteraction.onDoubleClick(this.unzoom.bind(this))}animationTime(f){if(null==
f)return this._animationTime;if(0>f)throw Error("animationTime cannot be negative");this._animationTime=f;return this}ease(f){if("function"!==typeof f)throw Error("ease function must be a function");0===f(0)&&1===f(1)||Plottable.Utils.Window.warn("Easing function does not maintain invariant f(0)\x3d\x3d0 \x26\x26 f(1)\x3d\x3d1. Bad behavior may result.");this.easeFn=f;return this}zoom(){let f=this.xExtent()[0].valueOf(),h=this.xExtent()[1].valueOf(),k=this.yExtent()[1].valueOf(),t=this.yExtent()[0].valueOf();
f!==h&&k!==t&&this.interpolateZoom(f,h,k,t)}unzoom(){var f=this.xScale();f._domainMin=null;f._domainMax=null;f=f._getExtent();this.xScale().domain(f);this.unzoomMethod()}isZooming(f){this._dragInteraction.enabled(!f);this._doubleClickInteraction.enabled(!f)}interpolateZoom(f,h,k,t){let l=this.xScale().domain()[0].valueOf(),p=this.xScale().domain()[1].valueOf(),m=this.yScale().domain()[0].valueOf(),n=this.yScale().domain()[1].valueOf(),q=this.easeFn,u=(y,w,C)=>d3.interpolateNumber(y,w)(q(C));this.isZooming(!0);
let x=Date.now(),A=()=>{var y=Date.now()-x;y=0===this._animationTime?1:Math.min(1,y/this._animationTime);let w=u(l,f,y),C=u(p,h,y),G=u(m,k,y),D=u(n,t,y);this.xScale().domain([w,C]);this.yScale().domain([G,D]);1>y?Plottable.Utils.DOM.requestAnimationFramePolyfill(A):(this.onEnd(),this.isZooming(!1))};A()}}b.DragZoomLayer=d})(Fh||(Fh={}));

//# sourceURL=build://vz-line-chart2/panZoomDragLayer.js
var Gh;
(function(b){let d;(function(h){h[h.NONE=0]="NONE";h[h.DRAG_ZOOMING=1]="DRAG_ZOOMING";h[h.PANNING=2]="PANNING"})(d||(d={}));class f extends Plottable.Components.Group{constructor(h,k,t){super();this.state=d.NONE;this.panStartCallback=new Plottable.Utils.CallbackSet;this.panEndCallback=new Plottable.Utils.CallbackSet;this.panZoom=new Plottable.Interactions.PanZoom(h,k);this.panZoom.dragInteraction().mouseFilter(p=>f.isPanKey(p)&&0===p.button);this.panZoom.wheelFilter(this.canScrollZoom);this.dragZoomLayer=new Fh.DragZoomLayer(h,
k,t);this.dragZoomLayer.dragInteraction().mouseFilter(p=>!f.isPanKey(p)&&0===p.button);this.append(this.dragZoomLayer);const l=this.onWheel.bind(this);this.onAnchor(()=>{this._mouseDispatcher=Plottable.Dispatchers.Mouse.getDispatcher(this);this._mouseDispatcher.onWheel(l);this.panZoom.attachTo(this)});this.onDetach(()=>{this.panZoom.detachFrom();this._mouseDispatcher&&(this._mouseDispatcher.offWheel(l),this._mouseDispatcher=null)});this.panZoom.dragInteraction().onDragStart(()=>{this.state==d.NONE&&
this.setState(d.PANNING)});this.panZoom.dragInteraction().onDragEnd(()=>{this.state==d.PANNING&&this.setState(d.NONE)});this.dragZoomLayer.dragInteraction().onDragStart(()=>{this.state==d.NONE&&this.setState(d.DRAG_ZOOMING)});this.dragZoomLayer.dragInteraction().onDragEnd(()=>{this.state==d.DRAG_ZOOMING&&this.setState(d.NONE)})}onWheel(h,k){if(!this.canScrollZoom(k)&&(h=this.element(),h.select(".help").empty())){var t=h.append("div").classed("help",!0);t.append("span").text("Alt + Scroll to Zoom");
t.on("animationend",()=>void t.remove())}}static isPanKey(h){return!!h.altKey||!!h.shiftKey}canScrollZoom(h){return h.altKey}setState(h){if(this.state!=h){var k=this.state;this.state=h;this.root().removeClass(this.stateClassName(k));this.root().addClass(this.stateClassName(h));k==d.PANNING&&this.panEndCallback.callCallbacks();h==d.PANNING&&this.panStartCallback.callCallbacks()}}stateClassName(h){switch(h){case d.PANNING:return"panning";case d.DRAG_ZOOMING:return"drag-zooming";default:return""}}onPanStart(h){this.panStartCallback.add(h)}onPanEnd(h){this.panEndCallback.add(h)}onScrollZoom(h){this.panZoom.onZoomEnd(h)}onDragZoomStart(h){this.dragZoomLayer.interactionStart(h)}onDragZoomEnd(h){this.dragZoomLayer.interactionEnd(h)}}
b.PanZoomDragLayer=f})(Gh||(Gh={}));

//# sourceURL=build://vz-line-chart2/tf-scale.js
(function(b){class d extends Plottable.QuantitativeScale{constructor(){super(...arguments);this._ignoreOutlier=!1}setValueProviderForDomain(f){this._valueProviderForDomain=f}ignoreOutlier(f){return"boolean"==typeof f?(this._ignoreOutlier=f,this):this._ignoreOutlier}_getAllIncludedValues(){const f=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(f)}}b.TfScale=d})(Gh||(Gh={}));

//# sourceURL=build://vz-line-chart2/linear-scale.js
(function(b){class d extends Plottable.Scales.Linear{constructor(){super();this._ignoreOutlier=!1;this.padProportion(.2)}setValueProviderForDomain(f){this._valueProviderForDomain=f}_niceDomain(f,h){const [k,t]=f,l=t-k;f=0===l?1.1*Math.abs(k)+1.1:l*this.padProportion();return super._niceDomain([0<=k&&k<l?-.1*t:k-f,t+f],h)}_getUnboundedExtent(f){f=this._getAllIncludedValues(f);let h=this._defaultExtent();0!==f.length&&(f=[Plottable.Utils.Math.min(f,h[0]),Plottable.Utils.Math.max(f,h[1])],h=this._niceDomain(f));
return h}_getAllIncludedValues(){const f=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(f)}extentOfValues(f){var h=f=f.filter(k=>Plottable.Utils.Math.isValidNumber(k));if(this.ignoreOutlier()){h=f.sort((l,p)=>l-p);const k=d3.quantile(h,.05),t=d3.quantile(h,.95);h=f.filter(l=>l>=k&&l<=t)}f=d3.extent(h);return null==f[0]||null==f[1]?[]:f}ignoreOutlier(f){return"boolean"==typeof f?(this._ignoreOutlier=f,this):this._ignoreOutlier}}b.LinearScale=d})(Gh||(Gh={}));

//# sourceURL=build://vz-line-chart2/log-scale.js
(function(b){function d(k){return Math.log10(k)}function f(k){return Math.pow(10,k)}b.MIN_POSITIVE_VALUE=Math.pow(2,-1074);class h extends b.TfScale{constructor(){super();this._d3LogScale=d3.scaleLog();this.padProportion(.2)}scale(k){return 0>=k?NaN:this._d3LogScale(k)}invert(k){return this._d3LogScale.invert(k)}scaleTransformation(k){return this.scale(k)}invertedTransformation(k){return this.invert(k)}getTransformationDomain(){return this.domain()}_getDomain(){return this._untransformedDomain}_setDomain(k){this._untransformedDomain=
k;const [t,l]=k;super._setDomain([Math.max(b.MIN_POSITIVE_VALUE,t),l])}_niceDomain(k){const [t,l]=k;k=Math.max(d(b.MIN_POSITIVE_VALUE),d(t));const p=d(l);var m=p-k;m=m?m*this.padProportion():1;return[f(Math.max(d(b.MIN_POSITIVE_VALUE),k-m)),f(p+m)]}_getUnboundedExtent(k){k=this._getAllIncludedValues(k);let t=this._defaultExtent();0!==k.length&&(k=[Plottable.Utils.Math.min(k,t[0]),Plottable.Utils.Math.max(k,t[1])],t=this._niceDomain(k));return t}_getAllIncludedValues(){return super._getAllIncludedValues().map(k=>
0<k?k:b.MIN_POSITIVE_VALUE)}_defaultExtent(){return[1,10]}_backingScaleDomain(k){if(null==k)return this._d3LogScale.domain();this._d3LogScale.domain(k);return this}_getRange(){return this._d3LogScale.range()}_setRange(k){this._d3LogScale.range(k)}defaultTicks(){return this._d3LogScale.ticks()}ticks(){return this._d3LogScale.ticks()}extentOfValues(k){let t=k=k.filter(l=>Plottable.Utils.Math.isValidNumber(l)&&0<l);if(this.ignoreOutlier()){k=k.map(d).sort((m,n)=>m-n);const l=d3.quantile(k,.05),p=d3.quantile(k,
.95);t=k.filter(m=>m>=l&&m<=p).map(f)}k=d3.extent(t);return null==k[0]||null==k[1]?[]:k}}b.LogScale=h})(Gh||(Gh={}));

//# sourceURL=build://vz-line-chart2/line-chart.js
(function(b){let d;(function(k){k[k.TEXT=0]="TEXT";k[k.DOM=1]="DOM"})(d||(d={}));let f;(function(k){k.LOG="log";k.LINEAR="linear"})(f||(f={}));class h{constructor(k,t,l,p,m,n,q,u,x,A,y){this.seriesNames=[];this.name2datasets={};this.colorScale=p;this.tooltip=m;this.datasets=[];this._ignoreYOutliers=!1;this.lastPointsDataset=new Plottable.Dataset;this.nanDataset=new Plottable.Dataset;this.yValueAccessor=t;this.symbolFunction=A;this.onDatasetChanged=this._onDatasetChanged.bind(this);this._defaultXRange=
u;this._defaultYRange=x;this.tooltipColumns=n;this.buildChart(k,l,q,y)}buildChart(k,t,l,p){this.destroy();k=k();this.xAccessor=k.accessor;this.xScale=k.scale;this.xAxis=k.axis;this.xAxis.margin(0).tickLabelPadding(3);p&&this.xAxis.formatter(p);this.yScale=h.getYScaleFromType(t);this.yScale.setValueProviderForDomain(()=>this.getValuesForYAxisDomainCompute());this.yAxis=new Plottable.Axes.Numeric(this.yScale,"left");p=rg.multiscaleFormatter(rg.Y_AXIS_FORMATTER_PRECISION);this.yAxis.margin(0).tickLabelPadding(5).formatter(p);
this.yAxis.usesTextWidthApproximation();this.fillArea=l;p=new b.PanZoomDragLayer(this.xScale,this.yScale,()=>this.resetDomain());this.tooltipInteraction=this.createTooltipInteraction(p);this.tooltipPointsComponent=new Plottable.Component;l=this.buildPlot(this.xScale,this.yScale,l);this.gridlines=new Plottable.Components.Gridlines(this.xScale,this.yScale);k=null;t!==f.LOG&&(k=new Plottable.Components.GuideLineLayer("horizontal"),k.scale(this.yScale).value(0));t=new Plottable.Components.GuideLineLayer("vertical");
t.scale(this.xScale).value(0);this.center=new Plottable.Components.Group([this.gridlines,k,t,l,this.tooltipPointsComponent,p]);this.center.addClass("main");this.outer=new Plottable.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(k,t,l){l&&(this.marginAreaPlot=new Plottable.Plots.Area,this.marginAreaPlot.x(this.xAccessor,k),this.marginAreaPlot.y(l.higherAccessor,t),this.marginAreaPlot.y0(l.lowerAccessor),this.marginAreaPlot.attr("fill",(q,u,x)=>this.colorScale.scale(x.metadata().name)),
this.marginAreaPlot.attr("fill-opacity",.3),this.marginAreaPlot.attr("stroke-width",0));this.smoothedAccessor=q=>q.smoothed;l=new Plottable.Plots.Line;l.x(this.xAccessor,k);l.y(this.yValueAccessor,t);l.attr("stroke",(q,u,x)=>this.colorScale.scale(x.metadata().name));this.linePlot=l;this.setupTooltips(l);let p=new Plottable.Plots.Line;p.x(this.xAccessor,k);p.y(this.smoothedAccessor,t);p.attr("stroke",(q,u,x)=>this.colorScale.scale(x.metadata().name));this.smoothLinePlot=p;if(this.symbolFunction){var m=
new Plottable.Plots.Scatter;m.x(this.xAccessor,k);m.y(this.yValueAccessor,t);m.attr("fill",(q,u,x)=>this.colorScale.scale(x.metadata().name));m.attr("opacity",1);m.size(2*rg.TOOLTIP_CIRCLE_SIZE);m.symbol((q,u,x)=>this.symbolFunction(x.metadata().name));this.markersScatterPlot=m}m=new Plottable.Plots.Scatter;m.x(this.xAccessor,k);m.y(this.yValueAccessor,t);m.attr("fill",q=>this.colorScale.scale(q.name));m.attr("opacity",1);m.size(2*rg.TOOLTIP_CIRCLE_SIZE);m.datasets([this.lastPointsDataset]);this.scatterPlot=
m;let n=new Plottable.Plots.Scatter;n.x(this.xAccessor,k);n.y(q=>q.displayY,t);n.attr("fill",q=>this.colorScale.scale(q.name));n.attr("opacity",1);n.size(2*rg.NAN_SYMBOL_SIZE);n.datasets([this.nanDataset]);n.symbol(Plottable.SymbolFactories.triangle);this.nanDisplay=n;k=[n,m,p,l];this.marginAreaPlot&&k.push(this.marginAreaPlot);this.markersScatterPlot&&k.push(this.markersScatterPlot);return new Plottable.Components.Group(k)}_onDatasetChanged(k){this.smoothingEnabled&&this.resmoothDataset(k);this.updateSpecialDatasets()}ignoreYOutliers(k){k!==
this._ignoreYOutliers&&(this._ignoreYOutliers=k,this.updateSpecialDatasets(),this.yScale.ignoreOutlier(k),this.resetYDomain())}getValuesForYAxisDomainCompute(){const k=this.getAccessorsForComputingYRange();return _.flattenDeep(this.datasets.map(t=>k.map(l=>t.data().map(p=>l(p,-1,t))))).filter(isFinite)}updateSpecialDatasets(){const k=this.getYAxisAccessor();var t=this.datasets.map(l=>{let p=null,m=l.data().filter(n=>!isNaN(k(n,-1,l)));0<m.length&&(p=m[m.length-1],p.name=l.metadata().name,p.relative=
rg.relativeAccessor(p,-1,l));return p}).filter(l=>null!=l);this.lastPointsDataset.data(t);this.markersScatterPlot&&this.markersScatterPlot.datasets(this.datasets.map(this.createSampledDatasetForMarkers));t=_.flatten(this.datasets.map(l=>{let p=null,m=l.data(),n=0;for(;n<m.length&&null==p;)isNaN(k(m[n],-1,l))||(p=k(m[n],-1,l)),n++;null==p&&(p=0);let q=[];for(n=0;n<m.length;n++)isNaN(k(m[n],-1,l))?(m[n].name=l.metadata().name,m[n].displayY=p,m[n].relative=rg.relativeAccessor(m[n],-1,l),q.push(m[n])):
p=k(m[n],-1,l);return q}));this.nanDataset.data(t)}resetDomain(){this.resetXDomain();this.resetYDomain()}resetXDomain(){if(null!=this._defaultXRange)var k=this._defaultXRange;else k=this.xScale,k._domainMin=null,k._domainMax=null,k=k._getExtent();this.xScale.domain(k)}resetYDomain(){null!=this._defaultYRange?this.yScale.domain(this._defaultYRange):(this.yScale.autoDomain(),this.yScale.domain(this.yScale.domain()))}getAccessorsForComputingYRange(){const k=[this.getYAxisAccessor()];this.fillArea&&k.push(this.fillArea.lowerAccessor,
this.fillArea.higherAccessor);return k}getYAxisAccessor(){return this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor}createTooltipInteraction(k){const t=new rg.PointerInteraction,l=()=>{t.enabled(!1);this.hideTooltips()},p=()=>t.enabled(!0);k.onPanStart(l);k.onDragZoomStart(l);k.onPanEnd(p);k.onDragZoomEnd(p);k.onScrollZoom(()=>this.updateTooltipContent(this._lastMousePosition));t.onPointerMove(m=>{this._lastMousePosition=m;this.updateTooltipContent(m)});t.onPointerExit(()=>this.hideTooltips());
return t}updateTooltipContent(k){this.linePlot&&(window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame),this._tooltipUpdateAnimationFrame=window.requestAnimationFrame(()=>{let t={x:k.x,y:k.y,datum:null,dataset:null},l=this.gridlines.content().node().getBBox();var p=this.linePlot.datasets().map(u=>this.findClosestPoint(t,u)).filter(Boolean);let m=Plottable.Utils.DOM.intersectsBBox,n=p.filter(u=>m(u.x,u.y,l)||isNaN(this.yValueAccessor(u.datum,0,u.dataset))),q=n.filter(u=>!isNaN(this.yValueAccessor(u.datum,
0,u.dataset)));0!==p.length?(this.scatterPlot.attr("display","none"),p=this.tooltipPointsComponent.content().selectAll(".point").data(q,u=>u.dataset.metadata().name),p.enter().append("circle").classed("point",!0),p.attr("r",rg.TOOLTIP_CIRCLE_SIZE).attr("cx",u=>u.x).attr("cy",u=>u.y).style("stroke","none").attr("fill",u=>this.colorScale.scale(u.dataset.metadata().name)),p.exit().remove(),this.drawTooltips(n,t,this.tooltipColumns)):this.hideTooltips()}))}hideTooltips(){window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame);
this.tooltip.hide();this.scatterPlot.attr("display","block");this.tooltipPointsComponent.content().selectAll(".point").remove()}setupTooltips(k){k.onDetach(()=>{this.tooltipInteraction.detachFrom();this.tooltipInteraction.enabled(!1)});k.onAnchor(()=>{this.tooltipInteraction.attachTo(k);this.tooltipInteraction.enabled(!0)})}drawTooltips(k,t,l){if(k.length){var p=this.colorScale;l=[{title:"",static:!1,evalType:d.DOM,evaluate(y){d3.select(this).select("span").style("background-color",()=>p.scale(y.dataset.metadata().name));
return""},enter(y){d3.select(this).append("span").classed("swatch",!0).style("background-color",()=>p.scale(y.dataset.metadata().name))}},...l];var m=y=>Math.pow(y.x-t.x,2)+Math.pow(y.y-t.y,2),n=_.min(k.map(m)),q=this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor;k="ascending"===this.tooltipSortingMethod?_.sortBy(k,y=>q(y.datum,-1,y.dataset)):"descending"===this.tooltipSortingMethod?_.sortBy(k,y=>q(y.datum,-1,y.dataset)).reverse():"nearest"===this.tooltipSortingMethod?_.sortBy(k,m):k.slice(0).reverse();
var u=this,x=d3.select(this.tooltip.content()).select("table"),A=x.select("thead").selectAll("th").data(l,y=>y.title);A.enter().append("th").text(y=>y.title).nodes();A.exit().remove();k=x.select("tbody").selectAll("tr").data(k,y=>y.dataset.metadata().name);k.classed("distant",y=>{var w=y.dataset.data()[0],C=_.last(y.dataset.data());w=this.xScale.scale(this.xAccessor(w,0,y.dataset));C=this.xScale.scale(this.xAccessor(C,0,y.dataset));y=this.smoothingEnabled?y.datum.smoothed:this.yValueAccessor(y.datum,
0,y.dataset);return t.x<w||t.x>C||isNaN(y)}).classed("closest",y=>m(y)===n).each(function(y){u.drawTooltipRow(this,l,y)}).order();k.exit().remove();k.enter().append("tr").each(function(y){u.drawTooltipRow(this,l,y)}).nodes();this.tooltip.updateAndPosition(this.targetSVG.node())}else this.tooltip.hide()}drawTooltipRow(k,t,l){const p=this;k=d3.select(k).selectAll("td").data(t);k.each(function(m){m.static||p.drawTooltipColumn.call(p,this,m,l)});k.enter().append("td").each(function(m){m.enter&&m.enter.call(this,
l);p.drawTooltipColumn.call(p,this,m,l)})}drawTooltipColumn(k,t,l){const p=this.smoothingEnabled;t.evalType==d.DOM?t.evaluate.call(k,l,{smoothingEnabled:p}):d3.select(k).text(t.evaluate.call(k,l,{smoothingEnabled:p}))}findClosestPoint(k,t){const l=t.data().map((n,q)=>this.xScale.scale(this.xAccessor(n,q,t)));let p=_.sortedIndex(l,k.x);if(0==l.length)return null;p===l.length?--p:0!==p&&(p=Math.abs(l[p-1]-k.x)<Math.abs(l[p]-k.x)?p-1:p);k=t.data()[p];const m=this.smoothingEnabled?this.smoothedAccessor(k,
p,t):this.yValueAccessor(k,p,t);return{x:l[p],y:this.yScale.scale(m),datum:k,dataset:t}}resmoothDataset(k){let t=k.data();const l=this.smoothingWeight;let p=0<t.length?0:NaN,m=0;const n=t.map((u,x)=>this.yValueAccessor(u,x,k)),q=n.every(u=>u==n[0]);t.forEach((u,x)=>{x=n[x];q||!Number.isFinite(x)?u.smoothed=x:(p=p*l+(1-l)*x,m++,x=1,1!==l&&(x=1-Math.pow(l,m)),u.smoothed=p/x)})}getDataset(k){void 0===this.name2datasets[k]&&(this.name2datasets[k]=new Plottable.Dataset([],{name:k,meta:null}));return this.name2datasets[k]}static getYScaleFromType(k){if(k===
f.LOG)return new b.LogScale;if(k===f.LINEAR)return new b.LinearScale;throw Error("Unrecognized yScale type "+k);}setVisibleSeries(k){this.seriesNames=k=k.sort();k.reverse();this.datasets.forEach(t=>t.offUpdate(this.onDatasetChanged));this.datasets=k.map(t=>this.getDataset(t));this.datasets.forEach(t=>t.onUpdate(this.onDatasetChanged));this.linePlot.datasets(this.datasets);this.smoothingEnabled&&this.smoothLinePlot.datasets(this.datasets);this.marginAreaPlot&&this.marginAreaPlot.datasets(this.datasets);
this.updateSpecialDatasets()}createSampledDatasetForMarkers(k){const t=k.data();if(20>=t.length)return k;const l=Math.ceil(t.length/20),p=Array(Math.floor(t.length/l));for(let m=0,n=0;m<p.length;m++,n+=l)p[m]=t[n];return new Plottable.Dataset(p,k.metadata())}setSeriesData(k,t){this.getDataset(k).data(t);this.measureBBoxAndMaybeInvalidateLayoutInRaf()}setSeriesMetadata(k,t){t=Object.assign({},this.getDataset(k).metadata(),{meta:t});this.getDataset(k).metadata(t)}smoothingUpdate(k){this.smoothingWeight=
k;this.datasets.forEach(t=>this.resmoothDataset(t));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)}setTooltipSortingMethod(k){this.tooltipSortingMethod=k}renderTo(k){this.targetSVG=k;this.outer.renderTo(k);null!=this._defaultXRange&&this.resetXDomain();null!=this._defaultYRange&&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){const k=this._lastDrawBBox.width,{width:t}=this.targetSVG.node().getBoundingClientRect();0==k&&k<t&&this.outer.invalidateCache()}this._lastDrawBBox=this.targetSVG.node().getBoundingClientRect()}destroy(){window.cancelAnimationFrame(this._redrawRaf);
window.cancelAnimationFrame(this._invalidateLayoutRaf);this.outer&&this.outer.destroy()}onAnchor(k){if(this.outer)this.outer.onAnchor(k)}}b.LineChart=h})(Gh||(Gh={}));

//# sourceURL=build://vz-line-chart2/vz-line-chart2.js
(function(b){const d=rg.multiscaleFormatter(rg.Y_TOOLTIP_FORMATTER_PRECISION),f=h=>isNaN(h)?"NaN":d(h);b.DEFAULT_TOOLTIP_COLUMNS=[{title:"Name",evaluate:h=>h.dataset.metadata().name},{title:"Smoothed",evaluate(h,k){return f(k.smoothingEnabled?h.datum.smoothed:h.datum.scalar)}},{title:"Value",evaluate:h=>f(h.datum.scalar)},{title:"Step",evaluate:h=>rg.stepFormatter(h.datum.step)},{title:"Time",evaluate:h=>rg.timeFormatter(h.datum.wall_time)},{title:"Relative",evaluate:h=>rg.relativeFormatter(rg.relativeAccessor(h.datum,
-1,h.dataset))}];Polymer({is:"vz-line-chart2",properties:{colorScale:{type:Object,value:function(){return(new Plottable.Scales.Color).range(d3.schemeCategory10)}},symbolFunction:Object,smoothingEnabled:{type:Boolean,notify:!0,value:!1},smoothingWeight:{type:Number,value:.6},xType:{type:String,value:""},xComponentsCreationMethod:{type:Object,value:""},xAxisFormatter:Object,yValueAccessor:{type:Object,value:()=>h=>h.scalar},tooltipColumns:{type:Array,value:()=>b.DEFAULT_TOOLTIP_COLUMNS},fillArea:Object,
defaultXRange:Array,defaultYRange:Array,yScaleType:{type:String,value:"linear"},ignoreYOutliers:{type:Boolean,value:!1},tooltipSortingMethod:{type:String,value:"default"},tooltipPosition:{type:String,value:Eh.TooltipPosition.BOTTOM},_chart:Object,_visibleSeriesCache:{type:Array,value:()=>[]},_seriesDataCache:{type:Object,value:()=>({})},_seriesMetadataCache:{type:Object,value:()=>({})},_makeChartAsyncCallbackId:{type:Number,value:null}},observers:["_makeChart(xComponentsCreationMethod, xType, yValueAccessor, yScaleType, tooltipColumns, colorScale, isAttached)",
"_reloadFromCache(_chart, _visibleSeriesCache)","_smoothingChanged(smoothingEnabled, smoothingWeight, _chart)","_tooltipSortingMethodChanged(tooltipSortingMethod, _chart)","_outliersChanged(ignoreYOutliers, _chart)"],ready(){this.scopeSubtree(this.$.chartdiv,!0)},attached(){const h={capture:!0,passive:!0};this._listen(this,"mousedown",this._onMouseDown.bind(this),h);this._listen(this,"mouseup",this._onMouseUp.bind(this),h);this._listen(window,"keydown",this._onKeyDown.bind(this),h);this._listen(window,
"keyup",this._onKeyUp.bind(this),h)},detached(){this.cancelAsync(this._makeChartAsyncCallbackId);this._chart&&this._chart.destroy();this._listeners&&(this._listeners.forEach(({node:h,eventName:k,func:t,option:l})=>{h.removeEventListener(k,t,l)}),this._listeners.clear())},_listen(h,k,t,l={}){this._listeners||(this._listeners=new Set);this._listeners.add({node:h,eventName:k,func:t,option:l});h.addEventListener(k,t,l)},_onKeyDown(h){this.toggleClass("pankey",b.PanZoomDragLayer.isPanKey(h))},_onKeyUp(h){this.toggleClass("pankey",
b.PanZoomDragLayer.isPanKey(h))},_onMouseDown(){this.toggleClass("mousedown",!0)},_onMouseUp(){this.toggleClass("mousedown",!1)},setVisibleSeries:function(h){_.isEqual(this._visibleSeriesCache,h)||(this._visibleSeriesCache=h)},setSeriesData:function(h,k){this._seriesDataCache[h]=k;this._chart&&this._chart.setSeriesData(h,k)},setSeriesMetadata(h,k){this._seriesMetadataCache[h]=k;this._chart&&this._chart.setSeriesMetadata(h,k)},resetDomain:function(){this._chart&&this._chart.resetDomain()},redraw:function(){this._chart&&
this._chart.redraw()},_makeChart:function(h,k,t,l,p,m){k||h?k&&(h=()=>rg.getXComponents(k)):h=rg.stepX;null!==this._makeChartAsyncCallbackId&&(this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=null);this._makeChartAsyncCallbackId=this.async(function(){this._makeChartAsyncCallbackId=null;if(h&&this.yValueAccessor&&this.tooltipColumns){var n=new b.LineChart(h,this.yValueAccessor,l,m,this.$.tooltip,this.tooltipColumns,this.fillArea,this.defaultXRange,this.defaultYRange,
this.symbolFunction,this.xAxisFormatter),q=d3.select(this.$.chartdiv);n.renderTo(q);this._chart&&this._chart.destroy();this._chart=n;this._chart.onAnchor(()=>this.fire("chart-attached"))}},350)},_reloadFromCache:function(){this._chart&&(this._visibleSeriesCache.forEach(h=>{this._chart.setSeriesData(h,this._seriesDataCache[h]||[])}),this._visibleSeriesCache.filter(h=>this._seriesMetadataCache[h]).forEach(h=>{this._chart.setSeriesMetadata(h,this._seriesMetadataCache[h])}),this._chart.setVisibleSeries(this._visibleSeriesCache))},
_smoothingChanged:function(){this._chart&&(this.smoothingEnabled?this._chart.smoothingUpdate(this.smoothingWeight):this._chart.smoothingDisable())},_outliersChanged:function(){this._chart&&this._chart.ignoreYOutliers(this.ignoreYOutliers)},_tooltipSortingMethodChanged:function(){this._chart&&this._chart.setTooltipSortingMethod(this.tooltipSortingMethod)},getExporter(){return new b.LineChartExporter(this.$.chartdiv)}})})(Gh||(Gh={}));

//# sourceURL=build://vz-line-chart2/vz-line-chart2.html.js
Polymer({is:"vz-line-chart-tooltip"});

//# sourceURL=build://vz-line-chart2/line-chart-exporter.js
(function(b){let d;(function(k){k.GROUP="G";k.DIV="DIV";k.SVG="SVG";k.TEXT="TEXT"})(d||(d={}));class f{constructor(k){this.uniqueId=0;this.root=k}exportAsString(){const k=this.convert(this.root);if(!k)return"";const t=this.createRootSvg();t.appendChild(k);return t.outerHTML}createUniqueId(){return`${"clip"}_${this.uniqueId++}`}getSize(){return this.root.getBoundingClientRect()}createRootSvg(){const k=document.createElement("svg"),t=this.getSize();k.setAttributeNS("svg","viewBox",`0 0 ${t.width} ${t.height}`);
k.setAttribute("xmlns","http://www.w3.org/2000/svg");return k}convert(k){let t=null;var l=k.nodeName.toUpperCase();if(k.nodeType!=Node.ELEMENT_NODE||l!=d.DIV&&l!=d.SVG)t=k.cloneNode();else{t=document.createElement(d.GROUP);var p=window.getComputedStyle(k),m=parseInt(p.left,10),n=parseInt(p.top,10);if(m||n)l=this.createUniqueId(),t.setAttribute("transform",`translate(${m}, ${n})`),t.setAttribute("clip-path",`url(#${l})`),n=parseInt(p.height,10),m=document.createElement("rect"),m.setAttribute("width",
String(parseInt(p.width,10))),m.setAttribute("height",String(n)),p=document.createElementNS("svg","clipPath"),p.id=l,p.appendChild(m),t.appendChild(p)}Array.from(k.childNodes).map(q=>this.convert(q)).filter(Boolean).forEach(q=>t.appendChild(q));return t.nodeName.toUpperCase()==d.GROUP&&!t.hasChildNodes()||this.shouldOmitNode(k)?null:this.stripClass(this.transferStyle(k,t))}stripClass(k){k.nodeType==Node.ELEMENT_NODE&&k.removeAttribute("class");return k}transferStyle(k,t){if(t.nodeType!=Node.ELEMENT_NODE)return t;
const l=t.nodeName.toUpperCase();k=window.getComputedStyle(k);l==d.TEXT&&Object.assign(t.style,{fontFamily:k.fontFamily,fontSize:k.fontSize,fontWeight:k.fontWeight});l!=d.GROUP&&(t.setAttribute("fill",k.fill),t.setAttribute("stroke",k.stroke),t.setAttribute("stroke-width",k.strokeWidth));"1"!=k.opacity&&t.setAttribute("opacity",k.opacity);return t}shouldOmitNode(){return!1}}b.PlottableExporter=f;class h extends f{shouldOmitNode(k){return k.nodeType==Node.ELEMENT_NODE?k.classList.contains("scatter-plot"):
!1}}b.LineChartExporter=h})(Gh||(Gh={}));

//# sourceURL=build://tf-line-chart-data-loader/tf-line-chart-data-loader.html.js
(function(){const b=[],d=function(){return _.throttle(function h(){if(0!=b.length){var k=b.shift();k.active&&(k.redraw(),k._maybeRenderedInBadState=!1);window.cancelAnimationFrame(0);window.requestAnimationFrame(h)}},100)}();Polymer({is:"tf-line-chart-data-loader",properties:{active:{type:Boolean,observer:"_fixBadStateWhenActive"},dataSeries:Array,requestManager:Object,logScaleActive:{type:Boolean,observer:"_logScaleChanged"},xComponentsCreationMethod:Object,xType:String,yValueAccessor:Object,fillArea:Object,
smoothingEnabled:Boolean,smoothingWeight:Number,tooltipColumns:Array,tooltipSortingMethod:String,tooltipPosition:String,ignoreYOutliers:Boolean,defaultXRange:Array,defaultYRange:Array,symbolFunction:Object,colorScale:{type:Object,value:()=>({scale:pf.runsColorScale})},_resetDomainOnNextLoad:{type:Boolean,value:!0},_maybeRenderedInBadState:{type:Boolean,value:!1,reflectToAttribute:!0}},behaviors:[qd.DataLoaderBehavior],observers:["_dataSeriesChanged(dataSeries.*)","_loadKeyChanged(loadKey)"],onLoadFinish(){0<
this.dataToLoad.length&&this._resetDomainOnNextLoad&&(this._resetDomainOnNextLoad=!1,this.$.chart.resetDomain());this.redraw()},detached(){cancelAnimationFrame(this._redrawRaf)},exportAsSvgString(){return this.$.chart.getExporter().exportAsString()},resetDomain(){this.$.chart.resetDomain()},setSeriesData(f,h){this.$.chart.setSeriesData(f,h)},setSeriesMetadata(f,h){this.$.chart.setSeriesMetadata(f,h)},redraw(){cancelAnimationFrame(this._redrawRaf);this._redrawRaf=window.requestAnimationFrame(()=>{this.active?
this.$.chart.redraw():this._maybeRenderedInBadState=!0})},_loadKeyChanged(){this.reset();this._resetDomainOnNextLoad=!0},_dataSeriesChanged(){this.$.chart.setVisibleSeries(this.dataSeries)},_logScaleChanged(f){this.$.chart.yScaleType=f?"log":"linear";this.redraw()},_fixBadStateWhenActive(){this.active&&this._maybeRenderedInBadState&&(b.push(this),d())},_onChartAttached(){this.active||(this._maybeRenderedInBadState=!0)}})})();

//# sourceURL=build://paper-dialog-scrollable/paper-dialog-scrollable.html.js
Polymer({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",0<this.scrollTarget.scrollTop);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.behaviors&&0<=this.dialogElement.behaviors.indexOf(Polymer.PaperDialogBehaviorImpl)?(this.dialogElement.sizingTarget=this.scrollTarget,this.scrollTarget.classList.remove("fit")):this.dialogElement&&this.scrollTarget.classList.add("fit")}});

//# sourceURL=build://tf-markdown-view/tf-markdown-view.html.js
Polymer({is:"tf-markdown-view",properties:{html:{type:String,value:""}},attached(){window.requestAnimationFrame(()=>{this.scopeSubtree(this.$.markdown,!0)})}});

//# sourceURL=build://tf-card-heading/util.js
var Hh;(function(b){function d(f){if(!f)return null;let h=f.match(/^#([0-9a-f]{1,2})([0-9a-f]{1,2})([0-9a-f]{1,2})$/);if(!h)return null;if(4==f.length)for(f=1;3>=f;f++)h[f]+=h[f];return[parseInt(h[1],16),parseInt(h[2],16),parseInt(h[3],16)]}b.formatDate=function(f){return f?f.toString().replace(/GMT-\d+ \(([^)]+)\)/,"$1"):""};b.pickTextColor=function(f){return(f=d(f))?125<Math.round((299*f[0]+587*f[1]+114*f[2])/1E3)?"inherit":"#eee":"inherit"}})(Hh||(Hh={}));

//# sourceURL=build://tf-card-heading/tf-card-heading.html.js
Polymer({is:"tf-card-heading",properties:{displayName:{type:String,value:null},tag:{type:String,value:null},run:{type:String,value:null},description:{type:String,value:null},color:{type:String,value:null},_runBackground:{type:String,computed:"_computeRunBackground(color)",readOnly:!0,observer:"_updateHeadingStyle"},_runColor:{type:String,computed:"_computeRunColor(color)",readOnly:!0,observer:"_updateHeadingStyle"},_nameLabel:{type:String,computed:"_computeNameLabel(displayName, tag)"},_tagLabel:{type:String,
computed:"_computeTagLabel(displayName, tag)"}},_updateHeadingStyle(){this.updateStyles({"--tf-card-heading-background-color":this._runBackground,"--tf-card-heading-color":this._runColor})},_computeRunBackground(b){return b||"none"},_computeRunColor(b){return Hh.pickTextColor(b)},_computeNameLabel(b,d){return b||d||""},_computeTagLabel(b,d){return d&&d!==b?d:""},_toggleDescriptionDialog(b){this.$.descriptionDialog.positionTarget=b.target;this.$.descriptionDialog.toggle()}});

//# sourceURL=build://tf-dashboard-common/tf-downloader.html.js
Polymer({is:"tf-downloader",properties:{_run:{type:String,value:""},runs:Array,tag:String,urlFn:Function},_csvUrl(b,d,f){return d?vc.addParams(f(b,d),{format:"csv"}):""},_jsonUrl(b,d,f){return d?f(b,d):""},_csvName(b,d){return d?`run-${d}-tag-${b}.csv`:""},_jsonName(b,d){return d?`run-${d}-tag-${b}.json`:""}});

//# sourceURL=build://tf-scalar-dashboard/tf-scalar-card.html.js
Polymer({is:"tf-scalar-card",properties:{tag:String,dataToLoad:Array,xType:String,active:Boolean,ignoreYOutliers:Boolean,requestManager:Object,showDownLinks:Boolean,smoothingEnabled:Boolean,smoothingWeight:Number,tagMetadata:Object,colorScale:{type:Object,value:null},tooltipSortingMethod:String,_loadDataCallback:{type:Object,value:function(){return(b,d,f)=>{f=f.map(k=>({wall_time:new Date(1E3*k[0]),step:k[1],scalar:k[2]}));const h=this._getSeriesNameFromDatum(d);b.setSeriesMetadata(h,d);b.setSeriesData(h,
f)}},readOnly:!0},getDataLoadUrl:{type:Function,value:function(){return({tag:b,run:d})=>vc.getRouter().pluginRoute("scalars","/scalars",new URLSearchParams({tag:b,run:d}))}},_downloadUrlFn:{type:Function,value:function(){return(b,d)=>this.getDataLoadUrl({tag:b,run:d})}},requestData:Function,_getDataLoadName:{type:Function,value:function(){return b=>this._getSeriesNameFromDatum(b)}},_expanded:{type:Boolean,value:!1,reflectToAttribute:!0},_logScaleActive:Boolean,_tooltipColumns:{type:Array,value:function(){const b=
Gh.DEFAULT_TOOLTIP_COLUMNS.slice(),d=b.findIndex(f=>"Name"==f.title);b.splice(d,1,{title:"Name",evaluate:f=>{f=f.dataset.metadata().meta;return this._getSeriesDisplayNameFromDatum(f)}});return b}}},reload(){this.$$("tf-line-chart-data-loader").reload()},redraw(){this.$$("tf-line-chart-data-loader").redraw()},_toggleExpanded(){this.set("_expanded",!this._expanded);this.redraw()},_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)},_resetDomain(){const b=this.$$("tf-line-chart-data-loader");
b&&b.resetDomain()},_updateDownloadLink(){const b=this.$$("tf-line-chart-data-loader").exportAsSvgString();this.$$("#svgLink").href=`data:image/svg+xml;base64,${btoa(b)}`},_runsFromData(b){return b.map(d=>d.run)},_getDataSeries(){return this.dataToLoad.map(b=>this._getSeriesNameFromDatum(b))},_getSeriesNameFromDatum({run:b,experiment:d={name:"_default"}}){return JSON.stringify([d.name,b])},_getSeriesDisplayNameFromDatum(b){return b.run},_getColorScale(){return null!==this.colorScale?this.colorScale:
{scale:b=>{[,b]=JSON.parse(b);return pf.runsColorScale(b)}}}});

//# sourceURL=build://iron-range-behavior/iron-range-behavior.html.js
Polymer.IronRangeBehavior={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(b){return(this._clampValue(b)-this.min)/(this.max-this.min)},_clampValue:function(b){return Math.min(this.max,Math.max(this.min,this._calcStep(b)))},_calcStep:function(b){b=parseFloat(b);
if(!this.step)return b;b=Math.round((b-this.min)/this.step);return 1>this.step?b/(1/this.step)+this.min:b*this.step+this.min},_validateValue:function(){var b=this._clampValue(this.value);this.value=this.oldValue=isNaN(b)?this.oldValue:b;return this.value!==b},_update:function(){this._validateValue();this._setRatio(100*this._calcRatio(this.value))}};

//# sourceURL=build://paper-progress/paper-progress.html.js
Polymer({is:"paper-progress",behaviors:[Polymer.IronRangeBehavior],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(b){this.toggleClass("indeterminate",
b,this.$.primaryProgress)},_transformProgress:function(b,d){b.style.transform=b.style.webkitTransform="scaleX("+d/100+")"},_mainRatioChanged:function(b){this._transformProgress(this.$.primaryProgress,b)},_progressChanged:function(b,d,f,h,k){b=this._clampValue(b);d=this._clampValue(d);var t=100*this._calcRatio(b),l=100*this._calcRatio(d);this._setSecondaryRatio(t);this._transformProgress(this.$.secondaryProgress,t);this._transformProgress(this.$.primaryProgress,l);this.secondaryProgress=b;k?this.removeAttribute("aria-valuenow"):
this.setAttribute("aria-valuenow",d);this.setAttribute("aria-valuemin",f);this.setAttribute("aria-valuemax",h)},_disabledChanged:function(b){this.setAttribute("aria-disabled",b?"true":"false")},_hideSecondaryProgress:function(b){return 0===b}});

//# sourceURL=build://paper-slider/paper-slider.html.js
Polymer({is:"paper-slider",behaviors:[Polymer.IronA11yKeysBehavior,Polymer.IronFormElementBehavior,Polymer.PaperInkyFocusBehavior,Polymer.IronRangeBehavior],properties:{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&&Polymer.Gestures.setTouchAction(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(b,d,f){this.setAttribute("aria-valuemin",d);this.setAttribute("aria-valuemax",f);this.setAttribute("aria-valuenow",b);this._positionKnob(100*this._calcRatio(b))},_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(b){this._setImmediateValue(this._calcStep(this._calcKnobPosition(b)));this._setRatio(100*this._calcRatio(this.immediateValue));this.$.sliderKnob.style.left=this.ratio+"%";this.dragging&&
(this._knobstartx=this.ratio*this._w/100,this.translate3d(0,0,0,this.$.sliderKnob))},_calcKnobPosition:function(b){return(this.max-this.min)*b/100+this.min},_onTrack:function(b){b.stopPropagation();switch(b.detail.state){case "start":this._trackStart(b);break;case "track":this._trackX(b);break;case "end":this._trackEnd()}},_trackStart:function(){this._setTransiting(!1);this._w=this.$.sliderBar.offsetWidth;this._knobstartx=this._startx=this._x=this.ratio*this._w/100;this._minx=-this._startx;this._maxx=
this._w-this._startx;this.$.sliderKnob.classList.add("dragging");this._setDragging(!0)},_trackX:function(b){this.dragging||this._trackStart(b);this._x=this._startx+Math.min(this._maxx,Math.max(this._minx,b.detail.dx*(this._isRTL?-1:1)));this._setImmediateValue(this._calcStep(this._calcKnobPosition(this._x/this._w*100)));this.translate3d(this._calcRatio(this.immediateValue)*this._w-this._knobstartx+"px",0,0,this.$.sliderKnob)},_trackEnd:function(){var b=this.$.sliderKnob.style;this.$.sliderKnob.classList.remove("dragging");
this._setDragging(!1);this._resetKnob();this.value=this.immediateValue;b.transform=b.webkitTransform="";this.fire("change",{composed:!0})},_knobdown:function(b){this._expandKnob();b.preventDefault();this.focus()},_bartrack:function(b){this._allowBarEvent(b)&&this._onTrack(b)},_barclick:function(b){this._w=this.$.sliderBar.offsetWidth;var d=this.$.sliderBar.getBoundingClientRect();d=(b.detail.x-d.left)/this._w*100;this._isRTL&&(d=100-d);var f=this.ratio;this._setTransiting(!0);this._positionKnob(d);
f===this.ratio&&this._setTransiting(!1);this.async(function(){this.fire("change",{composed:!0})});b.preventDefault();this.focus()},_bardown:function(b){this._allowBarEvent(b)&&(this.debounce("expandKnob",this._expandKnob,60),this._barclick(b))},_knobTransitionEnd:function(b){b.target===this.$.sliderKnob&&this._setTransiting(!1)},_updateMarkers:function(b,d,f,h){h||this._setMarkers([]);d=Math.round((f-d)/this.step);d>b&&(d=b);if(0>d||!isFinite(d))d=0;this._setMarkers(Array(d))},_mergeClasses:function(b){return Object.keys(b).filter(function(d){return b[d]}).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(b){return!this.ignoreBarTouch||b.detail.sourceEvent instanceof MouseEvent},get _isRTL(){void 0===this.__isRTL&&(this.__isRTL="rtl"===window.getComputedStyle(this).direction);return this.__isRTL},_leftKey:function(b){this._isRTL?this._incrementKey(b):
this._decrementKey(b)},_rightKey:function(b){this._isRTL?this._decrementKey(b):this._incrementKey(b)},_incrementKey:function(b){this.disabled||("end"===b.detail.key?this.value=this.max:this.increment(),this.fire("change"),b.preventDefault())},_decrementKey:function(b){this.disabled||("home"===b.detail.key?this.value=this.min:this.decrement(),this.fire("change"),b.preventDefault())},_changeValue:function(b){this.value=b.target.value;this.fire("change",{composed:!0})},_inputKeyDown:function(b){b.stopPropagation()},
_createRipple:function(){this._rippleContainer=this.$.sliderKnob;return Polymer.PaperInkyFocusBehaviorImpl._createRipple.call(this)},_focusedChanged:function(b){b&&this.ensureRipple();this.hasRipple()&&(this._ripple.style.display=b?"":"none",this._ripple.holdDown=b)}});

//# sourceURL=build://tf-scalar-dashboard/tf-smoothing-input.html.js
Polymer({is:"tf-smoothing-input",properties:{step:Number,max:Number,min:Number,weight:{type:Number,value:.6,notify:!0},_immediateWeightNumberForPaperSlider:{type:Number,notify:!0,observer:"_immediateWeightNumberForPaperSliderChanged"},_inputWeightStringForPaperInput:{type:String,notify:!0,observer:"_inputWeightStringForPaperInputChanged"}},_updateWeight:_.debounce(function(b){this.weight=b},250),_immediateWeightNumberForPaperSliderChanged:function(){this._inputWeightStringForPaperInput=this._immediateWeightNumberForPaperSlider.toString();
this._updateWeight.call(this,this._immediateWeightNumberForPaperSlider)},_inputWeightStringForPaperInputChanged:function(){0>+this._inputWeightStringForPaperInput?this._inputWeightStringForPaperInput="0":1<+this._inputWeightStringForPaperInput&&(this._inputWeightStringForPaperInput="1");var b=+this._inputWeightStringForPaperInput;isNaN(b)||this._updateWeight.call(this,b)}});

//# sourceURL=build://tf-scalar-dashboard/tf-scalar-dashboard.html.js
Polymer({is:"tf-scalar-dashboard",properties:{_showDownloadLinks:{type:Boolean,notify:!0,value:pd.getBooleanInitializer("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),observer:"_showDownloadLinksObserver"},_smoothingWeight:{type:Number,notify:!0,value:pd.getNumberInitializer("_smoothingWeight",{defaultValue:.6}),observer:"_smoothingWeightObserver"},_smoothingEnabled:{type:Boolean,computed:"_computeSmoothingEnabled(_smoothingWeight)"},_ignoreYOutliers:{type:Boolean,value:pd.getBooleanInitializer("_ignoreYOutliers",
{defaultValue:!0,useLocalStorage:!0}),observer:"_ignoreYOutliersObserver"},_xType:{type:String,value:rg.XType.STEP},_selectedRuns:{type:Array,value:()=>[]},_runToTagInfo:Object,_dataNotFound:Boolean,_tagFilter:{type:String,value:""},_categoriesDomReady:Boolean,_categories:{type:Array,value:()=>[]},_getCategoryItemKey:{type:Function,value:()=>b=>b.tag},_requestManager:{type:Object,value:()=>new vc.RequestManager(50)}},behaviors:[qd.ArrayUpdateHelper],observers:["_updateCategories(_runToTagInfo, _selectedRuns, _tagFilter, _categoriesDomReady)"],
_showDownloadLinksObserver:pd.getBooleanObserver("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),_smoothingWeightObserver:pd.getNumberObserver("_smoothingWeight",{defaultValue:.6}),_ignoreYOutliersObserver:pd.getBooleanObserver("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}),_computeSmoothingEnabled(b){return 0<b},_getCategoryKey(b){return b.metadata.type==$c.CategoryType.SEARCH_RESULTS?"":b.name},_shouldOpen(b){return 2>=b},ready(){this.reload()},reload(){this._fetchTags().then(()=>
{this._reloadCharts()})},_fetchTags(){const b=vc.getRouter().pluginRoute("scalars","/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,this._runToTagInfo)){var f=_.mapValues(d,h=>Object.keys(h));f=vc.getTags(f);this.set("_dataNotFound",0===f.length);this.set("_runToTagInfo",d);this.async(()=>{this.set("_categoriesDomReady",!0)})}})},_reloadCharts(){this.root.querySelectorAll("tf-scalar-card").forEach(b=>{b.reload()})},_updateCategories(b,d,f){b=_.mapValues(b,h=>Object.keys(h));
d=$c.categorizeTags(b,d,f);d.forEach(h=>{h.items=h.items.map(k=>({tag:k.tag,series:k.runs.map(t=>({run:t,tag:k.tag}))}))});this.updateArrayProp("_categories",d,this._getCategoryKey)},_tagMetadata(b,d,f){const h=f.tag,k={};f.series.forEach(({run:p})=>{k[p]=d[p][h]});f=h.replace(/\/scalar_summary$/,"");let {description:t,displayName:l}=rf.aggregateTagInfo(k,f);b.metadata.type==$c.CategoryType.PREFIX_GROUP&&l.startsWith(b.name+"/")&&(l=l.slice(b.name.length+1));return{description:t,displayName:l}}});

//# sourceURL=build://tf-custom-scalar-dashboard/tf-custom-scalar-helpers.js
var Ti;
(function(b){class d{constructor(h,k,t,l,p){this.run=h;this.tag=k;this.name=t;this.scalarData=l;this.symbol=p}getName(){return this.name}setData(h){this.scalarData=h}getData(){return this.scalarData}getRun(){return this.run}getTag(){return this.tag}getSymbol(){return this.symbol}}b.DataSeries=d;b.generateDataSeriesName=function(h,k){return`${k} (${h})`};class f{constructor(h){this.runBasedColorScale=h}scale(h){return this.runBasedColorScale.scale(this.parseRunName(h))}parseRunName(h){return(h=h.match(/\((.*)\)$/))?
h[1]:""}}b.DataSeriesColorScale=f})(Ti||(Ti={}));

//# sourceURL=build://tf-custom-scalar-dashboard/tf-custom-scalar-margin-chart-card.html.js
Polymer({is:"tf-custom-scalar-margin-chart-card",properties:{runs:Array,xType:String,active:{type:Boolean,value:!0,readOnly:!0},title:String,marginChartSeries:Array,ignoreYOutliers:Boolean,requestManager:Object,showDownloadLinks:Boolean,tagMetadata:Object,tooltipSortingMethod:String,_colorScale:{type:Object,value:new Ti.DataSeriesColorScale({scale:pf.runsColorScale}),readOnly:!0},_tagFilter:{type:String,computed:"_computeTagFilter(marginChartSeries)"},_tagFilterInvalid:Boolean,_nameToDataSeries:{type:Object,
value:()=>({})},_seriesNames:{type:Object,computed:"_computeSeriesNames(_nameToDataSeries, runs)"},_expanded:{type:Boolean,value:!1,reflectToAttribute:!0},_logScaleActive:Boolean,_dataUrl:{type:Function,value:function(){return b=>{const d=this._tagFilter;return vc.addParams(vc.getRouter().pluginRoute("custom_scalars","/scalars"),{tag:d,run:b})}}},_runToNextAvailableSymbolIndex:{type:Object,value:{}},_matchesListOpened:{type:Boolean,value:!1},_titleDisplayString:{type:String,computed:"_computeTitleDisplayString(title)"},
_fillArea:{type:Object,readOnly:!0,value:{lowerAccessor:b=>b.lower,higherAccessor:b=>b.upper}},_tooltipColumns:{type:Array,value:function(){const b=rg.multiscaleFormatter(rg.Y_TOOLTIP_FORMATTER_PRECISION),d=f=>isNaN(f)?"NaN":b(f);return[{title:"Name",evaluate:f=>f.dataset.metadata().name},{title:"Value",evaluate:f=>d(f.datum.scalar)},{title:"Lower Margin",evaluate:f=>d(f.datum.lower)},{title:"Upper Margin",evaluate:f=>d(f.datum.upper)},{title:"Step",evaluate:f=>rg.stepFormatter(f.datum.step)},{title:"Time",
evaluate:f=>rg.timeFormatter(f.datum.wall_time)},{title:"Relative",evaluate:f=>rg.relativeFormatter(rg.relativeAccessor(f.datum,-1,f.dataset))}]}},_missingTags:{type:Array,value:[]},_missingTagsCollapsibleOpened:{type:Boolean,value:!1},_stepsMismatch:Object},observers:["_updateChart(_nameToDataSeries)","_refreshDataSeries(_tagFilter)"],reload(){this.$.loader.reload()},redraw(){this.$.loader.redraw()},_toggleExpanded(){this.set("_expanded",!this._expanded);this.redraw()},_toggleLogScale(){this.set("_logScaleActive",
!this._logScaleActive)},_resetDomain(){const b=this.$.loader;b&&b.resetDomain()},_csvUrl(b,d){if(!d)return"";b=this._downloadDataUrl(b,d);return vc.addParams(b,{format:"csv"})},_jsonUrl(b,d){if(!d)return"";b=this._downloadDataUrl(b,d);return vc.addParams(b,{format:"json"})},_downloadDataUrl(b,d){b=b[d];b={tag:b.getTag(),run:b.getRun()};return vc.addParams(vc.getRouter().pluginRoute("custom_scalars","/download_data"),b)},_createProcessDataFunction(b){return(d,f,h)=>{if(h.regex_valid){var k=_.clone(this._nameToDataSeries),
t=[];_.forEach(b,l=>{var p=!1,m=h.tag_to_events[l.value];const n=h.tag_to_events[l.lower],q=h.tag_to_events[l.upper];_.isUndefined(m)&&(t.push(l.value),p=!0);_.isUndefined(n)&&(t.push(l.lower),p=!0);_.isUndefined(q)&&(t.push(l.upper),p=!0);if(!p){var u=y=>y[1];if(p=this._findStepMismatch(l,m.map(u),n.map(u),q.map(u)))this.set("_stepsMismatch",p);else{var x=y=>y[2];p=m.map((y,w)=>({wall_time:new Date(1E3*y[0]),step:u(y),scalar:x(y),lower:x(n[w]),upper:x(q[w])}));m=Ti.generateDataSeriesName(f,l.value);
var A=k[m];A?A.setData(p):(l=this._createNewDataSeries(f,l.value,m,p),k[m]=l)}}});this.set("_nameToDataSeries",k);d=_.findIndex(this._missingTags,l=>l.run===f);if(t.length&&3!=t.length){const l={run:f,tags:t};0<=d?this.splice("_missingTags",d,1,l):this.push("_missingTags",l)}else 0<=d&&this.splice("_missingTags",d,1)}else this.set("_tagFilterInvalid",!0)}},_findStepMismatch(b,d,f,h){return _.isEqual(f,d)&&_.isEqual(h,d)?null:{seriesObject:b,valueSteps:d,lowerSteps:f,upperSteps:h}},_createNewDataSeries(b,
d,f,h){this._runToNextAvailableSymbolIndex[b]|=0;d=new Ti.DataSeries(b,d,f,h,rg.SYMBOLS_LIST[this._runToNextAvailableSymbolIndex[b]]);this._runToNextAvailableSymbolIndex[b]=(this._runToNextAvailableSymbolIndex[b]+1)%rg.SYMBOLS_LIST.length;return d},_updateChart(b){_.forOwn(b,d=>{this.$.loader.setSeriesData(d.getName(),d.getData())})},_computeSeriesNames(){const b=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter(([,d])=>b.has(d.run)).map(([d])=>d)},_determineColor(b,d){return b.scale(d)},
_refreshDataSeries(){this.set("_nameToDataSeries",{})},_createSymbolFunction(){return b=>this._nameToDataSeries[b].getSymbol().method()},_determineSymbol(b,d){return b[d].getSymbol().character},_computeTagFilter(b){return _.flatten(b.map(d=>[d.value,d.lower,d.upper])).map(d=>"("+this._escapeRegexCharacters(d)+")").join("|")},_escapeRegexCharacters(b){return b.replace(/[.*+?^${}()|[\]\\]/g,"\\$\x26")},_getToggleCollapsibleIcon(b){return b?"expand-less":"expand-more"},_toggleMatchesOpen(){this.set("_matchesListOpened",
!this._matchesListOpened)},_computeTitleDisplayString(b){return b||"untitled"},_separateWithCommas(b){return b.join(", ")},_toggleMissingTagsCollapsibleOpen(){this.set("_missingTagsCollapsibleOpened",!this._missingTagsCollapsibleOpened)},_matchListEntryColorUpdated(){const b=this.$$("#match-list-repeat");b&&this.root.querySelectorAll(".match-list-entry").forEach(d=>{const f=b.itemForElement(d);d.style.color=this._determineColor(this._colorScale,f)})}});

//# sourceURL=build://tf-custom-scalar-dashboard/tf-custom-scalar-multi-line-chart-card.html.js
Polymer({is:"tf-custom-scalar-multi-line-chart-card",properties:{runs:Array,xType:String,active:{type:Boolean,value:!0,readOnly:!0},title:String,tagRegexes:Array,ignoreYOutliers:Boolean,requestManager:Object,showDownloadLinks:Boolean,smoothingEnabled:Boolean,smoothingWeight:Number,tagMetadata:Object,tooltipSortingMethod:String,_colorScale:{type:Object,value:new Ti.DataSeriesColorScale({scale:pf.runsColorScale}),readOnly:!0},_tagFilter:{type:String,computed:"_computeTagFilter(tagRegexes)"},_nameToDataSeries:{type:Object,
value:()=>({})},_seriesNames:{type:Object,computed:"_computeSeriesNames(_nameToDataSeries, runs)"},_expanded:{type:Boolean,value:!1,reflectToAttribute:!0},_logScaleActive:Boolean,_dataUrl:{type:Function,value:function(){return b=>{const d=this._tagFilter;return vc.addParams(vc.getRouter().pluginRoute("custom_scalars","/scalars"),{tag:d,run:b})}}},_runToNextAvailableSymbolIndex:{type:Object,value:{}},_matchesListOpened:{type:Boolean,value:!1},_titleDisplayString:{type:String,computed:"_computeTitleDisplayString(title)"}},
observers:["_updateChart(_nameToDataSeries)","_refreshDataSeries(_tagFilter)"],reload(){this.$.loader.reload()},redraw(){this.$.loader.redraw()},_toggleExpanded(){this.set("_expanded",!this._expanded);this.redraw()},_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)},_resetDomain(){const b=this.$.loader;b&&b.resetDomain()},_csvUrl(b,d){if(!d)return"";b=this._downloadDataUrl(b,d);return vc.addParams(b,{format:"csv"})},_jsonUrl(b,d){if(!d)return"";b=this._downloadDataUrl(b,d);return vc.addParams(b,
{format:"json"})},_downloadDataUrl(b,d){b=b[d];b={tag:b.getTag(),run:b.getRun()};return vc.addParams(vc.getRouter().pluginRoute("custom_scalars","/download_data"),b)},_createProcessDataFunction(){return(b,d,f)=>{if(f.regex_valid){const h=_.clone(this._nameToDataSeries);_.forOwn(f.tag_to_events,(k,t)=>{const l=k.map(m=>({wall_time:new Date(1E3*m[0]),step:m[1],scalar:m[2]}));k=Ti.generateDataSeriesName(d,t);const p=h[k];p?p.setData(l):(_.isUndefined(this._runToNextAvailableSymbolIndex[d])&&(this._runToNextAvailableSymbolIndex[d]=
0),t=new Ti.DataSeries(d,t,k,l,rg.SYMBOLS_LIST[this._runToNextAvailableSymbolIndex[d]]),h[k]=t,this._runToNextAvailableSymbolIndex[d]=(this._runToNextAvailableSymbolIndex[d]+1)%rg.SYMBOLS_LIST.length)});this.set("_nameToDataSeries",h)}}},_updateChart(b){Object.entries(b).forEach(([d,f])=>{this.$.loader.setSeriesData(d,f.getData())})},_computeSelectedRunsSet(b){const d={};_.forEach(b,f=>{d[f]=1});return d},_computeSeriesNames(){const b=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter(([,
d])=>b.has(d.run)).map(([d])=>d)},_determineColor(b,d){return b.scale(d)},_refreshDataSeries(){this.set("_nameToDataSeries",{})},_createSymbolFunction(){return b=>this._nameToDataSeries[b].getSymbol().method()},_determineSymbol(b,d){return b[d].getSymbol().character},_computeTagFilter(b){return 1===b.length?b[0]:b.map(d=>"("+d+")").join("|")},_getToggleMatchesIcon(b){return b?"expand-less":"expand-more"},_toggleMatchesOpen(){this.set("_matchesListOpened",!this._matchesListOpened)},_computeTitleDisplayString(b){return b||
"untitled"},_matchListEntryColorUpdated(){const b=this.$$("#match-list-repeat");b&&this.root.querySelectorAll(".match-list-entry").forEach(d=>{const f=b.itemForElement(d);d.style.color=this._determineColor(this._colorScale,f)})}});

//# sourceURL=build://tf-custom-scalar-dashboard/tf-custom-scalar-dashboard.html.js
Polymer({is:"tf-custom-scalar-dashboard",properties:{_requestManager:{type:Object,value:()=>new vc.RequestManager(50)},_canceller:{type:Object,value:()=>new vc.Canceller},_selectedRuns:Array,_showDownloadLinks:{type:Boolean,notify:!0,value:pd.getBooleanInitializer("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),observer:"_showDownloadLinksObserver"},_smoothingEnabled:{type:Boolean,computed:"_computeSmoothingEnabled(_smoothingWeight)"},_smoothingWeight:{type:Number,notify:!0,value:pd.getNumberInitializer("_smoothingWeight",
{defaultValue:.6}),observer:"_smoothingWeightObserver"},_ignoreYOutliers:{type:Boolean,value:pd.getBooleanInitializer("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}),observer:"_ignoreYOutliersObserver"},_xType:{type:String,value:"step"},_layout:Object,_dataNotFound:Boolean,_categories:{type:Array,computed:"_makeCategories(_layout)"},_openedCategories:{type:Object},_active:{type:Boolean,value:!0,readOnly:!0}},ready(){this.reload()},reload(){const b=vc.getRouter().pluginsListing(),d=this._canceller.cancellable(f=>
{f.cancelled||(this.set("_dataNotFound",!f.value.custom_scalars),this._dataNotFound||this._retrieveLayoutAndData())});this._requestManager.request(b).then(d)},_reloadCharts(){this.root.querySelectorAll("tf-custom-scalar-margin-chart-card, tf-custom-scalar-multi-line-chart-card").forEach(b=>{b.reload()})},_retrieveLayoutAndData(){const b=vc.getRouter().pluginRoute("custom_scalars","/layout"),d=this._canceller.cancellable(f=>{f.cancelled||(this.set("_layout",f.value),this._dataNotFound||this._reloadCharts())});
this._requestManager.request(b).then(d)},_showDownloadLinksObserver:pd.getBooleanObserver("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),_smoothingWeightObserver:pd.getNumberObserver("_smoothingWeight",{defaultValue:.6}),_ignoreYOutliersObserver:pd.getBooleanObserver("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}),_computeSmoothingEnabled(b){return 0<b},_makeCategories(b){if(!b.category)return[];let d=!1;this._openedCategories||(d=!0,this._openedCategories={});return b.category.map(f=>
{d&&!f.closed&&(this._openedCategories[f.title]=!0);return{name:f.title,items:f.chart,metadata:{opened:!!this._openedCategories[f.title]}}})},_categoryOpenedToggled(b){b=b.target;b.opened?this._openedCategories[b.category.name]=!0:delete this._openedCategories[b.category.name]}});

//# sourceURL=build://tf-image-dashboard/tf-image-loader.html.js
Polymer({is:"tf-image-loader",properties:{run:String,tag:String,sample:Number,ofSamples:Number,tagMetadata:Object,_runColor:{type:String,computed:"_computeRunColor(run)"},actualSize:{type:Boolean,value:!1,reflectToAttribute:!0},brightnessAdjustment:{type:Number,value:.5},contrastPercentage:{type:Number,value:0},requestManager:Object,_metadataCanceller:{type:Object,value:()=>new vc.Canceller},_imageCanceller:{type:Object,value:()=>new vc.Canceller},_steps:{type:Array,value:[],notify:!0},_stepIndex:{type:Number,
notify:!0},_currentStep:{type:Object,computed:"_computeCurrentStep(_steps, _stepIndex)"},_hasAtLeastOneStep:{type:Boolean,computed:"_computeHasAtLeastOneStep(_steps)"},_hasMultipleSteps:{type:Boolean,computed:"_computeHasMultipleSteps(_steps)"},_stepValue:{type:Number,computed:"_computeStepValue(_currentStep)"},_currentWallTime:{type:String,computed:"_computeCurrentWallTime(_currentStep)"},_maxStepIndex:{type:Number,computed:"_computeMaxStepIndex(_steps)"},_sampleText:{type:String,computed:"_computeSampleText(sample)"},
_hasMultipleSamples:{type:Boolean,computed:"_computeHasMultipleSamples(ofSamples)"},_isImageLoading:{type:Boolean,value:!1}},observers:["reload(run, tag)","_updateImageUrl(_currentStep, brightnessAdjustment, contrastPercentage)"],_computeRunColor(b){return pf.runsColorScale(b)},_computeHasAtLeastOneStep(b){return!!b&&0<b.length},_computeHasMultipleSteps(b){return!!b&&1<b.length},_computeCurrentStep(b,d){return b[d]||null},_computeStepValue(b){return b?b.step:0},_computeCurrentWallTime(b){return b?
Hh.formatDate(b.wall_time):""},_computeMaxStepIndex(b){return b.length-1},_computeSampleText(b){return`${b+1}`},_computeHasMultipleSamples(b){return 1<b},_getAriaExpanded(){return this.actualSize?"true":"false"},attached(){this._attached=!0;this.reload()},reload(){if(this._attached){this._metadataCanceller.cancelAll();var b=vc.addParams(vc.getRouter().pluginRoute("images","/images"),{tag:this.tag,run:this.run,sample:this.sample}),d=this._metadataCanceller.cancellable(f=>{f.cancelled||(f=f.value.map(this._createStepDatum.bind(this)),
this.set("_steps",f),this.set("_stepIndex",f.length-1))});this.requestManager.request(b).then(d)}},_createStepDatum(b){let d=vc.getRouter().pluginRoute("images","/individualImage");d=vc.addParams(d,{ts:b.wall_time});d+="\x26"+b.query;return{wall_time:new Date(1E3*b.wall_time),step:b.step,url:d}},_updateImageUrl(b,d,f){if(b){var h=new Image;this._imageCanceller.cancelAll();h.onload=h.onerror=this._imageCanceller.cancellable(k=>{k.cancelled||(k=this.$$("#main-image-container"),k.innerHTML="",Polymer.dom(k).appendChild(h),
this.set("_isImageLoading",!1))}).bind(this);h.style.filter=`contrast(${f}%) `;h.style.filter+=`brightness(${d})`;this.set("_isImageLoading",!0);h.src=b.url}},_handleTap(){this.set("actualSize",!this.actualSize)},_toLocaleString(b){return b.toLocaleString()}});

//# sourceURL=build://tf-image-dashboard/tf-image-dashboard.html.js
Polymer({is:"tf-image-dashboard",properties:{_selectedRuns:Array,_runToTagInfo:Object,_dataNotFound:Boolean,_actualSize:Boolean,_defaultBrightnessAdjustment:{type:Number,value:1,readOnly:!0},_defaultContrastPercentage:{type:Number,value:100,readOnly:!0},_brightnessAdjustment:{type:Number,value:1},_contrastPercentage:{type:Number,value:100},_tagFilter:String,_brightnessIsDefault:{type:Boolean,computed:"_computeBrightnessIsDefault(_brightnessAdjustment)"},_contrastIsDefault:{type:Boolean,computed:"_computeContrastIsDefault(_contrastPercentage)"},
_categoriesDomReady:Boolean,_categories:{type:Array,computed:"_makeCategories(_runToTagInfo, _selectedRuns, _tagFilter, _categoriesDomReady)"},_requestManager:{type:Object,value:()=>new vc.RequestManager}},ready(){this.reload()},reload(){this._fetchTags().then(()=>{this._reloadImages()})},_fetchTags(){const b=vc.getRouter().pluginRoute("images","/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,this._runToTagInfo)){var f=_.mapValues(d,h=>Object.keys(h));f=vc.getTags(f);this.set("_dataNotFound",
0===f.length);this.set("_runToTagInfo",d);this.async(()=>{this.set("_categoriesDomReady",!0)})}})},_reloadImages(){this.root.querySelectorAll("tf-image-loader").forEach(b=>{b.reload()})},_shouldOpen(b){return 2>=b},_resetBrightness(){this._brightnessAdjustment=this._defaultBrightnessAdjustment},_resetContrast(){this._contrastPercentage=this._defaultContrastPercentage},_computeBrightnessIsDefault(b){return b===this._defaultBrightnessAdjustment},_computeContrastIsDefault(b){return b===this._defaultContrastPercentage},
_makeCategories(b,d,f){function h(t){const l=b[t.run][t.tag].samples;return _.range(l).map(p=>Object.assign({},t,{sample:p,ofSamples:l}))}const k=_.mapValues(b,t=>Object.keys(t));return $c.categorizeRunTagCombinations(k,d,f).map(t=>Object.assign({},t,{items:[].concat.apply([],t.items.map(h))}))},_tagMetadata(b,d,f){return b[d][f]}});

//# sourceURL=build://tf-audio-dashboard/tf-audio-loader.html.js
Polymer({is:"tf-audio-loader",properties:{run:String,tag:String,sample:Number,totalSamples:Number,tagMetadata:Object,_runColor:{type:String,computed:"_computeRunColor(run)"},requestManager:Object,_metadataCanceller:{type:Object,value:()=>new vc.Canceller},_steps:{type:Array,value:()=>[]},_stepIndex:Number,_hasAtLeastOneStep:{type:Boolean,computed:"_computeHasAtLeastOneStep(_steps)"},_hasMultipleSteps:{type:Boolean,computed:"_computeHasMultipleSteps(_steps)"},_currentDatum:{type:Object,computed:"_computeCurrentDatum(_steps, _stepIndex)"},
_maxStepIndex:{type:Number,computed:"_computeMaxStepIndex(_steps)"},_sampleText:{type:String,computed:"_computeSampleText(sample)"},_hasMultipleSamples:{type:Boolean,computed:"_computeHasMultipleSamples(totalSamples)"}},observers:["reload(run, tag)"],_computeRunColor(b){return pf.runsColorScale(b)},_computeHasAtLeastOneStep(b){return!!b&&0<b.length},_computeHasMultipleSteps(b){return!!b&&1<b.length},_computeMaxStepIndex(b){return b.length-1},_computeCurrentDatum(b,d){return b[d]},_computeSampleText(b){return`${b+
1}`},_computeHasMultipleSamples(b){return 1<b},attached(){this._attached=!0;this.reload()},reload(){if(this._attached){this._metadataCanceller.cancelAll();var b=vc.getRouter().pluginRoute("audio","/audio",new URLSearchParams({tag:this.tag,run:this.run,sample:this.sample})),d=this._metadataCanceller.cancellable(f=>{f.cancelled||(f=f.value.map(this._createStepDatum.bind(this)),this.set("_steps",f),this.set("_stepIndex",f.length-1))});this.requestManager.request(b).then(d)}},_createStepDatum(b){var d=
new URLSearchParams(b.query);d.append("ts",b.wall_time);d=vc.getRouter().pluginRoute("audio","/individualAudio",d);return{wall_time:Hh.formatDate(new Date(1E3*b.wall_time)),step:b.step,label:b.label,contentType:b.contentType,url:d}}});

//# sourceURL=build://tf-audio-dashboard/tf-audio-dashboard.html.js
Polymer({is:"tf-audio-dashboard",properties:{_selectedRuns:Array,_runToTagInfo:Object,_dataNotFound:Boolean,_tagFilter:{type:String,value:""},_categories:{type:Array,computed:"_makeCategories(_runToTagInfo, _selectedRuns, _tagFilter)"},_requestManager:{type:Object,value:()=>new vc.RequestManager}},ready(){this.reload()},reload(){this._fetchTags().then(()=>{this._reloadAudio()})},_fetchTags(){const b=vc.getRouter().pluginRoute("audio","/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,
this._runToTagInfo)){var f=_.mapValues(d,h=>Object.keys(h));f=vc.getTags(f);this.set("_dataNotFound",0===f.length);this.set("_runToTagInfo",d)}})},_reloadAudio(){this.root.querySelectorAll("tf-audio-loader").forEach(b=>{b.reload()})},_shouldOpen(b){return 2>=b},_makeCategories(b,d,f){function h(t){const l=b[t.run][t.tag].samples;return _.range(l).map(p=>Object.assign({},t,{sample:p,totalSamples:l}))}const k=_.mapValues(b,t=>Object.keys(t));return $c.categorizeRunTagCombinations(k,d,f).map(t=>Object.assign({},
t,{items:[].concat.apply([],t.items.map(h))}))},_tagMetadata(b,d,f){return b[d][f]}});

//# sourceURL=build://iron-autogrow-textarea/iron-autogrow-textarea.html.js
Polymer({is:"iron-autogrow-textarea",behaviors:[Polymer.IronValidatableBehavior,Polymer.IronControlState],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},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(b){this.$.textarea.selectionStart=b},set selectionEnd(b){this.$.textarea.selectionEnd=b},attached:function(){navigator.userAgent.match(/iP(?:[oa]d|hone)/)&&(this.$.textarea.style.marginLeft="-3px")},validate:function(){var b=this.$.textarea.validity.valid;
b&&(this.required&&""===this.value?b=!1:this.hasValidator()&&(b=Polymer.IronValidatableBehavior.validate.call(this,this.value)));this.invalid=!b;this.fire("iron-input-validate");return b},_bindValueChanged:function(b){this.value=b},_valueChanged:function(b){var d=this.textarea;d&&(d.value!==b&&(d.value=b||0===b?b:""),this.bindValue=b,this.$.mirror.innerHTML=this._valueForMirror(),this.fire("bind-value-changed",{value:this.bindValue}))},_onInput:function(b){var d=Polymer.dom(b).path;this.value=d?d[0].value:
b.target.value},_constrain:function(b){b=b||[""];for(b=0<this.maxRows&&b.length>this.maxRows?b.slice(0,this.maxRows):b.slice(0);0<this.rows&&b.length<this.rows;)b.push("");return b.join("\x3cbr/\x3e")+"\x26#160;"},_valueForMirror:function(){var b=this.textarea;if(b)return this.tokens=b&&b.value?b.value.replace(/&/gm,"\x26amp;").replace(/"/gm,"\x26quot;").replace(/'/gm,"\x26#39;").replace(/</gm,"\x26lt;").replace(/>/gm,"\x26gt;").split("\n"):[""],this._constrain(this.tokens)},_updateCached:function(){this.$.mirror.innerHTML=
this._constrain(this.tokens)}});

//# sourceURL=build://paper-input/paper-textarea.html.js
Polymer({is:"paper-textarea",behaviors:[Polymer.PaperInputBehavior,Polymer.IronFormElementBehavior],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(b){this.$.input.textarea.selectionStart=b},get selectionEnd(){return this.$.input.textarea.selectionEnd},
set selectionEnd(b){this.$.input.textarea.selectionEnd=b},_ariaLabelledByChanged:function(b){this._focusableElement.setAttribute("aria-labelledby",b)},_ariaDescribedByChanged:function(b){this._focusableElement.setAttribute("aria-describedby",b)},get _focusableElement(){return this.inputElement.textarea}});

//# sourceURL=build://paper-toast/paper-toast.html.js
(function(){var b=null;Polymer({is:"paper-toast",behaviors:[Polymer.IronOverlayBehavior],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(){Polymer.Base._warn("`visible` is deprecated, use `opened` instead");
return this.opened},get _canAutoClose(){return 0<this.duration&&Infinity!==this.duration},created:function(){this._autoClose=null;Polymer.IronA11yAnnouncer.requestAvailability()},show:function(d){"string"==typeof d&&(d={text:d});for(var f in d)0===f.indexOf("_")?Polymer.Base._warn('The property "'+f+'" is private and was not set.'):f in this?this[f]=d[f]:Polymer.Base._warn('The property "'+f+'" is not valid.');this.open()},hide:function(){this.close()},__onTransitionEnd:function(d){d&&d.target===
this&&"opacity"===d.propertyName&&(this.opened?this._finishRenderOpened():this._finishRenderClosed())},_openedChanged:function(){null!==this._autoClose&&(this.cancelAsync(this._autoClose),this._autoClose=null);this.opened?(b&&b!==this&&b.close(),b=this,this.fire("iron-announce",{text:this.text}),this._canAutoClose&&(this._autoClose=this.async(this.close,this.duration))):b===this&&(b=null);Polymer.IronOverlayBehaviorImpl._openedChanged.apply(this,arguments)},_renderOpened:function(){this.classList.add("paper-toast-open")},
_renderClosed:function(){this.classList.remove("paper-toast-open")},_onFitIntoChanged:function(d){this.positionTarget=d}})})();

//# sourceURL=build://paper-toggle-button/paper-toggle-button.html.js
Polymer({is:"paper-toggle-button",behaviors:[Polymer.PaperCheckedElementBehavior],hostAttributes:{role:"button","aria-pressed":"false",tabindex:0},properties:{},listeners:{track:"_ontrack"},attached:function(){Polymer.RenderStatus.afterNextRender(this,function(){Polymer.Gestures.setTouchAction(this,"pan-y")})},_ontrack:function(b){b=b.detail;"start"===b.state?this._trackStart(b):"track"===b.state?this._trackMove(b):"end"===b.state&&this._trackEnd(b)},_trackStart:function(){this._width=this.$.toggleBar.offsetWidth/
2;this._trackChecked=this.checked;this.$.toggleButton.classList.add("dragging")},_trackMove:function(b){b=b.dx;this._x=Math.min(this._width,Math.max(0,this._trackChecked?this._width+b:b));this.translate3d(this._x+"px",0,0,this.$.toggleButton);this._userActivate(this._x>this._width/2)},_trackEnd:function(){this.$.toggleButton.classList.remove("dragging");this.transform("",this.$.toggleButton)},_createRipple:function(){this._rippleContainer=this.$.toggleButton;var b=Polymer.PaperRippleBehavior._createRipple();
b.id="ink";b.setAttribute("recenters","");b.classList.add("circle","toggle-ink");return b}});

(function(f){if(typeof exports==="object"&&typeof module!=="undefined")module.exports=f();else if(typeof define==="function"&&define.amd)define([],f);else{var g;if(typeof window!=="undefined")g=window;else if(typeof global!=="undefined")g=global;else if(typeof self!=="undefined")g=self;else g=this;g.graphlib=f()}})(function(){var define,module,exports;return function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);
var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f;}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s}({1:[function(require,module,exports){var lib=require("./lib");module.exports={Graph:lib.Graph,json:require("./lib/json"),alg:require("./lib/alg"),version:lib.version}},{"./lib":17,"./lib/alg":8,"./lib/json":18}],
2:[function(require,module,exports){var _=require("../lodash");module.exports=components;function components(g){var visited={},cmpts=[],cmpt;function dfs(v){if(_.has(visited,v))return;visited[v]=true;cmpt.push(v);_.each(g.successors(v),dfs);_.each(g.predecessors(v),dfs)}_.each(g.nodes(),function(v){cmpt=[];dfs(v);if(cmpt.length)cmpts.push(cmpt)});return cmpts}},{"../lodash":19}],3:[function(require,module,exports){var _=require("../lodash");module.exports=dfs;function dfs(g,vs,order){if(!_.isArray(vs))vs=
[vs];var navigation=(g.isDirected()?g.successors:g.neighbors).bind(g);var acc=[],visited={};_.each(vs,function(v){if(!g.hasNode(v))throw new Error("Graph does not have node: "+v);doDfs(g,v,order==="post",visited,navigation,acc)});return acc}function doDfs(g,v,postorder,visited,navigation,acc){if(!_.has(visited,v)){visited[v]=true;if(!postorder)acc.push(v);_.each(navigation(v),function(w){doDfs(g,w,postorder,visited,navigation,acc)});if(postorder)acc.push(v)}}},{"../lodash":19}],4:[function(require,
module,exports){var dijkstra=require("./dijkstra"),_=require("../lodash");module.exports=dijkstraAll;function dijkstraAll(g,weightFunc,edgeFunc){return _.transform(g.nodes(),function(acc,v){acc[v]=dijkstra(g,v,weightFunc,edgeFunc)},{})}},{"../lodash":19,"./dijkstra":5}],5:[function(require,module,exports){var _=require("../lodash"),PriorityQueue=require("../data/priority-queue");module.exports=dijkstra;var DEFAULT_WEIGHT_FUNC=_.constant(1);function dijkstra(g,source,weightFn,edgeFn){return runDijkstra(g,
String(source),weightFn||DEFAULT_WEIGHT_FUNC,edgeFn||function(v){return g.outEdges(v)})}function runDijkstra(g,source,weightFn,edgeFn){var results={},pq=new PriorityQueue,v,vEntry;var updateNeighbors=function(edge){var w=edge.v!==v?edge.v:edge.w,wEntry=results[w],weight=weightFn(edge),distance=vEntry.distance+weight;if(weight<0)throw new Error("dijkstra does not allow negative edge weights. "+"Bad edge: "+edge+" Weight: "+weight);if(distance<wEntry.distance){wEntry.distance=distance;wEntry.predecessor=
v;pq.decrease(w,distance)}};g.nodes().forEach(function(v){var distance=v===source?0:Number.POSITIVE_INFINITY;results[v]={distance:distance};pq.add(v,distance)});while(pq.size()>0){v=pq.removeMin();vEntry=results[v];if(vEntry.distance===Number.POSITIVE_INFINITY)break;edgeFn(v).forEach(updateNeighbors)}return results}},{"../data/priority-queue":15,"../lodash":19}],6:[function(require,module,exports){var _=require("../lodash"),tarjan=require("./tarjan");module.exports=findCycles;function findCycles(g){return _.filter(tarjan(g),
function(cmpt){return cmpt.length>1||cmpt.length===1&&g.hasEdge(cmpt[0],cmpt[0])})}},{"../lodash":19,"./tarjan":13}],7:[function(require,module,exports){var _=require("../lodash");module.exports=floydWarshall;var DEFAULT_WEIGHT_FUNC=_.constant(1);function floydWarshall(g,weightFn,edgeFn){return runFloydWarshall(g,weightFn||DEFAULT_WEIGHT_FUNC,edgeFn||function(v){return g.outEdges(v)})}function runFloydWarshall(g,weightFn,edgeFn){var results={},nodes=g.nodes();nodes.forEach(function(v){results[v]=
{};results[v][v]={distance:0};nodes.forEach(function(w){if(v!==w)results[v][w]={distance:Number.POSITIVE_INFINITY}});edgeFn(v).forEach(function(edge){var w=edge.v===v?edge.w:edge.v,d=weightFn(edge);results[v][w]={distance:d,predecessor:v}})});nodes.forEach(function(k){var rowK=results[k];nodes.forEach(function(i){var rowI=results[i];nodes.forEach(function(j){var ik=rowI[k];var kj=rowK[j];var ij=rowI[j];var altDistance=ik.distance+kj.distance;if(altDistance<ij.distance){ij.distance=altDistance;ij.predecessor=
kj.predecessor}})})});return results}},{"../lodash":19}],8:[function(require,module,exports){module.exports={components:require("./components"),dijkstra:require("./dijkstra"),dijkstraAll:require("./dijkstra-all"),findCycles:require("./find-cycles"),floydWarshall:require("./floyd-warshall"),isAcyclic:require("./is-acyclic"),postorder:require("./postorder"),preorder:require("./preorder"),prim:require("./prim"),tarjan:require("./tarjan"),topsort:require("./topsort")}},{"./components":2,"./dijkstra":5,
"./dijkstra-all":4,"./find-cycles":6,"./floyd-warshall":7,"./is-acyclic":9,"./postorder":10,"./preorder":11,"./prim":12,"./tarjan":13,"./topsort":14}],9:[function(require,module,exports){var topsort=require("./topsort");module.exports=isAcyclic;function isAcyclic(g){try{topsort(g)}catch(e){if(e instanceof topsort.CycleException)return false;throw e;}return true}},{"./topsort":14}],10:[function(require,module,exports){var dfs=require("./dfs");module.exports=postorder;function postorder(g,vs){return dfs(g,
vs,"post")}},{"./dfs":3}],11:[function(require,module,exports){var dfs=require("./dfs");module.exports=preorder;function preorder(g,vs){return dfs(g,vs,"pre")}},{"./dfs":3}],12:[function(require,module,exports){var _=require("../lodash"),Graph=require("../graph"),PriorityQueue=require("../data/priority-queue");module.exports=prim;function prim(g,weightFunc){var result=new Graph,parents={},pq=new PriorityQueue,v;function updateNeighbors(edge){var w=edge.v===v?edge.w:edge.v,pri=pq.priority(w);if(pri!==
undefined){var edgeWeight=weightFunc(edge);if(edgeWeight<pri){parents[w]=v;pq.decrease(w,edgeWeight)}}}if(g.nodeCount()===0)return result;_.each(g.nodes(),function(v){pq.add(v,Number.POSITIVE_INFINITY);result.setNode(v)});pq.decrease(g.nodes()[0],0);var init=false;while(pq.size()>0){v=pq.removeMin();if(_.has(parents,v))result.setEdge(v,parents[v]);else if(init)throw new Error("Input graph is not connected: "+g);else init=true;g.nodeEdges(v).forEach(updateNeighbors)}return result}},{"../data/priority-queue":15,
"../graph":16,"../lodash":19}],13:[function(require,module,exports){var _=require("../lodash");module.exports=tarjan;function tarjan(g){var index=0,stack=[],visited={},results=[];function dfs(v){var entry=visited[v]={onStack:true,lowlink:index,index:index++};stack.push(v);g.successors(v).forEach(function(w){if(!_.has(visited,w)){dfs(w);entry.lowlink=Math.min(entry.lowlink,visited[w].lowlink)}else if(visited[w].onStack)entry.lowlink=Math.min(entry.lowlink,visited[w].index)});if(entry.lowlink===entry.index){var cmpt=
[],w;do{w=stack.pop();visited[w].onStack=false;cmpt.push(w)}while(v!==w);results.push(cmpt)}}g.nodes().forEach(function(v){if(!_.has(visited,v))dfs(v)});return results}},{"../lodash":19}],14:[function(require,module,exports){var _=require("../lodash");module.exports=topsort;topsort.CycleException=CycleException;function topsort(g){var visited={},stack={},results=[];function visit(node){if(_.has(stack,node))throw new CycleException;if(!_.has(visited,node)){stack[node]=true;visited[node]=true;_.each(g.predecessors(node),
visit);delete stack[node];results.push(node)}}_.each(g.sinks(),visit);if(_.size(visited)!==g.nodeCount())throw new CycleException;return results}function CycleException(){}},{"../lodash":19}],15:[function(require,module,exports){var _=require("../lodash");module.exports=PriorityQueue;function PriorityQueue(){this._arr=[];this._keyIndices={}}PriorityQueue.prototype.size=function(){return this._arr.length};PriorityQueue.prototype.keys=function(){return this._arr.map(function(x){return x.key})};PriorityQueue.prototype.has=
function(key){return _.has(this._keyIndices,key)};PriorityQueue.prototype.priority=function(key){var index=this._keyIndices[key];if(index!==undefined)return this._arr[index].priority};PriorityQueue.prototype.min=function(){if(this.size()===0)throw new Error("Queue underflow");return this._arr[0].key};PriorityQueue.prototype.add=function(key,priority){var keyIndices=this._keyIndices;key=String(key);if(!_.has(keyIndices,key)){var arr=this._arr;var index=arr.length;keyIndices[key]=index;arr.push({key:key,
priority:priority});this._decrease(index);return true}return false};PriorityQueue.prototype.removeMin=function(){this._swap(0,this._arr.length-1);var min=this._arr.pop();delete this._keyIndices[min.key];this._heapify(0);return min.key};PriorityQueue.prototype.decrease=function(key,priority){var index=this._keyIndices[key];if(priority>this._arr[index].priority)throw new Error("New priority is greater than current priority. "+"Key: "+key+" Old: "+this._arr[index].priority+" New: "+priority);this._arr[index].priority=
priority;this._decrease(index)};PriorityQueue.prototype._heapify=function(i){var arr=this._arr;var l=2*i,r=l+1,largest=i;if(l<arr.length){largest=arr[l].priority<arr[largest].priority?l:largest;if(r<arr.length)largest=arr[r].priority<arr[largest].priority?r:largest;if(largest!==i){this._swap(i,largest);this._heapify(largest)}}};PriorityQueue.prototype._decrease=function(index){var arr=this._arr;var priority=arr[index].priority;var parent;while(index!==0){parent=index>>1;if(arr[parent].priority<priority)break;
this._swap(index,parent);index=parent}};PriorityQueue.prototype._swap=function(i,j){var arr=this._arr;var keyIndices=this._keyIndices;var origArrI=arr[i];var origArrJ=arr[j];arr[i]=origArrJ;arr[j]=origArrI;keyIndices[origArrJ.key]=i;keyIndices[origArrI.key]=j}},{"../lodash":19}],16:[function(require,module,exports){var _=require("./lodash");module.exports=Graph;var DEFAULT_EDGE_NAME="\x00",GRAPH_NODE="\x00",EDGE_KEY_DELIM="\u0001";function Graph(opts){this._isDirected=_.has(opts,"directed")?opts.directed:
true;this._isMultigraph=_.has(opts,"multigraph")?opts.multigraph:false;this._isCompound=_.has(opts,"compound")?opts.compound:false;this._label=undefined;this._defaultNodeLabelFn=_.constant(undefined);this._defaultEdgeLabelFn=_.constant(undefined);this._nodes={};if(this._isCompound){this._parent={};this._children={};this._children[GRAPH_NODE]={}}this._in={};this._preds={};this._out={};this._sucs={};this._edgeObjs={};this._edgeLabels={}}Graph.prototype._nodeCount=0;Graph.prototype._edgeCount=0;Graph.prototype.isDirected=
function(){return this._isDirected};Graph.prototype.isMultigraph=function(){return this._isMultigraph};Graph.prototype.isCompound=function(){return this._isCompound};Graph.prototype.setGraph=function(label){this._label=label;return this};Graph.prototype.graph=function(){return this._label};Graph.prototype.setDefaultNodeLabel=function(newDefault){if(!_.isFunction(newDefault))newDefault=_.constant(newDefault);this._defaultNodeLabelFn=newDefault;return this};Graph.prototype.nodeCount=function(){return this._nodeCount};
Graph.prototype.nodes=function(){return _.keys(this._nodes)};Graph.prototype.sources=function(){var self=this;return _.filter(this.nodes(),function(v){return _.isEmpty(self._in[v])})};Graph.prototype.sinks=function(){var self=this;return _.filter(this.nodes(),function(v){return _.isEmpty(self._out[v])})};Graph.prototype.setNodes=function(vs,value){var args=arguments;var self=this;_.each(vs,function(v){if(args.length>1)self.setNode(v,value);else self.setNode(v)});return this};Graph.prototype.setNode=
function(v,value){if(_.has(this._nodes,v)){if(arguments.length>1)this._nodes[v]=value;return this}this._nodes[v]=arguments.length>1?value:this._defaultNodeLabelFn(v);if(this._isCompound){this._parent[v]=GRAPH_NODE;this._children[v]={};this._children[GRAPH_NODE][v]=true}this._in[v]={};this._preds[v]={};this._out[v]={};this._sucs[v]={};++this._nodeCount;return this};Graph.prototype.node=function(v){return this._nodes[v]};Graph.prototype.hasNode=function(v){return _.has(this._nodes,v)};Graph.prototype.removeNode=
function(v){var self=this;if(_.has(this._nodes,v)){var removeEdge=function(e){self.removeEdge(self._edgeObjs[e])};delete this._nodes[v];if(this._isCompound){this._removeFromParentsChildList(v);delete this._parent[v];_.each(this.children(v),function(child){self.setParent(child)});delete this._children[v]}_.each(_.keys(this._in[v]),removeEdge);delete this._in[v];delete this._preds[v];_.each(_.keys(this._out[v]),removeEdge);delete this._out[v];delete this._sucs[v];--this._nodeCount}return this};Graph.prototype.setParent=
function(v,parent){if(!this._isCompound)throw new Error("Cannot set parent in a non-compound graph");if(_.isUndefined(parent))parent=GRAPH_NODE;else{parent+="";for(var ancestor=parent;!_.isUndefined(ancestor);ancestor=this.parent(ancestor))if(ancestor===v)throw new Error("Setting "+parent+" as parent of "+v+" would create a cycle");this.setNode(parent)}this.setNode(v);this._removeFromParentsChildList(v);this._parent[v]=parent;this._children[parent][v]=true;return this};Graph.prototype._removeFromParentsChildList=
function(v){delete this._children[this._parent[v]][v]};Graph.prototype.parent=function(v){if(this._isCompound){var parent=this._parent[v];if(parent!==GRAPH_NODE)return parent}};Graph.prototype.children=function(v){if(_.isUndefined(v))v=GRAPH_NODE;if(this._isCompound){var children=this._children[v];if(children)return _.keys(children)}else if(v===GRAPH_NODE)return this.nodes();else if(this.hasNode(v))return[]};Graph.prototype.predecessors=function(v){var predsV=this._preds[v];if(predsV)return _.keys(predsV)};
Graph.prototype.successors=function(v){var sucsV=this._sucs[v];if(sucsV)return _.keys(sucsV)};Graph.prototype.neighbors=function(v){var preds=this.predecessors(v);if(preds)return _.union(preds,this.successors(v))};Graph.prototype.isLeaf=function(v){var neighbors;if(this.isDirected())neighbors=this.successors(v);else neighbors=this.neighbors(v);return neighbors.length===0};Graph.prototype.filterNodes=function(filter){var copy=new this.constructor({directed:this._isDirected,multigraph:this._isMultigraph,
compound:this._isCompound});copy.setGraph(this.graph());var self=this;_.each(this._nodes,function(value,v){if(filter(v))copy.setNode(v,value)});_.each(this._edgeObjs,function(e){if(copy.hasNode(e.v)&&copy.hasNode(e.w))copy.setEdge(e,self.edge(e))});var parents={};function findParent(v){var parent=self.parent(v);if(parent===undefined||copy.hasNode(parent)){parents[v]=parent;return parent}else if(parent in parents)return parents[parent];else return findParent(parent)}if(this._isCompound)_.each(copy.nodes(),
function(v){copy.setParent(v,findParent(v))});return copy};Graph.prototype.setDefaultEdgeLabel=function(newDefault){if(!_.isFunction(newDefault))newDefault=_.constant(newDefault);this._defaultEdgeLabelFn=newDefault;return this};Graph.prototype.edgeCount=function(){return this._edgeCount};Graph.prototype.edges=function(){return _.values(this._edgeObjs)};Graph.prototype.setPath=function(vs,value){var self=this,args=arguments;_.reduce(vs,function(v,w){if(args.length>1)self.setEdge(v,w,value);else self.setEdge(v,
w);return w});return this};Graph.prototype.setEdge=function(){var v,w,name,value,valueSpecified=false,arg0=arguments[0];if(typeof arg0==="object"&&arg0!==null&&"v"in arg0){v=arg0.v;w=arg0.w;name=arg0.name;if(arguments.length===2){value=arguments[1];valueSpecified=true}}else{v=arg0;w=arguments[1];name=arguments[3];if(arguments.length>2){value=arguments[2];valueSpecified=true}}v=""+v;w=""+w;if(!_.isUndefined(name))name=""+name;var e=edgeArgsToId(this._isDirected,v,w,name);if(_.has(this._edgeLabels,
e)){if(valueSpecified)this._edgeLabels[e]=value;return this}if(!_.isUndefined(name)&&!this._isMultigraph)throw new Error("Cannot set a named edge when isMultigraph \x3d false");this.setNode(v);this.setNode(w);this._edgeLabels[e]=valueSpecified?value:this._defaultEdgeLabelFn(v,w,name);var edgeObj=edgeArgsToObj(this._isDirected,v,w,name);v=edgeObj.v;w=edgeObj.w;Object.freeze(edgeObj);this._edgeObjs[e]=edgeObj;incrementOrInitEntry(this._preds[w],v);incrementOrInitEntry(this._sucs[v],w);this._in[w][e]=
edgeObj;this._out[v][e]=edgeObj;this._edgeCount++;return this};Graph.prototype.edge=function(v,w,name){var e=arguments.length===1?edgeObjToId(this._isDirected,arguments[0]):edgeArgsToId(this._isDirected,v,w,name);return this._edgeLabels[e]};Graph.prototype.hasEdge=function(v,w,name){var e=arguments.length===1?edgeObjToId(this._isDirected,arguments[0]):edgeArgsToId(this._isDirected,v,w,name);return _.has(this._edgeLabels,e)};Graph.prototype.removeEdge=function(v,w,name){var e=arguments.length===1?
edgeObjToId(this._isDirected,arguments[0]):edgeArgsToId(this._isDirected,v,w,name),edge=this._edgeObjs[e];if(edge){v=edge.v;w=edge.w;delete this._edgeLabels[e];delete this._edgeObjs[e];decrementOrRemoveEntry(this._preds[w],v);decrementOrRemoveEntry(this._sucs[v],w);delete this._in[w][e];delete this._out[v][e];this._edgeCount--}return this};Graph.prototype.inEdges=function(v,u){var inV=this._in[v];if(inV){var edges=_.values(inV);if(!u)return edges;return _.filter(edges,function(edge){return edge.v===
u})}};Graph.prototype.outEdges=function(v,w){var outV=this._out[v];if(outV){var edges=_.values(outV);if(!w)return edges;return _.filter(edges,function(edge){return edge.w===w})}};Graph.prototype.nodeEdges=function(v,w){var inEdges=this.inEdges(v,w);if(inEdges)return inEdges.concat(this.outEdges(v,w))};function incrementOrInitEntry(map,k){if(map[k])map[k]++;else map[k]=1}function decrementOrRemoveEntry(map,k){if(!--map[k])delete map[k]}function edgeArgsToId(isDirected,v_,w_,name){var v=""+v_;var w=
""+w_;if(!isDirected&&v>w){var tmp=v;v=w;w=tmp}return v+EDGE_KEY_DELIM+w+EDGE_KEY_DELIM+(_.isUndefined(name)?DEFAULT_EDGE_NAME:name)}function edgeArgsToObj(isDirected,v_,w_,name){var v=""+v_;var w=""+w_;if(!isDirected&&v>w){var tmp=v;v=w;w=tmp}var edgeObj={v:v,w:w};if(name)edgeObj.name=name;return edgeObj}function edgeObjToId(isDirected,edgeObj){return edgeArgsToId(isDirected,edgeObj.v,edgeObj.w,edgeObj.name)}},{"./lodash":19}],17:[function(require,module,exports){module.exports={Graph:require("./graph"),
version:require("./version")}},{"./graph":16,"./version":20}],18:[function(require,module,exports){var _=require("./lodash"),Graph=require("./graph");module.exports={write:write,read:read};function write(g){var json={options:{directed:g.isDirected(),multigraph:g.isMultigraph(),compound:g.isCompound()},nodes:writeNodes(g),edges:writeEdges(g)};if(!_.isUndefined(g.graph()))json.value=_.clone(g.graph());return json}function writeNodes(g){return _.map(g.nodes(),function(v){var nodeValue=g.node(v),parent=
g.parent(v),node={v:v};if(!_.isUndefined(nodeValue))node.value=nodeValue;if(!_.isUndefined(parent))node.parent=parent;return node})}function writeEdges(g){return _.map(g.edges(),function(e){var edgeValue=g.edge(e),edge={v:e.v,w:e.w};if(!_.isUndefined(e.name))edge.name=e.name;if(!_.isUndefined(edgeValue))edge.value=edgeValue;return edge})}function read(json){var g=(new Graph(json.options)).setGraph(json.value);_.each(json.nodes,function(entry){g.setNode(entry.v,entry.value);if(entry.parent)g.setParent(entry.v,
entry.parent)});_.each(json.edges,function(entry){g.setEdge({v:entry.v,w:entry.w,name:entry.name},entry.value)});return g}},{"./graph":16,"./lodash":19}],19:[function(require,module,exports){var lodash;if(typeof require==="function")try{lodash=require("lodash")}catch(e){}if(!lodash)lodash=window._;module.exports=lodash},{"lodash":undefined}],20:[function(require,module,exports){module.exports="2.1.5"},{}]},{},[1])(1)});
(function(f){if(typeof exports==="object"&&typeof module!=="undefined")module.exports=f();else if(typeof define==="function"&&define.amd)define([],f);else{var g;if(typeof window!=="undefined")g=window;else if(typeof global!=="undefined")g=global;else if(typeof self!=="undefined")g=self;else g=this;g.dagre=f()}})(function(){var define,module,exports;return function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=
new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f;}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s}({1:[function(require,module,exports){module.exports={graphlib:require("./lib/graphlib"),layout:require("./lib/layout"),debug:require("./lib/debug"),util:{time:require("./lib/util").time,notime:require("./lib/util").notime},
version:require("./lib/version")}},{"./lib/debug":6,"./lib/graphlib":7,"./lib/layout":9,"./lib/util":29,"./lib/version":30}],2:[function(require,module,exports){var _=require("./lodash"),greedyFAS=require("./greedy-fas");module.exports={run:run,undo:undo};function run(g){var fas=g.graph().acyclicer==="greedy"?greedyFAS(g,weightFn(g)):dfsFAS(g);_.forEach(fas,function(e){var label=g.edge(e);g.removeEdge(e);label.forwardName=e.name;label.reversed=true;g.setEdge(e.w,e.v,label,_.uniqueId("rev"))});function weightFn(g){return function(e){return g.edge(e).weight}}
}function dfsFAS(g){var fas=[],stack={},visited={};function dfs(v){if(_.has(visited,v))return;visited[v]=true;stack[v]=true;_.forEach(g.outEdges(v),function(e){if(_.has(stack,e.w))fas.push(e);else dfs(e.w)});delete stack[v]}_.forEach(g.nodes(),dfs);return fas}function undo(g){_.forEach(g.edges(),function(e){var label=g.edge(e);if(label.reversed){g.removeEdge(e);var forwardName=label.forwardName;delete label.reversed;delete label.forwardName;g.setEdge(e.w,e.v,label,forwardName)}})}},{"./greedy-fas":8,
"./lodash":10}],3:[function(require,module,exports){var _=require("./lodash"),util=require("./util");module.exports=addBorderSegments;function addBorderSegments(g){function dfs(v){var children=g.children(v),node=g.node(v);if(children.length)_.forEach(children,dfs);if(_.has(node,"minRank")){node.borderLeft=[];node.borderRight=[];for(var rank=node.minRank,maxRank=node.maxRank+1;rank<maxRank;++rank){addBorderNode(g,"borderLeft","_bl",v,node,rank);addBorderNode(g,"borderRight","_br",v,node,rank)}}}_.forEach(g.children(),
dfs)}function addBorderNode(g,prop,prefix,sg,sgNode,rank){var label={width:0,height:0,rank:rank,borderType:prop},prev=sgNode[prop][rank-1],curr=util.addDummyNode(g,"border",label,prefix);sgNode[prop][rank]=curr;g.setParent(curr,sg);if(prev)g.setEdge(prev,curr,{weight:1})}},{"./lodash":10,"./util":29}],4:[function(require,module,exports){var _=require("./lodash");module.exports={adjust:adjust,undo:undo};function adjust(g){var rankDir=g.graph().rankdir.toLowerCase();if(rankDir==="lr"||rankDir==="rl")swapWidthHeight(g)}
function undo(g){var rankDir=g.graph().rankdir.toLowerCase();if(rankDir==="bt"||rankDir==="rl")reverseY(g);if(rankDir==="lr"||rankDir==="rl"){swapXY(g);swapWidthHeight(g)}}function swapWidthHeight(g){_.forEach(g.nodes(),function(v){swapWidthHeightOne(g.node(v))});_.forEach(g.edges(),function(e){swapWidthHeightOne(g.edge(e))})}function swapWidthHeightOne(attrs){var w=attrs.width;attrs.width=attrs.height;attrs.height=w}function reverseY(g){_.forEach(g.nodes(),function(v){reverseYOne(g.node(v))});_.forEach(g.edges(),
function(e){var edge=g.edge(e);_.forEach(edge.points,reverseYOne);if(_.has(edge,"y"))reverseYOne(edge)})}function reverseYOne(attrs){attrs.y=-attrs.y}function swapXY(g){_.forEach(g.nodes(),function(v){swapXYOne(g.node(v))});_.forEach(g.edges(),function(e){var edge=g.edge(e);_.forEach(edge.points,swapXYOne);if(_.has(edge,"x"))swapXYOne(edge)})}function swapXYOne(attrs){var x=attrs.x;attrs.x=attrs.y;attrs.y=x}},{"./lodash":10}],5:[function(require,module,exports){module.exports=List;function List(){var sentinel=
{};sentinel._next=sentinel._prev=sentinel;this._sentinel=sentinel}List.prototype.dequeue=function(){var sentinel=this._sentinel,entry=sentinel._prev;if(entry!==sentinel){unlink(entry);return entry}};List.prototype.enqueue=function(entry){var sentinel=this._sentinel;if(entry._prev&&entry._next)unlink(entry);entry._next=sentinel._next;sentinel._next._prev=entry;sentinel._next=entry;entry._prev=sentinel};List.prototype.toString=function(){var strs=[],sentinel=this._sentinel,curr=sentinel._prev;while(curr!==
sentinel){strs.push(JSON.stringify(curr,filterOutLinks));curr=curr._prev}return"["+strs.join(", ")+"]"};function unlink(entry){entry._prev._next=entry._next;entry._next._prev=entry._prev;delete entry._next;delete entry._prev}function filterOutLinks(k,v){if(k!=="_next"&&k!=="_prev")return v}},{}],6:[function(require,module,exports){var _=require("./lodash"),util=require("./util"),Graph=require("./graphlib").Graph;module.exports={debugOrdering:debugOrdering};function debugOrdering(g){var layerMatrix=
util.buildLayerMatrix(g);var h=(new Graph({compound:true,multigraph:true})).setGraph({});_.forEach(g.nodes(),function(v){h.setNode(v,{label:v});h.setParent(v,"layer"+g.node(v).rank)});_.forEach(g.edges(),function(e){h.setEdge(e.v,e.w,{},e.name)});_.forEach(layerMatrix,function(layer,i){var layerV="layer"+i;h.setNode(layerV,{rank:"same"});_.reduce(layer,function(u,v){h.setEdge(u,v,{style:"invis"});return v})});return h}},{"./graphlib":7,"./lodash":10,"./util":29}],7:[function(require,module,exports){var graphlib;
if(typeof require==="function")try{graphlib=require("graphlib")}catch(e){}if(!graphlib)graphlib=window.graphlib;module.exports=graphlib},{"graphlib":undefined}],8:[function(require,module,exports){var _=require("./lodash"),Graph=require("./graphlib").Graph,List=require("./data/list");module.exports=greedyFAS;var DEFAULT_WEIGHT_FN=_.constant(1);function greedyFAS(g,weightFn){if(g.nodeCount()<=1)return[];var state=buildState(g,weightFn||DEFAULT_WEIGHT_FN);var results=doGreedyFAS(state.graph,state.buckets,
state.zeroIdx);return _.flatten(_.map(results,function(e){return g.outEdges(e.v,e.w)}),true)}function doGreedyFAS(g,buckets,zeroIdx){var results=[],sources=buckets[buckets.length-1],sinks=buckets[0];var entry;while(g.nodeCount()){while(entry=sinks.dequeue())removeNode(g,buckets,zeroIdx,entry);while(entry=sources.dequeue())removeNode(g,buckets,zeroIdx,entry);if(g.nodeCount())for(var i=buckets.length-2;i>0;--i){entry=buckets[i].dequeue();if(entry){results=results.concat(removeNode(g,buckets,zeroIdx,
entry,true));break}}}return results}function removeNode(g,buckets,zeroIdx,entry,collectPredecessors){var results=collectPredecessors?[]:undefined;_.forEach(g.inEdges(entry.v),function(edge){var weight=g.edge(edge),uEntry=g.node(edge.v);if(collectPredecessors)results.push({v:edge.v,w:edge.w});uEntry.out-=weight;assignBucket(buckets,zeroIdx,uEntry)});_.forEach(g.outEdges(entry.v),function(edge){var weight=g.edge(edge),w=edge.w,wEntry=g.node(w);wEntry["in"]-=weight;assignBucket(buckets,zeroIdx,wEntry)});
g.removeNode(entry.v);return results}function buildState(g,weightFn){var fasGraph=new Graph,maxIn=0,maxOut=0;_.forEach(g.nodes(),function(v){fasGraph.setNode(v,{v:v,"in":0,out:0})});_.forEach(g.edges(),function(e){var prevWeight=fasGraph.edge(e.v,e.w)||0,weight=weightFn(e),edgeWeight=prevWeight+weight;fasGraph.setEdge(e.v,e.w,edgeWeight);maxOut=Math.max(maxOut,fasGraph.node(e.v).out+=weight);maxIn=Math.max(maxIn,fasGraph.node(e.w)["in"]+=weight)});var buckets=_.range(maxOut+maxIn+3).map(function(){return new List});
var zeroIdx=maxIn+1;_.forEach(fasGraph.nodes(),function(v){assignBucket(buckets,zeroIdx,fasGraph.node(v))});return{graph:fasGraph,buckets:buckets,zeroIdx:zeroIdx}}function assignBucket(buckets,zeroIdx,entry){if(!entry.out)buckets[0].enqueue(entry);else if(!entry["in"])buckets[buckets.length-1].enqueue(entry);else buckets[entry.out-entry["in"]+zeroIdx].enqueue(entry)}},{"./data/list":5,"./graphlib":7,"./lodash":10}],9:[function(require,module,exports){var _=require("./lodash"),acyclic=require("./acyclic"),
normalize=require("./normalize"),rank=require("./rank"),normalizeRanks=require("./util").normalizeRanks,parentDummyChains=require("./parent-dummy-chains"),removeEmptyRanks=require("./util").removeEmptyRanks,nestingGraph=require("./nesting-graph"),addBorderSegments=require("./add-border-segments"),coordinateSystem=require("./coordinate-system"),order=require("./order"),position=require("./position"),util=require("./util"),Graph=require("./graphlib").Graph;module.exports=layout;function layout(g,opts){var time=
opts&&opts.debugTiming?util.time:util.notime;time("layout",function(){var layoutGraph=time("  buildLayoutGraph",function(){return buildLayoutGraph(g)});time("  runLayout",function(){runLayout(layoutGraph,time)});time("  updateInputGraph",function(){updateInputGraph(g,layoutGraph)})})}function runLayout(g,time){time("    makeSpaceForEdgeLabels",function(){makeSpaceForEdgeLabels(g)});time("    removeSelfEdges",function(){removeSelfEdges(g)});time("    acyclic",function(){acyclic.run(g)});time("    nestingGraph.run",
function(){nestingGraph.run(g)});time("    rank",function(){rank(util.asNonCompoundGraph(g))});time("    injectEdgeLabelProxies",function(){injectEdgeLabelProxies(g)});time("    removeEmptyRanks",function(){removeEmptyRanks(g)});time("    nestingGraph.cleanup",function(){nestingGraph.cleanup(g)});time("    normalizeRanks",function(){normalizeRanks(g)});time("    assignRankMinMax",function(){assignRankMinMax(g)});time("    removeEdgeLabelProxies",function(){removeEdgeLabelProxies(g)});time("    normalize.run",
function(){normalize.run(g)});time("    parentDummyChains",function(){parentDummyChains(g)});time("    addBorderSegments",function(){addBorderSegments(g)});time("    order",function(){order(g)});time("    insertSelfEdges",function(){insertSelfEdges(g)});time("    adjustCoordinateSystem",function(){coordinateSystem.adjust(g)});time("    position",function(){position(g)});time("    positionSelfEdges",function(){positionSelfEdges(g)});time("    removeBorderNodes",function(){removeBorderNodes(g)});time("    normalize.undo",
function(){normalize.undo(g)});time("    fixupEdgeLabelCoords",function(){fixupEdgeLabelCoords(g)});time("    undoCoordinateSystem",function(){coordinateSystem.undo(g)});time("    translateGraph",function(){translateGraph(g)});time("    assignNodeIntersects",function(){assignNodeIntersects(g)});time("    reversePoints",function(){reversePointsForReversedEdges(g)});time("    acyclic.undo",function(){acyclic.undo(g)})}function updateInputGraph(inputGraph,layoutGraph){_.forEach(inputGraph.nodes(),function(v){var inputLabel=
inputGraph.node(v),layoutLabel=layoutGraph.node(v);if(inputLabel){inputLabel.x=layoutLabel.x;inputLabel.y=layoutLabel.y;if(layoutGraph.children(v).length){inputLabel.width=layoutLabel.width;inputLabel.height=layoutLabel.height}}});_.forEach(inputGraph.edges(),function(e){var inputLabel=inputGraph.edge(e),layoutLabel=layoutGraph.edge(e);inputLabel.points=layoutLabel.points;if(_.has(layoutLabel,"x")){inputLabel.x=layoutLabel.x;inputLabel.y=layoutLabel.y}});inputGraph.graph().width=layoutGraph.graph().width;
inputGraph.graph().height=layoutGraph.graph().height}var graphNumAttrs=["nodesep","edgesep","ranksep","marginx","marginy"],graphDefaults={ranksep:50,edgesep:20,nodesep:50,rankdir:"tb"},graphAttrs=["acyclicer","ranker","rankdir","align"],nodeNumAttrs=["width","height"],nodeDefaults={width:0,height:0},edgeNumAttrs=["minlen","weight","width","height","labeloffset"],edgeDefaults={minlen:1,weight:1,width:0,height:0,labeloffset:10,labelpos:"r"},edgeAttrs=["labelpos"];function buildLayoutGraph(inputGraph){var g=
new Graph({multigraph:true,compound:true}),graph=canonicalize(inputGraph.graph());g.setGraph(_.merge({},graphDefaults,selectNumberAttrs(graph,graphNumAttrs),_.pick(graph,graphAttrs)));_.forEach(inputGraph.nodes(),function(v){var node=canonicalize(inputGraph.node(v));g.setNode(v,_.defaults(selectNumberAttrs(node,nodeNumAttrs),nodeDefaults));g.setParent(v,inputGraph.parent(v))});_.forEach(inputGraph.edges(),function(e){var edge=canonicalize(inputGraph.edge(e));g.setEdge(e,_.merge({},edgeDefaults,selectNumberAttrs(edge,
edgeNumAttrs),_.pick(edge,edgeAttrs)))});return g}function makeSpaceForEdgeLabels(g){var graph=g.graph();graph.ranksep/=2;_.forEach(g.edges(),function(e){var edge=g.edge(e);edge.minlen*=2;if(edge.labelpos.toLowerCase()!=="c")if(graph.rankdir==="TB"||graph.rankdir==="BT")edge.width+=edge.labeloffset;else edge.height+=edge.labeloffset})}function injectEdgeLabelProxies(g){_.forEach(g.edges(),function(e){var edge=g.edge(e);if(edge.width&&edge.height){var v=g.node(e.v),w=g.node(e.w),label={rank:(w.rank-
v.rank)/2+v.rank,e:e};util.addDummyNode(g,"edge-proxy",label,"_ep")}})}function assignRankMinMax(g){var maxRank=0;_.forEach(g.nodes(),function(v){var node=g.node(v);if(node.borderTop){node.minRank=g.node(node.borderTop).rank;node.maxRank=g.node(node.borderBottom).rank;maxRank=_.max(maxRank,node.maxRank)}});g.graph().maxRank=maxRank}function removeEdgeLabelProxies(g){_.forEach(g.nodes(),function(v){var node=g.node(v);if(node.dummy==="edge-proxy"){g.edge(node.e).labelRank=node.rank;g.removeNode(v)}})}
function translateGraph(g){var minX=Number.POSITIVE_INFINITY,maxX=0,minY=Number.POSITIVE_INFINITY,maxY=0,graphLabel=g.graph(),marginX=graphLabel.marginx||0,marginY=graphLabel.marginy||0;function getExtremes(attrs){var x=attrs.x,y=attrs.y,w=attrs.width,h=attrs.height;minX=Math.min(minX,x-w/2);maxX=Math.max(maxX,x+w/2);minY=Math.min(minY,y-h/2);maxY=Math.max(maxY,y+h/2)}_.forEach(g.nodes(),function(v){getExtremes(g.node(v))});_.forEach(g.edges(),function(e){var edge=g.edge(e);if(_.has(edge,"x"))getExtremes(edge)});
minX-=marginX;minY-=marginY;_.forEach(g.nodes(),function(v){var node=g.node(v);node.x-=minX;node.y-=minY});_.forEach(g.edges(),function(e){var edge=g.edge(e);_.forEach(edge.points,function(p){p.x-=minX;p.y-=minY});if(_.has(edge,"x"))edge.x-=minX;if(_.has(edge,"y"))edge.y-=minY});graphLabel.width=maxX-minX+marginX;graphLabel.height=maxY-minY+marginY}function assignNodeIntersects(g){_.forEach(g.edges(),function(e){var edge=g.edge(e),nodeV=g.node(e.v),nodeW=g.node(e.w),p1,p2;if(!edge.points){edge.points=
[];p1=nodeW;p2=nodeV}else{p1=edge.points[0];p2=edge.points[edge.points.length-1]}edge.points.unshift(util.intersectRect(nodeV,p1));edge.points.push(util.intersectRect(nodeW,p2))})}function fixupEdgeLabelCoords(g){_.forEach(g.edges(),function(e){var edge=g.edge(e);if(_.has(edge,"x")){if(edge.labelpos==="l"||edge.labelpos==="r")edge.width-=edge.labeloffset;switch(edge.labelpos){case "l":edge.x-=edge.width/2+edge.labeloffset;break;case "r":edge.x+=edge.width/2+edge.labeloffset;break}}})}function reversePointsForReversedEdges(g){_.forEach(g.edges(),
function(e){var edge=g.edge(e);if(edge.reversed)edge.points.reverse()})}function removeBorderNodes(g){_.forEach(g.nodes(),function(v){if(g.children(v).length){var node=g.node(v),t=g.node(node.borderTop),b=g.node(node.borderBottom),l=g.node(_.last(node.borderLeft)),r=g.node(_.last(node.borderRight));node.width=Math.abs(r.x-l.x);node.height=Math.abs(b.y-t.y);node.x=l.x+node.width/2;node.y=t.y+node.height/2}});_.forEach(g.nodes(),function(v){if(g.node(v).dummy==="border")g.removeNode(v)})}function removeSelfEdges(g){_.forEach(g.edges(),
function(e){if(e.v===e.w){var node=g.node(e.v);if(!node.selfEdges)node.selfEdges=[];node.selfEdges.push({e:e,label:g.edge(e)});g.removeEdge(e)}})}function insertSelfEdges(g){var layers=util.buildLayerMatrix(g);_.forEach(layers,function(layer){var orderShift=0;_.forEach(layer,function(v,i){var node=g.node(v);node.order=i+orderShift;_.forEach(node.selfEdges,function(selfEdge){util.addDummyNode(g,"selfedge",{width:selfEdge.label.width,height:selfEdge.label.height,rank:node.rank,order:i+ ++orderShift,
e:selfEdge.e,label:selfEdge.label},"_se")});delete node.selfEdges})})}function positionSelfEdges(g){_.forEach(g.nodes(),function(v){var node=g.node(v);if(node.dummy==="selfedge"){var selfNode=g.node(node.e.v),x=selfNode.x+selfNode.width/2,y=selfNode.y,dx=node.x-x,dy=selfNode.height/2;g.setEdge(node.e,node.label);g.removeNode(v);node.label.points=[{x:x+2*dx/3,y:y-dy},{x:x+5*dx/6,y:y-dy},{x:x+dx,y:y},{x:x+5*dx/6,y:y+dy},{x:x+2*dx/3,y:y+dy}];node.label.x=node.x;node.label.y=node.y}})}function selectNumberAttrs(obj,
attrs){return _.mapValues(_.pick(obj,attrs),Number)}function canonicalize(attrs){var newAttrs={};_.forEach(attrs,function(v,k){newAttrs[k.toLowerCase()]=v});return newAttrs}},{"./acyclic":2,"./add-border-segments":3,"./coordinate-system":4,"./graphlib":7,"./lodash":10,"./nesting-graph":11,"./normalize":12,"./order":17,"./parent-dummy-chains":22,"./position":24,"./rank":26,"./util":29}],10:[function(require,module,exports){var lodash;if(typeof require==="function")try{lodash=require("lodash")}catch(e){}if(!lodash)lodash=
window._;module.exports=lodash},{"lodash":undefined}],11:[function(require,module,exports){var _=require("./lodash"),util=require("./util");module.exports={run:run,cleanup:cleanup};function run(g){var root=util.addDummyNode(g,"root",{},"_root");var depths=treeDepths(g);var height=_.max(_.values(depths))-1;var nodeSep=2*height+1;g.graph().nestingRoot=root;_.forEach(g.edges(),function(e){g.edge(e).minlen*=nodeSep});var weight=sumWeights(g)+1;_.forEach(g.children(),function(child){dfs(g,root,nodeSep,
weight,height,depths,child)});g.graph().nodeRankFactor=nodeSep}function dfs(g,root,nodeSep,weight,height,depths,v){var children=g.children(v);if(!children.length){if(v!==root)g.setEdge(root,v,{weight:0,minlen:nodeSep});return}var top=util.addBorderNode(g,"_bt"),bottom=util.addBorderNode(g,"_bb"),label=g.node(v);g.setParent(top,v);label.borderTop=top;g.setParent(bottom,v);label.borderBottom=bottom;_.forEach(children,function(child){dfs(g,root,nodeSep,weight,height,depths,child);var childNode=g.node(child),
childTop=childNode.borderTop?childNode.borderTop:child,childBottom=childNode.borderBottom?childNode.borderBottom:child,thisWeight=childNode.borderTop?weight:2*weight,minlen=childTop!==childBottom?1:height-depths[v]+1;g.setEdge(top,childTop,{weight:thisWeight,minlen:minlen,nestingEdge:true});g.setEdge(childBottom,bottom,{weight:thisWeight,minlen:minlen,nestingEdge:true})});if(!g.parent(v))g.setEdge(root,top,{weight:0,minlen:height+depths[v]})}function treeDepths(g){var depths={};function dfs(v,depth){var children=
g.children(v);if(children&&children.length)_.forEach(children,function(child){dfs(child,depth+1)});depths[v]=depth}_.forEach(g.children(),function(v){dfs(v,1)});return depths}function sumWeights(g){return _.reduce(g.edges(),function(acc,e){return acc+g.edge(e).weight},0)}function cleanup(g){var graphLabel=g.graph();g.removeNode(graphLabel.nestingRoot);delete graphLabel.nestingRoot;_.forEach(g.edges(),function(e){var edge=g.edge(e);if(edge.nestingEdge)g.removeEdge(e)})}},{"./lodash":10,"./util":29}],
12:[function(require,module,exports){var _=require("./lodash"),util=require("./util");module.exports={run:run,undo:undo};function run(g){g.graph().dummyChains=[];_.forEach(g.edges(),function(edge){normalizeEdge(g,edge)})}function normalizeEdge(g,e){var v=e.v,vRank=g.node(v).rank,w=e.w,wRank=g.node(w).rank,name=e.name,edgeLabel=g.edge(e),labelRank=edgeLabel.labelRank;if(wRank===vRank+1)return;g.removeEdge(e);var dummy,attrs,i;for(i=0,++vRank;vRank<wRank;++i,++vRank){edgeLabel.points=[];attrs={width:0,
height:0,edgeLabel:edgeLabel,edgeObj:e,rank:vRank};dummy=util.addDummyNode(g,"edge",attrs,"_d");if(vRank===labelRank){attrs.width=edgeLabel.width;attrs.height=edgeLabel.height;attrs.dummy="edge-label";attrs.labelpos=edgeLabel.labelpos}g.setEdge(v,dummy,{weight:edgeLabel.weight},name);if(i===0)g.graph().dummyChains.push(dummy);v=dummy}g.setEdge(v,w,{weight:edgeLabel.weight},name)}function undo(g){_.forEach(g.graph().dummyChains,function(v){var node=g.node(v),origLabel=node.edgeLabel,w;g.setEdge(node.edgeObj,
origLabel);while(node.dummy){w=g.successors(v)[0];g.removeNode(v);origLabel.points.push({x:node.x,y:node.y});if(node.dummy==="edge-label"){origLabel.x=node.x;origLabel.y=node.y;origLabel.width=node.width;origLabel.height=node.height}v=w;node=g.node(v)}})}},{"./lodash":10,"./util":29}],13:[function(require,module,exports){var _=require("../lodash");module.exports=addSubgraphConstraints;function addSubgraphConstraints(g,cg,vs){var prev={},rootPrev;_.forEach(vs,function(v){var child=g.parent(v),parent,
prevChild;while(child){parent=g.parent(child);if(parent){prevChild=prev[parent];prev[parent]=child}else{prevChild=rootPrev;rootPrev=child}if(prevChild&&prevChild!==child){cg.setEdge(prevChild,child);return}child=parent}})}},{"../lodash":10}],14:[function(require,module,exports){var _=require("../lodash");module.exports=barycenter;function barycenter(g,movable){return _.map(movable,function(v){var inV=g.inEdges(v);if(!inV.length)return{v:v};else{var result=_.reduce(inV,function(acc,e){var edge=g.edge(e),
nodeU=g.node(e.v);return{sum:acc.sum+edge.weight*nodeU.order,weight:acc.weight+edge.weight}},{sum:0,weight:0});return{v:v,barycenter:result.sum/result.weight,weight:result.weight}}})}},{"../lodash":10}],15:[function(require,module,exports){var _=require("../lodash"),Graph=require("../graphlib").Graph;module.exports=buildLayerGraph;function buildLayerGraph(g,rank,relationship){var root=createRootNode(g),result=(new Graph({compound:true})).setGraph({root:root}).setDefaultNodeLabel(function(v){return g.node(v)});
_.forEach(g.nodes(),function(v){var node=g.node(v),parent=g.parent(v);if(node.rank===rank||node.minRank<=rank&&rank<=node.maxRank){result.setNode(v);result.setParent(v,parent||root);_.forEach(g[relationship](v),function(e){var u=e.v===v?e.w:e.v,edge=result.edge(u,v),weight=!_.isUndefined(edge)?edge.weight:0;result.setEdge(u,v,{weight:g.edge(e).weight+weight})});if(_.has(node,"minRank"))result.setNode(v,{borderLeft:node.borderLeft[rank],borderRight:node.borderRight[rank]})}});return result}function createRootNode(g){var v;
while(g.hasNode(v=_.uniqueId("_root")));return v}},{"../graphlib":7,"../lodash":10}],16:[function(require,module,exports){var _=require("../lodash");module.exports=crossCount;function crossCount(g,layering){var cc=0;for(var i=1;i<layering.length;++i)cc+=twoLayerCrossCount(g,layering[i-1],layering[i]);return cc}function twoLayerCrossCount(g,northLayer,southLayer){var southPos=_.zipObject(southLayer,_.map(southLayer,function(v,i){return i}));var southEntries=_.flatten(_.map(northLayer,function(v){return _.chain(g.outEdges(v)).map(function(e){return{pos:southPos[e.w],
weight:g.edge(e).weight}}).sortBy("pos").value()}),true);var firstIndex=1;while(firstIndex<southLayer.length)firstIndex<<=1;var treeSize=2*firstIndex-1;firstIndex-=1;var tree=_.map(new Array(treeSize),function(){return 0});var cc=0;_.forEach(southEntries.forEach(function(entry){var index=entry.pos+firstIndex;tree[index]+=entry.weight;var weightSum=0;while(index>0){if(index%2)weightSum+=tree[index+1];index=index-1>>1;tree[index]+=entry.weight}cc+=entry.weight*weightSum}));return cc}},{"../lodash":10}],
17:[function(require,module,exports){var _=require("../lodash"),initOrder=require("./init-order"),crossCount=require("./cross-count"),sortSubgraph=require("./sort-subgraph"),buildLayerGraph=require("./build-layer-graph"),addSubgraphConstraints=require("./add-subgraph-constraints"),Graph=require("../graphlib").Graph,util=require("../util");module.exports=order;function order(g){var maxRank=util.maxRank(g),downLayerGraphs=buildLayerGraphs(g,_.range(1,maxRank+1),"inEdges"),upLayerGraphs=buildLayerGraphs(g,
_.range(maxRank-1,-1,-1),"outEdges");var layering=initOrder(g);assignOrder(g,layering);var bestCC=Number.POSITIVE_INFINITY,best;for(var i=0,lastBest=0;lastBest<4;++i,++lastBest){sweepLayerGraphs(i%2?downLayerGraphs:upLayerGraphs,i%4>=2);layering=util.buildLayerMatrix(g);var cc=crossCount(g,layering);if(cc<bestCC){lastBest=0;best=_.cloneDeep(layering);bestCC=cc}}assignOrder(g,best)}function buildLayerGraphs(g,ranks,relationship){return _.map(ranks,function(rank){return buildLayerGraph(g,rank,relationship)})}
function sweepLayerGraphs(layerGraphs,biasRight){var cg=new Graph;_.forEach(layerGraphs,function(lg){var root=lg.graph().root;var sorted=sortSubgraph(lg,root,cg,biasRight);_.forEach(sorted.vs,function(v,i){lg.node(v).order=i});addSubgraphConstraints(lg,cg,sorted.vs)})}function assignOrder(g,layering){_.forEach(layering,function(layer){_.forEach(layer,function(v,i){g.node(v).order=i})})}},{"../graphlib":7,"../lodash":10,"../util":29,"./add-subgraph-constraints":13,"./build-layer-graph":15,"./cross-count":16,
"./init-order":18,"./sort-subgraph":20}],18:[function(require,module,exports){var _=require("../lodash");module.exports=initOrder;function initOrder(g){var visited={},simpleNodes=_.filter(g.nodes(),function(v){return!g.children(v).length}),maxRank=_.max(_.map(simpleNodes,function(v){return g.node(v).rank})),layers=_.map(_.range(maxRank+1),function(){return[]});function dfs(v){if(_.has(visited,v))return;visited[v]=true;var node=g.node(v);layers[node.rank].push(v);_.forEach(g.successors(v),dfs)}var orderedVs=
_.sortBy(simpleNodes,function(v){return g.node(v).rank});_.forEach(orderedVs,dfs);return layers}},{"../lodash":10}],19:[function(require,module,exports){var _=require("../lodash");module.exports=resolveConflicts;function resolveConflicts(entries,cg){var mappedEntries={};_.forEach(entries,function(entry,i){var tmp=mappedEntries[entry.v]={indegree:0,"in":[],out:[],vs:[entry.v],i:i};if(!_.isUndefined(entry.barycenter)){tmp.barycenter=entry.barycenter;tmp.weight=entry.weight}});_.forEach(cg.edges(),function(e){var entryV=
mappedEntries[e.v],entryW=mappedEntries[e.w];if(!_.isUndefined(entryV)&&!_.isUndefined(entryW)){entryW.indegree++;entryV.out.push(mappedEntries[e.w])}});var sourceSet=_.filter(mappedEntries,function(entry){return!entry.indegree});return doResolveConflicts(sourceSet)}function doResolveConflicts(sourceSet){var entries=[];function handleIn(vEntry){return function(uEntry){if(uEntry.merged)return;if(_.isUndefined(uEntry.barycenter)||_.isUndefined(vEntry.barycenter)||uEntry.barycenter>=vEntry.barycenter)mergeEntries(vEntry,
uEntry)}}function handleOut(vEntry){return function(wEntry){wEntry["in"].push(vEntry);if(--wEntry.indegree===0)sourceSet.push(wEntry)}}while(sourceSet.length){var entry=sourceSet.pop();entries.push(entry);_.forEach(entry["in"].reverse(),handleIn(entry));_.forEach(entry.out,handleOut(entry))}return _.chain(entries).filter(function(entry){return!entry.merged}).map(function(entry){return _.pick(entry,["vs","i","barycenter","weight"])}).value()}function mergeEntries(target,source){var sum=0,weight=0;
if(target.weight){sum+=target.barycenter*target.weight;weight+=target.weight}if(source.weight){sum+=source.barycenter*source.weight;weight+=source.weight}target.vs=source.vs.concat(target.vs);target.barycenter=sum/weight;target.weight=weight;target.i=Math.min(source.i,target.i);source.merged=true}},{"../lodash":10}],20:[function(require,module,exports){var _=require("../lodash"),barycenter=require("./barycenter"),resolveConflicts=require("./resolve-conflicts"),sort=require("./sort");module.exports=
sortSubgraph;function sortSubgraph(g,v,cg,biasRight){var movable=g.children(v),node=g.node(v),bl=node?node.borderLeft:undefined,br=node?node.borderRight:undefined,subgraphs={};if(bl)movable=_.filter(movable,function(w){return w!==bl&&w!==br});var barycenters=barycenter(g,movable);_.forEach(barycenters,function(entry){if(g.children(entry.v).length){var subgraphResult=sortSubgraph(g,entry.v,cg,biasRight);subgraphs[entry.v]=subgraphResult;if(_.has(subgraphResult,"barycenter"))mergeBarycenters(entry,
subgraphResult)}});var entries=resolveConflicts(barycenters,cg);expandSubgraphs(entries,subgraphs);var result=sort(entries,biasRight);if(bl){result.vs=_.flatten([bl,result.vs,br],true);if(g.predecessors(bl).length){var blPred=g.node(g.predecessors(bl)[0]),brPred=g.node(g.predecessors(br)[0]);if(!_.has(result,"barycenter")){result.barycenter=0;result.weight=0}result.barycenter=(result.barycenter*result.weight+blPred.order+brPred.order)/(result.weight+2);result.weight+=2}}return result}function expandSubgraphs(entries,
subgraphs){_.forEach(entries,function(entry){entry.vs=_.flatten(entry.vs.map(function(v){if(subgraphs[v])return subgraphs[v].vs;return v}),true)})}function mergeBarycenters(target,other){if(!_.isUndefined(target.barycenter)){target.barycenter=(target.barycenter*target.weight+other.barycenter*other.weight)/(target.weight+other.weight);target.weight+=other.weight}else{target.barycenter=other.barycenter;target.weight=other.weight}}},{"../lodash":10,"./barycenter":14,"./resolve-conflicts":19,"./sort":21}],
21:[function(require,module,exports){var _=require("../lodash"),util=require("../util");module.exports=sort;function sort(entries,biasRight){var parts=util.partition(entries,function(entry){return _.has(entry,"barycenter")});var sortable=parts.lhs,unsortable=_.sortBy(parts.rhs,function(entry){return-entry.i}),vs=[],sum=0,weight=0,vsIndex=0;sortable.sort(compareWithBias(!!biasRight));vsIndex=consumeUnsortable(vs,unsortable,vsIndex);_.forEach(sortable,function(entry){vsIndex+=entry.vs.length;vs.push(entry.vs);
sum+=entry.barycenter*entry.weight;weight+=entry.weight;vsIndex=consumeUnsortable(vs,unsortable,vsIndex)});var result={vs:_.flatten(vs,true)};if(weight){result.barycenter=sum/weight;result.weight=weight}return result}function consumeUnsortable(vs,unsortable,index){var last;while(unsortable.length&&(last=_.last(unsortable)).i<=index){unsortable.pop();vs.push(last.vs);index++}return index}function compareWithBias(bias){return function(entryV,entryW){if(entryV.barycenter<entryW.barycenter)return-1;else if(entryV.barycenter>
entryW.barycenter)return 1;return!bias?entryV.i-entryW.i:entryW.i-entryV.i}}},{"../lodash":10,"../util":29}],22:[function(require,module,exports){var _=require("./lodash");module.exports=parentDummyChains;function parentDummyChains(g){var postorderNums=postorder(g);_.forEach(g.graph().dummyChains,function(v){var node=g.node(v),edgeObj=node.edgeObj,pathData=findPath(g,postorderNums,edgeObj.v,edgeObj.w),path=pathData.path,lca=pathData.lca,pathIdx=0,pathV=path[pathIdx],ascending=true;while(v!==edgeObj.w){node=
g.node(v);if(ascending){while((pathV=path[pathIdx])!==lca&&g.node(pathV).maxRank<node.rank)pathIdx++;if(pathV===lca)ascending=false}if(!ascending){while(pathIdx<path.length-1&&g.node(pathV=path[pathIdx+1]).minRank<=node.rank)pathIdx++;pathV=path[pathIdx]}g.setParent(v,pathV);v=g.successors(v)[0]}})}function findPath(g,postorderNums,v,w){var vPath=[],wPath=[],low=Math.min(postorderNums[v].low,postorderNums[w].low),lim=Math.max(postorderNums[v].lim,postorderNums[w].lim),parent,lca;parent=v;do{parent=
g.parent(parent);vPath.push(parent)}while(parent&&(postorderNums[parent].low>low||lim>postorderNums[parent].lim));lca=parent;parent=w;while((parent=g.parent(parent))!==lca)wPath.push(parent);return{path:vPath.concat(wPath.reverse()),lca:lca}}function postorder(g){var result={},lim=0;function dfs(v){var low=lim;_.forEach(g.children(v),dfs);result[v]={low:low,lim:lim++}}_.forEach(g.children(),dfs);return result}},{"./lodash":10}],23:[function(require,module,exports){var _=require("../lodash"),Graph=
require("../graphlib").Graph,util=require("../util");module.exports={positionX:positionX,findType1Conflicts:findType1Conflicts,findType2Conflicts:findType2Conflicts,addConflict:addConflict,hasConflict:hasConflict,verticalAlignment:verticalAlignment,horizontalCompaction:horizontalCompaction,alignCoordinates:alignCoordinates,findSmallestWidthAlignment:findSmallestWidthAlignment,balance:balance};function findType1Conflicts(g,layering){var conflicts={};function visitLayer(prevLayer,layer){var k0=0,scanPos=
0,prevLayerLength=prevLayer.length,lastNode=_.last(layer);_.forEach(layer,function(v,i){var w=findOtherInnerSegmentNode(g,v),k1=w?g.node(w).order:prevLayerLength;if(w||v===lastNode){_.forEach(layer.slice(scanPos,i+1),function(scanNode){_.forEach(g.predecessors(scanNode),function(u){var uLabel=g.node(u),uPos=uLabel.order;if((uPos<k0||k1<uPos)&&!(uLabel.dummy&&g.node(scanNode).dummy))addConflict(conflicts,u,scanNode)})});scanPos=i+1;k0=k1}});return layer}_.reduce(layering,visitLayer);return conflicts}
function findType2Conflicts(g,layering){var conflicts={};function scan(south,southPos,southEnd,prevNorthBorder,nextNorthBorder){var v;_.forEach(_.range(southPos,southEnd),function(i){v=south[i];if(g.node(v).dummy)_.forEach(g.predecessors(v),function(u){var uNode=g.node(u);if(uNode.dummy&&(uNode.order<prevNorthBorder||uNode.order>nextNorthBorder))addConflict(conflicts,u,v)})})}function visitLayer(north,south){var prevNorthPos=-1,nextNorthPos,southPos=0;_.forEach(south,function(v,southLookahead){if(g.node(v).dummy===
"border"){var predecessors=g.predecessors(v);if(predecessors.length){nextNorthPos=g.node(predecessors[0]).order;scan(south,southPos,southLookahead,prevNorthPos,nextNorthPos);southPos=southLookahead;prevNorthPos=nextNorthPos}}scan(south,southPos,south.length,nextNorthPos,north.length)});return south}_.reduce(layering,visitLayer);return conflicts}function findOtherInnerSegmentNode(g,v){if(g.node(v).dummy)return _.find(g.predecessors(v),function(u){return g.node(u).dummy})}function addConflict(conflicts,
v,w){if(v>w){var tmp=v;v=w;w=tmp}var conflictsV=conflicts[v];if(!conflictsV)conflicts[v]=conflictsV={};conflictsV[w]=true}function hasConflict(conflicts,v,w){if(v>w){var tmp=v;v=w;w=tmp}return _.has(conflicts[v],w)}function verticalAlignment(g,layering,conflicts,neighborFn){var root={},align={},pos={};_.forEach(layering,function(layer){_.forEach(layer,function(v,order){root[v]=v;align[v]=v;pos[v]=order})});_.forEach(layering,function(layer){var prevIdx=-1;_.forEach(layer,function(v){var ws=neighborFn(v);
if(ws.length){ws=_.sortBy(ws,function(w){return pos[w]});var mp=(ws.length-1)/2;for(var i=Math.floor(mp),il=Math.ceil(mp);i<=il;++i){var w=ws[i];if(align[v]===v&&prevIdx<pos[w]&&!hasConflict(conflicts,v,w)){align[w]=v;align[v]=root[v]=root[w];prevIdx=pos[w]}}}})});return{root:root,align:align}}function horizontalCompaction(g,layering,root,align,reverseSep){var xs={},blockG=buildBlockGraph(g,layering,root,reverseSep),borderType=reverseSep?"borderLeft":"borderRight";function iterate(setXsFunc,nextNodesFunc){var stack=
blockG.nodes();var elem=stack.pop();var visited={};while(elem){if(visited[elem])setXsFunc(elem);else{visited[elem]=true;stack.push(elem);stack=stack.concat(nextNodesFunc(elem))}elem=stack.pop()}}function pass1(elem){xs[elem]=blockG.inEdges(elem).reduce(function(acc,e){return Math.max(acc,xs[e.v]+blockG.edge(e))},0)}function pass2(elem){var min=blockG.outEdges(elem).reduce(function(acc,e){return Math.min(acc,xs[e.w]-blockG.edge(e))},Number.POSITIVE_INFINITY);var node=g.node(elem);if(min!==Number.POSITIVE_INFINITY&&
node.borderType!==borderType)xs[elem]=Math.max(xs[elem],min)}iterate(pass1,_.bind(blockG.predecessors,blockG));iterate(pass2,_.bind(blockG.successors,blockG));_.forEach(align,function(v){xs[v]=xs[root[v]]});return xs}function buildBlockGraph(g,layering,root,reverseSep){var blockGraph=new Graph,graphLabel=g.graph(),sepFn=sep(graphLabel.nodesep,graphLabel.edgesep,reverseSep);_.forEach(layering,function(layer){var u;_.forEach(layer,function(v){var vRoot=root[v];blockGraph.setNode(vRoot);if(u){var uRoot=
root[u],prevMax=blockGraph.edge(uRoot,vRoot);blockGraph.setEdge(uRoot,vRoot,Math.max(sepFn(g,v,u),prevMax||0))}u=v})});return blockGraph}function findSmallestWidthAlignment(g,xss){return _.minBy(_.values(xss),function(xs){var max=Number.NEGATIVE_INFINITY;var min=Number.POSITIVE_INFINITY;_.forIn(xs,function(x,v){var halfWidth=width(g,v)/2;max=Math.max(x+halfWidth,max);min=Math.min(x-halfWidth,min)});return max-min})}function alignCoordinates(xss,alignTo){var alignToVals=_.values(alignTo),alignToMin=
_.min(alignToVals),alignToMax=_.max(alignToVals);_.forEach(["u","d"],function(vert){_.forEach(["l","r"],function(horiz){var alignment=vert+horiz,xs=xss[alignment],delta;if(xs===alignTo)return;var xsVals=_.values(xs);delta=horiz==="l"?alignToMin-_.min(xsVals):alignToMax-_.max(xsVals);if(delta)xss[alignment]=_.mapValues(xs,function(x){return x+delta})})})}function balance(xss,align){return _.mapValues(xss.ul,function(ignore,v){if(align)return xss[align.toLowerCase()][v];else{var xs=_.sortBy(_.map(xss,
v));return(xs[1]+xs[2])/2}})}function positionX(g){var layering=util.buildLayerMatrix(g),conflicts=_.merge(findType1Conflicts(g,layering),findType2Conflicts(g,layering));var xss={},adjustedLayering;_.forEach(["u","d"],function(vert){adjustedLayering=vert==="u"?layering:_.values(layering).reverse();_.forEach(["l","r"],function(horiz){if(horiz==="r")adjustedLayering=_.map(adjustedLayering,function(inner){return _.values(inner).reverse()});var neighborFn=_.bind(vert==="u"?g.predecessors:g.successors,
g);var align=verticalAlignment(g,adjustedLayering,conflicts,neighborFn);var xs=horizontalCompaction(g,adjustedLayering,align.root,align.align,horiz==="r");if(horiz==="r")xs=_.mapValues(xs,function(x){return-x});xss[vert+horiz]=xs})});var smallestWidth=findSmallestWidthAlignment(g,xss);alignCoordinates(xss,smallestWidth);return balance(xss,g.graph().align)}function sep(nodeSep,edgeSep,reverseSep){return function(g,v,w){var vLabel=g.node(v),wLabel=g.node(w),sum=0,delta;sum+=vLabel.width/2;if(_.has(vLabel,
"labelpos"))switch(vLabel.labelpos.toLowerCase()){case "l":delta=-vLabel.width/2;break;case "r":delta=vLabel.width/2;break}if(delta)sum+=reverseSep?delta:-delta;delta=0;sum+=(vLabel.dummy?edgeSep:nodeSep)/2;sum+=(wLabel.dummy?edgeSep:nodeSep)/2;sum+=wLabel.width/2;if(_.has(wLabel,"labelpos"))switch(wLabel.labelpos.toLowerCase()){case "l":delta=wLabel.width/2;break;case "r":delta=-wLabel.width/2;break}if(delta)sum+=reverseSep?delta:-delta;delta=0;return sum}}function width(g,v){return g.node(v).width}
},{"../graphlib":7,"../lodash":10,"../util":29}],24:[function(require,module,exports){var _=require("../lodash"),util=require("../util"),positionX=require("./bk").positionX;module.exports=position;function position(g){g=util.asNonCompoundGraph(g);positionY(g);_.forEach(positionX(g),function(x,v){g.node(v).x=x})}function positionY(g){var layering=util.buildLayerMatrix(g),rankSep=g.graph().ranksep,prevY=0;_.forEach(layering,function(layer){var maxHeight=_.max(_.map(layer,function(v){return g.node(v).height}));
_.forEach(layer,function(v){g.node(v).y=prevY+maxHeight/2});prevY+=maxHeight+rankSep})}},{"../lodash":10,"../util":29,"./bk":23}],25:[function(require,module,exports){var _=require("../lodash"),Graph=require("../graphlib").Graph,slack=require("./util").slack;module.exports=feasibleTree;function feasibleTree(g){var t=new Graph({directed:false});var start=g.nodes()[0],size=g.nodeCount();t.setNode(start,{});var edge,delta;while(tightTree(t,g)<size){edge=findMinSlackEdge(t,g);delta=t.hasNode(edge.v)?
slack(g,edge):-slack(g,edge);shiftRanks(t,g,delta)}return t}function tightTree(t,g){function dfs(v){_.forEach(g.nodeEdges(v),function(e){var edgeV=e.v,w=v===edgeV?e.w:edgeV;if(!t.hasNode(w)&&!slack(g,e)){t.setNode(w,{});t.setEdge(v,w,{});dfs(w)}})}_.forEach(t.nodes(),dfs);return t.nodeCount()}function findMinSlackEdge(t,g){return _.minBy(g.edges(),function(e){if(t.hasNode(e.v)!==t.hasNode(e.w))return slack(g,e)})}function shiftRanks(t,g,delta){_.forEach(t.nodes(),function(v){g.node(v).rank+=delta})}
},{"../graphlib":7,"../lodash":10,"./util":28}],26:[function(require,module,exports){var rankUtil=require("./util"),longestPath=rankUtil.longestPath,feasibleTree=require("./feasible-tree"),networkSimplex=require("./network-simplex");module.exports=rank;function rank(g){switch(g.graph().ranker){case "network-simplex":networkSimplexRanker(g);break;case "tight-tree":tightTreeRanker(g);break;case "longest-path":longestPathRanker(g);break;default:networkSimplexRanker(g)}}var longestPathRanker=longestPath;
function tightTreeRanker(g){longestPath(g);feasibleTree(g)}function networkSimplexRanker(g){networkSimplex(g)}},{"./feasible-tree":25,"./network-simplex":27,"./util":28}],27:[function(require,module,exports){var _=require("../lodash"),feasibleTree=require("./feasible-tree"),slack=require("./util").slack,initRank=require("./util").longestPath,preorder=require("../graphlib").alg.preorder,postorder=require("../graphlib").alg.postorder,simplify=require("../util").simplify;module.exports=networkSimplex;
networkSimplex.initLowLimValues=initLowLimValues;networkSimplex.initCutValues=initCutValues;networkSimplex.calcCutValue=calcCutValue;networkSimplex.leaveEdge=leaveEdge;networkSimplex.enterEdge=enterEdge;networkSimplex.exchangeEdges=exchangeEdges;function networkSimplex(g){g=simplify(g);initRank(g);var t=feasibleTree(g);initLowLimValues(t);initCutValues(t,g);var e,f;while(e=leaveEdge(t)){f=enterEdge(t,g,e);exchangeEdges(t,g,e,f)}}function initCutValues(t,g){var vs=postorder(t,t.nodes());vs=vs.slice(0,
vs.length-1);_.forEach(vs,function(v){assignCutValue(t,g,v)})}function assignCutValue(t,g,child){var childLab=t.node(child),parent=childLab.parent;t.edge(child,parent).cutvalue=calcCutValue(t,g,child)}function calcCutValue(t,g,child){var childLab=t.node(child),parent=childLab.parent,childIsTail=true,graphEdge=g.edge(child,parent),cutValue=0;if(!graphEdge){childIsTail=false;graphEdge=g.edge(parent,child)}cutValue=graphEdge.weight;_.forEach(g.nodeEdges(child),function(e){var isOutEdge=e.v===child,other=
isOutEdge?e.w:e.v;if(other!==parent){var pointsToHead=isOutEdge===childIsTail,otherWeight=g.edge(e).weight;cutValue+=pointsToHead?otherWeight:-otherWeight;if(isTreeEdge(t,child,other)){var otherCutValue=t.edge(child,other).cutvalue;cutValue+=pointsToHead?-otherCutValue:otherCutValue}}});return cutValue}function initLowLimValues(tree,root){if(arguments.length<2)root=tree.nodes()[0];dfsAssignLowLim(tree,{},1,root)}function dfsAssignLowLim(tree,visited,nextLim,v,parent){var low=nextLim,label=tree.node(v);
visited[v]=true;_.forEach(tree.neighbors(v),function(w){if(!_.has(visited,w))nextLim=dfsAssignLowLim(tree,visited,nextLim,w,v)});label.low=low;label.lim=nextLim++;if(parent)label.parent=parent;else delete label.parent;return nextLim}function leaveEdge(tree){return _.find(tree.edges(),function(e){return tree.edge(e).cutvalue<0})}function enterEdge(t,g,edge){var v=edge.v,w=edge.w;if(!g.hasEdge(v,w)){v=edge.w;w=edge.v}var vLabel=t.node(v),wLabel=t.node(w),tailLabel=vLabel,flip=false;if(vLabel.lim>wLabel.lim){tailLabel=
wLabel;flip=true}var candidates=_.filter(g.edges(),function(edge){return flip===isDescendant(t,t.node(edge.v),tailLabel)&&flip!==isDescendant(t,t.node(edge.w),tailLabel)});return _.minBy(candidates,function(edge){return slack(g,edge)})}function exchangeEdges(t,g,e,f){var v=e.v,w=e.w;t.removeEdge(v,w);t.setEdge(f.v,f.w,{});initLowLimValues(t);initCutValues(t,g);updateRanks(t,g)}function updateRanks(t,g){var root=_.find(t.nodes(),function(v){return!g.node(v).parent}),vs=preorder(t,root);vs=vs.slice(1);
_.forEach(vs,function(v){var parent=t.node(v).parent,edge=g.edge(v,parent),flipped=false;if(!edge){edge=g.edge(parent,v);flipped=true}g.node(v).rank=g.node(parent).rank+(flipped?edge.minlen:-edge.minlen)})}function isTreeEdge(tree,u,v){return tree.hasEdge(u,v)}function isDescendant(tree,vLabel,rootLabel){return rootLabel.low<=vLabel.lim&&vLabel.lim<=rootLabel.lim}},{"../graphlib":7,"../lodash":10,"../util":29,"./feasible-tree":25,"./util":28}],28:[function(require,module,exports){var _=require("../lodash");
module.exports={longestPath:longestPath,slack:slack};function longestPath(g){var visited={};function dfs(v){var label=g.node(v);if(_.has(visited,v))return label.rank;visited[v]=true;var rank=_.minBy(_.map(g.outEdges(v),function(e){return dfs(e.w)-g.edge(e).minlen}));if(rank===Number.POSITIVE_INFINITY||rank===undefined||rank===null)rank=0;return label.rank=rank}_.forEach(g.sources(),dfs)}function slack(g,e){return g.node(e.w).rank-g.node(e.v).rank-g.edge(e).minlen}},{"../lodash":10}],29:[function(require,
module,exports){var _=require("./lodash"),Graph=require("./graphlib").Graph;module.exports={addDummyNode:addDummyNode,simplify:simplify,asNonCompoundGraph:asNonCompoundGraph,successorWeights:successorWeights,predecessorWeights:predecessorWeights,intersectRect:intersectRect,buildLayerMatrix:buildLayerMatrix,normalizeRanks:normalizeRanks,removeEmptyRanks:removeEmptyRanks,addBorderNode:addBorderNode,maxRank:maxRank,partition:partition,time:time,notime:notime};function addDummyNode(g,type,attrs,name){var v;
do v=_.uniqueId(name);while(g.hasNode(v));attrs.dummy=type;g.setNode(v,attrs);return v}function simplify(g){var simplified=(new Graph).setGraph(g.graph());_.forEach(g.nodes(),function(v){simplified.setNode(v,g.node(v))});_.forEach(g.edges(),function(e){var simpleLabel=simplified.edge(e.v,e.w)||{weight:0,minlen:1},label=g.edge(e);simplified.setEdge(e.v,e.w,{weight:simpleLabel.weight+label.weight,minlen:Math.max(simpleLabel.minlen,label.minlen)})});return simplified}function asNonCompoundGraph(g){var simplified=
(new Graph({multigraph:g.isMultigraph()})).setGraph(g.graph());_.forEach(g.nodes(),function(v){if(!g.children(v).length)simplified.setNode(v,g.node(v))});_.forEach(g.edges(),function(e){simplified.setEdge(e,g.edge(e))});return simplified}function successorWeights(g){var weightMap=_.map(g.nodes(),function(v){var sucs={};_.forEach(g.outEdges(v),function(e){sucs[e.w]=(sucs[e.w]||0)+g.edge(e).weight});return sucs});return _.zipObject(g.nodes(),weightMap)}function predecessorWeights(g){var weightMap=_.map(g.nodes(),
function(v){var preds={};_.forEach(g.inEdges(v),function(e){preds[e.v]=(preds[e.v]||0)+g.edge(e).weight});return preds});return _.zipObject(g.nodes(),weightMap)}function intersectRect(rect,point){var x=rect.x;var y=rect.y;var dx=point.x-x;var dy=point.y-y;var w=rect.width/2;var h=rect.height/2;if(!dx&&!dy)throw new Error("Not possible to find intersection inside of the rectangle");var sx,sy;if(Math.abs(dy)*w>Math.abs(dx)*h){if(dy<0)h=-h;sx=h*dx/dy;sy=h}else{if(dx<0)w=-w;sx=w;sy=w*dy/dx}return{x:x+
sx,y:y+sy}}function buildLayerMatrix(g){var layering=_.map(_.range(maxRank(g)+1),function(){return[]});_.forEach(g.nodes(),function(v){var node=g.node(v),rank=node.rank;if(!_.isUndefined(rank))layering[rank][node.order]=v});return layering}function normalizeRanks(g){var min=_.minBy(_.map(g.nodes(),function(v){return g.node(v).rank}));_.forEach(g.nodes(),function(v){var node=g.node(v);if(_.has(node,"rank"))node.rank-=min})}function removeEmptyRanks(g){var offset=_.minBy(_.map(g.nodes(),function(v){return g.node(v).rank}));
var layers=[];_.forEach(g.nodes(),function(v){var rank=g.node(v).rank-offset;if(!layers[rank])layers[rank]=[];layers[rank].push(v)});var delta=0,nodeRankFactor=g.graph().nodeRankFactor;_.forEach(layers,function(vs,i){if(_.isUndefined(vs)&&i%nodeRankFactor!==0)--delta;else if(delta)_.forEach(vs,function(v){g.node(v).rank+=delta})})}function addBorderNode(g,prefix,rank,order){var node={width:0,height:0};if(arguments.length>=4){node.rank=rank;node.order=order}return addDummyNode(g,"border",node,prefix)}
function maxRank(g){return _.max(_.map(g.nodes(),function(v){var rank=g.node(v).rank;if(!_.isUndefined(rank))return rank}))}function partition(collection,fn){var result={lhs:[],rhs:[]};_.forEach(collection,function(value){if(fn(value))result.lhs.push(value);else result.rhs.push(value)});return result}function time(name,fn){var start=_.now();try{return fn()}finally{console.log(name+" time: "+(_.now()-start)+"ms")}}function notime(name,fn){return fn()}},{"./graphlib":7,"./lodash":10}],30:[function(require,
module,exports){module.exports="0.8.2"},{}]},{},[1])(1)});
//# sourceURL=build://tf-graph-common/annotation.js
var tf;
(function(b){(function(d){(function(f){(function(h){function k(q){return(d.render.AnnotationType[q]||"").toLowerCase()||null}function t(q,u){u.annotationType===d.render.AnnotationType.SUMMARY?f.selectOrCreateChild(q,"use").attr("class","summary").attr("xlink:href","#summary-icon").attr("cursor","pointer"):(q=f.node.buildShape(q,u,f.Class.Annotation.NODE),f.selectOrCreateChild(q,"title").text(u.node.name))}function l(q,u){let x=u.node.name.split("/");return p(q,x[x.length-1],u,null)}function p(q,u,
x,A){let y=f.Class.Annotation.LABEL;A&&(y+=" "+A);q=q.append("text").attr("class",y).attr("dy",".35em").attr("text-anchor",x.isIn?"end":"start").text(u);return b.graph.scene.node.enforceLabelWidth(q,-1)}function m(q,u,x,A){q.on("mouseover",y=>{A.fire("annotation-highlight",{name:y.node.name,hostName:u.node.name})}).on("mouseout",y=>{A.fire("annotation-unhighlight",{name:y.node.name,hostName:u.node.name})}).on("click",y=>{d3.event.stopPropagation();A.fire("annotation-select",{name:y.node.name,hostName:u.node.name})});
if(x.annotationType!==d.render.AnnotationType.SUMMARY&&x.annotationType!==d.render.AnnotationType.CONSTANT)q.on("contextmenu",f.contextmenu.getMenu(A,f.node.getContextMenu(x.node,A)))}function n(q,u,x,A){let y=d.layout.computeCXPositionOfNodeShape(u);x.renderNodeInfo&&x.annotationType!==d.render.AnnotationType.ELLIPSIS&&f.node.stylize(q,x.renderNodeInfo,A,f.Class.Annotation.NODE);x.annotationType===d.render.AnnotationType.SUMMARY&&(x.width+=10);q.select("text."+f.Class.Annotation.LABEL).transition().attr("x",
y+x.dx+(x.isIn?-1:1)*(x.width/2+x.labelOffset)).attr("y",u.y+x.dy);q.select("use.summary").transition().attr("x",y+x.dx-3).attr("y",u.y+x.dy-6);f.positionEllipse(q.select("."+f.Class.Annotation.NODE+" ellipse"),y+x.dx,u.y+x.dy,x.width,x.height);f.positionRect(q.select("."+f.Class.Annotation.NODE+" rect"),y+x.dx,u.y+x.dy,x.width,x.height);f.positionRect(q.select("."+f.Class.Annotation.NODE+" use"),y+x.dx,u.y+x.dy,x.width,x.height);q.select("path."+f.Class.Annotation.EDGE).transition().attr("d",w=>
{w=w.points.map(C=>({x:C.dx+y,y:C.dy+u.y}));return f.edge.interpolate(w)})}h.buildGroup=function(q,u,x,A){q=q.selectAll(function(){return this.childNodes}).data(u.list,y=>y.node.name);q.enter().append("g").attr("data-name",y=>y.node.name).each(function(y){let w=d3.select(this);A.addAnnotationGroup(y,x,w);let C=f.Class.Annotation.EDGE,G=y.renderMetaedgeInfo&&y.renderMetaedgeInfo.metaedge;G&&!G.numRegularEdges&&(C+=" "+f.Class.Annotation.CONTROL_EDGE);G&&G.numRefEdges&&(C+=" "+f.Class.Edge.REF_LINE);
f.edge.appendEdge(w,y,A,C);y.annotationType!==d.render.AnnotationType.ELLIPSIS?(l(w,y),t(w,y)):p(w,y.node.name,y,f.Class.Annotation.ELLIPSIS)}).merge(q).attr("class",y=>f.Class.Annotation.GROUP+" "+k(y.annotationType)+" "+f.node.nodeClass(y)).each(function(y){let w=d3.select(this);n(w,x,y,A);y.annotationType!==d.render.AnnotationType.ELLIPSIS&&m(w,x,y,A)});q.exit().each(function(y){let w=d3.select(this);A.removeAnnotationGroup(y,x,w)}).remove();return q}})(f.annotation||(f.annotation={}))})(d.scene||
(d.scene={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/colors.js
(function(b){b.COLORS=[{name:"Google Blue",color:"#4184f3",active:"#3a53c5",disabled:"#cad8fc"},{name:"Google Red",color:"#db4437",active:"#8f2a0c",disabled:"#e8c6c1"},{name:"Google Yellow",color:"#f4b400",active:"#db9200",disabled:"#f7e8b0"},{name:"Google Green",color:"#0f9d58",active:"#488046",disabled:"#c2e1cc"},{name:"Purple",color:"#aa46bb",active:"#5c1398",disabled:"#d7bce6"},{name:"Teal",color:"#00abc0",active:"#47828e",disabled:"#c2eaf2"},{name:"Deep Orange",color:"#ff6f42",active:"#ca4a06",
disabled:"#f2cbba"},{name:"Lime",color:"#9d9c23",active:"#7f771d",disabled:"#f1f4c2"},{name:"Indigo",color:"#5b6abf",active:"#3e47a9",disabled:"#c5c8e8"},{name:"Pink",color:"#ef6191",active:"#ca1c60",disabled:"#e9b9ce"},{name:"Deep Teal",color:"#00786a",active:"#2b4f43",disabled:"#bededa"},{name:"Deep Pink",color:"#c1175a",active:"#75084f",disabled:"#de8cae"},{name:"Gray",color:"#9E9E9E",active:"#424242",disabled:"F5F5F5"}].reduce((d,f)=>{d[f.name]=f;return d},{});b.OP_GROUP_COLORS=[{color:"Google Red",
groups:"gen_legacy_ops legacy_ops legacy_flogs_input legacy_image_input legacy_input_example_input legacy_sequence_input legacy_seti_input_input".split(" ")},{color:"Deep Orange",groups:["constant_ops"]},{color:"Indigo",groups:["state_ops"]},{color:"Purple",groups:["nn_ops","nn"]},{color:"Google Green",groups:["math_ops"]},{color:"Lime",groups:["array_ops"]},{color:"Teal",groups:["control_flow_ops","data_flow_ops"]},{color:"Pink",groups:["summary_ops"]},{color:"Deep Pink",groups:["io_ops"]}].reduce((d,
f)=>{f.groups.forEach(function(h){d[h]=f.color});return d},{})})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/common.js
(function(b){(function(d){(function(f){f.OP_GRAPH="op_graph";f.CONCEPTUAL_GRAPH="conceptual_graph";f.PROFILE="profile"})(d.SelectionType||(d.SelectionType={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/contextmenu.js
(function(b){(function(d){(function(f){(function(h){function k(t){let l=0,p=0;for(;t&&0<=t.offsetLeft&&0<=t.offsetTop;)l+=t.offsetLeft-t.scrollLeft,p+=t.offsetTop-t.scrollTop,t=t.offsetParent;return{left:l,top:p}}h.getMenu=function(t,l){const p=t.getContextMenu(),m=d3.select(t.getContextMenu());return function(n,q){function u(y){y&&y.composedPath().includes(p)||(m.style("display","none"),document.body.removeEventListener("mousedown",u,{capture:!0}))}let x=d3.event;const A=k(t);m.style("display","block").style("left",
x.clientX-A.left+1+"px").style("top",x.clientY-A.top+1+"px");x.preventDefault();x.stopPropagation();document.body.addEventListener("mousedown",u,{capture:!0});m.html("");m.append("ul").selectAll("li").data(l).enter().append("li").on("click",y=>{y.action(this,n,q);u()}).html(function(y){return y.title(n)})}}})(f.contextmenu||(f.contextmenu={}))})(d.scene||(d.scene={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/edge.js
(function(b){(function(d){(function(f){(function(h){function k(y){return y.v+d.EDGE_KEY_DELIM+y.w}function t(y,w){w=w.getNodeByName(y.v);if(null==w.outputShapes||_.isEmpty(w.outputShapes))return null;y=w.outputShapes[y.outputTensorKey];return null==y?null:0===y.length?"scalar":y.map(C=>-1===C?"?":C).join("\u00d7")}function l(y,w){return w.edgeLabelFunction?w.edgeLabelFunction(y,w):1<y.baseEdgeList.length?y.baseEdgeList.length+" tensors":t(y.baseEdgeList[0],w)}function p(y,w,C){const G=document.createElementNS(b.graph.scene.SVG_NAMESPACE,
"path");for(let D=1;D<y.length;D++)if(G.setAttribute("d",C(y.slice(0,D))),G.getTotalLength()>w)return D-1;return y.length-1}function m(y,w,C){var G=d3.line().x(N=>N.x).y(N=>N.y),D=d3.select(document.createElementNS("http://www.w3.org/2000/svg","path")).attr("d",G(y)),B=+w.attr("markerWidth"),I=w.attr("viewBox").split(" ").map(Number);I=I[2]-I[0];w=+w.attr("refX");D=D.node();if(C)return B*=1-w/I,C=D.getPointAtLength(B),G=p(y,B,G),y[G-1]={x:C.x,y:C.y},y.slice(G-1);C=1-w/I;B=D.getTotalLength()-B*C;C=
D.getPointAtLength(B);G=p(y,B,G);y[G]={x:C.x,y:C.y};return y.slice(0,G+1)}function n(y,w,C,G){G=G||f.Class.Edge.LINE;w.label&&w.label.structural&&(G+=" "+f.Class.Edge.STRUCTURAL);w.label&&w.label.metaedge&&w.label.metaedge.numRefEdges&&(G+=" "+f.Class.Edge.REFERENCE_EDGE);C.handleEdgeSelected&&(G+=" "+f.Class.Edge.SELECTABLE);let D="path_"+k(w);if(C.renderHierarchy.edgeWidthFunction)var B=C.renderHierarchy.edgeWidthFunction(w,G);else B=1,null!=w.label&&null!=w.label.metaedge&&(B=w.label.metaedge.totalSize),
B=C.renderHierarchy.edgeWidthSizedBasedScale(B);G=y.append("path").attr("id",D).attr("class",G).style("stroke-width",B+"px");w.label&&w.label.metaedge&&(w.label.metaedge.numRefEdges?(B=`reference-arrowhead-${A(B)}`,G.style("marker-start",`url(#${B})`),w.label.startMarkerId=B):(B=`dataflow-arrowhead-${A(B)}`,G.style("marker-end",`url(#${B})`),w.label.endMarkerId=B));null!=w.label&&null!=w.label.metaedge&&(w=l(w.label.metaedge,C.renderHierarchy),null!=w&&y.append("text").append("textPath").attr("xlink:href",
"#"+D).attr("startOffset","50%").attr("text-anchor","middle").attr("dominant-baseline","central").text(w))}function q(y,w,C,G,D){G=C.label;let B=G.adjoiningMetaedge,I=G.points;y=y.shadowRoot;C.label.startMarkerId&&(I=m(I,d3.select(y.querySelector("#"+C.label.startMarkerId)),!0));C.label.endMarkerId&&(I=m(I,d3.select(y.querySelector("#"+C.label.endMarkerId)),!1));if(!B)return d3.interpolate(D,h.interpolate(I));let N=B.edgeGroup.node().firstChild,O=G.metaedge.inbound;return function(){let H=N.getPointAtLength(O?
N.getTotalLength():0).matrixTransform(N.getCTM()).matrixTransform(w.getCTM().inverse()),K=O?0:I.length-1;I[K].x=H.x;I[K].y=H.y;return h.interpolate(I)}}function u(y,w){d3.select(w).select("path."+f.Class.Edge.LINE).transition().attrTween("d",function(C,G,D){return q(y,this,C,G,D)})}function x(y,w){y.classed("faded",w.label.isFadedOut);w=w.label.metaedge;y.select("path."+f.Class.Edge.LINE).classed("control-dep",w&&!w.numRegularEdges)}h.MIN_EDGE_WIDTH=.75;h.MAX_EDGE_WIDTH=12;h.EDGE_WIDTH_SIZE_BASED_SCALE=
d3.scalePow().exponent(.3).domain([1,5E6]).range([h.MIN_EDGE_WIDTH,h.MAX_EDGE_WIDTH]).clamp(!0);let A=d3.scaleQuantize().domain([h.MIN_EDGE_WIDTH,h.MAX_EDGE_WIDTH]).range(["small","medium","large","xlarge"]);h.getEdgeKey=k;h.buildGroup=function(y,w,C){let G=[];G=_.reduce(w.edges(),(D,B)=>{let I=w.edge(B);D.push({v:B.v,w:B.w,label:I});return D},G);y=f.selectOrCreateChild(y,"g",f.Class.Edge.CONTAINER).selectAll(function(){return this.childNodes}).data(G,k);y.enter().append("g").attr("class",f.Class.Edge.GROUP).attr("data-edge",
k).each(function(D){let B=d3.select(this);D.label.edgeGroup=B;C._edgeGroupIndex[k(D)]=B;if(C.handleEdgeSelected)B.on("click",I=>{d3.event.stopPropagation();C.fire("edge-select",{edgeData:I,edgeGroup:B})});n(B,D,C)}).merge(y).each(function(){u(C,this)}).each(function(D){x(d3.select(this),D,C)});y.exit().each(D=>{delete C._edgeGroupIndex[k(D)]}).remove();return y};h.getLabelForBaseEdge=t;h.getLabelForEdge=l;h.appendEdge=n;h.interpolate=d3.line().curve(d3.curveBasis).x(y=>y.x).y(y=>y.y)})(f.edge||(f.edge=
{}))})(d.scene||(d.scene={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/externs.js

//# sourceURL=build://tf-graph-common/graph.js
(function(b){(function(d){function f(H,K,M,L,Q){return(M?M+"/":"")+(H+("undefined"!==typeof L&&"undefined"!==typeof Q?"["+L+"-"+Q+"]":"#")+K)}function h(H){if(!H)return null;for(let K=0;K<H.length;K++){let {key:M,value:L}=H[K];if("_output_shapes"===M){if(!L.list.shape)break;let Q=L.list.shape.map(T=>T.unknown_rank?null:null==T.dim||1===T.dim.length&&null==T.dim[0].size?[]:T.dim.map(X=>X.size));H.splice(K,1);return Q}}return null}function k(H){if(!H)return null;for(let K=0;K<H.length;K++)if("_XlaCluster"===
H[K].key)return H[K].value.s||null;return null}function t(H){let K=[];_.each(H,M=>{let L="^"===M[0];L&&(M=M.substring(1));let Q=M,T="0",X=M.match(/(.*):(\w+:\d+)$/);if(X)Q=X[1],T=X[2];else if(X=M.match(/(.*):(\d+)$/))Q=X[1],T=X[2];0!==K.length&&Q===K[K.length-1].name||K.push({name:Q,outputTensorKey:T,isControlDependency:L})});return K}function l(H,K,M,L,Q,T){K!==M.name&&H.edges.push({v:K,w:M.name,outputTensorKey:L.outputTensorKey,isControlDependency:L.isControlDependency,isReferenceEdge:!0===Q.refEdges[M.op+
" "+T]})}function p(H,K,M){M=M||{};let L=new graphlib.Graph(M);L.setGraph({name:H,rankdir:M.rankdir||"BT",type:K});return L}function m(H){return function(K){for(let M=0;M<H.length;M++){let L=new RegExp(H[M]);if("string"===typeof K.op&&K.op.match(L))return!0}return!1}}function n(H){let K=H.split(d.NAMESPACE_DELIM);return H+d.NAMESPACE_DELIM+"("+K[K.length-1]+")"}function q(H,K){let M={},L={};H.sort();for(let Q=0;Q<H.length-1;++Q){let T=H[Q];_.each(x(T).slice(0,-1),X=>{L[X]=!0});for(let X=Q+1;X<H.length;++X){let aa=
H[X];if(_.startsWith(aa,T)){if(aa.length>T.length&&aa.charAt(T.length)===d.NAMESPACE_DELIM){M[T]=n(T);break}}else break}}_.each(K,Q=>{Q in L&&(M[Q]=n(Q))});return M}function u(H){let K=H.nodes().map(function(M){return H.neighbors(M).length});K.sort();return K}function x(H,K){let M=[],L=H.indexOf(d.NAMESPACE_DELIM);for(;0<=L;)M.push(H.substring(0,L)),L=H.indexOf(d.NAMESPACE_DELIM,L+1);K&&(K=K[H])&&M.push(K);M.push(H);return M}d.NAMESPACE_DELIM="/";d.ROOT_NAME="__root__";d.FUNCTION_LIBRARY_NODE_PREFIX=
"__function_library__";d.LARGE_ATTRS_KEY="_too_large_attrs";d.LIMIT_ATTR_SIZE=1024;d.EDGE_KEY_DELIM="--";let A;(function(H){H[H.FULL=0]="FULL";H[H.EMBEDDED=1]="EMBEDDED";H[H.META=2]="META";H[H.SERIES=3]="SERIES";H[H.CORE=4]="CORE";H[H.SHADOW=5]="SHADOW";H[H.BRIDGE=6]="BRIDGE";H[H.EDGE=7]="EDGE"})(A=d.GraphType||(d.GraphType={}));let y;(function(H){H[H.META=0]="META";H[H.OP=1]="OP";H[H.SERIES=2]="SERIES";H[H.BRIDGE=3]="BRIDGE";H[H.ELLIPSIS=4]="ELLIPSIS"})(y=d.NodeType||(d.NodeType={}));let w;(function(H){H[H.INCLUDE=
0]="INCLUDE";H[H.EXCLUDE=1]="EXCLUDE";H[H.UNSPECIFIED=2]="UNSPECIFIED"})(w=d.InclusionType||(d.InclusionType={}));(function(H){H[H.GROUP=0]="GROUP";H[H.UNGROUP=1]="UNGROUP"})(d.SeriesGroupingType||(d.SeriesGroupingType={}));class C{constructor(){this.nodes={};this.edges=[]}}d.SlimGraph=C;class G{constructor(H){this.type=y.ELLIPSIS;this.isGroupNode=!1;this.cardinality=1;this.stats=this.parentNode=null;this.setNumMoreNodes(H);this.include=w.UNSPECIFIED}setNumMoreNodes(H){this.numMoreNodes=H;this.name=
"... "+H+" more"}}d.EllipsisNodeImpl=G;class D{constructor(H){this.op=H.op;this.name=H.name;this.device=H.device;this.attr=H.attr;this.inputs=t(H.input);this.outputShapes=h(H.attr);this.xlaCluster=k(H.attr);this.compatible=!1;this.type=y.OP;this.isGroupNode=!1;this.cardinality=1;this.inEmbeddings=[];this.outEmbeddings=[];this.parentNode=null;this.include=w.UNSPECIFIED;this.owningSeries=null}}d.OpNodeImpl=D;d.createMetanode=function(H,K={}){return new I(H,K)};d.joinStatsInfoWithGraph=function(H,K,
M){_.each(H.nodes,L=>{L.stats=null});_.each(K.dev_stats,L=>{M&&!M[L.device]||_.each(L.node_stats,Q=>{let T=Q.node_name in H.nodes?Q.node_name:n(Q.node_name);if(T in H.nodes){var X=0;Q.memory&&_.each(Q.memory,la=>{la.total_bytes&&(0<la.total_bytes?X+=Number(la.total_bytes):console.log("ignoring negative memory allocation for "+T))});var aa=null;Q.output&&(aa=_.map(Q.output,la=>_.map(la.tensor_description.shape.dim,Z=>Number(Z.size))));H.nodes[T].device=L.device;null==H.nodes[T].stats&&(H.nodes[T].stats=
new B(aa));H.nodes[T].stats.addBytesAllocation(X);Q.all_end_rel_micros&&(0<Q.all_end_rel_micros?H.nodes[T].stats.addExecutionTime(Q.all_start_micros,Q.all_start_micros+Q.all_end_rel_micros):console.log("ignoring negative runtime for "+T))}})})};class B{constructor(H){this.totalBytes=0;this.outputSize=H}addExecutionTime(H,K){this.startTime=null!=this.startTime?Math.min(this.startTime,H):H;this.endTime=null!=this.endTime?Math.max(this.endTime,K):K}addBytesAllocation(H){this.totalBytes=null!=this.totalBytes?
Math.max(this.totalBytes,H):H}combine(H){null!=H.totalBytes&&(this.totalBytes+=H.totalBytes);null!=H.getTotalMicros()&&this.addExecutionTime(H.startTime,H.endTime)}getTotalMicros(){return null==this.startTime||null==this.endTime?null:this.endTime-this.startTime}}d.NodeStats=B;class I{constructor(H,K={}){this.name=H;this.type=y.META;this.depth=1;this.isGroupNode=!0;this.cardinality=0;this.metagraph=p(H,A.META,K);this.bridgegraph=null;this.opHistogram={};this.deviceHistogram={};this.xlaClusterHistogram=
{};this.compatibilityHistogram={compatible:0,incompatible:0};this.parentNode=this.templateId=null;this.hasNonControlEdges=!1;this.include=w.UNSPECIFIED;this.associatedFunction=""}getFirstChild(){return this.metagraph.node(this.metagraph.nodes()[0])}getRootOp(){let H=this.name.split("/");return this.metagraph.node(this.name+"/("+H[H.length-1]+")")}leaves(){let H=[],K=[this],M;for(;K.length;){let L=K.shift();L.isGroupNode?(M=L.metagraph,_.each(M.nodes(),Q=>K.push(M.node(Q)))):H.push(L.name)}return H}}
d.MetanodeImpl=I;d.createMetaedge=function(H,K){return new N(H,K)};class N{constructor(H,K){this.v=H;this.w=K;this.baseEdgeList=[];this.inbound=null;this.totalSize=this.numRefEdges=this.numControlEdges=this.numRegularEdges=0}addBaseEdge(H,K){this.baseEdgeList.push(H);H.isControlDependency?this.numControlEdges+=1:this.numRegularEdges+=1;H.isReferenceEdge&&(this.numRefEdges+=1);this.totalSize+=N.computeSizeOfEdge(H,K);K.maxMetaEdgeSize=Math.max(K.maxMetaEdgeSize,this.totalSize)}static computeSizeOfEdge(H,
K){let M=K.node(H.v);if(!M.outputShapes)return 1;K.hasShapeInfo=!0;H=Object.keys(M.outputShapes).map(L=>M.outputShapes[L]).map(L=>null==L?1:L.reduce((Q,T)=>{-1===T&&(T=1);return Q*T},1));return _.sum(H)}}d.MetaedgeImpl=N;d.createSeriesNode=function(H,K,M,L,Q,T){return new O(H,K,M,L,Q,T)};d.getSeriesNodeName=f;class O{constructor(H,K,M,L,Q,T){this.name=Q||f(H,K,M);this.type=y.SERIES;this.hasLoop=!1;this.prefix=H;this.suffix=K;this.clusterId=L;this.ids=[];this.parent=M;this.isGroupNode=!0;this.cardinality=
0;this.metagraph=p(Q,A.SERIES,T);this.parentNode=this.bridgegraph=null;this.deviceHistogram={};this.xlaClusterHistogram={};this.compatibilityHistogram={compatible:0,incompatible:0};this.hasNonControlEdges=!1;this.include=w.UNSPECIFIED}}d.DefaultBuildParams={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}};d.build=function(H,K,M){let L={},Q={},T={},X=m(K.inEmbeddingTypes),aa=m(K.outEmbeddingTypes),la=[],Z=H.node,ba=Array(Z.length);return b.graph.util.runAsyncTask("Normalizing names",30,()=>{let ea=Array(Z.length),ca=0;const ka=Ea=>{let va=new D(Ea);if(X(va))return la.push(va.name),L[va.name]=va;if(aa(va))return la.push(va.name),Q[va.name]=va,_.each(va.inputs,xa=>{xa=xa.name;T[xa]=T[xa]||[];T[xa].push(va)}),va;ea[ca]=
va;ba[ca]=va.name;ca++;return va};_.each(Z,ka);const Y=Ea=>{const va=d.FUNCTION_LIBRARY_NODE_PREFIX+Ea.signature.name;ka({name:va,input:[],device:"",op:"",attr:[]});if(Ea.signature.input_arg){let ya=0;var xa=Sa=>{ka({name:va+d.NAMESPACE_DELIM+Sa.name,input:[],device:"",op:"input_arg",attr:[{key:"T",value:{type:Sa.type}}]}).functionInputIndex=ya;ya++};Ea.signature.input_arg.name?xa(Ea.signature.input_arg):_.each(Ea.signature.input_arg,xa)}let Aa=0;const Fa={};Ea.signature.output_arg&&(xa=ya=>{Fa[va+
d.NAMESPACE_DELIM+ya.name]=Aa;Aa++},Ea.signature.output_arg.name?xa(Ea.signature.output_arg):_.each(Ea.signature.output_arg,xa));_.each(Ea.node_def,ya=>{ya.name=va+"/"+ya.name;"string"===typeof ya.input&&(ya.input=[ya.input]);const Sa=ka(ya);_.isNumber(Fa[ya.name])&&(Sa.functionOutputIndex=Fa[ya.name]);_.each(Sa.inputs,Xa=>{Xa.name=va+d.NAMESPACE_DELIM+Xa.name})})};H.library&&H.library.function&&_.each(H.library.function,Y);ea.splice(ca);ba.splice(ca);return ea},M).then(ea=>b.graph.util.runAsyncTask("Building the data structure",
70,()=>{let ca=q(ba,la),ka=new C;_.each(ea,Y=>{let Ea=ca[Y.name]||Y.name;ka.nodes[Ea]=Y;Y.name in T&&(Y.outEmbeddings=T[Y.name],_.each(Y.outEmbeddings,va=>{va.name=ca[va.name]||va.name}));Y.name=Ea});_.each(ea,Y=>{_.each(Y.inputs,(Ea,va)=>{let xa=Ea.name;if(xa in L){Ea=L[xa];Y.inEmbeddings.push(Ea);for(var Aa of Ea.inputs)l(ka,ca[Aa.name]||Aa.name,Y,Aa,K,va)}else if(xa in Q){Aa=Q[xa];for(let Fa of Aa.inputs)l(ka,ca[Fa.name]||Fa.name,Y,Ea,K,va)}else l(ka,ca[xa]||xa,Y,Ea,K,va)})});_.each(L,Y=>{Y.name=
ca[Y.name]||Y.name});return ka},M))};d.createGraph=p;d.getStrictName=n;d.hasSimilarDegreeSequence=function(H,K){H=u(H);K=u(K);for(let M=0;M<H.length;M++)if(H[M]!==K[M])return!1;return!0};d.getHierarchicalPath=x;d.getIncludeNodeButtonString=function(H){return H===b.graph.InclusionType.EXCLUDE?"Add to main graph":"Remove from main graph"};d.getGroupSeriesNodeButtonString=function(H){return H===b.graph.SeriesGroupingType.GROUP?"Ungroup this series of nodes":"Group this series of nodes"};d.toggleNodeSeriesGroup=
function(H,K){H[K]=K in H&&H[K]!==b.graph.SeriesGroupingType.GROUP?b.graph.SeriesGroupingType.GROUP:b.graph.SeriesGroupingType.UNGROUP}})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/hierarchy.js
(function(b){(function(d){(function(f){function h(x,A,y,w){A=y?x.inEdges(A.name):x.outEdges(A.name);_.each(A,C=>{C=x.edge(C);(C.numRegularEdges?w.regular:w.control).push(C)})}function k(x,A){const y={};_.each(A.nodes,w=>{let C=d.getHierarchicalPath(w.name),G=x.root;G.depth=Math.max(C.length,G.depth);y[w.op]||(y[w.op]=[]);y[w.op].push(w);for(let B=0;B<C.length;B++){G.depth=Math.max(G.depth,C.length-B);G.cardinality+=w.cardinality;G.opHistogram[w.op]=(G.opHistogram[w.op]||0)+1;null!=w.device&&(G.deviceHistogram[w.device]=
(G.deviceHistogram[w.device]||0)+1);null!=w.xlaCluster&&(G.xlaClusterHistogram[w.xlaCluster]=(G.xlaClusterHistogram[w.xlaCluster]||0)+1);w.compatible?G.compatibilityHistogram.compatible=(G.compatibilityHistogram.compatible||0)+1:G.compatibilityHistogram.incompatible=(G.compatibilityHistogram.incompatible||0)+1;_.each(w.inEmbeddings,N=>{N.compatible?G.compatibilityHistogram.compatible=(G.compatibilityHistogram.compatible||0)+1:G.compatibilityHistogram.incompatible=(G.compatibilityHistogram.incompatible||
0)+1});_.each(w.outEmbeddings,N=>{N.compatible?G.compatibilityHistogram.compatible=(G.compatibilityHistogram.compatible||0)+1:G.compatibilityHistogram.incompatible=(G.compatibilityHistogram.incompatible||0)+1});if(B===C.length-1)break;var D=C[B];let I=x.node(D);I||(I=d.createMetanode(D,x.graphOptions),I.parentNode=G,x.setNode(D,I),G.metagraph.setNode(D,I),0===D.indexOf(b.graph.FUNCTION_LIBRARY_NODE_PREFIX)&&G.name===b.graph.ROOT_NAME&&(D=D.substring(b.graph.FUNCTION_LIBRARY_NODE_PREFIX.length),y[D]||
(y[D]=[]),x.libraryFunctions[D]={node:I,usages:y[D]},I.associatedFunction=D));G=I}x.setNode(w.name,w);w.parentNode=G;G.metagraph.setNode(w.name,w);_.each(w.inEmbeddings,function(B){x.setNode(B.name,B);B.parentNode=w});_.each(w.outEmbeddings,function(B){x.setNode(B.name,B);B.parentNode=w})})}function t(x,A){let y=x.getNodeMap(),w=[],C=[],G=(D,B)=>{let I=0;for(;D;)B[I++]=D.name,D=D.parentNode;return I-1};_.each(A.edges,D=>{var B=G(A.nodes[D.v],w),I=G(A.nodes[D.w],C);if(-1!==B&&-1!==I){for(;w[B]===C[I];)if(B--,
I--,0>B||0>I)throw Error("No difference found between ancestor paths.");var N=y[w[B+1]];B=w[B];I=C[I];var O=N.metagraph.edge(B,I);O||(O=d.createMetaedge(B,I),N.metagraph.setEdge(B,I,O));N.hasNonControlEdges||D.isControlDependency||(N.hasNonControlEdges=!0);O.addBaseEdge(D,x)}})}function l(x,A,y,w,C,G){let D=x.metagraph;_.each(D.nodes(),B=>{B=D.node(B);B.type===b.graph.NodeType.META&&l(B,A,y,w,C,G)});x=p(D);x=(G?n:m)(x,D,A.graphOptions);_.each(x,function(B,I){let N=B.metagraph.nodes();_.each(N,O=>
{O=D.node(O);O.owningSeries||(O.owningSeries=I)});N.length<w&&!(B.name in C)&&(C[B.name]=b.graph.SeriesGroupingType.UNGROUP);B.name in C&&C[B.name]===b.graph.SeriesGroupingType.UNGROUP||(A.setNode(I,B),D.setNode(I,B),_.each(N,O=>{let H=D.node(O);B.metagraph.setNode(O,H);B.parentNode=H.parentNode;B.cardinality++;null!=H.device&&(B.deviceHistogram[H.device]=(B.deviceHistogram[H.device]||0)+1);null!=H.xlaCluster&&(B.xlaClusterHistogram[H.xlaCluster]=(B.xlaClusterHistogram[H.xlaCluster]||0)+1);H.compatible?
B.compatibilityHistogram.compatible=(B.compatibilityHistogram.compatible||0)+1:B.compatibilityHistogram.incompatible=(B.compatibilityHistogram.incompatible||0)+1;_.each(H.inEmbeddings,K=>{K.compatible?B.compatibilityHistogram.compatible=(B.compatibilityHistogram.compatible||0)+1:B.compatibilityHistogram.incompatible=(B.compatibilityHistogram.incompatible||0)+1});_.each(H.outEmbeddings,K=>{K.compatible?B.compatibilityHistogram.compatible=(B.compatibilityHistogram.compatible||0)+1:B.compatibilityHistogram.incompatible=
(B.compatibilityHistogram.incompatible||0)+1});H.parentNode=B;y[O]=I;D.removeNode(O)}))})}function p(x){return _.reduce(x.nodes(),(A,y)=>{y=x.node(y);if(y.type===d.NodeType.META)return A;let w=y.op;w&&(A[w]=A[w]||[],A[w].push(y.name));return A},{})}function m(x,A,y){let w={};_.each(x,function(C,G){if(!(1>=C.length)){var D={};_.each(C,function(B){var I="*"===B.charAt(B.length-1),N=B.split("/"),O=N[N.length-1];N=N.slice(0,N.length-1).join("/");var H=O.match(/^(\D*)_(\d+)$/);let K="";H?(O=H[1],H=H[2]):
(O=I?O.substr(0,O.length-1):O,H=0,K=I?"*":"");I=d.getSeriesNodeName(O,K,N);D[I]=D[I]||[];B=d.createSeriesNode(O,K,N,+H,B,y);D[I].push(B)});_.each(D,function(B){if(!(2>B.length)){B.sort(function(N,O){return+N.clusterId-+O.clusterId});var I=[B[0]];for(let N=1;N<B.length;N++){let O=B[N];O.clusterId===I[I.length-1].clusterId+1?I.push(O):(q(I,w,+G,A,y),I=[O])}q(I,w,+G,A,y)}})}});return w}function n(x,A,y){let w={};_.each(x,function(C,G){if(!(1>=C.length)){var D={},B={};_.each(C,function(N){let O="*"===
N.charAt(N.length-1);var H=N.split("/");let K=H[H.length-1];H=H.slice(0,H.length-1).join("/");const M=/(\d+)/g;var L;let Q,T,X,aa=0;for(;L=M.exec(K);)++aa,Q=K.slice(0,L.index),T=L[0],L=K.slice(L.index+L[0].length),X=d.getSeriesNodeName(Q,L,H),D[X]=D[X],D[X]||(D[X]=d.createSeriesNode(Q,L,H,+T,N,y)),D[X].ids.push(T),B[N]=B[N]||[],B[N].push([X,T]);1>aa&&(Q=O?K.substr(0,K.length-1):K,T=0,L=O?"*":"",X=d.getSeriesNodeName(Q,L,H),D[X]=D[X],D[X]||(D[X]=d.createSeriesNode(Q,L,H,+T,N,y)),D[X].ids.push(T),B[N]=
B[N]||[],B[N].push([X,T]))});var I={};_.each(B,function(N,O){N.sort(function(M,L){return D[L[0]].ids.length-D[M[0]].ids.length});var H=N[0][0];N=N[0][1];I[H]=I[H]||[];const K=O.split("/");O=d.createSeriesNode(D[H].prefix,D[H].suffix,K.slice(0,K.length-1).join("/"),+N,O,y);I[H].push(O)});_.each(I,function(N){if(!(2>N.length)){N.sort(function(H,K){return+H.clusterId-+K.clusterId});var O=[N[0]];for(let H=1;H<N.length;H++){let K=N[H];K.clusterId===O[O.length-1].clusterId+1?O.push(K):(q(O,w,+G,A,y),O=
[K])}q(O,w,+G,A,y)}})}});return w}function q(x,A,y,w,C){if(1<x.length){let G=d.getSeriesNodeName(x[0].prefix,x[0].suffix,x[0].parent,x[0].clusterId,x[x.length-1].clusterId),D=d.createSeriesNode(x[0].prefix,x[0].suffix,x[0].parent,y,G,C);_.each(x,function(B){D.ids.push(B.clusterId);D.metagraph.setNode(B.name,w.node(B.name))});A[G]=D}}class u{constructor(x){this.hasShapeInfo=!1;this.maxMetaEdgeSize=1;this.graphOptions=x||{};this.graphOptions.compound=!0;this.root=d.createMetanode(d.ROOT_NAME,this.graphOptions);
this.libraryFunctions={};this.xlaClusters=this.devices=this.templates=null;this.index={};this.index[d.ROOT_NAME]=this.root;this.orderings={}}getNodeMap(){return this.index}node(x){return this.index[x]}setNode(x,A){this.index[x]=A}getBridgegraph(x){var A=this.index[x];if(!A)throw Error("Could not find node in hierarchy: "+x);if(!("metagraph"in A))return null;if(A.bridgegraph)return A.bridgegraph;let y=A.bridgegraph=d.createGraph("BRIDGEGRAPH",d.GraphType.BRIDGE,this.graphOptions);if(!(A.parentNode&&
"metagraph"in A.parentNode))return y;var w=A.parentNode;A=w.metagraph;w=this.getBridgegraph(w.name);_.each([A,w],C=>{C.edges().filter(G=>G.v===x||G.w===x).forEach(G=>{let D=G.w===x,B=C.edge(G);_.each(B.baseEdgeList,I=>{let [N,O]=D?[I.w,G.v]:[I.v,G.w];var H=this.getChildName(x,N);H={v:D?O:H,w:D?H:O};let K=y.edge(H);K||(K=d.createMetaedge(H.v,H.w),K.inbound=D,y.setEdge(H.v,H.w,K));K.addBaseEdge(I,this)})})});return y}getChildName(x,A){let y=this.index[A];for(;y;){if(y.parentNode&&y.parentNode.name===
x)return y.name;y=y.parentNode}throw Error("Could not find immediate child for descendant: "+A);}getPredecessors(x){let A=this.index[x];if(!A)throw Error("Could not find node with name: "+x);let y=this.getOneWayEdges(A,!0);A.isGroupNode||_.each(A.inEmbeddings,w=>{_.each(A.inputs,C=>{if(C.name===w.name){let G=new d.MetaedgeImpl(w.name,x);G.addBaseEdge({isControlDependency:C.isControlDependency,outputTensorKey:C.outputTensorKey,isReferenceEdge:!1,v:w.name,w:x},this);y.regular.push(G)}})});return y}getSuccessors(x){let A=
this.index[x];if(!A)throw Error("Could not find node with name: "+x);let y=this.getOneWayEdges(A,!1);A.isGroupNode||_.each(A.outEmbeddings,w=>{_.each(w.inputs,C=>{if(C.name===x){let G=new d.MetaedgeImpl(x,w.name);G.addBaseEdge({isControlDependency:C.isControlDependency,outputTensorKey:C.outputTensorKey,isReferenceEdge:!1,v:x,w:w.name},this);y.regular.push(G)}})});return y}getOneWayEdges(x,A){let y={control:[],regular:[]};if(!x.parentNode||!x.parentNode.isGroupNode)return y;var w=x.parentNode;let C=
w.metagraph;w=this.getBridgegraph(w.name);h(C,x,A,y);h(w,x,A,y);return y}getTopologicalOrdering(x){var A=this.index[x];if(!A)throw Error("Could not find node with name: "+x);if(!A.isGroupNode)return null;if(x in this.orderings)return this.orderings[x];let y={},w={},C=A.metagraph;_.each(C.edges(),D=>{C.edge(D).numRegularEdges&&(D.v in y||(y[D.v]=[]),y[D.v].push(D.w),w[D.w]=!0)});let G=_.difference(_.keys(y),_.keys(w));x=this.orderings[x]={};for(A=0;G.length;){let D=G.shift();x[D]=A++;_.each(y[D],B=>
G.push(B));delete y[D]}return x}getTemplateIndex(){let x=d3.keys(this.templates),A=d3.scaleOrdinal().domain(x).range(d3.range(0,x.length));return y=>A(y)}}f.DefaultHierarchyParams={verifyTemplate:!0,seriesNodeMinSize:5,seriesMap:{},rankDirection:"BT",useGeneralizedSeriesPatterns:!1};f.build=function(x,A,y){let w=new u({rankdir:A.rankDirection}),C={};return b.graph.util.runAsyncTask("Adding nodes",20,()=>{let G={},D={};_.each(x.nodes,B=>{B.device&&(G[B.device]=!0);B.xlaCluster&&(D[B.xlaCluster]=!0)});
w.devices=_.keys(G);w.xlaClusters=_.keys(D);k(w,x)},y).then(()=>b.graph.util.runAsyncTask("Detect series",20,()=>{0<A.seriesNodeMinSize&&l(w.root,w,C,A.seriesNodeMinSize,A.seriesMap,A.useGeneralizedSeriesPatterns)},y)).then(()=>b.graph.util.runAsyncTask("Adding edges",30,()=>{t(w,x,C)},y)).then(()=>b.graph.util.runAsyncTask("Finding similar subgraphs",30,()=>{w.templates=d.template.detect(w,A.verifyTemplate)},y)).then(()=>w)};f.joinAndAggregateStats=function(x){let A={},y={};_.each(x.root.leaves(),
w=>{w=x.node(w);null!=w.device&&(A[w.device]=!0);null!=w.xlaCluster&&(y[w.xlaCluster]=!0)});x.devices=_.keys(A);x.xlaClusters=_.keys(y);_.each(x.getNodeMap(),w=>{w.isGroupNode&&(w.stats=new d.NodeStats(null),w.deviceHistogram={})});_.each(x.root.leaves(),w=>{let C=w=x.node(w);for(;null!=C.parentNode;){if(null!=w.device){var G=C.parentNode.deviceHistogram;G[w.device]=(G[w.device]||0)+1}null!=w.xlaCluster&&(G=C.parentNode.xlaClusterHistogram,G[w.xlaCluster]=(G[w.xlaCluster]||0)+1);null!=w.stats&&C.parentNode.stats.combine(w.stats);
C=C.parentNode}})};f.getIncompatibleOps=function(x,A){let y=[],w={};_.each(x.root.leaves(),C=>{C=x.node(C);if(C.type==d.NodeType.OP){if(!C.compatible)if(C.owningSeries)if(A&&A.seriesMap[C.owningSeries]===b.graph.SeriesGroupingType.UNGROUP)y.push(C);else{if(!w[C.owningSeries]){let G=x.node(C.owningSeries);G&&(w[C.owningSeries]=G,y.push(G))}}else y.push(C);_.each(C.inEmbeddings,G=>{G.compatible||y.push(G)});_.each(C.outEmbeddings,G=>{G.compatible||y.push(G)})}});return y}})(d.hierarchy||(d.hierarchy=
{}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/layout.js
(function(b){(function(d){(function(f){function h(w){w.node.isGroupNode&&t(w);w.node.type===d.NodeType.META?p(w):w.node.type===d.NodeType.SERIES&&m(w)}function k(w){w.inboxWidth=0<w.inAnnotations.list.length?f.PARAMS.annotations.inboxWidth:0;w.outboxWidth=0<w.outAnnotations.list.length?f.PARAMS.annotations.outboxWidth:0;w.coreBox.width=w.width;w.coreBox.height=w.height;w.width=Math.max(w.coreBox.width+w.inboxWidth+w.outboxWidth,3*w.displayName.length)}function t(w){let C=w.coreGraph.nodes().map(G=>
w.coreGraph.node(G)).concat(w.isolatedInExtract,w.isolatedOutExtract,w.libraryFunctionsExtract);_.each(C,G=>{switch(G.node.type){case d.NodeType.OP:_.extend(G,f.PARAMS.nodeSize.op);break;case d.NodeType.BRIDGE:_.extend(G,f.PARAMS.nodeSize.bridge);break;case d.NodeType.META:G.expanded?h(G):(_.extend(G,f.PARAMS.nodeSize.meta),G.height=f.PARAMS.nodeSize.meta.height(G.node.cardinality));break;case d.NodeType.SERIES:G.expanded?(_.extend(G,f.PARAMS.nodeSize.series.expanded),h(G)):_.extend(G,G.node.hasNonControlEdges?
f.PARAMS.nodeSize.series.vertical:f.PARAMS.nodeSize.series.horizontal);break;default:throw Error("Unrecognized node type: "+G.node.type);}G.expanded||k(G);n(G)})}function l(w,C){_.extend(w.graph(),{nodesep:C.nodeSep,ranksep:C.rankSep,edgesep:C.edgeSep});let G=[],D=[];_.each(w.nodes(),H=>{w.node(H).node.type===d.NodeType.BRIDGE?G.push(H):D.push(H)});if(!D.length)return{width:0,height:0};dagre.layout(w);let B=Infinity,I=Infinity,N=-Infinity,O=-Infinity;_.each(D,H=>{H=w.node(H);var K=.5*H.width,M=H.x-
K;K=H.x+K;B=M<B?M:B;N=K>N?K:N;K=.5*H.height;M=H.y-K;H=H.y+K;I=M<I?M:I;O=H>O?H:O});_.each(w.edges(),H=>{H=w.edge(H);if(!H.structural){var K=w.node(H.metaedge.v),M=w.node(H.metaedge.w);if(3===H.points.length&&A(H.points)){if(null!=K){var L=K.expanded?K.x:u(K);H.points[0].x=L}null!=M&&(L=M.expanded?M.x:u(M),H.points[2].x=L);H.points=[H.points[0],H.points[1]]}L=H.points[H.points.length-2];null!=M&&(H.points[H.points.length-1]=y(L,M));M=H.points[1];null!=K&&(H.points[0]=y(M,K));_.each(H.points,Q=>{B=Q.x<
B?Q.x:B;N=Q.x>N?Q.x:N;I=Q.y<I?Q.y:I;O=Q.y>O?Q.y:O})}});_.each(w.nodes(),H=>{H=w.node(H);H.x-=B;H.y-=I});_.each(w.edges(),H=>{_.each(w.edge(H).points,K=>{K.x-=B;K.y-=I})});return{width:N-B,height:O-I}}function p(w){let C=f.PARAMS.subscene.meta;_.extend(w,C);_.extend(w.coreBox,l(w.coreGraph,f.PARAMS.graph.meta));var G=w.isolatedInExtract.length?_.max(w.isolatedInExtract,B=>B.width).width:null;w.inExtractBox.width=null!=G?G:0;w.inExtractBox.height=_.reduce(w.isolatedInExtract,(B,I,N)=>{N=0<N?C.extractYOffset:
0;I.x=0;I.y=B+N+I.height/2;return B+N+I.height},0);G=w.isolatedOutExtract.length?_.max(w.isolatedOutExtract,B=>B.width).width:null;w.outExtractBox.width=null!=G?G:0;w.outExtractBox.height=_.reduce(w.isolatedOutExtract,(B,I,N)=>{N=0<N?C.extractYOffset:0;I.x=0;I.y=B+N+I.height/2;return B+N+I.height},0);G=w.libraryFunctionsExtract.length?_.max(w.libraryFunctionsExtract,B=>B.width).width:null;w.libraryFunctionsBox.width=null!=G?G:0;w.libraryFunctionsBox.height=_.reduce(w.libraryFunctionsExtract,(B,I,
N)=>{N=0<N?C.extractYOffset:0;I.x=0;I.y=B+N+I.height/2;return B+N+I.height},0);G=0;0<w.isolatedInExtract.length&&G++;0<w.isolatedOutExtract.length&&G++;0<w.libraryFunctionsExtract.length&&G++;0<w.coreGraph.nodeCount()&&G++;let D=f.PARAMS.subscene.meta.extractXOffset;G=1>=G?0:G*D;w.coreBox.width+=Math.max(f.MIN_AUX_WIDTH,w.inExtractBox.width+w.outExtractBox.width)+G+w.libraryFunctionsBox.width+G;w.coreBox.height=C.labelHeight+Math.max(w.inExtractBox.height,w.coreBox.height,w.libraryFunctionsBox.height,
w.outExtractBox.height);w.width=w.coreBox.width+C.paddingLeft+C.paddingRight;w.height=w.paddingTop+w.coreBox.height+w.paddingBottom}function m(w){let C=w.coreGraph,G=f.PARAMS.subscene.series;_.extend(w,G);_.extend(w.coreBox,l(w.coreGraph,f.PARAMS.graph.series));_.each(C.nodes(),D=>{C.node(D).excluded=!1});w.width=w.coreBox.width+G.paddingLeft+G.paddingRight;w.height=w.coreBox.height+G.paddingTop+G.paddingBottom}function n(w){if(!w.expanded){var C=w.inAnnotations.list,G=w.outAnnotations.list;_.each(C,
K=>q(K));_.each(G,K=>q(K));var D=f.PARAMS.annotations,B=_.reduce(C,(K,M,L)=>{L=0<L?D.yOffset:0;M.dx=-(w.coreBox.width+M.width)/2-D.xOffset;M.dy=K+L+M.height/2;return K+L+M.height},0);_.each(C,K=>{K.dy-=B/2;K.labelOffset=D.labelOffset});var I=_.reduce(G,(K,M,L)=>{L=0<L?D.yOffset:0;M.dx=(w.coreBox.width+M.width)/2+D.xOffset;M.dy=K+L+M.height/2;return K+L+M.height},0);_.each(G,K=>{K.dy-=I/2;K.labelOffset=D.labelOffset});var N=Math.min(w.height/2-w.radius,B/2);N=0>N?0:N;var O=d3.scaleLinear().domain([0,
C.length-1]).range([-N,N]);_.each(C,(K,M)=>{K.points=[{dx:K.dx+K.width/2,dy:K.dy},{dx:-w.coreBox.width/2,dy:1<C.length?O(M):0}]});N=Math.min(w.height/2-w.radius,I/2);N=0>N?0:N;var H=d3.scaleLinear().domain([0,G.length-1]).range([-N,N]);_.each(G,(K,M)=>{K.points=[{dx:w.coreBox.width/2,dy:1<G.length?H(M):0},{dx:K.dx-K.width/2,dy:K.dy}]});w.height=Math.max(w.height,B,I)}}function q(w){switch(w.annotationType){case d.render.AnnotationType.CONSTANT:_.extend(w,f.PARAMS.constant.size);break;case d.render.AnnotationType.SHORTCUT:if(w.node.type===
d.NodeType.OP)_.extend(w,f.PARAMS.shortcutSize.op);else if(w.node.type===d.NodeType.META)_.extend(w,f.PARAMS.shortcutSize.meta);else if(w.node.type===d.NodeType.SERIES)_.extend(w,f.PARAMS.shortcutSize.series);else throw Error("Invalid node type: "+w.node.type);break;case d.render.AnnotationType.SUMMARY:_.extend(w,f.PARAMS.constant.size)}}function u(w){return w.expanded?w.x:w.x-w.width/2+(w.inAnnotations.list.length?w.inboxWidth:0)+w.coreBox.width/2}function x(w,C){return 180*Math.atan((C.y-w.y)/(C.x-
w.x))/Math.PI}function A(w){let C=x(w[0],w[1]);for(let G=1;G<w.length-1;G++){let D=x(w[G],w[G+1]);if(1<Math.abs(D-C))return!1;C=D}return!0}function y(w,C){let G=C.expanded?C.x:u(C),D=C.y;var B=w.x-G;w=w.y-D;let I=C.expanded?C.width:C.coreBox.width,N=C.expanded?C.height:C.coreBox.height;Math.abs(w)*I/2>Math.abs(B)*N/2?(0>w&&(N=-N),C=0===w?0:N/2*B/w,B=N/2):(0>B&&(I=-I),C=I/2,B=0===B?0:I/2*w/B);return{x:G+C,y:D+B}}f.PARAMS={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:d3.scaleLinear().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:120},constant:{size:{width:4,height:4}},series:{maxStackCount:3,parallelStackOffsetRatio:.2,towerStackOffsetRatio:.5},minimap:{size:150}};f.MIN_AUX_WIDTH=
140;f.layoutScene=h;f.computeCXPositionOfNodeShape=u})(d.layout||(d.layout={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/loader.js
var Ui=this&&this.__awaiter||function(b,d,f,h){return new (f||(f=Promise))(function(k,t){function l(n){try{m(h.next(n))}catch(q){t(q)}}function p(n){try{m(h["throw"](n))}catch(q){t(q)}}function m(n){n.done?k(n.value):(new f(function(q){q(n.value)})).then(l,p)}m((h=h.apply(b,d||[])).next())})};
(function(b){(function(d){(function(f){f.fetchAndConstructHierarchicalGraph=function(h,k,t,l=new d.op.TpuCompatibilityProvider,p=d.hierarchy.DefaultHierarchyParams){const m=d.util.getSubtaskTracker(h,20,"Graph"),n=d.util.getSubtaskTracker(h,50,"Namespace hierarchy");return d.parser.fetchAndParseGraphData(k,t,d.util.getSubtaskTracker(h,30,"Data")).then(function(q){if(!q.node)throw 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 d.build(q,d.DefaultBuildParams,m)},()=>{throw 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(q=>Ui(this,void 0,void 0,function*(){d.op.checkOpsForCompatibility(q,l);const u=yield d.hierarchy.build(q,p,n);return{graph:q,graphHierarchy:u}})).catch(q=>{h.reportError(`Graph visualization failed.\n\n${q}`,q);throw q;
})}})(d.loader||(d.loader={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/node.js
(function(b){(function(d){(function(f){(function(h){function k(Z,ba,ea){if(ba.node.isGroupNode){if(ba.expanded)return f.buildGroup(Z,ba,ea,f.Class.Subscene.GROUP);f.selectChild(Z,"g",f.Class.Subscene.GROUP).remove()}return null}function t(Z,ba){let ea=ba.x-ba.width/2+ba.paddingLeft;ba=ba.y-ba.height/2+ba.paddingTop;Z=f.selectChild(Z,"g",f.Class.Subscene.GROUP);f.translate(Z,ea,ba)}function l(Z,ba,ea){Z=f.selectOrCreateChild(Z,"g",f.Class.Node.BUTTON_CONTAINER);f.selectOrCreateChild(Z,"circle",f.Class.Node.BUTTON_CIRCLE);
f.selectOrCreateChild(Z,"path",f.Class.Node.EXPAND_BUTTON).attr("d","M0,-2.2 V2.2 M-2.2,0 H2.2");f.selectOrCreateChild(Z,"path",f.Class.Node.COLLAPSE_BUTTON).attr("d","M-2.2,0 H2.2");Z.on("click",ca=>{d3.event.stopPropagation();ea.fire("node-toggle-expand",{name:ca.node.name})});f.positionButton(Z,ba)}function p(Z,ba,ea,ca){if(ca)Z.attr("pointer-events","none");else{var ka=f.contextmenu.getMenu(ea,m(ba.node,ea));Z.on("dblclick",Y=>{ea.fire("node-toggle-expand",{name:Y.node.name})}).on("mouseover",
Y=>{ea.isNodeExpanded(Y)||ea.fire("node-highlight",{name:Y.node.name})}).on("mouseout",Y=>{ea.isNodeExpanded(Y)||ea.fire("node-unhighlight",{name:Y.node.name})}).on("click",Y=>{d3.event.stopPropagation();ea.fire("node-select",{name:Y.node.name})}).on("contextmenu",(Y,Ea)=>{ea.fire("node-select",{name:Y.node.name});ka.call(Y,Ea)})}}function m(Z,ba){let ea=[{title:()=>d.getIncludeNodeButtonString(Z.include),action:()=>{ba.fire("node-toggle-extract",{name:Z.name})}}];ba.nodeContextMenuItems&&(ea=ea.concat(ba.nodeContextMenuItems));
n(Z)&&ea.push({title:()=>x(Z),action:()=>{ba.fire("node-toggle-seriesgroup",{name:q(Z)})}});return ea}function n(Z){return null!==q(Z)}function q(Z){return Z?Z.type===d.NodeType.SERIES?Z.name:Z.type===d.NodeType.OP?Z.owningSeries:null:null}function u(Z){let ba=null;if(!Z)return null;Z.type===d.NodeType.SERIES?ba=Z:Z.parentNode&&Z.parentNode.type===d.NodeType.SERIES&&(ba=Z.parentNode);return ba}function x(Z){return b.graph.getGroupSeriesNodeButtonString(null!==u(Z)?b.graph.SeriesGroupingType.GROUP:
b.graph.SeriesGroupingType.UNGROUP)}function A(Z,ba,ea){var ca=ba.displayName;let ka=ba.node.type===d.NodeType.META&&!ba.expanded;Z=f.selectOrCreateChild(Z,"text",f.Class.Node.LABEL);let Y=Z.node();Y.parentNode.appendChild(Y);Z.attr("dy",".35em").attr("text-anchor","middle");ka&&(ca.length>ea.maxMetanodeLabelLength&&(ca=ca.substr(0,ea.maxMetanodeLabelLength-2)+"..."),ea=w(ea),Z.attr("font-size",ea(ca.length)+"px"));ca=Z.text(ca);y(ca,ba.node.type,ba);return Z}function y(Z,ba,ea){let ca=Z.node();var ka=
ca.getComputedTextLength();let Y=ca.textContent,Ea=null;switch(ba){case d.NodeType.META:ea&&!ea.expanded&&(Ea=d.layout.PARAMS.nodeSize.meta.maxLabelWidth);break;case d.NodeType.OP:Ea=d.layout.PARAMS.nodeSize.op.maxLabelWidth;break;case -1:Ea=d.layout.PARAMS.annotations.maxLabelWidth}if(!(null===Ea||ka<=Ea)){for(ka=1;ca.getSubStringLength(0,ka)<Ea;)ka++;ba=ca.textContent.substr(0,ka);do ba=ba.substr(0,ba.length-1),ca.textContent=ba+"...",ka=ca.getComputedTextLength();while(ka>Ea&&0<ba.length);return Z.append("title").text(Y)}}
function w(Z){aa||(aa=d3.scaleLinear().domain([Z.maxMetanodeLabelLengthLargeFont,Z.maxMetanodeLabelLength]).range([Z.maxMetanodeLabelLengthFontSize,Z.minMetanodeLabelLengthFontSize]).clamp(!0));return aa}function C(Z,ba,ea,ca){f.selectChild(Z,"text",f.Class.Node.LABEL).transition().attr("x",ba).attr("y",ea+ca)}function G(Z,ba,ea){Z=f.selectOrCreateChild(Z,"g",ea);switch(ba.node.type){case d.NodeType.OP:ba=ba.node;if(_.isNumber(ba.functionInputIndex)||_.isNumber(ba.functionOutputIndex)){f.selectOrCreateChild(Z,
"polygon",f.Class.Node.COLOR_TARGET);break}f.selectOrCreateChild(Z,"ellipse",f.Class.Node.COLOR_TARGET);break;case d.NodeType.SERIES:ea="annotation";ba.coreGraph&&(ea=ba.node.hasNonControlEdges?"vertical":"horizontal");let ca=[f.Class.Node.COLOR_TARGET];ba.isFadedOut&&ca.push("faded-ellipse");f.selectOrCreateChild(Z,"use",ca).attr("xlink:href","#op-series-"+ea+"-stamp");f.selectOrCreateChild(Z,"rect",f.Class.Node.COLOR_TARGET).attr("rx",ba.radius).attr("ry",ba.radius);break;case d.NodeType.BRIDGE:f.selectOrCreateChild(Z,
"rect",f.Class.Node.COLOR_TARGET).attr("rx",ba.radius).attr("ry",ba.radius);break;case d.NodeType.META:f.selectOrCreateChild(Z,"rect",f.Class.Node.COLOR_TARGET).attr("rx",ba.radius).attr("ry",ba.radius);break;default:throw Error("Unrecognized node type: "+ba.node.type);}return Z}function D(Z){switch(Z.node.type){case d.NodeType.OP:return f.Class.OPNODE;case d.NodeType.META:return f.Class.METANODE;case d.NodeType.SERIES:return f.Class.SERIESNODE;case d.NodeType.BRIDGE:return f.Class.BRIDGENODE;case d.NodeType.ELLIPSIS:return f.Class.ELLIPSISNODE}throw Error("Unrecognized node type: "+
Z.node.type);}function B(Z,ba){var ea=f.selectChild(Z,"g",f.Class.Node.SHAPE);let ca=d.layout.computeCXPositionOfNodeShape(ba);switch(ba.node.type){case d.NodeType.OP:{const ka=ba.node;_.isNumber(ka.functionInputIndex)||_.isNumber(ka.functionOutputIndex)?(ea=f.selectChild(ea,"polygon"),f.positionTriangle(ea,ba.x,ba.y,ba.coreBox.width,ba.coreBox.height)):(ea=f.selectChild(ea,"ellipse"),f.positionEllipse(ea,ca,ba.y,ba.coreBox.width,ba.coreBox.height));C(Z,ca,ba.y,ba.labelOffset);break}case d.NodeType.META:ea=
ea.selectAll("rect");ba.expanded?(f.positionRect(ea,ba.x,ba.y,ba.width,ba.height),t(Z,ba),C(Z,ca,ba.y,-ba.height/2+ba.labelHeight/2)):(f.positionRect(ea,ca,ba.y,ba.coreBox.width,ba.coreBox.height),C(Z,ca,ba.y,0));break;case d.NodeType.SERIES:ea=f.selectChild(ea,"use");ba.expanded?(f.positionRect(ea,ba.x,ba.y,ba.width,ba.height),t(Z,ba),C(Z,ca,ba.y,-ba.height/2+ba.labelHeight/2)):(f.positionRect(ea,ca,ba.y,ba.coreBox.width,ba.coreBox.height),C(Z,ca,ba.y,ba.labelOffset));break;case d.NodeType.BRIDGE:Z=
f.selectChild(ea,"rect");f.positionRect(Z,ba.x,ba.y,ba.width,ba.height);break;default:throw Error("Unrecognized node type: "+ba.node.type);}}function I(Z,ba,ea){let ca=b.graph.util.escapeQuerySelector(Z);if(!ea)return`url(#${ca})`;ea=d3.select(ea);let ka=ea.select("defs#_graph-gradients");ka.empty()&&(ka=ea.append("defs").attr("id","_graph-gradients"));let Y=ka.select("linearGradient#"+ca);if(Y.empty()){Y=ka.append("linearGradient").attr("id",Z);Y.selectAll("*").remove();let Ea=0;_.each(ba,va=>{let xa=
va.color;Y.append("stop").attr("offset",Ea).attr("stop-color",xa);Y.append("stop").attr("offset",Ea+va.proportion).attr("stop-color",xa);Ea+=va.proportion})}return`url(#${ca})`}function N(Z,ba,ea,ca,ka){let Y=d.render.MetanodeColors;switch(ba){case la.STRUCTURE:return ea.node.type===d.NodeType.META?(ba=ea.node.templateId,null===ba?Y.UNKNOWN:Y.STRUCTURE_PALETTE(Z(ba),ca)):ea.node.type===d.NodeType.SERIES?ca?Y.EXPANDED_COLOR:"white":ea.node.type===d.NodeType.BRIDGE?ea.structural?"#f0e":ea.node.inbound?
"#0ef":"#fe0":_.isNumber(ea.node.functionInputIndex)?"#795548":_.isNumber(ea.node.functionOutputIndex)?"#009688":"white";case la.DEVICE:return null==ea.deviceColors?Y.UNKNOWN:ca?Y.EXPANDED_COLOR:I("device-"+ea.node.name,ea.deviceColors,ka);case la.XLA_CLUSTER:return null==ea.xlaClusterColors?Y.UNKNOWN:ca?Y.EXPANDED_COLOR:I("xla-"+ea.node.name,ea.xlaClusterColors,ka);case la.COMPUTE_TIME:return ca?Y.EXPANDED_COLOR:ea.computeTimeColor||Y.UNKNOWN;case la.MEMORY:return ca?Y.EXPANDED_COLOR:ea.memoryColor||
Y.UNKNOWN;case la.OP_COMPATIBILITY:return null==ea.compatibilityColors?Y.UNKNOWN:ca?Y.EXPANDED_COLOR:I("op-compat-"+ea.node.name,ea.compatibilityColors,ka);default:throw Error("Unknown case to color nodes by");}}function O(Z,ba,ea,ca){ca=ca||f.Class.Node.SHAPE;let ka=ea.isNodeSelected(ba.node.name),Y=ba.isInExtract||ba.isOutExtract||ba.isLibraryFunction,Ea=ba.expanded&&ca!==f.Class.Annotation.NODE,va=ba.isFadedOut;Z.classed("highlighted",ea.isNodeHighlighted(ba.node.name));Z.classed("selected",ka);
Z.classed("extract",Y);Z.classed("expanded",Ea);Z.classed("faded",va);Z=Z.select("."+ca+" ."+f.Class.Node.COLOR_TARGET);ba=N(ea.templateIndex,la[ea.colorBy.toUpperCase()],ba,Ea,ea.getGraphSvgRoot());Z.style("fill",ba);Z.style("stroke",ka?null:H(ba))}function H(Z){return"url"===Z.substring(0,3)?d.render.MetanodeColors.GRADIENT_OUTLINE:d3.rgb(Z).darker().toString()}function K(Z,ba){let ea=[];Z=ba.getNodeByName(Z);if(Z instanceof b.graph.OpNodeImpl)return[Z].concat(Z.inEmbeddings);Z=Z.metagraph.nodes();
_.each(Z,function(ca){ea=ea.concat(K(ca,ba))});return ea}function M(Z,ba,ea,ca){if(ca[ea.name])return ca;ca[ea.name]=!0;var ka=ea.inputs;let Y=X(ba,ea);d3.select(Z).select(`.node[data-name="${Y.name}"]`).classed("input-highlight",!0);let Ea={};_.each(ka,function(Aa){Aa=ba.getNodeByName(Aa.name);if(void 0!==Aa){Aa instanceof d.MetanodeImpl&&(Aa=b.graph.getStrictName(Aa.name),Aa=ba.getNodeByName(Aa));var Fa=X(ba,Aa),ya=Ea[Fa.name];ya?ya.opNodes.push(Aa):Ea[Fa.name]={visibleParent:Fa,opNodes:[Aa]}}});
let va={},xa=[Y];va[Y.name]={traced:!1,index:0,connectionEndpoints:[]};ea=Y;for(ka=1;ea.name!==b.graph.ROOT_NAME;ka++)ea=ea.parentNode,va[ea.name]={traced:!1,index:ka,connectionEndpoints:[]},xa[ka]=ea;_.forOwn(Ea,function(Aa){let Fa=Aa.visibleParent;_.each(Aa.opNodes,function(ya){ca=M(Z,ba,ya,ca)});Fa.name!==Y.name&&L(Z,Fa,va,xa)});return ca}function L(Z,ba,ea,ca){var ka=ba,Y=ba;for(ba=[];!ea[ka.name];)Y.name!==ka.name&&ba.push([Y,ka]),Y=ka,ka=ka.parentNode;ea=ea[ka.name].index;let Ea=ca[Math.max(ea-
1,0)].name;Y=ka=Y.name;const va=d3.select(Z);va.selectAll(`[data-edge="${Y}--${Ea}"]`).classed("input-edge-highlight",!0);_.each(ba,function(xa){va.selectAll(`[data-edge="${xa[0].name}--${Ea}`+`~~${xa[1].name}~~OUT"]`).classed("input-edge-highlight",!0)});for(Z=1;Z<ea;Z++)va.selectAll(`[data-edge="${ka}~~${ca[Z].name}`+`~~IN--${ca[Z-1].name}"]`).classed("input-edge-highlight",!0)}function Q(Z,ba){let ea={};_.each(ba,function(ca){ca=Z.getNodeByName(ca);ca=X(Z,ca);ea[ca.name]=ca});return ea}function T(Z,
ba){_.forOwn(ba,function(ea){for(;ea.name!==b.graph.ROOT_NAME;){const ca=d3.select(Z).select(`.node[data-name="${ea.name}"]`);!ca.nodes().length||ca.classed("input-highlight")||ca.classed("selected")||ca.classed("op")||ca.classed("input-parent",!0);ea=ea.parentNode}})}function X(Z,ba){let ea=!1,ca=ba;for(;!ea;)if(ba=ca,ca=ba.parentNode,void 0===ca)ea=!0;else{let ka=Z.getRenderNodeByName(ca.name);ka&&(ka.expanded||ca instanceof d.OpNodeImpl)&&(ea=!0)}return ba}h.buildGroup=function(Z,ba,ea){Z=f.selectOrCreateChild(Z,
"g",f.Class.Node.CONTAINER).selectAll(function(){return this.childNodes}).data(ba,ca=>ca.node.name+":"+ca.node.type);Z.enter().append("g").attr("data-name",ca=>ca.node.name).each(function(ca){let ka=d3.select(this);ea.addNodeGroup(ca.node.name,ka)}).merge(Z).attr("class",ca=>f.Class.Node.GROUP+" "+D(ca)).each(function(ca){let ka=d3.select(this);var Y=f.selectOrCreateChild(ka,"g",f.Class.Annotation.INBOX);f.annotation.buildGroup(Y,ca.inAnnotations,ca,ea);Y=f.selectOrCreateChild(ka,"g",f.Class.Annotation.OUTBOX);
f.annotation.buildGroup(Y,ca.outAnnotations,ca,ea);Y=G(ka,ca,f.Class.Node.SHAPE);ca.node.isGroupNode&&l(Y,ca,ea);p(Y,ca,ea);k(ka,ca,ea);Y=A(ka,ca,ea);p(Y,ca,ea,ca.node.type===d.NodeType.META);O(ka,ca,ea);B(ka,ca)});Z.exit().each(function(ca){ea.removeNodeGroup(ca.node.name);let ka=d3.select(this);0<ca.inAnnotations.list.length&&ka.select("."+f.Class.Annotation.INBOX).selectAll("."+f.Class.Annotation.GROUP).each(Y=>{ea.removeAnnotationGroup(Y,ca)});0<ca.outAnnotations.list.length&&ka.select("."+f.Class.Annotation.OUTBOX).selectAll("."+
f.Class.Annotation.GROUP).each(Y=>{ea.removeAnnotationGroup(Y,ca)})}).remove();return Z};h.getContextMenu=m;h.canBeInSeries=n;h.getSeriesName=q;h.getGroupSettingLabel=x;h.enforceLabelWidth=y;let aa=null;h.buildShape=G;h.nodeClass=D;let la;(function(Z){Z[Z.STRUCTURE=0]="STRUCTURE";Z[Z.DEVICE=1]="DEVICE";Z[Z.XLA_CLUSTER=2]="XLA_CLUSTER";Z[Z.COMPUTE_TIME=3]="COMPUTE_TIME";Z[Z.MEMORY=4]="MEMORY";Z[Z.OP_COMPATIBILITY=5]="OP_COMPATIBILITY"})(la=h.ColorBy||(h.ColorBy={}));h.removeGradientDefinitions=function(Z){d3.select(Z).select("defs#_graph-gradients").remove()};
h.getFillForNode=N;h.stylize=O;h.getStrokeForFill=H;h.updateInputTrace=function(Z,ba,ea,ca){const ka=d3.select(Z);ka.selectAll(".input-highlight").classed("input-highlight",!1);ka.selectAll(".non-input").classed("non-input",!1);ka.selectAll(".input-parent").classed("input-parent",!1);ka.selectAll(".input-child").classed("input-child",!1);ka.selectAll(".input-edge-highlight").classed("input-edge-highlight",!1);ka.selectAll(".non-input-edge-highlight").classed("non-input-edge-highlight",!1);ka.selectAll(".input-highlight-selected").classed("input-highlight-selected",
!1);if(ba&&ca&&ea){ea=K(ea,ba);var Y={};_.each(ea,function(Ea){Y=M(Z,ba,Ea,Y)});ea=Object.keys(Y);ea=Q(ba,ea);T(Z,ea);ka.selectAll("g.node:not(.selected):not(.input-highlight):not(.input-parent):not(.input-children)").classed("non-input",!0).each(function(Ea){ka.selectAll(`[data-name="${Ea.node.name}"]`).classed("non-input",!0)});ka.selectAll("g.edge:not(.input-edge-highlight)").classed("non-input-edge-highlight",!0)}};h.getVisibleParent=X})(f.node||(f.node={}))})(d.scene||(d.scene={}))})(b.graph||
(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/op.js
(function(b){(function(d){(function(f){class h{isNotTpuOp(k){return-1!=k.toLowerCase().search("cpu:")||-1!=k.toLowerCase().search("gpu:")?!0:-1==k.toLowerCase().search("tpu")}opValid(k){return 0==k.name.search(d.FUNCTION_LIBRARY_NODE_PREFIX)||!k.op||k.device&&this.isNotTpuOp(k.device)||k.device&&-1!=k.device.search("TPU_SYSTEM")?!0:_.includes(h.WHITELIST,k.op)}}h.WHITELIST="Abs Acos Acosh Add AddN AdjustContrastv2 AdjustHue AdjustSaturation All Angle Any ApproximateEqual ArgMax ArgMin Asin Asinh Assert AssignAddVariableOp AssignSubVariableOp AssignVariableOp Atan Atan2 Atanh AvgPool AvgPool3D AvgPool3DGrad AvgPoolGrad BatchMatMul BatchToSpace BatchToSpaceND BiasAdd BiasAddGrad BiasAddV1 Bitcast BitwiseAnd BitwiseOr BitwiseXor BroadcastArgs BroadcastGradientArgs Bucketize Cast Ceil CheckNumerics Cholesky ClipByValue Complex ComplexAbs Concat ConcatOffset ConcatV2 Conj ConjugateTranspose Const ControlTrigger Conv2D Conv2DBackpropFilter Conv2DBackpropInput Conv3D Conv3DBackpropFilterV2 Conv3DBackpropInputV2 Cos Cosh Cross CrossReplicaSum Cumprod Cumsum DepthToSpace DepthwiseConv2dNative DepthwiseConv2dNativeBackpropFilter DepthwiseConv2dNativeBackpropInput Diag DiagPart Digamma Div DynamicStitch Elu EluGrad Empty Equal Erf Erfc Exp ExpandDims Expm1 ExtractImagePatches FFT FFT2D FFT3D FakeQuantWithMinMaxArgs FakeQuantWithMinMaxArgsGradient FakeQuantWithMinMaxVars FakeQuantWithMinMaxVarsGradient Fill Floor FloorDiv FloorMod FusedBatchNorm FusedBatchNormGrad FusedBatchNormGradV2 FusedBatchNormV2 Gather GatherNd GatherV2 GetItem Greater GreaterEqual HSVToRGB IFFT IFFT2D IFFT3D IRFFT IRFFT2D IRFFT3D Identity IdentityN If Imag InfeedDequeue InfeedDequeueTuple InplaceAdd InplaceUpdate Inv Invert InvertPermutation IsFinite IsInf IsNan L2Loss LRN LRNGrad LeftShift Less LessEqual Lgamma LinSpace ListDiff Log Log1p LogSoftmax LogicalAnd LogicalNot LogicalOr MatMul MatrixBandPart MatrixDiag MatrixDiagPart MatrixSetDiag MatrixTriangularSolve Max MaxPool MaxPool3D MaxPool3DGrad MaxPool3DGradGrad MaxPoolGrad MaxPoolGradGrad MaxPoolGradGradV2 MaxPoolGradV2 MaxPoolV2 Maximum Mean Min Minimum MirrorPad Mod Mul Multinomial Neg NoOp NonMaxSuppressionV4 NotEqual OneHot OnesLike OutfeedEnqueue OutfeedEnqueueTuple Pack Pad PadV2 ParallelDynamicStitch PlaceholderWithDefault Pow PreventGradient Prod Qr QuantizeAndDequantizeV2 QuantizeAndDequantizeV3 RFFT RFFT2D RFFT3D RGBToHSV RandomShuffle RandomStandardNormal RandomUniform RandomUniformInt Range Rank ReadVariableOp Real RealDiv Reciprocal ReciprocalGrad RecvTPUEmbeddingActivations Relu Relu6 Relu6Grad ReluGrad Reshape ResizeBilinear ResizeBilinearGrad ResourceApplyAdaMax ResourceApplyAdadelta ResourceApplyAdagrad ResourceApplyAdagradDA ResourceApplyAdam ResourceApplyAddSign ResourceApplyCenteredRMSProp ResourceApplyFtrl ResourceApplyFtrlV2 ResourceApplyGradientDescent ResourceApplyMomentum ResourceApplyPowerSign ResourceApplyProximalAdagrad ResourceApplyProximalGradientDescent ResourceApplyRMSProp ResourceGather ResourceScatterAdd ResourceScatterDiv ResourceScatterMax ResourceScatterMin ResourceScatterMul ResourceScatterNdAdd ResourceScatterNdUpdate ResourceScatterSub ResourceScatterUpdate ResourceStridedSliceAssign Reverse ReverseSequence ReverseV2 RightShift Rint Round Rsqrt RsqrtGrad ScatterNd Select Selu SeluGrad SendTPUEmbeddingGradients 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 StatelessIf StatelessRandomNormal StatelessRandomUniform StatelessTruncatedNormal StatelessWhile StopGradient StridedSlice StridedSliceGrad Sub Sum SymbolicGradient TPUEmbeddingActivations Tan Tanh TanhGrad TensorArrayCloseV3 TensorArrayConcatV3 TensorArrayGatherV3 TensorArrayGradV3 TensorArrayReadV3 TensorArrayScatterV3 TensorArraySizeV3 TensorArraySplitV3 TensorArrayV3 TensorArrayWriteV3 Tile TopKV2 Transpose TruncateDiv TruncateMod TruncatedNormal Unpack UnsortedSegmentMax UnsortedSegmentMin UnsortedSegmentProd UnsortedSegmentSum VarIsInitializedOp VariableShape While XlaDynamicUpdateSlice XlaHostCompute XlaIf XlaRecv XlaReduceWindow XlaSend XlaSort XlaWhile ZerosLike Enter Exit LoopCond Merge NextIteration Switch _Arg _ParallelConcatUpdate _Retval _TPUCompile _TPUExecute 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".split(" ");
f.TpuCompatibilityProvider=h;f.checkOpsForCompatibility=function(k,t){if(null===t)throw Error("Compatibility provider required, but got: "+t);_.each(k.nodes,l=>{l.compatible=t.opValid(l);_.each(l.inEmbeddings,p=>{p.compatible=t.opValid(p)});_.each(l.outEmbeddings,p=>{p.compatible=t.opValid(p)})})}})(d.op||(d.op={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/parser.js
(function(b){(function(d){(function(f){function h(u){if("true"===u)return!0;if("false"===u)return!1;if('"'===u[0])return u.substring(1,u.length-1);let x=parseFloat(u);return isNaN(x)?u:x}function k(u){return new Promise((x,A)=>{fetch(u).then(y=>{y.ok?y.arrayBuffer().then(x,A):y.text().then(A,A)})})}function t(u,x,A=1E6,y="\n"){return new Promise(function(w,C){function G(D,B,I){var N=I>=u.byteLength;B=B.split(y);B[0]=D+B[0];const O=N?"":B.pop();for(let H of B)try{x(H)}catch(K){C(K);return}N?w(!0):
(D=new Blob([u.slice(I,I+A)]),N=new FileReader,N.onload=function(H){G(O,H.target.result,I+A)},N.readAsText(D))}G("","",0)})}function l(u){return m(u,n)}function p(u){return m(u,q).then(x=>x.step_stats)}function m(u,x){function A(B){let I=B.indexOf(":"),N=B.substring(0,I).trim();B=h(B.substring(I+2).trim());return{name:N,value:B}}function y(B,I,N,O){let H=B[I];null==H?B[I]=O.join(".")in x?[N]:N:Array.isArray(H)?H.push(N):B[I]=[H,N]}let w={},C=[],G=[],D=w;return t(u,function(B){if(B)switch(B=B.trim(),
B[B.length-1]){case "{":B=B.substring(0,B.length-2).trim();let I={};C.push(D);G.push(B);y(D,B,I,G);D=I;break;case "}":D=C.pop();G.pop();break;default:B=A(B),y(D,B.name,B.value,G.concat(B.name))}}).then(function(){return w})}f.fetchPbTxt=k;f.fetchAndParseMetadata=function(u,x){return b.graph.util.runTask(()=>null==u?Promise.resolve(null):k(u),x).then(A=>b.graph.util.runAsyncPromiseTask("Parsing metadata.pbtxt",60,()=>null!=A?p(A):Promise.resolve(null),x))};f.fetchAndParseGraphData=function(u,x,A){return b.graph.util.runAsyncPromiseTask("Reading graph pbtxt",
40,()=>x?new Promise(function(y,w){let C=new FileReader;C.onload=()=>y(C.result);C.onerror=()=>w(C.error);C.readAsArrayBuffer(x)}):k(u),A).then(y=>b.graph.util.runAsyncPromiseTask("Parsing graph.pbtxt",60,()=>l(y),A))};f.streamParse=t;const n={"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},q={"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};f.parseGraphPbTxt=l;f.parseStatsPbTxt=p})(d.parser||(d.parser={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/proto.js

//# sourceURL=build://tf-graph-common/render.js
(function(b){(function(d){(function(f){function h(L,Q,T,X,aa){Q=new I(Q,T,X,aa,!0);L.inAnnotations.push(Q)}function k(L,Q,T,X,aa){Q=new I(Q,T,X,aa,!1);L.outAnnotations.push(Q)}function t(L,Q){_.each(L.nodes(),T=>{T=L.node(T);T.expanded=1<Q;if(0<Q)switch(T.node.type){case d.NodeType.META:case d.NodeType.SERIES:l(T,Q-1)}})}function l(L,Q){L.coreGraph&&t(L.coreGraph,Q)}function p(L,Q,T){let X=L.node(Q),aa=L.node(T),la=L.edge(Q,T);if(X.node.include!==d.InclusionType.INCLUDE&&aa.node.include!==d.InclusionType.INCLUDE||
X.node.include===d.InclusionType.EXCLUDE||aa.node.include===d.InclusionType.EXCLUDE)k(X,aa.node,aa,la,N.SHORTCUT),h(aa,X.node,X,la,N.SHORTCUT),L.removeEdge(Q,T)}function m(L,Q,T){let X=L.coreGraph,aa=X.node(Q);aa.isOutExtract=!0;_.each(X.predecessors(Q),la=>{p(X,la,Q)});(G.detachAllEdgesForHighDegree||T)&&_.each(X.successors(Q),la=>{p(X,Q,la)});0===X.neighbors(Q).length&&(aa.node.include=d.InclusionType.EXCLUDE,L.isolatedOutExtract.push(aa),X.removeNode(Q))}function n(L,Q,T){let X=L.coreGraph,aa=
X.node(Q);aa.isInExtract=!0;_.each(X.successors(Q),la=>{p(X,Q,la)});(G.detachAllEdgesForHighDegree||T)&&_.each(X.predecessors(Q),la=>{p(X,la,Q)});0===X.neighbors(Q).length&&(aa.node.include=d.InclusionType.EXCLUDE,L.isolatedInExtract.push(aa),X.removeNode(Q))}function q(L,Q){if(L.type===d.NodeType.OP)for(var T=0;T<Q.length;T++){if(L.op===Q[T])return!0}else if(L.type===d.NodeType.META&&(L=L.getRootOp()))for(T=0;T<Q.length;T++)if(L.op===Q[T])return!0;return!1}function u(L){let Q=L.coreGraph;_.each(Q.nodes(),
T=>{Q.node(T).node.include!==d.InclusionType.EXCLUDE||T.startsWith(b.graph.FUNCTION_LIBRARY_NODE_PREFIX)||(L.coreGraph.outEdges(T).length>L.coreGraph.inEdges(T).length?m(L,T,!0):n(L,T,!0))})}function x(L){let Q=L.coreGraph;_.each(Q.nodes(),T=>{let X=Q.node(T);X.node.include===d.InclusionType.UNSPECIFIED&&q(X.node,G.outExtractTypes)&&m(L,T)})}function A(L){let Q=L.coreGraph;_.each(Q.nodes(),T=>{let X=Q.node(T);X.node.include===d.InclusionType.UNSPECIFIED&&q(X.node,G.inExtractTypes)&&n(L,T)})}function y(L){let Q=
L.coreGraph,T={},X={},aa=0;_.each(Q.nodes(),ka=>{if(Q.node(ka).node.include===d.InclusionType.UNSPECIFIED){var Y=_.reduce(Q.predecessors(ka),(va,xa)=>{xa=Q.edge(xa,ka).metaedge;return va+(xa.numRegularEdges?1:0)},0);0===Y&&0<Q.predecessors(ka).length&&(Y=Q.predecessors(ka).length);var Ea=_.reduce(Q.successors(ka),(va,xa)=>{xa=Q.edge(ka,xa).metaedge;return va+(xa.numRegularEdges?1:0)},0);0===Ea&&0<Q.successors(ka).length&&(Ea=Q.successors(ka).length);T[ka]=Y;X[ka]=Ea;aa++}});if(!(aa<G.minNodeCountForExtraction)){var la=
G.minDegreeForExtraction-1,Z=Math.round(.75*aa),ba=Math.round(.25*aa),ea=Object.keys(T).sort((ka,Y)=>T[ka]-T[Y]),ca=T[ea[Z]];ca=ca+ca-T[ea[ba]];ca=Math.max(ca,la);for(let ka=aa-1;T[ea[ka]]>ca;ka--)n(L,ea[ka]);ea=Object.keys(X).sort((ka,Y)=>X[ka]-X[Y]);Z=X[ea[Z]];ba=Z+4*(Z-X[ea[ba]]);ba=Math.max(ba,la);for(la=aa-1;X[ea[la]]>ba;la--)(Z=Q.node(ea[la]))&&!Z.isInExtract&&m(L,ea[la])}}function w(L){let Q=L.coreGraph,T={};_.each(Q.edges(),X=>{Q.edge(X).metaedge.numRegularEdges||((T[X.v]=T[X.v]||[]).push(X),
(T[X.w]=T[X.w]||[]).push(X))});_.each(T,X=>{X.length>G.maxControlDegree&&_.each(X,aa=>p(Q,aa.v,aa.w))})}function C(L){u(L);G.outExtractTypes&&x(L);G.inExtractTypes&&A(L);y(L);G.maxControlDegree&&w(L);let Q=L.coreGraph;_.each(Q.nodes(),T=>{let X=Q.node(T);var aa=Q.neighbors(T).length;if(X.node.include===d.InclusionType.UNSPECIFIED&&0===aa){aa=0<X.outAnnotations.list.length;let la=0<X.inAnnotations.list.length;X.isInExtract?(L.isolatedInExtract.push(X),X.node.include=d.InclusionType.EXCLUDE,Q.removeNode(T)):
X.isOutExtract?(L.isolatedOutExtract.push(X),X.node.include=d.InclusionType.EXCLUDE,Q.removeNode(T)):G.extractIsolatedNodesWithAnnotationsOnOneSide&&(aa&&!la?(X.isInExtract=!0,L.isolatedInExtract.push(X),X.node.include=d.InclusionType.EXCLUDE,Q.removeNode(T)):la&&!aa&&(X.isOutExtract=!0,L.isolatedOutExtract.push(X),X.node.include=d.InclusionType.EXCLUDE,Q.removeNode(T)))}})}f.OpNodeColors={DEFAULT_FILL:"#ffffff",DEFAULT_STROKE:"#b2b2b2",COMPATIBLE:"#0f9d58",INCOMPATIBLE:"#db4437"};f.MetanodeColors=
{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(L,Q){var T=f.MetanodeColors.HUES;L=T[L%T.length];T=Math.sin(L*Math.PI/360);return d3.hsl(L,.01*(Q?30:90-60*T),.01*(Q?95:80)).toString()},DEVICE_PALETTE(L){return f.MetanodeColors.STRUCTURE_PALETTE(L)},XLA_CLUSTER_PALETTE(L){return f.MetanodeColors.STRUCTURE_PALETTE(L)},UNKNOWN:"#eee",GRADIENT_OUTLINE:"#888"};f.SeriesNodeColors={DEFAULT_FILL:"white",
DEFAULT_STROKE:"#b2b2b2"};const G={enableExtraction:!0,minNodeCountForExtraction:15,minDegreeForExtraction:5,maxControlDegree:4,maxBridgePathDegree:4,outExtractTypes:["NoOp"],inExtractTypes:[],detachAllEdgesForHighDegree:!0,extractIsolatedNodesWithAnnotationsOnOneSide:!0,enableBridgegraph:!0,minMaxColors:["#fff5f0","#fb6a4a"],maxAnnotations:5},D=new RegExp("^(?:"+b.graph.FUNCTION_LIBRARY_NODE_PREFIX+")?(\\w+)_[a-z0-9]{8}(?:_\\d+)?$");class B{constructor(L,Q){this.hierarchy=L;this.displayingStats=
Q;this.index={};this.renderedOpNames=[];this.computeScales();this.hasSubhierarchy={};this.root=new M(L.root,L.graphOptions);this.index[L.root.name]=this.root;this.renderedOpNames.push(L.root.name);this.buildSubhierarchy(L.root.name);this.root.expanded=!0;this.traceInputs=!1}computeScales(){this.deviceColorMap=d3.scaleOrdinal().domain(this.hierarchy.devices).range(_.map(d3.range(this.hierarchy.devices.length),f.MetanodeColors.DEVICE_PALETTE));this.xlaClusterColorMap=d3.scaleOrdinal().domain(this.hierarchy.xlaClusters).range(_.map(d3.range(this.hierarchy.xlaClusters.length),
f.MetanodeColors.XLA_CLUSTER_PALETTE));let L=this.hierarchy.root.metagraph;var Q=d3.max(L.nodes(),T=>{T=L.node(T);if(null!=T.stats)return T.stats.totalBytes});this.memoryUsageScale=d3.scaleLinear().domain([0,Q]).range(G.minMaxColors);Q=d3.max(L.nodes(),T=>{T=L.node(T);if(null!=T.stats)return T.stats.getTotalMicros()});this.computeTimeScale=d3.scaleLinear().domain([0,Q]).range(G.minMaxColors);this.edgeWidthSizedBasedScale=this.hierarchy.hasShapeInfo?d.scene.edge.EDGE_WIDTH_SIZE_BASED_SCALE:d3.scaleLinear().domain([1,
this.hierarchy.maxMetaEdgeSize]).range([d.scene.edge.MIN_EDGE_WIDTH,d.scene.edge.MAX_EDGE_WIDTH])}getRenderNodeByName(L){return this.index[L]}getNodeByName(L){return this.hierarchy.node(L)}colorHistogram(L,Q){if(0<Object.keys(L).length){const T=_.sum(Object.keys(L).map(X=>L[X]));return Object.keys(L).map(X=>({color:Q(X),proportion:L[X]/T}))}console.info("no pairs found!");return null}getOrCreateRenderNodeByName(L){if(!L)return null;if(L in this.index)return this.index[L];var Q=this.hierarchy.node(L);
if(!Q)return null;let T=Q.isGroupNode?new M(Q,this.hierarchy.graphOptions):new H(Q);this.index[L]=T;this.renderedOpNames.push(L);Q.stats&&(T.memoryColor=this.memoryUsageScale(Q.stats.totalBytes),T.computeTimeColor=this.computeTimeScale(Q.stats.getTotalMicros()));T.isFadedOut=this.displayingStats&&!b.graph.util.hasDisplayableNodeStats(Q.stats);var X=null,aa=null,la=null;if(Q.isGroupNode){X=Q.deviceHistogram;aa=Q.xlaClusterHistogram;var Z=Q.compatibilityHistogram.compatible;Q=Q.compatibilityHistogram.incompatible;
if(0!=Z||0!=Q)la=Z/(Z+Q)}else(Z=T.node.device)&&(X={[Z]:1}),(Z=T.node.xlaCluster)&&(aa={[Z]:1}),T.node.type===d.NodeType.OP&&(la=T.node.compatible?1:0);X&&(T.deviceColors=this.colorHistogram(X,this.deviceColorMap));aa&&(T.xlaClusterColors=this.colorHistogram(aa,this.xlaClusterColorMap));null!=la&&(T.compatibilityColors=[{color:b.graph.render.OpNodeColors.COMPATIBLE,proportion:la},{color:b.graph.render.OpNodeColors.INCOMPATIBLE,proportion:1-la}]);return this.index[L]}getNearestVisibleAncestor(L){var Q=
d.getHierarchicalPath(L);let T=0,X=null;for(;T<Q.length&&(L=Q[T],X=this.getRenderNodeByName(L),X.expanded);T++);return T==Q.length-2&&(Q=Q[T+1],X.inAnnotations.nodeNames[Q]||X.outAnnotations.nodeNames[Q])?Q:L}setDepth(L){l(this.root,+L)}isNodeAuxiliary(L){let Q=this.getRenderNodeByName(L.node.parentNode.name),T=_.find(Q.isolatedInExtract,X=>X.node.name===L.node.name);if(T)return!0;T=_.find(Q.isolatedOutExtract,X=>X.node.name===L.node.name);return!!T}getNamesOfRenderedOps(){return this.renderedOpNames}cloneAndAddFunctionOpNode(L,
Q,T,X){var aa=T.name.replace(Q,X);let la=L.metagraph.node(aa);if(la)return la;la=new d.OpNodeImpl({name:aa,input:[],device:T.device,op:T.op,attr:_.cloneDeep(T.attr)});la.cardinality=T.cardinality;la.include=T.include;la.outputShapes=_.cloneDeep(T.outputShapes);la.xlaCluster=T.xlaCluster;la.functionInputIndex=T.functionInputIndex;la.functionOutputIndex=T.functionOutputIndex;la.inputs=T.inputs.map(Z=>{const ba=_.clone(Z);ba.name=Z.name.replace(Q,X);return ba});la.parentNode=L;L.metagraph.setNode(la.name,
la);this.hierarchy.setNode(la.name,la);aa=Z=>this.cloneAndAddFunctionOpNode(L,Q,Z,X);la.inEmbeddings=T.inEmbeddings.map(aa);la.outEmbeddings=T.outEmbeddings.map(aa);return la}cloneFunctionLibraryMetanode(L,Q,T,X,aa){const la={};L=this.cloneFunctionLibraryMetanodeHelper(L,Q,T,X,aa,la);_.isEmpty(la)||this.patchEdgesFromFunctionOutputs(Q,la);return L}cloneFunctionLibraryMetanodeHelper(L,Q,T,X,aa,la){const Z=b.graph.createMetanode(T.name.replace(X,aa));Z.depth=T.depth;Z.cardinality=T.cardinality;Z.templateId=
T.templateId;Z.opHistogram=_.clone(T.opHistogram);Z.deviceHistogram=_.clone(T.deviceHistogram);Z.xlaClusterHistogram=_.clone(T.xlaClusterHistogram);Z.hasNonControlEdges=T.hasNonControlEdges;Z.include=T.include;Z.nodeAttributes=_.clone(T.nodeAttributes);Z.associatedFunction=T.associatedFunction;_.each(T.metagraph.nodes(),ba=>{ba=T.metagraph.node(ba);switch(ba.type){case d.NodeType.META:ba=this.cloneFunctionLibraryMetanodeHelper(L,Q,ba,X,aa,la);ba.parentNode=Z;Z.metagraph.setNode(ba.name,ba);this.hierarchy.setNode(ba.name,
ba);break;case d.NodeType.OP:ba=this.cloneAndAddFunctionOpNode(Z,X,ba,aa);_.isNumber(ba.functionInputIndex)&&this.patchEdgesIntoFunctionInputs(Q,ba);_.isNumber(ba.functionOutputIndex)&&(la[ba.functionOutputIndex]=ba);break;default:console.warn(ba.name+" is oddly neither a metanode nor an opnode.")}});this.cloneLibraryMetanodeEdges(T,Z,X,aa);return Z}cloneLibraryMetanodeEdges(L,Q,T,X){_.each(L.metagraph.edges(),aa=>{aa=L.metagraph.edge(aa);const la=aa.v.replace(T,X),Z=aa.w.replace(T,X),ba=new d.MetaedgeImpl(la,
Z);ba.inbound=aa.inbound;ba.numRegularEdges=aa.numRegularEdges;ba.numControlEdges=aa.numControlEdges;ba.numRefEdges=aa.numRefEdges;ba.totalSize=aa.totalSize;aa.baseEdgeList&&(ba.baseEdgeList=aa.baseEdgeList.map(ea=>{const ca=_.clone(ea);ca.v=ea.v.replace(T,X);ca.w=ea.w.replace(T,X);return ca}));Q.metagraph.node(Z)?Q.metagraph.setEdge(la,Z,ba):Q.metagraph.setEdge(Z,la,ba)})}patchEdgesIntoFunctionInputs(L,Q){let T=Math.min(Q.functionInputIndex,L.inputs.length-1);for(var X=_.clone(L.inputs[T]);X.isControlDependency;)T++,
X=L.inputs[T];Q.inputs.push(X);X=this.hierarchy.getPredecessors(L.name);let aa,la=0;_.each(X.regular,Z=>{la+=Z.numRegularEdges;if(la>T)return aa=Z,!1});_.each(aa.baseEdgeList,Z=>{Z.w===L.name&&(Z.w=Q.name);Z.v===L.name&&(Z.v=Q.name)})}patchEdgesFromFunctionOutputs(L,Q){const T=this.hierarchy.getSuccessors(L.name);_.each(T.regular,X=>{_.each(X.baseEdgeList,aa=>{const la=this.hierarchy.node(aa.w);_.each(la.inputs,Z=>{Z.name===L.name&&(Z.name=Q[Z.outputTensorKey].name,Z.outputTensorKey=aa.outputTensorKey)})});
_.each(X.baseEdgeList,aa=>{aa.v=Q[aa.outputTensorKey].name;aa.outputTensorKey="0"})})}buildSubhierarchy(L){if(!(L in this.hasSubhierarchy)){this.hasSubhierarchy[L]=!0;var Q=this.index[L];if(Q.node.type===d.NodeType.META||Q.node.type===d.NodeType.SERIES){var T=Q.node.metagraph,X=Q.coreGraph,aa=[],la=[];_.isEmpty(this.hierarchy.libraryFunctions)||(_.each(T.nodes(),xa=>{const Aa=T.node(xa),Fa=this.hierarchy.libraryFunctions[Aa.op];Fa&&0!==xa.indexOf(b.graph.FUNCTION_LIBRARY_NODE_PREFIX)&&(xa=this.cloneFunctionLibraryMetanode(T,
Aa,Fa.node,Fa.node.name,Aa.name),aa.push(Aa),la.push(xa))}),_.each(la,(xa,Aa)=>{Aa=aa[Aa];xa.parentNode=Aa.parentNode;T.setNode(Aa.name,xa);this.hierarchy.setNode(Aa.name,xa)}));_.each(T.nodes(),xa=>{let Aa=this.getOrCreateRenderNodeByName(xa),Fa=Aa.node;X.setNode(xa,Aa);Fa.isGroupNode||(_.each(Fa.inEmbeddings,ya=>{let Sa=new K(null),Xa=new H(ya);h(Aa,ya,Xa,Sa,N.CONSTANT);this.index[ya.name]=Xa}),_.each(Fa.outEmbeddings,ya=>{let Sa=new K(null),Xa=new H(ya);k(Aa,ya,Xa,Sa,N.SUMMARY);this.index[ya.name]=
Xa}))});_.each(T.edges(),xa=>{var Aa=T.edge(xa);Aa=new K(Aa);Aa.isFadedOut=this.index[xa.v].isFadedOut||this.index[xa.w].isFadedOut;X.setEdge(xa.v,xa.w,Aa)});G.enableExtraction&&Q.node.type===d.NodeType.META&&C(Q);_.isEmpty(this.hierarchy.libraryFunctions)||this.buildSubhierarchiesForNeededFunctions(T);L===b.graph.ROOT_NAME&&_.forOwn(this.hierarchy.libraryFunctions,xa=>{xa=xa.node;const Aa=this.getOrCreateRenderNodeByName(xa.name);Q.libraryFunctionsExtract.push(Aa);Aa.node.include=d.InclusionType.EXCLUDE;
X.removeNode(xa.name)});var Z=Q.node.parentNode;if(Z){var ba=this.index[Z.name],ea=(xa,...Aa)=>Aa.concat([xa?"IN":"OUT"]).join("~~"),ca=this.hierarchy.getBridgegraph(L),ka={},Y={},Ea={};_.each(ca.edges(),xa=>{let Aa=!!T.node(xa.w),Fa=Aa?xa.v:xa.w;ca.edge(xa).numRegularEdges?Aa?Y[Fa]=(Y[Fa]||0)+1:ka[Fa]=(ka[Fa]||0)+1:Ea[Fa]=(Ea[Fa]||0)+1});var va=this.hierarchy.getNodeMap();_.each(ca.edges(),xa=>{var Aa=ca.edge(xa);let Fa=!!T.node(xa.w),[ya,Sa]=Fa?[xa.w,xa.v]:[xa.v,xa.w];var Xa=this.index[ya],ub=this.index[Sa],
Bb=ub?ub.node:va[Sa],qb=!Aa.numRegularEdges&&Ea[Sa]>G.maxControlDegree,[,zb]=Fa?[Q.inAnnotations,Xa.inAnnotations]:[Q.outAnnotations,Xa.outAnnotations];let vb=(Fa?Y:ka)[Sa]>G.maxBridgePathDegree;xa=null;var Gb=!1;G.enableBridgegraph&&!vb&&!qb&&Xa.isInCore()&&(Gb=Nb=>ba.coreGraph.edge(Fa?{v:Nb,w:L}:{v:L,w:Nb}),(xa=Gb(Sa))||(xa=Gb(ea(Fa,Sa,Z.name))),Gb=!!xa);Xa=!1;if(xa&&!Aa.numRegularEdges){Xa=xa;for(qb=ba.node;Xa.adjoiningMetaedge;)Xa=Xa.adjoiningMetaedge,qb=qb.parentNode;qb=this.hierarchy.getTopologicalOrdering(qb.name);
Xa=Xa.metaedge;Xa=qb[Xa.v]>qb[Xa.w]}Gb&&!Xa?(Bb=ea(Fa,L),ub=ea(Fa,Sa,L),zb=X.node(ub),zb||(Gb=X.node(Bb),Gb||(Gb=new H({name:Bb,type:d.NodeType.BRIDGE,isGroupNode:!1,cardinality:0,parentNode:null,stats:null,include:d.InclusionType.UNSPECIFIED,inbound:Fa,nodeAttributes:{}}),this.index[Bb]=Gb,X.setNode(Bb,Gb)),zb=new H({name:ub,type:d.NodeType.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,include:d.InclusionType.UNSPECIFIED,inbound:Fa,nodeAttributes:{}}),this.index[ub]=zb,X.setNode(ub,
zb),X.setParent(ub,Bb),Gb.node.cardinality++),Aa=new K(Aa),Aa.adjoiningMetaedge=xa,Fa?X.setEdge(ub,ya,Aa):X.setEdge(ya,ub,Aa)):zb.push(new I(Bb,ub,new K(Aa),N.SHORTCUT,Fa))});_.each([!0,!1],xa=>{let Aa=ea(xa,L),Fa=X.node(Aa);Fa&&_.each(X.nodes(),ya=>{if(X.node(ya).node.type!==d.NodeType.BRIDGE&&(xa?!X.predecessors(ya).length:!X.successors(ya).length)){var Sa=ea(xa,L,"STRUCTURAL_TARGET"),Xa=X.node(Sa);Xa||(Xa=new H({name:Sa,type:d.NodeType.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,
include:d.InclusionType.UNSPECIFIED,inbound:xa,nodeAttributes:{}}),Xa.structural=!0,this.index[Sa]=Xa,X.setNode(Sa,Xa),Fa.node.cardinality++,X.setParent(Sa,Aa));Xa=new K(null);Xa.structural=!0;Xa.weight--;xa?X.setEdge(Sa,ya,Xa):X.setEdge(ya,Sa,Xa)}})})}}}}buildSubhierarchiesForNeededFunctions(L){_.each(L.edges(),Q=>{Q=L.edge(Q);Q=new K(Q);_.forEach(Q.metaedge.baseEdgeList,T=>{var X=T.v.split(b.graph.NAMESPACE_DELIM);for(var aa=X.length;0<=aa;aa--){T=X.slice(0,aa);const la=this.hierarchy.node(T.join(b.graph.NAMESPACE_DELIM));
if(la){if(la.type===d.NodeType.OP&&this.hierarchy.libraryFunctions[la.op])for(X=1;X<T.length;X++)(aa=T.slice(0,X).join(b.graph.NAMESPACE_DELIM))&&this.buildSubhierarchy(aa);break}}})})}}f.RenderGraphInfo=B;class I{constructor(L,Q,T,X,aa){this.node=L;this.renderNodeInfo=Q;this.renderMetaedgeInfo=T;this.annotationType=X;this.height=this.width=this.dy=this.dx=0;T&&T.metaedge&&(this.v=T.metaedge.v,this.w=T.metaedge.w);this.isIn=aa;this.points=[]}}f.Annotation=I;let N;(function(L){L[L.SHORTCUT=0]="SHORTCUT";
L[L.CONSTANT=1]="CONSTANT";L[L.SUMMARY=2]="SUMMARY";L[L.ELLIPSIS=3]="ELLIPSIS"})(N=f.AnnotationType||(f.AnnotationType={}));class O{constructor(){this.list=[];this.nodeNames={}}push(L){if(!(L.node.name in this.nodeNames))if(this.nodeNames[L.node.name]=!0,this.list.length<G.maxAnnotations)this.list.push(L);else{var Q=this.list[this.list.length-1];Q.annotationType===N.ELLIPSIS?(L=Q.node,L.setNumMoreNodes(++L.numMoreNodes)):(Q=new b.graph.EllipsisNodeImpl(1),this.list.push(new I(Q,new H(Q),null,N.ELLIPSIS,
L.isIn)))}}}f.AnnotationList=O;class H{constructor(L){this.node=L;this.expanded=!1;this.inAnnotations=new O;this.outAnnotations=new O;this.outboxWidth=this.inboxWidth=this.height=this.width=this.y=this.x=0;this.structural=this.excluded=!1;this.paddingBottom=this.paddingRight=this.paddingLeft=this.paddingTop=this.labelHeight=this.radius=this.labelOffset=0;this.isOutExtract=this.isInExtract=!1;this.coreBox={width:0,height:0};this.isFadedOut=!1;this.displayName=L.name.substring(L.name.lastIndexOf(b.graph.NAMESPACE_DELIM)+
1);L.type===d.NodeType.META&&L.associatedFunction&&((L=this.displayName.match(D))?this.displayName=L[1]:_.startsWith(this.displayName,b.graph.FUNCTION_LIBRARY_NODE_PREFIX)&&(this.displayName=this.displayName.substring(b.graph.FUNCTION_LIBRARY_NODE_PREFIX.length)))}isInCore(){return!this.isInExtract&&!this.isOutExtract&&!this.isLibraryFunction}}f.RenderNodeInfo=H;class K{constructor(L){this.metaedge=L;this.adjoiningMetaedge=null;this.structural=!1;this.weight=1;this.isFadedOut=!1}}f.RenderMetaedgeInfo=
K;class M extends H{constructor(L,Q){super(L);L=L.metagraph.graph();Q.compound=!0;this.coreGraph=d.createGraph(L.name,d.GraphType.CORE,Q);this.inExtractBox={width:0,height:0};this.outExtractBox={width:0,height:0};this.libraryFunctionsBox={width:0,height:0};this.isolatedInExtract=[];this.isolatedOutExtract=[];this.libraryFunctionsExtract=[]}}f.RenderGroupNodeInfo=M;f.makeInExtract=n;f.mapIndexToHue=function(L){return 1+579.2561679725*L%358};f.expandUntilNodeIsShown=function(L,Q){var T=document.getElementById("scene");
Q=Q.split("/");var X=Q[Q.length-1].match(/(.*):\w+/);2===X.length&&(Q[Q.length-1]=X[1]);X=Q[0];let aa=L.getRenderNodeByName(X);for(let la=1;la<Q.length&&aa.node.type!==b.graph.NodeType.OP;la++)L.buildSubhierarchy(X),aa.expanded=!0,T.setNodeExpanded(aa),X+="/"+Q[la],aa=L.getRenderNodeByName(X);return aa.node.name}})(d.render||(d.render={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/scene.js
(function(b){(function(d){(function(f){function h(q,u,x,A){var y=k(q,u,x);if(!y.empty())return y;u=document.createElementNS("http://www.w3.org/2000/svg",u);if(x instanceof Array)for(y=0;y<x.length;y++)u.classList.add(x[y]);else u.classList.add(x);A?q.node().insertBefore(u,A):q.node().appendChild(u);return d3.select(u).datum(q.datum())}function k(q,u,x){q=q.node().childNodes;for(let A=0;A<q.length;A++){let y=q[A];if(y.tagName===u)if(x instanceof Array){let w=!0;for(let C=0;C<x.length;C++)w=w&&y.classList.contains(x[C]);
if(w)return d3.select(y)}else if(!x||y.classList.contains(x))return d3.select(y)}return d3.select(null)}function t(q,u){let x=u.node.type===d.NodeType.SERIES?0:d.layout.PARAMS.subscene.meta.labelHeight;l(k(q,"g",f.Class.Scene.CORE),0,x);var A=0<u.isolatedInExtract.length,y=0<u.isolatedOutExtract.length;let w=0<u.libraryFunctionsExtract.length,C=d.layout.PARAMS.subscene.meta.extractXOffset,G=0;A&&(G+=u.outExtractBox.width);y&&(G+=u.outExtractBox.width);A&&(A=u.coreBox.width,A=G<d.layout.MIN_AUX_WIDTH?
A-d.layout.MIN_AUX_WIDTH+u.inExtractBox.width/2:A-u.inExtractBox.width/2-u.outExtractBox.width-(y?C:0),A=A-u.libraryFunctionsBox.width-(w?C:0),l(k(q,"g",f.Class.Scene.INEXTRACT),A,x));y&&(y=u.coreBox.width,y=G<d.layout.MIN_AUX_WIDTH?y-d.layout.MIN_AUX_WIDTH+u.outExtractBox.width/2:y-u.outExtractBox.width/2,y=y-u.libraryFunctionsBox.width-(w?C:0),l(k(q,"g",f.Class.Scene.OUTEXTRACT),y,x));w&&(u=u.coreBox.width-u.libraryFunctionsBox.width/2,l(k(q,"g",f.Class.Scene.FUNCTION_LIBRARY),u,x))}function l(q,
u,x){null!=q.attr("transform")&&(q=q.transition("position"));q.attr("transform","translate("+u+","+x+")")}function p(q,u){return u?q.toFixed(0):1<=Math.abs(q)?q.toFixed(1):q.toExponential(1)}function m(q,u,x,A){let y="Device: "+q.device_name+"\n";y+="dtype: "+q.dtype+"\n";let w="(scalar)";0<q.shape.length&&(w="("+q.shape.join(",")+")");y=y+("\nshape: "+w+"\n\n#(elements): ")+(u+"\n");q=[];for(u=0;u<x.length;u++)0<x[u]&&q.push("#("+f.healthPillEntries[u].label+"): "+x[u]);y+=q.join(", ")+"\n\n";A.max>=
A.min&&(y+="min: "+A.min+", max: "+A.max+"\n",y+="mean: "+A.mean+", stddev: "+A.stddev);return y}function n(q,u,x,A,y=60,w=10,C=0,G){d3.select(q.parentNode).selectAll(".health-pill").remove();if(u){var D=u.value,B=D.slice(2,8),I=B[0],N=B[1],O=B[5],H=D[1],K={min:D[8],max:D[9],mean:D[10],stddev:Math.sqrt(D[11])};null==y&&(y=60);null==w&&(w=10);null==C&&(C=0);null!=x&&x.node.type===b.graph.NodeType.OP&&(y/=2,w/=2);D=document.createElementNS(f.SVG_NAMESPACE,"g");D.classList.add("health-pill");var M=document.createElementNS(f.SVG_NAMESPACE,
"defs");D.appendChild(M);var L=document.createElementNS(f.SVG_NAMESPACE,"linearGradient");A="health-pill-gradient-"+A;L.setAttribute("id",A);var Q=0,T="0%";for(let aa=0;aa<B.length;aa++)if(B[aa]){Q+=B[aa];var X=document.createElementNS(f.SVG_NAMESPACE,"stop");X.setAttribute("offset",T);X.setAttribute("stop-color",f.healthPillEntries[aa].background_color);L.appendChild(X);T=document.createElementNS(f.SVG_NAMESPACE,"stop");X=100*Q/H+"%";T.setAttribute("offset",X);T.setAttribute("stop-color",f.healthPillEntries[aa].background_color);
L.appendChild(T);T=X}M.appendChild(L);M=document.createElementNS(f.SVG_NAMESPACE,"rect");M.setAttribute("fill","url(#"+A+")");M.setAttribute("width",String(y));M.setAttribute("height",String(w));M.setAttribute("y",String(C));D.appendChild(M);M=document.createElementNS(f.SVG_NAMESPACE,"title");M.textContent=m(u,H,B,K);D.appendChild(M);u=!1;if(null!=x&&(M=x.x-y/2,w=x.y-w-x.height/2-2,0>x.labelOffset&&(w+=x.labelOffset),D.setAttribute("transform","translate("+M+", "+w+")"),(B[2]||B[3]||B[4])&&(x=x.node.attr)&&
x.length))for(B=0;B<x.length;B++)if("T"===x[B].key){u=(x=x[B].value.type)&&/^DT_(BOOL|INT|UINT)/.test(x);break}x=document.createElementNS(f.SVG_NAMESPACE,"text");if(Number.isFinite(K.min)&&Number.isFinite(K.max)){if(B=p(K.min,u),K=p(K.max,u),x.textContent=1<H?B+" ~ "+K:B,0<I||0<N||0<O)x.textContent+=" (",H=[],0<I&&H.push(`NaN\u00d7${I}`),0<N&&H.push(`-\u221e\u00d7${N}`),0<O&&H.push(`+\u221e\u00d7${O}`),x.textContent+=H.join("; ")+")"}else x.textContent="(No finite elements)";x.classList.add("health-pill-stats");
null==G&&(G=y/2);x.setAttribute("x",String(G));x.setAttribute("y",String(C-2));D.appendChild(x);Polymer.dom(q.parentNode).appendChild(D)}}f.SVG_NAMESPACE="http://www.w3.org/2000/svg";f.Class={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"};f.healthPillEntries=[{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"}];f.fit=function(q,u,x,A){var y=q.getBoundingClientRect();let w=null;try{if(w=u.getBBox(),0===w.width)return}catch(C){return}u=d.layout.PARAMS.graph;y=d3.zoomIdentity.scale(.9*Math.min(y.width/
w.width,y.height/w.height,2)).translate(u.padding.paddingLeft,u.padding.paddingTop);d3.select(q).transition().duration(500).call(x.transform,y).on("end.fitted",()=>{x.on("end.fitted",null);A()})};f.panToNode=function(q,u,x,A){x=d3.select(u).select(`[data-name="${q}"]`).node();if(!x)return console.warn(`panToNode() failed for node name "${q}"`),!1;var y=x.getBBox(),w=x.getScreenCTM();q=u.createSVGPoint();x=u.createSVGPoint();q.x=y.x;q.y=y.y;x.x=y.x+y.width;x.y=y.y+y.height;q=q.matrixTransform(w);x=
x.matrixTransform(w);w=(G,D,B,I)=>!(G>B&&D<I);y=u.getBoundingClientRect();const C=y.top+y.height-150;return w(q.x,x.x,y.left,y.left+y.width-320)||w(q.y,x.y,y.top,C)?(w=y.left+y.width/2-(q.x+x.x)/2,q=y.top+y.height/2-(q.y+x.y)/2,x=d3.zoomTransform(u),d3.select(u).transition().duration(500).call(A.translateBy,w/x.k,q/x.k),!0):!1};f.selectOrCreateChild=h;f.selectChild=k;f.buildGroup=function(q,u,x,A){A=A||f.Class.Scene.GROUP;let y=k(q,"g",A).empty();q=h(q,"g",A);A=h(q,"g",f.Class.Scene.CORE);let w=_.reduce(u.coreGraph.nodes(),
(C,G)=>{G=u.coreGraph.node(G);G.excluded||C.push(G);return C},[]);u.node.type===d.NodeType.SERIES&&w.reverse();f.edge.buildGroup(A,u.coreGraph,x);f.node.buildGroup(A,w,x);0<u.isolatedInExtract.length?(A=h(q,"g",f.Class.Scene.INEXTRACT),f.node.buildGroup(A,u.isolatedInExtract,x)):k(q,"g",f.Class.Scene.INEXTRACT).remove();0<u.isolatedOutExtract.length?(A=h(q,"g",f.Class.Scene.OUTEXTRACT),f.node.buildGroup(A,u.isolatedOutExtract,x)):k(q,"g",f.Class.Scene.OUTEXTRACT).remove();0<u.libraryFunctionsExtract.length?
(A=h(q,"g",f.Class.Scene.FUNCTION_LIBRARY),f.node.buildGroup(A,u.libraryFunctionsExtract,x)):k(q,"g",f.Class.Scene.FUNCTION_LIBRARY).remove();t(q,u);y&&q.attr("opacity",0).transition().attr("opacity",1);return q};f.addGraphClickListener=function(q,u){d3.select(q).on("click",()=>{u.fire("graph-select")})};f.translate=l;f.positionRect=function(q,u,x,A,y){q.transition().attr("x",u-A/2).attr("y",x-y/2).attr("width",A).attr("height",y)};f.positionTriangle=function(q,u,x,A,y){y/=2;A/=2;u=[[u,x-y],[u+A,
x+y],[u-A,x+y]];q.transition().attr("points",u.map(w=>w.join(",")).join(" "))};f.positionButton=function(q,u){let x=d.layout.computeCXPositionOfNodeShape(u)+(u.expanded?u.width:u.coreBox.width)/2-6,A=u.y-(u.expanded?u.height:u.coreBox.height)/2+6;u.node.type!==d.NodeType.SERIES||u.expanded||(x+=10,A-=2);u="translate("+x+","+A+")";q.selectAll("path").transition().attr("transform",u);q.select("circle").transition().attr({cx:x,cy:A,r:d.layout.PARAMS.nodeSize.meta.expandButtonRadius})};f.positionEllipse=
function(q,u,x,A,y){q.transition().attr("cx",u).attr("cy",x).attr("rx",A/2).attr("ry",y/2)};f.humanizeHealthPillStat=p;f.addHealthPill=n;f.addHealthPills=function(q,u,x){if(u){var A=1;d3.select(q).selectAll("g.nodeshape").each(function(y){const w=u[y.node.name];n(this,w?w[x]:null,y,A++)})}}})(d.scene||(d.scene={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/template.js
(function(b){(function(d){(function(f){function h(n){let q=_.map({depth:n.depth,"|V|":n.metagraph.nodes().length,"|E|":n.metagraph.edges().length},function(u,x){return x+"\x3d"+u}).join(" ");n=_.map(n.opHistogram,function(u,x){return x+"\x3d"+u}).join(",");return q+" [ops] "+n}function k(n){const q=n.getNodeMap();let u=Object.keys(q).reduce((x,A)=>{const y=q[A];if(y.type!==d.NodeType.META)return x;A=A.split("/").length-1;let w=h(y),C=x[w]||{nodes:[],level:A};x[w]=C;C.nodes.push(y);C.level>A&&(C.level=
A);return x},{});return Object.keys(u).map(x=>[x,u[x]]).filter(([,x])=>{x=x.nodes;if(1<x.length)return!0;x=x[0];return x.type===d.NodeType.META&&x.associatedFunction}).sort(([,x])=>x.nodes[0].depth)}function t(n,q){return _.reduce(n,function(u,x){let A=x[0],y=[];x[1].nodes.forEach(function(w){for(let C=0;C<y.length;C++)if(!q||p(y[C].metanode.metagraph,w.metagraph)){w.templateId=y[C].metanode.templateId;y[C].members.push(w.name);return}w.templateId=A+"["+y.length+"]";y.push({metanode:w,members:[w.name]})});
y.forEach(function(w){u[w.metanode.templateId]={level:x[1].level,nodes:w.members}});return u},{})}function l(n,q,u){return _.sortBy(n,[x=>q.node(x).op,x=>q.node(x).templateId,x=>q.neighbors(x).length,x=>q.predecessors(x).length,x=>q.successors(x).length,x=>x.substr(u.length)])}function p(n,q){function u(I,N){let O=I.substr(x.length),H=N.substr(A.length);if(y[O]^w[H])return console.warn("different visit pattern","["+x+"]",O,"["+A+"]",H),!0;y[O]||(y[O]=w[H]=!0,C.push({n1:I,n2:N}));return!1}if(!b.graph.hasSimilarDegreeSequence(n,
q))return!1;let x=n.graph().name,A=q.graph().name,y={},w={},C=[];var G=n.sources(),D=q.sources();if(G.length!==D.length)return console.log("different source length"),!1;G=l(G,n,x);D=l(D,q,A);for(var B=0;B<G.length;B++)if(u(G[B],D[B]))return!1;for(;0<C.length;){D=C.pop();if(!m(n.node(D.n1),q.node(D.n2)))return!1;G=n.successors(D.n1);D=q.successors(D.n2);if(G.length!==D.length)return console.log("# of successors mismatch",G,D),!1;G=l(G,n,x);D=l(D,q,A);for(B=0;B<G.length;B++)if(u(G[B],D[B]))return!1}return!0}
function m(n,q){if(n.type===d.NodeType.META)return n.templateId&&q.templateId&&n.templateId===q.templateId;if(n.type===d.NodeType.OP&&q.type===d.NodeType.OP)return n.op===q.op;if(n.type===d.NodeType.SERIES&&q.type===d.NodeType.SERIES){let u=n.metagraph.nodeCount();return u===q.metagraph.nodeCount()&&(0===u||n.metagraph.node(n.metagraph.nodes()[0]).op===q.metagraph.node(q.metagraph.nodes()[0]).op)}return!1}f.detect=function(n,q){n=k(n);let u=t(n,q);return Object.keys(u).sort(x=>u[x].level).reduce((x,
A)=>{x[A]=u[A];return x},{})}})(d.template||(d.template={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/util.js
(function(b){(function(d){(function(f){f.time=function(h,k){let t=Date.now();k=k();console.log(h,":",Date.now()-t,"ms");return k};f.getTracker=function(h){return{setMessage:function(k){h.set("progress",{value:h.progress.value,msg:k})},updateProgress:function(k){h.set("progress",{value:h.progress.value+k,msg:h.progress.msg})},reportError:function(k,t){console.error(t.stack);h.set("progress",{value:h.progress.value,msg:k,error:!0})}}};f.getSubtaskTracker=function(h,k,t){return{setMessage:function(l){h.setMessage(t+
": "+l)},updateProgress:function(l){h.updateProgress(l*k/100)},reportError:function(l,p){h.reportError(t+": "+l,p)}}};f.runTask=function(h,k){k.setMessage("Reading metadata pbtxt");try{let t=b.graph.util.time("Reading metadata pbtxt",h);k.updateProgress(40);return t}catch(t){k.reportError("Failed Reading metadata pbtxt",t)}};f.runAsyncTask=function(h,k,t,l){return new Promise(p=>{l.setMessage(h);setTimeout(function(){try{let m=b.graph.util.time(h,t);l.updateProgress(k);p(m)}catch(m){l.reportError("Failed "+
h,m)}},20)})};f.runAsyncPromiseTask=function(h,k,t,l){return new Promise((p,m)=>{function n(q){l.reportError("Failed "+h,q);m(q)}l.setMessage(h);setTimeout(function(){try{let q=Date.now();t().then(function(u){console.log(h,":",Date.now()-q,"ms");l.updateProgress(k);p(u)}).catch(n)}catch(q){n(q)}},20)})};f.escapeQuerySelector=function(h){return h.replace(/([:.\[\],/\\\(\)])/g,"\\$1")};f.MEMORY_UNITS=[{symbol:"B"},{symbol:"KB",numUnits:1024},{symbol:"MB",numUnits:1024},{symbol:"GB",numUnits:1024},{symbol:"TB",
numUnits:1024},{symbol:"PB",numUnits:1024}];f.TIME_UNITS=[{symbol:"\u00b5s"},{symbol:"ms",numUnits:1E3},{symbol:"s",numUnits:1E3},{symbol:"min",numUnits:60},{symbol:"hr",numUnits:60},{symbol:"days",numUnits:24}];f.convertUnitsToHumanReadable=function(h,k,t=0){return t+1<k.length&&h>=k[t+1].numUnits?b.graph.util.convertUnitsToHumanReadable(h/k[t+1].numUnits,k,t+1):Number(h.toPrecision(3))+" "+k[t].symbol};f.hasDisplayableNodeStats=function(h){return h&&(0<h.totalBytes||0<h.getTotalMicros()||h.outputSize)?
!0:!1};f.removeCommonPrefix=function(h){if(2>h.length)return h;let k=0,t=0,l=_.min(_.map(h,p=>p.length));for(;;){k++;let p=_.map(h,m=>m.substring(0,k));if(p.every((m,n)=>0===n?!0:m===p[n-1])){if(k>=l)return h;t=k}else break}return _.map(h,p=>p.substring(t))};f.computeHumanFriendlyTime=function(h){h=+new Date-+new Date(h/1E3);return 3E4>h?"just now":6E4>h?Math.floor(h/1E3)+" seconds ago":12E4>h?"a minute ago":36E5>h?Math.floor(h/6E4)+" minutes ago":1==Math.floor(h/36E5)?"an hour ago":864E5>h?Math.floor(h/
36E5)+" hours ago":1728E5>h?"yesterday":Math.floor(h/864E5)+" days ago"}})(d.util||(d.util={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/minimap.js
(function(b){(function(d){class f{constructor(h,k,t,l,p,m){this.svg=h;this.labelPadding=m;this.zoomG=k;this.mainZoom=t;this.maxWandH=p;h=d3.select(l.shadowRoot);let n=h.select("svg"),q=n.select("rect");this.viewpointCoord={x:0,y:0};k=d3.drag().subject(Object).on("drag",()=>{this.viewpointCoord.x=d3.event.x;this.viewpointCoord.y=d3.event.y;this.updateViewpoint()});q.datum(this.viewpointCoord).call(k);n.on("click",()=>{if(!d3.event.defaultPrevented){var u=Number(q.attr("width")),x=Number(q.attr("height")),
A=d3.mouse(n.node());this.viewpointCoord.x=A[0]-u/2;this.viewpointCoord.y=A[1]-x/2;this.updateViewpoint()}});this.viewpoint=q.node();this.minimapSvg=n.node();this.minimap=l;this.canvas=h.select("canvas.first").node();this.canvasBuffer=h.select("canvas.second").node();this.downloadCanvas=h.select("canvas.download").node();d3.select(this.downloadCanvas).style("display","none");this.update()}updateViewpoint(){d3.select(this.viewpoint).attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y);let h=
-this.viewpointCoord.x*this.scaleMain/this.scaleMinimap,k=-this.viewpointCoord.y*this.scaleMain/this.scaleMinimap;d3.select(this.svg).call(this.mainZoom.transform,d3.zoomIdentity.translate(h,k).scale(this.scaleMain))}update(){let h=null;try{if(h=this.zoomG.getBBox(),0===h.width)return}catch(u){return}var k=d3.select("#graphdownload");this.download=k.node();k.on("click",()=>{URL.revokeObjectURL(this.download.href);var u=this.downloadCanvas.toDataURL("image/png");const x=u.slice(0,u.indexOf(","));if(x.endsWith(";base64")){var A=
atob(u.slice(u.indexOf(",")+1));u=(new Uint8Array(A.length)).map((y,w)=>A.charCodeAt(w));this.download.href=URL.createObjectURL(new Blob([u],{type:"image/png"}))}else console.warn(`non-base64 data URL (${x}); cannot use blob download`),this.download.href=u});k=d3.select(this.svg);var t="",l=this.svg;l=(l.getRootNode?l.getRootNode():this.svg.parentNode).styleSheets;for(var p=0;p<l.length;p++)try{var m=l[p].cssRules||l[p].rules;if(null!=m)for(let u=0;u<m.length;u++)t+=m[u].cssText.replace(/ ?tf-[\w-]+ ?/g,
"")+"\n"}catch(u){if("SecurityError"!==u.name)throw u;}m=k.append("style");m.text(t);t=d3.select(this.zoomG);l=t.attr("transform");t.attr("transform",null);h.height+=h.y;h.width+=h.x;h.height+=2*this.labelPadding;h.width+=2*this.labelPadding;k.attr("width",h.width).attr("height",h.height);this.scaleMinimap=this.maxWandH/Math.max(h.width,h.height);this.minimapSize={width:h.width*this.scaleMinimap,height:h.height*this.scaleMinimap};d3.select(this.minimapSvg).attr(this.minimapSize);d3.select(this.canvasBuffer).attr(this.minimapSize);
p=d3.select(this.downloadCanvas);p.style("width",h.width);p.style("height",h.height);p.attr("width",3*h.width);p.attr("height",3*h.height);null!=this.translate&&null!=this.zoom&&requestAnimationFrame(()=>this.zoom());let n=(new XMLSerializer).serializeToString(this.svg);m.remove();k.attr("width",null).attr("height",null);t.attr("transform",l);let q=new Image;q.onload=()=>{var u=this.canvasBuffer.getContext("2d");u.clearRect(0,0,this.canvasBuffer.width,this.canvasBuffer.height);u.drawImage(q,0,0,this.minimapSize.width,
this.minimapSize.height);requestAnimationFrame(()=>{d3.select(this.canvasBuffer).style("display",null);d3.select(this.canvas).style("display","none");[this.canvas,this.canvasBuffer]=[this.canvasBuffer,this.canvas]});u=this.downloadCanvas.getContext("2d");u.clearRect(0,0,this.downloadCanvas.width,this.downloadCanvas.height);u.drawImage(q,0,0,this.downloadCanvas.width,this.downloadCanvas.height)};q.onerror=()=>{q.src=URL.createObjectURL(new Blob([n],{type:"image/svg+xml;charset\x3dutf-8"}))};q.src=
"data:image/svg+xml;charset\x3dutf-8,"+encodeURIComponent(n)}zoom(h){if(null!=this.scaleMinimap){h&&(this.translate=[h.x,h.y],this.scaleMain=h.k);var k=this.svg.getBoundingClientRect(),t=d3.select(this.viewpoint);this.viewpointCoord.x=-this.translate[0]*this.scaleMinimap/this.scaleMain;this.viewpointCoord.y=-this.translate[1]*this.scaleMinimap/this.scaleMain;h=k.width*this.scaleMinimap/this.scaleMain;k=k.height*this.scaleMinimap/this.scaleMain;t.attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y).attr("width",
h).attr("height",k);t=this.minimapSize.width;var l=this.minimapSize.height,p=this.viewpointCoord.x,m=this.viewpointCoord.y;.8>(Math.min(Math.max(0,p+h),t)-Math.min(Math.max(0,p),t))*(Math.min(Math.max(0,m+k),l)-Math.min(Math.max(0,m),l))/(t*l)?this.minimap.classList.remove("hidden"):this.minimap.classList.add("hidden")}}}d.Minimap=f})(b.scene||(b.scene={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph/tf-graph-minimap.html.js
Polymer({is:"tf-graph-minimap",init:function(b,d,f,h,k){return new tf.scene.Minimap(b,d,f,this,h,k)}});

//# sourceURL=build://tf-graph/tf-graph-scene.html.js
Polymer({is:"tf-graph-scene",properties:{renderHierarchy:Object,name:String,colorBy:String,traceInputs:Boolean,_hasRenderHierarchyBeenFitOnce:Boolean,_isAttached:Boolean,_zoom:Object,highlightedNode:{type:String,observer:"_highlightedNodeChanged"},selectedNode:{type:String,observer:"_selectedNodeChanged"},handleEdgeSelected:Object,_zoomed:{type:Boolean,observer:"_onZoomChanged",value:!1},_zoomStartCoords:{type:Object,value:null},_zoomTransform:{type:Object,value:null},_maxZoomDistanceForClick:{type:Number,
value:20},templateIndex:Function,minimap:Object,_nodeGroupIndex:{type:Object,value:function(){return{}}},_annotationGroupIndex:{type:Object,value:function(){return{}}},_edgeGroupIndex:{type:Object,value:function(){return{}}},maxMetanodeLabelLengthFontSize:{type:Number,value:9},minMetanodeLabelLengthFontSize:{type:Number,value:6},maxMetanodeLabelLengthLargeFont:{type:Number,value:11},maxMetanodeLabelLength:{type:Number,value:18},progress:Object,nodeContextMenuItems:Array,nodeNamesToHealthPills:Object,
healthPillStepIndex:Number},observers:["_colorByChanged(colorBy)","_renderHierarchyChanged(renderHierarchy)","_animateAndFit(_isAttached, renderHierarchy)","_updateHealthPills(nodeNamesToHealthPills, healthPillStepIndex)","_updateInputTrace(traceInputs, selectedNode)"],getNode:function(b){return this.renderHierarchy.getRenderNodeByName(b)},isNodeExpanded:function(b){return b.expanded},setNodeExpanded:function(){this._build(this.renderHierarchy);this._updateLabels(!this._zoomed)},panToNode(b){tf.graph.scene.panToNode(b,
this.$.svg,this.$.root,this._zoom)&&(this._zoomed=!0)},getGraphSvgRoot(){return this.$.svg},getContextMenu(){return this.$.contextMenu},_resetState:function(){this._nodeGroupIndex={};this._annotationGroupIndex={};this._edgeGroupIndex={};this._updateLabels(!1);d3.select(this.$.svg).select("#root").selectAll("*").remove();tf.graph.scene.node.removeGradientDefinitions(this.$.svg)},_build:function(b){this.templateIndex=b.hierarchy.getTemplateIndex();tf.graph.util.time("tf-graph-scene (layout):",function(){tf.graph.layout.layoutScene(b.root,
this)}.bind(this));tf.graph.util.time("tf-graph-scene (build scene):",function(){tf.graph.scene.buildGroup(d3.select(this.$.root),b.root,this);tf.graph.scene.addGraphClickListener(this.$.svg,this);this._updateInputTrace()}.bind(this));setTimeout(function(){this._updateHealthPills(this.nodeNamesToHealthPills,this.healthPillStepIndex);this.minimap.update()}.bind(this),tf.graph.layout.PARAMS.animation.duration)},ready:function(){this._zoom=d3.zoom().on("end",function(){this._zoomStartCoords&&(Math.sqrt(Math.pow(this._zoomStartCoords.x-
this._zoomTransform.x,2)+Math.pow(this._zoomStartCoords.y-this._zoomTransform.y,2))<this._maxZoomDistanceForClick?this._fireEnableClick():setTimeout(this._fireEnableClick.bind(this),50));this._zoomStartCoords=null}.bind(this)).on("zoom",function(){this._zoomTransform=d3.event.transform;this._zoomStartCoords||(this._zoomStartCoords=this._zoomTransform,this.fire("disable-click"));this._zoomed=!0;d3.select(this.$.root).attr("transform",d3.event.transform);this.minimap.zoom(d3.event.transform)}.bind(this));
d3.select(this.$.svg).call(this._zoom).on("dblclick.zoom",null);d3.select(window).on("resize",function(){this.minimap.zoom()}.bind(this));this.minimap=this.$.minimap.init(this.$.svg,this.$.root,this._zoom,tf.graph.layout.PARAMS.minimap.size,tf.graph.layout.PARAMS.subscene.meta.labelHeight)},attached:function(){this.set("_isAttached",!0)},detached:function(){this.set("_isAttached",!1)},_renderHierarchyChanged:function(b){this._hasRenderHierarchyBeenFitOnce=!1;this._resetState();this._build(b)},_animateAndFit:function(b){!this._hasRenderHierarchyBeenFitOnce&&
b&&setTimeout(this.fit.bind(this),tf.graph.layout.PARAMS.animation.duration)},_updateLabels:function(b){var d=this.$$(".title"),f=d.style,h=this.$$(".auxTitle"),k=h.style,t=this.$$(".functionLibraryTitle").style;const l=d3.select(this.$.svg);var p=l.select("."+tf.graph.scene.Class.Scene.GROUP+"\x3e."+tf.graph.scene.Class.Scene.CORE).node();if(b&&p&&this.progress&&100===this.progress.value){b=l.select("."+tf.graph.scene.Class.Scene.GROUP+"\x3e."+tf.graph.scene.Class.Scene.INEXTRACT).node()||l.select("."+
tf.graph.scene.Class.Scene.GROUP+"\x3e."+tf.graph.scene.Class.Scene.OUTEXTRACT).node();var m=p.getCTM().e;p=b?b.getCTM().e:null;f.display="inline";f.left=m+"px";null!==p&&p!==m?(k.display="inline",p=Math.max(m+d.getBoundingClientRect().width,p),k.left=p+"px"):k.display="none";d=(d=l.select("."+tf.graph.scene.Class.Scene.GROUP+"\x3e."+tf.graph.scene.Class.Scene.FUNCTION_LIBRARY).node())?d.getCTM().e:null;null!==d&&d!==p?(t.display="inline",d=Math.max(p+h.getBoundingClientRect().width,d),t.left=d+"px"):
t.display="none"}else f.display="none",k.display="none",t.display="none"},_colorByChanged:function(){null!=this.renderHierarchy&&(_.each(this._nodeGroupIndex,(b,d)=>{this._updateNodeState(d)}),this.minimap.update())},fit:function(){this._hasRenderHierarchyBeenFitOnce=!0;tf.graph.scene.fit(this.$.svg,this.$.root,this._zoom,function(){this._zoomed=!1}.bind(this))},isNodeSelected:function(b){return b===this.selectedNode},isNodeHighlighted:function(b){return b===this.highlightedNode},addAnnotationGroup:function(b,
d,f){b=b.node.name;this._annotationGroupIndex[b]=this._annotationGroupIndex[b]||{};this._annotationGroupIndex[b][d.node.name]=f},getAnnotationGroupsIndex:function(b){return this._annotationGroupIndex[b]},removeAnnotationGroup:function(b,d){delete this._annotationGroupIndex[b.node.name][d.node.name]},addNodeGroup:function(b,d){this._nodeGroupIndex[b]=d},getNodeGroup:function(b){return this._nodeGroupIndex[b]},removeNodeGroup:function(b){delete this._nodeGroupIndex[b]},addEdgeGroup:function(b,d){this._edgeGroupIndex[b]=
d},getEdgeGroup:function(b){return this._edgeGroupIndex[b]},_updateHealthPills:function(b,d){tf.graph.scene.addHealthPills(this.$.svg,b,d)},_updateNodeState:function(b){var d=this.getNode(b),f=this.getNodeGroup(b);f&&tf.graph.scene.node.stylize(f,d,this);d.node.type===tf.graph.NodeType.META&&d.node.associatedFunction&&!d.isLibraryFunction&&(f=d3.select("."+tf.graph.scene.Class.Scene.GROUP+"\x3e."+tf.graph.scene.Class.Scene.FUNCTION_LIBRARY+' g[data-name\x3d"'+(tf.graph.FUNCTION_LIBRARY_NODE_PREFIX+
d.node.associatedFunction)+'"]'),tf.graph.scene.node.stylize(f,d,this));_.each(this.getAnnotationGroupsIndex(b),h=>{tf.graph.scene.node.stylize(h,d,this,tf.graph.scene.Class.Annotation.NODE)})},_selectedNodeChanged:function(b,d){if(b!==d&&(d&&this._updateNodeState(d),b)){this.minimap.update();d=this.renderHierarchy.hierarchy.node(b);for(var f=[];null!=d.parentNode&&d.parentNode.name!=tf.graph.ROOT_NAME;)d=d.parentNode,f.push(d.name);var h;_.forEachRight(f,k=>{this.renderHierarchy.buildSubhierarchy(k);
k=this.renderHierarchy.getRenderNodeByName(k);k.node.isGroupNode&&!k.expanded&&(k.expanded=!0,h||(h=k))});h&&(this.setNodeExpanded(h),this._zoomed=!0);b&&this._updateNodeState(b);setTimeout(()=>{this.panToNode(b)},tf.graph.layout.PARAMS.animation.duration)}},_highlightedNodeChanged:function(b,d){b!==d&&(b&&this._updateNodeState(b),d&&this._updateNodeState(d))},_onZoomChanged:function(){this._updateLabels(!this._zoomed)},_fireEnableClick:function(){this.fire("enable-click")},_updateInputTrace:function(){tf.graph.scene.node.updateInputTrace(this.getGraphSvgRoot(),
this.renderHierarchy,this.selectedNode,this.traceInputs)}});

//# sourceURL=build://tf-graph/tf-graph.html.js
Polymer({is:"tf-graph",properties:{graphHierarchy:{type:Object,notify:!0,observer:"_graphChanged"},basicGraph:Object,stats:Object,devicesForStats:Object,hierarchyParams:Object,progress:{type:Object,notify:!0},title:String,selectedNode:{type:String,notify:!0},selectedEdge:{type:Object,notify:!0},_lastSelectedEdgeGroup:Object,highlightedNode:{type:String,notify:!0},colorBy:String,colorByParams:{type:Object,notify:!0,readOnly:!0},renderHierarchy:{type:Object,readOnly:!0,notify:!0},traceInputs:Boolean,
nodeContextMenuItems:Array,_renderDepth:{type:Number,value:1},_allowGraphSelect:{type:Boolean,value:!0},nodeNamesToHealthPills:Object,healthPillStepIndex:Number,edgeWidthFunction:{type:Object,value:""},handleNodeSelected:{type:Object,value:""},edgeLabelFunction:{type:Object,value:""},handleEdgeSelected:{type:Object,value:""}},observers:["_statsChanged(stats, devicesForStats)","_buildNewRenderHierarchy(graphHierarchy, edgeWidthFunction, handleNodeSelected, edgeLabelFunction, handleEdgeSelected)","_selectedNodeChanged(selectedNode)",
"_selectedEdgeChanged(selectedEdge)"],panToNode(b){this.$$("tf-graph-scene").panToNode(b)},_buildNewRenderHierarchy(b){b&&this._buildRenderHierarchy(b)},_statsChanged:function(b,d){this.graphHierarchy&&(b&&d&&(tf.graph.joinStatsInfoWithGraph(this.basicGraph,b,d),tf.graph.hierarchy.joinAndAggregateStats(this.graphHierarchy)),this._buildRenderHierarchy(this.graphHierarchy))},_buildRenderHierarchy:function(b){tf.graph.util.time("new tf.graph.render.Hierarchy",function(){function d(h){return{minValue:h.domain()[0],
maxValue:h.domain()[1],startColor:h.range()[0],endColor:h.range()[1]}}if(b.root.type===tf.graph.NodeType.META){var f=new tf.graph.render.RenderGraphInfo(b,!!this.stats);f.edgeLabelFunction=this.edgeLabelFunction;f.edgeWidthFunction=this.edgeWidthFunction;this._setColorByParams({compute_time:d(f.computeTimeScale),memory:d(f.memoryUsageScale),device:_.map(f.deviceColorMap.domain(),function(h){return{device:h,color:f.deviceColorMap(h)}}),xla_cluster:_.map(f.xlaClusterColorMap.domain(),function(h){return{xla_cluster:h,
color:f.xlaClusterColorMap(h)}})});this._setRenderHierarchy(f);this.async(function(){this.fire("rendered")})}}.bind(this))},_getVisible:function(b){return b?this.renderHierarchy.getNearestVisibleAncestor(b):b},listeners:{"graph-select":"_graphSelected","disable-click":"_disableClick","enable-click":"_enableClick","node-toggle-expand":"_nodeToggleExpand","node-select":"_nodeSelected","node-highlight":"_nodeHighlighted","node-unhighlight":"_nodeUnhighlighted","node-toggle-extract":"_nodeToggleExtract",
"node-toggle-seriesgroup":"_nodeToggleSeriesGroup","edge-select":"_edgeSelected","annotation-select":"_nodeSelected","annotation-highlight":"_nodeHighlighted","annotation-unhighlight":"_nodeUnhighlighted"},fit:function(){this.$.scene.fit()},_graphChanged:function(){this.fire("graph-select")},_graphSelected:function(){this._allowGraphSelect&&(this.set("selectedNode",null),this.set("selectedEdge",null));this._allowGraphSelect=!0},_disableClick:function(){this._allowGraphSelect=!1},_enableClick:function(){this._allowGraphSelect=
!0},_selectedNodeChanged(b){this.handleNodeSelected&&this.handleNodeSelected(b)},_selectedEdgeChanged(b){this._deselectPreviousEdge();b&&(this._lastSelectedEdgeGroup.classed(tf.graph.scene.Class.Edge.SELECTED,!0),this._updateMarkerOfSelectedEdge(b));this.handleEdgeSelected&&this.handleEdgeSelected(b)},_nodeSelected:function(b){this._allowGraphSelect&&this.set("selectedNode",b.detail.name);this._allowGraphSelect=!0},_edgeSelected(b){this._allowGraphSelect&&(this.set("_lastSelectedEdgeGroup",b.detail.edgeGroup),
this.set("selectedEdge",b.detail.edgeData));this._allowGraphSelect=!0},_nodeHighlighted:function(b){this.set("highlightedNode",b.detail.name)},_nodeUnhighlighted:function(){this.set("highlightedNode",null)},_nodeToggleExpand:function(b){this._nodeSelected(b);b=b.detail.name;var d=this.renderHierarchy.getRenderNodeByName(b);d.node.type!==tf.graph.NodeType.OP&&(this.renderHierarchy.buildSubhierarchy(b),d.expanded=!d.expanded,this.async(function(){this.$.scene.setNodeExpanded(d)},75))},_nodeToggleExtract:function(b){this.nodeToggleExtract(b.detail.name)},
nodeToggleExtract:function(b){b=this.renderHierarchy.getRenderNodeByName(b);b.node.include=b.node.include==tf.graph.InclusionType.INCLUDE?tf.graph.InclusionType.EXCLUDE:b.node.include==tf.graph.InclusionType.EXCLUDE?tf.graph.InclusionType.INCLUDE:this.renderHierarchy.isNodeAuxiliary(b)?tf.graph.InclusionType.INCLUDE:tf.graph.InclusionType.EXCLUDE;this._buildRenderHierarchy(this.graphHierarchy)},_nodeToggleSeriesGroup:function(b){this.nodeToggleSeriesGroup(b.detail.name)},nodeToggleSeriesGroup:function(b){tf.graph.toggleNodeSeriesGroup(this.hierarchyParams.seriesMap,
b);this.set("progress",{value:0,msg:""});tf.graph.hierarchy.build(this.basicGraph,this.hierarchyParams,tf.graph.util.getSubtaskTracker(tf.graph.util.getTracker(this),100,"Namespace hierarchy")).then(function(d){this.set("graphHierarchy",d);this._buildRenderHierarchy(this.graphHierarchy)}.bind(this))},_deselectPreviousEdge(){d3.select("."+tf.graph.scene.Class.Edge.SELECTED).classed(tf.graph.scene.Class.Edge.SELECTED,!1).each(b=>{if(b.label){const d=d3.select(this).selectAll("path.edgeline");b.label.startMarkerId&&
d.style("marker-start",`url(#${b.label.startMarkerId})`);b.label.endMarkerId&&d.style("marker-end",`url(#${b.label.endMarkerId})`)}})},_updateMarkerOfSelectedEdge(b){if(b.label){var d=b.label.startMarkerId||b.label.endMarkerId;if(d){const f=d.replace("dataflow-","selected-");let h=this.$$("#"+f);h||(d=this.$.scene.querySelector("#"+d),h=d.cloneNode(!0),h.setAttribute("id",f),h.classList.add("selected-arrowhead"),d.parentNode.appendChild(h));b=b.label.startMarkerId?"marker-start":"marker-end";this._lastSelectedEdgeGroup.selectAll("path.edgeline").style(b,
`url(#${f})`)}}},not:function(b){return!b}});

//# sourceURL=build://tf-graph-loader/tf-graph-loader.js
(function(b){(function(d){(function(){Polymer({is:"tf-graph-loader",_template:null,properties:{datasets:Array,selectedData:{type:Number,value:0},selectedFile:Object,compatibilityProvider:{type:Object,value:()=>new b.graph.op.TpuCompatibilityProvider},overridingHierarchyParams:{type:Object,value:()=>({})},progress:{type:Object,notify:!0},outGraphHierarchy:{type:Object,readOnly:!0,notify:!0},outGraph:{type:Object,readOnly:!0,notify:!0},outHierarchyParams:{type:Object,readOnly:!0,notify:!0}},observers:["_loadData(datasets, selectedData, overridingHierarchyParams, compatibilityProvider)",
"_loadFile(selectedFile, overridingHierarchyParams, compatibilityProvider)"],_loadData(){this.debounce("load",()=>{const f=this.datasets[this.selectedData];f&&this._parseAndConstructHierarchicalGraph(f.path)})},_parseAndConstructHierarchicalGraph(f,h){const k=this.overridingHierarchyParams,t=this.compatibilityProvider;this.progress={value:0,msg:""};const l=b.graph.util.getTracker(this),p=Object.assign({},b.graph.hierarchy.DefaultHierarchyParams,k);b.graph.loader.fetchAndConstructHierarchicalGraph(l,
f,h,t,p).then(({graph:m,graphHierarchy:n})=>{this._setOutHierarchyParams(p);this._setOutGraph(m);this._setOutGraphHierarchy(n)})},_loadFile(f){if(f){f=f.target;var h=f.files[0];h&&(f.value="",this._parseAndConstructHierarchicalGraph(null,h))}}})})(d.loader||(d.loader={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-debugger-dashboard/health-pills.js
var Vi;
(function(b){function d(k,t){if(null==k)throw Error(`Missing refValue for condition (${t}).`);}function f(k){return null==k||0==k.length||1!==k[0]}const h={INF_OR_NAN:{description:"Contains +/-\u221e or NaN",predicate:k=>0<k[2]||0<k[3]||0<k[7]},INF:{description:"Contains +/-\u221e",predicate:k=>0<k[3]||0<k[7]},NAN:{description:"Contains NaN",predicate:k=>0<k[2]},MAX_GT:{description:"Max \x3e",predicate:(k,t)=>{d(t,"MAX_GT");return k[9]>t}},MAX_LT:{description:"Max \x3c",predicate:(k,t)=>{d(t,"MAX_LT");
return k[9]<t}},MIN_GT:{description:"Min \x3e",predicate:(k,t)=>{d(t,"MIN_GT");return k[8]>t}},MIN_LT:{description:"Min \x3c",predicate:(k,t)=>{d(t,"MIN_LT");return k[8]<t}},MEAN_GT:{description:"Mean \x3e",predicate:(k,t)=>{d(t,"MEAN_GT");return k[10]>t}},MEAN_LT:{description:"Mean \x3c",predicate:(k,t)=>{d(t,"MEAN_LT");return k[10]<t}},RANGE_GT:{description:"Max - Min \x3e",predicate:(k,t)=>{d(t,"RANGE_GT");return k[9]-k[8]>t}},RANGE_LT:{description:"Max - Min \x3c",predicate:(k,t)=>{d(t,"RANGE_LT");
return k[9]-k[8]<t}},STDDEV_GT:{description:"Standard deviation \x3e",predicate:(k,t)=>{d(t,"STDDEV_GT");return Math.sqrt(k[11])>t}},STDDEV_LT:{description:"Standard deviation \x3c",predicate:(k,t)=>{d(t,"STDDEV_LT");return Math.sqrt(k[11])<t}}};b.tensorConditionDescription2Key=function(k){for(const t in h)if(h.hasOwnProperty(t)&&h[t].description===k)return t;return null};b.checkHealthPillAgainstTensorConditionKey=function(k,t,l){if(f(t))return!1;k=h[k].predicate;return k(t,l)}})(Vi||(Vi={}));

//# sourceURL=build://tf-debugger-dashboard/tf-debugger-continue-dialog.html.js
Polymer({is:"tf-debugger-continue-dialog",properties:{continueNum:{type:Number,value:5},sessionRunGo:Function,tensorConditionGo:Function,forceContinuationStop:Function,_continueButtonText:{type:String,value:"Continue..."},_continueButtonContinueText:{type:String,value:"Continue...",readonly:!0},_continueButtonStopText:{type:String,value:"Stop Continuation",readonly:!0},_selectedTensorCondition:String,_tensorConditionRefValue:{type:Number,value:0,notify:!0},_isRefValueInputHidden:{type:Boolean,value:!0,
notify:!0}},observers:["_onSelectedTensorConditionChanged(_selectedTensorCondition)"],notifyContinuationStop(){this.updateContinueButtonText(!1)},_openDialog(){this.$.continueDialog.open()},_closeDialog(){this.$.continueDialog.close()},_continueButtonCallback(){this._continueButtonText===this._continueButtonStopText?this.forceContinuationStop():this._openDialog()},updateContinueButtonText(b){this.set("_continueButtonText",b?this._continueButtonStopText:this._continueButtonContinueText)},_sessionRunGoButtonCallback(){0<
this.continueNum?(this.sessionRunGo(this.continueNum),this.updateContinueButtonText(!0),this._closeDialog()):this.set("continueNum",1)},_tensorContinueGoButtonCallback(){if(null!=this._selectedTensorCondition){var b=Vi.tensorConditionDescription2Key(this._selectedTensorCondition);null==b&&console.error("Invalid Tensor Condition name:"+this._selectedTensorCondition);var d=Number(this._tensorConditionRefValue);Number.isFinite(d)?(this.tensorConditionGo(b,d),this.updateContinueButtonText(!0),this._closeDialog()):
this.set("_tensorConditionRefValue",0)}},_onSelectedTensorConditionChanged(b){b=Vi.tensorConditionDescription2Key(b);this.set("_isRefValueInputHidden",-1!==["INF_OR_NAN","INF","NAN"].indexOf(b))}});

//# sourceURL=build://tf-debugger-dashboard/tf-debugger-initial-dialog.html.js
Polymer({is:"tf-debugger-initial-dialog",properties:{_title:{type:String,value:null},_customMessage:{type:String,value:null},_hasCustomMessage:{type:Boolean,computed:"_computeHasCustomMessage(_customMessage)"},_host:{type:String,value:null},_port:{type:String,value:null},_open:{type:Boolean},_hidden:{type:Boolean,computed:"_computeHidden(_open)",reflectToAttribute:!0}},openDialog(b,d){this.set("_title","Debugger is waiting for Session.run() connections...");this.set("_customMessage",null);this.$.dialog.open();
null!=b&&null!=d&&(this.set("_host",b),this.set("_port",d))},closeDialog(){this.$.dialog.close()},openDisabledDialog(){this.set("_title","Debugger is not enabled in this TensorBoard instance");this.set("_customMessage","To enable the debugger in TensorBoard, use the flag: --debugger_port \x3cport_number\x3e");this.$.dialog.open()},_computeHidden(b){return!b},_computeHasCustomMessage(b){return!_.isEmpty(b)}});

//# sourceURL=build://tf-debugger-dashboard/tf-debugger-resizer.html.js
Polymer({is:"tf-debugger-resizer",properties:{currentLength:{type:Number,notify:!0},minLength:Number,maxLength:Number,isHorizontal:{type:Boolean,value:!1,reflectToAttribute:!0},_resizerIdentifier:{type:Boolean,value:!0,readOnly:!0,reflectToAttribute:!0},_isVertical:{type:Boolean,computed:"_computeIsVertical(isHorizontal)",reflectToAttribute:!0,readOnly:!0},_dragStartPosition:Number,_dragStartLength:Number,_previousMouseMoveCallback:Object,_previousMouseUpCallback:Object},listeners:{mousedown:"_handleMouseDown"},
_handleMouseDown(b){b.preventDefault();this._endDrag();this._previousMouseMoveCallback=d=>{d.preventDefault();d=this._dragStartLength+(this._getPositionRelativeToViewport(d)-this._dragStartPosition);d=Math.max(d,this.minLength);d=Math.min(d,this.maxLength);this.set("currentLength",d)};this._previousMouseUpCallback=d=>{d.preventDefault();this._endDrag()};this.set("_dragStartPosition",this._getPositionRelativeToViewport(b));this.set("_dragStartLength",this.currentLength);window.addEventListener("mouseup",
this._previousMouseUpCallback,!1);window.addEventListener("mousemove",this._previousMouseMoveCallback,!1)},_getPositionRelativeToViewport(b){return this.isHorizontal?b.clientY:b.clientX},_endDrag(){window.removeEventListener("mousemove",this._previousMouseMoveCallback,!1);this._previousMouseMoveCallback=null;window.removeEventListener("mouseup",this._previousMouseUpCallback,!1);this._previousMouseUpCallback=null},_computeIsVertical(b){return!b}});

//# sourceURL=build://tf-debugger-dashboard/selection-tree-node.js
(function(b){b.NODE_NAME_SEPARATOR="/";b.DEVICE_NAME_PATTERN=/^\/job:[A-Za-z0-9_]+\/replica:[0-9_]+\/task:[0-9]+\/device:[A-Za-z0-9_]+:[0-9]+/;let d;(function(k){k[k.EMPTY=0]="EMPTY";k[k.CHECKED=1]="CHECKED";k[k.PARTIAL=2]="PARTIAL"})(d=b.CheckboxState||(b.CheckboxState={}));b.splitNodeName=function(k){let t=[];const l=k.match(b.DEVICE_NAME_PATTERN);null!=l&&(t.push(l[0]),"/"!==k[l[0].length]&&console.error('No slash ("/") after device name in node name:',k),k=k.slice(l[0].length+1));return t.concat(k.split(b.NODE_NAME_SEPARATOR))};
b.getCleanNodeName=function(k){let t=k;const l=k.match(b.DEVICE_NAME_PATTERN);null!=l?(t.length>l[0].length&&"/"!=t[l[0].length]&&console.error('No slash ("/") after device name in node name:',k),t=t.slice(l[0].length+1)):"/"===t[0]&&(t=t.slice(1));t.indexOf(")")===t.length-1&&(t=t.slice(0,t.indexOf("/(")));return t};b.sortAndBaseExpandDebugWatches=function(k){k.sort((l,p)=>l.node_name<p.node_name?-1:l.node_name>p.node_name?1:l.output_slot-p.output_slot);for(let l=0;l<k.length;++l){var t=k[l].node_name+
"/";let p=!1;for(let m=l+1;m<k.length;++m)if(0===k[m].node_name.indexOf(t)){p=!0;break}p&&(t=k[l].node_name.split("/"),k[l].node_name+="/("+t[t.length-1]+")")}};b.removeNodeNameBaseExpansion=function(k){return k.endsWith(")")?k.slice(0,k.lastIndexOf("/(")):k};b.assembleDeviceAndNodeNames=function(k){const t=[null,null];if(k[0].match(b.DEVICE_NAME_PATTERN)){let l=k[0];"/"===l[l.length-1]&&(l=l.slice(0,l.length-1));t[0]=l;t[1]=k.slice(1).join("/")}else t[1]=k.join("/");return t};let f;(function(k){k[k.NodeName=
0]="NodeName";k[k.OpType=1]="OpType"})(f=b.DebugWatchFilterMode||(b.DebugWatchFilterMode={}));b.filterDebugWatches=function(k,t,l){if(t===f.NodeName)return k.filter(p=>p.node_name.match(l));if(t===f.OpType)return k.filter(p=>p.op_type.match(l))};class h{constructor(k,t,l,p){this.debugWatchChange=t;this.debugWatch=p;this.name=k;this.debugWatch=p;this.checkboxState=d.EMPTY;this.parent=l;this.children={};this.checkbox=document.createElement("paper-checkbox");this.checkbox.addEventListener("change",()=>
{this._handleChange()},!1)}_handleChange(){if(this.avoidPropagation)this.debugWatch&&this.debugWatchChange(this.debugWatch,this.isCheckboxChecked());else if(this.debugWatch)this.setCheckboxState(this.isCheckboxChecked()?d.CHECKED:d.EMPTY,!0),this.isCheckboxChecked()?this.setNodesAboveToChecked():this.setNodesAboveToEmpty(),this.debugWatchChange(this.debugWatch,this.isCheckboxChecked());else if(this.setCheckboxState(this.isCheckboxChecked()?d.CHECKED:d.EMPTY,!0),this.isCheckboxChecked()){const t=_.values(this.children);
for(;t.length;){var k=t.pop();_.forEach(k.children,l=>t.push(l));k.setCheckboxState(d.CHECKED,!0)}this.setNodesAboveToChecked()}else{const t=_.values(this.children);for(;t.length;)k=t.pop(),_.forEach(k.children,l=>t.push(l)),k.setCheckboxState(d.EMPTY,!0);this.setNodesAboveToEmpty()}}isLeaf(){return!!this.debugWatch}setToAllCheckedExternally(){this.setCheckboxState(d.CHECKED);this._handleChange()}setCheckboxState(k,t){this.avoidPropagation=t;this.checkboxState=k;this.checkbox.classList.toggle("partial-checkbox",
k===d.PARTIAL);k===d.CHECKED?this.checkbox.setAttribute("checked","checked"):this.checkbox.removeAttribute("checked");this.avoidPropagation=!1}isCheckboxChecked(){return this.checkbox.hasAttribute("checked")}setNodesAboveToChecked(){let k=this.parent,t=!1;for(;k;)t?k.setCheckboxState(d.PARTIAL,!0):(t=-1!==_.findIndex(_.values(k.children),l=>l.checkboxState!==d.CHECKED),k.setCheckboxState(t?d.PARTIAL:d.CHECKED,!0)),k=k.parent}setNodesAboveToEmpty(){let k=this.parent,t=!1;for(;k;)t?k.setCheckboxState(d.PARTIAL,
!0):(t=-1!==_.findIndex(_.values(k.children),l=>l.checkboxState!==d.EMPTY),k.setCheckboxState(t?d.PARTIAL:d.EMPTY,!0)),k=k.parent}setLevelDom(k){this.levelDom=k}}b.SelectionTreeNode=h})(Vi||(Vi={}));

//# sourceURL=build://tf-debugger-dashboard/tf-op-selector.html.js
Polymer({is:"tf-op-selector",properties:{debugWatches:Array,debugWatchChange:Object,nodeClicked:Function,forceExpandAndCheckNodeName:{type:String,value:null},forceExpandNodeName:{type:String,value:null},_selectedDebugWatchMapping:{type:Object,value:()=>({})},_levelName2Container:{type:Object,value:null},_levelName2Node:{type:Object,value:null},_watchHierarchy:{type:Object,computed:"_computeWatchHierarchy(debugWatches, debugWatchChange, _filterMode, _filterInput)"},_filterMode:{type:String,value:"Node Name",
notify:!0},_filterInput:{type:String,value:"",notify:!0},_isLoading:{type:Boolean,value:!1},_highlightedLevelDom:{type:Object,value:null}},observers:["_renderHierarchyWithTimeout(_watchHierarchy, debugWatchChange)","_handleForceNodeExpandAndCheck(forceExpandAndCheckNodeName)","_handleForceNodeExpand(forceExpandNodeName)"],_computeWatchHierarchy(b,d,f,h){h=h.trim();let k=b;null!=f&&0<h.length&&(k=Vi.filterDebugWatches(b,Vi.DebugWatchFilterMode[f.replace(/\s/g,"")],new RegExp(h)));const t=new Vi.SelectionTreeNode("",
d);t.isRoot=!0;_.forEach(k,l=>{const p=Vi.splitNodeName(l.device_name+"/"+l.node_name);let m=t;_.forEach(p,(n,q)=>{q===p.length-1?(q=new Vi.SelectionTreeNode(n,d,m,l),m.children[n]=q):(m.children[n]||(m.children[n]=new Vi.SelectionTreeNode(n,d,m)),m=m.children[n])})});return t},_clearSelectorHierarchy(){const b=this.$$("#selector-hierarchy");for(;b.firstChild;)b.removeChild(b.firstChild)},_renderHierarchyWithTimeout(b,d,f,h){this._isLoading||(this.set("_isLoading",!0),this._clearSelectorHierarchy(),
setTimeout(()=>{this._renderHierarchy(b,d,f,h)},10))},_renderHierarchy(b,d){this.set("_levelName2Container",{});this.set("_levelName2Node",{});b=this._renderLevel(null,null,b,d);Polymer.dom(this.$$("#selector-hierarchy")).appendChild(b);this.set("_isLoading",!1)},_renderLevel(b,d,f,h){const k=document.createElement("div");null!=b&&k.setAttribute("level-name",b);let t;t=null==d?b:d+"/"+b;Polymer.dom(k).classList.add("level-container");const l=document.createElement("iron-collapse");if(b){this._levelName2Container[t]=
l;l.removeAttribute("opened");Polymer.dom(k).classList.add("indented-level-container");d=document.createElement("div");Polymer.dom(d).classList.add("level-title");const n=document.createElement("paper-icon-button");Polymer.dom(n).classList.add("node-expand-button");const q=()=>{n.setAttribute("icon",l.hasAttribute("opened")?"expand-less":"expand-more")};n.addEventListener("click",()=>{l.hasAttribute("opened")?l.removeAttribute("opened"):l.setAttribute("opened",!0);q()},!1);q();Polymer.dom(d).appendChild(n);
Polymer.dom(d).appendChild(f.checkbox);f.setLevelDom(d);const u=document.createElement("span");Polymer.dom(u).classList.add("level-title-text");u.textContent=b;Polymer.dom(d).appendChild(u);Polymer.dom(k).appendChild(d);(b.match(Vi.DEVICE_NAME_PATTERN)||1===Object.keys(f.children).length)&&l.setAttribute("opened",!0)}else l.setAttribute("opened",!0);const p=[],m=[];Polymer.dom(l).classList.add("content-container");_.forEach(f.children,(n,q)=>{const u=n.debugWatch;var x=t;null==t&&(x="");x+="/"+q;
this._levelName2Node[x]=n;null!=this._selectedDebugWatchMapping[x]&&(n.setCheckboxState(Vi.CheckboxState.CHECKED),n.setNodesAboveToChecked());if(u){x=document.createElement("div");Polymer.dom(x).classList.add("op-description");n.checkbox.addEventListener("change",y=>{this._handleLeafNodeSelected(h,u,y.target.checked)},!1);Polymer.dom(x).appendChild(n.checkbox);n.setLevelDom(x);var A=document.createElement("span");A.textContent="["+u.op_type+"]";A.setAttribute("class","op-type");Polymer.dom(x).appendChild(A);
A=document.createElement("span");A.textContent=q;A.setAttribute("class","op-title-leaf");A.addEventListener("click",()=>{const y=this._getDeviceAndNodeNames(q,k);this.nodeClicked(y[0],y[1])},!1);Polymer.dom(x).appendChild(A);m.push(x)}else n.checkbox.addEventListener("change",y=>{this._handleMetaNodeChange(n,h,y.target.checked)}),p.push(this._renderLevel(q,t,n,h))});b=n=>{Polymer.dom(l).appendChild(n)};_.forEach(m,b);_.forEach(p,b);Polymer.dom(k).appendChild(l);return k},_getLeafDebugWatches(b,d){b.debugWatch?
d.push(b.debugWatch):_.forEach(b.children,f=>{this._getLeafDebugWatches(f,d)})},_getDeviceAndNodeNames(b,d){for(b=[b];;){const f=d.getAttribute("level-name");if(null==f)break;else b.push(f);d=Polymer.dom(d).parentNode.parentNode}b.reverse();return Vi.assembleDeviceAndNodeNames(b)},_handleMetaNodeChange(b,d,f){let h=[];this._getLeafDebugWatches(b,h);_.forEach(h,k=>{this._handleLeafNodeSelected(d,k,f)})},_handleLeafNodeSelected(b,d,f){const h=d.device_name+"/"+d.node_name;f?this._selectedDebugWatchMapping[h]=
d:delete this._selectedDebugWatchMapping[h];b(d,f)},_handleForceNode(b,d){this.set("_filterInput","");setTimeout(()=>{if(null!=b&&null!=this._levelName2Container){var f=Vi.splitNodeName(b);for(let k=1;k<=f.length;++k){var h=f.slice(0,k).join("/");const t=this._levelName2Node[h];null!=t&&null!=t.levelDom&&t.levelDom.scrollIntoView({block:"center",behaviour:"smooth"});k<f.length?null!=this._levelName2Container[h]&&this._levelName2Container[h].setAttribute("opened",!0):(t.debugWatch||this._handleMetaNodeChange(t,
t.debugWatchChange,!0),d&&(t.setToAllCheckedExternally(),(h=t.debugWatch)&&null==this._selectedDebugWatchMapping[h.node_name]&&(this._selectedDebugWatchMapping[b]=h)),null!=this._highlightedLevelDom&&this._highlightedLevelDom.classList.remove("highlighted"),t.levelDom.classList.add("highlighted"),this.set("_highlightedLevelDom",t.levelDom))}}},20)},_handleForceNodeExpandAndCheck(b){this._handleForceNode(b,!0)},_handleForceNodeExpand(b){this._handleForceNode(b,!1)}});

//# sourceURL=build://tf-debugger-dashboard/tf-session-runs-view.html.js
Polymer({is:"tf-session-runs-view",properties:{latestSessionRun:Object,sessionRunKeyToDeviceNames:Object,soleActive:Boolean,nodeOrTensorClicked:Function,_runKey2Count:{type:Object,value:{}},_runKey2NumDevices:{type:Object,value:{}},_activeRunKey:String},observers:["renderLatest(latestSessionRun)","setSoleActiveStatus(soleActive)"],renderLatest(b){b=JSON.stringify(b);this._runKey2Count[b]=void 0===this._runKey2Count[b]?1:this._runKey2Count[b]+1;void 0===this._runKey2NumDevices[b]&&(this._runKey2NumDevices[b]=
0);this._activeRunKey=b;this._renderSessionRunTable()},updateNumDevices(b){null!=this._activeRunKey&&(this._runKey2NumDevices[this._activeRunKey]=b,this._renderSessionRunTable())},setSoleActiveStatus(){this._renderSessionRunTable()},_renderSessionRunTable(){this._clearTable();this._renderHeader();let b;for(const f in this._runKey2Count)if(this._runKey2Count.hasOwnProperty(f)){var d=JSON.parse(f);(d=this._renderRow(d,this._runKey2NumDevices[f],this._runKey2Count[f],this._activeRunKey===f,this.soleActive))&&
(b=d)}b&&(Polymer.dom(this.$$("#session-runs-table")).parentNode.parentNode.scrollTop=b.offsetTop)},_clearTable(){const b=this.$$("#session-runs-table");for(;b.firstChild;)b.removeChild(b.firstChild)},_renderHeader(){const b=document.createElement("tr"),d=document.createElement("th");d.textContent="Feeds";const f=document.createElement("th");f.textContent="Fetches";const h=document.createElement("th");h.textContent="Targets";const k=document.createElement("th");k.textContent="#(Devices)";const t=
document.createElement("th");t.textContent="Count";b.appendChild(d);b.appendChild(f);b.appendChild(h);b.appendChild(k);b.appendChild(t);Polymer.dom(this.$$("#session-runs-table")).appendChild(b)},_renderRow(b,d,f,h,k){const t=document.createElement("tr"),l=this._renderGraphElements(b.feeds),p=this._renderGraphElements(b.fetches);b=this._renderGraphElements(b.targets);const m=document.createElement("td");m.textContent=d;d=document.createElement("td");d.textContent=f;t.appendChild(l);t.appendChild(p);
t.appendChild(b);t.appendChild(m);t.appendChild(d);h&&(k?t.setAttribute("class","sole-active-session-run"):t.setAttribute("class","active-session-run"));Polymer.dom(this.$$("#session-runs-table")).appendChild(t);if(h)return t},_renderGraphElements(b){const d=document.createElement("td");_.forEach(b,f=>{const h=document.createElement("div");h.textContent=f;h.setAttribute("class","node-or-tensor-element");h.addEventListener("click",()=>{this.nodeOrTensorClicked(f)});d.appendChild(h)});return d}});

//# sourceURL=build://tf-debugger-dashboard/tf-source-code-view.html.js
Polymer({is:"tf-source-code-view",properties:{requestManager:{type:Object,value:null},focusNodeName:{type:String,value:null},_oldFocusNodeName:{type:String,value:null},debugWatches:{type:Array,value:[]},nodeClicked:{type:Function,value:null},continueToNode:{type:Function,value:null},_highlightedElements:{type:Array,value:[]},_filePathSelected:Number,_fullFilePaths:{type:Array,value:null},_shortFilePaths:{type:Array,value:null},_fileLines:{type:Array,value:null},_nodeName2DeviceName:{type:Object,value:null},
_nodeName2BaseExpandedNodeName:{type:Object,value:null},_nodeName2NodeElements:{type:Object,value:null},_nodeName2StackTopNodeElement:{type:Object,value:null},_setHightlightOriginNodeElement:{type:Object,value:null},_fullStackShown:{type:Boolean,value:!1},_fullStackNodeName:{type:String,value:null},_renderDelayMillis:{type:Number,value:50,readonly:!0}},observers:["_renderFile(_filePathSelected)","_focusOnNode(focusNodeName)"],render(b){null!=b&&this.set("_debugWatches",b);this._querySourceCodeEndPoint({mode:"paths"}).then(d=>
{this.set("_fullFilePaths",d.paths);const f=d.paths.map(h=>({id:h,name:this._shortenPath(h,d.paths)}));this.set("_shortFilePaths",f);0<f.length&&this.set("_filePathSelected",0)})},_shortenPath(b){b=b.replace(/\\/g,"/");b=b.split("/");return b[b.length-1]},_renderFile(b){if(null!=b){var d=this._shortFilePaths[b].id;this._querySourceCodeEndPoint({mode:"content",file_path:d}).then(f=>{const h=[],k=f.content[d],t=f.lineno_to_op_name_and_stack_pos;f={};for(var l in t)t.hasOwnProperty(l)&&(f[l]=t[l].length);
this._filterFileTracebacksByDebugWatches(t);for(l=0;l<k.length;++l){const m=l+1;h.push({lineno:m,numNodes:null!=t[m]?String(t[m].length)+"/"+String(f[m])+" \u25bc":"",text:this._htmlEscape(k[l])})}this.set("_fileLines",h);const p=this;setTimeout(()=>{const m={},n={};for(const u in t){if(!t.hasOwnProperty(u))continue;for(var q=p.$$("#source-line-nodes-"+u);q.firstChild;)q.removeChild(q.firstChild);const x=t[u];x.sort(function(A,y){return A[0]<y[0]?-1:A[0]>y[0]?1:0});for(let A=0;A<x.length;++A){const y=
x[A][0],w=x[A][1],C=document.createElement("div"),G=document.createElement("span");G.setAttribute("class","source-line-node-enttry");G.setAttribute("sourceLineno",u);G.textContent=y;G.addEventListener("tap",()=>{this.nodeClicked(this._nodeName2DeviceName[y],this._nodeName2BaseExpandedNodeName[y],!0)});const D=document.createElement("paper-icon-button");D.setAttribute("icon","filter-list");D.setAttribute("title","Show stack");D.addEventListener("tap",()=>{this._highlightNodeElements(y);this.set("_fullStackNodeName",
y);this.set("_fullStackShown",!0);this._populateFullStack(y,this._fullFilePaths[this._filePathSelected],Number(u))});const B=document.createElement("paper-icon-button");B.setAttribute("icon","forward");B.setAttribute("title","Continue to");B.addEventListener("tap",()=>{this.nodeClicked(this._nodeName2DeviceName[y],this._nodeName2BaseExpandedNodeName[y],!0);const I=this._nodeName2DeviceName[y],N=this._nodeName2BaseExpandedNodeName[y];this.set("_setHightlightOriginNodeElement",G);this.continueToNode(I,
N)});C.appendChild(D);C.appendChild(B);C.appendChild(G);q.appendChild(C);m.hasOwnProperty(y)||(m[y]=[]);m[y].push(G);n.hasOwnProperty(y)||(n[y]=[G,w]);w>n[y][1]&&(n[y]=[G,w])}q.setAttribute("hidden",!0);q=p.$$("#source-line-node-toggle-"+u);null==q.getAttribute("tapCallbackSet")&&(q.addEventListener("tap",()=>{p._toggleLineNodes(Number(u))}),q.setAttribute("tapCallbackSet",!0))}p.set("_nodeName2NodeElements",m);for(const u in n)n.hasOwnProperty(u)&&(n[u]=n[u][0]);p.set("_nodeName2StackTopNodeElement",
n)},this._renderDelayMillis)})}},_toggleLineNodes(b,d=!1){b=this.$$("#source-line-nodes-"+b);null==b.getAttribute("hidden")&&!0!==d?b.setAttribute("hidden",!0):b.removeAttribute("hidden")},_filterFileTracebacksByDebugWatches(b){const d=this.debugWatches.map(k=>Vi.removeNodeNameBaseExpansion(k.node_name)),f={},h={};for(const k of this.debugWatches){const t=Vi.removeNodeNameBaseExpansion(k.node_name);f[t]=k.device_name;h[t]=k.node_name}this.set("_nodeName2DeviceName",f);this.set("_nodeName2BaseExpandedNodeName",
h);for(const k in b)b.hasOwnProperty(k)&&(b[k]=b[k].filter(t=>_.includes(d,t[0])))},_querySourceCodeEndPoint(b){const d=vc.getRouter().pluginRoute("debugger","/source_code");b=vc.addParams(d,b);return this.requestManager.request(b)},_htmlEscape(b){return b.replace(/ /g,"\u00a0")},_focusOnNode(b){if(null!=b){var d=this._shortFilePaths[this._filePathSelected].id,f=this;this._querySourceCodeEndPoint({mode:"op_traceback",op_name:b}).then(h=>{const k=h.op_traceback[b];h=[];for(let l=0;l<k.length;++l){const p=
k[l][1];k[l][0]===d&&h.push(p)}for(var t of f._highlightedElements)t.classList.remove("highlighted-source-line");t=[];for(const l of h)h=this.$$("#source-line-"+l),t.push(h),h.classList.add("highlighted-source-line"),f._toggleLineNodes(l,!0);f.set("_highlightedElements",t);this._highlightNodeElements(b)})}},_highlightNodeElements(b){if(null!=this._oldFocusNodeName)for(const d of this._nodeName2NodeElements[this._oldFocusNodeName])d.style["font-weight"]="normal";for(const d of this._nodeName2NodeElements[b])d.style["font-weight"]=
"bold";null==this._setHightlightOriginNodeElement?this._nodeName2StackTopNodeElement[b].scrollIntoView({block:"center",behaviour:"smooth"}):this.set("_setHightlightOriginNodeElement",null);this.set("_oldFocusNodeName",b)},_populateFullStack(b,d,f){this._querySourceCodeEndPoint({mode:"op_traceback",op_name:b}).then(h=>{const k=this.$$("#full-stack-content");for(;k.firstChild;)k.removeChild(k.firstChild);for(const t of h.op_traceback[b]){const l=document.createElement("li"),p=t[0],m=Number(t[1]);l.textContent=
p+": "+String(m);_.includes(this._fullFilePaths,p)?(l.classList.add("stack-frame-clickable"),l.style.color="blue",l.style["text-decoration"]="underline",l.style.cursor="pointer",p===d&&m===f&&(l.style["font-weight"]="bold"),l.addEventListener("tap",()=>{this.set("_filePathSelected",this._fullFilePaths.indexOf(p));setTimeout(()=>{this._toggleLineNodes(m,!0);for(const n of this._nodeName2NodeElements[b])Number(n.getAttribute("sourceLineno"))===Number(m)&&(n.scrollIntoView({block:"center",behaviour:"smooth"}),
this.set("_setHightlightOriginNodeElement",l),this._highlightNodeElements(b),d===p&&f===m||this._populateFullStack(b,p,m))},2*this._renderDelayMillis)})):(l.classList.add("stack-frame-nonclickable"),l.style.color="#555");k.appendChild(l)}})},_closeFullStackDialog(){this.set("_fullStackShown",!1)}});

//# sourceURL=build://tf-debugger-dashboard/tf-tensor-data-summary.html.js
Polymer({is:"tf-tensor-data-summary",properties:{latestTensorData:Object,expandHandler:Object,continueToCallback:Function,highlightedNodeName:{type:String,value:null},tensorNameClicked:{type:Function,value:null},getHealthPill:Function,_healthPillsEnabled:{type:Boolean,value:!0,notify:!0},_watchKeys:{type:Array,value:[]},_watchKey2Data:{type:Object,value:{}},_watchKey2Count:{type:Object,value:{}},_watchKey2ExpandHandler:{type:Object,value:{}},_watchKey2ValueShort:{type:Object,value:{}},_watchKey2Row:{type:Object,
value:{}},_activeWatchKey:String,_healthPillWidth:{type:Number,value:200,readonly:!0},_healthPillHeight:{type:Number,value:32,readonly:!0}},observers:["_renderLatest(latestTensorData, expandHandler)","_highlight(highlightedNodeName)"],listeners:{"show-health-pills.change":"_showHealthPillsChanged"},ready(){this._renderHealthPillLegend()},enableHealthPills(){this.set("_healthPillsEnabled",!0);this._renderHealthPillLegend()},_showHealthPillsChanged(){this._healthPillsEnabled?this._renderHealthPillLegend():
this._clearHealthPillLegend();this._renderAll()},_renderAll(){this._clearTensorDataTable();for(const b of this._watchKeys)this._renderLatest(this._watchKey2Data[b],this._watchKey2ExpandHandler[b])},_tensorData2WatchKey(b){return b.deviceName+"/"+b.tensorName+":"+b.debugOp},_renderLatest(b,d){if(b){var f=this._tensorData2WatchKey(b),h=null;"Uninitialized"!==b.dtype&&"Unsupported"!==b.dtype&&(h=()=>d(b));var k=null!=b.value?JSON.stringify(b.value,(t,l)=>l.toFixed?Number(l.toFixed(3)):l):"(Click to view)";
this._watchKey2Data[f]=b;-1===this._watchKeys.indexOf(f)?(this._watchKeys.push(f),this._watchKey2Count[f]=1):this._watchKey2Count[f]+=1;this._watchKey2ExpandHandler[f]=h;this._watchKey2ValueShort[f]=k;this._activeWatchKey=f;this._removeActiveStatusFromAllRows();this._renderRow(f)}},_clearTensorDataTable(){for(const b in this._watchKey2Row)this._watchKey2Row.hasOwnProperty(b)&&(this._watchKey2Row[b].remove(),delete this._watchKey2Row[b])},_clearTensorDataRow(b){for(;b.firstChild;)b.removeChild(b.firstChild)},
_clearHealthPillLegend(){const b=this.$$("#health-pill-legend");for(;b.firstChild;)b.removeChild(b.firstChild)},_renderHealthPillLegend(){this._clearHealthPillLegend();const b=this.$$("#health-pill-legend");var d=document.createElement("div");d.textContent="Legend:";b.appendChild(d);d.style["margin-right"]="0.5em";d.style.display="inline-block";for(d=0;d<tf.graph.scene.healthPillEntries.length;++d){const f=tf.graph.scene.healthPillEntries[d],h=document.createElement("div");h.style.display="inline-block";
h.style["margin-right"]="0.25em";const k=document.createElement("span");k.textContent="\u25a0";k.style.color=f.background_color;const t=document.createElement("span");t.textContent=f.label;t.style.color=f.background_color;h.appendChild(k);h.appendChild(t);b.appendChild(h)}},_removeActiveStatusFromAllRows(){for(const b in this._watchKey2Row){if(!this._watchKey2Row.hasOwnProperty(b))continue;const d=this._watchKey2Row[b];Polymer.dom(d).classList.remove("active-tensor");Polymer.dom(d).classList.remove("highlighted")}},
_renderRow(b){let d,f=!1;null!=this._watchKey2Row[b]?(d=this._watchKey2Row[b],this._clearTensorDataRow(d),f=!1):(d=document.createElement("tr"),f=!0);const h=this._watchKey2Data[b].deviceName,k=this._watchKey2Data[b].maybeBaseExpandedNodeName,t=h+"/"+k;var l=this._watchKey2Count[b],p=this._watchKey2Data[b].tensorName,m=this._watchKey2Data[b].debugOp,n=this._watchKey2ValueShort[b];const q=this._watchKey2ExpandHandler[b],u=b===this._activeWatchKey,x=document.createElement("td");Polymer.dom(x).classList.add("tensor-name");
x.style["text-decoration"]="underline";x.style.cursor="pointer";x.textContent=p;x.addEventListener("tap",()=>{null!=this.tensorNameClicked&&this.tensorNameClicked(h,k)});const A=document.createElement("td");A.textContent=l;const y=this._watchKey2Data[b].dtype;l=document.createElement("td");const w=this._watchKey2Data[b].shape;l.textContent=y;const C=document.createElement("td");C.textContent=JSON.stringify(w);const G=document.createElement("td");G.textContent=n;Polymer.dom(G).classList.add("value-expansion-link");
null!=q&&(G.addEventListener("tap",q,!1),G.style["text-decoration"]="underline",G.style.cursor="pointer");n=null;n=this._healthPillsEnabled?this._renderHealthPill(p+":"+m,{device_name:h,node_name:k,dtype:y,shape:w,value:null},q):document.createElement("td");p=document.createElement("td");m=document.createElement("paper-icon-button");m.setAttribute("icon","forward");m.setAttribute("title","Continue to");m.addEventListener("click",()=>{this.continueToCallback(h,k)});p.appendChild(m);d.appendChild(x);
d.appendChild(A);d.appendChild(l);d.appendChild(C);d.appendChild(G);d.appendChild(n);d.appendChild(p);d.setAttribute("nodeNameWithDevice",t);u&&(Polymer.dom(d).classList.add("active-tensor"),Polymer.dom(d).classList.add("highlighted"));this._watchKey2Row[b]=d;f&&Polymer.dom(this.$$("#tensor-data-table tbody")).appendChild(d);d.scrollIntoView({block:"end",inline:"nearest",behaviour:"smooth"})},_renderHealthPill(b,d,f){const h=document.createElement("td");Polymer.dom(h).classList.add("health-pill");
null!=f&&h.addEventListener("tap",f,!1);f=document.createElementNS(tf.graph.scene.SVG_NAMESPACE,"svg");f.setAttribute("width",this._healthPillWidth);f.setAttribute("height",this._healthPillHeight);const k=document.createElementNS(tf.graph.scene.SVG_NAMESPACE,"g");f.appendChild(k);h.appendChild(f);const t="tdp/"+b;this.getHealthPill(b,d.device_name,d.node_name,l=>{null==l?(h.textContent="N/A",h.style.color="gray"):(d.value=l,tf.graph.scene.addHealthPill(k,d,null,t,this._healthPillWidth,this._healthPillHeight/
2,this._healthPillHeight/2,0))});return h},_highlight(b){Polymer.dom(this.$$("#tensor-data-table"));const d=[];for(const f in this._watchKey2Row){if(!this._watchKey2Row.hasOwnProperty(f))continue;const h=this._watchKey2Row[f];null!=h.getAttribute&&(h.getAttribute("nodeNameWithDevice")===b?d.push(h):Polymer.dom(h).classList.remove("highlighted"))}if(null!=b)for(b=0;b<d.length;++b)Polymer.dom(d[b]).classList.add("highlighted"),d[b].scrollIntoView({block:"end",inline:"nearest",behaviour:"smooth"})}});

//# sourceURL=build://tensor-widget/tensor_widget_binary.js
var Wi=this&&this.__extends||function(){function b(d,f){b=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(h,k){h.__proto__=k}||function(h,k){for(var t in k)k.hasOwnProperty(t)&&(h[t]=k[t])};return b(d,f)}return function(d,f){function h(){this.constructor=d}b(d,f);d.prototype=null===f?Object.create(f):(h.prototype=f.prototype,new h)}}(),Xi=this&&this.__generator||function(b,d){function f(n){return function(q){return h([n,q])}}function h(n){if(t)throw new TypeError("Generator is already executing.");
for(;k;)try{if(t=1,l&&(p=n[0]&2?l["return"]:n[0]?l["throw"]||((p=l["return"])&&p.call(l),0):l.next)&&!(p=p.call(l,n[1])).done)return p;if(l=0,p)n=[n[0]&2,p.value];switch(n[0]){case 0:case 1:p=n;break;case 4:return k.label++,{value:n[1],done:!1};case 5:k.label++;l=n[1];n=[0];continue;case 7:n=k.ops.pop();k.trys.pop();continue;default:if(!(p=k.trys,p=0<p.length&&p[p.length-1])&&(6===n[0]||2===n[0])){k=0;continue}if(3===n[0]&&(!p||n[1]>p[0]&&n[1]<p[3]))k.label=n[1];else if(6===n[0]&&k.label<p[1])k.label=
p[1],p=n;else if(p&&k.label<p[2])k.label=p[2],k.ops.push(n);else{p[2]&&k.ops.pop();k.trys.pop();continue}}n=d.call(b,k)}catch(q){n=[6,q],l=0}finally{t=p=0}if(n[0]&5)throw n[1];return{value:n[0]?n[1]:void 0,done:!0}}var k={label:0,sent:function(){if(p[0]&1)throw p[1];return p[1]},trys:[],ops:[]},t,l,p,m;return m={next:f(0),"throw":f(1),"return":f(2)},"function"===typeof Symbol&&(m[Symbol.iterator]=function(){return this}),m},Yi=this&&this.__read||function(b,d){var f="function"===typeof Symbol&&b[Symbol.iterator];
if(!f)return b;b=f.call(b);var h,k=[];try{for(;(void 0===d||0<d--)&&!(h=b.next()).done;)k.push(h.value)}catch(l){var t={error:l}}finally{try{h&&!h.done&&(f=b["return"])&&f.call(b)}finally{if(t)throw t.error;}}return k};
(function(){function b(H,K,M,L){return new (M||(M=Promise))(function(Q,T){function X(Z){try{la(L.next(Z))}catch(ba){T(ba)}}function aa(Z){try{la(L["throw"](Z))}catch(ba){T(ba)}}function la(Z){Z.done?Q(Z.value):(new M(function(ba){ba(Z.value)})).then(X,aa)}la((L=L.apply(H,K||[])).next())})}function d(H){return null!==H.match(/^int[0-9]+$/)||null!==H.match(/^uint[0-9]+$/)}function f(H){return null!==H.match(/^float[0-9]+$/)||null!==H.match(/^bfloat[0-9]+$/)}function h(H){return"bool"===H.toLowerCase()||
"boolean"===H.toLowerCase()}function k(H){return"str"===H.toLowerCase()||"string"===H.toLowerCase()}function t(H){var K=1;H.forEach(function(M){K*=M});return K}function l(H){return 0===H.length?"scalar":"["+H+"]"}function p(H){var K={slicingDimsAndIndices:[],viewingDims:[],verticalRange:null,horizontalRange:null},M=H.length;if(1===M)K.viewingDims=[0];else if(1<M){if(2<M)for(var L=0;L<M-2;++L)K.slicingDimsAndIndices.push({dim:L,index:0===H[L]?null:0});for(L=H.length-2;L<H.length;++L)K.viewingDims.push(L)}return K}
function m(H,K){if(H.viewingDims[0]!==K.viewingDims[0]||H.viewingDims[1]!==K.viewingDims[1])return!1;K=H.slicingDimsAndIndices.map(function(M){return M.dim});K.sort();H=H.slicingDimsAndIndices.map(function(M){return M.dim});H.sort();return JSON.stringify(K)===JSON.stringify(H)}function n(H){return 20>=H.length?H:H.slice(0,10)+"..."+H.slice(H.length-7,H.length)}function q(H,K,M,L){void 0===M&&(M=2);if(isNaN(H))return"NaN";if(-Infinity===H)return"-\u221e";if(Infinity===H)return"+\u221e";null==L&&(L=
Math.abs(H),L=1E3>L&&.01<=L||0===L?"fixed":"exponential");return null==L||"fixed"===L?K?""+H:H.toFixed(M):H.toExponential(M)}function u(H,K){void 0===K&&(K=!0);return H?K?"T":"True":K?"F":"False"}function x(H,K){void 0===K&&(K=4);return null===K||H.length<=K?H:H.slice(0,K-1)+"\u2026"}var A=function(){function H(K){this.isShown=!1;this.blurHideFunction=null;this.dropdown=document.createElement("div");this.dropdown.classList.add("tensor-widget-dim-dropdown");this.dropdown.style.position="fixed";this.dropdown.style.display=
"none";K.appendChild(this.dropdown)}H.prototype.show=function(K,M,L){var Q=this;L.forEach(function(X){var aa=document.createElement("div");aa.classList.add("tensor-widget-dim-dropdown-menu-item");aa.textContent=X.caption;Q.dropdown.appendChild(aa);X.disabled?aa.classList.add("tensor-widget-dim-dropdown-menu-item-disabled"):(aa.addEventListener("click",function(la){la.stopPropagation();Q.dropdown.click();if(null!==X.onClick)X.onClick(la);Q.hide()}),aa.addEventListener("mouseenter",function(la){if(null!==
X.onHover)X.onHover(la);aa.classList.add("tensor-widget-dim-dropdown-menu-item-active")}),aa.addEventListener("mouseleave",function(){aa.classList.remove("tensor-widget-dim-dropdown-menu-item-active");if(null!==X.onHover){for(var la=[],Z=0;Z<aa.children.length;++Z){var ba=aa.children[Z];ba.classList.contains("tensor-widget-dim-dropdown")&&la.push(ba)}la.forEach(function(ea){return aa.removeChild(ea)})}}))});this.dropdown.style.display="block";this.dropdown.style.top=K+"px";this.dropdown.style.left=
M+"px";L=this.dropdown.getBoundingClientRect();var T=L.left-M;this.dropdown.style.top=(K-(L.top-K)).toFixed(1)+"px";this.dropdown.style.left=(M-T).toFixed(1)+"px";this.isShown=!0;this.blurHideFunction=function(){Q.hide()};setTimeout(function(){return window.addEventListener("click",Q.blurHideFunction)},50)};H.prototype.hide=function(){for(this.dropdown.style.display="none";this.dropdown.firstChild;)this.dropdown.removeChild(this.dropdown.firstChild);this.isShown=!1;null!=this.blurHideFunction&&window.removeEventListener("click",
this.blurHideFunction)};H.prototype.shown=function(){return this.isShown};return H}(),y=function(){function H(K,M){var L=this;this.config=K;this.parentElement=M;this.baseFlatMenu=new A(this.parentElement);this.currentChoiceSelections={};this.config.items.forEach(function(Q,T){null!=Q.options&&(L.currentChoiceSelections[T]=Q.defaultSelection)})}H.prototype.show=function(K,M){var L=this,Q=[];this.config.items.forEach(function(T,X){var aa={caption:T.caption,onClick:null,onHover:null};if(null!=T.options){var la=
L.currentChoiceSelections[X];aa.onHover=function(Z){var ba=Z.target,ea=[];T.options.forEach(function(ca,ka){ea.push({caption:ka===la?ca+" (\u2713)":ca,onClick:function(){la!==ka&&(L.currentChoiceSelections[X]=ka,T.callback(ka))},onHover:null})});Z=new A(ba);ba=ba.getBoundingClientRect();Z.show(ba.top,ba.right,ea)}}else aa.onClick=T.callback;null==T.isEnabled||T.isEnabled()||(aa.disabled=!0);Q.push(aa)});this.baseFlatMenu.show(K,M,Q)};H.prototype.hide=function(){this.baseFlatMenu.hide()};H.prototype.shown=
function(){return this.baseFlatMenu.shown()};return H}(),w;(function(H){H[H.UP=1]="UP";H[H.DOWN=2]="DOWN";H[H.LEFT=3]="LEFT";H[H.RIGHT=4]="RIGHT"})(w||(w={}));var C=function(){function H(K,M,L,Q,T,X){this.shape=K;this.sliceDims=[];this.sliceIndices=[];if(0===t(this.shape))throw Error("TensorElementSelection doesn't support tensor with zero elements.");for(K=0;K<M.slicingDimsAndIndices.length;++K){this.sliceDims.push(M.slicingDimsAndIndices[K].dim);var aa=M.slicingDimsAndIndices[K].index;if(null===
aa)throw Error("Failed to create TensorElementSelection due to undetermined slicing index at dimension "+K);this.sliceIndices.push(aa)}this.rank=this.shape.length;if(0<this.rank&&this.sliceDims.length>=this.rank)throw Error("Expected sliceDims to have a length less than rank "+this.rank+", but got length "+this.sliceDims.length);this.viewDims=[];for(K=0;K<this.rank;++K)-1===this.sliceDims.indexOf(K)&&this.viewDims.push(K);if(2<this.viewDims.length)throw Error("Only selections in 1D and 2D are supported.");
this.rowStart=null==L?0:L;this.colStart=null==Q?0:Q;this.rowCount=null==T?1:T;this.colCount=null==X?1:X}H.prototype.getElementStatus=function(K){if(K.length!==this.rank)throw Error("Expected indices to have a rank of "+this.rank+", but got "+(K.length+" (["+K+"])"));for(var M=0;M<K.length;++M)if(-1!==this.sliceDims.indexOf(M)&&K[M]!==this.sliceIndices[this.sliceDims.indexOf(M)])return null;M=null;var L=this.rowStart+this.rowCount,Q=this.colStart+this.colCount;if(0===this.viewDims.length)0===K.length&&
(M={topEdge:!0,bottomEdge:!0,leftEdge:!0,rightEdge:!0});else if(1===this.viewDims.length){var T=this.viewDims[0];K[T]>=this.rowStart&&K[T]<L&&(M={topEdge:K[T]===this.rowStart,bottomEdge:K[T]===L-1,leftEdge:!0,rightEdge:!0})}else if(2===this.viewDims.length){T=this.viewDims[0];var X=this.viewDims[1];K[T]>=this.rowStart&&K[T]<L&&K[X]>=this.colStart&&K[X]<Q&&(M={topEdge:K[T]===this.rowStart,bottomEdge:K[T]===L-1,leftEdge:K[X]===this.colStart,rightEdge:K[X]===Q-1})}else throw Error("Unexpected length of viewDims: "+
this.viewDims);return M};H.prototype.move=function(K,M){var L=null;if(0===this.rank||1===this.rank&&(K===w.LEFT||K===w.RIGHT))return null;if(null===M.verticalRange||null===M.verticalRange[1])throw Error("Failed to move due to undetermined vertical range.");K===w.UP?0<this.rowStart&&(this.rowStart--,null!=M.verticalRange&&this.rowStart<M.verticalRange[0]&&(L=w.UP)):K===w.DOWN?null!=M.viewingDims&&null!=M.viewingDims[0]&&this.rowStart<this.shape[M.viewingDims[0]]-1&&(this.rowStart++,null!=M.verticalRange&&
this.rowStart>=M.verticalRange[1]&&(L=w.DOWN)):K===w.LEFT?0<this.colStart&&(this.colStart--,null!=M.horizontalRange&&this.colStart<M.horizontalRange[0]&&(L=w.LEFT)):K===w.RIGHT&&null!=M.viewingDims&&null!=M.viewingDims[1]&&this.colStart<this.shape[M.viewingDims[1]]-1&&(this.colStart++,null!=M.horizontalRange&&this.colStart>=M.horizontalRange[1]&&(L=w.RIGHT));this.colCount=this.rowCount=1;return L};H.prototype.getRowStart=function(){return this.rowStart};H.prototype.getRowCount=function(){return this.rowCount};
H.prototype.getColStart=function(){return this.colStart};H.prototype.getColCount=function(){return this.colCount};return H}(),G=function(){function H(K,M,L){void 0===L&&(L=function(){});this.rootDiv=K;this.shape=M;this.onSlicingSpecChange=L;this.dimControls=[];this.dimInputs=[];this.commas=[];this.dropdowns=[];this.bracketDivs=[null,null];this.dimControlsListenerAttached=[];this.rank=this.shape.length;if(3>this.rank)throw Error("Dimension control is not applicable to tensor shapes less than 3D: received "+
(this.rank+"D tensor shape: ")+(JSON.stringify(this.shape)+"."));this.createComponents();this.slicingSpec=p(M)}H.prototype.createComponents=function(){for(var K=this;this.rootDiv.firstChild;)this.rootDiv.removeChild(this.rootDiv.firstChild);this.dimControls=[];this.dimInputs=[];this.commas=[];this.dropdowns=[];this.dimControlsListenerAttached=[];this.bracketDivs[0]=document.createElement("div");this.bracketDivs[0].textContent="Slicing: [";this.bracketDivs[0].classList.add("tensor-widget-dim-brackets");
this.rootDiv.appendChild(this.bracketDivs[0]);for(var M=0;M<this.rank;++M){var L=document.createElement("div");L.classList.add("tensor-widget-dim");L.title="Dimension "+M+": size\x3d"+this.shape[M];this.rootDiv.appendChild(L);this.dimControls.push(L);this.dimControlsListenerAttached.push(!1);L=document.createElement("input");L.classList.add("tensor-widget-dim");L.style.display="none";this.rootDiv.appendChild(L);this.dimInputs.push(L);M<this.rank-1&&(L=document.createElement("div"),L.classList.add("tensor-widget-dim-comma"),
L.textContent=",",this.rootDiv.appendChild(L),this.commas.push(L));L=document.createElement("div");L.classList.add("tensor-widget-dim-dropdown");L.style.display="none";this.rootDiv.appendChild(L);this.dropdowns.push(L)}this.bracketDivs[1]=document.createElement("div");this.bracketDivs[1].textContent="]";this.bracketDivs[1].classList.add("tensor-widget-dim-brackets");this.rootDiv.appendChild(this.bracketDivs[1]);this.rootDiv.addEventListener("mouseleave",function(){K.clearAllDropdowns()})};H.prototype.render=
function(K){function M(aa){var la=X.dimControls[aa],Z=X.dimInputs[aa],ba=X.dropdowns[aa];if("none"!==Z.style.display)return"continue";var ea=X.shape[aa];if(-1!==Q.indexOf(aa)){var ca=T[Q.indexOf(aa)];la.textContent=String(ca);Z.classList.add("tensor-widget-dim");Z.type="number";Z.min="0";Z.max=String(ea-1);Z.value=String(ca);X.dimControlsListenerAttached[aa]||(la.addEventListener("click",function(){L.clearAllDropdowns();la.style.display="none";Z.style.display="inline-block"}),Z.addEventListener("change",
function(){if(null===L.slicingSpec)throw Error("Slicing control change callback failed due to missing spec.");var ka=parseInt(Z.value,10);!isFinite(ka)||0>ka||ka>=ea||Math.floor(ea)!=ea?Z.value=String(L.slicingSpec.slicingDimsAndIndices[Q.indexOf(aa)].index):(L.slicingSpec.slicingDimsAndIndices[Q.indexOf(aa)].index=ka,la.textContent=String(ka),L.onSlicingSpecChange(L.slicingSpec))}),Z.addEventListener("blur",function(){Z.style.display="none";la.style.display="inline-block"}),X.dimControlsListenerAttached[aa]=
!0)}else{if(X.slicingSpec.viewingDims[0]===aa){if(null===X.slicingSpec.verticalRange)throw Error("Missing vertical range.");la.textContent="\u2195 "+X.slicingSpec.verticalRange[0]+":"+X.slicingSpec.verticalRange[1]}else{if(null===X.slicingSpec.horizontalRange)throw Error("Missing horizontal range.");la.textContent="\u2194 "+X.slicingSpec.horizontalRange[0]+":"+X.slicingSpec.horizontalRange[1]}la.classList.add("tensor-widget-dim");X.dimControlsListenerAttached[aa]||(la.addEventListener("click",function(){var ka=
la.getBoundingClientRect();L.renderDropdownMenuItems(ba,ka.bottom,ka.left,aa)}),X.dimControlsListenerAttached[aa]=!0)}}var L=this;null!=K&&(this.slicingSpec=JSON.parse(JSON.stringify(K)));if(null===this.slicingSpec)throw Error("Slicing control rendering failed due to missing slicing spec.");var Q=this.slicingSpec.slicingDimsAndIndices.map(function(aa){return aa.dim}),T=this.slicingSpec.slicingDimsAndIndices.map(function(aa){return aa.index}),X=this;for(K=0;K<this.rank;++K)M(K)};H.prototype.renderDropdownMenuItems=
function(K,M,L,Q){function T(ea){if(-1===aa.indexOf(ea)||Q===la.slicingSpec.viewingDims[1]&&ea<=la.slicingSpec.viewingDims[0]||Q==la.slicingSpec.viewingDims[0]&&ea>=la.slicingSpec.viewingDims[1])return"continue";var ca=document.createElement("div");ca.classList.add("tensor-widget-dim-dropdown-menu-item");ca.textContent="Swap with dimension "+ea;K.appendChild(ca);ca.addEventListener("mouseenter",function(){ca.classList.add("tensor-widget-dim-dropdown-menu-item-active");X.dimControls[ea].classList.add("tensor-widget-dim-highlighted")});
ca.addEventListener("mouseleave",function(){ca.classList.remove("tensor-widget-dim-dropdown-menu-item-active");X.dimControls[ea].classList.remove("tensor-widget-dim-highlighted")});var ka=la.slicingSpec.viewingDims[0]===Q;ca.addEventListener("click",function(){if(null===X.slicingSpec)throw Error("Dimension swapping failed due to missing slicing spec");var Y=aa.indexOf(ea);X.slicingSpec.viewingDims[ka?0:1]=ea;X.slicingSpec.slicingDimsAndIndices[Y]={dim:Q,index:0};X.slicingSpec.verticalRange=null;X.slicingSpec.horizontalRange=
null;if(X.onSlicingSpecChange)X.onSlicingSpecChange(X.slicingSpec)})}var X=this;if(null===this.slicingSpec)throw Error("Slicing control cannot render dropdown menu items due to missing slicing spec.");this.clearAllDropdowns();for(var aa=this.slicingSpec.slicingDimsAndIndices.map(function(ea){return ea.dim}),la=this,Z=0;Z<this.rank;++Z)T(Z);K.addEventListener("mouseleave",function(){K.style.display="none"});if(K.firstChild){K.style.position="fixed";K.style.top=M+"px";K.style.left=L+"px";K.style.display=
"block";Z=K.getBoundingClientRect();var ba=Z.left-L;K.style.top=(M-(Z.top-M)).toFixed(1)+"px";K.style.left=(L-ba).toFixed(1)+"px"}};H.prototype.setSlicingSpec=function(K){this.slicingSpec=JSON.parse(JSON.stringify(K));if(null===this.slicingSpec)throw Error("Cannot set slicing spec to null.");this.render(this.slicingSpec)};H.prototype.clearAllDropdowns=function(){this.dropdowns.forEach(function(K){if(null!=K){for(;K.firstChild;)K.removeChild(K.firstChild);K.style.display="none"}})};return H}(),D=function(){function H(K){this.config=
K;if(!isFinite(K.min))throw Error("min value ("+K.min+") is not finite");if(!isFinite(K.max))throw Error("max value ("+K.max+") is not finite");if(K.max<K.min)throw Error("max ("+K.max+") is \x3c min ("+K.min+")");}H.prototype.render=function(K,M){if(this.config.min!==this.config.max){var L=K.getContext("2d");if(null!=L){for(var Q=K.width/100,T=K.height,X=.6*T,aa=0;100>aa;++aa){var la=Q*aa,Z=.2*T,ba=Yi(this.getRGB(aa/100*(this.config.max-this.config.min)+this.config.min),3),ea=ba[0],ca=ba[1];ba=ba[2];
L.beginPath();L.fillStyle="rgba("+ea+", "+ca+", "+ba+", 1)";L.fillRect(la,Z,Q,X);L.stroke()}null!=M&&M>=this.config.min&&M<=this.config.max&&(K=(M-this.config.min)/(this.config.max-this.config.min)*K.width,L.beginPath(),L.fillStyle="rgba(0, 0, 0, 1)",L.moveTo(K,.2*T),L.lineTo(K-4,0),L.lineTo(K+4,0),L.fill(),L.beginPath(),L.moveTo(K,.8*T),L.lineTo(K-4,T),L.lineTo(K+4,T),L.fill())}}};return H}(),B=function(H){function K(){return null!==H&&H.apply(this,arguments)||this}Wi(K,H);K.prototype.getRGB=function(M){if(isNaN(M))return[255,
0,0];if(!isFinite(M))return 0<M?[0,0,255]:[255,127.5,0];M=this.config.min===this.config.max?.5:(M-this.config.min)/(this.config.max-this.config.min);M=Math.max(Math.min(M,1),0);return[255*M,255*M,255*M]};return K}(D);D=function(H){function K(){return null!==H&&H.apply(this,arguments)||this}Wi(K,H);K.prototype.getRGB=function(M){if(isNaN(M))return[63.75,63.75,63.75];if(!isFinite(M))return 0>M?[127.5,127.5,127.5]:[191.25,191.25,191.25];var L=0,Q=0,T=0;M=this.config.min===this.config.max?.5:(M-this.config.min)/
(this.config.max-this.config.min);M=Math.max(Math.min(M,1),0);.35>=M?(Q=M/.35,T=1):.35<M&&.65>=M?(L=(M-.35)/(.65-.35),Q=1,T=(.65-M)/(.65-.35)):.65<M&&(L=1,Q=(1-M)/.35);return[255*L,255*Q,255*T]};return K}(D);var I;(function(H){H[H.TEXT=1]="TEXT";H[H.IMAGE=2]="IMAGE"})(I||(I={}));var N={Grayscale:B,Jet:D},O=function(){function H(K,M,L){this.rootElement=K;this.tensorView=M;this.baseRulerTick=this.topRuler=this.valueSection=this.slicingSpecRoot=this.menuThumb=this.infoSubsection=this.headerSection=null;
this.topRulerTicks=[];this.leftRulerTicks=[];this.valueRows=[];this.valueDivs=[];this.slicingControl=this.valueTooltip=null;this.colsCutoff=this.rowsCutoff=!1;this.menu=this.menuConfig=this.selection=null;this.colorMapName="Grayscale";this.colorMap=null;this.showIndicesOnTicks=!1;this.imageCellSize=16;this.minImageCellSize=4;this.maxImageCellSize=40;this.zoomStepRatio=1.2;this.numericSummary=null;this.options=L||{};this.slicingSpec=p(this.tensorView.spec.shape);this.rank=this.tensorView.spec.shape.length;
this.valueRenderMode=I.TEXT}H.prototype.render=function(){return b(this,void 0,void 0,function(){return Xi(this,function(K){switch(K.label){case 0:this.rootElement.classList.add("tensor-widget");this.renderHeader();if(!(d(this.tensorView.spec.dtype)||f(this.tensorView.spec.dtype)||h(this.tensorView.spec.dtype)||k(this.tensorView.spec.dtype)))throw Error("Rendering dtype "+this.tensorView.spec.dtype+" is not supported yet.");return[4,this.renderValues()];case 1:return K.sent(),[2]}})})};H.prototype.renderHeader=
function(){null==this.headerSection&&(this.headerSection=document.createElement("div"),this.headerSection.classList.add("tensor-widget-header"),this.rootElement.appendChild(this.headerSection),this.createMenu());this.renderInfo()};H.prototype.renderInfo=function(){if(null===this.headerSection)throw Error("Rendering tensor info failed due to mising header section");null==this.infoSubsection&&(this.infoSubsection=document.createElement("div"),this.infoSubsection.classList.add("tensor-widget-info"),
this.headerSection.appendChild(this.infoSubsection));for(;this.infoSubsection.firstChild;)this.infoSubsection.removeChild(this.infoSubsection.firstChild);this.renderName();this.renderDType();this.renderShape()};H.prototype.renderName=function(){if(null==this.infoSubsection)throw Error("Rendering tensor name failed due to missing info subsection.");if(null!=this.options.name&&0!==this.options.name.length){var K=document.createElement("div");K.classList.add("tensor-widget-tensor-name");K.textContent=
n(this.options.name);K.title=this.options.name;this.infoSubsection.appendChild(K)}};H.prototype.renderDType=function(){if(null==this.infoSubsection)throw Error("Rendering tensor dtype failed due to missing info subsection.");var K=document.createElement("div");K.classList.add("tensor-widget-dtype");var M=document.createElement("span");M.classList.add("tensor-widget-dtype-label");M.textContent="dtype:";K.appendChild(M);M=document.createElement("span");M.textContent=this.tensorView.spec.dtype;K.appendChild(M);
this.infoSubsection.appendChild(K)};H.prototype.renderShape=function(){if(null==this.infoSubsection)throw Error("Rendering tensor shape failed due to missing info subsection.");var K=document.createElement("div");K.classList.add("tensor-widget-shape");var M=document.createElement("div");M.classList.add("tensor-widget-shape-label");M.textContent="shape:";K.appendChild(M);M=document.createElement("div");M.classList.add("tensor-widget-shape-value");M.textContent=l(this.tensorView.spec.shape);K.appendChild(M);
this.infoSubsection.appendChild(K)};H.prototype.createMenu=function(){var K=this;this.menuConfig={items:[]};if(f(this.tensorView.spec.dtype)||d(this.tensorView.spec.dtype)||h(this.tensorView.spec.dtype))this.menuConfig.items.push({caption:"Select display mode...",options:["Text","Image"],defaultSelection:0,callback:function(M){0===M?(K.valueRenderMode=I.TEXT,K.renderValues()):(K.valueRenderMode=I.IMAGE,K.tensorView.getNumericSummary().then(function(L){K.numericSummary=L;K.renderValues()}))}}),this.menuConfig.items.push({caption:"Select color map...",
options:Object.keys(N),defaultSelection:0,callback:function(M){K.colorMapName=Object.keys(N)[M];K.renderValues()},isEnabled:function(){return K.valueRenderMode===I.IMAGE}}),this.menuConfig.items.push({caption:"Zoom in (Image mode)",callback:function(){K.zoomInOneStepAndRenderValues()},isEnabled:function(){return K.valueRenderMode===I.IMAGE}}),this.menuConfig.items.push({caption:"Zoom out (Image mode)",callback:function(){K.zoomOutOneStepAndRenderValues()},isEnabled:function(){return K.valueRenderMode===
I.IMAGE}});null!==this.menuConfig&&0<this.menuConfig.items.length&&(this.menu=new y(this.menuConfig,this.headerSection),this.renderMenuThumb())};H.prototype.zoomInOneStepAndRenderValues=function(){this.imageCellSize*this.zoomStepRatio<=this.maxImageCellSize&&(this.imageCellSize*=this.zoomStepRatio,this.renderValues())};H.prototype.zoomOutOneStepAndRenderValues=function(){this.imageCellSize/this.zoomStepRatio>=this.minImageCellSize&&(this.imageCellSize/=this.zoomStepRatio,this.renderValues())};H.prototype.renderMenuThumb=
function(){var K=this;if(null==this.headerSection)throw Error("Rendering menu thumb failed due to missing header section.");this.menuThumb=document.createElement("div");this.menuThumb.textContent="\u22ee";this.menuThumb.classList.add("tensor-widget-menu-thumb");this.headerSection.appendChild(this.menuThumb);this.menuThumb.addEventListener("click",function(){if(null!==K.menu)if(K.menu.shown())K.menu.hide();else{var M=K.menuThumb.getBoundingClientRect();K.menu.show(M.bottom,M.left)}})};H.prototype.renderValues=
function(){return b(this,void 0,void 0,function(){var K=this;return Xi(this,function(M){switch(M.label){case 0:return 2<this.rank&&null===this.slicingSpecRoot&&(this.slicingSpecRoot=document.createElement("div"),this.slicingSpecRoot.classList.add("tensor-widget-slicing-group"),this.rootElement.appendChild(this.slicingSpecRoot)),null==this.valueSection&&(this.valueSection=document.createElement("div"),this.valueSection.classList.add("tensor-widget-value-section"),this.rootElement.appendChild(this.valueSection),
this.valueSection.addEventListener("wheel",function(L){return b(K,void 0,void 0,function(){var Q;return Xi(this,function(T){switch(T.label){case 0:Q=!1;null==this.options.wheelZoomKey||"ctrl"===this.options.wheelZoomKey?Q=L.ctrlKey:"alt"===this.options.wheelZoomKey?Q=L.altKey:"shift"===this.options.wheelZoomKey&&(Q=L.shiftKey);if(Q&&this.valueRenderMode===I.IMAGE)return L.stopPropagation(),L.preventDefault(),0<L.deltaY?this.zoomOutOneStepAndRenderValues():this.zoomInOneStepAndRenderValues(),[2];if(null==
this.selection)return[2];L.stopPropagation();L.preventDefault();this.hideValueTooltip();return[4,this.scrollUpOrDown(0<L.deltaY?w.DOWN:w.UP)];case 1:return T.sent(),[2]}})})}),this.valueSection.tabIndex=1024,this.valueSection.addEventListener("keydown",function(L){var Q=[38,40,37,39];if(null!=K.selection&&-1!==Q.indexOf(L.keyCode)){L.stopPropagation();L.preventDefault();K.hideValueTooltip();var T=Q=null;38===L.keyCode?T=w.UP:40===L.keyCode?T=w.DOWN:37===L.keyCode?T=w.LEFT:39===L.keyCode&&(T=w.RIGHT);
null!==T&&(Q=K.selection.move(T,K.slicingSpec));null===Q?K.renderSelection():Q===w.UP||Q===w.DOWN?K.scrollUpOrDown(Q):(Q===w.LEFT||Q===w.RIGHT)&&K.scrollLeftOrRight(Q)}})),this.clearValueSection(),this.createTopRuler(),this.createLeftRuler(),this.createValueDivs(),[4,this.renderRulersAndValueDivs()];case 1:return M.sent(),2<this.rank&&(this.slicingControl=new G(this.slicingSpecRoot,this.tensorView.spec.shape,function(L){return b(K,void 0,void 0,function(){return Xi(this,function(Q){switch(Q.label){case 0:if(m(this.slicingSpec,
L))return[3,2];this.slicingSpec=JSON.parse(JSON.stringify(L));return[4,this.render()];case 1:return Q.sent(),[3,4];case 2:return this.slicingSpec=JSON.parse(JSON.stringify(L)),[4,this.renderRulersAndValueDivs()];case 3:Q.sent(),Q.label=4;case 4:return[2]}})})}),this.slicingControl.render(this.slicingSpec)),[2]}})})};H.prototype.clearValueSection=function(){if(null!==this.valueSection){for(;this.valueSection.firstChild;)this.valueSection.removeChild(this.valueSection.firstChild);this.topRuler=null;
this.valueRows=[]}};H.prototype.createTopRuler=function(){var K=this;if(null===this.valueSection)throw Error("Failed to create top ruler due to missing value section.");null==this.topRuler&&(this.topRuler=document.createElement("div"),this.topRuler.classList.add("tenesor-widget-top-ruler"),this.topRuler.style.whiteSpace="nowrap",this.valueSection.appendChild(this.topRuler),this.topRulerTicks=[],this.topRuler.addEventListener("wheel",function(X){return b(K,void 0,void 0,function(){return Xi(this,function(aa){switch(aa.label){case 0:if(null==
this.selection)return[2];X.stopPropagation();X.preventDefault();this.hideValueTooltip();return[4,this.scrollLeftOrRight(0<X.deltaY?w.RIGHT:w.LEFT)];case 1:return aa.sent(),[2]}})})}));for(;this.topRuler.firstChild;)this.topRuler.removeChild(this.topRuler.firstChild);this.baseRulerTick=document.createElement("div");this.baseRulerTick.classList.add("tensor-widget-top-ruler-tick");this.topRuler.appendChild(this.baseRulerTick);2<=this.rank&&(this.slicingSpec.horizontalRange=[0,null]);var M=1>=this.rank?
1:this.tensorView.spec.shape[this.slicingSpec.viewingDims[1]];var L=this.rootElement.getBoundingClientRect().right;this.colsCutoff=!1;for(var Q=0;Q<M;++Q){var T=document.createElement("div");T.classList.add("tensor-widget-top-ruler-tick");this.valueRenderMode===I.IMAGE&&(T.style.width=this.imageCellSize+"px");this.topRuler.appendChild(T);this.topRulerTicks.push(T);if(T.getBoundingClientRect().right>=L){if(2<=this.rank){if(null===this.slicingSpec.horizontalRange)throw Error("Missing horizontal range for "+
this.rank+"D tensor.");this.slicingSpec.horizontalRange[1]=Q+1;this.colsCutoff=!0}break}}if(!this.colsCutoff&&2<=this.rank){if(null===this.slicingSpec.horizontalRange)throw Error("Missing horizontal range for "+this.rank+"D tensor.");this.slicingSpec.horizontalRange[1]=M}};H.prototype.createLeftRuler=function(){if(null===this.valueSection)throw Error("Failed to create left ruler due to missing value section.");this.valueRows=[];this.leftRulerTicks=[];1<=this.rank&&(this.slicingSpec.verticalRange=
[0,null]);var K=0===this.rank?1:this.tensorView.spec.shape[this.slicingSpec.viewingDims[0]];this.rowsCutoff=!1;for(var M=this.rootElement.getBoundingClientRect().bottom,L=0;L<K;++L){var Q=document.createElement("div");Q.classList.add("tensor-widget-value-row");this.valueRenderMode===I.IMAGE&&(Q.style.height=this.imageCellSize+"px",Q.style.lineHeight=this.imageCellSize+"px");this.valueSection.appendChild(Q);this.valueRows.push(Q);var T=document.createElement("div");T.classList.add("tensor-widget-top-ruler-tick");
this.valueRenderMode===I.IMAGE&&(T.style.height=this.imageCellSize+"px",T.style.lineHeight=this.imageCellSize+"px");Q.appendChild(T);this.leftRulerTicks.push(T);if(T.getBoundingClientRect().bottom>=M){if(1<=this.rank){if(null===this.slicingSpec.verticalRange)throw Error("Missing vertical range for "+this.rank+"D tensor.");this.slicingSpec.verticalRange[1]=L+1;this.rowsCutoff=!0}break}}if(!this.rowsCutoff&&1<=this.rank){if(null===this.slicingSpec.verticalRange)throw Error("Missing vertical range for "+
this.rank+"D tensor.");this.slicingSpec.verticalRange[1]=K}};H.prototype.createValueDivs=function(){function K(aa){function la(ba){var ea=document.createElement("div");ea.classList.add("tensor-widget-value-div");T.valueRenderMode===I.IMAGE&&(ea.style.width=T.imageCellSize+"px",ea.style.height=T.imageCellSize+"px",ea.style.lineHeight=T.imageCellSize+"px");T.valueRows[aa].appendChild(ea);T.valueDivs[aa].push(ea);ea.addEventListener("click",function(){M.selection=new C(M.tensorView.spec.shape,M.slicingSpec,
null==M.slicingSpec.verticalRange||null==M.slicingSpec.verticalRange[0]?0:M.slicingSpec.verticalRange[0]+aa,null==M.slicingSpec.horizontalRange||null==M.slicingSpec.horizontalRange[0]?0:M.slicingSpec.horizontalRange[0]+ba,1,1);M.renderSelection()});ea.addEventListener("mouseenter",function(){var ca=ea.getAttribute("detailed-value");if(null!==ca){var ka=M.rootElement.getBoundingClientRect(),Y=ea.getBoundingClientRect(),Ea=Y.bottom-Y.top,va=Y.right-Y.left,xa=M.calculateIndices(aa,ba);M.drawValueTooltip(xa,
ca,Y.top-ka.top+.8*Ea,Y.left-ka.left+.75*va)}});ea.addEventListener("mouseleave",function(){M.hideValueTooltip()})}T.valueDivs[aa]=[];for(var Z=0;Z<L;++Z)la(Z)}var M=this;if(null===this.valueRows)throw Error("Value rows are unexpectedly uninitialized.");this.valueDivs=[];for(var L=this.topRulerTicks.length,Q=this.valueRows.length,T=this,X=0;X<Q;++X)K(X)};H.prototype.renderTopRuler=function(){if(2<=this.rank)for(var K=this.tensorView.spec.shape[this.slicingSpec.viewingDims[1]],M=0;M<this.topRulerTicks.length;++M){if(null===
this.slicingSpec.horizontalRange)throw Error("Missing horizontal range for "+this.rank+"D tensor.");var L=this.slicingSpec.horizontalRange[0]+M;this.showIndicesOnTicks&&(this.topRulerTicks[M].textContent=L<K?""+L:"")}};H.prototype.renderLeftRuler=function(){if(1<=this.rank)for(var K=this.tensorView.spec.shape[this.slicingSpec.viewingDims[0]],M=0;M<this.leftRulerTicks.length;++M){if(null===this.slicingSpec.verticalRange)throw Error("Missing vertcial range for "+this.rank+"D tensor.");var L=this.slicingSpec.verticalRange[0]+
M;this.showIndicesOnTicks&&(this.leftRulerTicks[M].textContent=L<K?""+L:"")}};H.prototype.renderValueDivs=function(){return b(this,void 0,void 0,function(){var K,M,L,Q,T,X,aa,la,Z,ba,ea,ca,ka,Y,Ea,va,xa;return Xi(this,function(Aa){switch(Aa.label){case 0:return K=this.valueDivs.length,M=this.valueDivs[0].length,[4,this.tensorView.view(this.slicingSpec)];case 1:L=Aa.sent();0===this.rank?L=[[L]]:1===this.rank&&(L=L.map(function(Fa){return[Fa]}));Q=this.getValueClass();T=this.valueRenderMode;if(T===
I.IMAGE){if(null==this.numericSummary)throw Error("Failed to render image representation of tensor due to missing numeric summary");X=this.numericSummary;aa=X.minimum;la=X.maximum;if(null==aa||null==la)throw Error("Failed to render image representation of tensor due to missing minimum or maximum values in numeric summary");Z={min:aa,max:la};this.colorMap=this.colorMapName in N?new N[this.colorMapName](Z):new B(Z)}for(ba=0;ba<K;++ba)for(ea=0;ea<M;++ea)ca=this.valueDivs[ba][ea],ba<L.length&&ea<L[ba].length?
(ka=L[ba][ea],T===I.IMAGE?(Y=Yi(this.colorMap.getRGB(ka),3),Ea=Y[0],va=Y[1],xa=Y[2],ca.style.backgroundColor="rgb("+Ea+", "+va+", "+xa+")"):"numeric"===Q?ca.textContent=q(ka,d(this.tensorView.spec.dtype)):"boolean"===Q?ca.textContent=u(ka):"string"===Q&&(ca.textContent=x(ka)),ca.setAttribute("detailed-value",this.getDetailedValueTooltipString(ka))):(ca.textContent="",ca.setAttribute("detailed-value",""));this.renderSelection();return[2]}})})};H.prototype.getDetailedValueTooltipString=function(K){return"boolean"===
this.getValueClass()?u(K,!1):"string"===this.getValueClass()?"Length-"+K.length+' string: "'+x(K,500)+'"':String(K)};H.prototype.renderSelection=function(){if(null!=this.selection)for(var K=this.valueDivs.length,M=this.valueDivs[0].length,L=0;L<K;++L)for(var Q=0;Q<M;++Q){var T=this.valueDivs[L][Q];T.classList.remove("tensor-widget-value-div-selection");T.classList.remove("tensor-widget-value-div-selection-top");T.classList.remove("tensor-widget-value-div-selection-bottom");T.classList.remove("tensor-widget-value-div-selection-left");
T.classList.remove("tensor-widget-value-div-selection-right");var X=this.calculateIndices(L,Q);X=this.selection.getElementStatus(X);null!==X&&(T.classList.add("tensor-widget-value-div-selection"),X.topEdge&&T.classList.add("tensor-widget-value-div-selection-top"),X.bottomEdge&&T.classList.add("tensor-widget-value-div-selection-bottom"),X.leftEdge&&T.classList.add("tensor-widget-value-div-selection-left"),X.rightEdge&&T.classList.add("tensor-widget-value-div-selection-right"))}};H.prototype.calculateIndices=
function(K,M){for(var L=[],Q=this.slicingSpec.slicingDimsAndIndices.map(function(la){return la.dim}),T=this.slicingSpec.slicingDimsAndIndices.map(function(la){return la.index}),X=0;X<this.rank;++X)if(-1!==Q.indexOf(X)){var aa=T[Q.indexOf(X)];if(null===aa)throw Error("Failed to calculate indices: Undetermined index at dimension "+X);L.push(aa)}else if(X===this.slicingSpec.viewingDims[0]){if(null===this.slicingSpec.verticalRange||null===this.slicingSpec.verticalRange[0])throw Error("Failed to calculate indices due to undertermined vertical range.");
L.push(this.slicingSpec.verticalRange[0]+K)}else if(X===this.slicingSpec.viewingDims[1]){if(null===this.slicingSpec.horizontalRange||null===this.slicingSpec.horizontalRange[0])throw Error("Failed to calculate indices due to undertermined vertical range.");L.push(this.slicingSpec.horizontalRange[0]+M)}return L};H.prototype.drawValueTooltip=function(K,M,L,Q){null===this.valueTooltip&&(this.valueTooltip=document.createElement("div"),this.valueTooltip.classList.add("tensor-widget-value-tooltip"),this.rootElement.appendChild(this.valueTooltip));
for(;this.valueTooltip.firstChild;)this.valueTooltip.removeChild(this.valueTooltip.firstChild);var T=document.createElement("div");T.classList.add("tensor-widget-value-tooltip-indices");T.textContent="Indices: "+JSON.stringify(K);this.valueTooltip.appendChild(T);K=document.createElement("div");K.classList.add("tensor-widget-value-tooltip-value");K.textContent=M;this.valueTooltip.appendChild(K);this.valueTooltip.style.top=L+"px";this.valueTooltip.style.left=Q+"px";this.valueTooltip.style.display="block";
this.valueRenderMode==I.IMAGE&&null!=this.colorMap&&(L=document.createElement("canvas"),L.classList.add("tensor-widget-value-tooltip-colorbar"),this.valueTooltip.appendChild(L),this.colorMap.render(L,parseFloat(M)))};H.prototype.hideValueTooltip=function(){null!=this.valueTooltip&&(this.valueTooltip.style.display="none")};H.prototype.renderRulersAndValueDivs=function(){return b(this,void 0,void 0,function(){return Xi(this,function(K){switch(K.label){case 0:return null!=this.slicingControl&&this.slicingControl.setSlicingSpec(this.slicingSpec),
this.calculateShowIndicesOnRulerTicks(),this.renderTopRuler(),this.renderLeftRuler(),[4,this.renderValueDivs()];case 1:return K.sent(),[2]}})})};H.prototype.calculateShowIndicesOnRulerTicks=function(){if(2<=this.rank){var K=this.topRulerTicks[0].getBoundingClientRect();this.showIndicesOnTicks=K.right-K.left>9*Math.ceil(Math.log(this.tensorView.spec.shape[this.slicingSpec.viewingDims[0]])/Math.LN10)}else 1===this.rank?(K=this.leftRulerTicks[0].getBoundingClientRect(),this.showIndicesOnTicks=16<K.bottom-
K.top):this.showIndicesOnTicks=!1};H.prototype.scrollHorizontally=function(K){return b(this,void 0,void 0,function(){var M,L;return Xi(this,function(Q){switch(Q.label){case 0:if(1>=this.rank)return[2];if(null===this.slicingSpec.horizontalRange)throw Error("Missing horizontal range for "+this.rank+"D tensor.");M=this.tensorView.spec.shape[this.slicingSpec.viewingDims[1]];if(0>K||K>=M)throw Error("Index out of bound: "+K+" is outside [0, "+M+"])");this.slicingSpec.horizontalRange[0]=K;this.slicingSpec.horizontalRange[1]=
K+this.topRulerTicks.length;L=this.tensorView.spec.shape[this.slicingSpec.viewingDims[1]];this.slicingSpec.horizontalRange[1]>L&&(this.slicingSpec.horizontalRange[1]=L);return[4,this.renderRulersAndValueDivs()];case 1:return Q.sent(),[2]}})})};H.prototype.scrollVertically=function(K){return b(this,void 0,void 0,function(){var M,L;return Xi(this,function(Q){switch(Q.label){case 0:if(0===this.rank)return[2];if(null===this.slicingSpec.verticalRange)throw Error("Missing vertical range for "+this.rank+
"D tensor.");if(null===this.valueRows)throw Error("Vertical scrolling failed due to missing value rows.");M=this.tensorView.spec.shape[this.slicingSpec.viewingDims[0]];if(0>K||K>=M)throw Error("Index out of bound: "+K+" is outside [0, "+M+"])");this.slicingSpec.verticalRange[0]=K;this.slicingSpec.verticalRange[1]=K+this.valueRows.length;L=this.tensorView.spec.shape[this.slicingSpec.viewingDims[0]];this.slicingSpec.verticalRange[1]>L&&(this.slicingSpec.verticalRange[1]=L);return[4,this.renderRulersAndValueDivs()];
case 1:return Q.sent(),[2]}})})};H.prototype.scrollUpOrDown=function(K){return b(this,void 0,void 0,function(){var M,L,Q;return Xi(this,function(T){switch(T.label){case 0:if(0===this.rank||!this.rowsCutoff)return[2];if(null===this.slicingSpec.verticalRange)throw Error("Missing vertical range for "+this.rank+"D tensor.");if(null===this.valueRows)throw Error("Vertical scrolling failed due to missing value rows.");M=this.slicingSpec.verticalRange[0];if(K!==w.DOWN)return[3,3];L=this.valueRows.length-
1;Q=this.tensorView.spec.shape[this.slicingSpec.viewingDims[0]]-L;return M<Q?[4,this.scrollVertically(M+1)]:[3,2];case 1:T.sent(),T.label=2;case 2:return[3,5];case 3:return 0<=M-1?[4,this.scrollVertically(M-1)]:[3,5];case 4:T.sent(),T.label=5;case 5:return[2]}})})};H.prototype.scrollLeftOrRight=function(K){return b(this,void 0,void 0,function(){var M,L,Q;return Xi(this,function(T){switch(T.label){case 0:if(1>=this.rank||!this.colsCutoff)return[2];if(null===this.slicingSpec.horizontalRange)throw Error("Horizontal scrolling failed due to missing horizontal range.");
M=this.slicingSpec.horizontalRange[0];if(K!==w.RIGHT)return[3,3];L=this.topRulerTicks.length-1;Q=this.tensorView.spec.shape[this.slicingSpec.viewingDims[1]]-L;return M<Q?[4,this.scrollHorizontally(M+1)]:[3,2];case 1:T.sent(),T.label=2;case 2:return[3,5];case 3:return 0<=M-1?[4,this.scrollHorizontally(M-1)]:[3,5];case 4:T.sent(),T.label=5;case 5:return[2]}})})};H.prototype.navigateToIndices=function(){return b(this,void 0,void 0,function(){return Xi(this,function(){throw Error("navigateToIndices() is not implemented yet.");
})})};H.prototype.getValueClass=function(){var K=this.tensorView.spec.dtype;return d(K)||f(K)?"numeric":h(K)?"boolean":"string"};return H}();D=Object.freeze({tensorWidget:function(H,K,M){return new O(H,K,M)},VERSION:"0.0.0"});window.tensor_widget=D})();

//# sourceURL=build://tf-debugger-dashboard/tf-debugger-line-chart.html.js
Polymer({is:"tf-debugger-line-chart",properties:{data:{type:Object,value:null},_defaultSeriesName:{type:String,value:"__debugger_data__",readonly:!0},_lineChartXComponentsCreationMethod:{type:Object,readOnly:!0,value:()=>()=>{const b=new Plottable.Scales.Linear;return{scale:b,axis:new Plottable.Axes.Numeric(b,"bottom"),accessor:d=>d.step}}},_lineChartYValueAccessor:{type:Object,readOnly:!0,value:()=>b=>b.scalar},_lineChartTooltipColumns:{type:Array,readOnly:!0,value:()=>[{title:"Name",evaluate:b=>
"step\x3d"+b.datum.step+"; scalar\x3d "+b.datum.scalar}]},_lineChartSmoothingEnabled:{type:Boolean,value:!1,readOnly:!0}},observers:["render(data)"],render(b){if(null!=b){var d=this.$$("vz-line-chart2");d.setVisibleSeries([this._defaultSeriesName]);var f=[],h=b.x;b=b.y;for(let k=0;k<h.length;++k)f.push({step:h[k],scalar:b[k]});d.setSeriesData(this._defaultSeriesName,f)}}});

//# sourceURL=build://tf-debugger-dashboard/tf-tensor-value-view.html.js
Polymer({is:"tf-tensor-value-view",properties:{viewId:String,tensorName:String,debugOp:String,deviceName:String,maybeBaseExpandedNodeName:String,slicing:String,timeIndices:String,dtype:String,shape:Array,continueToButtonCallback:Object,closeButtonCallback:Object,tensorNameCallback:Object,tensorWidget:Object,getHealthPill:Function,_isTensorValueScalar:{type:Boolean,value:!1},_isTensorValueLineChart:{type:Boolean,value:!1},_isTensorValueImage:{type:Boolean,value:!1},_dataScalar:{type:Number,value:null},
_lineChartData:{type:Array,value:null},_dataImageSrc:{type:String,value:null},_requestManager:{type:Object,value:()=>new vc.RequestManager(10)}},observers:["_updateTimeIndicesToggle(timeIndices)"],renderTensorValue(){if(this.tensorName)if(null==this.slicing){this.set("_useTensorWidget",!0);const d={spec:{dtype:this.dtype,shape:this.shape},get:()=>{throw Error("tensorView.get() is not implemented yet.");},view:f=>{const h=this;return hc(function*(){const k=h.shape.length,t=f.slicingDimsAndIndices.map(m=>
m.dim),l=f.slicingDimsAndIndices.map(m=>m.index);let p="[";for(let m=0;m<k;++m)-1!==t.indexOf(m)?p+=`${l[t.indexOf(m)]}`:f.viewingDims[0]===m?p+=`${f.verticalRange[0]}:${f.verticalRange[1]}`:f.viewingDims[1]===m&&(p+=`${f.horizontalRange[0]}:${f.horizontalRange[1]}`),m<k-1&&(p+=",");p+="]";return new Promise((m,n)=>{const q=h._getTensorDataURL({watch_key:h.tensorName+":"+h.debugOp,slicing:p,time_indices:h.timeIndices,mapping:"none"});h._requestManager.request(q).then(u=>{null==u.error?m(u.tensor_data[u.tensor_data.length-
1]):n(u.error)}).catch(u=>n(u))})})},getNumericSummary:()=>{const f=this;return hc(function*(){return new Promise((h,k)=>{const t=f.tensorName+":"+f.debugOp;f.getHealthPill(t,f.deviceName,f.maybeBaseExpandedNodeName,l=>{null==l?k(`Failed to get health pill for watch key ${t}`):h({elementCount:l[1],minimum:l[8],maximum:l[9]})})})})}};setTimeout(()=>{null==this.tensorWidget&&(this.tensorWidget=tensor_widget.tensorWidget(this.$$("#tensor-widget"),d,{wheelZoomKey:"alt"}));this.tensorWidget.render()},
10)}else{this.set("_useTensorWidget",!1);var b=this._rankFromSlicing(this.slicing.trim());const d=this._isTimeIndicesSingleStep(this.timeIndices);let f=b;if(!d){if(1<b){this._showToast("History for tensors \x3e 1D is not yet supported.");return}f+=1}b=this._getTensorDataURL({watch_key:this.tensorName+":"+this.debugOp,slicing:this.slicing,time_indices:this.timeIndices,mapping:2<=f?"image/png":"none"});this._requestManager.request(b).then(h=>{this.$$("#debug-op").textContent=this._calculateDebugOpToDisplay();
if(null!=h.error)this._showToast(h.error.type+": "+h.error.message);else if(h=d?h.tensor_data[0]:h.tensor_data,0===f)this._setVisualizationType("scalar"),this.set("_dataScalar",h);else if(1===f){this._setVisualizationType("lineChart");let k={x:[],y:h};for(let t=0;t<h.length;++t)k.x.push(t+1);this.set("_lineChartData",k)}else 2<=f?(this._setVisualizationType("image"),this.set("_dataImageSrc","data:image/png;base64,"+h)):this._showToast("Visualization of rank-"+f+" tensors is not yet supported.")})}},
refresh(){this.tensorName.trim()&&this.renderTensorValue()},_getTensorDataURL(b){const d=vc.getRouter().pluginRoute("debugger","/tensor_data");return vc.addParams(d,b)},_rankFromSlicing(b){b.startsWith("[")&&(b=b.slice(1,b.length-1));if(0===b.length)return 0;{b=b.split(",");let d=b.length;for(const f of b)isNaN(Number(f))||d--;return d}},_setVisualizationType(b){"scalar"===b?(this.set("_isValueScalar",!0),this.set("_isValueLineChart",!1),this.set("_isValueImage",!1)):"lineChart"===b?(this.set("_isValueScalar",
!1),this.set("_isValueLineChart",!0),this.set("_isValueImage",!1)):"image"===b?(this.set("_isValueScalar",!1),this.set("_isValueLineChart",!1),this.set("_isValueImage",!0)):console.error("Invalid visualizationType:",b)},_timeIndicesToggleButtonCallback(){"full history"===Polymer.dom(this.$$("#time-indices-toggle-button")).textContent.toLowerCase()?this.set("timeIndices",":"):this.set("timeIndices","-1");this.renderTensorValue()},_updateTimeIndicesToggle(b){this._isTimeIndicesSingleStep(b)?Polymer.dom(this.$$("#time-indices-toggle-button")).textContent=
"Full History":Polymer.dom(this.$$("#time-indices-toggle-button")).textContent="Latest Time Point"},_isTimeIndicesSingleStep(b){b.startsWith("[")&&(b=b.slice(1,b.length-1));return!isNaN(Number(b))},_calculateDebugOpToDisplay(){return"DebugIdentity"===this.debugOp?"":this.debugOp},_showToast(b){this.$.tensorValueToast.setAttribute("text",b);this.$.tensorValueToast.open()}});

//# sourceURL=build://tf-debugger-dashboard/tf-tensor-value-multi-view.html.js
Polymer({is:"tf-tensor-value-multi-view",properties:{continueToCallback:Function,tensorNameClicked:Function,_tensorViewCounter:{type:Number,value:0},getHealthPill:Function},addView(b){const d=this.$$("#multi-tensor-view-container"),f=document.createElement("tf-tensor-value-view");f.setAttribute("class","debugger-tensor-view");f.viewId=b.viewId;f.tensorName=b.tensorName;f.debugOp=b.debugOp;f.deviceName=b.deviceName;f.maybeBaseExpandedNodeName=b.maybeBaseExpandedNodeName;f.dtype=b.dtype;f.shape=b.shape;
f.slicing=b.slicing;f.timeIndices=b.timeIndices;f.closeButtonCallback=this._createCloseButtonCallback(b.viewId);f.continueToButtonCallback=()=>{this.continueToCallback(b.deviceName,b.maybeBaseExpandedNodeName)};f.tensorNameCallback=()=>{this.tensorNameClicked(b.deviceName,b.maybeBaseExpandedNodeName)};f.getHealthPill=this.getHealthPill;d.appendChild(f);f.refresh()},getViews(){const b=[];_.forEach(this.root.querySelectorAll(".debugger-tensor-view"),d=>{b.push({viewId:d.viewId,tensorName:d.tensorName,
debugOp:d.debugOp,slicing:d.slicing,timeIndices:d.timeIndices})});return b},renderTensorValues(){_.forEach(this.root.querySelectorAll(".debugger-tensor-view"),b=>{b.renderTensorValue()})},_redrawViews(b){const d=this.$$("#multi-tensor-view-container");_.forEach(this.root.querySelectorAll(".debugger-tensor-view"),f=>{d.removeChild(f)});_.forEach(b,f=>{this.addView(f)})},_createCloseButtonCallback(b){return()=>{const d=[],f=this.root.querySelectorAll(".debugger-tensor-view");for(let h=0;h<f.length;++h){const k=
f[h];k.viewId!==b&&d.push({viewId:k.viewId,tensorName:k.tensorName,debugOp:k.debugOp,dtype:k.dtype,shape:k.shape,slicing:k.slicing,timeIndices:k.timeIndices})}this._redrawViews(d)}}});

//# sourceURL=build://tf-debugger-dashboard/tensor-shape-helper.js
(function(b){function d(f,h){return f<=h?"::":"::"+Math.ceil(f/h)}b.getDefaultSlicing=function(f){return 0===f.length?"":1===f.length?"["+d(f[0],1E3)+"]":2===f.length?"["+d(f[0],250)+", "+d(f[1],250)+"]":null};b.rankFromSlicing=function(f){f.startsWith("[")&&(f=f.slice(1,f.length-1));if(0===f.length)return 0;{f=f.split(",");let h=f.length;for(const k of f)isNaN(Number(k))||h--;return h}}})(Vi||(Vi={}));

//# sourceURL=build://tf-debugger-dashboard/tf-debugger-dashboard.html.js
const Zi=()=>window.innerHeight||document.documentElement.clientHeight||document.body.clientHeight,Hk=()=>window.innerWidth||document.documentElement.clientWidth||document.body.clientWidth,Ik=(Zi()-70)/2;
Polymer({is:"tf-debugger-dashboard",properties:{_topRightTabs:{type:Array,value:[{id:"tab-runtime-graphs",name:"Runtime Graphs"},{id:"tab-tensor-values",name:"Tensor Values"}],readonly:!0},_isTopRightRuntimeGraphsActive:{type:Boolean,value:!0},_isTopRightTensorValuesActive:{type:Boolean,value:!1},_topRightSelected:{type:String,value:"0",observer:"_topRightSelectedChanged"},_longPollCount:{type:Number,value:0},_stepButtonText:{type:String,value:"Step"},_continueButtonText:{type:String,value:"Continue..."},
_tensorViewIdCounter:{type:Number,value:0},isReloadDisabled:{type:Boolean,value:!0,readOnly:!0},alreadyStarted:{type:Boolean,value:!1},_currentSessionRunInfo:{type:String,value:null},_sessionRunTotalCounter:{type:Number,value:0},_sessionRunCounters:{type:Object,value:{}},_sessionRunKey2DeviceNames:{type:Object,value:{}},_activeSessionRunKey:{type:String,value:null},_activeSessionRunDevices:{type:Array,value:[]},_activeSessionRunNumDevices:{type:Number,value:-1},_activeRuntimeGraphDeviceName:{type:String,
value:null,notify:!0},_highlightNodeName:{type:String,value:null},_continueToType:{type:String,value:""},_continueToCounter:{type:Number,value:0},_continueStop:{type:Boolean,value:!1},_continueToTarget:{type:String,value:""},_continueToCounterTarget:{type:Number,value:-1},_forceExpandAndCheckNodeName:String,_forceExpandNodeName:String,_sourceFocusNodeName:String,_sourceCodeShown:{type:Boolean,value:!1,observer:"_showSourceCodeChanged"},_graphProgress:{type:Object},_requestManager:{type:Object,value:()=>
new vc.RequestManager(50)},_busy:{type:Boolean,value:!1},_leftPaneWidth:{type:Number,value:pd.getNumberInitializer("_leftPaneWidth",{defaultValue:450}),observer:"_leftPaneWidthObserver"},_minleftPaneWidth:{type:Number,value:450,readOnly:!0},_maxleftPaneWidth:{type:Number,computed:"_computeMaxleftPaneWidth(_windowWidth, _maxMainContentWidth, _resizerWidth)"},_maxMainContentWidth:{type:Number,value:350,readOnly:!0},_topRightQuadrantHeight:{type:Number,value:pd.getNumberInitializer("_topRightQuadrantHeight",
{defaultValue:Ik}),observer:"_topRightQuadrantHeightObserver"},_minTopRightQuadrantHeight:{type:Number,value:200,readOnly:!0},_maxTopRightQuadrantHeight:{type:Number,computed:"_computeMaxTopRightQuadrantHeight(_windowHeight, _resizerWidth)"},_resizerWidth:{type:Number,value:30,readOnly:!0},_windowWidth:Number,_windowHeight:Number,_debugWatches:Array,_latestSessionRun:Object},observers:["_onActiveRuntimeGraphDeviceNameChange(_activeRuntimeGraphDeviceName)","_sizeDashboardRegions(_leftPaneWidth, _topRightQuadrantHeight, _windowWidth)",
"_graphProgressUpdated(_graphProgress)"],ready(){this._handleWindowResize();window.addEventListener("resize",()=>{this._handleWindowResize()},!1);this.reload()},long_poll(){const b={pos:++this._longPollCount};let d=vc.getRouter().pluginRoute("debugger","/comm");d=vc.addParams(d,b);this._requestManager.request(d).then(f=>{const h=f.type;f=f.data;if("meta"===h){var k=f.run_key,t=k[0].split(","),l=k[1].split(",");const m=k[2].split(",");var p=this._activeSessionRunKey;this.set("_activeSessionRunKey",
k);this.set("_latestSessionRun",{feeds:t,fetches:l,targets:m});this.set("_sessionRunSoleActive",!0);void 0===this._sessionRunKey2DeviceNames[k]?(this._sessionRunKey2DeviceNames[k]=[],this.set("_activeSessionRunDevices",[])):this.set("_activeSessionRunDevices",this._sessionRunKey2DeviceNames[k]);this._currentSessionRunInfo=t="Feeds: "+t+"; Fetches: "+l+"; Targets: "+m;this._sessionRunCounters.hasOwnProperty(t)?this._sessionRunCounters[t]+=1:this._sessionRunCounters[t]=1;this._sessionRunTotalCounter++;
this.$.initialDialog.closeDialog();this._continueToType&&_.isEqual(p,k)||(this._processGatedGrpcDebugOps(k,!1),this._announceNewSessionRun())}else"tensor"===h?(k=f.device_name,p=f.node_name,t=f.maybe_base_expanded_node_name,this._activeRuntimeGraphDeviceName!=k?this.set("_activeRuntimeGraphDeviceName",k):!this._continueToType&&this._isTopRightRuntimeGraphsActive&&(this._focusOnGraphNode(k,t),this.set("_forceExpandNodeName",k+"/"+t)),this.set("_sessionRunSoleActive",!1),l=p+":"+f.output_slot,this.set("_latestTensorData",
{deviceName:k,tensorName:l,nodeName:p,maybeBaseExpandedNodeName:t,debugOp:f.debug_op,dtype:f.dtype,shape:f.shape,value:f.values}),this._maybeUpdateTensorValueViews(l,f.debug_op),this.set("_busy",!1)):console.error("Invalid long-polling response type: ",h);null!=this._continueToType&&this._processContinueTo(h,f);this.long_poll()})},_processContinueTo(b,d){this._continueStop?this._clearContinueTo():"SessionRun"===this._continueToType?this._processContinueToSessionRun("meta"===b):"TensorCondition"===
this._continueToType?this._step():"op"===this._continueToType?this._processContinueToOp("meta"===b,d):null!=this._continueToType&&""!==this._continueToType&&console.error("Invalid _continueToType:",this._continueToType)},_processContinueToSessionRun(b){b&&this.set("_continueToCounter",this._continueToCounter+1);this._continueToCounter<this._continueToCounterTarget?this._step():this._clearContinueTo()},_processContinueToOp(b,d){b&&this._announceNewSessionRun();b=d.device_name;d=d.maybe_base_expanded_node_name;
const f=null==d?null:Vi.removeNodeNameBaseExpansion(d);b+"/"+d===this._continueToTarget||b+"/"+f===this._continueToTarget?(this._clearContinueTo(),this._sourceCodeShown&&this.set("_sourceFocusNodeName",f)):this._step()},_maybeUpdateTensorValueViews(b,d){const f=this.$$("#tensorValueMultiView");if(null!=f){var h=!1;_.forEach(f.getViews(),k=>{if(k.tensorName===b&&k.debugOp===d)return h=!0,!1});h&&f.renderTensorValues()}},reload(){if(!this.alreadyStarted){this.set("alreadyStarted",!0);var b=vc.getRouter().pluginRoute("debugger",
"/debugger_grpc_host_port");this._requestManager.request(b).then(d=>{0<d.port?(this.$.initialDialog.openDialog(d.host,d.port),this.long_poll()):this.$.initialDialog.openDisabledDialog()})}},_showSourceCodeChanged(){this._sourceCodeShown?(this.$$("#node-entries").style.height="40%",this.$.sourceCodeView.render()):this.$$("#node-entries").style.height="80%"},_showToast(b){this.$.toast.setAttribute("text",b);this.$.toast.open()},_announceNewSessionRun(){this._showToast("Session.run() #"+this._sessionRunTotalCounter+
" is starting.")},_displayGraph(b,d){b={run_key:JSON.stringify(b),device_name:d};b=vc.addParams("/data/plugin/debugger/debugger_graph",b);this.$.loader.datasets=[{name:"/debugger_graph",path:b}];this.$.loader.set("selectedDataset",0)},_processGatedGrpcDebugOps(b,d){d?console.log("Polling for first GraphDef for run key:",b):this.set("_activeRuntimeGraphDeviceName",null);var f={mode:"retrieve_all",run_key:JSON.stringify(b)};const h=vc.getRouter().pluginRoute("debugger","/gated_grpc");f=vc.addParams(h,
f);let k=[];this._requestManager.request(f).then(t=>{if(0==t.device_names.length)d||this._step(),this._processGatedGrpcDebugOps(b,!0);else{var l=null;for(const p in t.gated_grpc_tensors)if(t.gated_grpc_tensors.hasOwnProperty(p)){-1===this._sessionRunKey2DeviceNames[b].indexOf(p)&&(this._sessionRunKey2DeviceNames[b].push(p),this.$.sessionRunsView.updateNumDevices(this._sessionRunKey2DeviceNames[b].length));this.set("_activeSessionRunDevices",this._sessionRunKey2DeviceNames[b].slice());l=this._activeSessionRunDevices[this._activeSessionRunDevices.length-
1];const m=t.gated_grpc_tensors[p];for(let n=0;n<m.length;++n)k.push({device_name:p,node_name:m[n][0],op_type:m[n][1],output_slot:m[n][2],debug_op:m[n][3]})}null!=l&&(this.set("_activeRuntimeGraphDeviceName",l),t=Polymer.dom(this.$$("#active-runtime-graph-device-name")),null!=t&&t.setAttribute("selected",l));Vi.sortAndBaseExpandDebugWatches(k);this.set("_debugWatches",k);this.$.sourceCodeView.render(k)}})},_createDebugWatchChangeHandler(){return(b,d)=>{d=d?"break":"disable";this._requestBreakpointStateChange(Vi.getCleanNodeName(b.device_name+
"/"+b.node_name),b.output_slot,b.debug_op,d)}},_focusOnGraphNode(b,d){null!=b&&this._activeRuntimeGraphDeviceName!==b&&this.set("_activeRuntimeGraphDeviceName",b);this._setTopRightRuntimeGraphsToActive();const f=this.$$("#graph");if(f.selectedNode===d)f.panToNode(d);else{const h=f.get("renderHierarchy").hierarchy.getNodeMap();null==h[d]&&(d=Vi.removeNodeNameBaseExpansion(d));null!=h[d]&&f.set("selectedNode",d)}this.set("_highlightNodeName",b+"/"+d)},_createNodeClickedHandler(){return(b,d,f)=>{this._sourceCodeShown&&
!0!==f&&this.set("_sourceFocusNodeName",Vi.removeNodeNameBaseExpansion(d));this._focusOnGraphNode(b,d);this.set("_forceExpandNodeName",b+"/"+d)}},_createFeedFetchTargetClickedHandler(){return b=>{let d=b;-1!==d.indexOf(":")&&(d=d.slice(0,d.indexOf(":")));b=_.find(this._debugWatches,f=>f.node_name===d||0===f.node_name.indexOf(d)&&"("===f.node_name[d.length]);null==b?this._showToast("Node '"+d+"' is not in the runtime graph of the current Session.run or does not have a debug op attached."):this._focusOnGraphNode(b.device_name,
d)}},_createTensorDataExpandHandler(){return b=>{this._setTopRightTensorValuesToActive();setTimeout(()=>{this.$$("#tensorValueMultiView").addView({viewId:this._createTensorViewId(),deviceName:b.deviceName,tensorName:b.tensorName,nodeName:b.nodeName,maybeBaseExpandedNodeName:b.maybeBaseExpandedNodeName,debugOp:b.debugOp,dtype:b.dtype,shape:b.shape,slicing:Vi.getDefaultSlicing(b.shape),timeIndices:"-1"})},10)}},_createTensorViewId(){const b="debugger-tensor-view-"+this._tensorViewIdCounter;this._tensorViewIdCounter++;
return b},_createNodeContextMenuItems(){return[{title:()=>"Expand and highlight",action:b=>{const d=Vi.getCleanNodeName(b.node.name);b=this._activeRuntimeGraphDeviceName+"/"+b.node.name;this.set("_forceExpandNodeName",b);this.set("_highlightNodeName",b);this._sourceCodeShown&&this.set("_sourceFocusNodeName",Vi.removeNodeNameBaseExpansion(d))}},{title:()=>"Add breakpoint",action:b=>{const d=Vi.getCleanNodeName(b.node.name);this.set("_forceExpandAndCheckNodeName",this._activeRuntimeGraphDeviceName+
"/"+b.node.name);this._sourceCodeShown&&this.set("_sourceFocusNodeName",Vi.removeNodeNameBaseExpansion(d))}},{title:()=>"Continue to",action:b=>{-1!==["_Arg","_Retval"].indexOf(b.node.op)?this._showToast('Cannot continue to node "'+b.node.name+'", due to op type "'+b.node.op+'".'):this._continueToNode(this._activeRuntimeGraphDeviceName,b.node.name)}}]},_createGetHealthPill(){return(b,d,f,h)=>{var k={watch_key:b,time_indices:"-1",mapping:"health-pill"};const t=vc.getRouter().pluginRoute("debugger",
"/tensor_data");k=vc.addParams(t,k);this._requestManager.request(k).then(l=>{l=l.tensor_data[0];h(l);this._conditionalHealthPillStop(b,d,f,l)})}},_conditionalHealthPillStop(b,d,f,h){if("TensorCondition"===this._continueToType&&Vi.checkHealthPillAgainstTensorConditionKey(this._continueToTarget,h,this._continueToCounterTarget)){this.set("_continueStop",!0);h=Vi.removeNodeNameBaseExpansion(f);this._sourceCodeShown&&this.set("_sourceFocusNodeName",h);this._focusOnGraphNode(d,f);const k=d+"/"+f;this.set("_forceExpandNodeName",
k);setTimeout(()=>{this.set("_highlightNodeName",null);this.set("_highlightNodeName",k)},100);this._showToast('Tensor condition "'+this._continueToTarget+'" is met by watch key: "'+b+'".\nStopping continuation.')}},_continueToNode(b,d){const f=Vi.getCleanNodeName(d);b=b+"/"+d;this._requestBreakpointStateChange(f,0,"DebugIdentity","break");this.set("_forceExpandAndCheckNodeName",b);this._sourceCodeShown&&this.set("_sourceFocusNodeName",Vi.removeNodeNameBaseExpansion(f));this._setContinueTo("op",b);
this.$.continueDialog.updateContinueButtonText(!0);this._step()},_createContinueToNodeHandler(){return(b,d)=>{this._continueToNode(b,d)}},_onActiveRuntimeGraphDeviceNameChange(b){const d=Polymer.dom(this.$$("#runtime-graph-device-name"));if(0<this._activeSessionRunDevices.length){let f;f=b+(" (device "+(this._activeSessionRunDevices.indexOf(b)+1)+" of "+this._activeSessionRunDevices.length+")");this._isTopRightRuntimeGraphsActive&&null!=d&&(d.textContent=f)}else this._isTopRightRuntimeGraphsActive&&
null!=d&&(d.textContent="Waiting for device...");null!=b&&this._displayGraph(this._activeSessionRunKey,b)},_step(){if(null!=this._activeSessionRunKey){this.set("_busy",!0);var b={mode:"retrieve_device_names",run_key:JSON.stringify(this._activeSessionRunKey)},d=vc.getRouter().pluginRoute("debugger","/gated_grpc");b=vc.addParams(d,b);this._requestManager.request(b).then(f=>{let h=!1;for(let k=0;k<f.device_names.length;++k)if(-1===this._activeSessionRunDevices.indexOf(f.device_names[k])){h=!0;break}f=
vc.getRouter().pluginRoute("debugger","/ack");this._requestManager.request(f).then(()=>{h&&this._processGatedGrpcDebugOps(this._activeSessionRunKey,!1)})})}},_createSessionRunGo(){return b=>{this._setContinueTo("SessionRun",this._currentSessionRunInfo,b);this._step()}},_createTensorConditionGo(){return(b,d)=>{this._setContinueTo("TensorCondition",b,d);this.$.tensorDataSummary.enableHealthPills();this._step()}},_createForceContinuationStop(){return()=>{this._showToast('Continuation of type "'+this._continueToType+
'" was interrupted by user.');this.set("_continueStop",!0)}},_setContinueTo(b,d,f=-1){this._continueToType=b;this._continueToTarget=d;this._continueToCounterTarget=f;this._continueToCounter=0;this._continueStop=!1},_clearContinueTo(){this.$.continueDialog.notifyContinuationStop();this._continueToTarget=this._continueToType="";this._continueToCounterTarget=-1;this._continueToCounter=0;this._continueStop=!1;this.set("_busy",!1)},_createContinueToCallback(){return(b,d)=>{this._setContinueTo("op",b+"/"+
d);this._step();this._isTopRightRuntimeGraphsActive&&this._focusOnGraphNode(b,d);this.set("_forceExpandNodeName",b+"/"+d)}},_topRightSelectedChanged(b){b=this._topRightTabs[b].id;this.set("_isTopRightRuntimeGraphsActive","tab-runtime-graphs"===b);this.set("_isTopRightTensorValuesActive","tab-tensor-values"===b)},_setTopRightRuntimeGraphsToActive(){this.set("_topRightSelected","0");this.set("_isTopRightRuntimeGraphsActive",!0);this.set("_isTopRightTensorValuesActive",!1)},_setTopRightTensorValuesToActive(){this.set("_topRightSelected",
"1");this.set("_isTopRightRuntimeGraphsActive",!1);this.set("_isTopRightTensorValuesActive",!0)},_requestBreakpointStateChange(b,d,f,h){b={mode:"set_state",node_name:b,output_slot:d,debug_op:f,state:h};d=vc.getRouter().pluginRoute("debugger","/gated_grpc");b=vc.addParams(d,b);this.set("_busy",!0);this._requestManager.request(b).then(k=>{this.set("_busy",!1);console.log("Breakpoint set_state response: ",k)})},_graphProgressUpdated(b){const d=this.$$("#top-right-progress-bar");null==this._latestSessionRun?
(d.setAttribute("value",0),this.set("_busy",!1)):(d.setAttribute("value",b.value),this.set("_busy",100>b.value))},_handleWindowResize(){this.set("_windowWidth",Hk());this.set("_windowHeight",Zi());this._sizeDashboardRegions(this._leftPaneWidth,this._topRightQuadrantHeight,this._windowWidth)},_computeMaxleftPaneWidth(b,d,f){return b-d-f},_computeMaxTopRightQuadrantHeight(b,d){return b-d-70},_sizeDashboardRegions(b,d,f){this.$$("#left-pane").style.width=b+"px";b=f-b-this._resizerWidth-8;this.$$("#center-content").style.width=
b+"px";b=d-this._resizerWidth;this.$$("#top-right-quadrant").style.height=b+"px";this.$$("#tensor-data").style.top=d+"px"},_leftPaneWidthObserver:pd.getNumberObserver("_leftPaneWidth",{defaultValue:450}),_topRightQuadrantHeightObserver:pd.getNumberObserver("_topRightQuadrantHeight",{defaultValue:Ik})});

//# sourceURL=build://paper-material/paper-material.html.js
Polymer({is:"paper-material",properties:{elevation:{type:Number,reflectToAttribute:!0,value:1},animated:{type:Boolean,reflectToAttribute:!0,value:!1}}});

//# sourceURL=build://tf-graph-debugger-data-card/tf-graph-debugger-data-card.html.js
(function(){Polymer({is:"tf-graph-debugger-data-card",properties:{renderHierarchy:Object,debuggerNumericAlerts:{type:Array,notify:!0},nodeNamesToHealthPills:Object,healthPillStepIndex:{type:Number,notify:!0},specificHealthPillStep:{type:Number,value:0,notify:!0},selectedNode:{type:String,notify:!0},highlightedNode:{type:String,notify:!0},selectedNodeInclude:{type:Number,notify:!0},areHealthPillsLoading:Boolean,healthPillEntries:{type:Array,value:tf.graph.scene.healthPillEntries,readOnly:!0},healthPillValuesForSelectedNode:{type:Array,
computed:"_computeHealthPillForNode(nodeNamesToHealthPills, healthPillStepIndex, selectedNode, allStepsModeEnabled, areHealthPillsLoading)"},allStepsModeEnabled:{type:Boolean,notify:!0},_biggestStepEverSeen:{type:Number,computed:"_computeBiggestStepEverSeen(nodeNamesToHealthPills)"},_maxStepIndex:{type:Number,computed:"_computeMaxStepIndex(nodeNamesToHealthPills)"},_currentStepDisplayValue:{type:String,computed:"_computeCurrentStepDisplayValue(nodeNamesToHealthPills, healthPillStepIndex, allStepsModeEnabled, specificHealthPillStep, areHealthPillsLoading)"}},
observers:["_updateAlertsList(debuggerNumericAlerts)"],ready:function(){var b=document.getElementById("mainContainer"),d=document.querySelector("tf-dashboard-layout .scrollbar");b&&d&&(b.style.overflow="hidden",d.style.overflow="hidden")},_healthPillsAvailable:function(b,d){return b&&d},_computeTensorCountString:function(b,d){return b?b[d].toFixed(0):""},_computeHealthPillForNode:function(b,d,f,h,k){if(k||!f)return null;b=b[f];return b?(d=b[h?0:d])?d.value.slice(2,8):null:null},_computeCurrentStepDisplayValue:function(b,
d,f,h,k){if(f)return h.toFixed(0);if(k)return 0;for(let t in b)return b[t][d].step.toFixed(0);return 0},_computeBiggestStepEverSeen:function(b){for(let d in b)return b=b[d],Math.max(this._biggestStepEverSeen,b[b.length-1].step);return this._biggestStepEverSeen||0},_computeMaxStepIndex:function(b){for(let d in b)return b[d].length-1;return 0},_hasDebuggerNumericAlerts:function(b){return b&&b.length},_updateAlertsList:function(b){var d=this.$$("#numeric-alerts-body");if(d){d.innerHTML="";for(var f=
0;f<b.length;f++){var h=b[f],k=document.createElement("tr"),t=document.createElement("td");t.innerHTML=tf.graph.util.computeHumanFriendlyTime(h.first_timestamp);t.classList.add("first-offense-td");k.appendChild(t);t=document.createElement("td");t.classList.add("tensor-device-td");var l=document.createElement("div");l.classList.add("tensor-section-within-table");l.innerHTML=h.tensor_name;this._addOpExpansionListener(l,h.tensor_name);t.appendChild(l);l=document.createElement("div");l.classList.add("device-section-within-table");
l.innerHTML="("+h.device_name+")";t.appendChild(l);k.appendChild(t);t=document.createElement("div");t.classList.add("mini-health-pill");l=document.createElement("td");l.classList.add("mini-health-pill-td");l.appendChild(t);k.appendChild(l);h.neg_inf_event_count&&(l=document.createElement("div"),l.classList.add("negative-inf-mini-health-pill-section"),l.innerHTML=h.neg_inf_event_count,l.setAttribute("title",h.neg_inf_event_count+" events with -\u221e"),t.appendChild(l));h.pos_inf_event_count&&(l=document.createElement("div"),
l.classList.add("positive-inf-mini-health-pill-section"),l.innerHTML=h.pos_inf_event_count,l.setAttribute("title",h.pos_inf_event_count+" events with +\u221e"),t.appendChild(l));h.nan_event_count&&(l=document.createElement("div"),l.classList.add("nan-mini-health-pill-section"),l.innerHTML=h.nan_event_count,l.setAttribute("title",h.nan_event_count+" events with NaN"),t.appendChild(l));Polymer.dom(d).appendChild(k)}}},_addOpExpansionListener:function(b,d){b.addEventListener("click",()=>{var f=tf.graph.render.expandUntilNodeIsShown(this.renderHierarchy,
d),h,k=document.querySelector("tf-graph-info#graph-info");k&&(h=k.scrollHeight-k.scrollTop);var t=this.selectedNode;this.set("selectedNode",f);f=()=>{k.scrollTop=k.scrollHeight-h};k&&(t?f():window.setTimeout(f,20))})}})})();

//# sourceURL=build://iron-scroll-target-behavior/iron-scroll-target-behavior.html.js
Polymer.IronScrollTargetBehavior={properties:{scrollTarget:{type:HTMLElement,value:function(){return this._defaultScrollTarget}}},observers:["_scrollTargetChanged(scrollTarget, isAttached)"],_shouldHaveListener:!0,_scrollTargetChanged:function(b,d){this._oldScrollTarget&&(this._toggleScrollListener(!1,this._oldScrollTarget),this._oldScrollTarget=null);d&&("document"===b?this.scrollTarget=this._doc:"string"===typeof b?this.scrollTarget=(d=this.domHost)&&d.$?d.$[b]:Polymer.dom(this.ownerDocument).querySelector("#"+
b):this._isValidScrollTarget()&&(this._oldScrollTarget=b,this._toggleScrollListener(this._shouldHaveListener,b)))},_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(b){this.scrollTarget===this._doc?window.scrollTo(window.pageXOffset,b):this._isValidScrollTarget()&&(this.scrollTarget.scrollTop=b)},set _scrollLeft(b){this.scrollTarget===this._doc?window.scrollTo(b,window.pageYOffset):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=b)},scroll:function(b,d){this.scrollTarget===this._doc?window.scrollTo(b,d):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=b,this.scrollTarget.scrollTop=d)},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(b,d){d=d===this._doc?window:d;b?this._boundScrollHandler||(this._boundScrollHandler=this._scrollHandler.bind(this),d.addEventListener("scroll",this._boundScrollHandler)):
this._boundScrollHandler&&(d.removeEventListener("scroll",this._boundScrollHandler),this._boundScrollHandler=null)},toggleScrollListener:function(b){this._shouldHaveListener=b;this._toggleScrollListener(b,this.scrollTarget)}};

//# sourceURL=build://iron-list/iron-list.html.js
(function(){var b=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),d=b&&8<=b[1],f=null!=Polymer.flush,h=f?Polymer.Async.animationFrame:0,k=f?Polymer.Async.idlePeriod:1,t=f?Polymer.Async.microTask:2;Polymer.OptionalMutableDataBehavior||(Polymer.OptionalMutableDataBehavior={});Polymer({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:[Polymer.Templatizer,Polymer.IronResizableBehavior,Polymer.IronScrollTargetBehavior,Polymer.OptionalMutableDataBehavior],
_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,_collection: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(){return(this.grid?this._physicalRows*this._rowHeight:this._physicalSize)-this._viewportHeight},get _itemsParent(){return Polymer.dom(Polymer.dom(this._userTemplate).parentNode)},get _maxScrollTop(){return this._estScrollHeight-this._viewportHeight+this._scrollOffset},
get _maxVirtualStart(){var l=this._convertIndexToCompleteRow(this._virtualCount);return Math.max(0,l-this._physicalCount)},set _virtualStart(l){l=this._clamp(l,0,this._maxVirtualStart);this.grid&&(l-=l%this._itemsPerRow);this._virtualStartVal=l},get _virtualStart(){return this._virtualStartVal||0},set _physicalStart(l){l%=this._physicalCount;0>l&&(l=this._physicalCount+l);this.grid&&(l-=l%this._itemsPerRow);this._physicalStartVal=l},get _physicalStart(){return this._physicalStartVal||0},get _physicalEnd(){return(this._physicalStart+
this._physicalCount-1)%this._physicalCount},set _physicalCount(l){this._physicalCountVal=l},get _physicalCount(){return this._physicalCountVal||0},get _optPhysicalSize(){return 0===this._viewportHeight?Infinity:this._viewportHeight*this._maxPages},get _isVisible(){return!(!this.offsetWidth&&!this.offsetHeight)},get firstVisibleIndex(){var l=this._firstVisibleIndexVal;if(null==l){var p=this._physicalTop+this._scrollOffset;this._firstVisibleIndexVal=l=this._iterateItems(function(m,n){p+=this._getPhysicalSizeIncrement(m);
if(p>this._scrollPosition)return this.grid?n-n%this._itemsPerRow:n;if(this.grid&&this._virtualCount-1===n)return n-n%this._itemsPerRow})||0}return l},get lastVisibleIndex(){var l=this._lastVisibleIndexVal;if(null==l){if(this.grid)l=Math.min(this._virtualCount,this.firstVisibleIndex+this._estRowsInView*this._itemsPerRow-1);else{var p=this._physicalTop+this._scrollOffset;this._iterateItems(function(m,n){p<this._scrollBottom&&(l=n);p+=this._getPhysicalSizeIncrement(m)})}this._lastVisibleIndexVal=l}return l},
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,h);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(l){this.style.webkitOverflowScrolling=l===this?"touch":"";this.style.overflowY=l===this?"auto":"";this._firstVisibleIndexVal=this._lastVisibleIndexVal=null;this._debounce("_render",this._render,h)},updateViewportBoundaries:function(){var l=window.getComputedStyle(this);this._scrollerPaddingTop=
this.scrollTarget===this?0:parseInt(l["padding-top"],10);this._isRTL="rtl"===l.direction;this._viewportWidth=this.$.items.offsetWidth;this._viewportHeight=this._scrollTargetHeight;this.grid&&this._updateGridMetrics()},_scrollHandler:function(){var l=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),p=l-this._scrollPosition,m=0<=p;this._scrollPosition=l;this._lastVisibleIndexVal=this._firstVisibleIndexVal=null;Math.abs(p)>this._physicalSize&&0<this._physicalSize?(p-=this._scrollOffset,m=Math.round(p/
this._physicalAverage)*this._itemsPerRow,this._virtualStart+=m,this._physicalStart+=m,this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage,this._update()):0<this._physicalCount&&(l=this._getReusables(m),m?(this._physicalTop=l.physicalTop,this._virtualStart+=l.indexes.length,this._physicalStart+=l.indexes.length):(this._virtualStart-=l.indexes.length,this._physicalStart-=l.indexes.length),this._update(l.indexes,m?null:l.indexes),this._debounce("_increasePoolIfNeeded",
this._increasePoolIfNeeded.bind(this,0),t))},_getReusables:function(l){var p=[],m=this._hiddenContentSize*this._ratio,n=this._virtualStart,q=this._virtualEnd,u=this._physicalCount,x=this._physicalTop+this._scrollOffset;var A=this._physicalBottom+this._scrollOffset;var y=this._scrollTop,w=this._scrollBottom;if(l){var C=this._physicalStart;A=y-x}else C=this._physicalEnd,A-=w;for(;;){var G=this._getPhysicalSizeIncrement(C);A-=G;if(p.length>=u||A<=m)break;if(l){if(q+p.length+1>=this._virtualCount)break;
if(x+G>=y-this._scrollOffset)break;p.push(C);x+=G;C=(C+1)%u}else{if(0>=n-p.length)break;if(x+this._physicalSize-G<=w)break;p.push(C);x-=G;C=0===C?u-1:C-1}}return{indexes:p,physicalTop:x-this._scrollOffset}},_update:function(l,p){if(!(l&&0===l.length||0===this._physicalCount)){this._manageFocus();this._assignModels(l);this._updateMetrics(l);if(p)for(;p.length;)l=p.pop(),this._physicalTop-=this._getPhysicalSizeIncrement(l);this._positionItems();this._updateScrollerSize()}},_createPool:function(l){this._ensureTemplatized();
var p,m=Array(l);for(p=0;p<l;p++){var n=this.stamp(null);m[p]=n.root.querySelector("*");this._itemsParent.appendChild(n.root)}return m},_isClientFull:function(){return 0!=this._scrollBottom&&this._physicalBottom-1>=this._scrollBottom&&this._physicalTop<=this._scrollPosition},_increasePoolIfNeeded:function(l){l=this._clamp(this._physicalCount+l,3,this._virtualCount-this._virtualStart);l=this._convertIndexToCompleteRow(l);if(this.grid){var p=l%this._itemsPerRow;p&&l-p<=this._physicalCount&&(l+=this._itemsPerRow);
l-=p}l-=this._physicalCount;p=Math.round(.5*this._physicalCount);if(!(0>l)){if(0<l){p=window.performance.now();[].push.apply(this._physicalItems,this._createPool(l));for(var m=0;m<l;m++)this._physicalSizes.push(0);this._physicalCount+=l;this._physicalStart>this._physicalEnd&&this._isIndexRendered(this._focusedVirtualIndex)&&this._getPhysicalIndex(this._focusedVirtualIndex)<this._physicalEnd&&(this._physicalStart+=l);this._update();this._templateCost=(window.performance.now()-p)/l;p=Math.round(.5*
this._physicalCount)}this._virtualEnd>=this._virtualCount-1||0===p||(this._isClientFull()?this._physicalSize<this._optPhysicalSize&&this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,this._clamp(Math.round(50/this._templateCost),1,p)),k):this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,p),t))}},_render:function(){if(this.isAttached&&this._isVisible)if(0!==this._physicalCount){var l=this._getReusables(!0);this._physicalTop=l.physicalTop;this._virtualStart+=
l.indexes.length;this._physicalStart+=l.indexes.length;this._update(l.indexes);this._update();this._increasePoolIfNeeded(0)}else 0<this._virtualCount&&(this.updateViewportBoundaries(),this._increasePoolIfNeeded(3))},_ensureTemplatized:function(){if(!this.ctor){(this._userTemplate=this.queryEffectiveChildren("template"))||console.warn("iron-list requires a template to be provided in light-dom");var l={__key__:!0};l[this.as]=!0;l[this.indexAs]=!0;l[this.selectedAs]=!0;l.tabIndex=!0;this._instanceProps=
l;this.templatize(this._userTemplate,this.mutableData)}},_gridChanged:function(l,p){"undefined"!==typeof p&&(this.notifyResize(),Polymer.flush?Polymer.flush():Polymer.dom.flush(),l&&this._updateGridMetrics())},_itemsChanged:function(l){if("items"===l.path)this._physicalTop=this._virtualStart=0,this._virtualCount=this.items?this.items.length:0,this._collection=this.items&&Polymer.Collection?Polymer.Collection.get(this.items):null,this._physicalIndexForKey={},this._lastVisibleIndexVal=this._firstVisibleIndexVal=
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,h);else if("items.splices"===l.path){this._adjustVirtualIndex(l.value.indexSplices);this._virtualCount=this.items?this.items.length:0;if(l.value.indexSplices.some(function(m){return 0<m.addedCount||0<m.removed.length})){var p=
this._getActiveElement();this.contains(p)&&p.blur()}l=l.value.indexSplices.some(function(m){return m.index+m.addedCount>=this._virtualStart&&m.index<=this._virtualEnd},this);this._isClientFull()&&!l||this._debounce("_render",this._render,h)}else"items.length"!==l.path&&this._forwardItemPath(l.path,l.value)},_forwardItemPath:function(l,p){l=l.slice(6);var m=l.indexOf(".");-1===m&&(m=l.length);var n,q=this.modelForElement(this._offscreenFocusedItem);if(f){var u=parseInt(l.substring(0,m),10);if(n=this._isIndexRendered(u)){var x=
this._getPhysicalIndex(u);var A=this.modelForElement(this._physicalItems[x])}else q&&(A=q);if(!A||A[this.indexAs]!==u)return}else if(u=l.substring(0,m),q&&q.__key__===u)A=q;else if(x=this._physicalIndexForKey[u],A=this.modelForElement(this._physicalItems[x]),!A||A.__key__!==u)return;l=l.substring(m+1);l=this.as+(l?"."+l:"");f?A._setPendingPropertyOrPath(l,p,!1,!0):A.notifyPath(l,p,!0);A._flushProperties&&A._flushProperties(!0);n&&(this._updateMetrics([x]),this._positionItems(),this._updateScrollerSize())},
_adjustVirtualIndex:function(l){l.forEach(function(p){p.removed.forEach(this._removeItem,this);p.index<this._virtualStart&&(p=Math.max(p.addedCount-p.removed.length,p.index-this._virtualStart),this._virtualStart+=p,0<=this._focusedVirtualIndex&&(this._focusedVirtualIndex+=p))},this)},_removeItem:function(l){this.$.selector.deselect(l);this._focusedItem&&this.modelForElement(this._focusedItem)[this.as]===l&&this._removeFocusedItem()},_iterateItems:function(l,p){var m,n;if(2===arguments.length&&p)for(n=
0;n<p.length;n++){var q=p[n];var u=this._computeVidx(q);if(null!=(m=l.call(this,q,u)))return m}else{q=this._physicalStart;for(u=this._virtualStart;q<this._physicalCount;q++,u++)if(null!=(m=l.call(this,q,u)))return m;for(q=0;q<this._physicalStart;q++,u++)if(null!=(m=l.call(this,q,u)))return m}},_computeVidx:function(l){return l>=this._physicalStart?this._virtualStart+(l-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+l},_assignModels:function(l){this._iterateItems(function(p,
m){var n=this._physicalItems[p],q=this.items&&this.items[m];if(null!=q){var u=this.modelForElement(n);u.__key__=this._collection?this._collection.getKey(q):null;this._forwardProperty(u,this.as,q);this._forwardProperty(u,this.selectedAs,this.$.selector.isSelected(q));this._forwardProperty(u,this.indexAs,m);this._forwardProperty(u,"tabIndex",this._focusedVirtualIndex===m?0:-1);this._physicalIndexForKey[u.__key__]=p;u._flushProperties&&u._flushProperties(!0);n.removeAttribute("hidden")}else n.setAttribute("hidden",
"")},l)},_updateMetrics:function(l){Polymer.flush?Polymer.flush():Polymer.dom.flush();var p=0,m=0,n=this._physicalAverageCount,q=this._physicalAverage;this._iterateItems(function(u){m+=this._physicalSizes[u];this._physicalSizes[u]=this._physicalItems[u].offsetHeight;p+=this._physicalSizes[u];this._physicalAverageCount+=this._physicalSizes[u]?1:0},l);this.grid?(this._updateGridMetrics(),this._physicalSize=Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight):(m=1===this._itemsPerRow?m:
Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight,this._physicalSize=this._physicalSize+p-m,this._itemsPerRow=1);this._physicalAverageCount!==n&&(this._physicalAverage=Math.round((q*n+p)/this._physicalAverageCount))},_updateGridMetrics:function(){this._itemWidth=0<this._physicalCount?this._physicalItems[0].getBoundingClientRect().width:200;this._rowHeight=0<this._physicalCount?this._physicalItems[0].offsetHeight:200;this._itemsPerRow=this._itemWidth?Math.floor(this._viewportWidth/this._itemWidth):
this._itemsPerRow},_positionItems:function(){this._adjustScrollPosition();var l=this._physicalTop;if(this.grid){var p=(this._viewportWidth-this._itemsPerRow*this._itemWidth)/2;this._iterateItems(function(m,n){var q=Math.floor(n%this._itemsPerRow*this._itemWidth+p);this._isRTL&&(q*=-1);this.translate3d(q+"px",l+"px",0,this._physicalItems[m]);this._shouldRenderNextRow(n)&&(l+=this._rowHeight)})}else this._iterateItems(function(m){this.translate3d(0,l+"px",0,this._physicalItems[m]);l+=this._physicalSizes[m]})},
_getPhysicalSizeIncrement:function(l){return this.grid?this._computeVidx(l)%this._itemsPerRow!==this._itemsPerRow-1?0:this._rowHeight:this._physicalSizes[l]},_shouldRenderNextRow:function(l){return l%this._itemsPerRow===this._itemsPerRow-1},_adjustScrollPosition:function(){var l=0===this._virtualStart?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);if(0!==l){this._physicalTop-=l;var p=this._scrollTop;!d&&0<p&&this._resetScrollPosition(p-l)}},_resetScrollPosition:function(l){this.scrollTarget&&
0<=l&&(this._scrollPosition=this._scrollTop=l)},_updateScrollerSize:function(l){this._estScrollHeight=this.grid?this._virtualRowCount*this._rowHeight:this._physicalBottom+Math.max(this._virtualCount-this._physicalCount-this._virtualStart,0)*this._physicalAverage;if((l=(l=(l=l||0===this._scrollHeight)||this._scrollPosition>=this._estScrollHeight-this._physicalSize)||this.grid&&this.$.items.style.height<this._estScrollHeight)||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._viewportHeight)this.$.items.style.height=
this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight},scrollToItem:function(l){return this.scrollToIndex(this.items.indexOf(l))},scrollToIndex:function(l){if(!("number"!==typeof l||0>l||l>this.items.length-1)&&(Polymer.flush?Polymer.flush():Polymer.dom.flush(),0!==this._physicalCount)){l=this._clamp(l,0,this._virtualCount-1);if(!this._isIndexRendered(l)||l>=this._maxVirtualStart)this._virtualStart=this.grid?l-2*this._itemsPerRow:l-1;this._manageFocus();this._assignModels();this._updateMetrics();
this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage;for(var p=this._physicalStart,m=this._virtualStart,n=0,q=this._hiddenContentSize;m<l&&n<=q;)n+=this._getPhysicalSizeIncrement(p),p=(p+1)%this._physicalCount,m++;this._updateScrollerSize(!0);this._positionItems();this._resetScrollPosition(this._physicalTop+this._scrollOffset+n);this._increasePoolIfNeeded(0);this._lastVisibleIndexVal=this._firstVisibleIndexVal=null}},_resetAverage:function(){this._physicalAverageCount=
this._physicalAverage=0},_resizeHandler:function(){this._debounce("_render",function(){this._lastVisibleIndexVal=this._firstVisibleIndexVal=null;this.updateViewportBoundaries();this._isVisible?(this.toggleScrollListener(!0),this._resetAverage(),this._render()):this.toggleScrollListener(!1)},h)},selectItem:function(l){return this.selectIndex(this.items.indexOf(l))},selectIndex:function(l){if(!(0>l||l>=this._virtualCount)){!this.multiSelection&&this.selectedItem&&this.clearSelection();if(this._isIndexRendered(l)){var p=
this.modelForElement(this._physicalItems[this._getPhysicalIndex(l)]);p&&(p[this.selectedAs]=!0);this.updateSizeForIndex(l)}this.$.selector.selectIndex?this.$.selector.selectIndex(l):this.$.selector.select(this.items[l])}},deselectItem:function(l){return this.deselectIndex(this.items.indexOf(l))},deselectIndex:function(l){0>l||l>=this._virtualCount||(this._isIndexRendered(l)&&(this.modelForElement(this._physicalItems[this._getPhysicalIndex(l)])[this.selectedAs]=!1,this.updateSizeForIndex(l)),this.$.selector.deselectIndex?
this.$.selector.deselectIndex(l):this.$.selector.deselect(this.items[l]))},toggleSelectionForItem:function(l){return this.toggleSelectionForIndex(this.items.indexOf(l))},toggleSelectionForIndex:function(l){(this.$.selector.isIndexSelected?this.$.selector.isIndexSelected(l):this.$.selector.isSelected(this.items[l]))?this.deselectIndex(l):this.selectIndex(l)},clearSelection:function(){this._iterateItems(function(l){this.modelForElement(this._physicalItems[l])[this.selectedAs]=!1});this.$.selector.clearSelection()},
_selectionEnabledChanged:function(l){(l?this.listen:this.unlisten).call(this,this,"tap","_selectionHandler")},_selectionHandler:function(l){var p=this.modelForElement(l.target);if(p){var m=Polymer.dom(l).path[0];l=this._getActiveElement();var n=this._physicalItems[this._getPhysicalIndex(p[this.indexAs])];if("input"!==m.localName&&"button"!==m.localName&&"select"!==m.localName){m=p.tabIndex;p.tabIndex=-100;var q=l?l.tabIndex:-1;p.tabIndex=m;l&&n!==l&&n.contains(l)&&-100!==q||this.toggleSelectionForItem(p[this.as])}}},
_multiSelectionChanged:function(l){this.clearSelection();this.$.selector.multi=l},updateSizeForItem:function(l){return this.updateSizeForIndex(this.items.indexOf(l))},updateSizeForIndex:function(l){if(!this._isIndexRendered(l))return null;this._updateMetrics([this._getPhysicalIndex(l)]);this._positionItems();return null},_manageFocus:function(){var l=this._focusedVirtualIndex;0<=l&&l<this._virtualCount?this._isIndexRendered(l)?this._restoreFocusedItem():this._createFocusBackfillItem():0<this._virtualCount&&
0<this._physicalCount&&(this._focusedPhysicalIndex=this._physicalStart,this._focusedVirtualIndex=this._virtualStart,this._focusedItem=this._physicalItems[this._physicalStart])},_convertIndexToCompleteRow:function(l){this._itemsPerRow=this._itemsPerRow||1;return this.grid?Math.ceil(l/this._itemsPerRow)*this._itemsPerRow:l},_isIndexRendered:function(l){return l>=this._virtualStart&&l<=this._virtualEnd},_isIndexVisible:function(l){return l>=this.firstVisibleIndex&&l<=this.lastVisibleIndex},_getPhysicalIndex:function(l){return f?
(this._physicalStart+(l-this._virtualStart))%this._physicalCount:this._physicalIndexForKey[this._collection.getKey(this.items[l])]},focusItem:function(l){this._focusPhysicalItem(l)},_focusPhysicalItem:function(l){if(!(0>l||l>=this._virtualCount)){this._restoreFocusedItem();this._isIndexRendered(l)||this.scrollToIndex(l);var p=this._physicalItems[this._getPhysicalIndex(l)],m=this.modelForElement(p),n;m.tabIndex=-100;-100===p.tabIndex&&(n=p);n||(n=Polymer.dom(p).querySelector('[tabindex\x3d"-100"]'));
m.tabIndex=0;this._focusedVirtualIndex=l;n&&n.focus()}},_removeFocusedItem:function(){this._offscreenFocusedItem&&this._itemsParent.removeChild(this._offscreenFocusedItem);this._focusedItem=this._focusBackfillItem=this._offscreenFocusedItem=null;this._focusedPhysicalIndex=this._focusedVirtualIndex=-1},_createFocusBackfillItem:function(){var l=this._focusedPhysicalIndex;if(!(this._offscreenFocusedItem||0>this._focusedVirtualIndex)){if(!this._focusBackfillItem){var p=this.stamp(null);this._focusBackfillItem=
p.root.querySelector("*");this._itemsParent.appendChild(p.root)}this._offscreenFocusedItem=this._physicalItems[l];this.modelForElement(this._offscreenFocusedItem).tabIndex=0;this._physicalItems[l]=this._focusBackfillItem;this._focusedPhysicalIndex=l;this.translate3d(0,"-10000px",0,this._offscreenFocusedItem)}},_restoreFocusedItem:function(){if(this._offscreenFocusedItem&&!(0>this._focusedVirtualIndex)){this._assignModels();var l=this._focusedPhysicalIndex=this._getPhysicalIndex(this._focusedVirtualIndex),
p=this._physicalItems[l];if(p){var m=this.modelForElement(p),n=this.modelForElement(this._offscreenFocusedItem);m[this.as]===n[this.as]?(this._focusBackfillItem=p,m.tabIndex=-1,this._physicalItems[l]=this._offscreenFocusedItem,this.translate3d(0,"-10000px",0,this._focusBackfillItem)):(this._removeFocusedItem(),this._focusBackfillItem=null);this._offscreenFocusedItem=null}}},_didFocus:function(l){l=this.modelForElement(l.target);var p=this.modelForElement(this._focusedItem),m=null!==this._offscreenFocusedItem,
n=this._focusedVirtualIndex;l&&(p===l?this._isIndexVisible(n)||this.scrollToIndex(n):(this._restoreFocusedItem(),p&&(p.tabIndex=-1),l.tabIndex=0,this._focusedVirtualIndex=n=l[this.indexAs],this._focusedPhysicalIndex=this._getPhysicalIndex(n),this._focusedItem=this._physicalItems[this._focusedPhysicalIndex],m&&!this._offscreenFocusedItem&&this._update()))},_keydownHandler:function(l){switch(l.keyCode){case 40:this._focusedVirtualIndex<this._virtualCount-1&&l.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:0<this._focusedVirtualIndex&&l.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(l)}},_clamp:function(l,
p,m){return Math.min(m,Math.max(p,l))},_debounce:function(l,p,m){f?(this._debouncers=this._debouncers||{},this._debouncers[l]=Polymer.Debouncer.debounce(this._debouncers[l],m,p.bind(this)),Polymer.enqueueDebouncer(this._debouncers[l])):Polymer.dom.addDebouncer(this.debounce(l,p))},_forwardProperty:function(l,p,m){f?l._setPendingProperty(p,m):l[p]=m},_forwardHostPropV2:function(l,p){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(m){m&&this.modelForElement(m).forwardHostProp(l,
p)},this)},_notifyInstancePropV2:function(l,p,m){Polymer.Path.matches(this.as,p)&&(l=l[this.indexAs],p==this.as&&(this.items[l]=m),this.notifyPath(Polymer.Path.translate(this.as,"items."+l,p),m))},_getStampedChildren:function(){return this._physicalItems},_forwardInstancePath:function(l,p,m){0===p.indexOf(this.as+".")&&this.notifyPath("items."+l.__key__+"."+p.slice(this.as.length+1),m)},_forwardParentPath:function(l,p){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(m){m&&
this.modelForElement(m).notifyPath(l,p,!0)},this)},_forwardParentProp:function(l,p){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(m){m&&(this.modelForElement(m)[l]=p)},this)},_getActiveElement:function(){var l=this._itemsParent.node.domHost;return Polymer.dom(l?l.root:document).activeElement}})})();

//# sourceURL=build://paper-item/paper-item-body.html.js
Polymer({is:"paper-item-body"});

//# sourceURL=build://tf-graph-common/tf-graph-icon.js
(function(b){(function(d){(function(f){let h;(function(k){k.CONST="CONST";k.META="META";k.OP="OP";k.SERIES="SERIES";k.SUMMARY="SUMMARY"})(h=f.GraphIconType||(f.GraphIconType={}));Polymer({is:"tf-graph-icon",properties:{type:String,vertical:{type:Boolean,value:!1},fillOverride:{type:String,value:null},strokeOverride:{type:String,value:null},height:{type:Number,value:20},faded:{type:Boolean,value:!1},_fill:{type:String,computed:"_computeFill(type, fillOverride)"},_stroke:{type:String,computed:"_computeStroke(type, strokeOverride)"}},
getSvgDefinableElement(){return this.$.svgDefs},_computeFill(k,t){if(null!=t)return t;switch(k){case h.META:return b.graph.render.MetanodeColors.DEFAULT_FILL;case h.SERIES:return b.graph.render.SeriesNodeColors.DEFAULT_FILL;default:return b.graph.render.OpNodeColors.DEFAULT_FILL}},_computeStroke(k,t){if(null!=t)return t;switch(k){case h.META:return b.graph.render.MetanodeColors.DEFAULT_STROKE;case h.SERIES:return b.graph.render.SeriesNodeColors.DEFAULT_STROKE;default:return b.graph.render.OpNodeColors.DEFAULT_STROKE}},
_isType(k,t){return k===t},_fadedClass:function(k,t){return k?"faded-"+t:""}})})(d.icon||(d.icon={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/tf-node-icon.html.js
(function(){Polymer({is:"tf-node-icon",properties:{node:{type:Object,value:null},renderInfo:{type:Object,value:null},colorBy:{type:Object,value:"structural"},templateIndex:{type:Function,value:null},type:{type:String,value:null},vertical:{type:Boolean,value:!1},const:{type:Boolean,value:!1},summary:{type:Boolean,value:!1},fill:{type:String,value:null},height:{type:Number,value:20},_fillOverride:{type:String,computed:"_computeFillOverride(node, renderInfo, colorBy, templateIndex, fill)",observer:"_onFillOverrideChanged"}},
_computeFillOverride:function(b,d,f,h,k){return b&&d&&f&&h?(b=tf.graph.scene.node,b.getFillForNode(h,b.ColorBy[f.toUpperCase()],d,!1)):k},_getStrokeOverride:function(b){return b?tf.graph.scene.node.getStrokeForFill(b):null},_getType:function(b,d,f,h){const k=tf.graph.icon.GraphIconType;if(b)switch(b.type){case tf.graph.NodeType.OP:return b=b.op,"string"!==typeof b?k.OP:"Const"===b||f?k.CONST:b.endsWith("Summary")||d?k.SUMMARY:k.OP;case tf.graph.NodeType.META:return k.META;case tf.graph.NodeType.SERIES:return k.SERIES}return h},
_isVertical:function(b,d){return b?b.hasNonControlEdges:!!d},_getFaded:function(b){return b&&b.isFadedOut},_onFillOverrideChanged(b,d){const f=this.node,h=this.renderInfo,k=this.colorBy,t=this.templateIndex,l=tf.graph.scene.node;b!==d&&l.removeGradientDefinitions(this.$.icon.getSvgDefinableElement());f&&h&&k&&t&&l.getFillForNode(t,l.ColorBy[k.toUpperCase()],h,!1,this.$.icon.getSvgDefinableElement())}})})();

//# sourceURL=build://tf-graph-op-compat-card/tf-graph-op-compat-list-item.html.js
(function(){Polymer({is:"tf-graph-op-compat-list-item",properties:{cardNode:Object,itemNode:Object,edgeLabel:String,itemRenderInfo:Object,name:String,itemType:{type:String,observer:"_itemTypeChanged"},colorBy:String,colorByParams:Object,templateIndex:Function},_itemTypeChanged:function(){"subnode"!==this.itemType?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")},_nodeListener:function(b){this.fire("node-list-item-"+b.type,{nodeName:this.name,type:this.itemType})},
_fadedClass:function(b){return b&&b.isFadedOut?"faded":""}})})();

//# sourceURL=build://tf-graph-op-compat-card/tf-graph-op-compat-card.html.js
(function(){Polymer({is:"tf-graph-op-compat-card",properties:{graphHierarchy:Object,hierarchyParams:Object,renderHierarchy:Object,nodeTitle:String,_templateIndex:{type:Function,computed:"_getTemplateIndex(graphHierarchy)"},_incompatibleOpNodes:{type:Object,computed:"_getIncompatibleOpNodes(graphHierarchy, hierarchyParams)"},_expanded:{type:Boolean,value:!0},_opCompatScore:{type:Number,computed:"_computeOpCompatScore(graphHierarchy)"},_opCompatScoreLabel:{type:String,computed:"_getOpCompatScoreLabel(_opCompatScore)"},
_opCompatColor:{type:String,value:tf.graph.render.OpNodeColors.COMPATIBLE},_opIncompatColor:{type:String,value:tf.graph.render.OpNodeColors.INCOMPATIBLE},_totalIncompatOps:{type:Number,computed:"_getTotalIncompatibleOps(graphHierarchy)"}},_getTemplateIndex:function(b){return b.getTemplateIndex()},_getNode:function(b,d){return d.node(b)},_getPrintableHTMLNodeName:function(b){return(b||"").replace(/\//g,"\x3cwbr\x3e/")},_getRenderInfo:function(b){return this.renderHierarchy.getOrCreateRenderNodeByName(b)},
_toggleExpanded:function(){this._expanded=!this._expanded},_getToggleIcon:function(b){return b?"expand-less":"expand-more"},_resizeList:function(b){(b=document.querySelector(b))&&b.fire("iron-resize")},_getIncompatibleOpNodes:function(b,d){if(b&&b.root)return this.async(this._resizeList.bind(this,"#incompatibleOpsList")),tf.graph.hierarchy.getIncompatibleOps(b,d)},_computeOpCompatScore:function(b){if(b&&b.root){var d=b.root;b=d.compatibilityHistogram.compatible;d=d.compatibilityHistogram.incompatible;
return 0==b&&0==d?0:Math.floor(100*b/(b+d))/100}return 0},_getOpCompatScoreLabel:function(b){return d3.format(".0%")(b)},_getTotalIncompatibleOps:function(b){return b&&b.root?b.root.compatibilityHistogram.incompatible:0}})})();

//# sourceURL=build://tf-graph-info/tf-node-list-item.html.js
(function(){Polymer({is:"tf-node-list-item",properties:{cardNode:Object,itemNode:Object,edgeLabel:String,itemRenderInfo:Object,name:String,itemType:{type:String,observer:"_itemTypeChanged"},colorBy:String,colorByParams:Object,templateIndex:Function},_itemTypeChanged:function(){"subnode"!==this.itemType?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")},_nodeListener:function(b){this.fire("node-list-item-"+b.type,{cardNode:this.cardNode.name,nodeName:this.name,
type:this.itemType})},_fadedClass:function(b){return b&&b.isFadedOut?"faded":""}})})();

//# sourceURL=build://tf-graph-info/tf-node-info.html.js
(function(){Polymer({is:"tf-node-info",properties:{graphNodeName:String,graphHierarchy:Object,renderHierarchy:Object,colorBy:String,_templateIndex:{type:Function,computed:"_getTemplateIndex(graphHierarchy)"},_node:{type:Object,computed:"_getNode(graphNodeName, graphHierarchy)",observer:"_resetState"},_nodeStats:{type:Object,computed:"_getNodeStats(graphNodeName, graphHierarchy)",observer:"_resetState"},_hasDisplayableNodeStats:{type:Object,computed:"_getHasDisplayableNodeStats(_nodeStats)"},_nodeStatsFormattedBytes:{type:String,
computed:"_getNodeStatsFormattedBytes(_nodeStats)"},_nodeStatsFormattedComputeTime:{type:String,computed:"_getNodeStatsFormattedComputeTime(_nodeStats)"},_nodeStatsFormattedOutputSizes:{type:Array,computed:"_getNodeStatsFormattedOutputSizes(_nodeStats)"},nodeInclude:{type:Number,observer:"_nodeIncludeStateChanged"},_attributes:{type:Array,computed:"_getAttributes(_node)"},_device:{type:String,computed:"_getDevice(_node)"},_successors:{type:Object,computed:"_getSuccessors(_node, graphHierarchy)"},
_predecessors:{type:Object,computed:"_getPredecessors(_node, graphHierarchy)"},_functionUsages:{type:Array,computed:"_getFunctionUsages(_node, graphHierarchy)"},_subnodes:{type:Array,computed:"_getSubnodes(_node)"},_expanded:{type:Boolean,value:!0},_totalPredecessors:{type:Number,computed:"_getTotalPred(_predecessors)"},_totalSuccessors:{type:Number,computed:"_getTotalSucc(_successors)"},_openedControlPred:{type:Boolean,value:!1},_openedControlSucc:{type:Boolean,value:!1},_auxButtonText:String,_groupButtonText:String},
expandNode:function(){this.fire("_node.expand",this.node)},_getTemplateIndex:function(b){return b.getTemplateIndex()},_getNode:function(b,d){return d.node(b)},_getNodeStats:function(b,d){return(b=this._getNode(b,d))?b.stats:null},_getTotalMicros:function(b){return b?b.getTotalMicros():0},_getHasDisplayableNodeStats:function(b){return tf.graph.util.hasDisplayableNodeStats(b)},_getNodeStatsFormattedBytes:function(b){if(b&&b.totalBytes)return tf.graph.util.convertUnitsToHumanReadable(b.totalBytes,tf.graph.util.MEMORY_UNITS)},
_getNodeStatsFormattedComputeTime:function(b){if(b&&b.getTotalMicros())return tf.graph.util.convertUnitsToHumanReadable(b.getTotalMicros(),tf.graph.util.TIME_UNITS)},_getNodeStatsFormattedOutputSizes:function(b){if(b&&b.outputSize&&b.outputSize.length)return _.map(b.outputSize,function(d){return 0===d.length?"scalar":"["+d.join(", ")+"]"})},_getPrintableHTMLNodeName:function(b){return(b||"").replace(/\//g,"\x3cwbr\x3e/")},_getRenderInfo:function(b){return this.renderHierarchy.getOrCreateRenderNodeByName(b)},
_getAttributes:function(b){this.async(this._resizeList.bind(this,"#attributesList"));if(!b||!b.attr)return[];var d=[];_.each(b.attr,function(f){f.key===tf.graph.LARGE_ATTRS_KEY?d=d.concat(f.value.list.s.map(function(h){return{key:h,value:"Too large to show..."}})):d.push({key:f.key,value:JSON.stringify(f.value)})});return d},_getDevice:function(b){return b?b.device:null},_getSuccessors(b,d){this._refreshNodeItemList("inputsList");return b?this._convertEdgeListToEdgeInfoList(d.getSuccessors(b.name),
!1,b.isGroupNode):{regular:[],control:[]}},_getPredecessors(b,d){this._refreshNodeItemList("outputsList");return b?this._convertEdgeListToEdgeInfoList(d.getPredecessors(b.name),!0,b.isGroupNode):{regular:[],control:[]}},_getFunctionUsages(b,d){this._refreshNodeItemList("functionUsagesList");return b&&b.type===tf.graph.NodeType.META?(b=d.libraryFunctions[b.associatedFunction])?b.usages:[]:[]},_refreshNodeItemList(b){this.async(this._resizeList.bind(this,`#${b}`))},_convertEdgeListToEdgeInfoList:function(b,
d,f){var h=t=>_.map(t.baseEdgeList,l=>{var p=d?l.v:l.w;return{name:p,node:this._getNode(p,this.graphHierarchy),edgeLabel:tf.graph.scene.edge.getLabelForBaseEdge(l,this.renderHierarchy),renderInfo:this._getRenderInfo(p,this.renderHierarchy)}}),k=function(t){var l=[];_.each(t,p=>{var m=d?p.v:p.w;f&&1!=p.baseEdgeList.length?l.push({name:m,node:this._getNode(m,this.graphHierarchy),edgeLabel:tf.graph.scene.edge.getLabelForEdge(p,this.renderHierarchy),renderInfo:this._getRenderInfo(m,this.renderHierarchy)}):
l=l.concat(h(p))});return l}.bind(this);return{regular:k(b.regular),control:k(b.control)}},_getSubnodes:function(b){return b&&b.metagraph?b.metagraph.nodes():null},_getTotalPred:function(b){return b.regular.length+b.control.length},_getTotalSucc:function(b){return b.regular.length+b.control.length},_toggleControlPred:function(){this._openedControlPred=!this._openedControlPred},_toggleControlSucc:function(){this._openedControlSucc=!this._openedControlSucc},_toggleExpanded:function(){this._expanded=
!this._expanded},_getToggleIcon:function(b){return b?"expand-less":"expand-more"},_resetState:function(){this._openedControlSucc=this._openedControlPred=!1;this.set("_groupButtonText",tf.graph.scene.node.getGroupSettingLabel(this._node));this._node&&(Polymer.dom(this.$.nodetitle).innerHTML=this._getPrintableHTMLNodeName(this._node.name))},_resizeList:function(b){(b=document.querySelector(b))&&b.fire("iron-resize")},_toggleInclude:function(){this.fire("node-toggle-inclusion",{name:this.graphNodeName})},
_nodeIncludeStateChanged:function(b){this.set("_auxButtonText",tf.graph.getIncludeNodeButtonString(b))},_toggleGroup:function(){var b=tf.graph.scene.node.getSeriesName(this._node);this.fire("node-toggle-seriesgroup",{name:b})},_isLibraryFunction(b){return b&&b.name.startsWith(tf.graph.FUNCTION_LIBRARY_NODE_PREFIX)},_isInSeries:function(b){return tf.graph.scene.node.canBeInSeries(b)}})})();

//# sourceURL=build://tf-graph-info/tf-graph-info.html.js
(function(){Polymer({is:"tf-graph-info",properties:{title:String,graphHierarchy:Object,graph:Object,renderHierarchy:Object,nodeNamesToHealthPills:Object,healthPillStepIndex:{type:Number,notify:!0},colorBy:String,compatNodeTitle:String,selectedNode:{type:String,notify:!0},highlightedNode:{type:String,notify:!0},selectedNodeInclude:{type:Number,notify:!0},debuggerDataEnabled:Boolean},listeners:{"node-list-item-click":"_nodeListItemClicked","node-list-item-mouseover":"_nodeListItemMouseover","node-list-item-mouseout":"_nodeListItemMouseout"},
_nodeListItemClicked:function(b){this.selectedNode=b.detail.nodeName},_nodeListItemMouseover:function(b){this.highlightedNode=b.detail.nodeName},_nodeListItemMouseout:function(){this.highlightedNode=null},_healthPillsAvailable:function(b,d){return b&&d&&0<Object.keys(d).length},_equals:function(b,d){return b===d}})})();

//# sourceURL=build://tf-graph-board/tf-graph-board.html.js
Polymer({is:"tf-graph-board",properties:{graphHierarchy:Object,graph:Object,stats:Object,progress:Object,traceInputs:Boolean,colorBy:String,colorByParams:{type:Object,notify:!0},renderHierarchy:{type:Object,notify:!0},debuggerDataEnabled:Boolean,areHealthPillsLoading:Boolean,debuggerNumericAlerts:{type:Array,notify:!0},nodeNamesToHealthPills:Object,allStepsModeEnabled:{type:Boolean,notify:!0,value:!1},specificHealthPillStep:{type:Number,notify:!0,value:0},healthPillStepIndex:Number,selectedNode:{type:String,
notify:!0},compatNodeTitle:{type:String,value:"TPU Compatibility"},edgeWidthFunction:Object,_selectedNodeInclude:Number,_highlightedNode:String,handleNodeSelected:Object,edgeLabelFunction:Object,handleEdgeSelected:Object},observers:["_updateNodeInclude(selectedNode, renderHierarchy)"],fit:function(){this.$.graph.fit()},_isNotComplete:function(b){return 100>b.value},_getContainerClass:function(b){var d="container";b.error&&(d+=" error");this._isNotComplete(b)&&(d+=" loading");return d},_onNodeInclusionToggled(b){this.$.graph.nodeToggleExtract(b.detail.name)},
_onNodeSeriesGroupToggled(b){this.$.graph.nodeToggleSeriesGroup(b.detail.name)},_updateNodeInclude(){const b=this.renderHierarchy?this.renderHierarchy.getNodeByName(this.selectedNode):null;this._selectedNodeInclude=b?b.include:tf.graph.InclusionType.UNSPECIFIED}});

//# sourceURL=build://iron-menu-behavior/iron-menubar-behavior.html.js
Polymer.IronMenubarBehaviorImpl={hostAttributes:{role:"menubar"},keyBindings:{left:"_onLeftKey",right:"_onRightKey"},_onUpKey:function(b){this.focusedItem.click();b.detail.keyboardEvent.preventDefault()},_onDownKey:function(b){this.focusedItem.click();b.detail.keyboardEvent.preventDefault()},get _isRTL(){return"rtl"===window.getComputedStyle(this).direction},_onLeftKey:function(b){this._isRTL?this._focusNext():this._focusPrevious();b.detail.keyboardEvent.preventDefault()},_onRightKey:function(b){this._isRTL?
this._focusPrevious():this._focusNext();b.detail.keyboardEvent.preventDefault()},_onKeydown:function(b){this.keyboardEventMatchesKeys(b,"up down left right esc")||this._focusWithKeyboardEvent(b)}};Polymer.IronMenubarBehavior=[Polymer.IronMenuBehavior,Polymer.IronMenubarBehaviorImpl];

//# sourceURL=build://paper-radio-button/paper-radio-button.html.js
Polymer({is:"paper-radio-button",behaviors:[Polymer.PaperCheckedElementBehavior],hostAttributes:{role:"radio","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},ready:function(){this._rippleContainer=this.$.radioContainer},attached:function(){Polymer.RenderStatus.afterNextRender(this,function(){if("-1px"===this.getComputedStyleValue("--calculated-paper-radio-button-ink-size").trim()){var b=parseFloat(this.getComputedStyleValue("--calculated-paper-radio-button-size").trim()),
d=Math.floor(3*b);d%2!==b%2&&d++;this.updateStyles({"--paper-radio-button-ink-size":d+"px"})}})}});

//# sourceURL=build://paper-radio-group/paper-radio-group.html.js
Polymer({is:"paper-radio-group",behaviors:[Polymer.IronMenubarBehavior],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(b){var d=this._valueToItem(b);if(!d||!d.hasAttribute("disabled")){if(this.selected){d=this._valueToItem(this.selected);if(this.selected==b)if(this.allowEmptySelection)b="";else{d&&
(d.checked=!0);return}d&&(d.checked=!1)}Polymer.IronSelectableBehavior.select.apply(this,[b]);this.fire("paper-radio-group-changed")}},_activateFocusedItem:function(){this._itemActivate(this._valueForItem(this.focusedItem),this.focusedItem)},_onUpKey:function(b){this._focusPrevious();b.preventDefault();this._activateFocusedItem()},_onDownKey:function(b){this._focusNext();b.preventDefault();this._activateFocusedItem()},_onLeftKey:function(b){Polymer.IronMenubarBehaviorImpl._onLeftKey.apply(this,arguments);
this._activateFocusedItem()},_onRightKey:function(b){Polymer.IronMenubarBehaviorImpl._onRightKey.apply(this,arguments);this._activateFocusedItem()}});

//# sourceURL=build://paper-tooltip/paper-tooltip.html.js
Polymer({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 b=Polymer.dom(this).parentNode,d=Polymer.dom(this).getOwnerRoot();return this.for?Polymer.dom(d).querySelector("#"+this.for):b.nodeType==Node.DOCUMENT_FRAGMENT_NODE?d.host:b},attached:function(){this._findTarget()},detached:function(){this.manualMode||this._removeListeners()},
playAnimation:function(b){"entry"===b?this.show():"exit"===b&&this.hide()},cancelAnimation:function(){this.$.tooltip.classList.add("cancel-animation")},show:function(){if(!this._showing){if(""===Polymer.dom(this).textContent.trim()){for(var b=!0,d=Polymer.dom(this).getEffectiveChildNodes(),f=0;f<d.length;f++)if(""!==d[f].textContent.trim()){b=!1;break}if(b)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(){this._showing&&(this._animationPlaying?(this._showing=!1,this._cancelAnimation()):(this._onAnimationFinish(),this._showing=!1,this._animationPlaying=!0))},updatePosition:function(){if(this._target&&this.offsetParent){var b=this.offset;14!=this.marginTop&&14==this.offset&&(b=this.marginTop);var d=this.offsetParent.getBoundingClientRect(),f=this._target.getBoundingClientRect(),
h=this.getBoundingClientRect(),k=(f.width-h.width)/2,t=(f.height-h.height)/2,l=f.left-d.left,p=f.top-d.top;switch(this.position){case "top":var m=l+k;var n=p-h.height-b;break;case "bottom":m=l+k;n=p+f.height+b;break;case "left":m=l-h.width-b;n=p+t;break;case "right":m=l+f.width+b,n=p+t}this.fitToVisibleBounds?(d.left+m+h.width>window.innerWidth?(this.style.right="0px",this.style.left="auto"):(this.style.left=Math.max(0,m)+"px",this.style.right="auto"),d.top+n+h.height>window.innerHeight?(this.style.bottom=
d.height+"px",this.style.top="auto"):(this.style.top=Math.max(-d.top,n)+"px",this.style.bottom="auto")):(this.style.left=m+"px",this.style.top=n+"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(b){500!==b&&this.updateStyles({"--paper-tooltip-delay-in":b+"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(b){if("entry"===b&&""!==this.animationEntry)return this.animationEntry;
if("exit"===b&&""!==this.animationExit)return this.animationExit;if(this.animationConfig[b]&&"string"===typeof this.animationConfig[b][0].name){if(this.animationConfig[b][0].timing&&this.animationConfig[b][0].timing.delay&&0!==this.animationConfig[b][0].timing.delay){var d=this.animationConfig[b][0].timing.delay;"entry"===b?this.updateStyles({"--paper-tooltip-delay-in":d+"ms"}):"exit"===b&&this.updateStyles({"--paper-tooltip-delay-out":d+"ms"})}return this.animationConfig[b][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")}});

//# sourceURL=build://tf-graph-node-search/tf-graph-node-search.html.js
Polymer({is:"tf-graph-node-search",properties:{renderHierarchy:Object,selectedNode:{type:String,notify:!0},_rawRegexInput:{type:String,value:""},_regexInput:{type:String,computed:"_computeRegexInput(renderHierarchy, _rawRegexInput)"},_previousRegexInput:{type:String,value:""},_searchTimeoutDelay:{type:Number,value:150,readOnly:!0},_searchPending:Boolean,_maxRegexResults:{type:Number,value:42},_regexMatches:Array},observers:["_regexInputChanged(_regexInput)"],_computeRegexInput(b,d){return d.trim()},
_regexInputChanged(){this._requestSearch()},_clearSearchResults(){this.set("_regexMatches",[])},_requestSearch(){this._searchPending||(this._regexInput===this._previousRegexInput?this._searchPending=!1:(this._searchPending=!0,this._executeSearch(),this.async(()=>{this._searchPending=!1;this._requestSearch()},this._searchTimeoutDelay)))},_executeSearch(){if(this._previousRegexInput=this._regexInput){try{var b=new RegExp(this._regexInput)}catch(f){this._clearSearchResults();return}var d=[];_.each(this.renderHierarchy.hierarchy.getNodeMap(),
(f,h)=>{if(d.length>=this._maxRegexResults)return!1;b.test(h)&&d.push(h)});this.set("_regexMatches",d)}else this._clearSearchResults()},_matchClicked(b){this.set("selectedNode",b.model.item)}});

//# sourceURL=build://tf-graph-controls/tf-graph-controls.js
(function(b){(function(d){(function(f){const h=/device:([^:]+:[0-9]+)$/,k=[{regex:h}],t=[];let l;(function(m){m.COMPUTE_TIME="compute_time";m.MEMORY="memory";m.STRUCTURE="structure";m.XLA_CLUSTER="xla_cluster";m.OP_COMPATIBILITY="op_compatibility"})(l=f.ColorBy||(f.ColorBy={}));const p=new Set([l.COMPUTE_TIME,l.MEMORY]);Polymer({is:"tf-graph-controls",properties:{stats:{value:null,type:Object,observer:"_statsChanged"},devicesForStats:{value:null,type:Object,notify:!0,readonly:!0},colorBy:{type:String,
value:l.STRUCTURE,notify:!0},colorByParams:{type:Object,notify:!0,readonly:!0},datasets:{type:Array,observer:"_datasetsChanged",value:()=>[]},renderHierarchy:{type:Object},selection:{type:Object,notify:!0,readOnly:!0,computed:"_computeSelection(datasets, _selectedRunIndex, _selectedTagIndex, _selectedGraphType)"},selectedFile:{type:Object,notify:!0},_selectedRunIndex:{type:Number,value:0,observer:"_selectedRunIndexChanged"},traceInputs:{type:Boolean,notify:!0,value:!1},_selectedTagIndex:{type:Number,
value:0,observer:"_selectedTagIndexChanged"},_selectedGraphType:{type:String,value:b.graph.SelectionType.OP_GRAPH},selectedNode:{type:String,notify:!0},_currentDevices:{type:Array,computed:"_getCurrentDevices(devicesForStats)"},_currentDeviceParams:{type:Array,computed:"_getCurrentDeviceParams(colorByParams)"},_currentXlaClusterParams:{type:Array,computed:"_getCurrentXlaClusterParams(colorByParams)"},_currentGradientParams:{type:Object,computed:"_getCurrentGradientParams(colorByParams, colorBy)"},
showSessionRunsDropdown:{type:Boolean,value:!0},showUploadButton:{type:Boolean,value:!0},healthPillsFeatureEnabled:Boolean,healthPillsToggledOn:{type:Boolean,notify:!0},_legendOpened:{type:Boolean,value:!0}},_xlaClustersProvided:function(m){return m&&m.hierarchy&&0<m.hierarchy.xlaClusters.length},_statsChanged:function(m){if(null!=m){var n={};_.each(m.dev_stats,function(q){var u=_.some(k,function(A){return A.regex.test(q.device)}),x=_.some(t,function(A){return A.regex.test(q.device)});u&&!x&&(n[q.device]=
!0)});this.set("devicesForStats",n)}},_getCurrentDevices:function(m){var n=this.stats;n=(n?n.dev_stats:[]).map(u=>u.device).filter(u=>k.some(x=>x.regex.test(u)));const q=b.graph.util.removeCommonPrefix(n);if(1==q.length){const u=q[0].match(h);u&&(q[0]=u[1])}return n.map((u,x)=>{let A=null;t.forEach(y=>{y.regex.test(u)&&(A=y.msg)});return{device:u,suffix:q[x],used:m[u],ignoredMsg:A}})},_deviceCheckboxClicked:function(m){m=m.target;const n=Object.assign({},this.devicesForStats),q=m.value;m.checked?
n[q]=!0:delete n[q];this.set("devicesForStats",n)},_numTags:function(m,n){return this._getTags(m,n).length},_getTags:function(m,n){return m&&m[n]?m[n].tags:[]},_fit:function(){this.fire("fit-tap")},_isGradientColoring:function(m,n){return p.has(n)&&null!=m},_equals:function(m,n){return m===n},_getCurrentDeviceParams:function(m){m=m.device.filter(u=>k.some(x=>x.regex.test(u.device)));const n=b.graph.util.removeCommonPrefix(m.map(u=>u.device));if(1==n.length){var q=n[0].match(h);q&&(n[0]=q[1])}return m.map((u,
x)=>({device:n[x],color:u.color}))},_getCurrentXlaClusterParams:function(m){return m.xla_cluster},_getCurrentGradientParams:function(m,n){if(this._isGradientColoring(this.stats,n)){m=m[n];var q=m.minValue,u=m.maxValue;n===l.MEMORY?(q=b.graph.util.convertUnitsToHumanReadable(q,b.graph.util.MEMORY_UNITS),u=b.graph.util.convertUnitsToHumanReadable(u,b.graph.util.MEMORY_UNITS)):n===l.COMPUTE_TIME&&(q=b.graph.util.convertUnitsToHumanReadable(q,b.graph.util.TIME_UNITS),u=b.graph.util.convertUnitsToHumanReadable(u,
b.graph.util.TIME_UNITS));return{minValue:q,maxValue:u,startColor:m.startColor,endColor:m.endColor}}},download:function(){this.$.graphdownload.click()},_updateFileInput:function(m){var n=m.target.files[0];if(n){n=n.name;var q=n.lastIndexOf(".");0<=q&&(n=n.substring(0,q));q=n.lastIndexOf("/");0<=q&&(n=n.substring(q+1));this._setDownloadFilename(n);this.set("selectedFile",m)}},_datasetsChanged:function(m,n){null!=n&&(this._selectedRunIndex=0)},_computeSelection:function(m,n,q,u){return m[n]&&m[n].tags[q]?
{run:m[n].name,tag:m[n].tags[q].tag,type:u}:null},_selectedRunIndexChanged:function(m){this.datasets&&(this.colorBy=l.STRUCTURE,this._selectedTagIndex=0,this._selectedGraphType=this._getDefaultSelectionType(),this.traceInputs=!1,this._setDownloadFilename(this.datasets[m]?this.datasets[m].name:""))},_selectedTagIndexChanged(){this._selectedGraphType=this._getDefaultSelectionType()},_getDefaultSelectionType(){const m=this.datasets,n=this._selectedRunIndex,q=this._selectedTagIndex;return m&&m[n]&&m[n].tags[q]&&
!m[n].tags[q].opGraph?m[n].tags[q].profile?b.graph.SelectionType.PROFILE:m[n].tags[q].conceptualGraph?b.graph.SelectionType.CONCEPTUAL_GRAPH:b.graph.SelectionType.OP_GRAPH:b.graph.SelectionType.OP_GRAPH},_getFile:function(){this.$$("#file").click()},_setDownloadFilename:function(m){this.$.graphdownload.setAttribute("download",m+".png")},_statsNotNull:function(m){return null!==m},_toggleLegendOpen(){this.set("_legendOpened",!this._legendOpened)},_getToggleText(m){return m?"Close legend.":"Expand legend."},
_getToggleLegendIcon(m){return m?"expand-more":"expand-less"},_getSelectionOpGraphDisabled(m,n,q){return!m[n]||!m[n].tags[q]||!m[n].tags[q].opGraph},_getSelectionProfileDisabled(m,n,q){return!m[n]||!m[n].tags[q]||!m[n].tags[q].profile},_getSelectionConceptualGraphDisabled(m,n,q){return!m[n]||!m[n].tags[q]||!m[n].tags[q].conceptualGraph}})})(d.controls||(d.controls={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-loader/tf-graph-dashboard-loader.js
Ui=this&&this.__awaiter||function(b,d,f,h){return new (f||(f=Promise))(function(k,t){function l(n){try{m(h.next(n))}catch(q){t(q)}}function p(n){try{m(h["throw"](n))}catch(q){t(q)}}function m(n){n.done?k(n.value):(new f(function(q){q(n.value)})).then(l,p)}m((h=h.apply(b,d||[])).next())})};
(function(b){(function(d){(function(){Polymer({is:"tf-graph-dashboard-loader",_template:null,properties:{datasets:Array,progress:{type:Object,notify:!0},selection:Object,selectedFile:Object,compatibilityProvider:{type:Object,value:()=>new b.graph.op.TpuCompatibilityProvider},hierarchyParams:{type:Object,value:()=>b.graph.hierarchy.DefaultHierarchyParams},outGraphHierarchy:{type:Object,readOnly:!0,notify:!0},outGraph:{type:Object,readOnly:!0,notify:!0},outStats:{type:Object,readOnly:!0,notify:!0},
_graphRunTag:Object},observers:["_selectionChanged(selection, compatibilityProvider)","_selectedFileChanged(selectedFile, compatibilityProvider)"],_selectionChanged(){this.debounce("selectionchange",()=>{this._load(this.selection)})},_load:function(f){const h=f.run,k=f.tag;f=f.type;switch(f){case b.graph.SelectionType.OP_GRAPH:case b.graph.SelectionType.CONCEPTUAL_GRAPH:this._setOutStats(null);var t=new URLSearchParams;t.set("run",h);t.set("conceptual",String(f===b.graph.SelectionType.CONCEPTUAL_GRAPH));
k&&t.set("tag",k);f=vc.getRouter().pluginRoute("graphs","/graph",t);return this._fetchAndConstructHierarchicalGraph(f).then(()=>{this._graphRunTag={run:h,tag:k}});case b.graph.SelectionType.PROFILE:{({tags:f}=this.datasets.find(({name:m})=>m===h));const l=f.find(m=>m.tag===k).opGraph?k:null;console.assert(f.find(m=>m.tag===l),`Required tag (${l}) is missing.`);f=this._graphRunTag&&this._graphRunTag.run===h&&this._graphRunTag.tag===l?Promise.resolve():this._load({run:h,tag:l,type:b.graph.SelectionType.OP_GRAPH});
t=new URLSearchParams;t.set("tag",k);t.set("run",h);const p=vc.getRouter().pluginRoute("graphs","/run_metadata",t);return f.then(()=>this._readAndParseMetadata(p))}default:return Promise.reject(Error(`Unknown selection type: ${f}`))}},_readAndParseMetadata:function(f){this.set("progress",{value:0,msg:""});b.graph.parser.fetchAndParseMetadata(f,b.graph.util.getTracker(this)).then(h=>{this._setOutStats(h)})},_fetchAndConstructHierarchicalGraph:function(f,h){return Ui(this,void 0,void 0,function*(){this.set("progress",
{value:0,msg:""});return b.graph.loader.fetchAndConstructHierarchicalGraph(b.graph.util.getTracker(this),f,h,this.compatibilityProvider,this.hierarchyParams).then(({graph:k,graphHierarchy:t})=>{this._setOutGraph(k);this._setOutGraphHierarchy(t)})})},_selectedFileChanged:function(f){if(f){f=f.target;var h=f.files[0];h&&(f.value="",this._fetchAndConstructHierarchicalGraph(null,h))}}})})(d.loader||(d.loader={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-dashboard/tf-graph-dashboard.html.js
Polymer({is:"tf-graph-dashboard",properties:{_datasets:{type:Array,value:()=>[]},_datasetsFetched:{type:Boolean,value:!1},_selectedDataset:{type:Number,value:0},_renderHierarchy:{type:Object,observer:"_renderHierarchyChanged"},_requestManager:{type:Object,value:()=>new vc.RequestManager},_canceller:{type:Object,value:()=>new vc.Canceller},_debuggerDataEnabled:Boolean,allStepsModeEnabled:Boolean,specificHealthPillStep:{type:Number,value:0},healthPillsToggledOn:{type:Boolean,value:!1,observer:"_healthPillsToggledOnChanged"},
selectedNode:{type:String,notify:!0},_isAttached:Boolean,_initialized:Boolean,_areHealthPillsLoading:Boolean,_debuggerNumericAlerts:{type:Array,value:[],notify:!0},_nodeNamesToHealthPills:{type:Object,value:{}},_healthPillStepIndex:Number,_healthPillRequestId:{type:Number,value:1},_healthPillStepRequestTimerId:Number,_healthPillStepRequestTimerDelay:{type:Number,value:500,readOnly:!0},runs:Array,run:{type:String,notify:!0,value:pd.getStringInitializer("run",{defaultValue:"",useLocalStorage:!1}),observer:"_runObserver"},
_selection:{type:Object},_compatibilityProvider:Object,_traceInputs:Boolean},listeners:{"node-toggle-expand":"_handleNodeToggleExpand"},observers:["_maybeFetchHealthPills(_debuggerDataEnabled, allStepsModeEnabled, specificHealthPillStep, _selectedNode)","_maybeInitializeDashboard(_isAttached)","_determineSelectedDataset(_datasetsFetched, _datasets, run)","_updateSelectedDatasetName(_datasetsFetched, _datasets, _selectedDataset)"],attached:function(){this.set("_isAttached",!0)},detached:function(){this.set("_isAttached",
!1)},reload:function(){this._debuggerDataEnabled||this._requestManager.request(vc.getRouter().pluginsListing()).then(this._canceller.cancellable(b=>{b.cancelled||b.value["debugger"]&&this.set("_debuggerDataEnabled",!0)}));this._maybeFetchHealthPills()},_fit:function(){this.$$("#graphboard").fit()},_runObserver:pd.getStringObserver("run",{defaultValue:"",polymerProperty:"run",useLocalStorage:!1}),_fetchDataset(){return this._requestManager.request(vc.getRouter().pluginRoute("graphs","/info"))},_fetchHealthPills(b,
d){b={node_names:JSON.stringify(b),run:"__debugger_data__"};void 0!==d&&(b.step=d);d=vc.getRouter().pluginRoute("debugger","/health_pills");return this._requestManager.request(d,b)},_fetchDebuggerNumericsAlerts(){return this._requestManager.request(vc.getRouter().pluginRoute("debugger","/numerics_alert_report"))},_graphUrl(b,d,f){return vc.getRouter().pluginRoute("graphs","/graph",new URLSearchParams({run:b,limit_attr_size:d,large_attrs_key:f}))},_shouldRequestHealthPills:function(){return this._debuggerDataEnabled&&
this.healthPillsToggledOn&&this._renderHierarchy&&this._datasetsState(this._datasetsFetched,this._datasets,"PRESENT")},_maybeInitializeDashboard:function(b){!this._initialized&&b&&(this.set("_compatibilityProvider",new tf.graph.op.TpuCompatibilityProvider),this._initialized=!0,this._fetchDataset().then(d=>{this._datasets=Object.keys(d).sort(rc.compareTagNames).map(f=>{const h=d[f];var k=Object.keys(h.tags).sort(rc.compareTagNames).map(t=>h.tags[t]).map(({tag:t,conceptual_graph:l,op_graph:p,profile:m})=>
({tag:t,displayName:t,conceptualGraph:l,opGraph:p,profile:m}));k=h.run_graph?[{tag:null,displayName:"Default",conceptualGraph:!1,opGraph:!0,profile:!1},...k]:k;return{name:f,tags:k}});this._datasetsFetched=!0}))},_determineSelectedDataset(b,d,f){f?(d=d.findIndex(h=>h.name===f),-1===d?b&&(b=this.$$("#error-dialog"),b.textContent=`No dataset named "${f}" could be found.`,b.open()):this.set("_selectedDataset",d)):this.set("_selectedDataset",0)},_updateSelectedDatasetName(b,d,f){b&&(d.length<=f||this.set("run",
d[f].name))},_requestHealthPills:function(){this.set("_areHealthPillsLoading",!0);var b=++this._healthPillRequestId;null!==this._healthPillStepRequestTimerId&&(window.clearTimeout(this._healthPillStepRequestTimerId),this._healthPillStepRequestTimerId=null);this.allStepsModeEnabled?this._healthPillStepRequestTimerId=setTimeout(function(){this._healthPillStepRequestTimerId=null;this._initiateNetworkRequestForHealthPills(b)}.bind(this),this._healthPillStepRequestTimerDelay):this._initiateNetworkRequestForHealthPills(b)},
_initiateNetworkRequestForHealthPills:function(b){if(this._healthPillRequestId===b){var d=this._fetchHealthPills(this._renderHierarchy.getNamesOfRenderedOps(),this.allStepsModeEnabled?this.specificHealthPillStep:void 0),f=this._fetchDebuggerNumericsAlerts();Promise.all([d,f]).then(function(h){var k=h[0];h=h[1];if(this.healthPillsToggledOn&&b===this._healthPillRequestId){for(var t in k){this.set("_healthPillStepIndex",k[t].length-1);break}this.set("_debuggerNumericAlerts",h);this.set("_nodeNamesToHealthPills",
k);this.set("_areHealthPillsLoading",!1);this.set("_healthPillStepRequestTimerId",null)}}.bind(this))}},_datasetsState:function(b,d,f){return b?d&&d.length?"PRESENT"===f:"EMPTY"===f:"NOT_LOADED"===f},_renderHierarchyChanged:function(){this.reload()},_handleNodeToggleExpand:function(){this._maybeFetchHealthPills()},_healthPillsToggledOnChanged:function(b){b?this.reload():this.set("_nodeNamesToHealthPills",{})},_maybeFetchHealthPills:function(){this._shouldRequestHealthPills()&&this._requestHealthPills()}});

//# sourceURL=build://vz-distribution-chart/vz-distribution-chart.js
var Jk;
(function(b){class d{constructor(f,h){this.run2datasets={};this.colorScale=h;this.buildChart(f)}getDataset(f){void 0===this.run2datasets[f]&&(this.run2datasets[f]=new Plottable.Dataset([],{run:f}));return this.run2datasets[f]}buildChart(f){this.outer&&this.outer.destroy();f=rg.getXComponents(f);this.xAccessor=f.accessor;this.xScale=f.scale;this.xAxis=f.axis;this.xAxis.margin(0).tickLabelPadding(3);this.yScale=new Plottable.Scales.Linear;this.yAxis=new Plottable.Axes.Numeric(this.yScale,"left");f=
rg.multiscaleFormatter(rg.Y_AXIS_FORMATTER_PRECISION);this.yAxis.margin(0).tickLabelPadding(5).formatter(f);this.yAxis.usesTextWidthApproximation();f=this.buildPlot(this.xAccessor,this.xScale,this.yScale);this.gridlines=new Plottable.Components.Gridlines(this.xScale,this.yScale);this.center=new Plottable.Components.Group([this.gridlines,f]);this.outer=new Plottable.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(f,h,k){let t=[0,228,1587,3085,5E3,6915,8413,9772,1E4],l=_.range(t.length-
1).map(u=>(t[u+1]-t[u])/2500),p=t.map((u,x)=>A=>A[x][1]),m=p[4],n=_.range(p.length-1).map(u=>{let x=new Plottable.Plots.Area;x.x(f,h);let A=4<u?p[u]:p[u+1];x.y(4<u?p[u+1]:p[u],k);x.y0(A);x.attr("fill",(y,w,C)=>this.colorScale.scale(C.metadata().run));x.attr("stroke",(y,w,C)=>this.colorScale.scale(C.metadata().run));x.attr("stroke-weight",()=>"0.5px");x.attr("stroke-opacity",()=>l[u]);x.attr("fill-opacity",()=>l[u]);return x}),q=new Plottable.Plots.Line;q.x(f,h);q.y(m,k);q.attr("stroke",(u,x,A)=>this.colorScale.scale(A.run));
this.plots=n;return new Plottable.Components.Group(n)}setVisibleSeries(f){this.runs=f;let h=f.map(k=>this.getDataset(k));this.plots.forEach(k=>k.datasets(h))}setSeriesData(f,h){this.getDataset(f).data(h)}renderTo(f){this.targetSVG=f;this.outer.renderTo(f)}redraw(){this.outer.redraw()}destroy(){this.outer.destroy()}}b.DistributionChart=d;Polymer({is:"vz-distribution-chart",properties:{colorScale:{type:Object,value:function(){return(new Plottable.Scales.Color).range(d3.schemeCategory10)}},xType:{type:String,
value:"step"},_attached:Boolean,_chart:Object,_visibleSeriesCache:{type:Array,value:function(){return[]}},_seriesDataCache:{type:Object,value:function(){return{}}},_makeChartAsyncCallbackId:{type:Number,value:null}},observers:["_makeChart(xType, colorScale, _attached)","_reloadFromCache(_chart)"],setVisibleSeries:function(f){this._visibleSeriesCache=f;this._chart&&(this._chart.setVisibleSeries(f),this.redraw())},setSeriesData:function(f,h){this._seriesDataCache[f]=h;this._chart&&this._chart.setSeriesData(f,
h)},redraw:function(){this._chart.redraw()},ready:function(){this.scopeSubtree(this.$.chartdiv,!0)},_makeChart:function(f,h,k){null===this._makeChartAsyncCallbackId&&this.cancelAsync(this._makeChartAsyncCallbackId);this._makeChartAsyncCallbackId=this.async(function(){this._makeChartAsyncCallbackId=null;if(k){this._chart&&this._chart.destroy();var t=new d(f,h),l=d3.select(this.$.chartdiv);t.renderTo(l);this._chart=t}},350)},_reloadFromCache:function(){this._chart&&(this._chart.setVisibleSeries(this._visibleSeriesCache),
this._visibleSeriesCache.forEach(function(f){this._chart.setSeriesData(f,this._seriesDataCache[f]||[])}.bind(this)))},attached:function(){this._attached=!0},detached:function(){this._attached=!1}})})(Jk||(Jk={}));

//# sourceURL=build://tf-distribution-dashboard/tf-distribution-loader.html.js
Polymer({is:"tf-distribution-loader",properties:{run:String,tag:String,tagMetadata:Object,xType:String,dataToLoad:{type:Array,computed:"_computeDataToLoad(run, tag)"},getDataLoadName:{type:Function,value:()=>({run:b})=>b},getDataLoadUrl:{type:Function,value:()=>({tag:b,run:d})=>vc.addParams(vc.getRouter().pluginRoute("distributions","/distributions"),{tag:b,run:d})},loadDataCallback:{type:Function,value:function(){return(b,d,f)=>{b=f.map(h=>{const [k,t,l]=h;l.wall_time=new Date(1E3*k);l.step=t;return l});
d=this.getDataLoadName(d);this.$.chart.setSeriesData(d,b);this.$.chart.setVisibleSeries([d])}}},_colorScale:{type:Object,value:()=>({scale:pf.runsColorScale}),readOnly:!0},_runColor:{type:String,computed:"_computeRunColor(run)"},_expanded:{type:Boolean,value:!1,reflectToAttribute:!0},requestManager:Object,_canceller:{type:Object,value:()=>new vc.Canceller}},observers:["reload(run, tag)"],behaviors:[qd.DataLoaderBehavior],_computeDataToLoad(b,d){return[{run:b,tag:d}]},_computeRunColor(b){return this._colorScale.scale(b)},
redraw(){this.$.chart.redraw()},_toggleExpanded(){this.set("_expanded",!this._expanded);this.redraw()}});

//# sourceURL=build://tf-distribution-dashboard/tf-distribution-dashboard.html.js
Polymer({is:"tf-distribution-dashboard",properties:{_xType:{type:String,value:"step"},_selectedRuns:Array,_runToTag:Object,_runToTagInfo:Object,_dataNotFound:Boolean,_tagFilter:String,_categoriesDomReady:Boolean,_categories:{type:Array,computed:"_makeCategories(_runToTag, _selectedRuns, _tagFilter, _categoriesDomReady)"},_requestManager:{type:Object,value:()=>new vc.RequestManager}},ready(){this.reload()},reload(){this._fetchTags().then(()=>{this._reloadDistributions()})},_fetchTags(){const b=vc.getRouter().pluginRoute("distributions",
"/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,this._runToTagInfo)){var f=_.mapValues(d,k=>Object.keys(k)),h=vc.getTags(f);this.set("_dataNotFound",0===h.length);this.set("_runToTag",f);this.set("_runToTagInfo",d);this.async(()=>{this.set("_categoriesDomReady",!0)})}})},_reloadDistributions(){this.root.querySelectorAll("tf-distribution-loader").forEach(b=>{b.reload()})},_shouldOpen(b){return 2>=b},_makeCategories(b,d,f){return $c.categorizeRunTagCombinations(b,d,f)},_tagMetadata(b,
d,f){return b[d][f]}});

//# sourceURL=build://vz-histogram-timeseries/vz-histogram-timeseries.html.js
Polymer({is:"vz-histogram-timeseries",properties:{mode:{type:String,value:"offset"},timeProperty:{type:String,value:"step"},bins:{type:String,value:"bins"},x:{type:String,value:"x"},dx:{type:String,value:"dx"},y:{type:String,value:"y"},colorScale:{type:Object,value:function(){return d3.scaleOrdinal(d3.schemeCategory10)}},modeTransitionDuration:{type:Number,value:500},_attached:Boolean,_name:{type:String,value:null},_data:{type:Array,value:null}},observers:["redraw(timeProperty, _attached)","_modeRedraw(mode)"],
ready:function(){this.scopeSubtree(this.$.svg,!0)},attached:function(){this._attached=!0},detached:function(){this._attached=!1},setSeriesData:function(b,d){this._name=b;this._data=d;this.redraw()},redraw:function(){this._draw(0)},_modeRedraw:function(){this._draw(this.modeTransitionDuration)},_draw:function(b){if(this._attached&&this._data){if(void 0===b)throw Error("vz-histogram-timeseries _draw needs duration");if(0>=this._data.length)throw Error("Not enough steps in the data");if(!this._data[0].hasOwnProperty(this.bins))throw Error("No bins property of '"+
this.bins+"' in data");if(0>=this._data[0][this.bins].length)throw Error("Must have at least one bin in bins in data");if(!this._data[0][this.bins][0].hasOwnProperty(this.x))throw Error("No x property '"+this.x+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.dx))throw Error("No dx property '"+this.dx+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.y))throw Error("No y property '"+this.y+"' on bins data");var d=this.timeProperty,f=this.x,h=this.bins,k=this.dx,
t=this.y,l=this._data,p=this.mode,m=d3.hcl(this.colorScale(this._name)),n=d3.select(this.$.tooltip),q=function(ya){return ya[f]},u=function(ya){return ya[t]},x=function(ya){return ya[f]+ya[k]},A=function(ya){return ya[d]};"relative"===d&&(A=function(ya){return ya.wall_time-l[0].wall_time});var y=this.$.svg.getBoundingClientRect(),w=y.width,C=y.height,G=5;if("offset"===p){var D=C/2.5;G=D+5}else D=C-G-20;var B=w-24-60,I=C-G-20;d3.min(l,q);d3.max(l,x);var N=d3.format(".3n");y=d3.format(".0f");"wall_time"===
d?y=d3.timeFormat("%m/%d %X"):"relative"===d&&(y=function(ya){return d3.format(".1r")(ya/36E5)+"h"});var O=l.map(function(ya){return[d3.min(ya[h],q),d3.max(ya[h],x)]}),H=l.map(function(ya){return d3.extent(ya[h],u)}),K=d3.extent(l,A),M=("wall_time"===d?d3.scaleTime():d3.scaleLinear()).domain(K).range([0,"offset"===p?I:0]),L=d3.scaleLinear().domain([0,d3.max(l,function(ya,Sa){return H[Sa][1]})]).range([D,0]),Q=d3.scaleLinear().domain(L.domain()).range([500,0]),T=d3.scaleLinear().domain([d3.min(l,function(ya,
Sa){return O[Sa][0]}),d3.max(l,function(ya,Sa){return O[Sa][1]})]).nice().range([0,B]),X=d3.scaleLinear().domain(T.domain()).range([0,500]),aa=d3.scaleLinear().domain(d3.extent(l,A)).range([m.darker(),m.brighter()]).interpolate(d3.interpolateHcl);m=d3.axisBottom(T).ticks();var la=d3.axisRight(M).ticks().tickFormat(y),Z=d3.axisRight(L).ticks().tickSize(B+5).tickFormat(N),ba=function(ya){return ya[f]+ya[k]/2},ea=d3.line().x(function(ya){return X(ba(ya))}).y(function(ya){return Q(ya[t])}),ca=function(ya){return"M"+
X(ba(ya[0]))+","+Q(0)+"L"+ea(ya).slice(1)+"L"+X(ba(ya[ya.length-1]))+","+Q(0)},ka=this.$.svg;y=d3.select(ka);b=y.transition().duration(b);y=y.select("g").classed("small",function(){return 0<B&&150>=B}).classed("medium",function(){return 150<B&&300>=B}).classed("large",function(){return 300<B});b=b.select("g").attr("transform","translate(24,"+G+")");var Y=d3.bisector(x).left;K=y.select(".stage").on("mouseover",function(){va.style("opacity",1);xa.style("opacity",1);Aa.style("opacity",1);Fa.style("opacity",
1);n.style("opacity",1)}).on("mouseout",function(){va.style("opacity",0);xa.style("opacity",0);Aa.style("opacity",0);Fa.style("opacity",0);va.classed("hover-closest",!1);Ea.classed("outline-hover",!1);n.style("opacity",0)}).on("mousemove",function(){function ya(Ab){return Math.min(Ab[h].length-1,Y(Ab[h],Xa))}var Sa=d3.mouse(this),Xa=T.invert(Sa[0]);M.invert(Sa[1]);var ub,Bb=Infinity,qb;va.attr("transform",function(Ab){var Hb=ya(Ab);qb=Ab;var ic=T(Ab[h][Hb][f]+Ab[h][Hb][k]/2);Hb=L(Ab[h][Hb][t]);var bc=
"offset"===p?M(A(Ab))-(D-Hb):Hb;bc=Math.abs(Sa[1]-bc);bc<Bb&&(Bb=bc,ub=Ab);return"translate("+ic+","+Hb+")"});va.select("text").text(function(Ab){var Hb=ya(Ab);return Ab[h][Hb][t]});va.classed("hover-closest",function(Ab){return Ab===ub});Ea.classed("outline-hover",function(Ab){return Ab===ub});var zb=ya(qb);xa.attr("transform",function(){return"translate("+T(qb[h][zb][f]+qb[h][zb][k]/2)+", "+I+")"}).select("text").text(function(){return N(qb[h][zb][f]+qb[h][zb][k]/2)});var vb=la.tickFormat();Aa.attr("transform",
function(){return"translate("+B+", "+("offset"===p?M(A(ub)):0)+")"}).style("display","offset"===p?"":"none").select("text").text(function(){return vb(A(ub))});var Gb=Z.tickFormat();Fa.attr("transform",function(){return"translate("+B+", "+("offset"===p?0:L(ub[h][zb][t]))+")"}).style("display","offset"===p?"none":"").select("text").text(function(){return Gb(ub[h][zb][t])});var Nb=d3.mouse(ka);n.style("transform","translate("+(Nb[0]+15)+"px,"+(Nb[1]-15)+"px)").select("span").text("offset"===p?Gb(ub[h][zb][t]):
("step"===d?"step ":"")+vb(A(ub)))});K.select(".background").attr("transform","translate(-24,"+-G+")").attr("width",w).attr("height",C);C=K.selectAll(".histogram").data(l);C.exit().remove();w=C.enter().append("g").attr("class","histogram");C=w.merge(C).sort(function(ya,Sa){return A(ya)-A(Sa)});G=b.selectAll(".histogram").attr("transform",function(ya){return"translate(0, "+("offset"===p?M(A(ya))-D:0)+")"});w.append("line").attr("class","baseline");G.select(".baseline").style("stroke-opacity",function(){return"offset"===
p?.1:0}).attr("y1",D).attr("y2",D).attr("x2",B);w.append("path").attr("class","outline");var Ea=C.select(".outline").attr("vector-effect","non-scaling-stroke").attr("d",function(ya){return ca(ya[h])}).style("stroke-width",1);G.select(".outline").attr("transform","scale("+B/500+", "+D/500+")").style("stroke",function(ya){return"offset"===p?"white":aa(A(ya))}).style("fill-opacity",function(){return"offset"===p?1:0}).style("fill",function(ya){return aa(A(ya))});w=w.append("g").attr("class","hover").style("fill",
function(ya){return aa(A(ya))});var va=C.select(".hover");w.append("circle").attr("r",2);w.append("text").style("display","none").attr("dx",4);w=y.select(".x-axis-hover").selectAll(".label").data(["x"]);C=w.enter().append("g").attr("class","label");var xa=w.merge(C);C.append("rect").attr("x",-20).attr("y",6).attr("width",40).attr("height",14);C.append("line").attr("x1",0).attr("x2",0).attr("y1",0).attr("y2",6);C.append("text").attr("dy",18);w=y.select(".y-axis-hover").selectAll(".label").data(["y"]);
C=w.enter().append("g").attr("class","label");var Aa=w.merge(C);C.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14);C.append("line").attr("x1",0).attr("x2",6).attr("y1",0).attr("y2",0);C.append("text").attr("dx",8).attr("dy",4);y=y.select(".y-slice-axis-hover").selectAll(".label").data(["y"]);w=y.enter().append("g").attr("class","label");var Fa=y.merge(w);w.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14);w.append("line").attr("x1",0).attr("x2",6).attr("y1",
0).attr("y2",0);w.append("text").attr("dx",8).attr("dy",4);b.select(".y.axis.slice").style("opacity","offset"===p?0:1).attr("transform","translate(0, "+("offset"===p?-D:0)+")").call(Z);b.select(".x.axis").attr("transform","translate(0, "+I+")").call(m);b.select(".y.axis").style("opacity","offset"===p?1:0).attr("transform","translate("+B+", "+("offset"===p?0:I)+")").call(la);b.selectAll(".tick text").attr("fill","#aaa");b.selectAll(".axis path.domain").attr("stroke","none")}}});

//# sourceURL=build://tf-histogram-dashboard/histogramCore.js
var Kk;
(function(b){function d(h){const [k,t,l]=h;return{wall_time:k,step:t,min:d3.min(l.map(([p])=>p)),max:d3.max(l.map(([,p])=>p)),buckets:l.map(([p,m,n])=>({left:p,right:m,count:n}))}}function f(h,k,t,l=30){t===k&&(t=1.1*k+1,k=k/1.1-1);const p=(t-k)/l;let m=0;return d3.range(k,t,p).map(n=>{const q=n+p;let u=0;for(;m<h.buckets.length;){const A=Math.min(t,h.buckets[m].right);var x=Math.max(k,h.buckets[m].left);const y=Math.min(A,q)-Math.max(x,n);x=y/(A-x)*h.buckets[m].count;u+=0<y?x:0;if(A>q)break;m++}return{x:n,
dx:p,y:u}})}b.backendToIntermediate=d;b.intermediateToD3=f;b.backendToVz=function(h){h=h.map(d);const k=d3.min(h,l=>l.min),t=d3.max(h,l=>l.max);return h.map(l=>({wall_time:l.wall_time,step:l.step,bins:f(l,k,t)}))}})(Kk||(Kk={}));

//# sourceURL=build://tf-histogram-dashboard/tf-histogram-loader.html.js
Polymer({is:"tf-histogram-loader",properties:{run:String,tag:String,dataToLoad:{type:Array,computed:"_computeDataToLoad(run, tag)"},getDataLoadName:{type:Function,value:()=>({run:b})=>b},getDataLoadUrl:{type:Function,value:()=>({tag:b,run:d})=>vc.addParams(vc.getRouter().pluginRoute("histograms","/histograms"),{tag:b,run:d})},loadDataCallback:{type:Function,value:function(){return(b,d,f)=>{b=Kk.backendToVz(f);d=this.getDataLoadName(d);this.$.chart.setSeriesData(d,b)}}},tagMetadata:Object,timeProperty:String,
histogramMode:String,_colorScaleFunction:{type:Object,value:()=>pf.runsColorScale},_runColor:{type:String,computed:"_computeRunColor(run)"},_expanded:{type:Boolean,value:!1,reflectToAttribute:!0}},observers:["reload(run, tag, requestManager)"],behaviors:[qd.DataLoaderBehavior],_computeDataToLoad(b,d){return[{run:b,tag:d}]},_computeRunColor(b){return this._colorScaleFunction(b)},redraw(){this.$.chart.redraw()},_toggleExpanded(){this.set("_expanded",!this._expanded);this.redraw()}});

//# sourceURL=build://tf-histogram-dashboard/tf-histogram-dashboard.html.js
Polymer({is:"tf-histogram-dashboard",properties:{_histogramMode:{type:String,value:"offset"},_timeProperty:{type:String,value:"step"},_selectedRuns:Array,_runToTag:Object,_runToTagInfo:Object,_dataNotFound:Boolean,_tagFilter:String,_restamp:{type:Boolean,value:!1},_categoriesDomReady:Boolean,_categories:{type:Array,computed:"_makeCategories(_runToTag, _selectedRuns, _tagFilter, _categoriesDomReady)"},_requestManager:{type:Object,value:()=>new vc.RequestManager}},listeners:{"content-visibility-changed":"_redrawCategoryPane"},
_redrawCategoryPane(b,d){d&&b.target.querySelectorAll("tf-histogram-loader").forEach(f=>f.redraw())},ready(){this.reload()},reload(){this._fetchTags().then(()=>{this._reloadHistograms()})},_fetchTags(){const b=vc.getRouter().pluginRoute("histograms","/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,this._runToTagInfo)){var f=_.mapValues(d,k=>Object.keys(k)),h=vc.getTags(f);this.set("_dataNotFound",0===h.length);this.set("_runToTag",f);this.set("_runToTagInfo",d);this.async(()=>
{this.set("_categoriesDomReady",!0)})}})},_reloadHistograms(){this.root.querySelectorAll("tf-histogram-loader").forEach(b=>{b.reload()})},_shouldOpen(b){return 2>=b},_makeCategories(b,d,f){return $c.categorizeRunTagCombinations(b,d,f)},_tagMetadata(b,d,f){return b[d][f]}});

//# sourceURL=build://tf-text-dashboard/tf-text-loader.html.js
Polymer({is:"tf-text-loader",properties:{run:String,tag:String,_runColor:{type:String,computed:"_computeRunColor(run)"},_texts:{type:Array,value:[]},requestManager:Object,_canceller:{type:Object,value:()=>new vc.Canceller}},_computeRunColor(b){return pf.runsColorScale(b)},attached(){this._attached=!0;this.reload()},reload(){if(this._attached){this._canceller.cancelAll();var b=vc.addParams(vc.getRouter().pluginRoute("text","/text"),{tag:this.tag,run:this.run}),d=this._canceller.cancellable(f=>{f.cancelled||
(f=f.value.map(h=>({wall_time:new Date(1E3*h.wall_time),step:h.step,text:h.text})),this.set("_texts",f.slice().reverse()))});this.requestManager.request(b).then(d)}},_formatStep(b){return d3.format(",")(b)}});

//# sourceURL=build://tf-text-dashboard/tf-text-dashboard.html.js
Polymer({is:"tf-text-dashboard",properties:{_selectedRuns:Array,_runToTag:Object,_dataNotFound:Boolean,_tagFilter:String,_categoriesDomReady:Boolean,_categories:{type:Array,computed:"_makeCategories(_runToTag, _selectedRuns, _tagFilter, _categoriesDomReady)"},_requestManager:{type:Object,value:()=>new vc.RequestManager}},ready(){this.reload()},reload(){this._fetchTags().then(()=>{this._reloadTexts()})},_shouldOpen(b){return 2>=b},_fetchTags(){const b=vc.getRouter().pluginRoute("text","/tags");return this._requestManager.request(b).then(d=>
{if(!_.isEqual(d,this._runToTag)){var f=vc.getTags(d);this.set("_dataNotFound",0===f.length);this.set("_runToTag",d);this.async(()=>{this.set("_categoriesDomReady",!0)})}})},_reloadTexts(){this.root.querySelectorAll("tf-text-loader").forEach(b=>{b.reload()})},_makeCategories(b,d,f){return $c.categorizeRunTagCombinations(b,d,f)}});

//# sourceURL=build://tf-pr-curve-dashboard/tf-pr-curve-card.html.js
Polymer({is:"tf-pr-curve-card",properties:{runs:Array,tag:String,tagMetadata:Object,runToStepCap:Object,requestManager:Object,active:Boolean,_expanded:{type:Boolean,value:!1,reflectToAttribute:!0},_runToPrCurveEntry:{type:Object,value:()=>({})},_previousRunToPrCurveEntry:{type:Object,value:()=>({})},_runsWithStepAvailable:{type:Array,computed:"_computeRunsWithStepAvailable(runs, _runToPrCurveEntry)"},_setOfRelevantRuns:{type:Object,computed:"_computeSetOfRelevantRuns(_runsWithStepAvailable)"},_runToDataOverTime:Object,
_colorScaleFunction:{type:Object,value:()=>({scale:pf.runsColorScale})},_canceller:{type:Object,value:()=>new vc.Canceller},_attached:Boolean,_xComponentsCreationMethod:{type:Object,readOnly:!0,value:()=>()=>{const b=new Plottable.Scales.Linear;return{scale:b,axis:new Plottable.Axes.Numeric(b,"bottom"),accessor:d=>d.recall}}},_yValueAccessor:{type:Object,readOnly:!0,value:()=>b=>b.precision},_tooltipColumns:{type:Array,readOnly:!0,value:()=>{const b=rg.multiscaleFormatter(rg.Y_TOOLTIP_FORMATTER_PRECISION),
d=f=>isNaN(f)?"NaN":b(f);return[{title:"Run",evaluate:f=>f.dataset.metadata().name},{title:"Threshold",evaluate:f=>d(f.datum.thresholds)},{title:"Precision",evaluate:f=>d(f.datum.precision)},{title:"Recall",evaluate:f=>d(f.datum.recall)},{title:"TP",evaluate:f=>f.datum.true_positives},{title:"FP",evaluate:f=>f.datum.false_positives},{title:"TN",evaluate:f=>f.datum.true_negatives},{title:"FN",evaluate:f=>f.datum.false_negatives}]}},_seriesDataFields:{type:Array,value:"thresholds precision recall true_positives false_positives true_negatives false_negatives".split(" "),
readOnly:!0},_defaultXRange:{type:Array,value:[-.05,1.05],readOnly:!0},_defaultYRange:{type:Array,value:[-.05,1.05],readOnly:!0},_dataUrl:{type:Function,value:function(){return b=>{const d=this.tag;return vc.addParams(vc.getRouter().pluginRoute("pr_curves","/pr_curves"),{tag:d,run:b})}}},_smoothingEnabled:{type:Boolean,value:!1,readOnly:!0}},observers:["reload(runs, tag)","_setChartData(_runToPrCurveEntry, _previousRunToPrCurveEntry, _setOfRelevantRuns)","_updateRunToPrCurveEntry(_runToDataOverTime, runToStepCap)"],
_createProcessDataFunction(){return(b,d,f)=>{this.set("_runToDataOverTime",Object.assign({},this._runToDataOverTime,f))}},_computeRunColor(b){return this._colorScaleFunction.scale(b)},attached(){this._attached=!0;this.reload()},reload(){this._attached&&(0===this.runs.length?this.set("_runToDataOverTime",{}):this.$$("tf-line-chart-data-loader").reload())},_setChartData(b,d,f){_.forOwn(b,(h,k)=>{const t=d[k];t&&b[k].step===t.step||(f[k]?this._updateSeriesDataForRun(k,h):this._clearSeriesData(k))})},
_updateSeriesDataForRun(b,d){const f=_.reduce(this._seriesDataFields,(k,t)=>{k[t]=d[t].slice().reverse();return k},{}),h=Array(f[this._seriesDataFields[0]].length);for(let k=0;k<h.length;k++)h[k]=_.mapValues(f,t=>t[k]);this.$$("tf-line-chart-data-loader").setSeriesData(b,h)},_clearSeriesData(b){this.$$("tf-line-chart-data-loader").setSeriesData(b,[])},_updateRunToPrCurveEntry(b,d){const f={};_.forOwn(b,(h,k)=>{h&&h.length&&(f[k]=this._computeEntryClosestOrEqualToStepCap(d[k],h))});this.set("_previousRunToPrCurveEntry",
this._runToPrCurveEntry);this.set("_runToPrCurveEntry",f)},_computeEntryClosestOrEqualToStepCap(b,d){b=Math.min(_.sortedIndex(d.map(f=>f.step),b),d.length-1);return d[b]},_computeRunsWithStepAvailable(b,d){return _.filter(b,f=>d[f]).sort()},_computeSetOfRelevantRuns(b){const d={};_.forEach(b,f=>{d[f]=!0});return d},_computeCurrentStepForRun(b,d){return(b=b[d])?b.step:null},_computeCurrentWallTimeForRun(b,d){return(b=b[d])?(new Date(1E3*b.wall_time)).toString():null},_toggleExpanded(){this.set("_expanded",
!this._expanded);this.redraw()},_resetDomain(){this.$$("tf-line-chart-data-loader").resetDomain()},redraw(){this.$$("tf-line-chart-data-loader").redraw()}});

//# sourceURL=build://tf-pr-curve-dashboard/tf-pr-curve-steps-selector.html.js
Polymer({is:"tf-pr-curve-steps-selector",properties:{runs:Array,runToAvailableTimeEntries:Object,runToStep:{type:Object,notify:!0,computed:"_computeRunToStep(runToAvailableTimeEntries, _runToStepIndex)"},timeDisplayType:String,_runToStepIndex:{type:Object,value:()=>({})},_runsWithSliders:{type:Array,computed:"_computeRunsWithSliders(runs, runToAvailableTimeEntries)"}},observers:["_updateStepsForNewRuns(runToAvailableTimeEntries)"],_computeColorForRun(b){return pf.runsColorScale(b)},_computeTimeTextForRun(b,
d,f,h){d=d[f];if(!_.isNumber(d))return"";b=b[f];if(!b)return"";b=b[d][h];if("step"===h)return`step ${b}`;if("relative"===h)return 1>b?`${(1E3*b).toFixed(2)} ms`:`${b.toFixed(2)} s`;if("wall_time"===h)return(new Date(1E3*b)).toString();throw Error(`The display type of ${h} is not recognized.`);},_sliderValueChanged(b){const d=b.target.dataset.run,f=b.target.immediateValue,h=Object.assign({},this._runToStepIndex);isNaN(f)?delete h[d]:h[d]=b.target.immediateValue;this._runToStepIndex=h},_computeMaxStepIndexForRun(b,
d){return(b=b[d])&&b.length?b.length-1:0},_updateStepsForNewRuns(b){const d=Object.assign({},this._runToStepIndex);_.forOwn(b,(f,h)=>{_.isNumber(d[h])||(d[h]=f.length-1)});this._runToStepIndex=d},_getStep(b,d){return this._runToStepIndex?this._runToStepIndex[d]:0},_computeRunToStep(b,d){const f={};_.forOwn(d,(h,k)=>{const t=b[k];t&&(f[k]=t[h].step)});return f},_computeRunsWithSliders(b,d){return b.filter(f=>d[f])}});

//# sourceURL=build://tf-pr-curve-dashboard/tf-pr-curve-dashboard.html.js
Polymer({is:"tf-pr-curve-dashboard",properties:{_timeDisplayType:{type:String,value:"step"},_selectedRuns:{type:Array,value:()=>[]},_runToTagInfo:{type:Object,value:()=>({})},_runToAvailableTimeEntries:{type:Object,value:{}},_relevantSelectedRuns:{type:Array,computed:"_computeRelevantSelectedRuns(_selectedRuns, _runToTagInfo)"},_runsWithPrCurveData:Array,_runToStep:{type:Object,notify:!0},_dataNotFound:Boolean,_tagFilter:String,_categoriesDomReady:Boolean,_categories:{type:Array,computed:"_makeCategories(_runToTagInfo, _selectedRuns, _tagFilter, _categoriesDomReady)"},
_getCategoryItemKey:{type:Function,value:()=>b=>b.tag},_requestManager:{type:Object,value:()=>new vc.RequestManager},_step:{type:Number,value:0,notify:!0}},ready(){this.reload()},reload(){Promise.all([this._fetchTags(),this._fetchTimeEntriesPerRun()]).then(()=>{this._reloadCards()})},_shouldOpen(b){return 2>=b},_fetchTags(){const b=vc.getRouter().pluginRoute("pr_curves","/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,this._runToTagInfo)){var f=_.mapValues(d,h=>_.keys(h));
f=vc.getTags(f);this.set("_dataNotFound",0===f.length);this.set("_runToTagInfo",d);this.async(()=>{this.set("_categoriesDomReady",!0)})}})},_fetchTimeEntriesPerRun(){const b=vc.getRouter().pluginRoute("pr_curves","/available_time_entries");return this._requestManager.request(b).then(d=>{_.forOwn(d,f=>{_.forEach(f,h=>{h.relative=h.wall_time-f[0].wall_time})});this.set("_runToAvailableTimeEntries",d);d=_.keys(d).slice().sort();_.isEqual(d,this._runsWithPrCurveData)||this.set("_runsWithPrCurveData",
d)})},_reloadCards(){_.forEach(this.root.querySelectorAll("tf-pr-curve-card"),b=>{b.reload()})},_makeCategories(b,d,f){b=_.mapValues(b,h=>Object.keys(h));return $c.categorizeTags(b,d,f)},_computeColorForRun(b){return pf.runsColorScale(b)},_computeRelevantSelectedRuns(b,d){return b.filter(f=>d[f])},_tagMetadata(b,d,f){const h={};d.forEach(k=>{h[k]=b[k][f]});d=f.replace(/\/pr_curves$/,"");return rf.aggregateTagInfo(h,d)}});

//# sourceURL=build://tf-profile-redirect-dashboard/tf-profile-redirect-dashboard.html.js
(function(){Polymer({is:"tf-profile-redirect-dashboard",properties:{_installCommand:{type:String,readOnly:!0,value:"pip install -U tensorboard_plugin_profile"}},_copyInstallCommand(){const b=this;return hc(function*(){const d=()=>hc(function*(){b.$.commandTextarea.select();try{yield navigator.clipboard.writeText(b._installCommand)}catch(f){if(!document.execCommand("copy"))return Promise.reject()}});try{yield d(),b.$.copiedMessage.innerText="Copied."}catch(f){b.$.copiedMessage.innerText="Failed to copy to clipboard."}})},
_removeCopiedMessage(){this.$.copiedMessage.innerText=""}})})();

//# sourceURL=build://tf-tensorboard/plugin-dialog.html.js
Polymer({is:"tf-plugin-dialog",properties:{_title:{type:String,value:null},_customMessage:{type:String,value:null},_open:{type:Boolean},_hidden:{type:Boolean,computed:"_computeHidden(_open)",reflectToAttribute:!0},_useNativeBackdrop:{type:Boolean,value:!1,readOnly:!0}},openNoTensorFlowDialog(){this.openDialog("This plugin is disabled without TensorFlow",'To enable this plugin in TensorBoard, install TensorFlow with "pip install tensorflow" or equivalent.')},openOldTensorFlowDialog(b){this.openDialog("This plugin is disabled without TensorFlow "+
b,"To enable this plugin in TensorBoard, install TensorFlow "+b+' or greater with "pip install tensorflow" or equivalent.')},openDialog(b,d){this.set("_title",b);this.set("_customMessage",d);this.$.dialog.open()},closeDialog(){this.$.dialog.close()},_computeHidden(b){return!b}});

//# sourceURL=build://tf-beholder-dashboard/tf-beholder-video.html.js
(function(){const b=vc.getRouter().pluginRoute("beholder","/beholder-frame"),d=vc.getRouter().pluginRoute("beholder","/ping");Polymer({is:"tf-beholder-video",properties:{fps:{type:Number,value:10,observer:"_fpsChanged"},pingSleep:{type:Number,value:1E3},xhrTimeout:{type:Number,value:2500},_imageURL:{type:String,value:"data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs\x3d"},_xhr:Object,_timer:Number,_isDead:Boolean},attached(){this.set("_imageURL",b);this._ping()},detached(){this._clear();
this.set("_imageURL","data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs\x3d")},_ping(){this._clear();this._xhr=new XMLHttpRequest;this._xhr.open("GET",d,!0);this._xhr.timeout=this.xhrTimeout;this._xhr.onload=this._onPingLoad.bind(this);this._xhr.onerror=this._onPing.bind(this,!1,this.pingSleep);this._xhr.ontimeout=this._onPing.bind(this,!1,1);this._xhr.send(null)},_onPingLoad(){if(200==this._xhr.status){const f=JSON.parse(this._xhr.responseText);this._onPing("alive"==f.status,this.pingSleep)}else this._onPing(!1,
this.pingSleep)},_onPing(f,h){f&&this._isDead&&this.set("_imageURL",b+"?t\x3d"+(new Date).getTime());this._isDead=!f;this._timer=window.setTimeout(()=>this._ping(),h)},_clear(){this._timer&&(window.clearTimeout(this._timer),this._timer=null);this._xhr&&(this._xhr.readyState<XMLHttpRequest.DONE&&this._xhr.abort(),this._xhr=null)},_fpsChanged(f,h){0==f?this._clear():0==h&&this._ping()}})})();

//# sourceURL=build://tf-beholder-dashboard/tf-beholder-info.html.js
(function(){const b=vc.getRouter().pluginRoute("beholder","/section-info");Polymer({is:"tf-beholder-info",properties:{fps:{type:Number,value:10,observer:"_fpsChanged"},xhrTimeout:{type:Number,value:1E4},_items:{type:Array,value:()=>[{name:"Loading..."}]},_xhr:Object,_timer:Number},attached(){this._load()},detached(){this._clear()},_load(){this._clear();this._xhr=new XMLHttpRequest;this._xhr.open("GET",b,!0);this._xhr.timeout=this.xhrTimeout;this._xhr.onload=this._onLoad.bind(this);this._xhr.onerror=
this._retry.bind(this,this._getSleep());this._xhr.ontimeout=this._retry.bind(this,1);this._xhr.send(null)},_onLoad(){if(200==this._xhr.status){const d=JSON.parse(this._xhr.responseText);console.assert(Array.isArray(d),"Expected response to be in an array");this._items=d}this._retry(this._getSleep())},_retry(d){this._timer=window.setTimeout(this._load.bind(this),d)},_getSleep(){return 1E3/(0===this.fps?1:this.fps)},_clear(){this._timer&&(window.clearTimeout(this._timer),this._timer=null);this._xhr&&
(this._xhr.readyState<XMLHttpRequest.DONE&&this._xhr.abort(),this._xhr=null)},_fpsChanged(d,f){0==d?this._clear():0==f&&this._load()}})})();

//# sourceURL=build://tf-beholder-dashboard/tf-beholder-dashboard.html.js
(function(){Polymer({is:"tf-beholder-dashboard",properties:{_requestManager:{type:Object,value:()=>new vc.RequestManager(10,0)},_isAvailable:Boolean,_values:{type:String,value:"trainable_variables",observer:"_configChanged"},_mode:{type:String,value:"variance",observer:"_configChanged"},_scaling:{type:String,value:"layer",observer:"_configChanged"},_windowSize:{type:Number,value:15,observer:"_configChanged"},_previousFPS:{type:Number,value:30},_FPS:{type:Number,value:10,observer:"_configChanged"},
_recordText:{type:String,value:"start recording"},_isRecording:{type:Boolean,value:!1,observer:"_configChanged"},_showAll:{type:Boolean,value:!1,observer:"_configChanged"},_colormap:{type:String,value:"magma",observer:"_configChanged"},_is_active:{type:Boolean,value:!1,observer:"_configChanged"},_controls_disabled:{type:Boolean,value:!1,observer:"_configChanged"}},_valuesNotFrame(b){return"frames"!==b},_varianceSelected(b){return"variance"===b},_configChanged(){if(this._is_active&&!this._controls_disabled){var b=
[this._values,this._mode,this._scaling,this._windowSize,this._FPS,this._isRecording,this._showAll,this._colormap],d;for(d of b)if("undefined"===typeof d||""===d)return;b=vc.getRouter().pluginRoute("beholder","/change-config");this._requestManager.request(b,{values:this._values,mode:this._mode,scaling:this._scaling,window_size:this._windowSize,FPS:this._FPS,is_recording:this._isRecording,show_all:this._showAll,colormap:this._colormap})}},_toggleRecord(){"start recording"==this._recordText?(this.set("_recordText",
"stop recording"),this.set("_isRecording",!0)):(this.set("_recordText","start recording"),this.set("_isRecording",!1));this.$.record_button.classList.toggle("is-recording")},attached:function(){this._requestManager.request(vc.getRouter().pluginsListing()).then(b=>{"beholder"in b?(this.$.initialDialog.closeDialog(),this.set("_isAvailable",!0)):(this.$.initialDialog.openNoTensorFlowDialog(),this.set("_isAvailable",!1))})},ready(){this.reload()},reload(){if(this._isAvailable){const b=vc.getRouter().pluginRoute("beholder",
"/is-active");this._requestManager.request(b).then(d=>{this.set("_is_active",d.is_active);this.set("_controls_disabled",!d.is_config_writable)})}}});qf.registerDashboard()})();

//# sourceURL=build://tf-hparams-utils/tf-hparams-utils.html.js
(function(b){(function(d){(function(f){function h(B){return""!==B.displayName&&void 0!==B.displayName?B.displayName:B.name}function k(B){if(""!==B.displayName&&void 0!==B.displayName)return B.displayName;let I=B.name.group;B=B.name.tag;void 0===I&&(I="");void 0===B&&(B="");return""===I?B:I+"."+B}function t(B){return B.hparamColumns.length}function l(B){return B.metricColumns.length}function p(B,I){return B[I]}function m(B,I){return B.find(N=>_.isEqual(N.name,I))}function n(B,I,N){return I.hparams[B.hparamColumns[N].hparamInfo.name]}
function q(B,I,N){B=m(I.metricValues,B.metricColumns[N].metricInfo.name);return void 0===B?void 0:B.value}function u(B,I,N){return N<B.hparamColumns.length?n(B,I,N):q(B,I,N-B.hparamColumns.length)}function x(B){return B.hparamInfos.length}function A(B){return B.metricInfos.length}function y(B,I,N){return I.hparams[B.hparamInfos[N].name]}function w(B,I,N){B=m(I.metricValues,B.metricInfos[N].name);return void 0===B?void 0:B.value}function C(B,I,N){return N<B.hparamInfos.length?y(B,I,N):w(B,I,N-B.hparamInfos.length)}
function G(B){return _.isNumber(B)?B.toPrecision(5):void 0===B?"":B.toString()}function D(B,I){return B*B+I*I}f.hparamName=h;f.metricName=k;f.schemaColumnName=function(B,I){return I<B.hparamColumns.length?h(B.hparamColumns[I].hparamInfo):k(B.metricColumns[I-B.hparamColumns.length].metricInfo)};f.numHParams=t;f.numMetrics=l;f.numColumns=function(B){return t(B)+l(B)};f.hparamValueByName=p;f.metricValueByName=m;f.hparamValueByIndex=n;f.metricValueByIndex=q;f.columnValueByIndex=u;f.numericColumnExtent=
function(B,I,N){return d3.extent(I,O=>u(B,O,N))};f.getAbsoluteColumnIndex=function(B,I,N){if(N<I.hparamInfos.length)B=B.hparamColumns.findIndex(O=>O.hparamInfo.name===I.hparamInfos[N].name);else{const O=I.metricInfos[N-I.hparamInfos.length].name;B=B.hparamColumns.length+B.metricColumns.findIndex(H=>H.metricInfo.name===O)}console.assert(-1!==B);return B};f.schemaVisibleColumnName=function(B,I){return I<B.hparamInfos.length?h(B.hparamInfos[I]):k(B.metricInfos[I-B.hparamInfos.length])};f.numVisibleHParams=
x;f.numVisibleMetrics=A;f.numVisibleColumns=function(B){return x(B)+A(B)};f.visibleNumericColumnExtent=function(B,I,N){return d3.extent(I,O=>C(B,O,N))};f.prettyPrintHParamValueByName=function(B,I){return G(p(B,I))};f.prettyPrintMetricValueByName=function(B,I){return G(m(B,I))};f.sessionGroupWithName=function(B,I){return B.find(N=>N.name===I)};f.hparamValueByVisibleIndex=y;f.metricValueByVisibleIndex=w;f.columnValueByVisibleIndex=C;f.prettyPrint=G;f.l2NormSquared=D;f.euclideanDist=function(B,I,N,O){return Math.sqrt(D(B-
N,I-O))};f.pointToRectangleDist=function(B,I,N,O,H,K){if(B<N&&I<O)return f.euclideanDist(B,I,N,O);if(N<=B&&B<H&&I<O)return O-I;if(H<=B&&I<O)return f.euclideanDist(B,I,H,O);if(B<N&&O<=I&&I<K)return N-B;if(N<=B&&B<H&&O<=I&&I<K)return 0;if(H<=B&&O<=I&&I<K)return B-H;if(B<N&&K<=I)return f.euclideanDist(B,I,N,K);if(N<=B&&B<H&&K<=I)return I-K;if(H<=B&&K<=I)return f.euclideanDist(B,I,H,K);throw"Point (x,y) must be in one of the regions defined above.";};f.translateStr=function(B,I){return void 0===I?"translate("+
B+")":"translate("+B+","+I+")"};f.rotateStr=function(B,I){let N="rotate(90";void 0!==B&&void 0!==I&&(N=N+","+B+","+I);return N+")"};f.isNullOrUndefined=function(B){return null===B||void 0===B};f.quadTreeVisitPointsInRect=function(B,I,N,O,H,K){B.visit((M,L,Q,T,X)=>{if(void 0===M.length){do L=B.x()(M.data),Q=B.y()(M.data),I<=L&&L<O&&N<=Q&&Q<H&&K(M.data);while(M=M.next);return!0}return L>=O||T<=I||Q>=H||X<=N})};f.quadTreeVisitPointsInDisk=function(B,I,N,O,H){B.visit((K,M,L,Q,T)=>{if(void 0===K.length){do M=
B.x()(K.data),L=B.y()(K.data),M=f.euclideanDist(I,N,M,L),M<=O&&H(K.data,M);while(K=K.next);return!0}return f.pointToRectangleDist(I,N,M,L,Q,T)>O})};f.filterSet=function(B,I){const N=new Set;B.forEach(O=>{I(O)&&N.add(O)});return N};f.setArrayObservably=function(B,I){const N=B.get("sessionGroups",B);Array.isArray(N)?B.splice.apply(B,["sessionGroups",0,N.length].concat(I)):B.set("sessionGroups",I)};f.hashOfString=function(B){let I=0;for(let N=0;N<B.length;++N)I=31*I+B.charCodeAt(N)&4294967295;return I+
Math.pow(2,31)}})(d.utils||(d.utils={}))})(b.hparams||(b.hparams={}))})(tf||(tf={}));

//# sourceURL=build://vaadin-split-layout/vaadin-split-layout.html.js
Polymer({is:"vaadin-split-layout",behaviors:[Polymer.IronResizableBehavior],properties:{vertical:{type:Boolean,reflectToAttribute:!0,value:!1},_previousPrimaryPointerEvents:String,_previousSecondaryPointerEvents:String},attached:function(){this._observer=Polymer.dom(this).observeNodes(this._processChildren)},detached:function(){Polymer.dom(this).unobserveNodes(this._observer)},_processChildren:function(){this.getEffectiveChildren().filter(function(b){return b.classList.contains("splitter-handle")?
(Polymer.dom(b).setAttribute("slot","handle"),!1):!0}).forEach(function(b,d){0===d?(this._primaryChild=b,Polymer.dom(b).setAttribute("slot","primary")):1==d?(this._secondaryChild=b,Polymer.dom(b).setAttribute("slot","secondary")):Polymer.dom(b).removeAttribute("slot")}.bind(this))},_setFlexBasis:function(b,d,f){d=Math.max(0,Math.min(d,f));0===d&&(d=1E-6);b.style.flex="1 1 "+d+"px"},_onHandleTrack:function(b){if(this._primaryChild&&this._secondaryChild){var d=this.vertical?"height":"width";"start"===
b.detail.state?(this._startSize={container:this.getBoundingClientRect()[d]-this.$.splitter.getBoundingClientRect()[d],primary:this._primaryChild.getBoundingClientRect()[d],secondary:this._secondaryChild.getBoundingClientRect()[d]},this._previousPrimaryPointerEvents=this._primaryChild.style.pointerEvents,this._previousSecondaryPointerEvents=this._secondaryChild.style.pointerEvents,this._primaryChild.style.pointerEvents="none",this._secondaryChild.style.pointerEvents="none"):(d=this.vertical?b.detail.dy:
b.detail.dx,this._setFlexBasis(this._primaryChild,this._startSize.primary+d,this._startSize.container),this._setFlexBasis(this._secondaryChild,this._startSize.secondary-d,this._startSize.container),this.notifyResize(),"end"===b.detail.state&&(delete this._startSize,this._primaryChild.style.pointerEvents=this._previousPrimaryPointerEvents,this._secondaryChild.style.pointerEvents=this._previousSecondaryPointerEvents))}},_preventDefault:function(b){b.preventDefault()}});

//# sourceURL=build://tf-hparams-query-pane/tf-hparams-query-pane.html.js
Polymer({is:"tf-hparams-query-pane",properties:{backend:Object,experimentName:String,configuration:{type:Object,value:()=>({schema:{hparamColumns:[],metricColumns:[]},columnsVisibility:[],visibleSchema:{hparamInfos:[],metricInfos:[]}}),readOnly:!0,notify:!0},sessionGroups:{type:Array,value:()=>[],readOnly:!0,notify:!0},_experiment:Object,_hparams:Array,_metrics:Array,_statuses:{type:Array,value:()=>[{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}]},_getExperimentResolved:{type:Object,value:function(){return new Promise(b=>{this._resolveGetExperiment=b})}},_resolveGetExperiment:Function,_listSessionGroupsCanceller:{type:Object,value:()=>new vc.Canceller},_sortByIndex:Number,_sortDirection:Number,_pageSizeInput:{type:Object,value:{value:"100",invalid:!1}},_pageNumberInput:{type:Object,value:{value:"1",invalid:!1}},
_pageCountStr:{type:String,value:"?"},_totalSessionGroupsCountStr:String,_sessionGroupsRequest:Object},observers:["_computeExperimentAndRelatedProps(backend, experimentName)","_updateConfiguration(_hparams.*, _metrics.*)"],reload(){this._queryServer()},_csvUrl(b,d){return this._downloadDataUrl(b,d,"csv")},_jsonUrl(b,d){return this._downloadDataUrl(b,d,"json")},_latexUrl(b,d){return this._downloadDataUrl(b,d,"latex")},_downloadDataUrl(b,d,f){return this.backend.getDownloadUrl(f,b,d.columnsVisibility)},
_computeExperimentAndRelatedProps(){const b=tf.hparams.utils;b.isNullOrUndefined(this.backend)||b.isNullOrUndefined(this.experimentName)||this.backend.getExperiment({experimentName:this.experimentName}).then(d=>{_.isEqual(d,this._experiment)||(this.set("_experiment",d),this._computeHParams(),this._computeMetrics(),this._queryServer(),this._resolveGetExperiment())})},_computeHParams(){const b=[];this._experiment.hparamInfos.forEach((d,f)=>{const h={info:d,displayed:5>f,filter:{}};h.info.hasOwnProperty("domainDiscrete")?
(h.filter.domainDiscrete=[],h.info.domainDiscrete.forEach(k=>{h.filter.domainDiscrete.push({value:k,checked:!0})})):"DATA_TYPE_BOOL"===h.info.type?h.filter.domainDiscrete=[{value:!1,checked:!0},{value:!0,checked:!0}]:"DATA_TYPE_FLOAT64"===h.info.type?h.filter.interval={min:{value:"",invalid:!1},max:{value:"",invalid:!1}}:"DATA_TYPE_STRING"===h.info.type?h.filter.regexp="":console.warn("unknown hparam.info.type: %s",h.info.type);b.push(h)});this.set("_hparams",b)},_computeMetrics(){const b=[];this._experiment.metricInfos.forEach((d,
f)=>{b.push({info:d,filter:{interval:{min:{value:"",invalid:!1},max:{value:"",invalid:!1}}},displayed:5>f})});this.set("_metrics",b)},_computeSchema(){return this._hparams&&this._metrics?{hparamColumns:this._hparams.map(b=>({hparamInfo:b.info})),metricColumns:this._metrics.map(b=>({metricInfo:b.info}))}:{hparamColumns:[],metricColumns:[]}},_updateConfiguration(){this.debounce("_updateConfiguration",()=>{this._setConfiguration({schema:this._computeSchema(),columnsVisibility:this._computeColumnsVisibility(),
visibleSchema:this._computeVisibleSchema()})})},_computeColumnsVisibility(){return this._hparams&&this._metrics?this._hparams.map(b=>b.displayed).concat(this._metrics.map(b=>b.displayed)):[]},_computeVisibleSchema(){if(!this._hparams||!this._metrics)return{hparamInfos:[],metricInfos:[]};const b=this._hparams.filter(f=>f.displayed).map(f=>f.info),d=this._metrics.filter(f=>f.displayed).map(f=>f.info);return{hparamInfos:b,metricInfos:d}},_queryServer(){this.debounce("queryServer",()=>this._queryServerNoDebounce(),
100)},_queryServerNoDebounce(){return this._sendListSessionGroupsRequest().then(this._listSessionGroupsCanceller.cancellable(({value:b,cancelled:d})=>{d||(0<=b.totalSize?(this.set("_pageCountStr",String(Math.ceil(b.totalSize/+this._pageSizeInput.value))),this.set("_totalSessionGroupsCountStr",b.totalSize)):(this.set("_pageCountStr","?"),this.set("_totalSessionGroupsCountStr","Unknown")),tf.hparams.utils.setArrayObservably(this,b.sessionGroups))}))},_sendListSessionGroupsRequest(){const b=this._buildListSessionGroupsRequest();
if(null!==b)return this.set("_sessionGroupsRequest",b),this._listSessionGroupsCanceller.cancelAll(),this.backend.listSessionGroups(b)},_buildListSessionGroupsRequest(){function b(m){var n=f.get(m+".min.value");console.assert(void 0!==n);n=""===n?"-Infinity":+n;f.set(m+".min.invalid",isNaN(n));h=h&&!isNaN(n);var q=f.get(m+".max.value");console.assert(void 0!==q);q=""===q?"Infinity":+q;f.set(m+".max.invalid",isNaN(q));h=h&&!isNaN(q);return isNaN(n)||isNaN(q)?null:{minValue:n,maxValue:q}}function d(m){var n=
f.get(m+".value");console.assert(void 0!==n);n=+n;const q=Number.isInteger(n)&&0<n;f.set(m+".invalid",!q);h=h&&q;return q?n:null}const f=this;let h=!0;const k=this._statuses.filter(m=>m.allowed).map(m=>m.value);let t=[];this._hparams.forEach((m,n)=>{let q={hparam:m.info.name};if(m.filter.domainDiscrete)q.filterDiscrete=[],m.filter.domainDiscrete.forEach(u=>{u.checked&&q.filterDiscrete.push(u.value)});else if(m.filter.interval)q.filterInterval=b("_hparams."+n+".filter.interval");else if(m.filter.regexp)q.filterRegexp=
m.filter.regexp;else return console.error("hparam.filter with no domainDiscrete, interval or regexp properties set: %s",m),null;t.push(q)});this._metrics.forEach((m,n)=>{m={metric:m.info.name,filterInterval:b("_metrics."+n+".filter.interval")};t.push(m)});if(void 0!==this._sortByIndex&&void 0!==this._sortDirection){if(!(this._sortByIndex in t))return console.error("No column in colParams with index sortByIndex: %s",this._sortByIndex),null;t[this._sortByIndex].order=0===this._sortDirection?"ORDER_ASC":
"ORDER_DESC"}const l=d("_pageNumberInput"),p=d("_pageSizeInput");return h?{experimentName:this.experimentName,allowedStatuses:k,colParams:t,startIndex:p*(l-1),sliceSize:p}:null},_metricSortByIndex(b){return b+this._hparams.length},_hparamName:tf.hparams.utils.hparamName,_metricName:tf.hparams.utils.metricName,_prettyPrint:tf.hparams.utils.prettyPrint});

//# sourceURL=build://iron-pages/iron-pages.html.js
Polymer({is:"iron-pages",behaviors:[Polymer.IronResizableBehavior,Polymer.IronSelectableBehavior],properties:{activateEvent:{type:String,value:null}},observers:["_selectedPageChanged(selected)"],_selectedPageChanged:function(){this.async(this.notifyResize)}});

//# sourceURL=build://paper-header-panel/paper-header-panel.html.js
(function(){var b={scroll:!0},d={standard:2,waterfall:1,"waterfall-tall":1},f={"waterfall-tall":!0};Polymer({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 Polymer.dom(this.$.headerSlot).getDistributedNodes()[0]},get scroller(){return this._getScrollerForMode(this.mode)},get visibleShadow(){return this.$.dropShadow.classList.contains("has-shadow")},_computeDropShadowHidden:function(h,k){k=d[k];this.shadow?this.toggleClass("has-shadow",!0,this.$.dropShadow):2===k?this.toggleClass("has-shadow",!0,this.$.dropShadow):
1!==k||h?this.toggleClass("has-shadow",!1,this.$.dropShadow):this.toggleClass("has-shadow",!0,this.$.dropShadow)},_computeMainContainerClass:function(h){var k={};k.flex="cover"!==h;return Object.keys(k).filter(function(t){return k[t]}).join(" ")},_addListener:function(){this.scroller.addEventListener("scroll",this.scrollHandler)},_removeListener:function(){this.scroller.removeEventListener("scroll",this.scrollHandler)},_modeChanged:function(h,k){var t=this.header;t&&(f[k]&&!f[h]?(t.classList.remove(this.tallClass),
this.async(function(){t.classList.remove("animate")},200)):this.toggleClass("animate",f[h],t));this._keepScrollingState()},_keepScrollingState:function(){var h=this.scroller,k=this.header;this._setAtTop(0===h.scrollTop);k&&this.tallClass&&f[this.mode]&&this.toggleClass(this.tallClass,this.atTop||k.classList.contains(this.tallClass)&&h.scrollHeight<this.offsetHeight,k)},_scroll:function(){this._keepScrollingState();this.fire("content-scroll",{target:this.scroller},{bubbles:!1})},_getScrollerForMode:function(h){return b[h]?
this:this.$.mainContainer}})})();

//# sourceURL=build://paper-tabs/paper-tab.html.js
Polymer({is:"paper-tab",behaviors:[Polymer.IronControlState,Polymer.IronButtonState,Polymer.PaperRippleBehavior],properties:{link:{type:Boolean,value:!1,reflectToAttribute:!0}},hostAttributes:{role:"tab"},listeners:{down:"_updateNoink",tap:"_onTap"},attached:function(){this._updateNoink()},get _parentNoink(){var b=Polymer.dom(this).parentNode;return!!b&&!!b.noink},_updateNoink:function(){this.noink=!!this.noink||!!this._parentNoink},_onTap:function(b){if(this.link){var d=this.queryEffectiveChildren("a");
d&&b.target!==d&&d.click()}}});

//# sourceURL=build://paper-tabs/paper-tabs.html.js
Polymer({is:"paper-tabs",behaviors:[Polymer.IronResizableBehavior,Polymer.IronMenubarBehavior],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._pendingActivationTimeout=this._pendingActivationItem=
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(b){Polymer.dom(this).querySelectorAll("paper-tab").forEach(b?this._setNoinkAttribute:this._removeNoinkAttribute)},_setNoinkAttribute:function(b){b.setAttribute("noink","")},_removeNoinkAttribute:function(b){b.removeAttribute("noink")},
_computeScrollButtonClass:function(b,d,f){return!d||f?"hidden":b?"not-visible":""},_computeTabsContentClass:function(b,d){return b?"scrollable"+(d?" fit-container":""):" fit-container"},_computeSelectionBarClass:function(b,d){return b?"hidden":d?"align-bottom":""},_onTabSizingChanged:function(){this.debounce("_onTabSizingChanged",function(){this._scroll();this._tabChanged(this.selectedItem)},10)},_onIronSelect:function(b){this._tabChanged(b.detail.item,this._previousTab);this._previousTab=b.detail.item;
this.cancelDebouncer("tab-changed")},_onIronDeselect:function(){this.debounce("tab-changed",function(){this._tabChanged(null,this._previousTab);this._previousTab=null},1)},_activateHandler:function(){this._cancelPendingActivation();Polymer.IronMenuBehaviorImpl._activateHandler.apply(this,arguments)},_scheduleActivation:function(b,d){this._pendingActivationItem=b;this._pendingActivationTimeout=this.async(this._bindDelayedActivationHandler,d)},_delayedActivationHandler:function(){var b=this._pendingActivationItem;
this._pendingActivationTimeout=this._pendingActivationItem=void 0;b.fire(this.activateEvent,null,{bubbles:!0,cancelable:!0})},_cancelPendingActivation:function(){void 0!==this._pendingActivationTimeout&&(this.cancelAsync(this._pendingActivationTimeout),this._pendingActivationTimeout=this._pendingActivationItem=void 0)},_onArrowKeyup:function(){this.autoselect&&this._scheduleActivation(this.focusedItem,this.autoselectDelay)},_onBlurCapture:function(b){b.target===this._pendingActivationItem&&this._cancelPendingActivation()},
get _tabContainerScrollSize(){return Math.max(0,this.$.tabsContainer.scrollWidth-this.$.tabsContainer.offsetWidth)},_scroll:function(b,d){this.scrollable&&this._affectScroll(d&&-d.ddx||0)},_down:function(){this.async(function(){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null)},1)},_affectScroll:function(b){this.$.tabsContainer.scrollLeft+=b;b=this.$.tabsContainer.scrollLeft;this._leftHidden=0===b;this._rightHidden=b===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(b,d){if(b){var f=this.$.tabsContent.getBoundingClientRect(),
h=f.width,k=b.getBoundingClientRect();f=k.left-f.left;this._pos={width:this._calcPercent(k.width,h),left:this._calcPercent(f,h)};if(this.noSlide||null==d)this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),this._positionBar(this._pos.width,this._pos.left);else{var t=d.getBoundingClientRect();d=this.items.indexOf(d);b=this.items.indexOf(b);this.$.selectionBar.classList.add("expand");b=d<b;this._isRTL&&(b=!b);b?this._positionBar(this._calcPercent(k.left+k.width-
t.left,h)-5,this._left):this._positionBar(this._calcPercent(t.left+t.width-k.left,h)-5,this._calcPercent(f,h)+5);this.scrollable&&this._scrollToSelectedIfNeeded(k.width,f)}}else this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),this._positionBar(0,0)},_scrollToSelectedIfNeeded:function(b,d){d-=this.$.tabsContainer.scrollLeft;0>d?this.$.tabsContainer.scrollLeft+=d:(d+=b-this.$.tabsContainer.offsetWidth,0<d&&(this.$.tabsContainer.scrollLeft+=d))},_calcPercent:function(b,
d){return 100*b/d},_positionBar:function(b,d){b=b||0;d=d||0;this._width=b;this._left=d;this.transform("translateX("+d+"%) scaleX("+b/100+")",this.$.selectionBar)},_onBarTransitionEnd:function(){var b=this.$.selectionBar.classList;b.contains("expand")?(b.remove("expand"),b.add("contract"),this._positionBar(this._pos.width,this._pos.left)):b.contains("contract")&&b.remove("contract")}});

//# sourceURL=build://paper-toolbar/paper-toolbar.html.js
Polymer({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(b){var d=new MutationObserver(function(){this._updateAriaLabelledBy()}.bind(this));
d.observe(b,{childList:!0,subtree:!0});return d},_updateAriaLabelledBy:function(){Polymer.dom.flush();for(var b=[],d=Array.prototype.slice.call(Polymer.dom(this.root).querySelectorAll("slot")).concat(Array.prototype.slice.call(Polymer.dom(this.root).querySelectorAll("content"))),f,h=0;f=d[h];h++){f=Polymer.dom(f).getDistributedNodes();for(var k,t=0;k=f[t];t++)if(k.classList&&k.classList.contains("title"))if(k.id)b.push(k.id);else{var l="paper-toolbar-label-"+Math.floor(1E4*Math.random());k.id=l;b.push(l)}}0<
b.length&&this.setAttribute("aria-labelledby",b.join(" "))},_computeBarExtraClasses:function(b){return b?b+("justified"===b?"":"-justified"):""}});

//# sourceURL=build://tf-hparams-scale-and-color-controls/tf-hparams-scale-and-color-controls.html.js
Polymer({is:"tf-hparams-scale-and-color-controls",properties:{configuration:Object,sessionGroups:Array,options:{type:Object,notify:!0,value:null}},observers:["_configurationChanged(configuration.*)","_unselectDisabledLogScales(sessionGroups.*)"],_configurationChanged(){const b=this.configuration.visibleSchema,d=this.configuration.schema,f={columns:b.hparamInfos.map((h,k)=>({name:tf.hparams.utils.hparamName(h),index:k,absoluteIndex:tf.hparams.utils.getAbsoluteColumnIndex(d,b,k),scale:this._isNumericColumn(k)?
"LINEAR":"NON_NUMERIC"})).concat(b.metricInfos.map((h,k)=>{k+=b.hparamInfos.length;return{scale:"LINEAR",name:tf.hparams.utils.metricName(h),index:k,absoluteIndex:tf.hparams.utils.getAbsoluteColumnIndex(d,b,k)}})),minColor:"#0000FF",maxColor:"#FF0000",configuration:this.configuration};this.set("options",f);Polymer.dom.flush();this.set("options.colorByColumnIndex",this._defaultColorByColumnIndex())},_unselectDisabledLogScales(){null!==this.options&&this.options.columns.forEach(b=>{const d="options.columns."+
b.index;this._allowLogScale(b)||"LOG"!==b.scale||this.set(d+".scale","LINEAR")})},_allowLogScale(b){if(!this._isNumericColumn(b.index)||!this.sessionGroups)return!1;const [d,f]=tf.hparams.utils.visibleNumericColumnExtent(this.configuration.visibleSchema,this.sessionGroups,b.index);return 0<d||0>f},_isNumericColumn(b){return b>=this.configuration.visibleSchema.hparamInfos.length||"DATA_TYPE_FLOAT64"===this.configuration.visibleSchema.hparamInfos[b].type},_defaultColorByColumnIndex(){if(0<this.configuration.visibleSchema.metricInfos.length)return this.configuration.visibleSchema.hparamInfos.length;
const b=this.configuration.visibleSchema.hparamInfos.findIndex(d=>"DATA_TYPE_FLOAT64"===d.type);if(-1!==b)return b}});

//# sourceURL=build://vaadin-grid/vaadin-grid-active-item-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.ActiveItemBehavior={properties:{activeItem:{type:Object,notify:!0,value:null}},listeners:{"cell-activate":"_activateItem"},observers:["_activeItemChanged(activeItem)"],_activateItem:function(b){var d=b.detail.model.item;this.activeItem=this.activeItem!==d?d:null;b.stopImmediatePropagation()},_activeItemChanged:function(){this.$.scroller._physicalItems&&this.$.scroller._physicalItems.forEach(function(b){this._updateItem(b,b.item)}.bind(this))}};

//# sourceURL=build://vaadin-grid/vaadin-grid-table-scroll-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.TableScrollBehaviorImpl={properties:{_vidxOffset:{type:Number,value:0},ios:{type:Boolean,value:navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),reflectToAttribute:!0},fixedSections:{type:Boolean,reflectToAttribute:!0,computed:"_hasFixedSections(scrollbarWidth)"},_frozenCells:{type:Array,value:function(){return[]}},scrolling:{type:Boolean,reflectToAttribute:!0}},ready:function(){this.scrollTarget=this.$.table},attached:function(){this.listen(this.scrollTarget,"wheel",
"_onWheel")},detached:function(){this.unlisten(this.scrollTarget,"wheel","_onWheel")},scrollToScaledIndex:function(b){this._pendingScrollToScaledIndex=null;this.$.items.style.borderTopWidth||(this._pendingScrollToScaledIndex=b);b=Math.min(Math.max(b,0),this.size-1);this.$.table.scrollTop=b/this.size*this.$.table.scrollHeight;this._scrollHandler();this.scrollToIndex(b-this._vidxOffset);this._resetScrollPosition(this._scrollPosition);this._scrollHandler();this._vidxOffset+this.lastVisibleIndex===this.size-
1&&(this.$.table.scrollTop=this.$.table.scrollHeight-this.$.table.offsetHeight,this._scrollHandler())},_hasFixedSections:function(b){return navigator.userAgent.match(/Edge/)&&0===b},_onWheel:function(b){if(!b.ctrlKey&&!this._hasScrolledAncestor(b.target,b.deltaX,b.deltaY)){var d=this.$.table,f=b.deltaY;1===b.deltaMode&&(f*=grid.$.scroller._physicalAverage);var h=Math.abs(b.deltaX)+Math.abs(f);this._canScroll(d,b.deltaX,f)?(b.preventDefault(),d.scrollTop+=f,d.scrollLeft+=b.deltaX,this._scrollHandler(),
this._hasResidualMomentum=!0,this._ignoreNewWheel=this.debounce("ignore-new-wheel",function(){this._ignoreNewWheel=null},500)):this._hasResidualMomentum&&h<=this._previousMomentum||this._ignoreNewWheel?b.preventDefault():h>this._previousMomentum&&(this._hasResidualMomentum=!1);this._previousMomentum=h}},_hasScrolledAncestor:function(b,d,f){if(this._canScroll(b,d,f))return!0;if("vaadin-grid-cell-content"!==b.localName&&b!==this&&b.parentElement)return this._hasScrolledAncestor(b.parentElement,d,f)},
_canScroll:function(b,d,f){return 0<f&&b.scrollTop<b.scrollHeight-b.offsetHeight||0>f&&0<b.scrollTop||0<d&&b.scrollLeft<b.scrollWidth-b.offsetWidth||0>d&&0<b.scrollLeft},_scrollHandler:function(){var b=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),d=b-this._scrollPosition,f=this._ratio,h=0,k=this._hiddenContentSize,t=f,l=[];this._scrollPosition=b;this._lastVisibleIndexVal=this._firstVisibleIndexVal=null;var p=this._scrollBottom;var m=this._physicalBottom;if(Math.abs(d)>this._physicalSize)this._physicalTop+=
d,h=Math.round(d/this._physicalAverage);else if(0>d){var n=b-this._physicalTop;l=this._virtualStart;var q=[];var u=this._physicalEnd;for(t=n/k;t<f&&h<this._physicalCount&&0<l-h&&m-this._getPhysicalSizeIncrement(u)>p;)n=this._getPhysicalSizeIncrement(u),t+=n/k,m-=n,q.push(u),h++,u=0===u?this._physicalCount-1:u-1;l=q;h=-h}else if(0<d){var x=this._virtualEnd,A=this._virtualCount-1;q=[];u=this._physicalStart;for(t=(m-p)/k;t<f&&h<this._physicalCount&&x+h<A&&this._physicalTop+this._getPhysicalSizeIncrement(u)<
b;)n=this._getPhysicalSizeIncrement(u),t+=n/k,this._physicalTop+=n,q.push(u),h++,u=(u+1)%this._physicalCount}this._virtualCount<this.size&&this._adjustVirtualIndexOffset(d);0===h?(m<p||this._physicalTop>b)&&this._increasePoolIfNeeded():(this._virtualStart+=h,this._physicalStart+=h,this._update(q,l));this._translateStationaryElements();this.hasAttribute("reordering")||(this.scrolling=!0);this.debounce("vaadin-grid-scrolling",function(){this.scrolling=!1;this._reorderRows()},100)},_adjustVirtualIndexOffset:function(b){if(1E4<
Math.abs(b))this._noScale?this._noScale=!1:(b=Math.round(this._scrollPosition/this._scrollHeight*1E3)/1E3,this._vidxOffset=Math.round(b*this.size-b*this._virtualCount),0===this._scrollTop&&this.scrollToIndex(0));else{b=this._vidxOffset||0;0===this._scrollTop?(this._vidxOffset=0,b!==this._vidxOffset&&this.scrollToIndex(0)):1E3>this.firstVisibleIndex&&0<this._vidxOffset&&(this._vidxOffset-=Math.min(this._vidxOffset,100),this.scrollToIndex(this.firstVisibleIndex+(b-this._vidxOffset)+1),this._noScale=
!0);var d=this.size-this._virtualCount;this._scrollTop>=this._maxScrollTop?(this._vidxOffset=d,b!==this._vidxOffset&&this.scrollToIndex(this._virtualCount)):this.firstVisibleIndex>this._virtualCount-1E3&&this._vidxOffset<d&&(this._vidxOffset+=Math.min(d-this._vidxOffset,100),this.scrollToIndex(this.firstVisibleIndex-(this._vidxOffset-b)),this._noScale=!0)}},_reorderRows:function(){var b=Polymer.dom(this.$.items),d=b.querySelectorAll(".vaadin-grid-row"),f=d.length-(d[0].index-(this._virtualStart+this._vidxOffset));
if(f<d.length/2)for(var h=0;h<f;h++)b.appendChild(d[h]);else for(;f<d.length;f++)b.insertBefore(d[f],d[0])},_frozenCellsChanged:function(){this.debounce("cache-elements",function(){Polymer.dom(this.domHost.root).querySelectorAll(".vaadin-grid-cell").forEach(function(b){b.style.transform=""});this._frozenCells=Array.prototype.slice.call(Polymer.dom(this.domHost.root).querySelectorAll("[frozen]"));this._translateStationaryElements()});this._updateLastFrozen()},_updateLastFrozen:function(){if(this.columnTree){var b=
this.columnTree[this.columnTree.length-1].slice(0);b.sort(function(f,h){return f._order-h._order});var d=b.reduce(function(f,h,k){h._lastFrozen=!1;return h.frozen&&!h.hidden?k:f},void 0);void 0!==d&&(b[d]._lastFrozen=!0)}},_translateStationaryElements:function(){this.fixedSections?(this.$.items.style.transform=this._getTranslate(-this._scrollLeft||0,-this._scrollTop||0),this.$.footer.style.transform=this.$.header.style.transform=this._getTranslate(-this._scrollLeft||0,0)):this.$.footer.style.transform=
this.$.header.style.transform=this._getTranslate(0,this._scrollTop);for(var b=this._getTranslate(this._scrollLeft,0),d=0;d<this._frozenCells.length;d++)this._frozenCells[d].style.transform=b},_getTranslate:function(b,d){return"translate("+b+"px,"+d+"px)"}};vaadin.elements.grid.TableScrollBehavior=[Polymer.IronScrollTargetBehavior,vaadin.elements.grid.TableScrollBehaviorImpl];

//# sourceURL=build://vaadin-grid/vaadin-grid-cell-click-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.CellClickBehavior={listeners:{click:"_onClick"},attached:function(){this._cellContentFocusHandler=function(b){b.target!==this._cellContent&&this.fire("cell-content-focus",{cell:this})}.bind(this);this.addEventListener("focus",this._cellContentFocusHandler,!0)},detached:function(){this.removeEventListener("focus",this._cellContentFocusHandler,!0)},_onClick:function(b){"vaadin-grid-sorter"!==this.localName&&this.fire("cell-focus",{cell:this});if(this._cellClick){var d=Polymer.dom(b).localTarget;
d.getDistributedNodes&&(d=Polymer.dom(d).getDistributedNodes()[0]);var f=Polymer.dom(b).path;f=Array.prototype.slice.call(f,0,f.indexOf(d)+1);d.contains(this.target&&this.target.root.activeElement||document.activeElement)||f.some(this._isFocusable)||this._cellClick(b)}},_isFocusable:function(b){var d=Polymer.dom(b).parentNode;d=-1!==Array.prototype.indexOf.call(Polymer.dom(d).querySelectorAll("[tabindex], button, input, select, textarea, object, iframe, label, a[href], area[href]"),b);return!b.disabled&&
d}};

//# sourceURL=build://vaadin-grid/vaadin-grid-table-cell.html.js
(function(){var b={properties:{column:Object,expanded:Boolean,flexGrow:Number,colSpan:Number,focused:{type:Boolean,reflectToAttribute:!0},frozen:{type:Boolean,reflectToAttribute:!0},lastFrozen:{type:Boolean,reflectToAttribute:!0},hidden:{type:Boolean,reflectToAttribute:!0},instance:Object,index:Number,item:Object,selected:Boolean,template:Object,target:Object,width:String,order:Number,reorderStatus:{type:String,reflectToAttribute:!0},_childColumns:Array,_cellContent:Object,_insertionPoint:Object,
_templatizer:Object},observers:"_columnChanged(column);_cellAttached(column, isAttached);_expandedChanged(expanded, instance);_flexGrowChanged(flexGrow);_indexChanged(index, instance);_itemChanged(item, instance);_instanceChanged(instance, target);_selectedChanged(selected, instance);_toggleContent(isAttached, _cellContent, _insertionPoint);_toggleInstance(isAttached, _templatizer, instance);_widthChanged(width);_orderChanged(order);_visibleChildColumnsChanged(_visibleChildColumns);_childColumnsChanged(_childColumns)".split(";"),
ready:function(){this.classList.add("vaadin-grid-cell");!1===Polymer.Settings.useShadow&&(this.classList.add("style-scope"),this.classList.add("vaadin-grid"))},_columnChanged:function(d){this.flexGrow=d.flexGrow;this.frozen=d.frozen;this.lastFrozen=d._lastFrozen;this.headerTemplate=d.headerTemplate;this.footerTemplate=d.footerTemplate;this.template=d.template;this.width=d.width;this.hidden=d.hidden;this.resizable=d.resizable;this._childColumns=d._childColumns;this.order=d._order;d.colSpan&&(this.colSpan=
d.colSpan);this.listen(d,"property-changed","_columnPropChanged")},_cellAttached:function(d,f){void 0!==d&&void 0!==f&&(f?this.listen(d,"property-changed","_columnPropChanged"):this.async(function(){this.isAttached||this.unlisten(d,"property-changed","_columnPropChanged")}))},_columnPropChanged:function(d){d.target==this.column&&(this[d.detail.path]=d.detail.value)},_expandedChanged:function(d,f){void 0!==d&&void 0!==f&&(f.__expanded__=d,f.expanded=d)},_flexGrowChanged:function(d){this.style.flexGrow=
d},_indexChanged:function(d,f){void 0!==d&&void 0!==f&&(f.index=d)},_itemChanged:function(d,f){void 0!==d&&void 0!==f&&(f.item=d)},_selectedChanged:function(d,f){void 0!==d&&void 0!==f&&(f.__selected__=d,f.selected=d)},_childColumnsChanged:function(d){this.colSpan=d.length},_toggleContent:function(d,f,h){void 0!==d&&void 0!==f&&void 0!==h&&(d?(Polymer.dom(f).parentNode!==this.target&&Polymer.dom(this.target).appendChild(f),Polymer.dom(this).appendChild(h)):this.async(function(){this.isAttached||Polymer.dom(f).parentNode!==
this.target||Polymer.dom(this.target).removeChild(f)}))},_toggleInstance:function(d,f,h){void 0!==d&&void 0!==f&&void 0!==h&&(d?f.addInstance(h):f.removeInstance(h))},_widthChanged:function(d){this.style.width=d},_orderChanged:function(d){this.style.order=d},_templateChanged:function(d){this.instance=d.templatizer.createInstance();this._templatizer=d.templatizer},_instanceChanged:function(d,f){void 0!==d&&void 0!==f&&(this.style.height="",this._cellContent=this._cellContent||document.createElement("vaadin-grid-cell-content"),
d="vaadin-grid-cell-content-"+(vaadin.elements.grid._contentIndex=vaadin.elements.grid._contentIndex+1||0),this._cellContent.innerHTML="",Polymer.dom(this._cellContent).appendChild(this.instance.root),this._cellContent.setAttribute("id",d),Polymer.Element?(this._cellContent.setAttribute("slot",d),this._insertionPoint=this._insertionPoint||document.createElement("slot"),this._insertionPoint.setAttribute("name",d)):(this._insertionPoint=this._insertionPoint||document.createElement("content"),this._insertionPoint.setAttribute("select",
"#"+d)))}};Polymer({is:"vaadin-grid-table-cell",behaviors:[b,vaadin.elements.grid.CellClickBehavior],observers:["_templateChanged(template)"],_cellClick:function(d){d.defaultPrevented||this.fire("cell-activate",{model:this.instance})}});Polymer({is:"vaadin-grid-table-header-cell",properties:{headerTemplate:Object,resizable:Boolean,columnResizing:{type:Boolean,reflectToAttribute:!0}},behaviors:[b,vaadin.elements.grid.CellClickBehavior],observers:["_headerTemplateChanged(headerTemplate)","_isEmptyChanged(_isEmpty, isAttached)",
"_resizableChanged(resizable)"],listeners:{mousedown:"_cancelMouseDownOnResize",mousemove:"_enableDrag",mouseout:"_disableDrag",touchstart:"_onTouchStart",touchmove:"_onTouchMove",touchend:"_onTouchEnd",contextmenu:"_onContextMenu"},_onContextMenu:function(d){this._reorderGhost&&d.preventDefault()},_onTouchStart:function(d){d.target!==this._resizeHandle&&this.target.columnReorderingAllowed&&(this._startReorderTimeout=setTimeout(this._startReorder.bind(this,d),100))},_startReorder:function(d){this._reorderGhost=
this._getGhost();this._reorderGhost.style.visibility="visible";var f=new CustomEvent("dragstart",{bubbles:!0});this._cellContent.dispatchEvent(f);this._reorderXY={x:d.touches[0].clientX-this.getBoundingClientRect().left,y:d.touches[0].clientY-this.getBoundingClientRect().top};this._updateGhostPosition(d.touches[0].clientX,d.touches[0].clientY)},_onTouchMove:function(d){if(this._reorderGhost){d.preventDefault();var f=new CustomEvent("dragover",{bubbles:!0});f.clientX=d.touches[0].clientX;f.clientY=
d.touches[0].clientY;var h=this._contentFromPoint(f.clientX,f.clientY);h&&h.dispatchEvent(f);this._updateGhostPosition(d.touches[0].clientX,d.touches[0].clientY)}else clearTimeout(this._startReorderTimeout)},_updateGhostPosition:function(d,f){d-=this._reorderXY.x;f=f-this._reorderXY.y-50;var h=parseInt(this._reorderGhost.style.left||0),k=parseInt(this._reorderGhost.style.top||0),t=this._reorderGhost.getBoundingClientRect();this._reorderGhost.style.left=h-(t.left-d)+"px";this._reorderGhost.style.top=
k-(t.top-f)+"px"},_onTouchEnd:function(d){clearTimeout(this._startReorderTimeout);this._reorderGhost&&(d.preventDefault(),d=new CustomEvent("dragend",{bubbles:!0}),this.dispatchEvent(d),this._reorderGhost.style.visibility="hidden",this._reorderGhost=null)},_contentFromPoint:function(d,f){if(Polymer.Settings.useShadow){var h=this.target.$.scroller;h.toggleAttribute("no-content-pointer-events",!0);d=this.domHost.root.elementFromPoint(d,f);h.toggleAttribute("no-content-pointer-events",!1);if(d&&d.getContentChildren)return d.getContentChildren(Polymer.Element?
"slot":"content")[0]}else return document.elementFromPoint(d,f)},_getGhost:function(){var d=this.target.$.scroller.$.reorderghost;d.innerText=this._cellContent.innerText;var f=window.getComputedStyle(this._cellContent);"boxSizing display width height background alignItems padding border flex-direction overflow".split(" ").forEach(function(h){d.style[h]=f[h]},this);return d},_enableDrag:function(){this._cellContent.draggable=this.target.columnReorderingAllowed&&!window.getSelection().toString()},_disableDrag:function(){this._cellContent.draggable=
!1},_cancelMouseDownOnResize:function(d){d.target===this._resizeHandle&&d.preventDefault()},_resizableChanged:function(d){d?(this._resizeHandle=document.createElement("div"),this._resizeHandle.classList.add("vaadin-grid-column-resize-handle"),this.listen(this._resizeHandle,"track","_onTrack"),Polymer.dom(this).appendChild(this._resizeHandle)):this._resizeHandle&&(this.unlisten(this._resizeHandle,"track","_onTrack"),Polymer.dom(this).removeChild(this._resizeHandle))},_onTrack:function(d){this.columnResizing=
!0;var f=this.column;"vaadin-grid-column-group"===f.localName&&(f=Array.prototype.slice.call(f._childColumns,0).sort(function(t,l){return t._order-l._order}).filter(function(t){return!t.hidden}).pop());var h=this._getHeaderCellByColumn(f);if(h.offsetWidth){var k=window.getComputedStyle(h._cellContent);f.width=Math.max(10+parseInt(k.paddingLeft)+parseInt(k.paddingRight),h.offsetWidth+d.detail.x-h.getBoundingClientRect().right)+"px";f.flexGrow=0}Array.prototype.slice.call(Polymer.dom(this.parentElement.parentElement).querySelectorAll(".vaadin-grid-row:last-child .vaadin-grid-cell")).sort(function(t,
l){return t.column._order-l.column._order}).forEach(function(t,l,p){l<p.indexOf(h)&&(t.column.width=t.offsetWidth+"px",t.column.flexGrow=0)});this.columnResizing&&"end"===d.detail.state&&(this.columnResizing=!1);this.fire("column-resizing")},_getHeaderCellByColumn:function(d){return Array.prototype.filter.call(Polymer.dom(this.parentElement.parentElement).querySelectorAll(".vaadin-grid-row:last-child .vaadin-grid-cell"),function(f){return f.column===d})[0]},_headerTemplateChanged:function(d){void 0!==
d&&(null===d||!this._isColumnRow&&"vaadin-grid-column-group"!==this.column.localName?(this.instance={root:document.createElement("div")},this._isEmpty=!0):(this.instance=d.templatizer.createInstance(),this._templatizer=d.templatizer,this._isEmpty=!1))},_isEmptyChanged:function(d,f){f&&this.fire("cell-empty-changed")}});Polymer({is:"vaadin-grid-table-footer-cell",properties:{footerTemplate:Object},behaviors:[b,vaadin.elements.grid.CellClickBehavior],observers:["_footerTemplateChanged(footerTemplate)",
"_isEmptyChanged(_isEmpty, isAttached)"],_footerTemplateChanged:function(d){void 0!==d&&(null===d||!this._isColumnRow&&"vaadin-grid-column-group"!==this.column.localName?(this.instance={root:document.createElement("div")},this._isEmpty=!0):(this.instance=d.templatizer.createInstance(),this._templatizer=d.templatizer,this._isEmpty=!1))},_isEmptyChanged:function(d,f){f&&this.fire("cell-empty-changed")}});Polymer({is:"vaadin-grid-sizer-cell",behaviors:[b]})})();

//# sourceURL=build://vaadin-grid/vaadin-grid-sizer.html.js
Polymer({is:"vaadin-grid-sizer",properties:{columnTree:Array,top:Number,_columns:Array},observers:["_columnTreeChanged(columnTree)","_topChanged(top)"],_columnTreeChanged:function(b){this._columns=b[b.length-1]},_topChanged:function(b){this.style.top=b+"px"}});

//# sourceURL=build://vaadin-grid/vaadin-grid-table-outer-scroller.html.js
Polymer({is:"vaadin-grid-table-outer-scroller",properties:{scrollTarget:{type:Object,observer:"_scrollTargetChanged"},passthrough:{type:Boolean,reflectToAttribute:!0,value:!0}},listeners:{scroll:"_syncScrollTarget"},attached:function(){this.listen(this.domHost,"mousemove","_onMouseMove");this.style.webkitOverflowScrolling="touch"},detached:function(){this.unlisten(this.domHost,"mousemove","_onMouseMove")},_scrollTargetChanged:function(b,d){d&&this.unlisten(d,"scroll","_syncOuterScroller");this.listen(b,
"scroll","_syncOuterScroller")},_onMouseMove:function(b){this.passthrough=b.offsetY<=this.clientHeight&&b.offsetX<=this.clientWidth},_syncOuterScroller:function(){this._syncingScrollTarget||(this._syncingOuterScroller=!0,this.scrollTop=this.domHost._scrollTop,this.scrollLeft=this.domHost._scrollLeft);this._syncingScrollTarget=!1},_syncScrollTarget:function(){this._syncingOuterScroller||(this._syncingScrollTarget=!0,this.scrollTarget.scrollTop=this.scrollTop,this.scrollTarget.scrollLeft=this.scrollLeft,
this.domHost._scrollHandler());this._syncingOuterScroller=!1}});

//# sourceURL=build://vaadin-grid/vaadin-grid-focusable-cell-container-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.FocusableCellContainerBehavior={properties:{focused:{type:Boolean,reflectToAttribute:!0},_focusedRow:Object,_focusedRowIndex:Number,_focusedCell:Object,_focusedCellIndex:Number,_lastFocusedCell:Object},observers:["_announceFocusedCell(_focusedCell, focused)","_dispatchEvents(_focusedCell, focused)","_focusedCellChanged(_focusedRowIndex, _focusedCellIndex)"],_announceFocusedCell:function(b,d){void 0!==b&&void 0!==d&&this.domHost.navigating&&d&&(d=Polymer.Element?b._cellContent.getAttribute("slot"):
b._cellContent.id,"vaadin-grid-table-body"!==this.is||b.hasAttribute("detailscell")||(b=Array.prototype.indexOf.call(Polymer.dom(b.parentElement).querySelectorAll(".vaadin-grid-cell"),b),d=this.domHost.$.header.lastElementChild.children[b]._cellContent.id+" "+d),this.domHost.$.footerFocusTrap.activeTarget=d)},_dispatchEvents:function(b,d){void 0!==b&&void 0!==d&&(this._lastFocusedCell&&(this._lastFocusedCell._cellContent.dispatchEvent(new CustomEvent("cell-focusout")),this._lastFocusedCell=void 0),
d&&(b._cellContent.dispatchEvent(new CustomEvent("cell-focusin")),this._lastFocusedCell=b))},_focusedCellChanged:function(b,d){void 0!==b&&void 0!==d&&Array.prototype.forEach.call(Polymer.dom(this).children,function(f,h){f.focused=h===b;f.focused&&(this._focusedRow=f,this._focusedCellIndex=Math.min(d,f.children.length-1),this._focusedCell=f.children[this._focusedCellIndex]);f.cells.forEach(function(k,t){k.focused=t===this._focusedCellIndex}.bind(this))}.bind(this))},focusLeft:function(){if(!this._focusedCell.hasAttribute("detailscell")){var b=
this._visibleCellIndexes();0<b.length&&(this._focusedCellIndex=b[Math.max(0,b.indexOf(this._focusedCellIndex)-1)])}},focusDown:function(){this._focusedRowIndex=Math.min(this._focusedRowIndex+1,this.children.length-1)},_visibleCellIndexes:function(){var b=[];if(this._focusedRow&&this._focusedRow.children){for(var d=this._focusedRow.children,f=0;f<d.length;f++)d[f].hidden||d[f]===this._focusedRow._rowDetailsCell||b.push(f);b.sort(function(h,k){return d[h].column._order<d[k].column._order?-1:1})}return b},
focusPageDown:function(){this._focusedRowIndex=Math.min(this._focusedRowIndex+10,this.children.length-1)},focusPageUp:function(){this._focusedRowIndex=Math.max(0,this._focusedRowIndex-10)},focusRight:function(){if(!this._focusedCell.hasAttribute("detailscell")){var b=this._visibleCellIndexes();0<b.length&&(this._focusedCellIndex=b[Math.min(b.indexOf(this._focusedCellIndex)+1,b.length-1)])}},focusUp:function(){this._focusedRowIndex=Math.max(0,this._focusedRowIndex-1)},focusHome:function(){if(!this._focusedCell.hasAttribute("detailscell")){var b=
this._visibleCellIndexes();0<b.length&&(this._focusedCellIndex=b[0])}},focusEnd:function(){if(!this._focusedCell.hasAttribute("detailscell")){var b=this._visibleCellIndexes();0<b.length&&(this._focusedCellIndex=b[b.length-1])}},focusFirst:function(){this._focusedRowIndex=0;this.focusHome()},focusLast:function(){this._focusedRowIndex=this.children.length-1;this.focusEnd()}};

//# sourceURL=build://vaadin-grid/vaadin-grid-table-header-footer.html.js
(function(){var b={properties:{columnTree:Array,target:Object,_rows:Array},observers:["_columnTreeChanged(columnTree, target)","_rowsChanged(_rows)"],_columnTreeChanged:function(d,f){if(void 0!==d&&void 0!==f){this._rows&&this._rows.forEach(function(l){Polymer.dom(l).innerHTML=""});for(var h=[],k=0;k<d.length;k++){var t=this._createRow();t.target=f;t._isColumnRow=k==d.length-1;t.columns=d[k];h.push(t)}this._rows="vaadin-grid-table-header"===this.localName?h:h.reverse()}},_rowsChanged:function(d){Polymer.dom(this).innerHTML=
"";d.forEach(function(f){Polymer.dom(this).appendChild(f)}.bind(this))}};Polymer({is:"vaadin-grid-table-header",behaviors:[b,vaadin.elements.grid.FocusableCellContainerBehavior],_createRow:function(){return document.createElement("vaadin-grid-table-header-row")}});Polymer({is:"vaadin-grid-table-body",behaviors:[vaadin.elements.grid.FocusableCellContainerBehavior],observers:["_announceFocusedRow(_focusedRow)"],_announceFocusedRow:function(d){this.fire("iron-announce",{text:"Row "+(d.index+1)+" of "+
this.domHost.size})},_moveFocusToDetailsCell:function(){this._focusedCell.focused=!1;this._focusedRow._rowDetailsCell.focused=!0;this._focusedCell=this._focusedRow._rowDetailsCell},_focusedRowHasDetailsCell:function(){return this._focusedRow&&this._focusedRow._rowDetailsCell&&this._focusedCell!==this._focusedRow._rowDetailsCell},focusDown:function(){this._focusedRowHasDetailsCell()?this._moveFocusToDetailsCell():this._focusedRowIndex=Math.min(this._focusedRowIndex+1,this.domHost.size-1)},focusUp:function(){this._focusedRow&&
this._focusedCell===this._focusedRow._rowDetailsCell?this._focusedCellChanged(this._focusedRowIndex,this._focusedCellIndex):(this._focusedRowIndex=Math.max(0,this._focusedRowIndex-1),this._focusedRowHasDetailsCell()&&this._moveFocusToDetailsCell())},focusLast:function(){this._focusedRowIndex=this.domHost.size-1;this.focusEnd()},_focusedCellChanged:function(d,f){void 0!==d&&void 0!==f&&Array.prototype.forEach.call(Polymer.dom(this).children,function(h){h.focused=h.index===d;h.index===d&&(this._focusedRow=
h,this._focusedCell=h.children[f]);h.iterateCells(function(k,t){k.focused=t===f})}.bind(this))}});Polymer({is:"vaadin-grid-table-footer",behaviors:[b,vaadin.elements.grid.FocusableCellContainerBehavior],_createRow:function(){return document.createElement("vaadin-grid-table-footer-row")}})})();

//# sourceURL=build://vaadin-grid/vaadin-grid-table-focus-trap.html.js
Polymer({is:"vaadin-grid-table-focus-trap",hostAttributes:{role:"gridcell"},properties:{activeTarget:{type:String,observer:"_activeTargetChanged"}},ready:function(){this._primary=Polymer.dom(this.root).querySelector(".primary");this._secondary=Polymer.dom(this.root).querySelector(".secondary");if(Polymer.Settings.useNativeShadow||Polymer.Settings.useShadow)Polymer.dom(this).appendChild(this._secondary),Polymer.dom(this).appendChild(this._primary)},focus:function(){this._focused!==this._primary?this._primary.focus():
this._secondary.focus()},_onBaitFocus:function(b){this._focused=b.target;this._movingFocusInternally||(this.fire("focus-gained"),this._primary.tabIndex=-1)},_onBaitBlur:function(){this._movingFocusInternally||(this.fire("focus-lost"),this._primary.tabIndex=0)},_activeTargetChanged:function(b){this._movingFocusInternally=!0;this._focused===this._primary?(this._secondary.setAttribute("aria-labelledby",b),this._secondary.focus()):(this._primary.setAttribute("aria-labelledby",b),this._primary.focus());
this._movingFocusInternally=!1},_reannounce:function(){this._movingFocusInternally=!0;this._focused===this._primary?(this._secondary.setAttribute("aria-labelledby",this.activeTarget),this._secondary.focus()):(this._primary.setAttribute("aria-labelledby",this.activeTarget),this._primary.focus());this._movingFocusInternally=!1}});

//# sourceURL=build://vaadin-grid/vaadin-grid-table-row.html.js
(function(){var b={properties:{active:{type:Boolean,reflectToAttribute:!0,value:!1},columns:Array,index:Number,cells:{value:[]},target:Object,expanded:{value:!1},focused:{type:Boolean,reflectToAttribute:!0},item:Object,selected:{reflectToAttribute:!0},_rowDetailsCell:Object,rowDetailsTemplate:Object},observers:"_columnsChanged(columns, target);_indexChanged(index, cells);_itemChanged(item, cells);_itemChangedForDetails(item, _rowDetailsCell);_rowDetailsChanged(expanded, rowDetailsTemplate, target);_rowDetailsCellIndexChanged(_rowDetailsCell, index);_rowDetailsCellChanged(_rowDetailsCell, target);_selectedChanged(selected, cells);_selectedChangedForDetails(selected, _rowDetailsCell)".split(";"),
ready:function(){this.classList.add("vaadin-grid-row");!1===Polymer.Settings.useShadow&&(this.classList.add("style-scope"),this.classList.add("vaadin-grid"))},iterateCells:function(d){this.cells.forEach(d);this._rowDetailsCell&&d(this._rowDetailsCell)},_rowDetailsChanged:function(d,f,h){if(void 0!==d&&void 0!==f&&void 0!==h){if(d){var k=document.createElement("vaadin-grid-table-cell");k.setAttribute("detailscell",!0);k.frozen=!0;k.target=h;k.template=f;k.toggleAttribute("lastcolumn",!0);Polymer.dom(this.root).appendChild(k);
Polymer.dom.flush();this._rowDetailsCell=k}else this._rowDetailsCell&&(Polymer.dom(this.root).removeChild(this._rowDetailsCell),this._rowDetailsCell=null);this.iterateCells(function(t){t.expanded=d});this.target.$.scroller._frozenCellsChanged()}},_updateRowVisibility:function(){this.hidden=this.cells.every(function(d){return d._isEmpty})},_rowDetailsCellChanged:function(d,f){void 0!==d&&void 0!==f&&f.$.scroller._update()},_rowDetailsCellIndexChanged:function(d,f){void 0!==d&&void 0!==f&&(d?(d.index=
f,Polymer.dom.flush(),this.updateRowDetailsCellMetrics()):this.style.paddingBottom="")},updateRowDetailsCellMetrics:function(){this._rowDetailsCell&&(this.target&&this.target._observer&&this.target._observer.flush&&this.target._observer.flush(),this._rowDetailsCell.style.height="",this.style.paddingBottom=this._rowDetailsCell.style.height=this._rowDetailsCell.clientHeight+"px")},_columnsChanged:function(d,f){if(void 0!==d&&void 0!==f){Polymer.dom(this).innerHTML="";var h=[];d.forEach(function(k){var t=
"_"+this.is.replace(/-/g,"_")+"_cells";t=k[t]=k[t]||[];var l=t.filter(function(m){return!Polymer.dom(m).parentNode})[0];if(!l){l=this._createCell();var p=Array.prototype.some.call(this.target.querySelectorAll("dom-repeat"),function(m){return!m.restamp});(p=p||"vaadin-grid-table-header-row"===this.is||"vaadin-grid-table-footer-row"===this.is)||t.push(l)}l.index=this.index;l.target=this.target;l._isColumnRow=this._isColumnRow;l.column=k;l.expanded=this.expanded;Polymer.dom(this).appendChild(l);h.push(l)}.bind(this));
this.cells=h}},_indexChanged:function(d,f){void 0!==d&&void 0!==f&&f.forEach(function(h){h.index=d})},_itemChanged:function(d,f){void 0!==d&&void 0!==f&&f.forEach(function(h){h.item=d})},_itemChangedForDetails:function(d,f){void 0!==d&&void 0!==f&&f&&(f.item=d)},_selectedChanged:function(d,f){void 0!==d&&void 0!==f&&f.forEach(function(h){h.selected=d})},_selectedChangedForDetails:function(d,f){void 0!==d&&void 0!==f&&f&&(f.selected=d)},updateLastColumn:function(){this.cells.slice(0).sort(function(d,
f){return d.column._order-f.column._order}).forEach(function(d,f,h){d.toggleAttribute("lastcolumn",f===h.length-1)})}};Polymer({is:"vaadin-grid-table-row",behaviors:[b],_createCell:function(){return document.createElement("vaadin-grid-table-cell")}});Polymer({is:"vaadin-grid-table-header-row",behaviors:[b],observers:["_updateRowVisibility(columns)"],listeners:{"cell-empty-changed":"_updateRowVisibility"},_createCell:function(){return document.createElement("vaadin-grid-table-header-cell")}});Polymer({is:"vaadin-grid-table-footer-row",
behaviors:[b],observers:["_updateRowVisibility(columns)"],listeners:{"cell-empty-changed":"_updateRowVisibility"},_createCell:function(){return document.createElement("vaadin-grid-table-footer-cell")}})})();

//# sourceURL=build://vaadin-grid/vaadin-grid-templatizer.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};vaadin.elements.grid.Templatizer=function(){};
vaadin.elements.grid.Templatizer=Polymer({is:"vaadin-grid-templatizer",behaviors:[Polymer.Templatizer],properties:{dataHost:Object,template:Object,_templateInstances:{type:Array,value:function(){return[]}},_parentPathValues:{value:function(){return{}}}},observers:["_templateInstancesChanged(_templateInstances.*, _parentPathValues.*)"],created:function(){this._parentModel=!0;this._instanceProps={expanded:!0,index:!0,item:!0,selected:!0}},createInstance:function(){this._ensureTemplatized();var b=this.stamp({});
this.addInstance(b);return b},addInstance:function(b){-1===this._templateInstances.indexOf(b)&&this.push("_templateInstances",b)},removeInstance:function(b){this.splice("_templateInstances",this._templateInstances.indexOf(b),1)},_ensureTemplatized:function(){this.template._templatized||(this.template._templatized=!0,this.templatize(this.template),this._parentProps=this._parentProps||{},Polymer.Element||Object.keys(this._parentProps).forEach(function(){},this))},_forwardInstanceProp:function(b,d,f){void 0!==
b["__"+d+"__"]&&b["__"+d+"__"]!==f&&this.fire("template-instance-changed",{prop:d,value:f,inst:b})},_forwardInstancePath:function(b,d,f){0!==d.indexOf("item.")||this._suppressItemChangeEvent||this.fire("item-changed",{item:b.item,path:d.substring(5),value:f})},_notifyInstancePropV2:function(b,d,f){this._forwardInstanceProp(b,d,f);this._forwardInstancePath(b,d,f)},_forwardParentProp:function(b,d){this._parentPathValues[b]=d;this._templateInstances.forEach(function(f){f.set(b,d)},this)},_forwardParentPath:function(b,
d){this.set(["_parentPathValues",b],d);this._templateInstances.forEach(function(f){f.notifyPath(b,d)},this)},_forwardHostPropV2:function(b,d){this._forwardParentProp(b,d);this._templateInstances&&this._templateInstances.forEach(function(f){f.notifyPath(b,d)},this)},_templateInstancesChanged:function(b){if("_templateInstances"===b.path){var d=0;var f=this._templateInstances.length}else if("_templateInstances.splices"===b.path)d=b.value.index,f=b.value.addedCount;else return;Object.keys(this._parentPathValues||
{}).forEach(function(h){for(var k=d;k<d+f;k++)this._templateInstances[k].set(h,this._parentPathValues[h])},this)}});

//# sourceURL=build://vaadin-grid/vaadin-grid-row-details-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.RowDetailsBehavior={properties:{expandedItems:{type:Array,value:function(){return[]}}},listeners:{"template-instance-changed":"_templateInstanceChangedExpanded"},observers:["_expandedItemsChanged(expandedItems.*, dataProvider)","_rowDetailsTemplateChanged(_rowDetailsTemplate)"],_expandedItemsChanged:function(b,d){void 0!==b&&void 0!==d&&(this._flushItemsDebouncer(),this.$.scroller._physicalItems&&this.$.scroller._physicalItems.forEach(function(f){f.expanded=this._isExpanded(f.item)}.bind(this)))},
_rowDetailsTemplateChanged:function(b){var d=new vaadin.elements.grid.Templatizer;d.dataHost=this.dataHost;d._instanceProps={expanded:!0,index:!0,item:!0,selected:!0};Polymer.dom(this.root).appendChild(d);d.template=b;b.templatizer=d},_isExpanded:function(b){return this.expandedItems&&-1!==this.expandedItems.indexOf(b)},expandItem:function(b){this._isExpanded(b)||this.push("expandedItems",b)},collapseItem:function(b){this._isExpanded(b)&&this.splice("expandedItems",this.expandedItems.indexOf(b),1)},
_templateInstanceChangedExpanded:function(b){"expanded"===b.detail.prop&&(b.detail.value?this.expandItem(b.detail.inst.item):this.collapseItem(b.detail.inst.item),b.stopPropagation())}};

//# sourceURL=build://vaadin-grid/vaadin-grid-data-provider-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.DataProviderBehavior={listeners:{"item-changed":"_templateItemChanged"},properties:{pageSize:{type:Number,value:50,observer:"_pageSizeChanged"},dataProvider:{type:Object,notify:!0,observer:"_dataProviderChanged"},_loading:Boolean,_cache:{type:Object,value:function(){return{}}},_pendingRequests:{type:Object,value:function(){return{}}}},_templateItemChanged:function(b){var d=b.detail.item;Array.prototype.forEach.call(Polymer.dom(this.$.items).children,function(f){f.item===d&&f.iterateCells(function(h){h._templatizer._suppressItemChangeEvent=
!0;h.instance.notifyPath("item."+b.detail.path,b.detail.value);h._templatizer._suppressItemChangeEvent=!1})})},_getCachedItem:function(b){var d=this._getPageForIndex(b),f=this._cache&&this._cache[d];return f?f[b-d*this.pageSize]:null},_getItem:function(b,d){this._updateItem(d,this._getCachedItem(b));this._eagerlyLoadPages();var f=this._uncachedPagesForPhysicalItems();0<f.length&&(this._loading=!0,this.debounce("load",function(){f.forEach(function(h){this._loadPage(h)}.bind(this))},100))},_cachedPagesForPhysicalItems:function(){return this._pagesForPhysicalItems().filter(function(b){return void 0!==
this._cache&&void 0!==this._cache[b]}.bind(this))},_uncachedPagesForPhysicalItems:function(){return this._pagesForPhysicalItems().filter(function(b){return void 0!==this._cache&&void 0===this._cache[b]}.bind(this))},_eagerlyLoadPages:function(){var b=this._cachedPagesForPhysicalItems().slice(0);if(0<b.length){b.sort(function(f,h){return f>h});var d=Math.min(b[b.length-1]+1,Math.max(0,Math.floor(this.size/this.pageSize)-1));this._loadPage(Math.max(0,b[0]-1));this._loadPage(d)}},_pagesForPhysicalItems:function(){return[this._getPageForIndex(this.$.scroller.firstVisibleIndex+
this.$.scroller._vidxOffset)].concat(this.$.scroller._physicalItems.filter(function(b){return b.index}).map(function(b){return this._getPageForIndex(b.index)}.bind(this))).reduce(function(b,d){-1===b.indexOf(d)&&b.push(d);return b},[])},_updateItems:function(b,d){for(var f=0;f<this.pageSize;f++){var h=this.$.scroller._virtualIndexToItem[b*this.pageSize+f];h&&(this._updateItem(h,d[f]),this.debounce("update-heights",function(){this.$.scroller._updateMetrics();this.$.scroller._positionItems();this.$.scroller._updateScrollerSize()},
1))}},_loadPage:function(b,d){d=d||this._updateItems.bind(this);if(!this._cache[b]&&!this._pendingRequests[b]&&this.dataProvider){this._pendingRequests[b]=!0;var f={page:b,pageSize:this.pageSize,sortOrders:this._mapSorters(),filters:this._mapFilters()};this.dataProvider(f,function(h){this._cache[b]=h;delete this._pendingRequests[b];d(b,h);this._loading=0<this._pendingRequests.length;this.debounce("check-size",this._checkSize,2E3)}.bind(this))}},_getPageForIndex:function(b){return Math.floor(b/this.pageSize)},
clearCache:function(){this._cache={};this._pendingRequests={};this.$.scroller.hasData&&this.$.scroller._update();this._flushItemsDebouncer()},_flushItemsDebouncer:function(){this.flushDebouncer("load")},_pageSizeChanged:function(b,d){void 0!==d&&b!==d&&this.clearCache()},_checkSize:function(){void 0===this.size&&console.warn('The \x3cvaadin-grid\x3e needs a value for "size" property in order to display rows.')},_dataProviderChanged:function(b,d){void 0!==d&&this.clearCache();this.$.scroller.hasData||
(this._loading=!0,this._loadPage(0,function(){this.$.scroller.hasData=!0}.bind(this)))}};

//# sourceURL=build://vaadin-grid/vaadin-grid-selection-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.SelectionBehavior={properties:{selectedItems:{type:Object,notify:!0,value:function(){return[]}}},observers:["_selectedItemsChanged(selectedItems.*)"],listeners:{"template-instance-changed":"_templateInstanceChangedSelection"},_templateInstanceChangedSelection:function(b){if("selected"===b.detail.prop){var d=b.detail.inst.item;(this._isSelected(d)?this.deselectItem:this.selectItem).bind(this)(d);this.fire("iron-announce",{text:(this._isSelected(d)?"Selected":"Deselected")+" Row "+
(b.detail.inst.index+1)+" of "+this.size});b.stopPropagation()}},_isSelected:function(b){return this.selectedItems&&-1<this.selectedItems.indexOf(b)},selectItem:function(b){b=this._takeItem(b);this._isSelected(b)||this.push("selectedItems",b)},deselectItem:function(b){b=this._takeItem(b);b=this.selectedItems.indexOf(b);-1<b&&this.splice("selectedItems",b,1)},_toggleItem:function(b){b=this._takeItem(b);-1===this.selectedItems.indexOf(b)?this.selectItem(b):this.deselectItem(b)},_takeItem:function(b){return"number"===
typeof b&&0<=b&&this.items&&this.items.length>b?this.items[b]:b},_selectedItemsChanged:function(b){!this.$.scroller._physicalItems||"selectedItems"!==b.path&&"selectedItems.splices"!==b.path||this.$.scroller._physicalItems.forEach(function(d){d.selected=this._isSelected(d.item)}.bind(this))}};

//# sourceURL=build://vaadin-grid/vaadin-grid-keyboard-navigation-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.TableKeyboardBehaviorImpl={hostAttributes:{role:"application",tabindex:0},keyBindings:{"ctrl+home":"_onCtrlHome","ctrl+end":"_onCtrlEnd",down:"_onArrowDown",end:"_onEnd",enter:"_onEnter",esc:"_onEscape",f2:"_onF2",home:"_onHome",left:"_onArrowLeft",pagedown:"_onPageDown",pageup:"_onPageUp",right:"_onArrowRight",space:"_onSpace",tab:"_onTab",up:"_onArrowUp"},attached:function(){Polymer.IronA11yAnnouncer.requestAvailability()},properties:{_virtualFocus:{type:Object,observer:"_virtualFocusChanged"},
interacting:{type:Boolean,reflectToAttribute:!0,value:!1},navigating:{type:Boolean,reflectToAttribute:!0,value:!1}},listeners:{focus:"_onFocus","cell-focus":"_onCellFocus","cell-content-focus":"_onCellContentFocus"},ready:function(){document.addEventListener("keydown",function(b){9===b.keyCode&&(this._tabbed=!0);9===b.keyCode&&b.shiftKey&&(this._shiftTabbed=!0)}.bind(this),!0);document.addEventListener("keyup",function(b){9===b.keyCode&&(this._tabbed=!1);9===b.keyCode&&b.shiftKey&&(this._shiftTabbed=
!1)}.bind(this),!0)},_isFooterVisible:function(){return 0<this.$.footer._rows.filter(function(b){return!b.hidden}).length},_onFocus:function(){this._tabbed&&!this._shiftTabbed&&this._activateNavigation()},_activateNavigation:function(){this.$.footerFocusTrap.focus()},_onFocusout:function(){this.interacting=this.navigating=!1},_onFooterFocus:function(){this.navigating=!0;this.interacting=!1;this._virtualFocus=this._virtualFocus||(this._shiftTabbed?this._isFooterVisible()?this.$.footer:this.$.items:
this.$.header)},_virtualFocusChanged:function(b,d){d&&(d.focused=!1);b&&(b._focusedCellIndex=b._focusedCellIndex||0,b._focusedRowIndex=b._focusedRowIndex||0,b.focused=!0,b===this.$.items&&this._ensureVirtualFocusInViewport())},_onTab:function(b){if(!this.interacting&&this._virtualFocus)if(this.navigating)if(b.detail.keyboardEvent.shiftKey)switch(this._virtualFocus){case this.$.footer:this._virtualFocus=this.$.items;b.preventDefault();break;case this.$.items:this._virtualFocus=this.$.header;b.preventDefault();
break;case this.$.header:this.focus(),this._virtualFocus=null}else switch(this._virtualFocus){case this.$.header:this._virtualFocus=this.$.items;b.preventDefault();break;case this.$.items:this._isFooterVisible()?(this._virtualFocus=this.$.footer,b.preventDefault()):this.async(function(){this._virtualFocus=null},1);break;case this.$.footer:this._virtualFocus=null}else this._activateNavigation(),b.preventDefault()},_isAboveViewport:function(b){return this.firstVisibleIndex>b},_onArrowDown:function(b){this.interacting||
(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusDown(),this._ensureVirtualFocusInViewport())},_scrollPageDown:function(){var b=this.$.header.getBoundingClientRect(),d=this.$.footer.getBoundingClientRect();this.$.scroller.$.table.scrollTop+=d.top-b.bottom;this.$.scroller._scrollHandler()},_onPageDown:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus===this.$.items?(b=this.$.scroller.lastVisibleIndex,this._scrollPageDown(),this._virtualFocus._focusedRowIndex+=
this.$.scroller.lastVisibleIndex-b||this.$.scroller.lastVisibleIndex-this._virtualFocus._focusedRowIndex,this._ensureVirtualFocusInViewport()):this._virtualFocus.focusPageDown())},_scrollPageUp:function(){var b=this.$.header.getBoundingClientRect(),d=this.$.footer.getBoundingClientRect();this.$.scroller.$.table.scrollTop-=d.top-b.bottom;this.$.scroller._scrollHandler()},_onPageUp:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus===this.$.items?(b=this.$.scroller.lastVisibleIndex,
this._scrollPageUp(),this._virtualFocus._focusedRowIndex-=b-this.$.scroller.lastVisibleIndex||this._virtualFocus._focusedRowIndex,this._ensureVirtualFocusInViewport()):this._virtualFocus.focusPageUp())},_onArrowUp:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusUp(),this._ensureVirtualFocusInViewport())},_onArrowRight:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusRight(),this._ensureVirtualFocusInViewport())},
_onArrowLeft:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusLeft(),this._ensureVirtualFocusInViewport())},_onHome:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusHome(),this._ensureVirtualFocusInViewport())},_onEnd:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusEnd(),this._ensureVirtualFocusInViewport())},_moveFocusToFocusTarget:function(){var b=this._virtualFocus._focusedCell._cellContent;
(b=b.querySelector("[focus-target]")||b.firstElementChild)&&b.focus()},_onEnter:function(b){this.interacting?"input"===b.detail.keyboardEvent.target.localName&&"text"===b.detail.keyboardEvent.target.type&&this.$.footerFocusTrap.focus():(b.preventDefault(),this._moveFocusToFocusTarget())},_onEscape:function(){this.interacting?this.$.footerFocusTrap.focus():this.navigating&&(this.navigating=!1)},_onF2:function(b){b.preventDefault();this.interacting?this.$.footerFocusTrap.focus():this._moveFocusToFocusTarget()},
_onCtrlHome:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusFirst(),this._ensureVirtualFocusInViewport())},_onCtrlEnd:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusLast(),this._ensureVirtualFocusInViewport())},_onSpace:function(b){if(!this.interacting){b.preventDefault();b=this._virtualFocus._focusedCell;var d=b.getContentChildren(Polymer.Element?"slot":"content")[0].firstElementChild;d?d.click():this.navigating&&
this.fire("cell-activate",{model:b.instance})}},_onCellContentFocus:function(b){this.interacting=!0;this._onCellFocus(b)},_onCellFocus:function(b){b=b.detail.cell;var d=b.parentElement,f=d.parentElement,h=Array.prototype.indexOf.call(Polymer.dom(f).children,d);f===this.$.items&&(h=d.index);f._focusedRowIndex=h;f._focusedCellIndex=Array.prototype.indexOf.call(Polymer.dom(d).children,b);this._virtualFocus=f;b.hasAttribute("detailscell")&&(f._focusedCellIndex=0,f._moveFocusToDetailsCell())},_ensureVirtualFocusInViewport:function(){var b=
this.$.scroller._vidxOffset+this.$.scroller._virtualStart,d=this._virtualFocus._focusedRowIndex;this._virtualFocus===this.$.items&&(d<b||d>b+this.$.scroller._physicalCount)&&(this.$.scroller.scrollToScaledIndex(d),this._virtualFocus._focusedCellChanged(d,this._virtualFocus._focusedCellIndex));this._ensureElementInViewport(this._virtualFocus._focusedCell)},_ensureElementInViewport:function(b){var d=b.getBoundingClientRect();if(this._virtualFocus===this.$.items){var f=this.$.footer.getBoundingClientRect().top,
h=this.$.header.getBoundingClientRect().bottom;d.bottom>f?this.$.scroller.$.table.scrollTop+=d.bottom-f:d.top<h&&(this.$.scroller.$.table.scrollTop+=d.top-h)}if(!b.hasAttribute("detailscell")){b=this.$.scroller.$.table.getBoundingClientRect().right;f=this.$.scroller.$.table.getBoundingClientRect().left;if(h=this._virtualFocus._focusedRow.querySelector("[last-frozen]"))f=h.getBoundingClientRect().right;d.right>b?this.$.scroller.$.table.scrollLeft+=d.right-b:d.left<f&&(this.$.scroller.$.table.scrollLeft+=
d.left-f)}}};vaadin.elements.grid.TableKeyboardBehavior=[vaadin.elements.grid.TableKeyboardBehaviorImpl,Polymer.IronA11yKeysBehavior];

//# sourceURL=build://vaadin-grid/vaadin-grid-column-reordering-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};vaadin.elements.grid.ColumnReorderingBehavior={properties:{columnReorderingAllowed:{type:Boolean,value:!1}}};
vaadin.elements.grid.TableColumnReorderingBehavior={properties:{_orderBaseScope:{type:Number,value:1E7}},listeners:{dragstart:"_onDragStart",dragover:"_onDragOver",dragend:"_onDragEnd"},observers:["_updateOrders(columnTree, columnTree.*)"],_updateOrders:function(b,d){void 0!==b&&void 0!==d&&b[0].forEach(function(f,h){f._order=(h+1)*this._orderBaseScope},this)},_onDragStart:function(b){if("vaadin-grid-cell-content"===b.target.localName){var d=this._getCellByCellContent(b.target);d&&(this.toggleAttribute("reordering",
!0),this._draggedColumn=d.column,this._setSiblingsReorderStatus(this._draggedColumn,"allowed"),this._draggedColumn._reorderStatus="dragging",b.dataTransfer&&(b.dataTransfer.setData("text",""),b.dataTransfer.effectAllowed="move"),this._autoScroller())}},_setSiblingsReorderStatus:function(b,d){Array.prototype.filter.call(Polymer.dom(Polymer.dom(b).parentNode).children,function(f){return/column/.test(f.localName)&&this._isSwapAllowed(f,b)},this).forEach(function(f){f._reorderStatus=d})},_onDragOver:function(b){if(this._draggedColumn){var d=
(Polymer.Element?b.composedPath():Polymer.dom(b).path).filter(function(f){return"vaadin-grid-cell-content"===f.localName})[0];d&&(b.preventDefault(),d=this._getCellByCellContent(d),(d=this._getTargetColumn(d,this._draggedColumn))&&this._isSwapAllowed(this._draggedColumn,d)&&this._isSwappableByPosition(d,b.clientX)&&this._swapColumnOrders(this._draggedColumn,d),this._lastDragClientX=b.clientX)}},_autoScroller:function(){if(this._lastDragClientX){var b=this._lastDragClientX-this.getBoundingClientRect().right+
50,d=this.getBoundingClientRect().left-this._lastDragClientX+50;0<b?this.$.table.scrollLeft+=b/10:0<d&&(this.$.table.scrollLeft-=d/10);this._scrollHandler()}this._draggedColumn&&this.async(this._autoScroller,10)},_onDragEnd:function(){this._draggedColumn&&(this.toggleAttribute("reordering",!1),this._draggedColumn._reorderStatus="",this._setSiblingsReorderStatus(this._draggedColumn,""),this._lastDragClientX=this._draggedColumn=null)},_isSwapAllowed:function(b,d){if(b&&d){var f=b.parentElement===d.parentElement,
h=b.frozen===d.frozen;return b!==d&&f&&h}},_isSwappableByPosition:function(b,d){var f=Array.prototype.filter.call(Polymer.dom(this.$.header).querySelectorAll(".vaadin-grid-cell"),function(k){return k.column===b})[0],h=this.$.header.querySelector("[reorder-status\x3ddragging]").getBoundingClientRect();return f.getBoundingClientRect().left>h.left?d>f.getBoundingClientRect().right-h.width:d<f.getBoundingClientRect().left+h.width},_getCellByCellContent:function(b){if(Polymer.Element)return b.assignedSlot.parentNode;
b=Polymer.dom(b).getDestinationInsertionPoints()[0];return Polymer.dom(b).parentNode},_swapColumnOrders:function(b,d){var f=b._order;b._order=d._order;d._order=f;this._updateLastFrozen();this._updateLastColumn()},_getTargetColumn:function(b,d){if(b&&d){for(var f=b.column;f.parentElement!==d.parentElement&&f!==this.target;)f=f.parentElement;return f.parentElement===d.parentElement?f:b.column}}};

//# sourceURL=build://vaadin-grid/iron-list-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.IronListBehaviorImpl=function(){var b=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),d=b&&8<=b[1];return{is:"iron-list",properties:{maxPhysicalCount:{type:Number,value:500},as:{type:String,value:"item"},indexAs:{type:String,value:"index"}},_ratio:.5,_scrollerPaddingTop:0,_scrollPosition:0,_physicalSize:0,_physicalAverage:0,_physicalAverageCount:0,_physicalTop:0,_virtualCount:0,_physicalIndexForKey:null,_estScrollHeight:0,_scrollHeight:0,_viewportHeight:0,_viewportWidth:0,
_physicalItems:null,_physicalSizes:null,_firstVisibleIndexVal:null,_lastVisibleIndexVal:null,_collection:null,_itemsRendered:!1,_lastPage:null,_maxPages:3,_itemsPerRow:1,_itemWidth:0,_rowHeight: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._scrollerPaddingTop},_minVirtualStart:0,get _maxVirtualStart(){return Math.max(0,this._virtualCount-this._physicalCount)},_virtualStartVal:0,set _virtualStart(f){this._virtualStartVal=Math.min(this._maxVirtualStart,Math.max(this._minVirtualStart,f))},get _virtualStart(){return this._virtualStartVal||0},_physicalStartVal:0,set _physicalStart(f){this._physicalStartVal=f%this._physicalCount;0>this._physicalStartVal&&(this._physicalStartVal=this._physicalCount+this._physicalStartVal);
this._physicalEnd=(this._physicalStart+this._physicalCount-1)%this._physicalCount},get _physicalStart(){return this._physicalStartVal||0},_physicalCountVal:0,set _physicalCount(f){this._physicalCountVal=f;this._physicalEnd=(this._physicalStart+this._physicalCount-1)%this._physicalCount},get _physicalCount(){return this._physicalCountVal},_physicalEnd:0,get _optPhysicalSize(){return this._viewportHeight*this._maxPages},get _optPhysicalCount(){return this._estRowsInView*this._itemsPerRow*this._maxPages},
get _isVisible(){return this.scrollTarget&&!(!this.scrollTarget.offsetWidth&&!this.scrollTarget.offsetHeight)},get firstVisibleIndex(){if(null===this._firstVisibleIndexVal){var f=Math.floor(this._physicalTop+this._scrollerPaddingTop);this._firstVisibleIndexVal=this._iterateItems(function(h,k){f+=this._getPhysicalSizeIncrement(h);if(f>this._scrollPosition)return k})||0}return this._firstVisibleIndexVal},get lastVisibleIndex(){if(null===this._lastVisibleIndexVal){var f=this._physicalTop;this._iterateItems(function(h,
k){if(f<this._scrollBottom)this._lastVisibleIndexVal=k;else return!0;f+=this._getPhysicalSizeIncrement(h)})}return this._lastVisibleIndexVal},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)},attached:function(){this.updateViewportBoundaries();this._render();this.listen(this,"iron-resize",
"_resizeHandler")},detached:function(){this._itemsRendered=!1;this.unlisten(this,"iron-resize","_resizeHandler")},updateViewportBoundaries:function(){this._scrollerPaddingTop=this.scrollTarget===this?0:parseInt(window.getComputedStyle(this)["padding-top"]||0,10);this._viewportHeight=this._scrollTargetHeight},_update:function(f,h){this._assignModels(f);this._updateMetrics(f);if(h)for(;h.length;)f=h.pop(),this._physicalTop-=this._getPhysicalSizeIncrement(f);this._positionItems();this._updateScrollerSize();
this._increasePoolIfNeeded()},_increasePoolIfNeeded:function(){if(0===this._viewportHeight)return!1;var f=this._physicalSizes.reduce(function(k,t){return k+(t||100)},0),h=f>this._viewportHeight;if(f>=this._optPhysicalSize&&h)return!1;f=Math.floor(this._physicalSize/this._viewportHeight);0===f?this._debounceTemplate(this._increasePool.bind(this,Math.round(.5*this._physicalCount))):this._lastPage!==f&&h?Polymer.dom.addDebouncer(this.debounce("_debounceTemplate",this._increasePool.bind(this,this._itemsPerRow),
16)):this._debounceTemplate(this._increasePool.bind(this,Math.ceil(this._viewportHeight/(this._physicalSize/this._physicalCount)*this._maxPages-this._physicalCount)||1));this._lastPage=f;return!0},_debounceTemplate:function(f){Polymer.dom.addDebouncer(this.debounce("_debounceTemplate",f))},_increasePool:function(f){var h=this._physicalCount;f=Math.min(this._physicalCount+f,this._virtualCount-this._virtualStart,Math.max(this.maxPhysicalCount,25))-h;0>=f||([].push.apply(this._physicalItems,this._createPool(f)),
[].push.apply(this._physicalSizes,Array(f)),this._physicalCount=h+f,this._update())},_render:function(){var f=0<this._virtualCount||0<this._physicalCount;this.isAttached&&!this._itemsRendered&&this._isVisible&&f&&(this._lastPage=0,this._update(),this._itemsRendered=!0)},_iterateItems:function(f,h){var k,t;if(2===arguments.length&&h)for(t=0;t<h.length;t++){var l=h[t];var p=this._computeVidx(l);if(null!=(k=f.call(this,l,p)))return k}else{l=this._physicalStart;for(p=this._virtualStart;l<this._physicalCount;l++,
p++)if(null!=(k=f.call(this,l,p)))return k;for(l=0;l<this._physicalStart;l++,p++)if(null!=(k=f.call(this,l,p)))return k}},_computeVidx:function(f){return f>=this._physicalStart?this._virtualStart+(f-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+f},_updateMetrics:function(f){this.scrolling&&Polymer.dom.flush();var h=0,k=0,t=this._physicalAverageCount,l=this._physicalAverage;this._iterateItems(function(p){k+=this._physicalSizes[p]||0;this._physicalSizes[p]=this._physicalItems[p].offsetHeight;
h+=this._physicalSizes[p];this._physicalAverageCount+=this._physicalSizes[p]?1:0},f);this._viewportHeight=this._scrollTargetHeight;this._physicalSize=this._physicalSize+h-k;this._physicalAverageCount!==t&&(this._physicalAverage=Math.round((l*t+h)/this._physicalAverageCount))},_positionItems:function(){this._adjustScrollPosition();var f=this._physicalTop;this._iterateItems(function(h){this._physicalItems[h].style.transform=this._getTranslate(0,f);f+=this._physicalSizes[h]})},_getPhysicalSizeIncrement:function(f){return this._physicalSizes[f]},
_shouldRenderNextRow:function(f){return f%this._itemsPerRow===this._itemsPerRow-1},_adjustScrollPosition:function(){var f=0===this._virtualStart?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);f&&(this._physicalTop-=f,d||0===this._physicalTop||this._resetScrollPosition(this._scrollTop-f))},_resetScrollPosition:function(f){this.scrollTarget&&(this._scrollPosition=this._scrollTop=f)},_updateScrollerSize:function(f){this._estScrollHeight=this._physicalBottom+Math.max(this._virtualCount-
this._physicalCount-this._virtualStart,0)*this._physicalAverage;if((f=(f=f||0===this._scrollHeight)||this._scrollPosition>=this._estScrollHeight-this._physicalSize)||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._optPhysicalSize)this.$.items.style.height=this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight},scrollToIndex:function(f){Polymer.dom.flush();f=Math.min(Math.max(f,0),this._virtualCount-1);if(!this._isIndexRendered(f)||f>=this._maxVirtualStart)this._virtualStart=
f-1;this._assignModels();this._updateMetrics();this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage;for(var h=this._physicalStart,k=this._virtualStart,t=0,l=this._hiddenContentSize;k<f&&t<=l;)t+=this._getPhysicalSizeIncrement(h),h=(h+1)%this._physicalCount,k++;this._updateScrollerSize(!0);this._positionItems();this._resetScrollPosition(this._physicalTop+this._scrollerPaddingTop+t);this._increasePoolIfNeeded();this._lastVisibleIndexVal=this._firstVisibleIndexVal=
null},_resetAverage:function(){this._physicalAverageCount=this._physicalAverage=0},_resizeHandler:function(){Polymer.dom.addDebouncer(this.debounce("_debounceTemplate",function(){this.updateViewportBoundaries();this._render();this._itemsRendered&&this._physicalItems&&this._isVisible&&(this._resetAverage(),this.scrollToIndex(this.firstVisibleIndex))}.bind(this),1))},updateSizeForItem:function(f){f=this._physicalIndexForKey[f];null!=f&&(this._updateMetrics([f]),this._positionItems())},_isIndexRendered:function(f){return f>=
this._virtualStart&&f<=this._virtualEnd},_isIndexVisible:function(f){return f>=this.firstVisibleIndex&&f<=this.lastVisibleIndex}}}();vaadin.elements.grid.IronListBehavior=[Polymer.Templatizer,Polymer.IronScrollTargetBehavior,vaadin.elements.grid.IronListBehaviorImpl];

//# sourceURL=build://vaadin-grid/vaadin-grid-table.html.js
Polymer({is:"vaadin-grid-table",behaviors:[vaadin.elements.grid.IronListBehavior,vaadin.elements.grid.TableScrollBehavior,vaadin.elements.grid.TableColumnReorderingBehavior,Polymer.Templatizer],properties:{size:Number,columnTree:Array,bindData:Function,rowDetailsTemplate:Object,columnReorderingAllowed:{type:Boolean,reflectToAttribute:!0},safari:{type:Boolean,value:/^((?!chrome|android).)*safari/i.test(navigator.userAgent)},scrollbarWidth:{type:Number,value:function(){var b=document.createElement("div");
b.style.width="100px";b.style.height="100px";b.style.overflow="scroll";b.style.position="absolute";b.style.top="-9999px";document.body.appendChild(b);var d=b.offsetWidth-b.clientWidth;document.body.removeChild(b);return d}},target:Object,hasData:Boolean},observers:["_columnTreeChanged(columnTree, _physicalItems, _physicalCountVal)","_sizeChanged(size, bindData, hasData)","_rowDetailsTemplateChanged(rowDetailsTemplate, _physicalItems, _physicalCountVal)"],listeners:{"property-changed":"_columnPropChanged",
animationend:"_onAnimationEnd","column-resizing":"_onColumnResize"},ready:function(){this.$=this.$||{};this.$.header=this.domHost.$.header;this.$.items=this.domHost.$.items;this.$.footer=this.domHost.$.footer},_onColumnResize:function(){this.toggleAttribute("column-resizing",this.$.header.querySelector("[column-resizing]"));this._gridResizeHandler()},_onAnimationEnd:function(b){/appear/.test(b.animationName)&&(this._render(),this._updateHeaderFooterMetrics(),b.stopPropagation())},_columnPropChanged:function(b){"headerTemplate"===
b.detail.path&&this.toggleAttribute("has-templates",!0,this.$.header);"footerTemplate"===b.detail.path&&this.toggleAttribute("has-templates",!0,this.$.footer);/frozen|hidden/.test(b.detail.path)&&this._frozenCellsChanged();"hidden"===b.detail.path&&this._gridResizeHandler()},_hideOuterScroller:function(b,d){return 0===b&&!d},_hideTableOverflow:function(b,d){return 0===b&&d},_rowDetailsTemplateChanged:function(b,d,f){void 0!==b&&d&&void 0!==f&&Array.prototype.forEach.call(d,function(h){h.rowDetailsTemplate=
b})},_columnTreeChanged:function(b,d,f){void 0!==b&&d&&void 0!==f&&(Polymer.RenderStatus.afterNextRender(this,this._update),this._frozenCellsChanged(),this._hasTemplatesChanged(b),Array.prototype.forEach.call(d,function(h){h.columns=b[b.length-1]}),this._gridResizeHandler(),Polymer.dom.flush(this),this._updateLastColumn())},_updateLastColumn:function(){Array.prototype.forEach.call(Polymer.dom(this.domHost.root).querySelectorAll(".vaadin-grid-row"),function(b){b.updateLastColumn()})},_updateHeaderFooterMetrics:function(){this._physicalSizes&&
Polymer.dom.flush();this._updateHeaderFooterMetricsSync();Polymer.RenderStatus.afterNextRender(this.$.header,function(){this._updateHeaderFooterMetricsSync();this._pendingScrollToScaledIndex&&this.scrollToScaledIndex(this._pendingScrollToScaledIndex)}.bind(this))},_updateHeaderFooterMetricsSync:function(){var b=this.$.header.clientHeight+"px",d=this.$.footer.clientHeight+"px";[this.$.outersizer,this.$.fixedsizer,this.$.items].forEach(function(f){f.style.borderTopWidth=b;f.style.borderBottomWidth=
d})},_hasTemplatesChanged:function(b){var d=!1,f=!1;b.forEach(function(h){return h.forEach(function(k){d=d||k.headerTemplate;f=f||k.footerTemplate})});this.toggleAttribute("has-templates",d,this.$.header);this.toggleAttribute("has-templates",f,this.$.footer)},_createPool:function(b){for(var d=Array(b),f=0;f<b;f++){var h=document.createElement("vaadin-grid-table-row");h.target=this.domHost;d[f]=h;h.setAttribute("hidden","");Polymer.dom(this.$.items).appendChild(h)}return d},_sizeChanged:function(b,
d,f){if(void 0!==b&&void 0!==d&&void 0!==f){var h=this._scrollTop,k=this.firstVisibleIndex+this._vidxOffset;this._virtualCount=Math.min(b,1E5);this._physicalIndexForKey={};this._lastVisibleIndexVal=this._firstVisibleIndexVal=null;this._vidxOffset=0;this._physicalItems||(this._physicalCount=Math.max(1,Math.min(25,this._virtualCount)),this._physicalItems=this._createPool(this._physicalCount),this._physicalSizes=Array(this._physicalCount));this._itemsRendered=!1;this._debounceTemplate(function(){this._render();
this._viewportHeight&&(this.scrollToScaledIndex(Math.min(k,this.size)),this._scrollTop=h,this._scrollHandler(),this.flushDebouncer("vaadin-grid-scrolling"))})}},_assignModels:function(b){this._virtualIndexToItem=this._virtualIndexToItem||{};this._iterateItems(function(d,f){d=this._physicalItems[d];d.index&&delete this._virtualIndexToItem[d.index];d.index=f+this._vidxOffset;this._virtualIndexToItem[d.index]=d;d.toggleAttribute("odd",d.index%2);d.toggleAttribute("lastrow",d.index===this.size-1);d.toggleAttribute("hidden",
d.index>=this.size);this.bindData(d.index,d)},b)},_gridResizeHandler:function(){this._updateHeaderFooterMetrics();this._physicalSizes&&(this._physicalItems.forEach(function(b){b.updateRowDetailsCellMetrics()}),this.debounce("vaadin-grid-resizing",function(){this._update()}.bind(this),1))}});

//# sourceURL=build://vaadin-grid/vaadin-grid-column.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.ColumnBaseBehavior={properties:{resizable:{type:Boolean,value:function(){if("vaadin-grid-column-group"!==this.localName){var b=Polymer.dom(this).parentNode;return b&&"vaadin-grid-column-group"===b.localName?b.resizable||!1:!1}}},headerTemplate:{type:Object},footerTemplate:{type:Object},frozen:{type:Boolean,notify:!0,value:!1},hidden:{type:Boolean,notify:!0},_lastFrozen:{type:Boolean,notify:!0,value:!1},_order:Number,_reorderStatus:Boolean},observers:["_footerTemplateChanged(footerTemplate)",
"_headerTemplateChanged(headerTemplate)","_lastFrozenChanged(_lastFrozen)"],created:function(){function b(d){0<=d.addedNodes.length&&(this.headerTemplate=this._prepareHeaderTemplate(),this.footerTemplate=this._prepareFooterTemplate(),this.template=this._prepareBodyTemplate())}this._templateObserver=Polymer.Element?new Polymer.FlattenedNodesObserver(this,b):Polymer.dom(this).observeNodes(b)},_prepareHeaderTemplate:function(){return this._prepareTemplatizer(this._findTemplate("template.header")||null,
{})},_prepareFooterTemplate:function(){return this._prepareTemplatizer(this._findTemplate("template.footer")||null,{})},_prepareBodyTemplate:function(){return this._prepareTemplatizer(this._findTemplate("template:not(.header):not(.footer)",{}))},_prepareTemplatizer:function(b,d){if(b&&!b.templatizer){var f=new vaadin.elements.grid.Templatizer;f.dataHost=this.dataHost;f._instanceProps=d||f._instanceProps;f.template=b;b.templatizer=f}return b},_selectFirstTemplate:function(b){return Array.prototype.filter.call(Polymer.dom(this).querySelectorAll(b),
function(d){return Polymer.dom(d).parentNode===this}.bind(this))[0]},_findTemplate:function(b){(b=this._selectFirstTemplate(b))&&this.dataHost&&(b._rootDataHost=this.dataHost._rootDataHost||this.dataHost);return b},_headerTemplateChanged:function(b){this.fire("property-changed",{path:"headerTemplate",value:b})},_footerTemplateChanged:function(b){this.fire("property-changed",{path:"footerTemplate",value:b})},_flexGrowChanged:function(b){this.fire("property-changed",{path:"flexGrow",value:b})},_widthChanged:function(b){this.fire("property-changed",
{path:"width",value:b})},_lastFrozenChanged:function(b){this.fire("property-changed",{path:"lastFrozen",value:b})}};
vaadin.elements.grid.ColumnBehaviorImpl={properties:{width:{type:String,value:"100px"},flexGrow:{type:Number,value:1},template:{type:Object}},observers:"_flexGrowChanged(flexGrow);_widthChanged(width);_templateChanged(template);_frozenChanged(frozen, isAttached);_hiddenChanged(hidden);_orderChanged(_order);_reorderStatusChanged(_reorderStatus);_resizableChanged(resizable)".split(";"),_frozenChanged:function(b,d){void 0!==b&&void 0!==d&&(void 0===this._oldFrozen&&!1===b||this.fire("property-changed",
{path:"frozen",value:b}),this._oldFrozen=b)},_templateChanged:function(b){b&&b.templatizer&&Polymer.dom(this.root).appendChild(b.templatizer);this.fire("property-changed",{path:"template",value:b},{bubbles:!1})},_hiddenChanged:function(b){this.fire("property-changed",{path:"hidden",value:b})},_orderChanged:function(b){this.fire("property-changed",{path:"order",value:b})},_reorderStatusChanged:function(b){this.fire("property-changed",{path:"reorderStatus",value:b})},_resizableChanged:function(b){this.fire("property-changed",
{path:"resizable",value:b})}};vaadin.elements.grid.ColumnBehavior=[vaadin.elements.grid.ColumnBaseBehavior,vaadin.elements.grid.ColumnBehaviorImpl];

//# sourceURL=build://vaadin-grid/vaadin-grid-column.html-2.js
Polymer({is:"vaadin-grid-column",behaviors:[vaadin.elements.grid.ColumnBehavior]});

//# sourceURL=build://vaadin-grid/vaadin-grid-array-data-provider-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.ArrayDataProviderBehavior={properties:{items:Array},observers:["_itemsChanged(items, items.*)"],_itemsChanged:function(b,d){void 0!==b&&void 0!==d&&(this.size=(b||[]).length,this.dataProvider=this.dataProvider||this._arrayDataProvider,this.clearCache())},_arrayDataProvider:function(b,d){var f=(this.items||[]).slice(0);this._checkPaths(this._filters,"filtering",f)&&(f=this._filter(f));this.size=f.length;b.sortOrders.length&&this._checkPaths(this._sorters,"sorting",f)&&(f=f.sort(this._multiSort.bind(this)));
var h=b.page*b.pageSize;d(f.slice(h,h+b.pageSize),f.length)},_checkPaths:function(b,d,f){if(!f.length)return!1;var h=!0,k;for(k in b){var t=b[k].path;if(t&&-1!==t.indexOf(".")){var l=t.replace(/\.[^\.]*$/,"");void 0===Polymer.Base.get(l,f[0])&&(console.warn('Path "'+t+'" used for '+d+" does not exist in all of the items, "+d+" is disabled."),h=!1)}}return h},_multiSort:function(b,d){return this._sorters.map(function(f){return"asc"===f.direction?this._compare(Polymer.Base.get(f.path,b),Polymer.Base.get(f.path,
d)):"desc"===f.direction?this._compare(Polymer.Base.get(f.path,d),Polymer.Base.get(f.path,b)):0},this).reduce(function(f,h){return f?f:h},0)},_normalizeEmptyValue:function(b){return 0<=[void 0,null].indexOf(b)?"":isNaN(b)?b.toString():b},_compare:function(b,d){b=this._normalizeEmptyValue(b);d=this._normalizeEmptyValue(d);return b<d?-1:b>d?1:0},_filter:function(b){return b.filter(function(d){return 0===this._filters.filter(function(f){return-1===this._normalizeEmptyValue(Polymer.Base.get(f.path,d)).toString().toLowerCase().indexOf(f.value.toString().toLowerCase())}.bind(this)).length},
this)}};

//# sourceURL=build://vaadin-grid/vaadin-grid-dynamic-columns-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.DynamicColumnsBehavior={ready:function(){this._addNodeObserver()},_hasColumnGroups:function(b){for(var d=0;d<b.length;d++)if("vaadin-grid-column-group"===b[d].localName)return!0;return!1},_getChildColumns:function(b){return Polymer.dom(b).queryDistributedElements("vaadin-grid-column, vaadin-grid-column-group, vaadin-grid-selection-column")},_flattenColumnGroups:function(b){return b.map(function(d){return"vaadin-grid-column-group"===d.localName?this._getChildColumns(d):[d]},this).reduce(function(d,
f){return d.concat(f)},[])},_getColumnTree:function(){for(var b=[],d=this.queryAllEffectiveChildren("vaadin-grid-column, vaadin-grid-column-group, vaadin-grid-selection-column");;){b.push(d);if(!this._hasColumnGroups(d))break;d=this._flattenColumnGroups(d)}return b},_updateColumnTree:function(){var b=this._getColumnTree();this._arrayEquals(b,this._columnTree)||(this._columnTree=b)},_addNodeObserver:function(){this._observer=Polymer.dom(this).observeNodes(function(b){function d(f){return f.nodeType===
Node.ELEMENT_NODE&&/^vaadin-grid-(column|selection)/i.test(f.localName)}(0<b.addedNodes.filter(d).length||0<b.removedNodes.filter(d).length)&&this._updateColumnTree();(Polymer.Settings.useNativeShadow||Polymer.Settings.useShadow)&&Polymer.dom(this).appendChild(this.$.footerFocusTrap);this.debounce("check-imports",this._checkImports,2E3)}.bind(this))},_arrayEquals:function(b,d){if(!b||!d||b.length!=d.length)return!1;for(var f=0,h=b.length;f<h;f++)if(b[f]instanceof Array&&d[f]instanceof Array){if(!this._arrayEquals(b[f],
d[f]))return!1}else if(b[f]!=d[f])return!1;return!0},_checkImports:function(){["vaadin-grid-column-group","vaadin-grid-sorter","vaadin-grid-filter","vaadin-grid-selection-column"].forEach(function(b){var d=Polymer.dom(this).querySelector(b);!d||(Polymer.isInstance?Polymer.isInstance(d):d instanceof Polymer.Element)||console.warn("Make sure you have imported the required module for \x3c"+b+"\x3e element.")},this)}};

//# sourceURL=build://vaadin-grid/vaadin-grid-sort-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.SortBehavior={properties:{multiSort:{type:Boolean,value:!1},_sorters:{type:Array,value:function(){return[]}},_previousSorters:{type:Array,value:function(){return[]}}},listeners:{"sorter-changed":"_onSorterChanged"},ready:function(){Polymer.Element&&!Polymer.Settings.useNativeShadow&&this.async(function(){var b=Polymer.dom(this).querySelectorAll("vaadin-grid-sorter");Array.prototype.forEach.call(b,function(d){d.fire&&d.fire("sorter-changed")})})},_onSorterChanged:function(b){var d=
b.target;this._removeArrayItem(this._sorters,d);d._order=null;this.multiSort?(d.direction&&this._sorters.unshift(d),this._sorters.forEach(function(f,h){f._order=1<this._sorters.length?h:null},this)):(this._sorters.forEach(function(f){f._order=null;f.direction=null}),d.direction&&(this._sorters=[d]));b.stopPropagation();this.dataProvider&&JSON.stringify(this._previousSorters)!==JSON.stringify(this._mapSorters())&&this.clearCache();this._previousSorters=this._mapSorters()},_mapSorters:function(){return this._sorters.map(function(b){return{path:b.path,
direction:b.direction}})},_removeArrayItem:function(b,d){d=b.indexOf(d);-1<d&&b.splice(d,1)}};

//# sourceURL=build://vaadin-grid/vaadin-grid-filter-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};vaadin.elements.grid.FilterBehavior={properties:{_filters:{type:Array,value:function(){return[]}}},listeners:{"filter-changed":"_filterChanged"},_filterChanged:function(b){-1===this._filters.indexOf(b.target)&&this._filters.push(b.target);b.stopPropagation();this.dataProvider&&this.clearCache()},_mapFilters:function(){return this._filters.map(function(b){return{path:b.path,value:b.value}})}};

//# sourceURL=build://vaadin-grid/vaadin-grid.html.js
Polymer({is:"vaadin-grid",properties:{_columnTree:{type:Array,notify:!0},size:Number,_rowDetailsTemplate:Object,_bindData:{type:Object,value:function(){return this._getItem.bind(this)}}},behaviors:[Polymer.IronA11yKeysBehavior,Polymer.IronResizableBehavior,vaadin.elements.grid.ActiveItemBehavior,vaadin.elements.grid.RowDetailsBehavior,vaadin.elements.grid.DataProviderBehavior,vaadin.elements.grid.DynamicColumnsBehavior,vaadin.elements.grid.ArrayDataProviderBehavior,vaadin.elements.grid.SelectionBehavior,
vaadin.elements.grid.SortBehavior,vaadin.elements.grid.FilterBehavior,vaadin.elements.grid.ColumnReorderingBehavior,vaadin.elements.grid.TableKeyboardBehavior],listeners:{"property-changed":"_columnPropChanged","iron-resize":"_gridResizeHandler"},_updateItem:function(b,d){b.style.minHeight=d?"":this.$.scroller._physicalAverage+"px";b.item=d;b.selected=this._isSelected(d);b.expanded=this._isExpanded(d);b.active=null!==d&&d==this.activeItem;b.focused=b.index===this.$.items._focusedRowIndex},_getContentTarget:function(){return this},
ready:function(){this._updateColumnTree();this._rowDetailsTemplate=Polymer.dom(this).querySelector("template.row-details")||void 0;this.$.scroller.target=this;null===document.doctype&&console.warn('\x3cvaadin-grid\x3e requires the "standards mode" declaration. Please add \x3c!DOCTYPE html\x3e to the HTML document.')},_columnPropChanged:function(b){"_childColumns"===b.detail.path&&this._updateColumnTree();b.stopPropagation()},_gridResizeHandler:function(){this.$.scroller._gridResizeHandler()}});

//# sourceURL=build://tf-hparams-session-group-details/tf-hparams-session-group-details.html.js
Polymer({is:"tf-hparams-session-group-details",properties:{backend:Object,experimentName:String,visibleSchema:Object,sessionGroup:Object,_xType:{type:String,value:rg.XType.STEP},_noMultiExperiments:{type:Boolean,value:!1},_indexOfSession:Object,_sessionGroupNameHash:Number,_requestData:{type:Function,value:function(){return({tag:b,run:d})=>this.backend.listMetricEvals({experimentName:this.experimentName,sessionName:d,metricName:b})}},_colorScale:{type:Object,value:function(){return{scale:b=>{b=JSON.parse(b)[1];
b=this._indexOfSession.get(b);const d=pf.standard;return d[(this._sessionGroupNameHash+b)%d.length]}}}}},behaviors:[Polymer.IronResizableBehavior],listeners:{"iron-resize":"redraw"},observers:["_sessionGroupChanged(sessionGroup.*)"],redraw(){Polymer.dom(this.root).querySelectorAll("tf-scalar-card").forEach(b=>b.redraw())},_sessionGroupChanged(){this.sessionGroup?(this._indexOfSession=new Map(this.sessionGroup.sessions.map((b,d)=>[b.name,d])),this._sessionGroupNameHash=tf.hparams.utils.hashOfString(this.sessionGroup.name)):
(this._indexOfSession=new Map,this._sessionGroupNameHash=0);Polymer.dom(this.root).querySelectorAll("tf-scalar-card").forEach(b=>{const d=b.get("tag");b.set("tag","");b.set("tag",d)})},_haveMetrics(){return this.visibleSchema&&Array.isArray(this.visibleSchema.metricInfos)&&0<this.visibleSchema.metricInfos.length},_haveMetricsAndSessionGroup(){return this.sessionGroup&&this._haveMetrics()},_computeSeriesForSessionGroupMetric(b,d){return null===b||null===d?[]:b.sessions.filter(f=>void 0!==tf.hparams.utils.metricValueByName(f.metricValues,
d.name)).map(f=>({tag:d.name,run:f.name}))},_computeTagMetadata(b){return{displayName:tf.hparams.utils.metricName(b),description:b.description||""}}});

//# sourceURL=build://tf-hparams-table-view/tf-hparams-table-view.html.js
Polymer({is:"tf-hparams-table-view",properties:{visibleSchema:Object,sessionGroups:Array,enableShowMetrics:Boolean,backend:Object,experimentName:String},observers:["_visibleSchemaOrSessionGroupsChanged(visibleSchema.*, sessionGroups.*)"],_visibleSchemaOrSessionGroupsChanged(){const b=this.$.sessionGroupsTable.get("expandedItems");this.$.sessionGroupsTable.set("expandedItems",[]);Polymer.dom.flush();const d=new Map;this.sessionGroups.forEach(f=>{d.set(f.name,f)});this.$.sessionGroupsTable.set("expandedItems",
b.map(f=>d.get(f.name)).filter(Boolean))},_hparamName:tf.hparams.utils.hparamName,_metricName:tf.hparams.utils.metricName,_sessionGroupHParam(b,d){return null!=b&&Object.prototype.hasOwnProperty.call(b.hparams,d)?tf.hparams.utils.prettyPrint(b.hparams[d]):""},_sessionGroupMetric(b,d){if(null==b)return null;for(let f=0;f<b.metricValues.length;++f){let h=b.metricValues[f];if(h.name.group===d.group&&h.name.tag==d.tag)return tf.hparams.utils.prettyPrint(h.value)}return""},_rowNumber(b){return b+1}});

//# sourceURL=build://tf-hparams-session-group-values/tf-hparams-session-group-values.html.js
Polymer({is:"tf-hparams-session-group-values",properties:{sessionGroup:{type:Object,value:null},visibleSchema:{type:Object,value:null}},_propertiesArePopulated:function(b,d){return void 0!==b&&null!==b&&void 0!==d&&null!==d},_singletonSessionGroups:function(b){return null===b||void 0===b?[]:[b]}});

//# sourceURL=build://tf-hparams-parallel-coords-plot/utils.html.js
(function(b){(function(d){(function(f){function h(k,t,l){function p(){if(0===k.length)return[1,2];const [m,n]=d3.extent(k);return m!==n?[m,n]:0<m?[.5*m,1.5*m]:0>m?[1.5*m,.5*m]:[-1,1]}if("LINEAR"===l)return d3.scaleLinear().domain(p()).range([t,0]);if("LOG"===l)return l=p(),0>=l[0]&&0<=l[1]?h(k,t,"LINEAR"):d3.scaleLog().domain(l).range([t,0]);if("QUANTILE"===l)return l=d3.range(20).map(m=>t-m*t/19),0===k.length&&(k=[1]),d3.scaleQuantile().domain(_.uniq(k)).range(l);if("NON_NUMERIC"===l)return d3.scalePoint().domain(_.uniq(k.sort())).range([t,
0]).padding(.1);throw RangeError("Unknown scale: "+l);}f.findClosestPath=function(k,t,l){function p(y,w,C,G){const D=y-C,B=w-G;C=m-C;G=n-G;const I=(D*C+B*G)/(D*D+B*B);return 0>=I?b.hparams.utils.l2NormSquared(C,G):1<=I?b.hparams.utils.l2NormSquared(y-m,w-n):b.hparams.utils.l2NormSquared(C-I*D,G-I*B)}if(2>t.length)return console.error("Less than two axes in parallel coordinates plot."),null;const m=l[0],n=l[1];if(m<=t[0]||m>=t[t.length-1])return null;const q=_.sortedIndex(t,m);console.assert(0<q);
console.assert(q<t.length);const u=q-1;let x=null,A=null;k.forEach(y=>{const w=p(y.controlPoints[u][0],y.controlPoints[u][1],y.controlPoints[q][0],y.controlPoints[q][1]);100<w||!(null===x||w<x)||(x=w,A=y)});return A};f.pointScaleInverseImage=function(k,t,l){return k.domain().filter(p=>{p=k(p);return t<=p&&p<=l})};f.quantileScaleInverseImage=function(k,t,l){const p=k.range(),m=p.filter(n=>t<=n&&n<=l).map(n=>{const q=k.invertExtent(n);return n===p[p.length-1]?[q[0],q[1]+1]:q});return 0==m.length?[0,
0]:d3.extent(d3.merge(m))};f.continuousScaleInverseImage=function(k,t,l){return[k.invert(t),k.invert(l)].sort((p,m)=>p-m)};f.createAxisScale=h})(d.parallel_coords_plot||(d.parallel_coords_plot={}))})(b.hparams||(b.hparams={}))})(tf||(tf={}));

//# sourceURL=build://tf-hparams-parallel-coords-plot/axes.js
(function(b){(function(d){(function(f){function h(q){return null!==q.sourceEvent}let k;(function(q){q.LINEAR="LINEAR";q.LOG="LOG";q.QUANTILE="QUANTILE";q.NON_NUMERIC="NON_NUMERIC"})(k=f.ScaleType||(f.ScaleType={}));class t{isPassing(){return!0}}class l{constructor(q,u,x,A){this._lower=q;this._upper=u;this._lowerOpen=x;this._upperOpen=A}isPassing(q){return this._before(this._lower,q,!this._lowerOpen)&&this._before(q,this._upper,!this._upperOpen)}_before(q,u,x){return x?q<=u:q<u}}class p{constructor(q){this._domainSet=
q}isPassing(q){return-1!==this._domainSet.findIndex(u=>u===q)}}class m{constructor(q,u,x,A){this._svgProps=q;this._schema=u;this._interactionManager=x;this._colIndex=A;this._isDisplayed=!1;this._scaleType=this._yScale=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(q){this._brushSelection=q;this._brushFilter=this._buildBrushFilter(this.brushSelection(),
this.scaleType(),this.yScale())}setDomainAndScale(q,u){this._scaleType=u;this._yScale=b.hparams.parallel_coords_plot.createAxisScale(q.slice(),this._svgProps.height,this.scaleType());this._brushFilter=this._buildBrushFilter(this.brushSelection(),this.scaleType(),this.yScale())}brushFilter(){return this._brushFilter}updateDOM(q){var u=d3.axisLeft(this.yScale());this.scaleType()===k.QUANTILE&&(u=u.tickValues(this.yScale().quantiles()).tickFormat(d3.format("-.6g")));var x=d3.select(q);x.selectAll("g").remove();
x.append("g").classed("axis",!0).call(u).append("text").classed("axis-title",!0).style("cursor","move").style("text-anchor","middle").attr("y",-9).text(A=>b.hparams.utils.schemaColumnName(this._schema,A));x.call(d3.drag().on("start",()=>{q.setAttribute("is-dragging","");this._interactionManager.onDragStart(this.colIndex())}).on("drag",()=>this._interactionManager.onDrag(d3.event.x)).on("end",()=>{this._interactionManager.onDragEnd();q.removeAttribute("is-dragging")}));u=d3.brushY().extent([[-8,0],
[8,this._svgProps.height+1]]).on("start",()=>{h(d3.event)&&(q.setAttribute("is-brushing",""),this._interactionManager.onBrushChanged(this.colIndex()))}).on("brush",()=>{if(h(d3.event))this._interactionManager.onBrushChanged(this.colIndex())}).on("end",()=>{h(d3.event)&&(this._interactionManager.onBrushChanged(this.colIndex()),q.removeAttribute("is-brushing"))});x=d3.select(q).append("g").classed("brush",!0);x.call(u);u.move(x,this.brushSelection())}setDisplayed(q){this._isDisplayed=q}_buildBrushFilter(q,
u,x){if(null===q)return new t;if(null===u)return console.error("Scale type is null, but brushSelection isn't: ",q),new t;switch(u){case k.LINEAR:case k.LOG:{const [A,y]=b.hparams.parallel_coords_plot.continuousScaleInverseImage(x,q[0],q[1]);return new l(A,y,!1,!1)}case k.QUANTILE:{const [A,y]=b.hparams.parallel_coords_plot.quantileScaleInverseImage(x,q[0],q[1]);return new l(A,y,!1,!0)}case k.NON_NUMERIC:return new p(b.hparams.parallel_coords_plot.pointScaleInverseImage(x,q[0],q[1]))}console.error("Unknown scale type: ",
u);return new t}}f.Axis=m;class n{constructor(q,u,x){this._svgProps=q;this._schema=u;this._axes=this._createAxes(x);this._stationaryAxesPositions=d3.scalePoint().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(q,u){console.assert(!this.isAxisDragging());const x=new Set;q.columns.forEach(y=>{const w=y.absoluteIndex;let C=this._axes[w];C.setDisplayed(!0);
const G=u.map(D=>b.hparams.utils.columnValueByIndex(this._schema,D,w));C.setDomainAndScale(G,y.scale);x.add(w)});this._axes.forEach(y=>{x.has(y.colIndex())||y.setDisplayed(!1)});this._updateStationaryAxesPositions(x);this._parentsSel=this._parentsSel.data(Array.from(x),y=>y);this._parentsSel.exit().remove();this._parentsSel=this._parentsSel.enter().append("g").classed("axis-parent",!0).merge(this._parentsSel);const A=this;this._parentsSel.call(y=>this._updateAxesPositionsInDOM(y)).each(function(y){A._axes[y].updateDOM(this)})}mapVisibleAxes(q){return this._stationaryAxesPositions.domain().map(u=>
q(this.getAxisPosition(u),this._axes[u]))}allVisibleAxesSatisfy(q){return this._stationaryAxesPositions.domain().every(u=>q(this.getAxisPosition(u),this._axes[u]))}getAxisForColIndex(q){return this._axes[q]}dragStart(q){console.assert(!this.isAxisDragging());console.assert(this._axes[q].isDisplayed());this._draggedAxis=this._axes[q];this._draggedAxisPosition=this._stationaryAxesPositions(q)}drag(q){this._draggedAxisPosition=q=Math.min(Math.max(q,0),this._svgProps.width);q=this._stationaryAxesPositions.domain();
q.sort((u,x)=>this.getAxisPosition(u)-this.getAxisPosition(x));this._stationaryAxesPositions.domain(q);this._updateAxesPositionsInDOM(this._parentsSel)}dragEnd(){console.assert(this.isAxisDragging());this._draggedAxis=this._draggedAxisPosition=null;this._updateAxesPositionsInDOM(this._parentsSel.transition().duration(500))}isAxisDragging(){return null!==this._draggedAxis}getAxisPosition(q){return null!==this._draggedAxis&&this._draggedAxis.colIndex()===q?this._draggedAxisPosition:this._stationaryAxesPositions(q)}_updateStationaryAxesPositions(q){var u=
this._stationaryAxesPositions.domain().filter(x=>q.has(x));u=Array.from(new Set([...u,...Array.from(q)]));this._stationaryAxesPositions.domain(u)}_updateAxesPositionsInDOM(q){q.attr("transform",u=>b.hparams.utils.translateStr(this.getAxisPosition(u)))}_createAxes(q){return d3.range(b.hparams.utils.numColumns(this._schema)).map(u=>new m(this._svgProps,this._schema,q,u))}}f.AxesCollection=n})(d.parallel_coords_plot||(d.parallel_coords_plot={}))})(b.hparams||(b.hparams={}))})(tf||(tf={}));

//# sourceURL=build://tf-hparams-parallel-coords-plot/lines.js
(function(b){(function(d){(function(f){let h;(function(l){l[l.FOREGROUND=0]="FOREGROUND";l[l.BACKGROUND=1]="BACKGROUND"})(h=f.LineType||(f.LineType={}));class k{constructor(l){void 0===l&&(l=d3.selectAll(null));console.assert(1>=l.size());this._sessionGroupSel=l}sessionGroup(){return 1===this._sessionGroupSel.size()?this._sessionGroupSel.datum():null}isNull(){return null===this.sessionGroup()}selection(){return this._sessionGroupSel}equalsTo(l){return this.isNull()?l.isNull():l.isNull()?!1:l.sessionGroup().name==
this.sessionGroup().name}}f.SessionGroupHandle=k;class t{constructor(l,p,m){this._svgProps=l;this._schema=p;this._axesCollection=m;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 k;this._selectedSessionGroupHandle=new k;this._d3line=d3.line().curve(d3.curveLinear)}getSessionGroupHandle(l){return null===l||void 0===l?new k:new k(this._fgPathsSel.filter(p=>p.name===l.name))}hideBackgroundLines(){this._bgPathsSel.attr("visibility","hidden")}showBackgroundLines(){this._bgPathsSel.attr("visibility",null)}peakedSessionGroupHandle(){return this._peakedSessionGroupHandle}selectedSessionGroupHandle(){return this._selectedSessionGroupHandle}recomputeControlPoints(l,p=0){(l===h.FOREGROUND?
this._fgPathsSel:this._bgPathsSel).transition().duration(p).attr("d",m=>this._pathDAttribute(m));l===h.FOREGROUND&&window.setTimeout(()=>{const m=this;this._fgPathsSel.each(function(n){m._setControlPointsProperty(this,n)})})}recomputeForegroundLinesVisibility(){this._fgPathsSel.classed("invisible-path",l=>!this._axesCollection.allVisibleAxesSatisfy((p,m)=>m.brushFilter().isPassing(b.hparams.utils.columnValueByIndex(this._schema,l,m.colIndex()))));this._updateVisibleFgPathsSel()}setForegroundLinesColor(l,
p,m){l=this._createLineColorFunction(l,p,m);this._fgPathsSel.attr("stroke",l)}redraw(l,p,m,n){const q=this._peakedSessionGroupHandle.sessionGroup(),u=this._selectedSessionGroupHandle.sessionGroup();this._sessionGroups=l;this._fgPathsSel=this._recomputePathSelection(this._fgPathsSel);this._bgPathsSel=this._recomputePathSelection(this._bgPathsSel);this._peakedSessionGroupHandle=this.getSessionGroupHandle(q);this._selectedSessionGroupHandle=this.getSessionGroupHandle(u);this.recomputeControlPoints(h.FOREGROUND);
this.recomputeControlPoints(h.BACKGROUND);this.recomputeForegroundLinesVisibility();this.setForegroundLinesColor(p,m,n)}updatePeakedSessionGroup(l){this._peakedSessionGroupHandle.selection().classed("peaked-path",!1);this._peakedSessionGroupHandle=l;this._peakedSessionGroupHandle.selection().classed("peaked-path",!0)}clearPeakedSessionGroup(){this.updatePeakedSessionGroup(new k)}updateSelectedSessionGroup(l){this._selectedSessionGroupHandle.selection().classed("selected-path",!1);this._selectedSessionGroupHandle=
l;this._selectedSessionGroupHandle.selection().classed("selected-path",!0)}findClosestSessionGroup(l,p){const m=this._axesCollection.mapVisibleAxes(n=>n);l=b.hparams.parallel_coords_plot.findClosestPath(this._visibleFgPathsSel.nodes(),m,[l,p]);return null===l?new k:new k(d3.select(l))}_createLineColorFunction(l,p,m){if(null===l)return()=>"red";const n=d3.scaleLinear().domain(b.hparams.utils.numericColumnExtent(this._schema,this._sessionGroups,l)).range([p,m]).interpolate(d3.interpolateLab);return q=>
n(b.hparams.utils.columnValueByIndex(this._schema,q,l))}_recomputePathSelection(l){l=l.data(this._sessionGroups,p=>p.name);l.exit().remove();return l.enter().append("path").merge(l)}_setControlPointsProperty(l,p){l.controlPoints=this._computeControlPoints(p)}_computeControlPoints(l){return this._axesCollection.mapVisibleAxes((p,m)=>[p,m.yScale()(b.hparams.utils.columnValueByIndex(this._schema,l,m.colIndex()))])}_pathDAttribute(l){return this._d3line(this._computeControlPoints(l))}_updateVisibleFgPathsSel(){this._visibleFgPathsSel=
this._fgPathsSel.filter(":not(.invisible-path)")}}f.LinesCollection=t})(d.parallel_coords_plot||(d.parallel_coords_plot={}))})(b.hparams||(b.hparams={}))})(tf||(tf={}));

//# sourceURL=build://tf-hparams-parallel-coords-plot/interaction_manager.js
(function(b){(function(d){(function(f){class h{constructor(t,l){this.svg=d3.select(t);t=100*l+20;this.svg.attr("viewBox",`0 0 ${t} ${240}`);this.svg.attr("preserveAspectRatio","xMidYMid");this.svg.style("min-width",t+"px");this.svg.style("min-height","240px");this.width=t-10-10;this.height=200;this.svgG=this.svg.append("g").attr("transform",b.hparams.utils.translateStr(10,30))}}f.SVGProperties=h;class k{constructor(t,l,p,m){this._svgProps=t;this._schema=l;this._peakedSessionGroupChangedCB=p;this._selectedSessionGroupChangedCB=
m;this._axesCollection=new f.AxesCollection(t,l,this);this._linesCollection=new f.LinesCollection(t,l,this._axesCollection);this._svgProps.svg.on("click",()=>this.onClick()).on("mousemove mouseenter",()=>{const [n,q]=d3.mouse(this._svgProps.svgG.node());this.onMouseMoved(n,q)}).on("mouseleave",()=>this.onMouseLeave())}onDragStart(t){this._axesCollection.dragStart(t);this._linesCollection.hideBackgroundLines()}onDrag(t){this._axesCollection.drag(t);this._linesCollection.recomputeControlPoints(f.LineType.FOREGROUND)}onDragEnd(){this._axesCollection.dragEnd();
this._linesCollection.recomputeControlPoints(f.LineType.FOREGROUND,500);window.setTimeout(()=>{this._linesCollection.recomputeControlPoints(f.LineType.BACKGROUND);this._linesCollection.showBackgroundLines()},500)}onBrushChanged(t){this._axesCollection.getAxisForColIndex(t).setBrushSelection(d3.event.selection);this._linesCollection.recomputeForegroundLinesVisibility()}onMouseMoved(t,l){this._linesCollection.updatePeakedSessionGroup(this._linesCollection.findClosestSessionGroup(t,l));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 f.SessionGroupHandle):this._linesCollection.updateSelectedSessionGroup(this._linesCollection.peakedSessionGroupHandle());this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}onOptionsOrSessionGroupsChanged(t,
l){this._axesCollection.updateAxes(t,l);const p=this._linesCollection.peakedSessionGroupHandle(),m=this._linesCollection.selectedSessionGroupHandle();this._linesCollection.redraw(l,void 0!==t.colorByColumnIndex?t.columns[t.colorByColumnIndex].absoluteIndex:null,t.minColor,t.maxColor);p.equalsTo(this._linesCollection.peakedSessionGroupHandle())||this._peakedSessionGroupChangedCB(this._linesCollection.peakedSessionGroupHandle().sessionGroup());m.equalsTo(this._linesCollection.selectedSessionGroupHandle())||
this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}schema(){return this._schema}}f.InteractionManager=k})(d.parallel_coords_plot||(d.parallel_coords_plot={}))})(b.hparams||(b.hparams={}))})(tf||(tf={}));

//# sourceURL=build://tf-hparams-parallel-coords-plot/tf-hparams-parallel-coords-plot.html.js
Polymer({is:"tf-hparams-parallel-coords-plot",properties:{sessionGroups:Array,options:Object,selectedSessionGroup:{type:Object,value:null,readOnly:!0,notify:!0},closestSessionGroup:{type:Object,value:null,readOnly:!0,notify:!0},redrawCount:{type:Number,value:0},_validSessionGroups:Array,_interactionManager:Object},observers:["_optionsOrSessionGroupsChanged(options.*, sessionGroups.*)"],_optionsOrSessionGroupsChanged(){if(null!==this.options){var b=this.options.configuration;if(void 0===this._interactionManager||
!_.isEqual(this._interactionManager.schema(),b.schema)){d3.select(this.$.svg).selectAll("*").remove();const d=new tf.hparams.parallel_coords_plot.SVGProperties(this.$.svg,tf.hparams.utils.numColumns(b.schema));this.scopeSubtree(this.$.svg,!0);this._interactionManager=new tf.hparams.parallel_coords_plot.InteractionManager(d,b.schema,f=>this.closestSessionGroupChanged(f),f=>this.selectedSessionGroupChanged(f))}this._computeValidSessionGroups();this._interactionManager.onOptionsOrSessionGroupsChanged(this.options,
this._validSessionGroups);this.redrawCount++}},closestSessionGroupChanged(b){this._setClosestSessionGroup(b)},selectedSessionGroupChanged(b){this._setSelectedSessionGroup(b)},_computeValidSessionGroups(){const b=tf.hparams.utils;if(void 0===this.sessionGroups)this._validSessionGroups=void 0;else{var d=this.options.configuration.schema;this._validSessionGroups=this.sessionGroups.filter(f=>{for(let h=0;h<b.numColumns(d);++h)if(this.options.configuration.columnsVisibility[h]&&void 0===b.columnValueByIndex(d,
f,h))return!1;return!0})}}});

//# sourceURL=build://tf-hparams-parallel-coords-view/tf-hparams-parallel-coords-view.html.js
Polymer({is:"tf-hparams-parallel-coords-view",properties:{backend:Object,experimentName:String,configuration:Object,sessionGroups:Array},_closestOrSelected:function(b,d){return null!==b?b:d}});

//# sourceURL=build://tf-hparams-scatter-plot-matrix-plot/tf-hparams-scatter-plot-matrix-plot.html.js
Polymer({is:"tf-hparams-scatter-plot-matrix-plot",properties:{visibleSchema:Object,sessionGroups:Array,options:Object,selectedSessionGroup:{type:Object,value:null,readOnly:!0,notify:!0},closestSessionGroup:{type:Object,value:null,readOnly:!0,notify:!0},_container:{type:Object,value:null},_svg:{type:Object,value:null},width:{type:Number,value:0},height:{type:Number,value:0},_brushedCellIndex:{type:Object,value:null},_brushSelection:{type:Object,value:null}},observers:["_sessionGroupsChanged(sessionGroups.*)",
"_visibleSchemaChanged(visibleSchema.*)","_redraw(options.*)"],ready(){this._container=this.$.container;this._svg=d3.select(this.$.svg);this._redraw()},_sessionGroupsChanged(){null!==this.selectedSessionGroup&&this._setSelectedSessionGroup(tf.hparams.utils.sessionGroupWithName(this.sessionGroups,this.selectedSessionGroup.name)||null);this._redraw()},_visibleSchemaChanged(){this._brushSelection=this._brushedCellIndex=null;this._redraw()},_redraw(){this.debounce("_redraw",()=>{const b=tf.hparams.utils;
this.width=Math.max(150*b.numVisibleColumns(this.visibleSchema),1200);this.height=Math.max(112.5*b.numVisibleMetrics(this.visibleSchema),480);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(){function b(ka){return"x-axis-clip-path-"+ka}function d(ka){return"x-label-clip-path-"+ka}function f(ka){return"y-axis-clip-path-"+ka}function h(ka){return"y-label-clip-path-"+
ka}function k(ka,Y,Ea,va,xa){Ea=Math.floor(Ea/va);va=Y.scale();if("QUANTILE"===xa){let Aa=va.quantiles();Aa=d3.range(0,Aa.length,Math.ceil(Aa.length/Ea)).map(Fa=>Aa[Fa]);Y.tickValues(Aa).tickFormat(d3.format("-.2g"))}"LINEAR"!==xa&&"LOG"!==xa||Y.ticks(Ea);ka.call(Y);ka.selectAll(".domain").remove();ka.selectAll(".tick line").attr("stroke","#ddd")}function t(ka,Y){return O[Y](w._colValue(ka,Y))}function l(ka,Y){return H[Y](w._metricValue(ka,Y))}function p(ka,Y){const Ea=[];T[ka][Y].each(function(){Ea.push(this)});
return d3.quadtree().x(va=>d3.select(va).datum().x).y(va=>d3.select(va).datum().y).addAll(Ea)}function m(){let ka=new Set(Q.nodes());x()||(ka=n(w._brushedCellIndex,w._brushSelection));d3.selectAll(Array.from(y.filterSet(ka,Y=>!Z.has(Y)))).attr("fill",L);d3.selectAll(Array.from(y.filterSet(Z,Y=>!ka.has(Y)))).attr("fill","#ddd");Z=ka}function n(ka,Y){console.assert(null!==ka);console.assert(null!==Y);const [Ea,va]=ka,xa=new Set;y.quadTreeVisitPointsInRect(aa[Ea][va],Y[0][0],Y[0][1],Y[1][0],Y[1][1],
Aa=>{d3.select(Aa).datum().sessionGroupMarkers.forEach(Fa=>{xa.add(Fa)})});return xa}function q(ka){const Y=d3.brushSelection(ka);!u()&&null===Y||u()&&ka===la.node()&&_.isEqual(Y,w._brushSelection)||(w._brushSelection=Y,null!==Y?(la=d3.select(ka),w._brushedCellIndex=la.datum()):(la=null,w._brushedCellIndex=null),m())}function u(){return null!==w._brushedCellIndex&&null!==w._brushSelection}function x(){return!u()||w._brushSelection[0][0]===w._brushSelection[1][0]||w._brushSelection[0][1]===w._brushSelection[1][1]}
function A(ka,Y,Ea,va,xa){let Aa=Infinity,Fa=null;y.quadTreeVisitPointsInDisk(aa[ka][Y],Ea,va,xa,(ya,Sa)=>{Z.has(ya)&&Sa<Aa&&(ya=d3.select(ya).datum(),Aa=Sa,Fa=ya.sessionGroup)});return null===Fa?null:d3.selectAll(X.get(Fa))}const y=tf.hparams.utils,w=this;if(this.sessionGroups&&0!=this.sessionGroups.length&&this.visibleSchema&&0!=this.visibleSchema.metricInfos.length){var C=d3.range(y.numVisibleColumns(w.visibleSchema)),G=d3.range(y.numVisibleMetrics(w.visibleSchema)),D=d3.scaleBand().domain(C).range([85,
this.width-1-5]).paddingInner(.1),B=d3.scaleBand().domain(G).range([this.height-1-5-50,5]).paddingInner(.1),I=D.bandwidth(),N=B.bandwidth(),O=C.map(ka=>w._cellScale(ka,[0,I-1])),H=G.map(ka=>w._cellScale(ka+y.numVisibleHParams(w.visibleSchema),[N-1,0])),K=this._svg.selectAll(".x-axis").data(C).enter().append("g").classed("x-axis",!0).attr("transform",ka=>y.translateStr(D(ka),0));K.append("clipPath").attr("id",b).append("rect").attr("x",-5).attr("y",0).attr("width",I+10).attr("height",w.height-25);
K.append("clipPath").attr("id",d).append("rect").attr("x",0).attr("y",w.height-25).attr("width",I).attr("height",25);K.append("g").attr("clip-path",ka=>"url(#"+b(ka)+")").each(function(ka){d3.select(this).call(k,d3.axisBottom(O[ka]).tickSize(w.height-50),I,40,w.options.columns[ka].scale)});K.append("g").classed("x-axis-label",!0).attr("clip-path",ka=>"url(#"+d(ka)+")").append("text").attr("text-anchor","middle").attr("x",I/2).attr("y",w.height-1-12.5).text(ka=>y.schemaVisibleColumnName(w.visibleSchema,
ka)).append("title").text(ka=>y.schemaVisibleColumnName(w.visibleSchema,ka));K=this._svg.selectAll(".y-axis").data(G).enter().append("g").classed("y-axis",!0).attr("transform",ka=>y.translateStr(w.width-1,B(ka)));K.append("clipPath").attr("id",f).append("rect").attr("x",-(w.width-40-1)).attr("y",-5).attr("width",w.width-40).attr("height",N+10);K.append("clipPath").attr("id",h).append("rect").attr("x",-(w.width-1)).attr("y",0).attr("width",40).attr("height",N);K.append("g").attr("clip-path",ka=>"url(#"+
f(ka)+")").each(function(ka){d3.select(this).call(k,d3.axisLeft(H[ka]).tickSize(w.width-80),N,20,w.options.columns[ka+y.numVisibleHParams(w.visibleSchema)].scale)});K.append("g").classed("y-axis-label",!0).attr("clip-path",ka=>"url(#"+h(ka)+")").append("text").attr("text-anchor","middle").attr("x",-(w.width-20-1)).attr("y",N/2).attr("transform",y.rotateStr(-(w.width-20-1),N/2)).text(ka=>y.metricName(w.visibleSchema.metricInfos[ka])).append("title").text(ka=>y.metricName(w.visibleSchema.metricInfos[ka]));
K=this._svg.selectAll(".cell").data(d3.cross(C,G)).enter().append("g").classed("cell",!0).attr("transform",([ka,Y])=>y.translateStr(D(ka),B(Y)));K.append("g").classed("frame",!0).append("rect").attr("x",-5).attr("y",-5).attr("width",I+10).attr("height",N+10).attr("stroke","#000").attr("fill","none").attr("shape-rendering","crispEdges");var M=null;void 0!==w.options.colorByColumnIndex&&(M=d3.scaleLinear().domain(this._colExtent(this.options.colorByColumnIndex)).range([this.options.minColor,this.options.maxColor]).interpolate(d3.interpolateLab));
var L=void 0===w.options.colorByColumnIndex?()=>"red":({sessionGroup:ka})=>M(this._colValue(ka,w.options.colorByColumnIndex)),[Q,T,X]=function(ka,Y){const Ea=ka.selectAll(".data-marker").data(([xa,Aa])=>w.sessionGroups.filter(Fa=>void 0!==w._colValue(Fa,xa)&&void 0!==w._metricValue(Fa,Aa)).map(Fa=>({col:xa,metric:Aa,sessionGroup:Fa,x:t(Fa,xa),y:l(Fa,Aa),sessionGroupMarkers:null}))).enter().append("circle").classed("data-marker",!0).attr("cx",({x:xa})=>xa).attr("cy",({y:xa})=>xa).attr("r",2).attr("fill",
Y),va=new Map;w.sessionGroups.forEach(xa=>{va.set(xa,[])});Ea.each(function(xa){va.get(xa.sessionGroup).push(this)});Ea.each(xa=>{const Aa=va.get(xa.sessionGroup);xa.sessionGroupMarkers=new Set(Aa)});ka=C.map(xa=>G.map(Aa=>Ea.filter(Fa=>Fa.col==xa&&Fa.metric==Aa)));return[Ea,ka,va]}(K.append("g"),L),aa=C.map(ka=>G.map(Y=>p(ka,Y))),la=null;u()&&(la=K.filter(ka=>_.isEqual(ka,w._brushedCellIndex)),console.assert(1==la.size(),la));var Z=new Set(Q.nodes());m();var ba=d3.brush().extent([[-4,-4],[I-1+5-
1,N-1+5-1]]).on("start",function(){u()&&la.node()!=this&&ba.move(la,null);q(this)}).on("brush",function(){q(this)}).on("end",function(){q(this)});K.call(ba);u()&&ba.move(la,w._brushSelection);var ea=null,ca=null;null!==this.selectedSessionGroup&&(ca=d3.selectAll(X.get(this.selectedSessionGroup)).classed("selected-marker",!0));K.on("click",function(){var ka=ea===ca?null:ea;ka!==ca&&(null!==ca&&ca.classed("selected-marker",!1),ca=ka,null!==ca&&ca.classed("selected-marker",!0),ka=null===ca?null:ca.datum().sessionGroup,
w._setSelectedSessionGroup(ka))}).on("mousemove mouseenter",function([ka,Y]){const [Ea,va]=d3.mouse(this);ka=A(ka,Y,Ea,va,20);ea!==ka&&(null!==ea&&ea.classed("closest-marker",!1),ea=ka,null!==ea?(ea.classed("closest-marker",!0),w._setClosestSessionGroup(ea.datum().sessionGroup)):w._setClosestSessionGroup(null))}).on("mouseleave",function(){null!==ea&&(ea.classed("closest-marker",!1),ea=null,w._setClosestSessionGroup(null))});this._svg.selectAll("*").classed("tf-hparams-scatter-plot-matrix-plot",!0)}},
_cellScale(b,d){var f=this._colExtent(b);const h=d3.scaleLinear().domain(f).range(d);if("LINEAR"===this.options.columns[b].scale)return h;if("LOG"===this.options.columns[b].scale)return 0>=f[0]&&0<=f[1]?h:d3.scaleLog().domain(f).range(d);if("QUANTILE"===this.options.columns[b].scale){const k=(d[1]-d[0])/19;f=d3.range(20).map(t=>d[0]+k*t);return d3.scaleQuantile().domain(_.uniq(this.sessionGroups.map(t=>this._colValue(t,b)))).range(f)}if("NON_NUMERIC"===this.options.columns[b].scale)return d3.scalePoint().domain(_.uniq(this.sessionGroups.map(k=>
this._colValue(k,b)).sort())).range(d).padding(.1);throw"Unknown scale for column: "+b+". options: "+this.options;},_colValue(b,d){return tf.hparams.utils.columnValueByVisibleIndex(this.visibleSchema,b,d)},_metricValue(b,d){return tf.hparams.utils.metricValueByVisibleIndex(this.visibleSchema,b,d)},_colExtent(b){return tf.hparams.utils.visibleNumericColumnExtent(this.visibleSchema,this.sessionGroups,b)}});

//# sourceURL=build://tf-hparams-scatter-plot-matrix-view/tf-hparams-scatter-plot-matrix-view.html.js
Polymer({is:"tf-hparams-scatter-plot-matrix-view",properties:{backend:Object,experimentName:String,configuration:Object,sessionGroups:Array},_closestOrSelected:function(b,d){return null!==b?b:d}});

//# sourceURL=build://tf-hparams-sessions-pane/tf-hparams-sessions-pane.html.js
Polymer({is:"tf-hparams-sessions-pane",properties:{backend:Object,helpUrl:String,bugReportUrl:String,experimentName:String,configuration:Object,sessionGroups:Array,_selectedTab:{type:Number,value:0}}});

//# sourceURL=build://tf-hparams-google-analytics-tracker/tf-hparams-google-analytics-tracker.html.js
(function(){Polymer({is:"tf-hparams-google-analytics-tracker",handleEvent:function(){}})})();

//# sourceURL=build://tf-hparams-main/tf-hparams-main.html.js
Polymer({is:"tf-hparams-main",properties:{backend:Object,experimentName:String,trackingId:String,helpUrl:String,bugReportUrl:String,_configuration:Object,_sessionGroups:Array,_throttledSendEventToGA:{type:Function,value:()=>_.throttle(function(){this._handleGAEvent({detail:{hitType:"event",eventCategory:"UserInteraction",eventLabel:"Experiment: "+this.experimentName}})},6E4,{leading:!0})}},listeners:{mousemove:"_sendEventToGA",tap:"_sendEventToGA","google-analytics-tracking":"_handleGAEvent"},attached(){this._handleGAEvent({detail:{hitType:"pageview"}})},
reload(){this.$["query-pane"].reload()},_sendEventToGA(){this._throttledSendEventToGA(this)},_handleGAEvent(b){this.$.tracker.handleEvent(b)}});

//# sourceURL=build://tf-hparams-backend/tf-hparams-backend.html.js
(function(b){(function(d){class f{constructor(h,k,t=!0){this._apiUrl=h;this._requestManager=k;this._useHttpGet=t}getExperiment(h){return this._sendRequest("experiment",h)}getDownloadUrl(h,k,t){return this._apiUrl+"/download_data?"+new URLSearchParams({format:h,columnsVisibility:JSON.stringify(t),request:JSON.stringify(k)})}listSessionGroups(h){return this._sendRequest("session_groups",h)}listMetricEvals(h){return this._sendRequest("metric_evals",h)}_sendRequest(h,k){if(this._useHttpGet)return k=encodeURIComponent(JSON.stringify(k)),
this._requestManager.request(this._apiUrl+"/"+h+"?request\x3d"+k);const t=new vc.RequestOptions;t.withCredentials=!0;t.methodType="POST";t.contentType="text/plain";t.body=JSON.stringify(k);return this._requestManager.requestWithOptions(this._apiUrl+"/"+h,t)}}d.Backend=f})(b.hparams||(b.hparams={}))})(tf||(tf={}));

//# sourceURL=build://tf-hparams-dashboard/tf-hparams-dashboard.html.js
(function(){Polymer({is:"tf-hparams-dashboard",properties:{_backend:{type:Object,value:()=>new tf.hparams.Backend(vc.getRouter().pluginRoute("hparams",""),new vc.RequestManager,!!(window.TENSORBOARD_ENV||{}).IN_COLAB)}},reload(){this.$["hparams-main"].reload()}})})();

//# sourceURL=build://tf-imports/three.js
(function(b,d){"object"===typeof exports&&"undefined"!==typeof module?d(exports):"function"===typeof define&&define.amd?define(["exports"],d):(b=b||self,d(b.THREE={}))})(this,function(b){function d(){}function f(a,c){this.x=a||0;this.y=c||0}function h(a,c,e,g){this._x=a||0;this._y=c||0;this._z=e||0;this._w=void 0!==g?g:1}function k(a,c,e){this.x=a||0;this.y=c||0;this.z=e||0}function t(){this.elements=[1,0,0,0,1,0,0,0,1];0<arguments.length&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}
function l(a,c,e,g,r,v,z,E,F,J){Object.defineProperty(this,"id",{value:Nk++});this.uuid=hb.generateUUID();this.name="";this.image=void 0!==a?a:l.DEFAULT_IMAGE;this.mipmaps=[];this.mapping=void 0!==c?c:l.DEFAULT_MAPPING;this.wrapS=void 0!==e?e:1001;this.wrapT=void 0!==g?g:1001;this.magFilter=void 0!==r?r:1006;this.minFilter=void 0!==v?v:1008;this.anisotropy=void 0!==F?F:1;this.format=void 0!==z?z:1023;this.type=void 0!==E?E:1009;this.offset=new f(0,0);this.repeat=new f(1,1);this.center=new f(0,0);
this.rotation=0;this.matrixAutoUpdate=!0;this.matrix=new t;this.generateMipmaps=!0;this.premultiplyAlpha=!1;this.flipY=!0;this.unpackAlignment=4;this.encoding=void 0!==J?J:3E3;this.version=0;this.onUpdate=null}function p(a,c,e,g){this.x=a||0;this.y=c||0;this.z=e||0;this.w=void 0!==g?g:1}function m(a,c,e){this.width=a;this.height=c;this.scissor=new p(0,0,a,c);this.scissorTest=!1;this.viewport=new p(0,0,a,c);e=e||{};this.texture=new l(void 0,void 0,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,
e.anisotropy,e.encoding);this.texture.image={};this.texture.image.width=a;this.texture.image.height=c;this.texture.generateMipmaps=void 0!==e.generateMipmaps?e.generateMipmaps:!1;this.texture.minFilter=void 0!==e.minFilter?e.minFilter:1006;this.depthBuffer=void 0!==e.depthBuffer?e.depthBuffer:!0;this.stencilBuffer=void 0!==e.stencilBuffer?e.stencilBuffer:!0;this.depthTexture=void 0!==e.depthTexture?e.depthTexture:null}function n(a,c,e){m.call(this,a,c,e);this.samples=4}function q(){this.elements=
[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];0<arguments.length&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}function u(a,c,e,g){this._x=a||0;this._y=c||0;this._z=e||0;this._order=g||u.DefaultOrder}function x(){this.mask=1}function A(){Object.defineProperty(this,"id",{value:Ok++});this.uuid=hb.generateUUID();this.name="";this.type="Object3D";this.parent=null;this.children=[];this.up=A.DefaultUp.clone();var a=new k,c=new u,e=new h,g=new k(1,1,1);c._onChange(function(){e.setFromEuler(c,
!1)});e._onChange(function(){c.setFromQuaternion(e,void 0,!1)});Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:a},rotation:{configurable:!0,enumerable:!0,value:c},quaternion:{configurable:!0,enumerable:!0,value:e},scale:{configurable:!0,enumerable:!0,value:g},modelViewMatrix:{value:new q},normalMatrix:{value:new t}});this.matrix=new q;this.matrixWorld=new q;this.matrixAutoUpdate=A.DefaultMatrixAutoUpdate;this.matrixWorldNeedsUpdate=!1;this.layers=new x;this.visible=!0;
this.receiveShadow=this.castShadow=!1;this.frustumCulled=!0;this.renderOrder=0;this.userData={}}function y(){A.call(this);this.type="Scene";this.overrideMaterial=this.fog=this.background=null;this.autoUpdate=!0;"undefined"!==typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}function w(a,c){this.min=void 0!==a?a:new k(Infinity,Infinity,Infinity);this.max=void 0!==c?c:new k(-Infinity,-Infinity,-Infinity)}function C(a,c,e,g,r){var v;var z=0;for(v=a.length-
3;z<=v;z+=3){Kd.fromArray(a,z);var E=c.dot(Kd),F=e.dot(Kd),J=g.dot(Kd);if(Math.max(-Math.max(E,F,J),Math.min(E,F,J))>r.x*Math.abs(Kd.x)+r.y*Math.abs(Kd.y)+r.z*Math.abs(Kd.z))return!1}return!0}function G(a,c){this.center=void 0!==a?a:new k;this.radius=void 0!==c?c:0}function D(a,c){this.origin=void 0!==a?a:new k;this.direction=void 0!==c?c:new k}function B(a,c,e){this.a=void 0!==a?a:new k;this.b=void 0!==c?c:new k;this.c=void 0!==e?e:new k}function I(a,c,e){return void 0===c&&void 0===e?this.set(a):
this.setRGB(a,c,e)}function N(a,c,e){0>e&&(e+=1);1<e&&--e;return e<1/6?a+6*(c-a)*e:.5>e?c:e<2/3?a+6*(c-a)*(2/3-e):a}function O(a){return.04045>a?.0773993808*a:Math.pow(.9478672986*a+.0521327014,2.4)}function H(a){return.0031308>a?12.92*a:1.055*Math.pow(a,.41666)-.055}function K(a,c,e,g,r,v){this.a=a;this.b=c;this.c=e;this.normal=g&&g.isVector3?g:new k;this.vertexNormals=Array.isArray(g)?g:[];this.color=r&&r.isColor?r:new I;this.vertexColors=Array.isArray(r)?r:[];this.materialIndex=void 0!==v?v:0}
function M(){Object.defineProperty(this,"id",{value:Pk++});this.uuid=hb.generateUUID();this.name="";this.type="Material";this.lights=this.fog=!0;this.blending=1;this.side=0;this.vertexTangents=this.flatShading=!1;this.vertexColors=0;this.opacity=1;this.transparent=!1;this.blendSrc=204;this.blendDst=205;this.blendEquation=100;this.blendEquationAlpha=this.blendDstAlpha=this.blendSrcAlpha=null;this.depthFunc=3;this.depthWrite=this.depthTest=!0;this.stencilFunc=519;this.stencilRef=0;this.stencilMask=
255;this.stencilZPass=this.stencilZFail=this.stencilFail=7680;this.stencilWrite=!1;this.clippingPlanes=null;this.clipShadows=this.clipIntersection=!1;this.shadowSide=null;this.colorWrite=!0;this.precision=null;this.polygonOffset=!1;this.polygonOffsetUnits=this.polygonOffsetFactor=0;this.dithering=!1;this.alphaTest=0;this.premultipliedAlpha=!1;this.toneMapped=this.visible=!0;this.userData={};this.needsUpdate=!0}function L(a){M.call(this);this.type="MeshBasicMaterial";this.color=new I(16777215);this.lightMap=
this.map=null;this.lightMapIntensity=1;this.aoMap=null;this.aoMapIntensity=1;this.envMap=this.alphaMap=this.specularMap=null;this.combine=0;this.reflectivity=1;this.refractionRatio=.98;this.wireframe=!1;this.wireframeLinewidth=1;this.wireframeLinejoin=this.wireframeLinecap="round";this.lights=this.morphTargets=this.skinning=!1;this.setValues(a)}function Q(a,c,e){if(Array.isArray(a))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="";this.array=a;this.itemSize=
c;this.count=void 0!==a?a.length/c:0;this.normalized=!0===e;this.dynamic=!1;this.updateRange={offset:0,count:-1};this.version=0}function T(a,c,e){Q.call(this,new Int8Array(a),c,e)}function X(a,c,e){Q.call(this,new Uint8Array(a),c,e)}function aa(a,c,e){Q.call(this,new Uint8ClampedArray(a),c,e)}function la(a,c,e){Q.call(this,new Int16Array(a),c,e)}function Z(a,c,e){Q.call(this,new Uint16Array(a),c,e)}function ba(a,c,e){Q.call(this,new Int32Array(a),c,e)}function ea(a,c,e){Q.call(this,new Uint32Array(a),
c,e)}function ca(a,c,e){Q.call(this,new Float32Array(a),c,e)}function ka(a,c,e){Q.call(this,new Float64Array(a),c,e)}function Y(){this.vertices=[];this.normals=[];this.colors=[];this.uvs=[];this.uvs2=[];this.groups=[];this.morphTargets={};this.skinWeights=[];this.skinIndices=[];this.boundingSphere=this.boundingBox=null;this.groupsNeedUpdate=this.uvsNeedUpdate=this.colorsNeedUpdate=this.normalsNeedUpdate=this.verticesNeedUpdate=!1}function Ea(a){if(0===a.length)return-Infinity;for(var c=a[0],e=1,g=
a.length;e<g;++e)a[e]>c&&(c=a[e]);return c}function va(){Object.defineProperty(this,"id",{value:Qk+=2});this.uuid=hb.generateUUID();this.name="";this.type="BufferGeometry";this.index=null;this.attributes={};this.morphAttributes={};this.groups=[];this.boundingSphere=this.boundingBox=null;this.drawRange={start:0,count:Infinity};this.userData={}}function xa(a,c){A.call(this);this.type="Mesh";this.geometry=void 0!==a?a:new va;this.material=void 0!==c?c:new L({color:16777215*Math.random()});this.drawMode=
0;this.updateMorphTargets()}function Aa(a,c,e,g,r,v,z,E){if(null===(1===c.side?g.intersectTriangle(z,v,r,!0,E):g.intersectTriangle(r,v,z,2!==c.side,E)))return null;sg.copy(E);sg.applyMatrix4(a.matrixWorld);c=e.ray.origin.distanceTo(sg);return c<e.near||c>e.far?null:{distance:c,point:sg.clone(),object:a}}function Fa(a,c,e,g,r,v,z,E,F,J,P){Ld.fromBufferAttribute(r,F);Md.fromBufferAttribute(r,J);Nd.fromBufferAttribute(r,P);r=a.morphTargetInfluences;if(c.morphTargets&&v&&r){Ih.set(0,0,0);Jh.set(0,0,0);
Kh.set(0,0,0);for(var R=0,S=v.length;R<S;R++){var V=r[R],W=v[R];0!==V&&($i.fromBufferAttribute(W,F),aj.fromBufferAttribute(W,J),bj.fromBufferAttribute(W,P),Ih.addScaledVector($i.sub(Ld),V),Jh.addScaledVector(aj.sub(Md),V),Kh.addScaledVector(bj.sub(Nd),V))}Ld.add(Ih);Md.add(Jh);Nd.add(Kh)}if(a=Aa(a,c,e,g,Ld,Md,Nd,sf))z&&(oe.fromBufferAttribute(z,F),pe.fromBufferAttribute(z,J),qe.fromBufferAttribute(z,P),a.uv=B.getUV(sf,Ld,Md,Nd,oe,pe,qe,new f)),E&&(oe.fromBufferAttribute(E,F),pe.fromBufferAttribute(E,
J),qe.fromBufferAttribute(E,P),a.uv2=B.getUV(sf,Ld,Md,Nd,oe,pe,qe,new f)),z=new K(F,J,P),B.getNormal(Ld,Md,Nd,z.normal),a.face=z;return a}function ya(){Object.defineProperty(this,"id",{value:Rk+=2});this.uuid=hb.generateUUID();this.name="";this.type="Geometry";this.vertices=[];this.colors=[];this.faces=[];this.faceVertexUvs=[[]];this.morphTargets=[];this.morphNormals=[];this.skinWeights=[];this.skinIndices=[];this.lineDistances=[];this.boundingSphere=this.boundingBox=null;this.groupsNeedUpdate=this.lineDistancesNeedUpdate=
this.colorsNeedUpdate=this.normalsNeedUpdate=this.uvsNeedUpdate=this.verticesNeedUpdate=this.elementsNeedUpdate=!1}function Sa(a,c,e,g,r,v){ya.call(this);this.type="BoxGeometry";this.parameters={width:a,height:c,depth:e,widthSegments:g,heightSegments:r,depthSegments:v};this.fromBufferGeometry(new Xa(a,c,e,g,r,v));this.mergeVertices()}function Xa(a,c,e,g,r,v){function z(W,ha,fa,ra,pa,qa,ua,oa,ta,Ba,Ta){var Ua=qa/ta,Ca=ua/Ba,Ha=qa/2,Da=ua/2,Ma=oa/2;ua=ta+1;var db=Ba+1,tb=qa=0,Ka,bb,jb=new k;for(bb=
0;bb<db;bb++){var Eb=bb*Ca-Da;for(Ka=0;Ka<ua;Ka++)jb[W]=(Ka*Ua-Ha)*ra,jb[ha]=Eb*pa,jb[fa]=Ma,J.push(jb.x,jb.y,jb.z),jb[W]=0,jb[ha]=0,jb[fa]=0<oa?1:-1,P.push(jb.x,jb.y,jb.z),R.push(Ka/ta),R.push(1-bb/Ba),qa+=1}for(bb=0;bb<Ba;bb++)for(Ka=0;Ka<ta;Ka++)W=S+Ka+ua*(bb+1),ha=S+(Ka+1)+ua*(bb+1),fa=S+(Ka+1)+ua*bb,F.push(S+Ka+ua*bb,W,fa),F.push(W,ha,fa),tb+=6;E.addGroup(V,tb,Ta);V+=tb;S+=qa}va.call(this);this.type="BoxBufferGeometry";this.parameters={width:a,height:c,depth:e,widthSegments:g,heightSegments:r,
depthSegments:v};var E=this;a=a||1;c=c||1;e=e||1;g=Math.floor(g)||1;r=Math.floor(r)||1;v=Math.floor(v)||1;var F=[],J=[],P=[],R=[],S=0,V=0;z("z","y","x",-1,-1,e,c,a,v,r,0);z("z","y","x",1,-1,e,c,-a,v,r,1);z("x","z","y",1,1,a,e,c,g,v,2);z("x","z","y",1,-1,a,e,-c,g,v,3);z("x","y","z",1,-1,a,c,e,g,r,4);z("x","y","z",-1,-1,a,c,-e,g,r,5);this.setIndex(F);this.addAttribute("position",new ca(J,3));this.addAttribute("normal",new ca(P,3));this.addAttribute("uv",new ca(R,2))}function ub(a){var c={},e;for(e in a){c[e]=
{};for(var g in a[e]){var r=a[e][g];c[e][g]=r&&(r.isColor||r.isMatrix3||r.isMatrix4||r.isVector2||r.isVector3||r.isVector4||r.isTexture)?r.clone():Array.isArray(r)?r.slice():r}}return c}function Bb(a){for(var c={},e=0;e<a.length;e++){var g=ub(a[e]),r;for(r in g)c[r]=g[r]}return c}function qb(a){M.call(this);this.type="ShaderMaterial";this.defines={};this.uniforms={};this.vertexShader="void main() {\n\tgl_Position \x3d projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}";this.fragmentShader=
"void main() {\n\tgl_FragColor \x3d vec4( 1.0, 0.0, 0.0, 1.0 );\n}";this.linewidth=1;this.wireframe=!1;this.wireframeLinewidth=1;this.morphNormals=this.morphTargets=this.skinning=this.clipping=this.lights=this.fog=!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;void 0!==a&&(void 0!==a.attributes&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),
this.setValues(a))}function zb(){A.call(this);this.type="Camera";this.matrixWorldInverse=new q;this.projectionMatrix=new q;this.projectionMatrixInverse=new q}function vb(a,c,e,g){zb.call(this);this.type="PerspectiveCamera";this.fov=void 0!==a?a:50;this.zoom=1;this.near=void 0!==e?e:.1;this.far=void 0!==g?g:2E3;this.focus=10;this.aspect=void 0!==c?c:1;this.view=null;this.filmGauge=35;this.filmOffset=0;this.updateProjectionMatrix()}function Gb(a,c,e,g){A.call(this);this.type="CubeCamera";var r=new vb(90,
1,a,c);r.up.set(0,-1,0);r.lookAt(new k(1,0,0));this.add(r);var v=new vb(90,1,a,c);v.up.set(0,-1,0);v.lookAt(new k(-1,0,0));this.add(v);var z=new vb(90,1,a,c);z.up.set(0,0,1);z.lookAt(new k(0,1,0));this.add(z);var E=new vb(90,1,a,c);E.up.set(0,0,-1);E.lookAt(new k(0,-1,0));this.add(E);var F=new vb(90,1,a,c);F.up.set(0,-1,0);F.lookAt(new k(0,0,1));this.add(F);var J=new vb(90,1,a,c);J.up.set(0,-1,0);J.lookAt(new k(0,0,-1));this.add(J);g=g||{format:1022,magFilter:1006,minFilter:1006};this.renderTarget=
new Nb(e,e,g);this.renderTarget.texture.name="CubeCamera";this.update=function(P,R){null===this.parent&&this.updateMatrixWorld();var S=P.getRenderTarget(),V=this.renderTarget,W=V.texture.generateMipmaps;V.texture.generateMipmaps=!1;P.setRenderTarget(V,0);P.render(R,r);P.setRenderTarget(V,1);P.render(R,v);P.setRenderTarget(V,2);P.render(R,z);P.setRenderTarget(V,3);P.render(R,E);P.setRenderTarget(V,4);P.render(R,F);V.texture.generateMipmaps=W;P.setRenderTarget(V,5);P.render(R,J);P.setRenderTarget(S)};
this.clear=function(P,R,S,V){for(var W=P.getRenderTarget(),ha=this.renderTarget,fa=0;6>fa;fa++)P.setRenderTarget(ha,fa),P.clear(R,S,V);P.setRenderTarget(W)}}function Nb(a,c,e){m.call(this,a,c,e)}function Ab(a,c,e,g,r,v,z,E,F,J,P,R){l.call(this,null,v,z,E,F,J,g,r,P,R);this.image={data:a,width:c,height:e};this.magFilter=void 0!==F?F:1003;this.minFilter=void 0!==J?J:1003;this.flipY=this.generateMipmaps=!1;this.unpackAlignment=1}function Hb(a,c){this.normal=void 0!==a?a:new k(1,0,0);this.constant=void 0!==
c?c:0}function ic(a,c,e,g,r,v){this.planes=[void 0!==a?a:new Hb,void 0!==c?c:new Hb,void 0!==e?e:new Hb,void 0!==g?g:new Hb,void 0!==r?r:new Hb,void 0!==v?v:new Hb]}function bc(){function a(r,v){!1!==e&&(g(r,v),c.requestAnimationFrame(a))}var c=null,e=!1,g=null;return{start:function(){!0!==e&&null!==g&&(c.requestAnimationFrame(a),e=!0)},stop:function(){e=!1},setAnimationLoop:function(r){g=r},setContext:function(r){c=r}}}function Od(a){function c(r,v){var z=r.array,E=r.dynamic?35048:35044,F=a.createBuffer();
a.bindBuffer(v,F);a.bufferData(v,z,E);r.onUploadCallback();v=5126;z instanceof Float32Array?v=5126:z instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):z instanceof Uint16Array?v=5123:z instanceof Int16Array?v=5122:z instanceof Uint32Array?v=5125:z instanceof Int32Array?v=5124:z instanceof Int8Array?v=5120:z instanceof Uint8Array&&(v=5121);return{buffer:F,type:v,bytesPerElement:z.BYTES_PER_ELEMENT,version:r.version}}function e(r,v,z){var E=
v.array,F=v.updateRange;a.bindBuffer(z,r);!1===v.dynamic?a.bufferData(z,E,35044):-1===F.count?a.bufferSubData(z,0,E):0===F.count?console.error("THREE.WebGLObjects.updateBuffer: dynamic THREE.BufferAttribute marked as needsUpdate but updateRange.count is 0, ensure you are using set methods or updating manually."):(a.bufferSubData(z,F.offset*E.BYTES_PER_ELEMENT,E.subarray(F.offset,F.offset+F.count)),F.count=-1)}var g=new WeakMap;return{get:function(r){r.isInterleavedBufferAttribute&&(r=r.data);return g.get(r)},
remove:function(r){r.isInterleavedBufferAttribute&&(r=r.data);var v=g.get(r);v&&(a.deleteBuffer(v.buffer),g.delete(r))},update:function(r,v){r.isInterleavedBufferAttribute&&(r=r.data);var z=g.get(r);void 0===z?g.set(r,c(r,v)):z.version<r.version&&(e(z.buffer,r,v),z.version=r.version)}}}function rd(a,c,e,g){ya.call(this);this.type="PlaneGeometry";this.parameters={width:a,height:c,widthSegments:e,heightSegments:g};this.fromBufferGeometry(new Lc(a,c,e,g));this.mergeVertices()}function Lc(a,c,e,g){va.call(this);
this.type="PlaneBufferGeometry";this.parameters={width:a,height:c,widthSegments:e,heightSegments:g};a=a||1;c=c||1;var r=a/2,v=c/2;e=Math.floor(e)||1;g=Math.floor(g)||1;var z=e+1,E=g+1,F=a/e,J=c/g,P=[],R=[],S=[],V=[];for(a=0;a<E;a++){var W=a*J-v;for(c=0;c<z;c++)R.push(c*F-r,-W,0),S.push(0,0,1),V.push(c/e),V.push(1-a/g)}for(a=0;a<g;a++)for(c=0;c<e;c++)r=c+z*(a+1),v=c+1+z*(a+1),E=c+1+z*a,P.push(c+z*a,r,E),P.push(r,v,E);this.setIndex(P);this.addAttribute("position",new ca(R,3));this.addAttribute("normal",
new ca(S,3));this.addAttribute("uv",new ca(V,2))}function sd(a,c,e,g){function r(R,S){c.buffers.color.setClear(R.r,R.g,R.b,S,g)}var v=new I(0),z=0,E,F,J=null,P=0;return{getClearColor:function(){return v},setClearColor:function(R,S){v.set(R);z=void 0!==S?S:1;r(v,z)},getClearAlpha:function(){return z},setClearAlpha:function(R){z=R;r(v,z)},render:function(R,S,V,W){S=S.background;V=a.vr;(V=V.getSession&&V.getSession())&&"additive"===V.environmentBlendMode&&(S=null);null===S?(r(v,z),J=null,P=0):S&&S.isColor&&
(r(S,1),W=!0,J=null,P=0);(a.autoClear||W)&&a.clear(a.autoClearColor,a.autoClearDepth,a.autoClearStencil);if(S&&(S.isCubeTexture||S.isWebGLRenderTargetCube)){void 0===F&&(F=new xa(new Xa(1,1,1),new qb({type:"BackgroundCubeMaterial",uniforms:ub(Mc.cube.uniforms),vertexShader:Mc.cube.vertexShader,fragmentShader:Mc.cube.fragmentShader,side:1,depthTest:!1,depthWrite:!1,fog:!1})),F.geometry.removeAttribute("normal"),F.geometry.removeAttribute("uv"),F.onBeforeRender=function(ha,fa,ra){this.matrixWorld.copyPosition(ra.matrixWorld)},
Object.defineProperty(F.material,"map",{get:function(){return this.uniforms.tCube.value}}),e.update(F));W=S.isWebGLRenderTargetCube?S.texture:S;F.material.uniforms.tCube.value=W;F.material.uniforms.tFlip.value=S.isWebGLRenderTargetCube?1:-1;if(J!==S||P!==W.version)F.material.needsUpdate=!0,J=S,P=W.version;R.unshift(F,F.geometry,F.material,0,0,null)}else if(S&&S.isTexture){void 0===E&&(E=new xa(new Lc(2,2),new qb({type:"BackgroundMaterial",uniforms:ub(Mc.background.uniforms),vertexShader:Mc.background.vertexShader,
fragmentShader:Mc.background.fragmentShader,side:0,depthTest:!1,depthWrite:!1,fog:!1})),E.geometry.removeAttribute("normal"),Object.defineProperty(E.material,"map",{get:function(){return this.uniforms.t2D.value}}),e.update(E));E.material.uniforms.t2D.value=S;!0===S.matrixAutoUpdate&&S.updateMatrix();E.material.uniforms.uvTransform.value.copy(S.matrix);if(J!==S||P!==S.version)E.material.needsUpdate=!0,J=S,P=S.version;R.unshift(E,E.geometry,E.material,0,0,null)}}}}function sa(a,c,e,g){var r;this.setMode=
function(v){r=v};this.render=function(v,z){a.drawArrays(r,v,z);e.update(z,r)};this.renderInstances=function(v,z,E){if(g.isWebGL2){var F=a;var J="drawArraysInstanced"}else if(F=c.get("ANGLE_instanced_arrays"),J="drawArraysInstancedANGLE",null===F){console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}F[J](r,z,E,v.maxInstancedCount);e.update(E,r,v.maxInstancedCount)}}function Mb(a,c,e){function g(qa){if("highp"===
qa){if(0<a.getShaderPrecisionFormat(35633,36338).precision&&0<a.getShaderPrecisionFormat(35632,36338).precision)return"highp";qa="mediump"}return"mediump"===qa&&0<a.getShaderPrecisionFormat(35633,36337).precision&&0<a.getShaderPrecisionFormat(35632,36337).precision?"mediump":"lowp"}var r,v="undefined"!==typeof WebGL2RenderingContext&&a instanceof WebGL2RenderingContext,z=void 0!==e.precision?e.precision:"highp",E=g(z);E!==z&&(console.warn("THREE.WebGLRenderer:",z,"not supported, using",E,"instead."),
z=E);e=!0===e.logarithmicDepthBuffer;E=a.getParameter(34930);var F=a.getParameter(35660),J=a.getParameter(3379),P=a.getParameter(34076),R=a.getParameter(34921),S=a.getParameter(36347),V=a.getParameter(36348),W=a.getParameter(36349),ha=0<F,fa=v||!!c.get("OES_texture_float"),ra=ha&&fa,pa=v?a.getParameter(36183):0;return{isWebGL2:v,getMaxAnisotropy:function(){if(void 0!==r)return r;var qa=c.get("EXT_texture_filter_anisotropic");return r=null!==qa?a.getParameter(qa.MAX_TEXTURE_MAX_ANISOTROPY_EXT):0},
getMaxPrecision:g,precision:z,logarithmicDepthBuffer:e,maxTextures:E,maxVertexTextures:F,maxTextureSize:J,maxCubemapSize:P,maxAttributes:R,maxVertexUniforms:S,maxVaryings:V,maxFragmentUniforms:W,vertexTextures:ha,floatFragmentTextures:fa,floatVertexTextures:ra,maxSamples:pa}}function wc(){function a(){J.value!==g&&(J.value=g,J.needsUpdate=0<r);e.numPlanes=r;e.numIntersection=0}function c(P,R,S,V){var W=null!==P?P.length:0,ha=null;if(0!==W){ha=J.value;if(!0!==V||null===ha){V=S+4*W;R=R.matrixWorldInverse;
F.getNormalMatrix(R);if(null===ha||ha.length<V)ha=new Float32Array(V);for(V=0;V!==W;++V,S+=4)E.copy(P[V]).applyMatrix4(R,F),E.normal.toArray(ha,S),ha[S+3]=E.constant}J.value=ha;J.needsUpdate=!0}e.numPlanes=W;return ha}var e=this,g=null,r=0,v=!1,z=!1,E=new Hb,F=new t,J={value:null,needsUpdate:!1};this.uniform=J;this.numIntersection=this.numPlanes=0;this.init=function(P,R,S){var V=0!==P.length||R||0!==r||v;v=R;g=c(P,S,0);r=P.length;return V};this.beginShadows=function(){z=!0;c(null)};this.endShadows=
function(){z=!1;a()};this.setState=function(P,R,S,V,W,ha){if(!v||null===P||0===P.length||z&&!S)z?c(null):a();else{S=z?0:r;var fa=4*S,ra=W.clippingState||null;J.value=ra;ra=c(P,V,fa,ha);for(P=0;P!==fa;++P)ra[P]=g[P];W.clippingState=ra;this.numIntersection=R?this.numPlanes:0;this.numPlanes+=S}}}function bd(a){var c={};return{get:function(e){if(void 0!==c[e])return c[e];switch(e){case "WEBGL_depth_texture":var g=a.getExtension("WEBGL_depth_texture")||a.getExtension("MOZ_WEBGL_depth_texture")||a.getExtension("WEBKIT_WEBGL_depth_texture");
break;case "EXT_texture_filter_anisotropic":g=a.getExtension("EXT_texture_filter_anisotropic")||a.getExtension("MOZ_EXT_texture_filter_anisotropic")||a.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case "WEBGL_compressed_texture_s3tc":g=a.getExtension("WEBGL_compressed_texture_s3tc")||a.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||a.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case "WEBGL_compressed_texture_pvrtc":g=a.getExtension("WEBGL_compressed_texture_pvrtc")||
a.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:g=a.getExtension(e)}null===g&&console.warn("THREE.WebGLRenderer: "+e+" extension not supported.");return c[e]=g}}}function td(a,c,e){function g(E){var F=E.target;E=v.get(F);null!==E.index&&c.remove(E.index);for(var J in E.attributes)c.remove(E.attributes[J]);F.removeEventListener("dispose",g);v.delete(F);if(J=z.get(E))c.remove(J),z.delete(E);e.memory.geometries--}function r(E){var F=[],J=E.index,P=E.attributes.position;if(null!==
J){var R=J.array;J=J.version;P=0;for(var S=R.length;P<S;P+=3){var V=R[P+0],W=R[P+1],ha=R[P+2];F.push(V,W,W,ha,ha,V)}}else for(R=P.array,J=P.version,P=0,S=R.length/3-1;P<S;P+=3)V=P+0,W=P+1,ha=P+2,F.push(V,W,W,ha,ha,V);F=new (65535<Ea(F)?ea:Z)(F,1);F.version=J;c.update(F,34963);(R=z.get(E))&&c.remove(R);z.set(E,F)}var v=new WeakMap,z=new WeakMap;return{get:function(E,F){var J=v.get(F);if(J)return J;F.addEventListener("dispose",g);F.isBufferGeometry?J=F:F.isGeometry&&(void 0===F._bufferGeometry&&(F._bufferGeometry=
(new va).setFromObject(E)),J=F._bufferGeometry);v.set(F,J);e.memory.geometries++;return J},update:function(E){var F=E.index,J=E.attributes;null!==F&&c.update(F,34963);for(var P in J)c.update(J[P],34962);E=E.morphAttributes;for(P in E){F=E[P];J=0;for(var R=F.length;J<R;J++)c.update(F[J],34962)}},getWireframeAttribute:function(E){var F=z.get(E);if(F){var J=E.index;null!==J&&F.version<J.version&&r(E)}else r(E);return z.get(E)}}}function tg(a,c,e,g){var r,v,z;this.setMode=function(E){r=E};this.setIndex=
function(E){v=E.type;z=E.bytesPerElement};this.render=function(E,F){a.drawElements(r,F,v,E*z);e.update(F,r)};this.renderInstances=function(E,F,J){if(g.isWebGL2){var P=a;var R="drawElementsInstanced"}else if(P=c.get("ANGLE_instanced_arrays"),R="drawElementsInstancedANGLE",null===P){console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}P[R](r,J,v,F*z,E.maxInstancedCount);e.update(J,r,E.maxInstancedCount)}}
function Sk(){var a={frame:0,calls:0,triangles:0,points:0,lines:0};return{memory:{geometries:0,textures:0},render:a,programs:null,autoReset:!0,reset:function(){a.frame++;a.calls=0;a.triangles=0;a.points=0;a.lines=0},update:function(c,e,g){g=g||1;a.calls++;switch(e){case 4:a.triangles+=c/3*g;break;case 5:case 6:a.triangles+=g*(c-2);break;case 1:a.lines+=c/2*g;break;case 3:a.lines+=g*(c-1);break;case 2:a.lines+=g*c;break;case 0:a.points+=g*c;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",
e)}}}}function Tk(a,c){return Math.abs(c[1])-Math.abs(a[1])}function Uk(a){var c={},e=new Float32Array(8);return{update:function(g,r,v,z){var E=g.morphTargetInfluences,F=E.length;g=c[r.id];if(void 0===g){g=[];for(var J=0;J<F;J++)g[J]=[J,0];c[r.id]=g}var P=v.morphTargets&&r.morphAttributes.position;v=v.morphNormals&&r.morphAttributes.normal;for(J=0;J<F;J++){var R=g[J];0!==R[1]&&(P&&r.removeAttribute("morphTarget"+J),v&&r.removeAttribute("morphNormal"+J))}for(J=0;J<F;J++)R=g[J],R[0]=J,R[1]=E[J];g.sort(Tk);
for(J=0;8>J;J++){if(R=g[J])if(E=R[0],F=R[1]){P&&r.addAttribute("morphTarget"+J,P[E]);v&&r.addAttribute("morphNormal"+J,v[E]);e[J]=F;continue}e[J]=0}z.getUniforms().setValue(a,"morphTargetInfluences",e)}}}function Vk(a,c){var e={};return{update:function(g){var r=c.render.frame,v=g.geometry,z=a.get(g,v);e[z.id]!==r&&(v.isGeometry&&z.updateFromObject(g),a.update(z),e[z.id]=r);return z},dispose:function(){e={}}}}function cd(a,c,e,g,r,v,z,E,F,J){a=void 0!==a?a:[];l.call(this,a,void 0!==c?c:301,e,g,r,v,
void 0!==z?z:1022,E,F,J);this.flipY=!1}function re(a,c,e,g){l.call(this,null);this.image={data:a,width:c,height:e,depth:g};this.minFilter=this.magFilter=1003;this.wrapR=1001;this.flipY=this.generateMipmaps=!1}function se(a,c,e,g){l.call(this,null);this.image={data:a,width:c,height:e,depth:g};this.minFilter=this.magFilter=1003;this.wrapR=1001;this.flipY=this.generateMipmaps=!1}function te(a,c,e){var g=a[0];if(0>=g||0<g)return a;var r=c*e,v=cj[r];void 0===v&&(v=new Float32Array(r),cj[r]=v);if(0!==c)for(g.toArray(v,
0),g=1,r=0;g!==c;++g)r+=e,a[g].toArray(v,r);return v}function sc(a,c){if(a.length!==c.length)return!1;for(var e=0,g=a.length;e<g;e++)if(a[e]!==c[e])return!1;return!0}function mc(a,c){for(var e=0,g=c.length;e<g;e++)a[e]=c[e]}function dj(a,c){var e=ej[c];void 0===e&&(e=new Int32Array(c),ej[c]=e);for(var g=0;g!==c;++g)e[g]=a.allocateTextureUnit();return e}function Wk(a,c){var e=this.cache;e[0]!==c&&(a.uniform1f(this.addr,c),e[0]=c)}function Xk(a,c){var e=this.cache;if(void 0!==c.x){if(e[0]!==c.x||e[1]!==
c.y)a.uniform2f(this.addr,c.x,c.y),e[0]=c.x,e[1]=c.y}else sc(e,c)||(a.uniform2fv(this.addr,c),mc(e,c))}function Yk(a,c){var e=this.cache;if(void 0!==c.x){if(e[0]!==c.x||e[1]!==c.y||e[2]!==c.z)a.uniform3f(this.addr,c.x,c.y,c.z),e[0]=c.x,e[1]=c.y,e[2]=c.z}else if(void 0!==c.r){if(e[0]!==c.r||e[1]!==c.g||e[2]!==c.b)a.uniform3f(this.addr,c.r,c.g,c.b),e[0]=c.r,e[1]=c.g,e[2]=c.b}else sc(e,c)||(a.uniform3fv(this.addr,c),mc(e,c))}function Zk(a,c){var e=this.cache;if(void 0!==c.x){if(e[0]!==c.x||e[1]!==c.y||
e[2]!==c.z||e[3]!==c.w)a.uniform4f(this.addr,c.x,c.y,c.z,c.w),e[0]=c.x,e[1]=c.y,e[2]=c.z,e[3]=c.w}else sc(e,c)||(a.uniform4fv(this.addr,c),mc(e,c))}function $k(a,c){var e=this.cache,g=c.elements;void 0===g?sc(e,c)||(a.uniformMatrix2fv(this.addr,!1,c),mc(e,c)):sc(e,g)||(fj.set(g),a.uniformMatrix2fv(this.addr,!1,fj),mc(e,g))}function al(a,c){var e=this.cache,g=c.elements;void 0===g?sc(e,c)||(a.uniformMatrix3fv(this.addr,!1,c),mc(e,c)):sc(e,g)||(gj.set(g),a.uniformMatrix3fv(this.addr,!1,gj),mc(e,g))}
function bl(a,c){var e=this.cache,g=c.elements;void 0===g?sc(e,c)||(a.uniformMatrix4fv(this.addr,!1,c),mc(e,c)):sc(e,g)||(hj.set(g),a.uniformMatrix4fv(this.addr,!1,hj),mc(e,g))}function cl(a,c,e){var g=this.cache,r=e.allocateTextureUnit();g[0]!==r&&(a.uniform1i(this.addr,r),g[0]=r);e.safeSetTexture2D(c||ij,r)}function dl(a,c,e){var g=this.cache,r=e.allocateTextureUnit();g[0]!==r&&(a.uniform1i(this.addr,r),g[0]=r);e.setTexture2DArray(c||el,r)}function fl(a,c,e){var g=this.cache,r=e.allocateTextureUnit();
g[0]!==r&&(a.uniform1i(this.addr,r),g[0]=r);e.setTexture3D(c||gl,r)}function hl(a,c,e){var g=this.cache,r=e.allocateTextureUnit();g[0]!==r&&(a.uniform1i(this.addr,r),g[0]=r);e.safeSetTextureCube(c||jj,r)}function il(a,c){var e=this.cache;e[0]!==c&&(a.uniform1i(this.addr,c),e[0]=c)}function jl(a,c){var e=this.cache;sc(e,c)||(a.uniform2iv(this.addr,c),mc(e,c))}function kl(a,c){var e=this.cache;sc(e,c)||(a.uniform3iv(this.addr,c),mc(e,c))}function ll(a,c){var e=this.cache;sc(e,c)||(a.uniform4iv(this.addr,
c),mc(e,c))}function ml(a){switch(a){case 5126:return Wk;case 35664:return Xk;case 35665:return Yk;case 35666:return Zk;case 35674:return $k;case 35675:return al;case 35676:return bl;case 35678:case 36198:return cl;case 35679:return fl;case 35680:return hl;case 36289:return dl;case 5124:case 35670:return il;case 35667:case 35671:return jl;case 35668:case 35672:return kl;case 35669:case 35673:return ll}}function nl(a,c){a.uniform1fv(this.addr,c)}function ol(a,c){a.uniform1iv(this.addr,c)}function pl(a,
c){a.uniform2iv(this.addr,c)}function ql(a,c){a.uniform3iv(this.addr,c)}function rl(a,c){a.uniform4iv(this.addr,c)}function sl(a,c){c=te(c,this.size,2);a.uniform2fv(this.addr,c)}function tl(a,c){c=te(c,this.size,3);a.uniform3fv(this.addr,c)}function ul(a,c){c=te(c,this.size,4);a.uniform4fv(this.addr,c)}function vl(a,c){c=te(c,this.size,4);a.uniformMatrix2fv(this.addr,!1,c)}function wl(a,c){c=te(c,this.size,9);a.uniformMatrix3fv(this.addr,!1,c)}function xl(a,c){c=te(c,this.size,16);a.uniformMatrix4fv(this.addr,
!1,c)}function yl(a,c,e){var g=c.length,r=dj(e,g);a.uniform1iv(this.addr,r);for(a=0;a!==g;++a)e.safeSetTexture2D(c[a]||ij,r[a])}function zl(a,c,e){var g=c.length,r=dj(e,g);a.uniform1iv(this.addr,r);for(a=0;a!==g;++a)e.safeSetTextureCube(c[a]||jj,r[a])}function Al(a){switch(a){case 5126:return nl;case 35664:return sl;case 35665:return tl;case 35666:return ul;case 35674:return vl;case 35675:return wl;case 35676:return xl;case 35678:return yl;case 35680:return zl;case 5124:case 35670:return ol;case 35667:case 35671:return pl;
case 35668:case 35672:return ql;case 35669:case 35673:return rl}}function Bl(a,c,e){this.id=a;this.addr=e;this.cache=[];this.setValue=ml(c.type)}function kj(a,c,e){this.id=a;this.addr=e;this.cache=[];this.size=c.size;this.setValue=Al(c.type)}function lj(a){this.id=a;this.seq=[];this.map={}}function mj(a,c){a.seq.push(c);a.map[c.id]=c}function Cl(a,c,e){var g=a.name,r=g.length;for(Lh.lastIndex=0;;){var v=Lh.exec(g),z=Lh.lastIndex,E=v[1],F=v[3];"]"===v[2]&&(E|=0);if(void 0===F||"["===F&&z+2===r){mj(e,
void 0===F?new Bl(E,a,c):new kj(E,a,c));break}else v=e.map[E],void 0===v&&(v=new lj(E),mj(e,v)),e=v}}function ud(a,c){this.seq=[];this.map={};for(var e=a.getProgramParameter(c,35718),g=0;g<e;++g){var r=a.getActiveUniform(c,g);Cl(r,a.getUniformLocation(c,r.name),this)}}function nj(a,c,e){c=a.createShader(c);a.shaderSource(c,e);a.compileShader(c);return c}function Dl(a){a=a.split("\n");for(var c=0;c<a.length;c++)a[c]=c+1+": "+a[c];return a.join("\n")}function oj(a){switch(a){case 3E3:return["Linear",
"( value )"];case 3001:return["sRGB","( value )"];case 3002:return["RGBE","( value )"];case 3004:return["RGBM","( value, 7.0 )"];case 3005:return["RGBM","( value, 16.0 )"];case 3006:return["RGBD","( value, 256.0 )"];case 3007:return["Gamma","( value, float( GAMMA_FACTOR ) )"];case 3003:return["LogLuv","( value )"];default:throw Error("unsupported encoding: "+a);}}function pj(a,c,e){var g=a.getShaderParameter(c,35713),r=a.getShaderInfoLog(c).trim();return g&&""===r?"":"THREE.WebGLShader: gl.getShaderInfoLog() "+
e+"\n"+r+Dl(a.getShaderSource(c))}function ug(a,c){c=oj(c);return"vec4 "+a+"( vec4 value ) { return "+c[0]+"ToLinear"+c[1]+"; }"}function El(a,c){c=oj(c);return"vec4 "+a+"( vec4 value ) { return LinearTo"+c[0]+c[1]+"; }"}function Fl(a,c){switch(c){case 1:c="Linear";break;case 2:c="Reinhard";break;case 3:c="Uncharted2";break;case 4:c="OptimizedCineon";break;case 5:c="ACESFilmic";break;default:throw Error("unsupported toneMapping: "+c);}return"vec3 "+a+"( vec3 color ) { return "+c+"ToneMapping( color ); }"}
function Gl(a,c,e){a=a||{};return[a.derivatives||c.envMapCubeUV||c.bumpMap||c.tangentSpaceNormalMap||c.clearcoatNormalMap||c.flatShading?"#extension GL_OES_standard_derivatives : enable":"",(a.fragDepth||c.logarithmicDepthBuffer)&&e.get("EXT_frag_depth")?"#extension GL_EXT_frag_depth : enable":"",a.drawBuffers&&e.get("WEBGL_draw_buffers")?"#extension GL_EXT_draw_buffers : require":"",(a.shaderTextureLOD||c.envMap)&&e.get("EXT_shader_texture_lod")?"#extension GL_EXT_shader_texture_lod : enable":""].filter(uf).join("\n")}
function Hl(a){var c=[],e;for(e in a){var g=a[e];!1!==g&&c.push("#define "+e+" "+g)}return c.join("\n")}function Il(a,c){for(var e={},g=a.getProgramParameter(c,35721),r=0;r<g;r++){var v=a.getActiveAttrib(c,r).name;e[v]=a.getAttribLocation(c,v)}return e}function uf(a){return""!==a}function qj(a,c){return a.replace(/NUM_DIR_LIGHTS/g,c.numDirLights).replace(/NUM_SPOT_LIGHTS/g,c.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,c.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,c.numPointLights).replace(/NUM_HEMI_LIGHTS/g,
c.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,c.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,c.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,c.numPointLightShadows)}function rj(a,c){return a.replace(/NUM_CLIPPING_PLANES/g,c.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,c.numClippingPlanes-c.numClipIntersection)}function Mh(a){return a.replace(/^[ \t]*#include +<([\w\d./]+)>/gm,function(c,e){c=rb[e];if(void 0===c)throw Error("Can not resolve #include \x3c"+e+"\x3e");return Mh(c)})}
function sj(a){return a.replace(/#pragma unroll_loop[\s]+?for \( int i = (\d+); i < (\d+); i \+\+ \) \{([\s\S]+?)(?=\})\}/g,function(c,e,g,r){c="";for(e=parseInt(e);e<parseInt(g);e++)c+=r.replace(/\[ i \]/g,"[ "+e+" ]").replace(/UNROLLED_LOOP_INDEX/g,e);return c})}function Jl(a,c,e,g,r,v,z){var E=a.getContext(),F=g.defines,J=r.vertexShader,P=r.fragmentShader,R="SHADOWMAP_TYPE_BASIC";1===v.shadowMapType?R="SHADOWMAP_TYPE_PCF":2===v.shadowMapType?R="SHADOWMAP_TYPE_PCF_SOFT":3===v.shadowMapType&&(R=
"SHADOWMAP_TYPE_VSM");var S="ENVMAP_TYPE_CUBE",V="ENVMAP_MODE_REFLECTION",W="ENVMAP_BLENDING_MULTIPLY";if(v.envMap){switch(g.envMap.mapping){case 301:case 302:S="ENVMAP_TYPE_CUBE";break;case 306:case 307:S="ENVMAP_TYPE_CUBE_UV";break;case 303:case 304:S="ENVMAP_TYPE_EQUIREC";break;case 305:S="ENVMAP_TYPE_SPHERE"}switch(g.envMap.mapping){case 302:case 304:V="ENVMAP_MODE_REFRACTION"}switch(g.combine){case 0:W="ENVMAP_BLENDING_MULTIPLY";break;case 1:W="ENVMAP_BLENDING_MIX";break;case 2:W="ENVMAP_BLENDING_ADD"}}var ha=
0<a.gammaFactor?a.gammaFactor:1,fa=z.isWebGL2?"":Gl(g.extensions,v,c),ra=Hl(F),pa=E.createProgram();g.isRawShaderMaterial?(F=[ra].filter(uf).join("\n"),0<F.length&&(F+="\n"),c=[fa,ra].filter(uf).join("\n"),0<c.length&&(c+="\n")):(F=["precision "+v.precision+" float;","precision "+v.precision+" int;","highp"===v.precision?"#define HIGH_PRECISION":"","#define SHADER_NAME "+r.name,ra,v.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define GAMMA_FACTOR "+ha,"#define MAX_BONES "+v.maxBones,v.useFog&&
v.fog?"#define USE_FOG":"",v.useFog&&v.fogExp2?"#define FOG_EXP2":"",v.map?"#define USE_MAP":"",v.envMap?"#define USE_ENVMAP":"",v.envMap?"#define "+V:"",v.lightMap?"#define USE_LIGHTMAP":"",v.aoMap?"#define USE_AOMAP":"",v.emissiveMap?"#define USE_EMISSIVEMAP":"",v.bumpMap?"#define USE_BUMPMAP":"",v.normalMap?"#define USE_NORMALMAP":"",v.normalMap&&v.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",v.normalMap&&v.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",v.clearcoatNormalMap?
"#define USE_CLEARCOAT_NORMALMAP":"",v.displacementMap&&v.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",v.specularMap?"#define USE_SPECULARMAP":"",v.roughnessMap?"#define USE_ROUGHNESSMAP":"",v.metalnessMap?"#define USE_METALNESSMAP":"",v.alphaMap?"#define USE_ALPHAMAP":"",v.vertexTangents?"#define USE_TANGENT":"",v.vertexColors?"#define USE_COLOR":"",v.vertexUvs?"#define USE_UV":"",v.flatShading?"#define FLAT_SHADED":"",v.skinning?"#define USE_SKINNING":"",v.useVertexTexture?"#define BONE_TEXTURE":
"",v.morphTargets?"#define USE_MORPHTARGETS":"",v.morphNormals&&!1===v.flatShading?"#define USE_MORPHNORMALS":"",v.doubleSided?"#define DOUBLE_SIDED":"",v.flipSided?"#define FLIP_SIDED":"",v.shadowMapEnabled?"#define USE_SHADOWMAP":"",v.shadowMapEnabled?"#define "+R:"",v.sizeAttenuation?"#define USE_SIZEATTENUATION":"",v.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",v.logarithmicDepthBuffer&&(z.isWebGL2||c.get("EXT_frag_depth"))?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;",
"uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","\tattribute vec4 tangent;","#endif","#ifdef USE_COLOR","\tattribute vec3 color;","#endif","#ifdef USE_MORPHTARGETS","\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(uf).join("\n"),c=[fa,"precision "+v.precision+" float;","precision "+v.precision+" int;","highp"===v.precision?"#define HIGH_PRECISION":
"","#define SHADER_NAME "+r.name,ra,v.alphaTest?"#define ALPHATEST "+v.alphaTest+(v.alphaTest%1?"":".0"):"","#define GAMMA_FACTOR "+ha,v.useFog&&v.fog?"#define USE_FOG":"",v.useFog&&v.fogExp2?"#define FOG_EXP2":"",v.map?"#define USE_MAP":"",v.matcap?"#define USE_MATCAP":"",v.envMap?"#define USE_ENVMAP":"",v.envMap?"#define "+S:"",v.envMap?"#define "+V:"",v.envMap?"#define "+W:"",v.lightMap?"#define USE_LIGHTMAP":"",v.aoMap?"#define USE_AOMAP":"",v.emissiveMap?"#define USE_EMISSIVEMAP":"",v.bumpMap?
"#define USE_BUMPMAP":"",v.normalMap?"#define USE_NORMALMAP":"",v.normalMap&&v.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",v.normalMap&&v.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",v.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",v.specularMap?"#define USE_SPECULARMAP":"",v.roughnessMap?"#define USE_ROUGHNESSMAP":"",v.metalnessMap?"#define USE_METALNESSMAP":"",v.alphaMap?"#define USE_ALPHAMAP":"",v.sheen?"#define USE_SHEEN":"",v.vertexTangents?"#define USE_TANGENT":
"",v.vertexColors?"#define USE_COLOR":"",v.vertexUvs?"#define USE_UV":"",v.gradientMap?"#define USE_GRADIENTMAP":"",v.flatShading?"#define FLAT_SHADED":"",v.doubleSided?"#define DOUBLE_SIDED":"",v.flipSided?"#define FLIP_SIDED":"",v.shadowMapEnabled?"#define USE_SHADOWMAP":"",v.shadowMapEnabled?"#define "+R:"",v.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",v.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",v.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",v.logarithmicDepthBuffer&&
(z.isWebGL2||c.get("EXT_frag_depth"))?"#define USE_LOGDEPTHBUF_EXT":"",(g.extensions&&g.extensions.shaderTextureLOD||v.envMap)&&(z.isWebGL2||c.get("EXT_shader_texture_lod"))?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;",0!==v.toneMapping?"#define TONE_MAPPING":"",0!==v.toneMapping?rb.tonemapping_pars_fragment:"",0!==v.toneMapping?Fl("toneMapping",v.toneMapping):"",v.dithering?"#define DITHERING":"",v.outputEncoding||v.mapEncoding||v.matcapEncoding||v.envMapEncoding||
v.emissiveMapEncoding?rb.encodings_pars_fragment:"",v.mapEncoding?ug("mapTexelToLinear",v.mapEncoding):"",v.matcapEncoding?ug("matcapTexelToLinear",v.matcapEncoding):"",v.envMapEncoding?ug("envMapTexelToLinear",v.envMapEncoding):"",v.emissiveMapEncoding?ug("emissiveMapTexelToLinear",v.emissiveMapEncoding):"",v.outputEncoding?El("linearToOutputTexel",v.outputEncoding):"",v.depthPacking?"#define DEPTH_PACKING "+g.depthPacking:"","\n"].filter(uf).join("\n"));J=Mh(J);J=qj(J,v);J=rj(J,v);P=Mh(P);P=qj(P,
v);P=rj(P,v);J=sj(J);P=sj(P);z.isWebGL2&&!g.isRawShaderMaterial&&(z=!1,R=/^\s*#version\s+300\s+es\s*\n/,g.isShaderMaterial&&null!==J.match(R)&&null!==P.match(R)&&(z=!0,J=J.replace(R,""),P=P.replace(R,"")),F="#version 300 es\n\n#define attribute in\n#define varying out\n#define texture2D texture\n"+F,c=["#version 300 es\n\n#define varying in",z?"":"out highp vec4 pc_fragColor;",z?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth\n#define texture2D texture\n#define textureCube texture\n#define texture2DProj textureProj\n#define texture2DLodEXT textureLod\n#define texture2DProjLodEXT textureProjLod\n#define textureCubeLodEXT textureLod\n#define texture2DGradEXT textureGrad\n#define texture2DProjGradEXT textureProjGrad\n#define textureCubeGradEXT textureGrad"].join("\n")+
"\n"+c);P=c+P;J=nj(E,35633,F+J);P=nj(E,35632,P);E.attachShader(pa,J);E.attachShader(pa,P);void 0!==g.index0AttributeName?E.bindAttribLocation(pa,0,g.index0AttributeName):!0===v.morphTargets&&E.bindAttribLocation(pa,0,"position");E.linkProgram(pa);if(a.debug.checkShaderErrors){a=E.getProgramInfoLog(pa).trim();v=E.getShaderInfoLog(J).trim();z=E.getShaderInfoLog(P).trim();S=R=!0;if(!1===E.getProgramParameter(pa,35714))R=!1,V=pj(E,J,"vertex"),W=pj(E,P,"fragment"),console.error("THREE.WebGLProgram: shader error: ",
E.getError(),"35715",E.getProgramParameter(pa,35715),"gl.getProgramInfoLog",a,V,W);else if(""!==a)console.warn("THREE.WebGLProgram: gl.getProgramInfoLog()",a);else if(""===v||""===z)S=!1;S&&(this.diagnostics={runnable:R,material:g,programLog:a,vertexShader:{log:v,prefix:F},fragmentShader:{log:z,prefix:c}})}E.deleteShader(J);E.deleteShader(P);var qa;this.getUniforms=function(){void 0===qa&&(qa=new ud(E,pa));return qa};var ua;this.getAttributes=function(){void 0===ua&&(ua=Il(E,pa));return ua};this.destroy=
function(){E.deleteProgram(pa);this.program=void 0};this.name=r.name;this.id=Kl++;this.code=e;this.usedTimes=1;this.program=pa;this.vertexShader=J;this.fragmentShader=P;return this}function Ll(a,c,e){function g(F){F=F.skeleton.bones;if(e.floatVertexTextures)return 1024;var J=Math.min(Math.floor((e.maxVertexUniforms-20)/4),F.length);return J<F.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+F.length+" bones. This GPU supports "+J+"."),0):J}function r(F,J){if(F)F.isTexture?P=F.encoding:F.isWebGLRenderTarget&&
(console.warn("THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead."),P=F.texture.encoding);else var P=3E3;3E3===P&&J&&(P=3007);return P}var v=[],z={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"phong",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",
LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"},E="precision supportsVertexTextures map mapEncoding matcap matcapEncoding envMap envMapMode envMapEncoding lightMap aoMap emissiveMap emissiveMapEncoding bumpMap normalMap objectSpaceNormalMap tangentSpaceNormalMap clearcoatNormalMap displacementMap specularMap roughnessMap metalnessMap gradientMap alphaMap combine vertexColors vertexTangents fog useFog fogExp2 flatShading sizeAttenuation logarithmicDepthBuffer skinning maxBones useVertexTexture morphTargets morphNormals maxMorphTargets maxMorphNormals premultipliedAlpha numDirLights numPointLights numSpotLights numHemiLights numRectAreaLights shadowMapEnabled shadowMapType toneMapping physicallyCorrectLights alphaTest doubleSided flipSided numClippingPlanes numClipIntersection depthPacking dithering sheen".split(" ");
this.getParameters=function(F,J,P,R,S,V,W){var ha=z[F.type],fa=W.isSkinnedMesh?g(W):0,ra=e.precision;null!==F.precision&&(ra=e.getMaxPrecision(F.precision),ra!==F.precision&&console.warn("THREE.WebGLProgram.getParameters:",F.precision,"not supported, using",ra,"instead."));var pa=a.getRenderTarget();return{shaderID:ha,precision:ra,supportsVertexTextures:e.vertexTextures,outputEncoding:r(pa?pa.texture:null,a.gammaOutput),map:!!F.map,mapEncoding:r(F.map,a.gammaInput),matcap:!!F.matcap,matcapEncoding:r(F.matcap,
a.gammaInput),envMap:!!F.envMap,envMapMode:F.envMap&&F.envMap.mapping,envMapEncoding:r(F.envMap,a.gammaInput),envMapCubeUV:!!F.envMap&&(306===F.envMap.mapping||307===F.envMap.mapping),lightMap:!!F.lightMap,aoMap:!!F.aoMap,emissiveMap:!!F.emissiveMap,emissiveMapEncoding:r(F.emissiveMap,a.gammaInput),bumpMap:!!F.bumpMap,normalMap:!!F.normalMap,objectSpaceNormalMap:1===F.normalMapType,tangentSpaceNormalMap:0===F.normalMapType,clearcoatNormalMap:!!F.clearcoatNormalMap,displacementMap:!!F.displacementMap,
roughnessMap:!!F.roughnessMap,metalnessMap:!!F.metalnessMap,specularMap:!!F.specularMap,alphaMap:!!F.alphaMap,gradientMap:!!F.gradientMap,sheen:!!F.sheen,combine:F.combine,vertexTangents:F.normalMap&&F.vertexTangents,vertexColors:F.vertexColors,vertexUvs:!!F.map||!!F.bumpMap||!!F.normalMap||!!F.specularMap||!!F.alphaMap||!!F.emissiveMap||!!F.roughnessMap||!!F.metalnessMap||!!F.clearcoatNormalMap,fog:!!R,useFog:F.fog,fogExp2:R&&R.isFogExp2,flatShading:F.flatShading,sizeAttenuation:F.sizeAttenuation,
logarithmicDepthBuffer:e.logarithmicDepthBuffer,skinning:F.skinning&&0<fa,maxBones:fa,useVertexTexture:e.floatVertexTextures,morphTargets:F.morphTargets,morphNormals:F.morphNormals,maxMorphTargets:a.maxMorphTargets,maxMorphNormals:a.maxMorphNormals,numDirLights:J.directional.length,numPointLights:J.point.length,numSpotLights:J.spot.length,numRectAreaLights:J.rectArea.length,numHemiLights:J.hemi.length,numDirLightShadows:J.directionalShadowMap.length,numPointLightShadows:J.pointShadowMap.length,numSpotLightShadows:J.spotShadowMap.length,
numClippingPlanes:S,numClipIntersection:V,dithering:F.dithering,shadowMapEnabled:a.shadowMap.enabled&&W.receiveShadow&&0<P.length,shadowMapType:a.shadowMap.type,toneMapping:F.toneMapped?a.toneMapping:0,physicallyCorrectLights:a.physicallyCorrectLights,premultipliedAlpha:F.premultipliedAlpha,alphaTest:F.alphaTest,doubleSided:2===F.side,flipSided:1===F.side,depthPacking:void 0!==F.depthPacking?F.depthPacking:!1}};this.getProgramCode=function(F,J){var P=[];J.shaderID?P.push(J.shaderID):(P.push(F.fragmentShader),
P.push(F.vertexShader));if(void 0!==F.defines)for(var R in F.defines)P.push(R),P.push(F.defines[R]);for(R=0;R<E.length;R++)P.push(J[E[R]]);P.push(F.onBeforeCompile.toString());P.push(a.gammaOutput);P.push(a.gammaFactor);return P.join()};this.acquireProgram=function(F,J,P,R){for(var S,V=0,W=v.length;V<W;V++){var ha=v[V];if(ha.code===R){S=ha;++S.usedTimes;break}}void 0===S&&(S=new Jl(a,c,R,F,J,P,e),v.push(S));return S};this.releaseProgram=function(F){0===--F.usedTimes&&(v[v.indexOf(F)]=v[v.length-1],
v.pop(),F.destroy())};this.programs=v}function Ml(){var a=new WeakMap;return{get:function(c){var e=a.get(c);void 0===e&&(e={},a.set(c,e));return e},remove:function(c){a.delete(c)},update:function(c,e,g){a.get(c)[e]=g},dispose:function(){a=new WeakMap}}}function Nl(a,c){return a.groupOrder!==c.groupOrder?a.groupOrder-c.groupOrder:a.renderOrder!==c.renderOrder?a.renderOrder-c.renderOrder:a.program!==c.program?a.program.id-c.program.id:a.material.id!==c.material.id?a.material.id-c.material.id:a.z!==
c.z?a.z-c.z:a.id-c.id}function Ol(a,c){return a.groupOrder!==c.groupOrder?a.groupOrder-c.groupOrder:a.renderOrder!==c.renderOrder?a.renderOrder-c.renderOrder:a.z!==c.z?c.z-a.z:a.id-c.id}function tj(){function a(z,E,F,J,P,R){var S=c[e];void 0===S?(S={id:z.id,object:z,geometry:E,material:F,program:F.program||v,groupOrder:J,renderOrder:z.renderOrder,z:P,group:R},c[e]=S):(S.id=z.id,S.object=z,S.geometry=E,S.material=F,S.program=F.program||v,S.groupOrder=J,S.renderOrder=z.renderOrder,S.z=P,S.group=R);
e++;return S}var c=[],e=0,g=[],r=[],v={id:-1};return{opaque:g,transparent:r,init:function(){e=0;g.length=0;r.length=0},push:function(z,E,F,J,P,R){z=a(z,E,F,J,P,R);(!0===F.transparent?r:g).push(z)},unshift:function(z,E,F,J,P,R){z=a(z,E,F,J,P,R);(!0===F.transparent?r:g).unshift(z)},sort:function(){1<g.length&&g.sort(Nl);1<r.length&&r.sort(Ol)}}}function Pl(){function a(e){e=e.target;e.removeEventListener("dispose",a);c.delete(e)}var c=new WeakMap;return{get:function(e,g){var r=c.get(e);if(void 0===
r){var v=new tj;c.set(e,new WeakMap);c.get(e).set(g,v);e.addEventListener("dispose",a)}else v=r.get(g),void 0===v&&(v=new tj,r.set(g,v));return v},dispose:function(){c=new WeakMap}}}function Ql(){var a={};return{get:function(c){if(void 0!==a[c.id])return a[c.id];switch(c.type){case "DirectionalLight":var e={direction:new k,color:new I,shadow:!1,shadowBias:0,shadowRadius:1,shadowMapSize:new f};break;case "SpotLight":e={position:new k,direction:new k,color:new I,distance:0,coneCos:0,penumbraCos:0,decay:0,
shadow:!1,shadowBias:0,shadowRadius:1,shadowMapSize:new f};break;case "PointLight":e={position:new k,color:new I,distance:0,decay:0,shadow:!1,shadowBias:0,shadowRadius:1,shadowMapSize:new f,shadowCameraNear:1,shadowCameraFar:1E3};break;case "HemisphereLight":e={direction:new k,skyColor:new I,groundColor:new I};break;case "RectAreaLight":e={color:new I,position:new k,halfWidth:new k,halfHeight:new k}}return a[c.id]=e}}}function Rl(a,c){return(c.castShadow?1:0)-(a.castShadow?1:0)}function Sl(){for(var a=
new Ql,c={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:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],point:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[],numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},e=0;9>e;e++)c.probe.push(new k);var g=new k,r=new q,v=new q;return{setup:function(z,
E,F){for(var J=0,P=0,R=0,S=0;9>S;S++)c.probe[S].set(0,0,0);var V=E=0,W=0,ha=0,fa=0,ra=0,pa=0,qa=0;F=F.matrixWorldInverse;z.sort(Rl);S=0;for(var ua=z.length;S<ua;S++){var oa=z[S],ta=oa.color,Ba=oa.intensity,Ta=oa.distance,Ua=oa.shadow&&oa.shadow.map?oa.shadow.map.texture:null;if(oa.isAmbientLight)J+=ta.r*Ba,P+=ta.g*Ba,R+=ta.b*Ba;else if(oa.isLightProbe)for(Ua=0;9>Ua;Ua++)c.probe[Ua].addScaledVector(oa.sh.coefficients[Ua],Ba);else if(oa.isDirectionalLight){var Ca=a.get(oa);Ca.color.copy(oa.color).multiplyScalar(oa.intensity);
Ca.direction.setFromMatrixPosition(oa.matrixWorld);g.setFromMatrixPosition(oa.target.matrixWorld);Ca.direction.sub(g);Ca.direction.transformDirection(F);if(Ca.shadow=oa.castShadow)Ba=oa.shadow,Ca.shadowBias=Ba.bias,Ca.shadowRadius=Ba.radius,Ca.shadowMapSize=Ba.mapSize,c.directionalShadowMap[E]=Ua,c.directionalShadowMatrix[E]=oa.shadow.matrix,ra++;c.directional[E]=Ca;E++}else if(oa.isSpotLight){Ca=a.get(oa);Ca.position.setFromMatrixPosition(oa.matrixWorld);Ca.position.applyMatrix4(F);Ca.color.copy(ta).multiplyScalar(Ba);
Ca.distance=Ta;Ca.direction.setFromMatrixPosition(oa.matrixWorld);g.setFromMatrixPosition(oa.target.matrixWorld);Ca.direction.sub(g);Ca.direction.transformDirection(F);Ca.coneCos=Math.cos(oa.angle);Ca.penumbraCos=Math.cos(oa.angle*(1-oa.penumbra));Ca.decay=oa.decay;if(Ca.shadow=oa.castShadow)Ba=oa.shadow,Ca.shadowBias=Ba.bias,Ca.shadowRadius=Ba.radius,Ca.shadowMapSize=Ba.mapSize,c.spotShadowMap[W]=Ua,c.spotShadowMatrix[W]=oa.shadow.matrix,qa++;c.spot[W]=Ca;W++}else if(oa.isRectAreaLight)Ca=a.get(oa),
Ca.color.copy(ta).multiplyScalar(Ba),Ca.position.setFromMatrixPosition(oa.matrixWorld),Ca.position.applyMatrix4(F),v.identity(),r.copy(oa.matrixWorld),r.premultiply(F),v.extractRotation(r),Ca.halfWidth.set(.5*oa.width,0,0),Ca.halfHeight.set(0,.5*oa.height,0),Ca.halfWidth.applyMatrix4(v),Ca.halfHeight.applyMatrix4(v),c.rectArea[ha]=Ca,ha++;else if(oa.isPointLight){Ca=a.get(oa);Ca.position.setFromMatrixPosition(oa.matrixWorld);Ca.position.applyMatrix4(F);Ca.color.copy(oa.color).multiplyScalar(oa.intensity);
Ca.distance=oa.distance;Ca.decay=oa.decay;if(Ca.shadow=oa.castShadow)Ba=oa.shadow,Ca.shadowBias=Ba.bias,Ca.shadowRadius=Ba.radius,Ca.shadowMapSize=Ba.mapSize,Ca.shadowCameraNear=Ba.camera.near,Ca.shadowCameraFar=Ba.camera.far,c.pointShadowMap[V]=Ua,c.pointShadowMatrix[V]=oa.shadow.matrix,pa++;c.point[V]=Ca;V++}else oa.isHemisphereLight&&(Ca=a.get(oa),Ca.direction.setFromMatrixPosition(oa.matrixWorld),Ca.direction.transformDirection(F),Ca.direction.normalize(),Ca.skyColor.copy(oa.color).multiplyScalar(Ba),
Ca.groundColor.copy(oa.groundColor).multiplyScalar(Ba),c.hemi[fa]=Ca,fa++)}c.ambient[0]=J;c.ambient[1]=P;c.ambient[2]=R;z=c.hash;if(z.directionalLength!==E||z.pointLength!==V||z.spotLength!==W||z.rectAreaLength!==ha||z.hemiLength!==fa||z.numDirectionalShadows!==ra||z.numPointShadows!==pa||z.numSpotShadows!==qa)c.directional.length=E,c.spot.length=W,c.rectArea.length=ha,c.point.length=V,c.hemi.length=fa,c.directionalShadowMap.length=ra,c.pointShadowMap.length=pa,c.spotShadowMap.length=qa,c.directionalShadowMatrix.length=
ra,c.pointShadowMatrix.length=pa,c.spotShadowMatrix.length=qa,z.directionalLength=E,z.pointLength=V,z.spotLength=W,z.rectAreaLength=ha,z.hemiLength=fa,z.numDirectionalShadows=ra,z.numPointShadows=pa,z.numSpotShadows=qa,c.version=Tl++},state:c}}function uj(){var a=new Sl,c=[],e=[];return{init:function(){c.length=0;e.length=0},state:{lightsArray:c,shadowsArray:e,lights:a},setupLights:function(g){a.setup(c,e,g)},pushLight:function(g){c.push(g)},pushShadow:function(g){e.push(g)}}}function Ul(){function a(e){e=
e.target;e.removeEventListener("dispose",a);c.delete(e)}var c=new WeakMap;return{get:function(e,g){if(!1===c.has(e)){var r=new uj;c.set(e,new WeakMap);c.get(e).set(g,r);e.addEventListener("dispose",a)}else!1===c.get(e).has(g)?(r=new uj,c.get(e).set(g,r)):r=c.get(e).get(g);return r},dispose:function(){c=new WeakMap}}}function vd(a){M.call(this);this.type="MeshDepthMaterial";this.depthPacking=3200;this.morphTargets=this.skinning=!1;this.displacementMap=this.alphaMap=this.map=null;this.displacementScale=
1;this.displacementBias=0;this.wireframe=!1;this.wireframeLinewidth=1;this.lights=this.fog=!1;this.setValues(a)}function wd(a){M.call(this);this.type="MeshDistanceMaterial";this.referencePosition=new k;this.nearDistance=1;this.farDistance=1E3;this.morphTargets=this.skinning=!1;this.displacementMap=this.alphaMap=this.map=null;this.displacementScale=1;this.displacementBias=0;this.lights=this.fog=!1;this.setValues(a)}function vj(a,c,e){function g(ta,Ba){var Ta=c.update(ra);W.uniforms.shadow_pass.value=
ta.map.texture;W.uniforms.resolution.value=ta.mapSize;W.uniforms.radius.value=ta.radius;a.setRenderTarget(ta.mapPass);a.clear();a.renderBufferDirect(Ba,null,Ta,W,ra,null);ha.uniforms.shadow_pass.value=ta.mapPass.texture;ha.uniforms.resolution.value=ta.mapSize;ha.uniforms.radius.value=ta.radius;a.setRenderTarget(ta.map);a.clear();a.renderBufferDirect(Ba,null,Ta,ha,ra,null)}function r(ta,Ba,Ta,Ua,Ca,Ha){var Da=ta.geometry;var Ma=P;var db=ta.customDepthMaterial;Ta.isPointLight&&(Ma=R,db=ta.customDistanceMaterial);
db?Ma=db:(db=!1,Ba.morphTargets&&(Da&&Da.isBufferGeometry?db=Da.morphAttributes&&Da.morphAttributes.position&&0<Da.morphAttributes.position.length:Da&&Da.isGeometry&&(db=Da.morphTargets&&0<Da.morphTargets.length)),ta.isSkinnedMesh&&!1===Ba.skinning&&console.warn("THREE.WebGLShadowMap: THREE.SkinnedMesh with material.skinning set to false:",ta),ta=ta.isSkinnedMesh&&Ba.skinning,Da=0,db&&(Da|=1),ta&&(Da|=2),Ma=Ma[Da]);a.localClippingEnabled&&!0===Ba.clipShadows&&0!==Ba.clippingPlanes.length&&(Da=Ma.uuid,
db=Ba.uuid,ta=S[Da],void 0===ta&&(ta={},S[Da]=ta),Da=ta[db],void 0===Da&&(Da=Ma.clone(),ta[db]=Da),Ma=Da);Ma.visible=Ba.visible;Ma.wireframe=Ba.wireframe;Ma.side=3===Ha?null!=Ba.shadowSide?Ba.shadowSide:Ba.side:null!=Ba.shadowSide?Ba.shadowSide:V[Ba.side];Ma.clipShadows=Ba.clipShadows;Ma.clippingPlanes=Ba.clippingPlanes;Ma.clipIntersection=Ba.clipIntersection;Ma.wireframeLinewidth=Ba.wireframeLinewidth;Ma.linewidth=Ba.linewidth;Ta.isPointLight&&Ma.isMeshDistanceMaterial&&(Ma.referencePosition.setFromMatrixPosition(Ta.matrixWorld),
Ma.nearDistance=Ua,Ma.farDistance=Ca);return Ma}function v(ta,Ba,Ta,Ua,Ca){if(!1!==ta.visible){if(ta.layers.test(Ba.layers)&&(ta.isMesh||ta.isLine||ta.isPoints)&&(ta.castShadow||ta.receiveShadow&&3===Ca)&&(!ta.frustumCulled||z.intersectsObject(ta))){ta.modelViewMatrix.multiplyMatrices(Ta.matrixWorldInverse,ta.matrixWorld);var Ha=c.update(ta),Da=ta.material;if(Array.isArray(Da))for(var Ma=Ha.groups,db=0,tb=Ma.length;db<tb;db++){var Ka=Ma[db],bb=Da[Ka.materialIndex];bb&&bb.visible&&(bb=r(ta,bb,Ua,Ta.near,
Ta.far,Ca),a.renderBufferDirect(Ta,null,Ha,bb,ta,Ka))}else Da.visible&&(bb=r(ta,Da,Ua,Ta.near,Ta.far,Ca),a.renderBufferDirect(Ta,null,Ha,bb,ta,null))}ta=ta.children;Ha=0;for(Da=ta.length;Ha<Da;Ha++)v(ta[Ha],Ba,Ta,Ua,Ca)}}var z=new ic,E=new f,F=new f,J=new p,P=Array(4),R=Array(4),S={},V={0:1,1:0,2:2},W=new qb({defines:{SAMPLE_RATE:.25,HALF_SAMPLE_RATE:.125},uniforms:{shadow_pass:{value:null},resolution:{value:new f},radius:{value:4}},vertexShader:"void main() {\n\tgl_Position \x3d vec4( position, 1.0 );\n}",
fragmentShader:"uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include \x3cpacking\x3e\nvoid main() {\n  float mean \x3d 0.0;\n  float squared_mean \x3d 0.0;\n  \n\tfloat depth \x3d unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy  ) / resolution ) );\n  for ( float i \x3d -1.0; i \x3c 1.0 ; i +\x3d SAMPLE_RATE) {\n    #ifdef HORIZONAL_PASS\n      vec2 distribution \x3d decodeHalfRGBA ( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( i, 0.0 ) * radius ) / resolution ) );\n      mean +\x3d distribution.x;\n      squared_mean +\x3d distribution.y * distribution.y + distribution.x * distribution.x;\n    #else\n      float depth \x3d unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0,  i )  * radius ) / resolution ) );\n      mean +\x3d depth;\n      squared_mean +\x3d depth * depth;\n    #endif\n  }\n  mean \x3d mean * HALF_SAMPLE_RATE;\n  squared_mean \x3d squared_mean * HALF_SAMPLE_RATE;\n  float std_dev \x3d pow( squared_mean - mean * mean, 0.5 );\n  gl_FragColor \x3d encodeHalfRGBA( vec2( mean, std_dev ) );\n}"}),
ha=W.clone();ha.defines.HORIZONAL_PASS=1;var fa=new va;fa.addAttribute("position",new Q(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));var ra=new xa(fa,W);for(fa=0;4!==fa;++fa){var pa=0!==(fa&1),qa=0!==(fa&2),ua=new vd({depthPacking:3201,morphTargets:pa,skinning:qa});P[fa]=ua;pa=new wd({morphTargets:pa,skinning:qa});R[fa]=pa}var oa=this;this.enabled=!1;this.autoUpdate=!0;this.needsUpdate=!1;this.type=1;this.render=function(ta,Ba,Ta){if(!1!==oa.enabled&&(!1!==oa.autoUpdate||!1!==oa.needsUpdate)&&
0!==ta.length){var Ua=a.getRenderTarget(),Ca=a.getActiveCubeFace(),Ha=a.getActiveMipmapLevel(),Da=a.state;Da.setBlending(0);Da.buffers.color.setClear(1,1,1,1);Da.buffers.depth.setTest(!0);Da.setScissorTest(!1);for(var Ma=0,db=ta.length;Ma<db;Ma++){var tb=ta[Ma],Ka=tb.shadow;if(void 0===Ka)console.warn("THREE.WebGLShadowMap:",tb,"has no shadow.");else{E.copy(Ka.mapSize);var bb=Ka.getFrameExtents();E.multiply(bb);F.copy(Ka.mapSize);if(E.x>e||E.y>e)console.warn("THREE.WebGLShadowMap:",tb,"has shadow exceeding max texture size, reducing"),
E.x>e&&(F.x=Math.floor(e/bb.x),E.x=F.x*bb.x,Ka.mapSize.x=F.x),E.y>e&&(F.y=Math.floor(e/bb.y),E.y=F.y*bb.y,Ka.mapSize.y=F.y);null!==Ka.map||Ka.isPointLightShadow||3!==this.type||(bb={minFilter:1006,magFilter:1006,format:1023},Ka.map=new m(E.x,E.y,bb),Ka.map.texture.name=tb.name+".shadowMap",Ka.mapPass=new m(E.x,E.y,bb),Ka.camera.updateProjectionMatrix());null===Ka.map&&(bb={minFilter:1003,magFilter:1003,format:1023},Ka.map=new m(E.x,E.y,bb),Ka.map.texture.name=tb.name+".shadowMap",Ka.camera.updateProjectionMatrix());
a.setRenderTarget(Ka.map);a.clear();bb=Ka.getViewportCount();for(var jb=0;jb<bb;jb++){var Eb=Ka.getViewport(jb);J.set(F.x*Eb.x,F.y*Eb.y,F.x*Eb.z,F.y*Eb.w);Da.viewport(J);Ka.updateMatrices(tb,Ta,jb);z=Ka.getFrustum();v(Ba,Ta,Ka.camera,tb,this.type)}Ka.isPointLightShadow||3!==this.type||g(Ka,Ta)}}oa.needsUpdate=!1;a.setRenderTarget(Ua,Ca,Ha)}}}function Vl(a,c,e,g){function r(ja,Ga,La){var nb=new Uint8Array(4),Va=a.createTexture();a.bindTexture(ja,Va);a.texParameteri(ja,10241,9728);a.texParameteri(ja,
10240,9728);for(ja=0;ja<La;ja++)a.texImage2D(Ga+ja,0,6408,1,1,0,6408,5121,nb);return Va}function v(ja,Ga){ra[ja]=1;0===pa[ja]&&(a.enableVertexAttribArray(ja),pa[ja]=1);qa[ja]!==Ga&&((g.isWebGL2?a:c.get("ANGLE_instanced_arrays"))[g.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](ja,Ga),qa[ja]=Ga)}function z(ja){!0!==ua[ja]&&(a.enable(ja),ua[ja]=!0)}function E(ja){!1!==ua[ja]&&(a.disable(ja),ua[ja]=!1)}function F(ja,Ga,La,nb,Va,ib,kb,Qa){if(0===ja)Ba&&(E(3042),Ba=!1);else if(Ba||(z(3042),
Ba=!0),5!==ja){if(ja!==Ta||Qa!==tb){if(100!==Ua||100!==Da)a.blendEquation(32774),Da=Ua=100;if(Qa)switch(ja){case 1:a.blendFuncSeparate(1,771,1,771);break;case 2:a.blendFunc(1,1);break;case 3:a.blendFuncSeparate(0,0,769,771);break;case 4:a.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",ja)}else switch(ja){case 1:a.blendFuncSeparate(770,771,1,771);break;case 2:a.blendFunc(770,1);break;case 3:a.blendFunc(0,769);break;case 4:a.blendFunc(0,768);break;
default:console.error("THREE.WebGLState: Invalid blending: ",ja)}db=Ma=Ha=Ca=null;Ta=ja;tb=Qa}}else{Va=Va||Ga;ib=ib||La;kb=kb||nb;if(Ga!==Ua||Va!==Da)a.blendEquationSeparate(e.convert(Ga),e.convert(Va)),Ua=Ga,Da=Va;if(La!==Ca||nb!==Ha||ib!==Ma||kb!==db)a.blendFuncSeparate(e.convert(La),e.convert(nb),e.convert(ib),e.convert(kb)),Ca=La,Ha=nb,Ma=ib,db=kb;Ta=ja;tb=null}}function J(ja){Ka!==ja&&(ja?a.frontFace(2304):a.frontFace(2305),Ka=ja)}function P(ja){0!==ja?(z(2884),ja!==bb&&(1===ja?a.cullFace(1029):
2===ja?a.cullFace(1028):a.cullFace(1032))):E(2884);bb=ja}function R(ja,Ga,La){if(ja){if(z(32823),Eb!==Ga||xb!==La)a.polygonOffset(Ga,La),Eb=Ga,xb=La}else E(32823)}function S(ja){void 0===ja&&(ja=33984+ia-1);za!==ja&&(a.activeTexture(ja),za=ja)}var V=new function(){var ja=!1,Ga=new p,La=null,nb=new p(0,0,0,0);return{setMask:function(Va){La===Va||ja||(a.colorMask(Va,Va,Va,Va),La=Va)},setLocked:function(Va){ja=Va},setClear:function(Va,ib,kb,Qa,eb){!0===eb&&(Va*=Qa,ib*=Qa,kb*=Qa);Ga.set(Va,ib,kb,Qa);
!1===nb.equals(Ga)&&(a.clearColor(Va,ib,kb,Qa),nb.copy(Ga))},reset:function(){ja=!1;La=null;nb.set(-1,0,0,0)}}},W=new function(){var ja=!1,Ga=null,La=null,nb=null;return{setTest:function(Va){Va?z(2929):E(2929)},setMask:function(Va){Ga===Va||ja||(a.depthMask(Va),Ga=Va)},setFunc:function(Va){if(La!==Va){if(Va)switch(Va){case 0:a.depthFunc(512);break;case 1:a.depthFunc(519);break;case 2:a.depthFunc(513);break;case 3:a.depthFunc(515);break;case 4:a.depthFunc(514);break;case 5:a.depthFunc(518);break;case 6:a.depthFunc(516);
break;case 7:a.depthFunc(517);break;default:a.depthFunc(515)}else a.depthFunc(515);La=Va}},setLocked:function(Va){ja=Va},setClear:function(Va){nb!==Va&&(a.clearDepth(Va),nb=Va)},reset:function(){ja=!1;nb=La=Ga=null}}},ha=new function(){var ja=!1,Ga=null,La=null,nb=null,Va=null,ib=null,kb=null,Qa=null,eb=null;return{setTest:function(mb){ja||(mb?z(2960):E(2960))},setMask:function(mb){Ga===mb||ja||(a.stencilMask(mb),Ga=mb)},setFunc:function(mb,pb,sb){if(La!==mb||nb!==pb||Va!==sb)a.stencilFunc(mb,pb,
sb),La=mb,nb=pb,Va=sb},setOp:function(mb,pb,sb){if(ib!==mb||kb!==pb||Qa!==sb)a.stencilOp(mb,pb,sb),ib=mb,kb=pb,Qa=sb},setLocked:function(mb){ja=mb},setClear:function(mb){eb!==mb&&(a.clearStencil(mb),eb=mb)},reset:function(){ja=!1;eb=Qa=kb=ib=Va=nb=La=Ga=null}}},fa=a.getParameter(34921),ra=new Uint8Array(fa),pa=new Uint8Array(fa),qa=new Uint8Array(fa),ua={},oa=null,ta=null,Ba=null,Ta=null,Ua=null,Ca=null,Ha=null,Da=null,Ma=null,db=null,tb=!1,Ka=null,bb=null,jb=null,Eb=null,xb=null,ia=a.getParameter(35661),
na=!1;fa=0;fa=a.getParameter(7938);-1!==fa.indexOf("WebGL")?(fa=parseFloat(/^WebGL ([0-9])/.exec(fa)[1]),na=1<=fa):-1!==fa.indexOf("OpenGL ES")&&(fa=parseFloat(/^OpenGL ES ([0-9])/.exec(fa)[1]),na=2<=fa);var za=null,Ja={},Ya=new p,Na=new p,cb={};cb[3553]=r(3553,3553,1);cb[34067]=r(34067,34069,6);V.setClear(0,0,0,1);W.setClear(1);ha.setClear(0);z(2929);W.setFunc(3);J(!1);P(1);z(2884);F(0);return{buffers:{color:V,depth:W,stencil:ha},initAttributes:function(){for(var ja=0,Ga=ra.length;ja<Ga;ja++)ra[ja]=
0},enableAttribute:function(ja){v(ja,0)},enableAttributeAndDivisor:v,disableUnusedAttributes:function(){for(var ja=0,Ga=pa.length;ja!==Ga;++ja)pa[ja]!==ra[ja]&&(a.disableVertexAttribArray(ja),pa[ja]=0)},enable:z,disable:E,getCompressedTextureFormats:function(){if(null===oa&&(oa=[],c.get("WEBGL_compressed_texture_pvrtc")||c.get("WEBGL_compressed_texture_s3tc")||c.get("WEBGL_compressed_texture_etc1")||c.get("WEBGL_compressed_texture_astc")))for(var ja=a.getParameter(34467),Ga=0;Ga<ja.length;Ga++)oa.push(ja[Ga]);
return oa},useProgram:function(ja){return ta!==ja?(a.useProgram(ja),ta=ja,!0):!1},setBlending:F,setMaterial:function(ja,Ga){2===ja.side?E(2884):z(2884);var La=1===ja.side;Ga&&(La=!La);J(La);1===ja.blending&&!1===ja.transparent?F(0):F(ja.blending,ja.blendEquation,ja.blendSrc,ja.blendDst,ja.blendEquationAlpha,ja.blendSrcAlpha,ja.blendDstAlpha,ja.premultipliedAlpha);W.setFunc(ja.depthFunc);W.setTest(ja.depthTest);W.setMask(ja.depthWrite);V.setMask(ja.colorWrite);Ga=ja.stencilWrite;ha.setTest(Ga);Ga&&
(ha.setFunc(ja.stencilFunc,ja.stencilRef,ja.stencilMask),ha.setOp(ja.stencilFail,ja.stencilZFail,ja.stencilZPass));R(ja.polygonOffset,ja.polygonOffsetFactor,ja.polygonOffsetUnits)},setFlipSided:J,setCullFace:P,setLineWidth:function(ja){ja!==jb&&(na&&a.lineWidth(ja),jb=ja)},setPolygonOffset:R,setScissorTest:function(ja){ja?z(3089):E(3089)},activeTexture:S,bindTexture:function(ja,Ga){null===za&&S();var La=Ja[za];void 0===La&&(La={type:void 0,texture:void 0},Ja[za]=La);if(La.type!==ja||La.texture!==
Ga)a.bindTexture(ja,Ga||cb[ja]),La.type=ja,La.texture=Ga},compressedTexImage2D:function(){try{a.compressedTexImage2D.apply(a,arguments)}catch(ja){console.error("THREE.WebGLState:",ja)}},texImage2D:function(){try{a.texImage2D.apply(a,arguments)}catch(ja){console.error("THREE.WebGLState:",ja)}},texImage3D:function(){try{a.texImage3D.apply(a,arguments)}catch(ja){console.error("THREE.WebGLState:",ja)}},scissor:function(ja){!1===Ya.equals(ja)&&(a.scissor(ja.x,ja.y,ja.z,ja.w),Ya.copy(ja))},viewport:function(ja){!1===
Na.equals(ja)&&(a.viewport(ja.x,ja.y,ja.z,ja.w),Na.copy(ja))},reset:function(){for(var ja=0;ja<pa.length;ja++)1===pa[ja]&&(a.disableVertexAttribArray(ja),pa[ja]=0);ua={};za=oa=null;Ja={};bb=Ka=Ta=ta=null;V.reset();W.reset();ha.reset()}}}function Wl(a,c,e,g,r,v,z){function E(ia,na){return bb?new OffscreenCanvas(ia,na):document.createElementNS("http://www.w3.org/1999/xhtml","canvas")}function F(ia,na,za,Ja){var Ya=1;if(ia.width>Ja||ia.height>Ja)Ya=Ja/Math.max(ia.width,ia.height);if(1>Ya||!0===na){if("undefined"!==
typeof HTMLImageElement&&ia instanceof HTMLImageElement||"undefined"!==typeof HTMLCanvasElement&&ia instanceof HTMLCanvasElement||"undefined"!==typeof ImageBitmap&&ia instanceof ImageBitmap)return Ja=na?hb.floorPowerOfTwo:Math.floor,na=Ja(Ya*ia.width),Ya=Ja(Ya*ia.height),void 0===Ka&&(Ka=E(na,Ya)),za=za?E(na,Ya):Ka,za.width=na,za.height=Ya,za.getContext("2d").drawImage(ia,0,0,na,Ya),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+ia.width+"x"+ia.height+") to ("+na+"x"+Ya+")."),
za;"data"in ia&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+ia.width+"x"+ia.height+").")}return ia}function J(ia){return hb.isPowerOfTwo(ia.width)&&hb.isPowerOfTwo(ia.height)}function P(ia){return r.isWebGL2?!1:1001!==ia.wrapS||1001!==ia.wrapT||1003!==ia.minFilter&&1006!==ia.minFilter}function R(ia,na){return ia.generateMipmaps&&na&&1003!==ia.minFilter&&1006!==ia.minFilter}function S(ia,na,za,Ja){a.generateMipmap(ia);g.get(na).__maxMipLevel=Math.log(Math.max(za,Ja))*Math.LOG2E}
function V(ia,na){if(!r.isWebGL2)return ia;var za=ia;6403===ia&&(5126===na&&(za=33326),5131===na&&(za=33325),5121===na&&(za=33321));6407===ia&&(5126===na&&(za=34837),5131===na&&(za=34843),5121===na&&(za=32849));6408===ia&&(5126===na&&(za=34836),5131===na&&(za=34842),5121===na&&(za=32856));33325===za||33326===za||34842===za||34836===za?c.get("EXT_color_buffer_float"):(34843===za||34837===za)&&console.warn("THREE.WebGLRenderer: Floating point textures with RGB format not supported. Please use RGBA instead.");
return za}function W(ia){return 1003===ia||1004===ia||1005===ia?9728:9729}function ha(ia){ia=ia.target;ia.removeEventListener("dispose",ha);ra(ia);ia.isVideoTexture&&tb.delete(ia);z.memory.textures--}function fa(ia){ia=ia.target;ia.removeEventListener("dispose",fa);pa(ia);z.memory.textures--}function ra(ia){var na=g.get(ia);void 0!==na.__webglInit&&(a.deleteTexture(na.__webglTexture),g.remove(ia))}function pa(ia){var na=g.get(ia),za=g.get(ia.texture);if(ia){void 0!==za.__webglTexture&&a.deleteTexture(za.__webglTexture);
ia.depthTexture&&ia.depthTexture.dispose();if(ia.isWebGLRenderTargetCube)for(za=0;6>za;za++)a.deleteFramebuffer(na.__webglFramebuffer[za]),na.__webglDepthbuffer&&a.deleteRenderbuffer(na.__webglDepthbuffer[za]);else a.deleteFramebuffer(na.__webglFramebuffer),na.__webglDepthbuffer&&a.deleteRenderbuffer(na.__webglDepthbuffer);g.remove(ia.texture);g.remove(ia)}}function qa(ia,na){var za=g.get(ia);ia.isVideoTexture&&db(ia);if(0<ia.version&&za.__version!==ia.version){var Ja=ia.image;if(void 0===Ja)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");
else if(!1===Ja.complete)console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete");else{Ta(za,ia,na);return}}e.activeTexture(33984+na);e.bindTexture(3553,za.__webglTexture)}function ua(ia,na){if(6===ia.image.length){var za=g.get(ia);if(0<ia.version&&za.__version!==ia.version){Ba(za,ia);e.activeTexture(33984+na);e.bindTexture(34067,za.__webglTexture);a.pixelStorei(37440,ia.flipY);var Ja=ia&&ia.isCompressedTexture;na=ia.image[0]&&ia.image[0].isDataTexture;for(var Ya=[],
Na=0;6>Na;Na++)Ya[Na]=Ja||na?na?ia.image[Na].image:ia.image[Na]:F(ia.image[Na],!1,!0,r.maxCubemapSize);var cb=Ya[0],ja=J(cb)||r.isWebGL2,Ga=v.convert(ia.format),La=v.convert(ia.type),nb=V(Ga,La);ta(34067,ia,ja);if(Ja){for(Na=0;6>Na;Na++){var Va=Ya[Na].mipmaps;for(Ja=0;Ja<Va.length;Ja++){var ib=Va[Ja];1023!==ia.format&&1022!==ia.format?-1<e.getCompressedTextureFormats().indexOf(Ga)?e.compressedTexImage2D(34069+Na,Ja,nb,ib.width,ib.height,0,ib.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):
e.texImage2D(34069+Na,Ja,nb,ib.width,ib.height,0,Ga,La,ib.data)}}za.__maxMipLevel=Va.length-1}else{Va=ia.mipmaps;for(Na=0;6>Na;Na++)if(na)for(e.texImage2D(34069+Na,0,nb,Ya[Na].width,Ya[Na].height,0,Ga,La,Ya[Na].data),Ja=0;Ja<Va.length;Ja++)ib=Va[Ja],ib=ib.image[Na].image,e.texImage2D(34069+Na,Ja+1,nb,ib.width,ib.height,0,Ga,La,ib.data);else for(e.texImage2D(34069+Na,0,nb,Ga,La,Ya[Na]),Ja=0;Ja<Va.length;Ja++)ib=Va[Ja],e.texImage2D(34069+Na,Ja+1,nb,Ga,La,ib.image[Na]);za.__maxMipLevel=Va.length}R(ia,
ja)&&S(34067,ia,cb.width,cb.height);za.__version=ia.version;if(ia.onUpdate)ia.onUpdate(ia)}else e.activeTexture(33984+na),e.bindTexture(34067,za.__webglTexture)}}function oa(ia,na){e.activeTexture(33984+na);e.bindTexture(34067,g.get(ia).__webglTexture)}function ta(ia,na,za){za?(a.texParameteri(ia,10242,v.convert(na.wrapS)),a.texParameteri(ia,10243,v.convert(na.wrapT)),32879!==ia&&35866!==ia||a.texParameteri(ia,32882,v.convert(na.wrapR)),a.texParameteri(ia,10240,v.convert(na.magFilter)),a.texParameteri(ia,
10241,v.convert(na.minFilter))):(a.texParameteri(ia,10242,33071),a.texParameteri(ia,10243,33071),32879!==ia&&35866!==ia||a.texParameteri(ia,32882,33071),1001===na.wrapS&&1001===na.wrapT||console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),a.texParameteri(ia,10240,W(na.magFilter)),a.texParameteri(ia,10241,W(na.minFilter)),1003!==na.minFilter&&1006!==na.minFilter&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter."));
!(za=c.get("EXT_texture_filter_anisotropic"))||1015===na.type&&null===c.get("OES_texture_float_linear")||1016===na.type&&null===(r.isWebGL2||c.get("OES_texture_half_float_linear"))||!(1<na.anisotropy||g.get(na).__currentAnisotropy)||(a.texParameterf(ia,za.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(na.anisotropy,r.getMaxAnisotropy())),g.get(na).__currentAnisotropy=na.anisotropy)}function Ba(ia,na){void 0===ia.__webglInit&&(ia.__webglInit=!0,na.addEventListener("dispose",ha),ia.__webglTexture=a.createTexture(),
z.memory.textures++)}function Ta(ia,na,za){var Ja=3553;na.isDataTexture2DArray&&(Ja=35866);na.isDataTexture3D&&(Ja=32879);Ba(ia,na);e.activeTexture(33984+za);e.bindTexture(Ja,ia.__webglTexture);a.pixelStorei(37440,na.flipY);a.pixelStorei(37441,na.premultiplyAlpha);a.pixelStorei(3317,na.unpackAlignment);za=P(na)&&!1===J(na.image);za=F(na.image,za,!1,r.maxTextureSize);var Ya=J(za)||r.isWebGL2,Na=v.convert(na.format),cb=v.convert(na.type),ja=V(Na,cb);ta(Ja,na,Ya);var Ga=na.mipmaps;if(na.isDepthTexture){ja=
6402;if(1015===na.type){if(!r.isWebGL2)throw Error("Float Depth Texture only supported in WebGL2.0");ja=36012}else r.isWebGL2&&(ja=33189);1026===na.format&&6402===ja&&1012!==na.type&&1014!==na.type&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),na.type=1012,cb=v.convert(na.type));1027===na.format&&(ja=34041,1020!==na.type&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),na.type=1020,cb=
v.convert(na.type)));e.texImage2D(3553,0,ja,za.width,za.height,0,Na,cb,null)}else if(na.isDataTexture)if(0<Ga.length&&Ya){for(var La=0,nb=Ga.length;La<nb;La++)Ja=Ga[La],e.texImage2D(3553,La,ja,Ja.width,Ja.height,0,Na,cb,Ja.data);na.generateMipmaps=!1;ia.__maxMipLevel=Ga.length-1}else e.texImage2D(3553,0,ja,za.width,za.height,0,Na,cb,za.data),ia.__maxMipLevel=0;else if(na.isCompressedTexture){La=0;for(nb=Ga.length;La<nb;La++)Ja=Ga[La],1023!==na.format&&1022!==na.format?-1<e.getCompressedTextureFormats().indexOf(Na)?
e.compressedTexImage2D(3553,La,ja,Ja.width,Ja.height,0,Ja.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):e.texImage2D(3553,La,ja,Ja.width,Ja.height,0,Na,cb,Ja.data);ia.__maxMipLevel=Ga.length-1}else if(na.isDataTexture2DArray)e.texImage3D(35866,0,ja,za.width,za.height,za.depth,0,Na,cb,za.data),ia.__maxMipLevel=0;else if(na.isDataTexture3D)e.texImage3D(32879,0,ja,za.width,za.height,za.depth,0,Na,cb,za.data),ia.__maxMipLevel=0;else if(0<
Ga.length&&Ya){La=0;for(nb=Ga.length;La<nb;La++)Ja=Ga[La],e.texImage2D(3553,La,ja,Na,cb,Ja);na.generateMipmaps=!1;ia.__maxMipLevel=Ga.length-1}else e.texImage2D(3553,0,ja,Na,cb,za),ia.__maxMipLevel=0;R(na,Ya)&&S(3553,na,za.width,za.height);ia.__version=na.version;if(na.onUpdate)na.onUpdate(na)}function Ua(ia,na,za,Ja){var Ya=v.convert(na.texture.format),Na=v.convert(na.texture.type),cb=V(Ya,Na);e.texImage2D(Ja,0,cb,na.width,na.height,0,Ya,Na,null);a.bindFramebuffer(36160,ia);a.framebufferTexture2D(36160,
za,Ja,g.get(na.texture).__webglTexture,0);a.bindFramebuffer(36160,null)}function Ca(ia,na,za){a.bindRenderbuffer(36161,ia);if(na.depthBuffer&&!na.stencilBuffer)za?(za=Ma(na),a.renderbufferStorageMultisample(36161,za,33189,na.width,na.height)):a.renderbufferStorage(36161,33189,na.width,na.height),a.framebufferRenderbuffer(36160,36096,36161,ia);else if(na.depthBuffer&&na.stencilBuffer)za?(za=Ma(na),a.renderbufferStorageMultisample(36161,za,35056,na.width,na.height)):a.renderbufferStorage(36161,34041,
na.width,na.height),a.framebufferRenderbuffer(36160,33306,36161,ia);else{ia=v.convert(na.texture.format);var Ja=v.convert(na.texture.type);ia=V(ia,Ja);za?(za=Ma(na),a.renderbufferStorageMultisample(36161,za,ia,na.width,na.height)):a.renderbufferStorage(36161,ia,na.width,na.height)}a.bindRenderbuffer(36161,null)}function Ha(ia,na){if(na&&na.isWebGLRenderTargetCube)throw Error("Depth Texture with cube render targets is not supported");a.bindFramebuffer(36160,ia);if(!na.depthTexture||!na.depthTexture.isDepthTexture)throw Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");
g.get(na.depthTexture).__webglTexture&&na.depthTexture.image.width===na.width&&na.depthTexture.image.height===na.height||(na.depthTexture.image.width=na.width,na.depthTexture.image.height=na.height,na.depthTexture.needsUpdate=!0);qa(na.depthTexture,0);ia=g.get(na.depthTexture).__webglTexture;if(1026===na.depthTexture.format)a.framebufferTexture2D(36160,36096,3553,ia,0);else if(1027===na.depthTexture.format)a.framebufferTexture2D(36160,33306,3553,ia,0);else throw Error("Unknown depthTexture format");
}function Da(ia){var na=g.get(ia),za=!0===ia.isWebGLRenderTargetCube;if(ia.depthTexture){if(za)throw Error("target.depthTexture not supported in Cube render targets");Ha(na.__webglFramebuffer,ia)}else if(za)for(na.__webglDepthbuffer=[],za=0;6>za;za++)a.bindFramebuffer(36160,na.__webglFramebuffer[za]),na.__webglDepthbuffer[za]=a.createRenderbuffer(),Ca(na.__webglDepthbuffer[za],ia);else a.bindFramebuffer(36160,na.__webglFramebuffer),na.__webglDepthbuffer=a.createRenderbuffer(),Ca(na.__webglDepthbuffer,
ia);a.bindFramebuffer(36160,null)}function Ma(ia){return r.isWebGL2&&ia.isWebGLMultisampleRenderTarget?Math.min(r.maxSamples,ia.samples):0}function db(ia){var na=z.render.frame;tb.get(ia)!==na&&(tb.set(ia,na),ia.update())}var tb=new WeakMap,Ka,bb="undefined"!==typeof OffscreenCanvas,jb=0,Eb=!1,xb=!1;this.allocateTextureUnit=function(){var ia=jb;ia>=r.maxTextures&&console.warn("THREE.WebGLTextures: Trying to use "+ia+" texture units while this GPU supports only "+r.maxTextures);jb+=1;return ia};this.resetTextureUnits=
function(){jb=0};this.setTexture2D=qa;this.setTexture2DArray=function(ia,na){var za=g.get(ia);0<ia.version&&za.__version!==ia.version?Ta(za,ia,na):(e.activeTexture(33984+na),e.bindTexture(35866,za.__webglTexture))};this.setTexture3D=function(ia,na){var za=g.get(ia);0<ia.version&&za.__version!==ia.version?Ta(za,ia,na):(e.activeTexture(33984+na),e.bindTexture(32879,za.__webglTexture))};this.setTextureCube=ua;this.setTextureCubeDynamic=oa;this.setupRenderTarget=function(ia){var na=g.get(ia),za=g.get(ia.texture);
ia.addEventListener("dispose",fa);za.__webglTexture=a.createTexture();z.memory.textures++;var Ja=!0===ia.isWebGLRenderTargetCube,Ya=!0===ia.isWebGLMultisampleRenderTarget,Na=J(ia)||r.isWebGL2;if(Ja)for(na.__webglFramebuffer=[],Ya=0;6>Ya;Ya++)na.__webglFramebuffer[Ya]=a.createFramebuffer();else if(na.__webglFramebuffer=a.createFramebuffer(),Ya)if(r.isWebGL2){na.__webglMultisampledFramebuffer=a.createFramebuffer();na.__webglColorRenderbuffer=a.createRenderbuffer();a.bindRenderbuffer(36161,na.__webglColorRenderbuffer);
Ya=v.convert(ia.texture.format);var cb=v.convert(ia.texture.type);Ya=V(Ya,cb);cb=Ma(ia);a.renderbufferStorageMultisample(36161,cb,Ya,ia.width,ia.height);a.bindFramebuffer(36160,na.__webglMultisampledFramebuffer);a.framebufferRenderbuffer(36160,36064,36161,na.__webglColorRenderbuffer);a.bindRenderbuffer(36161,null);ia.depthBuffer&&(na.__webglDepthRenderbuffer=a.createRenderbuffer(),Ca(na.__webglDepthRenderbuffer,ia,!0));a.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");
if(Ja){e.bindTexture(34067,za.__webglTexture);ta(34067,ia.texture,Na);for(Ya=0;6>Ya;Ya++)Ua(na.__webglFramebuffer[Ya],ia,36064,34069+Ya);R(ia.texture,Na)&&S(34067,ia.texture,ia.width,ia.height);e.bindTexture(34067,null)}else e.bindTexture(3553,za.__webglTexture),ta(3553,ia.texture,Na),Ua(na.__webglFramebuffer,ia,36064,3553),R(ia.texture,Na)&&S(3553,ia.texture,ia.width,ia.height),e.bindTexture(3553,null);ia.depthBuffer&&Da(ia)};this.updateRenderTargetMipmap=function(ia){var na=ia.texture,za=J(ia)||
r.isWebGL2;if(R(na,za)){za=ia.isWebGLRenderTargetCube?34067:3553;var Ja=g.get(na).__webglTexture;e.bindTexture(za,Ja);S(za,na,ia.width,ia.height);e.bindTexture(za,null)}};this.updateMultisampleRenderTarget=function(ia){if(ia.isWebGLMultisampleRenderTarget)if(r.isWebGL2){var na=g.get(ia);a.bindFramebuffer(36008,na.__webglMultisampledFramebuffer);a.bindFramebuffer(36009,na.__webglFramebuffer);na=ia.width;var za=ia.height,Ja=16384;ia.depthBuffer&&(Ja|=256);ia.stencilBuffer&&(Ja|=1024);a.blitFramebuffer(0,
0,na,za,0,0,na,za,Ja,9728)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")};this.safeSetTexture2D=function(ia,na){ia&&ia.isWebGLRenderTarget&&(!1===Eb&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),Eb=!0),ia=ia.texture);qa(ia,na)};this.safeSetTextureCube=function(ia,na){ia&&ia.isWebGLRenderTargetCube&&(!1===xb&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),
xb=!0),ia=ia.texture);ia&&ia.isCubeTexture||Array.isArray(ia.image)&&6===ia.image.length?ua(ia,na):oa(ia,na)}}function wj(a,c,e){return{convert:function(g){if(1E3===g)return 10497;if(1001===g)return 33071;if(1002===g)return 33648;if(1003===g)return 9728;if(1004===g)return 9984;if(1005===g)return 9986;if(1006===g)return 9729;if(1007===g)return 9985;if(1008===g)return 9987;if(1009===g)return 5121;if(1017===g)return 32819;if(1018===g)return 32820;if(1019===g)return 33635;if(1010===g)return 5120;if(1011===
g)return 5122;if(1012===g)return 5123;if(1013===g)return 5124;if(1014===g)return 5125;if(1015===g)return 5126;if(1016===g){if(e.isWebGL2)return 5131;var r=c.get("OES_texture_half_float");if(null!==r)return r.HALF_FLOAT_OES}if(1021===g)return 6406;if(1022===g)return 6407;if(1023===g)return 6408;if(1024===g)return 6409;if(1025===g)return 6410;if(1026===g)return 6402;if(1027===g)return 34041;if(1028===g)return 6403;if(100===g)return 32774;if(101===g)return 32778;if(102===g)return 32779;if(200===g)return 0;
if(201===g)return 1;if(202===g)return 768;if(203===g)return 769;if(204===g)return 770;if(205===g)return 771;if(206===g)return 772;if(207===g)return 773;if(208===g)return 774;if(209===g)return 775;if(210===g)return 776;if(33776===g||33777===g||33778===g||33779===g)if(r=c.get("WEBGL_compressed_texture_s3tc"),null!==r){if(33776===g)return r.COMPRESSED_RGB_S3TC_DXT1_EXT;if(33777===g)return r.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(33778===g)return r.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(33779===g)return r.COMPRESSED_RGBA_S3TC_DXT5_EXT}if(35840===
g||35841===g||35842===g||35843===g)if(r=c.get("WEBGL_compressed_texture_pvrtc"),null!==r){if(35840===g)return r.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(35841===g)return r.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(35842===g)return r.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(35843===g)return r.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}if(36196===g&&(r=c.get("WEBGL_compressed_texture_etc1"),null!==r))return r.COMPRESSED_RGB_ETC1_WEBGL;if(37808===g||37809===g||37810===g||37811===g||37812===g||37813===g||37814===g||37815===g||37816===
g||37817===g||37818===g||37819===g||37820===g||37821===g)if(r=c.get("WEBGL_compressed_texture_astc"),null!==r)return g;if(103===g||104===g){if(e.isWebGL2){if(103===g)return 32775;if(104===g)return 32776}r=c.get("EXT_blend_minmax");if(null!==r){if(103===g)return r.MIN_EXT;if(104===g)return r.MAX_EXT}}if(1020===g){if(e.isWebGL2)return 34042;r=c.get("WEBGL_depth_texture");if(null!==r)return r.UNSIGNED_INT_24_8_WEBGL}return 0}}}function ue(){A.call(this);this.type="Group"}function vf(a){vb.call(this);
this.cameras=a||[]}function xj(a,c,e){yj.setFromMatrixPosition(c.matrixWorld);zj.setFromMatrixPosition(e.matrixWorld);var g=yj.distanceTo(zj),r=c.projectionMatrix.elements,v=e.projectionMatrix.elements,z=r[14]/(r[10]-1);e=r[14]/(r[10]+1);var E=(r[9]+1)/r[5],F=(r[9]-1)/r[5],J=(r[8]-1)/r[0],P=(v[8]+1)/v[0];r=z*J;v=z*P;P=g/(-J+P);J=P*-J;c.matrixWorld.decompose(a.position,a.quaternion,a.scale);a.translateX(J);a.translateZ(P);a.matrixWorld.compose(a.position,a.quaternion,a.scale);a.matrixWorldInverse.getInverse(a.matrixWorld);
c=z+P;z=e+P;a.projectionMatrix.makePerspective(r-J,v+(g-J),E*e/z*c,F*e/z*c,c,z)}function Nh(a){function c(){return null!==J&&!0===J.isPresenting}function e(){if(c()){var Ha=J.getEyeParameters("left");z=2*Ha.renderWidth*ha;E=Ha.renderHeight*ha;Ta=a.getPixelRatio();a.getSize(Ba);a.setDrawingBufferSize(z,E,1);ua.viewport.set(0,0,z/2,E);oa.viewport.set(z/2,0,z/2,E);Ca.start();F.dispatchEvent({type:"sessionstart"})}else F.enabled&&a.setDrawingBufferSize(Ba.width,Ba.height,Ta),Ca.stop(),F.dispatchEvent({type:"sessionend"})}
function g(Ha){for(var Da=navigator.getGamepads&&navigator.getGamepads(),Ma=0,db=0,tb=Da.length;Ma<tb;Ma++){var Ka=Da[Ma];if(Ka&&("Daydream Controller"===Ka.id||"Gear VR Controller"===Ka.id||"Oculus Go Controller"===Ka.id||"OpenVR Gamepad"===Ka.id||Ka.id.startsWith("Oculus Touch")||Ka.id.startsWith("HTC Vive Focus")||Ka.id.startsWith("Spatial Controller"))){if(db===Ha)return Ka;db++}}}function r(){for(var Ha=0;Ha<S.length;Ha++){var Da=S[Ha],Ma=g(Ha);if(void 0!==Ma&&void 0!==Ma.pose){if(null===Ma.pose)break;
var db=Ma.pose;!1===db.hasPosition&&Da.position.set(.2,-.6,-.05);null!==db.position&&Da.position.fromArray(db.position);null!==db.orientation&&Da.quaternion.fromArray(db.orientation);Da.matrix.compose(Da.position,Da.quaternion,Da.scale);Da.matrix.premultiply(V);Da.matrix.decompose(Da.position,Da.quaternion,Da.scale);Da.matrixWorldNeedsUpdate=!0;Da.visible=!0;db="Daydream Controller"===Ma.id?0:1;void 0===Ua[Ha]&&(Ua[Ha]=!1);Ua[Ha]!==Ma.buttons[db].pressed&&(Ua[Ha]=Ma.buttons[db].pressed,!0===Ua[Ha]?
Da.dispatchEvent({type:"selectstart"}):(Da.dispatchEvent({type:"selectend"}),Da.dispatchEvent({type:"select"})))}else Da.visible=!1}}function v(Ha,Da){null!==Da&&4===Da.length&&Ha.set(Da[0]*z,Da[1]*E,Da[2]*z,Da[3]*E)}var z,E,F=this,J=null,P=null,R=null,S=[],V=new q,W=new q,ha=1,fa="local-floor";"undefined"!==typeof window&&"VRFrameData"in window&&(P=new window.VRFrameData,window.addEventListener("vrdisplaypresentchange",e,!1));var ra=new q,pa=new h,qa=new k,ua=new vb;ua.viewport=new p;ua.layers.enable(1);
var oa=new vb;oa.viewport=new p;oa.layers.enable(2);var ta=new vf([ua,oa]);ta.layers.enable(1);ta.layers.enable(2);var Ba=new f,Ta,Ua=[];this.enabled=!1;this.getController=function(Ha){var Da=S[Ha];void 0===Da&&(Da=new ue,Da.matrixAutoUpdate=!1,Da.visible=!1,S[Ha]=Da);return Da};this.getDevice=function(){return J};this.setDevice=function(Ha){void 0!==Ha&&(J=Ha);Ca.setContext(Ha)};this.setFramebufferScaleFactor=function(Ha){ha=Ha};this.setReferenceSpaceType=function(Ha){fa=Ha};this.setPoseTarget=function(Ha){void 0!==
Ha&&(R=Ha)};this.getCamera=function(Ha){var Da="local-floor"===fa?1.6:0;if(!1===c())return Ha.position.set(0,Da,0),Ha.rotation.set(0,0,0),Ha;J.depthNear=Ha.near;J.depthFar=Ha.far;J.getFrameData(P);if("local-floor"===fa){var Ma=J.stageParameters;Ma?V.fromArray(Ma.sittingToStandingTransform):V.makeTranslation(0,Da,0)}Da=P.pose;Ma=null!==R?R:Ha;Ma.matrix.copy(V);Ma.matrix.decompose(Ma.position,Ma.quaternion,Ma.scale);null!==Da.orientation&&(pa.fromArray(Da.orientation),Ma.quaternion.multiply(pa));null!==
Da.position&&(pa.setFromRotationMatrix(V),qa.fromArray(Da.position),qa.applyQuaternion(pa),Ma.position.add(qa));Ma.updateMatrixWorld();ua.near=Ha.near;oa.near=Ha.near;ua.far=Ha.far;oa.far=Ha.far;ua.matrixWorldInverse.fromArray(P.leftViewMatrix);oa.matrixWorldInverse.fromArray(P.rightViewMatrix);W.getInverse(V);"local-floor"===fa&&(ua.matrixWorldInverse.multiply(W),oa.matrixWorldInverse.multiply(W));Ha=Ma.parent;null!==Ha&&(ra.getInverse(Ha.matrixWorld),ua.matrixWorldInverse.multiply(ra),oa.matrixWorldInverse.multiply(ra));
ua.matrixWorld.getInverse(ua.matrixWorldInverse);oa.matrixWorld.getInverse(oa.matrixWorldInverse);ua.projectionMatrix.fromArray(P.leftProjectionMatrix);oa.projectionMatrix.fromArray(P.rightProjectionMatrix);xj(ta,ua,oa);Ha=J.getLayers();Ha.length&&(Ha=Ha[0],v(ua.viewport,Ha.leftBounds),v(oa.viewport,Ha.rightBounds));r();return ta};this.getStandingMatrix=function(){return V};this.isPresenting=c;var Ca=new bc;this.setAnimationLoop=function(Ha){Ca.setAnimationLoop(Ha);c()&&Ca.start()};this.submitFrame=
function(){c()&&J.submitFrame()};this.dispose=function(){"undefined"!==typeof window&&window.removeEventListener("vrdisplaypresentchange",e)};this.setFrameOfReferenceType=function(){console.warn("THREE.WebVRManager: setFrameOfReferenceType() has been deprecated.")}}function Aj(a,c){function e(){return null!==F&&null!==J}function g(qa){for(var ua=0;ua<S.length;ua++)V[ua]===qa.inputSource&&S[ua].dispatchEvent({type:qa.type})}function r(){a.setFramebuffer(null);a.setRenderTarget(a.getRenderTarget());
pa.stop();E.dispatchEvent({type:"sessionend"})}function v(qa){J=qa;pa.setContext(F);pa.start();E.dispatchEvent({type:"sessionstart"})}function z(qa,ua){null===ua?qa.matrixWorld.copy(qa.matrix):qa.matrixWorld.multiplyMatrices(ua.matrixWorld,qa.matrix);qa.matrixWorldInverse.getInverse(qa.matrixWorld)}var E=this,F=null,J=null,P="local-floor",R=null,S=[],V=[],W=new vb;W.layers.enable(1);W.viewport=new p;var ha=new vb;ha.layers.enable(2);ha.viewport=new p;var fa=new vf([W,ha]);fa.layers.enable(1);fa.layers.enable(2);
this.enabled=!1;this.getController=function(qa){var ua=S[qa];void 0===ua&&(ua=new ue,ua.matrixAutoUpdate=!1,ua.visible=!1,S[qa]=ua);return ua};this.setFramebufferScaleFactor=function(){};this.setReferenceSpaceType=function(qa){P=qa};this.getSession=function(){return F};this.setSession=function(qa){F=qa;null!==F&&(F.addEventListener("select",g),F.addEventListener("selectstart",g),F.addEventListener("selectend",g),F.addEventListener("end",r),F.updateRenderState({baseLayer:new XRWebGLLayer(F,c)}),F.requestReferenceSpace(P).then(v),
V=F.inputSources,F.addEventListener("inputsourceschange",function(){V=F.inputSources;console.log(V);for(var ua=0;ua<S.length;ua++)S[ua].userData.inputSource=V[ua]}))};this.getCamera=function(qa){if(e()){var ua=qa.parent,oa=fa.cameras;z(fa,ua);for(var ta=0;ta<oa.length;ta++)z(oa[ta],ua);qa.matrixWorld.copy(fa.matrixWorld);qa=qa.children;ta=0;for(ua=qa.length;ta<ua;ta++)qa[ta].updateMatrixWorld(!0);xj(fa,W,ha);return fa}return qa};this.isPresenting=e;var ra=null,pa=new bc;pa.setAnimationLoop(function(qa,
ua){R=ua.getViewerPose(J);if(null!==R){var oa=R.views,ta=F.renderState.baseLayer;a.setFramebuffer(ta.framebuffer);for(var Ba=0;Ba<oa.length;Ba++){var Ta=oa[Ba],Ua=ta.getViewport(Ta),Ca=fa.cameras[Ba];Ca.matrix.fromArray(Ta.transform.inverse.matrix).getInverse(Ca.matrix);Ca.projectionMatrix.fromArray(Ta.projectionMatrix);Ca.viewport.set(Ua.x,Ua.y,Ua.width,Ua.height);0===Ba&&fa.matrix.copy(Ca.matrix)}}for(Ba=0;Ba<S.length;Ba++){oa=S[Ba];if(ta=V[Ba])if(ta=ua.getPose(ta.targetRaySpace,J),null!==ta){oa.matrix.fromArray(ta.transform.matrix);
oa.matrix.decompose(oa.position,oa.rotation,oa.scale);oa.visible=!0;continue}oa.visible=!1}ra&&ra(qa)});this.setAnimationLoop=function(qa){ra=qa};this.dispose=function(){};this.getStandingMatrix=function(){console.warn("THREE.WebXRManager: getStandingMatrix() is no longer needed.");return new q};this.getDevice=function(){console.warn("THREE.WebXRManager: getDevice() has been deprecated.")};this.setDevice=function(){console.warn("THREE.WebXRManager: setDevice() has been deprecated.")};this.setFrameOfReferenceType=
function(){console.warn("THREE.WebXRManager: setFrameOfReferenceType() has been deprecated.")};this.submitFrame=function(){}}function Oh(a){var c;function e(){return null===ib?cc:1}function g(){Lb=new bd(Ra);dc=new Mb(Ra,Lb,a);dc.isWebGL2||(Lb.get("WEBGL_depth_texture"),Lb.get("OES_texture_float"),Lb.get("OES_texture_half_float"),Lb.get("OES_texture_half_float_linear"),Lb.get("OES_standard_derivatives"),Lb.get("OES_element_index_uint"),Lb.get("ANGLE_instanced_arrays"));Lb.get("OES_texture_float_linear");
Nc=new wj(Ra,Lb,dc);yb=new Vl(Ra,Lb,Nc,dc);yb.scissor(Sb.copy(ve).multiplyScalar(cc).floor());yb.viewport(Kb.copy(we).multiplyScalar(cc).floor());xd=new Sk(Ra);ec=new Ml;Oc=new Wl(Ra,Lb,yb,ec,dc,Nc,xd);vg=new Od(Ra);Ph=new td(Ra,vg,xd);xe=new Vk(Ph,xd);Bj=new Uk(Ra);Pd=new Ll(ja,Lb,dc);wg=new Pl;ye=new Ul;yd=new sd(ja,yb,xe,na);Cj=new sa(Ra,Lb,xd,dc);Dj=new tg(Ra,Lb,xd,dc);xd.programs=Pd.programs;ja.capabilities=dc;ja.extensions=Lb;ja.properties=ec;ja.renderLists=wg;ja.state=yb;ja.info=xd}function r(U){U.preventDefault();
console.log("THREE.WebGLRenderer: Context Lost.");Ga=!0}function v(){console.log("THREE.WebGLRenderer: Context Restored.");Ga=!1;g()}function z(U){U=U.target;U.removeEventListener("dispose",z);E(U)}function E(U){F(U);ec.remove(U)}function F(U){var da=ec.get(U).program;U.program=void 0;void 0!==da&&Pd.releaseProgram(da)}function J(U,da){U.render(function(ma){ja.renderBufferImmediate(ma,da)})}function P(U,da,ma){if(ma&&ma.isInstancedBufferGeometry&&!dc.isWebGL2&&null===Lb.get("ANGLE_instanced_arrays"))console.error("THREE.WebGLRenderer.setupVertexAttributes: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");
else{yb.initAttributes();var Ia=ma.attributes;da=da.getAttributes();U=U.defaultAttributeValues;for(var Oa in da){var ab=da[Oa];if(0<=ab){var Pa=Ia[Oa];if(void 0!==Pa){var fb=Pa.normalized,Cb=Pa.itemSize,ob=vg.get(Pa);if(void 0!==ob){var $a=ob.buffer,Pc=ob.type;ob=ob.bytesPerElement;if(Pa.isInterleavedBufferAttribute){var xc=Pa.data,ze=xc.stride;Pa=Pa.offset;xc&&xc.isInstancedInterleavedBuffer?(yb.enableAttributeAndDivisor(ab,xc.meshPerAttribute),void 0===ma.maxInstancedCount&&(ma.maxInstancedCount=
xc.meshPerAttribute*xc.count)):yb.enableAttribute(ab);Ra.bindBuffer(34962,$a);Ra.vertexAttribPointer(ab,Cb,Pc,fb,ze*ob,Pa*ob)}else Pa.isInstancedBufferAttribute?(yb.enableAttributeAndDivisor(ab,Pa.meshPerAttribute),void 0===ma.maxInstancedCount&&(ma.maxInstancedCount=Pa.meshPerAttribute*Pa.count)):yb.enableAttribute(ab),Ra.bindBuffer(34962,$a),Ra.vertexAttribPointer(ab,Cb,Pc,fb,0,0)}}else if(void 0!==U&&(fb=U[Oa],void 0!==fb))switch(fb.length){case 2:Ra.vertexAttrib2fv(ab,fb);break;case 3:Ra.vertexAttrib3fv(ab,
fb);break;case 4:Ra.vertexAttrib4fv(ab,fb);break;default:Ra.vertexAttrib1fv(ab,fb)}}}yb.disableUnusedAttributes()}}function R(U,da,ma,Ia){if(!1!==U.visible){if(U.layers.test(da.layers))if(U.isGroup)ma=U.renderOrder;else if(U.isLOD)!0===U.autoUpdate&&U.update(da);else if(U.isLight)cb.pushLight(U),U.castShadow&&cb.pushShadow(U);else if(U.isSprite){if(!U.frustumCulled||Qh.intersectsSprite(U)){Ia&&zd.setFromMatrixPosition(U.matrixWorld).applyMatrix4(wf);var Oa=xe.update(U),ab=U.material;ab.visible&&Na.push(U,
Oa,ab,ma,zd.z,null)}}else if(U.isImmediateRenderObject)Ia&&zd.setFromMatrixPosition(U.matrixWorld).applyMatrix4(wf),Na.push(U,null,U.material,ma,zd.z,null);else if(U.isMesh||U.isLine||U.isPoints)if(U.isSkinnedMesh&&U.skeleton.update(),!U.frustumCulled||Qh.intersectsObject(U))if(Ia&&zd.setFromMatrixPosition(U.matrixWorld).applyMatrix4(wf),Oa=xe.update(U),ab=U.material,Array.isArray(ab))for(var Pa=Oa.groups,fb=0,Cb=Pa.length;fb<Cb;fb++){var ob=Pa[fb],$a=ab[ob.materialIndex];$a&&$a.visible&&Na.push(U,
Oa,$a,ma,zd.z,ob)}else ab.visible&&Na.push(U,Oa,ab,ma,zd.z,null);U=U.children;fb=0;for(Cb=U.length;fb<Cb;fb++)R(U[fb],da,ma,Ia)}}function S(U,da,ma,Ia){for(var Oa=0,ab=U.length;Oa<ab;Oa++){var Pa=U[Oa],fb=Pa.object,Cb=Pa.geometry,ob=void 0===Ia?Pa.material:Ia;Pa=Pa.group;if(ma.isArrayCamera){sb=ma;for(var $a=ma.cameras,Pc=0,xc=$a.length;Pc<xc;Pc++){var ze=$a[Pc];fb.layers.test(ze.layers)&&(yb.viewport(Kb.copy(ze.viewport)),cb.setupLights(ze),V(fb,da,ze,Cb,ob,Pa))}}else sb=null,V(fb,da,ma,Cb,ob,Pa)}}
function V(U,da,ma,Ia,Oa,ab){U.onBeforeRender(ja,da,ma,Ia,Oa,ab);cb=ye.get(da,sb||ma);U.modelViewMatrix.multiplyMatrices(ma.matrixWorldInverse,U.matrixWorld);U.normalMatrix.getNormalMatrix(U.modelViewMatrix);U.isImmediateRenderObject?(yb.setMaterial(Oa),Ia=ha(ma,da.fog,Oa,U),eb=c=null,mb=!1,J(U,Ia)):ja.renderBufferDirect(ma,da.fog,Ia,Oa,U,ab);cb=ye.get(da,sb||ma)}function W(U,da,ma){var Ia=ec.get(U),Oa=cb.state.lights,ab=Oa.state.version;ma=Pd.getParameters(U,Oa.state,cb.state.shadowsArray,da,yc.numPlanes,
yc.numIntersection,ma);var Pa=Pd.getProgramCode(U,ma),fb=Ia.program,Cb=!0;if(void 0===fb)U.addEventListener("dispose",z);else if(fb.code!==Pa)F(U);else{if(Ia.lightsStateVersion!==ab)Ia.lightsStateVersion=ab;else if(void 0!==ma.shaderID)return;Cb=!1}Cb&&(ma.shaderID?(Pa=Mc[ma.shaderID],Ia.shader={name:U.type,uniforms:ub(Pa.uniforms),vertexShader:Pa.vertexShader,fragmentShader:Pa.fragmentShader}):Ia.shader={name:U.type,uniforms:U.uniforms,vertexShader:U.vertexShader,fragmentShader:U.fragmentShader},
Pa=Pd.getProgramCode(U,ma),fb=Pd.acquireProgram(U,Ia.shader,ma,Pa),Ia.program=fb,U.program=fb);ma=fb.getAttributes();if(U.morphTargets)for(Pa=U.numSupportedMorphTargets=0;Pa<ja.maxMorphTargets;Pa++)0<=ma["morphTarget"+Pa]&&U.numSupportedMorphTargets++;if(U.morphNormals)for(Pa=U.numSupportedMorphNormals=0;Pa<ja.maxMorphNormals;Pa++)0<=ma["morphNormal"+Pa]&&U.numSupportedMorphNormals++;ma=Ia.shader.uniforms;if(!U.isShaderMaterial&&!U.isRawShaderMaterial||!0===U.clipping)Ia.numClippingPlanes=yc.numPlanes,
Ia.numIntersection=yc.numIntersection,ma.clippingPlanes=yc.uniform;Ia.fog=da;Ia.lightsStateVersion=ab;U.lights&&(ma.ambientLightColor.value=Oa.state.ambient,ma.lightProbe.value=Oa.state.probe,ma.directionalLights.value=Oa.state.directional,ma.spotLights.value=Oa.state.spot,ma.rectAreaLights.value=Oa.state.rectArea,ma.pointLights.value=Oa.state.point,ma.hemisphereLights.value=Oa.state.hemi,ma.directionalShadowMap.value=Oa.state.directionalShadowMap,ma.directionalShadowMatrix.value=Oa.state.directionalShadowMatrix,
ma.spotShadowMap.value=Oa.state.spotShadowMap,ma.spotShadowMatrix.value=Oa.state.spotShadowMatrix,ma.pointShadowMap.value=Oa.state.pointShadowMap,ma.pointShadowMatrix.value=Oa.state.pointShadowMatrix);U=Ia.program.getUniforms();U=ud.seqWithValue(U.seq,ma);Ia.uniformsList=U}function ha(U,da,ma,Ia){Oc.resetTextureUnits();var Oa=ec.get(ma),ab=cb.state.lights;xg&&(Rh||U!==pb)&&yc.setState(ma.clippingPlanes,ma.clipIntersection,ma.clipShadows,U,Oa,U===pb&&ma.id===Qa);!1===ma.needsUpdate&&(void 0===Oa.program?
ma.needsUpdate=!0:ma.fog&&Oa.fog!==da?ma.needsUpdate=!0:ma.lights&&Oa.lightsStateVersion!==ab.state.version?ma.needsUpdate=!0:void 0===Oa.numClippingPlanes||Oa.numClippingPlanes===yc.numPlanes&&Oa.numIntersection===yc.numIntersection||(ma.needsUpdate=!0));ma.needsUpdate&&(W(ma,da,Ia),ma.needsUpdate=!1);var Pa=!1,fb=ab=!1,Cb=Oa.program,ob=Cb.getUniforms(),$a=Oa.shader.uniforms;yb.useProgram(Cb.program)&&(fb=ab=Pa=!0);ma.id!==Qa&&(Qa=ma.id,ab=!0);if(Pa||pb!==U){ob.setValue(Ra,"projectionMatrix",U.projectionMatrix);
dc.logarithmicDepthBuffer&&ob.setValue(Ra,"logDepthBufFC",2/(Math.log(U.far+1)/Math.LN2));pb!==U&&(pb=U,fb=ab=!0);if(ma.isShaderMaterial||ma.isMeshPhongMaterial||ma.isMeshStandardMaterial||ma.envMap)Pa=ob.map.cameraPosition,void 0!==Pa&&Pa.setValue(Ra,zd.setFromMatrixPosition(U.matrixWorld));(ma.isMeshPhongMaterial||ma.isMeshLambertMaterial||ma.isMeshBasicMaterial||ma.isMeshStandardMaterial||ma.isShaderMaterial||ma.skinning)&&ob.setValue(Ra,"viewMatrix",U.matrixWorldInverse)}if(ma.skinning&&(ob.setOptional(Ra,
Ia,"bindMatrix"),ob.setOptional(Ra,Ia,"bindMatrixInverse"),U=Ia.skeleton))if(Pa=U.bones,dc.floatVertexTextures){if(void 0===U.boneTexture){Pa=Math.sqrt(4*Pa.length);Pa=hb.ceilPowerOfTwo(Pa);Pa=Math.max(Pa,4);var Pc=new Float32Array(Pa*Pa*4);Pc.set(U.boneMatrices);var xc=new Ab(Pc,Pa,Pa,1023,1015);xc.needsUpdate=!0;U.boneMatrices=Pc;U.boneTexture=xc;U.boneTextureSize=Pa}ob.setValue(Ra,"boneTexture",U.boneTexture,Oc);ob.setValue(Ra,"boneTextureSize",U.boneTextureSize)}else ob.setOptional(Ra,U,"boneMatrices");
ab&&(ob.setValue(Ra,"toneMappingExposure",ja.toneMappingExposure),ob.setValue(Ra,"toneMappingWhitePoint",ja.toneMappingWhitePoint),ma.lights&&tb($a,fb),da&&ma.fog&&oa($a,da),ma.isMeshBasicMaterial?fa($a,ma):ma.isMeshLambertMaterial?(fa($a,ma),ta($a,ma)):ma.isMeshPhongMaterial?(fa($a,ma),ma.isMeshToonMaterial?Ta($a,ma):Ba($a,ma)):ma.isMeshStandardMaterial?(fa($a,ma),ma.isMeshPhysicalMaterial?Ca($a,ma):Ua($a,ma)):ma.isMeshMatcapMaterial?(fa($a,ma),Ha($a,ma)):ma.isMeshDepthMaterial?(fa($a,ma),Da($a,
ma)):ma.isMeshDistanceMaterial?(fa($a,ma),Ma($a,ma)):ma.isMeshNormalMaterial?(fa($a,ma),db($a,ma)):ma.isLineBasicMaterial?(ra($a,ma),ma.isLineDashedMaterial&&pa($a,ma)):ma.isPointsMaterial?qa($a,ma):ma.isSpriteMaterial?ua($a,ma):ma.isShadowMaterial&&($a.color.value.copy(ma.color),$a.opacity.value=ma.opacity),void 0!==$a.ltc_1&&($a.ltc_1.value=Wa.LTC_1),void 0!==$a.ltc_2&&($a.ltc_2.value=Wa.LTC_2),ud.upload(Ra,Oa.uniformsList,$a,Oc));ma.isShaderMaterial&&!0===ma.uniformsNeedUpdate&&(ud.upload(Ra,Oa.uniformsList,
$a,Oc),ma.uniformsNeedUpdate=!1);ma.isSpriteMaterial&&ob.setValue(Ra,"center",Ia.center);ob.setValue(Ra,"modelViewMatrix",Ia.modelViewMatrix);ob.setValue(Ra,"normalMatrix",Ia.normalMatrix);ob.setValue(Ra,"modelMatrix",Ia.matrixWorld);return Cb}function fa(U,da){U.opacity.value=da.opacity;da.color&&U.diffuse.value.copy(da.color);da.emissive&&U.emissive.value.copy(da.emissive).multiplyScalar(da.emissiveIntensity);da.map&&(U.map.value=da.map);da.alphaMap&&(U.alphaMap.value=da.alphaMap);da.specularMap&&
(U.specularMap.value=da.specularMap);da.envMap&&(U.envMap.value=da.envMap,U.flipEnvMap.value=da.envMap.isCubeTexture?-1:1,U.reflectivity.value=da.reflectivity,U.refractionRatio.value=da.refractionRatio,U.maxMipLevel.value=ec.get(da.envMap).__maxMipLevel);da.lightMap&&(U.lightMap.value=da.lightMap,U.lightMapIntensity.value=da.lightMapIntensity);da.aoMap&&(U.aoMap.value=da.aoMap,U.aoMapIntensity.value=da.aoMapIntensity);if(da.map)var ma=da.map;else da.specularMap?ma=da.specularMap:da.displacementMap?
ma=da.displacementMap:da.normalMap?ma=da.normalMap:da.bumpMap?ma=da.bumpMap:da.roughnessMap?ma=da.roughnessMap:da.metalnessMap?ma=da.metalnessMap:da.alphaMap?ma=da.alphaMap:da.emissiveMap&&(ma=da.emissiveMap);void 0!==ma&&(ma.isWebGLRenderTarget&&(ma=ma.texture),!0===ma.matrixAutoUpdate&&ma.updateMatrix(),U.uvTransform.value.copy(ma.matrix))}function ra(U,da){U.diffuse.value.copy(da.color);U.opacity.value=da.opacity}function pa(U,da){U.dashSize.value=da.dashSize;U.totalSize.value=da.dashSize+da.gapSize;
U.scale.value=da.scale}function qa(U,da){U.diffuse.value.copy(da.color);U.opacity.value=da.opacity;U.size.value=da.size*cc;U.scale.value=.5*zc;U.map.value=da.map;null!==da.map&&(!0===da.map.matrixAutoUpdate&&da.map.updateMatrix(),U.uvTransform.value.copy(da.map.matrix))}function ua(U,da){U.diffuse.value.copy(da.color);U.opacity.value=da.opacity;U.rotation.value=da.rotation;U.map.value=da.map;null!==da.map&&(!0===da.map.matrixAutoUpdate&&da.map.updateMatrix(),U.uvTransform.value.copy(da.map.matrix))}
function oa(U,da){U.fogColor.value.copy(da.color);da.isFog?(U.fogNear.value=da.near,U.fogFar.value=da.far):da.isFogExp2&&(U.fogDensity.value=da.density)}function ta(U,da){da.emissiveMap&&(U.emissiveMap.value=da.emissiveMap)}function Ba(U,da){U.specular.value.copy(da.specular);U.shininess.value=Math.max(da.shininess,1E-4);da.emissiveMap&&(U.emissiveMap.value=da.emissiveMap);da.bumpMap&&(U.bumpMap.value=da.bumpMap,U.bumpScale.value=da.bumpScale,1===da.side&&(U.bumpScale.value*=-1));da.normalMap&&(U.normalMap.value=
da.normalMap,U.normalScale.value.copy(da.normalScale),1===da.side&&U.normalScale.value.negate());da.displacementMap&&(U.displacementMap.value=da.displacementMap,U.displacementScale.value=da.displacementScale,U.displacementBias.value=da.displacementBias)}function Ta(U,da){Ba(U,da);da.gradientMap&&(U.gradientMap.value=da.gradientMap)}function Ua(U,da){U.roughness.value=da.roughness;U.metalness.value=da.metalness;da.roughnessMap&&(U.roughnessMap.value=da.roughnessMap);da.metalnessMap&&(U.metalnessMap.value=
da.metalnessMap);da.emissiveMap&&(U.emissiveMap.value=da.emissiveMap);da.bumpMap&&(U.bumpMap.value=da.bumpMap,U.bumpScale.value=da.bumpScale,1===da.side&&(U.bumpScale.value*=-1));da.normalMap&&(U.normalMap.value=da.normalMap,U.normalScale.value.copy(da.normalScale),1===da.side&&U.normalScale.value.negate());da.displacementMap&&(U.displacementMap.value=da.displacementMap,U.displacementScale.value=da.displacementScale,U.displacementBias.value=da.displacementBias);da.envMap&&(U.envMapIntensity.value=
da.envMapIntensity)}function Ca(U,da){Ua(U,da);U.reflectivity.value=da.reflectivity;U.clearcoat.value=da.clearcoat;U.clearcoatRoughness.value=da.clearcoatRoughness;da.sheen&&U.sheen.value.copy(da.sheen);da.clearcoatNormalMap&&(U.clearcoatNormalScale.value.copy(da.clearcoatNormalScale),U.clearcoatNormalMap.value=da.clearcoatNormalMap,1===da.side&&U.clearcoatNormalScale.value.negate());U.transparency.value=da.transparency}function Ha(U,da){da.matcap&&(U.matcap.value=da.matcap);da.bumpMap&&(U.bumpMap.value=
da.bumpMap,U.bumpScale.value=da.bumpScale,1===da.side&&(U.bumpScale.value*=-1));da.normalMap&&(U.normalMap.value=da.normalMap,U.normalScale.value.copy(da.normalScale),1===da.side&&U.normalScale.value.negate());da.displacementMap&&(U.displacementMap.value=da.displacementMap,U.displacementScale.value=da.displacementScale,U.displacementBias.value=da.displacementBias)}function Da(U,da){da.displacementMap&&(U.displacementMap.value=da.displacementMap,U.displacementScale.value=da.displacementScale,U.displacementBias.value=
da.displacementBias)}function Ma(U,da){da.displacementMap&&(U.displacementMap.value=da.displacementMap,U.displacementScale.value=da.displacementScale,U.displacementBias.value=da.displacementBias);U.referencePosition.value.copy(da.referencePosition);U.nearDistance.value=da.nearDistance;U.farDistance.value=da.farDistance}function db(U,da){da.bumpMap&&(U.bumpMap.value=da.bumpMap,U.bumpScale.value=da.bumpScale,1===da.side&&(U.bumpScale.value*=-1));da.normalMap&&(U.normalMap.value=da.normalMap,U.normalScale.value.copy(da.normalScale),
1===da.side&&U.normalScale.value.negate());da.displacementMap&&(U.displacementMap.value=da.displacementMap,U.displacementScale.value=da.displacementScale,U.displacementBias.value=da.displacementBias)}function tb(U,da){U.ambientLightColor.needsUpdate=da;U.lightProbe.needsUpdate=da;U.directionalLights.needsUpdate=da;U.pointLights.needsUpdate=da;U.spotLights.needsUpdate=da;U.rectAreaLights.needsUpdate=da;U.hemisphereLights.needsUpdate=da}a=a||{};var Ka=void 0!==a.canvas?a.canvas:document.createElementNS("http://www.w3.org/1999/xhtml",
"canvas"),bb=void 0!==a.context?a.context:null,jb=void 0!==a.alpha?a.alpha:!1,Eb=void 0!==a.depth?a.depth:!0,xb=void 0!==a.stencil?a.stencil:!0,ia=void 0!==a.antialias?a.antialias:!1,na=void 0!==a.premultipliedAlpha?a.premultipliedAlpha:!0,za=void 0!==a.preserveDrawingBuffer?a.preserveDrawingBuffer:!1,Ja=void 0!==a.powerPreference?a.powerPreference:"default",Ya=void 0!==a.failIfMajorPerformanceCaveat?a.failIfMajorPerformanceCaveat:!1,Na=null,cb=null;this.domElement=Ka;this.debug={checkShaderErrors:!0};
this.sortObjects=this.autoClearStencil=this.autoClearDepth=this.autoClearColor=this.autoClear=!0;this.clippingPlanes=[];this.localClippingEnabled=!1;this.gammaFactor=2;this.physicallyCorrectLights=this.gammaOutput=this.gammaInput=!1;this.toneMappingWhitePoint=this.toneMappingExposure=this.toneMapping=1;this.maxMorphTargets=8;this.maxMorphNormals=4;var ja=this,Ga=!1,La=null,nb=0,Va=0,ib=null,kb=null,Qa=-1;var eb=c=null;var mb=!1;var pb=null,sb=null,Kb=new p,Sb=new p,nc=null,Qc=Ka.width,zc=Ka.height,
cc=1,we=new p(0,0,Qc,zc),ve=new p(0,0,Qc,zc),Sh=!1,Qh=new ic,yc=new wc,xg=!1,Rh=!1,wf=new q,zd=new k;try{jb={alpha:jb,depth:Eb,stencil:xb,antialias:ia,premultipliedAlpha:na,preserveDrawingBuffer:za,powerPreference:Ja,failIfMajorPerformanceCaveat:Ya,xrCompatible:!0};Ka.addEventListener("webglcontextlost",r,!1);Ka.addEventListener("webglcontextrestored",v,!1);var Ra=bb||Ka.getContext("webgl",jb)||Ka.getContext("experimental-webgl",jb);if(null===Ra){if(null!==Ka.getContext("webgl"))throw Error("Error creating WebGL context with your selected attributes.");
throw Error("Error creating WebGL context.");}void 0===Ra.getShaderPrecisionFormat&&(Ra.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(U){throw console.error("THREE.WebGLRenderer: "+U.message),U;}var Lb,dc,yb,xd,ec,Oc,vg,Ph,xe,Pd,wg,ye,yd,Bj,Cj,Dj,Nc;g();var dd="undefined"!==typeof navigator&&"xr"in navigator&&"supportsSession"in navigator.xr?new Aj(ja,Ra):new Nh(ja);this.vr=dd;var Ej=new vj(ja,xe,dc.maxTextureSize);this.shadowMap=Ej;this.getContext=function(){return Ra};
this.getContextAttributes=function(){return Ra.getContextAttributes()};this.forceContextLoss=function(){var U=Lb.get("WEBGL_lose_context");U&&U.loseContext()};this.forceContextRestore=function(){var U=Lb.get("WEBGL_lose_context");U&&U.restoreContext()};this.getPixelRatio=function(){return cc};this.setPixelRatio=function(){var U=window.devicePixelRatio;void 0!==U&&(cc=U,this.setSize(Qc,zc,!1))};this.getSize=function(U){void 0===U&&(console.warn("WebGLRenderer: .getsize() now requires a Vector2 as an argument"),
U=new f);return U.set(Qc,zc)};this.setSize=function(U,da,ma){dd.isPresenting()?console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting."):(Qc=U,zc=da,Ka.width=Math.floor(U*cc),Ka.height=Math.floor(da*cc),!1!==ma&&(Ka.style.width=U+"px",Ka.style.height=da+"px"),this.setViewport(U,da))};this.getDrawingBufferSize=function(U){void 0===U&&(console.warn("WebGLRenderer: .getdrawingBufferSize() now requires a Vector2 as an argument"),U=new f);return U.set(Qc*cc,zc*cc).floor()};
this.setDrawingBufferSize=function(U,da,ma){Qc=U;zc=da;cc=ma;Ka.width=Math.floor(U*ma);Ka.height=Math.floor(da*ma);this.setViewport(U,da)};this.getCurrentViewport=function(U){void 0===U&&(console.warn("WebGLRenderer: .getCurrentViewport() now requires a Vector4 as an argument"),U=new p);return U.copy(Kb)};this.getViewport=function(U){return U.copy(we)};this.setViewport=function(U,da){(0).isVector4?we.set((0).x,(0).y,(0).z,(0).w):we.set(0,0,U,da);yb.viewport(Kb.copy(we).multiplyScalar(cc).floor())};
this.getScissor=function(U){return U.copy(ve)};this.setScissor=function(U,da,ma,Ia){U.isVector4?ve.set(U.x,U.y,U.z,U.w):ve.set(U,da,ma,Ia);yb.scissor(Sb.copy(ve).multiplyScalar(cc).floor())};this.getScissorTest=function(){return Sh};this.setScissorTest=function(U){yb.setScissorTest(Sh=U)};this.getClearColor=function(){return yd.getClearColor()};this.setClearColor=function(){yd.setClearColor.apply(yd,arguments)};this.getClearAlpha=function(){return yd.getClearAlpha()};this.setClearAlpha=function(){yd.setClearAlpha.apply(yd,
arguments)};this.clear=function(U,da,ma){var Ia=0;if(void 0===U||U)Ia|=16384;if(void 0===da||da)Ia|=256;if(void 0===ma||ma)Ia|=1024;Ra.clear(Ia)};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(){Ka.removeEventListener("webglcontextlost",r,!1);Ka.removeEventListener("webglcontextrestored",v,!1);wg.dispose();ye.dispose();ec.dispose();xe.dispose();dd.dispose();yg.stop()};this.renderBufferImmediate=
function(U,da){yb.initAttributes();var ma=ec.get(U);U.hasPositions&&!ma.position&&(ma.position=Ra.createBuffer());U.hasNormals&&!ma.normal&&(ma.normal=Ra.createBuffer());U.hasUvs&&!ma.uv&&(ma.uv=Ra.createBuffer());U.hasColors&&!ma.color&&(ma.color=Ra.createBuffer());da=da.getAttributes();U.hasPositions&&(Ra.bindBuffer(34962,ma.position),Ra.bufferData(34962,U.positionArray,35048),yb.enableAttribute(da.position),Ra.vertexAttribPointer(da.position,3,5126,!1,0,0));U.hasNormals&&(Ra.bindBuffer(34962,ma.normal),
Ra.bufferData(34962,U.normalArray,35048),yb.enableAttribute(da.normal),Ra.vertexAttribPointer(da.normal,3,5126,!1,0,0));U.hasUvs&&(Ra.bindBuffer(34962,ma.uv),Ra.bufferData(34962,U.uvArray,35048),yb.enableAttribute(da.uv),Ra.vertexAttribPointer(da.uv,2,5126,!1,0,0));U.hasColors&&(Ra.bindBuffer(34962,ma.color),Ra.bufferData(34962,U.colorArray,35048),yb.enableAttribute(da.color),Ra.vertexAttribPointer(da.color,3,5126,!1,0,0));yb.disableUnusedAttributes();Ra.drawArrays(4,0,U.count);U.count=0};this.renderBufferDirect=
function(U,da,ma,Ia,Oa,ab){yb.setMaterial(Ia,Oa.isMesh&&0>Oa.matrixWorld.determinant());var Pa=ha(U,da,Ia,Oa),fb=!1;if(c!==ma.id||eb!==Pa.id||mb!==(!0===Ia.wireframe))c=ma.id,eb=Pa.id,mb=!0===Ia.wireframe,fb=!0;Oa.morphTargetInfluences&&(Bj.update(Oa,ma,Ia,Pa),fb=!0);var Cb=ma.index,ob=ma.attributes.position;da=1;!0===Ia.wireframe&&(Cb=Ph.getWireframeAttribute(ma),da=2);U=Cj;if(null!==Cb){var $a=vg.get(Cb);U=Dj;U.setIndex($a)}fb&&(P(Ia,Pa,ma),null!==Cb&&Ra.bindBuffer(34963,$a.buffer));$a=Infinity;
null!==Cb?$a=Cb.count:void 0!==ob&&($a=ob.count);ob=ma.drawRange.start*da;Pa=null!==ab?ab.start*da:0;Cb=Math.max(ob,Pa);ab=Math.max(0,Math.min($a,ob+ma.drawRange.count*da,Pa+(null!==ab?ab.count*da:Infinity))-1-Cb+1);if(0!==ab){if(Oa.isMesh)if(!0===Ia.wireframe)yb.setLineWidth(Ia.wireframeLinewidth*e()),U.setMode(1);else switch(Oa.drawMode){case 0:U.setMode(4);break;case 1:U.setMode(5);break;case 2:U.setMode(6)}else Oa.isLine?(Ia=Ia.linewidth,void 0===Ia&&(Ia=1),yb.setLineWidth(Ia*e()),Oa.isLineSegments?
U.setMode(1):Oa.isLineLoop?U.setMode(2):U.setMode(3)):Oa.isPoints?U.setMode(0):Oa.isSprite&&U.setMode(4);ma&&ma.isInstancedBufferGeometry?0<ma.maxInstancedCount&&U.renderInstances(ma,Cb,ab):U.render(Cb,ab)}};this.compile=function(U,da){cb=ye.get(U,da);cb.init();U.traverse(function(ma){ma.isLight&&(cb.pushLight(ma),ma.castShadow&&cb.pushShadow(ma))});cb.setupLights(da);U.traverse(function(ma){if(ma.material)if(Array.isArray(ma.material))for(var Ia=0;Ia<ma.material.length;Ia++)W(ma.material[Ia],U.fog,
ma);else W(ma.material,U.fog,ma)})};var Th=null,yg=new bc;yg.setAnimationLoop(function(U){dd.isPresenting()||Th&&Th(U)});"undefined"!==typeof window&&yg.setContext(window);this.setAnimationLoop=function(U){Th=U;dd.setAnimationLoop(U);yg.start()};this.render=function(U,da,ma,Ia){if(void 0!==ma){console.warn("THREE.WebGLRenderer.render(): the renderTarget argument has been removed. Use .setRenderTarget() instead.");var Oa=ma}if(void 0!==Ia){console.warn("THREE.WebGLRenderer.render(): the forceClear argument has been removed. Use .clear() instead.");
var ab=Ia}da&&da.isCamera?Ga||(eb=c=null,mb=!1,Qa=-1,pb=null,!0===U.autoUpdate&&U.updateMatrixWorld(),null===da.parent&&da.updateMatrixWorld(),dd.enabled&&(da=dd.getCamera(da)),cb=ye.get(U,da),cb.init(),U.onBeforeRender(ja,U,da,Oa||ib),wf.multiplyMatrices(da.projectionMatrix,da.matrixWorldInverse),Qh.setFromMatrix(wf),Rh=this.localClippingEnabled,xg=yc.init(this.clippingPlanes,Rh,da),Na=wg.get(U,da),Na.init(),R(U,da,0,ja.sortObjects),!0===ja.sortObjects&&Na.sort(),xg&&yc.beginShadows(),Ej.render(cb.state.shadowsArray,
U,da),cb.setupLights(da),xg&&yc.endShadows(),this.info.autoReset&&this.info.reset(),void 0!==Oa&&this.setRenderTarget(Oa),yd.render(Na,U,da,ab),ma=Na.opaque,Ia=Na.transparent,U.overrideMaterial?(Oa=U.overrideMaterial,ma.length&&S(ma,U,da,Oa),Ia.length&&S(Ia,U,da,Oa)):(ma.length&&S(ma,U,da),Ia.length&&S(Ia,U,da)),null!==ib&&(Oc.updateRenderTargetMipmap(ib),Oc.updateMultisampleRenderTarget(ib)),yb.buffers.depth.setTest(!0),yb.buffers.depth.setMask(!0),yb.buffers.color.setMask(!0),yb.setPolygonOffset(!1),
dd.enabled&&dd.submitFrame(),cb=Na=null):console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.")};this.setFramebuffer=function(U){La!==U&&Ra.bindFramebuffer(36160,U);La=U};this.getActiveCubeFace=function(){return nb};this.getActiveMipmapLevel=function(){return Va};this.getRenderTarget=function(){return ib};this.setRenderTarget=function(U,da,ma){ib=U;nb=da;Va=ma;U&&void 0===ec.get(U).__webglFramebuffer&&Oc.setupRenderTarget(U);var Ia=La,Oa=!1;U?(Ia=ec.get(U).__webglFramebuffer,
U.isWebGLRenderTargetCube?(Ia=Ia[da||0],Oa=!0):Ia=U.isWebGLMultisampleRenderTarget?ec.get(U).__webglMultisampledFramebuffer:Ia,Kb.copy(U.viewport),Sb.copy(U.scissor),nc=U.scissorTest):(Kb.copy(we).multiplyScalar(cc).floor(),Sb.copy(ve).multiplyScalar(cc).floor(),nc=Sh);kb!==Ia&&(Ra.bindFramebuffer(36160,Ia),kb=Ia);yb.viewport(Kb);yb.scissor(Sb);yb.setScissorTest(nc);Oa&&(U=ec.get(U.texture),Ra.framebufferTexture2D(36160,36064,34069+(da||0),U.__webglTexture,ma||0))};this.readRenderTargetPixels=function(U,
da,ma,Ia,Oa,ab,Pa){if(U&&U.isWebGLRenderTarget){var fb=ec.get(U).__webglFramebuffer;U.isWebGLRenderTargetCube&&void 0!==Pa&&(fb=fb[Pa]);if(fb){Pa=!1;fb!==kb&&(Ra.bindFramebuffer(36160,fb),Pa=!0);try{var Cb=U.texture,ob=Cb.format,$a=Cb.type;1023!==ob&&Nc.convert(ob)!==Ra.getParameter(35739)?console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format."):1009===$a||Nc.convert($a)===Ra.getParameter(35738)||1015===$a&&(dc.isWebGL2||Lb.get("OES_texture_float")||
Lb.get("WEBGL_color_buffer_float"))||1016===$a&&(dc.isWebGL2?Lb.get("EXT_color_buffer_float"):Lb.get("EXT_color_buffer_half_float"))?36053===Ra.checkFramebufferStatus(36160)?0<=da&&da<=U.width-Ia&&0<=ma&&ma<=U.height-Oa&&Ra.readPixels(da,ma,Ia,Oa,Nc.convert(ob),Nc.convert($a),ab):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete."):console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.")}finally{Pa&&
Ra.bindFramebuffer(36160,kb)}}}else console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.")};this.copyFramebufferToTexture=function(U,da,ma){var Ia=da.image.width,Oa=da.image.height,ab=Nc.convert(da.format);Oc.setTexture2D(da,0);Ra.copyTexImage2D(3553,ma||0,ab,U.x,U.y,Ia,Oa,0)};this.copyTextureToTexture=function(U,da,ma,Ia){var Oa=da.image.width,ab=da.image.height,Pa=Nc.convert(ma.format),fb=Nc.convert(ma.type);Oc.setTexture2D(ma,0);da.isDataTexture?
Ra.texSubImage2D(3553,Ia||0,U.x,U.y,Oa,ab,Pa,fb,da.image.data):Ra.texSubImage2D(3553,Ia||0,U.x,U.y,Pa,fb,da.image)};"undefined"!==typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}function zg(a,c){this.name="";this.color=new I(a);this.density=void 0!==c?c:2.5E-4}function Ag(a,c,e){this.name="";this.color=new I(a);this.near=void 0!==c?c:1;this.far=void 0!==e?e:1E3}function Qd(a,c){this.array=a;this.stride=c;this.count=void 0!==a?a.length/c:0;this.dynamic=
!1;this.updateRange={offset:0,count:-1};this.version=0}function xf(a,c,e,g){this.data=a;this.itemSize=c;this.offset=e;this.normalized=!0===g}function Ad(a){M.call(this);this.type="SpriteMaterial";this.color=new I(16777215);this.map=null;this.rotation=0;this.sizeAttenuation=!0;this.lights=!1;this.transparent=!0;this.setValues(a)}function yf(a){A.call(this);this.type="Sprite";if(void 0===Ae){Ae=new va;var c=new Qd(new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),5);Ae.setIndex([0,
1,2,0,2,3]);Ae.addAttribute("position",new xf(c,3,0,!1));Ae.addAttribute("uv",new xf(c,2,3,!1))}this.geometry=Ae;this.material=void 0!==a?a:new Ad;this.center=new f(.5,.5)}function Bg(a,c,e,g,r,v){Be.subVectors(a,e).addScalar(.5).multiply(g);void 0!==r?(zf.x=v*Be.x-r*Be.y,zf.y=r*Be.x+v*Be.y):zf.copy(Be);a.copy(c);a.x+=zf.x;a.y+=zf.y;a.applyMatrix4(Fj)}function Af(){A.call(this);this.type="LOD";Object.defineProperties(this,{levels:{enumerable:!0,value:[]}});this.autoUpdate=!0}function Bf(a,c){a&&a.isGeometry&&
console.error("THREE.SkinnedMesh no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");xa.call(this,a,c);this.type="SkinnedMesh";this.bindMode="attached";this.bindMatrix=new q;this.bindMatrixInverse=new q}function Cg(a,c){a=a||[];this.bones=a.slice(0);this.boneMatrices=new Float32Array(16*this.bones.length);if(void 0===c)this.calculateInverses();else if(this.bones.length===c.length)this.boneInverses=c.slice(0);else for(console.warn("THREE.Skeleton boneInverses is the wrong length."),
this.boneInverses=[],a=0,c=this.bones.length;a<c;a++)this.boneInverses.push(new q)}function Uh(){A.call(this);this.type="Bone"}function Fb(a){M.call(this);this.type="LineBasicMaterial";this.color=new I(16777215);this.linewidth=1;this.linejoin=this.linecap="round";this.lights=!1;this.setValues(a)}function Vb(a,c,e){1===e&&console.error("THREE.Line: parameter THREE.LinePieces no longer supported. Use THREE.LineSegments instead.");A.call(this);this.type="Line";this.geometry=void 0!==a?a:new va;this.material=
void 0!==c?c:new Fb({color:16777215*Math.random()})}function Ib(a,c){Vb.call(this,a,c);this.type="LineSegments"}function Dg(a,c){Vb.call(this,a,c);this.type="LineLoop"}function Ac(a){M.call(this);this.type="PointsMaterial";this.color=new I(16777215);this.map=null;this.size=1;this.sizeAttenuation=!0;this.lights=this.morphTargets=!1;this.setValues(a)}function Ce(a,c){A.call(this);this.type="Points";this.geometry=void 0!==a?a:new va;this.material=void 0!==c?c:new Ac({color:16777215*Math.random()});this.updateMorphTargets()}
function Vh(a,c,e,g,r,v,z){var E=Wh.distanceSqToPoint(a);E<e&&(e=new k,Wh.closestPointToPoint(a,e),e.applyMatrix4(g),a=r.ray.origin.distanceTo(e),a<r.near||a>r.far||v.push({distance:a,distanceToRay:Math.sqrt(E),point:e,index:c,face:null,object:z}))}function Xh(a,c,e,g,r,v,z,E,F){l.call(this,a,c,e,g,r,v,z,E,F);this.format=void 0!==z?z:1022;this.minFilter=void 0!==v?v:1006;this.magFilter=void 0!==r?r:1006;this.generateMipmaps=!1}function De(a,c,e,g,r,v,z,E,F,J,P,R){l.call(this,null,v,z,E,F,J,g,r,P,
R);this.image={width:c,height:e};this.mipmaps=a;this.generateMipmaps=this.flipY=!1}function Cf(a,c,e,g,r,v,z,E,F){l.call(this,a,c,e,g,r,v,z,E,F);this.needsUpdate=!0}function Df(a,c,e,g,r,v,z,E,F,J){J=void 0!==J?J:1026;if(1026!==J&&1027!==J)throw Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");void 0===e&&1026===J&&(e=1012);void 0===e&&1027===J&&(e=1020);l.call(this,null,g,r,v,z,E,J,e,F);this.image={width:a,height:c};this.magFilter=void 0!==z?z:1003;this.minFilter=
void 0!==E?E:1003;this.generateMipmaps=this.flipY=!1}function Ee(a){va.call(this);this.type="WireframeGeometry";var c=[],e,g,r,v=[0,0],z={},E=["a","b","c"];if(a&&a.isGeometry){var F=a.faces;var J=0;for(g=F.length;J<g;J++){var P=F[J];for(e=0;3>e;e++){var R=P[E[e]];var S=P[E[(e+1)%3]];v[0]=Math.min(R,S);v[1]=Math.max(R,S);R=v[0]+","+v[1];void 0===z[R]&&(z[R]={index1:v[0],index2:v[1]})}}for(R in z)J=z[R],E=a.vertices[J.index1],c.push(E.x,E.y,E.z),E=a.vertices[J.index2],c.push(E.x,E.y,E.z)}else if(a&&
a.isBufferGeometry)if(E=new k,null!==a.index){F=a.attributes.position;P=a.index;var V=a.groups;0===V.length&&(V=[{start:0,count:P.count,materialIndex:0}]);a=0;for(r=V.length;a<r;++a)for(J=V[a],e=J.start,g=J.count,J=e,g=e+g;J<g;J+=3)for(e=0;3>e;e++)R=P.getX(J+e),S=P.getX(J+(e+1)%3),v[0]=Math.min(R,S),v[1]=Math.max(R,S),R=v[0]+","+v[1],void 0===z[R]&&(z[R]={index1:v[0],index2:v[1]});for(R in z)J=z[R],E.fromBufferAttribute(F,J.index1),c.push(E.x,E.y,E.z),E.fromBufferAttribute(F,J.index2),c.push(E.x,
E.y,E.z)}else for(F=a.attributes.position,J=0,g=F.count/3;J<g;J++)for(e=0;3>e;e++)z=3*J+e,E.fromBufferAttribute(F,z),c.push(E.x,E.y,E.z),z=3*J+(e+1)%3,E.fromBufferAttribute(F,z),c.push(E.x,E.y,E.z);this.addAttribute("position",new ca(c,3))}function Ef(a,c,e){ya.call(this);this.type="ParametricGeometry";this.parameters={func:a,slices:c,stacks:e};this.fromBufferGeometry(new Fe(a,c,e));this.mergeVertices()}function Fe(a,c,e){va.call(this);this.type="ParametricBufferGeometry";this.parameters={func:a,
slices:c,stacks:e};var g=[],r=[],v=[],z=[],E=new k,F=new k,J=new k,P=new k,R=new k,S,V;3>a.length&&console.error("THREE.ParametricGeometry: Function must now modify a Vector3 as third parameter.");var W=c+1;for(S=0;S<=e;S++){var ha=S/e;for(V=0;V<=c;V++){var fa=V/c;a(fa,ha,F);r.push(F.x,F.y,F.z);0<=fa-1E-5?(a(fa-1E-5,ha,J),P.subVectors(F,J)):(a(fa+1E-5,ha,J),P.subVectors(J,F));0<=ha-1E-5?(a(fa,ha-1E-5,J),R.subVectors(F,J)):(a(fa,ha+1E-5,J),R.subVectors(J,F));E.crossVectors(P,R).normalize();v.push(E.x,
E.y,E.z);z.push(fa,ha)}}for(S=0;S<e;S++)for(V=0;V<c;V++)a=S*W+V+1,E=(S+1)*W+V+1,F=(S+1)*W+V,g.push(S*W+V,a,F),g.push(a,E,F);this.setIndex(g);this.addAttribute("position",new ca(r,3));this.addAttribute("normal",new ca(v,3));this.addAttribute("uv",new ca(z,2))}function Ff(a,c,e,g){ya.call(this);this.type="PolyhedronGeometry";this.parameters={vertices:a,indices:c,radius:e,detail:g};this.fromBufferGeometry(new jc(a,c,e,g));this.mergeVertices()}function jc(a,c,e,g){function r(W,ha,fa,ra){ra=Math.pow(2,
ra);var pa=[],qa,ua;for(qa=0;qa<=ra;qa++){pa[qa]=[];var oa=W.clone().lerp(fa,qa/ra),ta=ha.clone().lerp(fa,qa/ra),Ba=ra-qa;for(ua=0;ua<=Ba;ua++)pa[qa][ua]=0===ua&&qa===ra?oa:oa.clone().lerp(ta,ua/Ba)}for(qa=0;qa<ra;qa++)for(ua=0;ua<2*(ra-qa)-1;ua++)W=Math.floor(ua/2),0===ua%2?(z(pa[qa][W+1]),z(pa[qa+1][W]),z(pa[qa][W])):(z(pa[qa][W+1]),z(pa[qa+1][W+1]),z(pa[qa+1][W]))}function v(){for(var W=0;W<V.length;W+=6){var ha=V[W+0],fa=V[W+2],ra=V[W+4],pa=Math.min(ha,fa,ra);.9<Math.max(ha,fa,ra)&&.1>pa&&(.2>
ha&&(V[W+0]+=1),.2>fa&&(V[W+2]+=1),.2>ra&&(V[W+4]+=1))}}function z(W){S.push(W.x,W.y,W.z)}function E(W,ha){W*=3;ha.x=a[W+0];ha.y=a[W+1];ha.z=a[W+2]}function F(){for(var W=new k,ha=new k,fa=new k,ra=new k,pa=new f,qa=new f,ua=new f,oa=0,ta=0;oa<S.length;oa+=9,ta+=6){W.set(S[oa+0],S[oa+1],S[oa+2]);ha.set(S[oa+3],S[oa+4],S[oa+5]);fa.set(S[oa+6],S[oa+7],S[oa+8]);pa.set(V[ta+0],V[ta+1]);qa.set(V[ta+2],V[ta+3]);ua.set(V[ta+4],V[ta+5]);ra.copy(W).add(ha).add(fa).divideScalar(3);var Ba=P(ra);J(pa,ta+0,W,
Ba);J(qa,ta+2,ha,Ba);J(ua,ta+4,fa,Ba)}}function J(W,ha,fa,ra){0>ra&&1===W.x&&(V[ha]=W.x-1);0===fa.x&&0===fa.z&&(V[ha]=ra/2/Math.PI+.5)}function P(W){return Math.atan2(W.z,-W.x)}function R(W){return Math.atan2(-W.y,Math.sqrt(W.x*W.x+W.z*W.z))}va.call(this);this.type="PolyhedronBufferGeometry";this.parameters={vertices:a,indices:c,radius:e,detail:g};e=e||1;g=g||0;var S=[],V=[];(function(W){for(var ha=new k,fa=new k,ra=new k,pa=0;pa<c.length;pa+=3)E(c[pa+0],ha),E(c[pa+1],fa),E(c[pa+2],ra),r(ha,fa,ra,
W)})(g);(function(W){for(var ha=new k,fa=0;fa<S.length;fa+=3)ha.x=S[fa+0],ha.y=S[fa+1],ha.z=S[fa+2],ha.normalize().multiplyScalar(W),S[fa+0]=ha.x,S[fa+1]=ha.y,S[fa+2]=ha.z})(e);(function(){for(var W=new k,ha=0;ha<S.length;ha+=3){W.x=S[ha+0];W.y=S[ha+1];W.z=S[ha+2];var fa=P(W)/2/Math.PI+.5,ra=R(W)/Math.PI+.5;V.push(fa,1-ra)}F();v()})();this.addAttribute("position",new ca(S,3));this.addAttribute("normal",new ca(S.slice(),3));this.addAttribute("uv",new ca(V,2));0===g?this.computeVertexNormals():this.normalizeNormals()}
function Gf(a,c){ya.call(this);this.type="TetrahedronGeometry";this.parameters={radius:a,detail:c};this.fromBufferGeometry(new Ge(a,c));this.mergeVertices()}function Ge(a,c){jc.call(this,[1,1,1,-1,-1,1,-1,1,-1,1,-1,-1],[2,1,0,0,3,2,1,3,0,2,3,1],a,c);this.type="TetrahedronBufferGeometry";this.parameters={radius:a,detail:c}}function Hf(a,c){ya.call(this);this.type="OctahedronGeometry";this.parameters={radius:a,detail:c};this.fromBufferGeometry(new Rd(a,c));this.mergeVertices()}function Rd(a,c){jc.call(this,
[1,0,0,-1,0,0,0,1,0,0,-1,0,0,0,1,0,0,-1],[0,2,4,0,4,3,0,3,5,0,5,2,1,2,5,1,5,3,1,3,4,1,4,2],a,c);this.type="OctahedronBufferGeometry";this.parameters={radius:a,detail:c}}function If(a,c){ya.call(this);this.type="IcosahedronGeometry";this.parameters={radius:a,detail:c};this.fromBufferGeometry(new He(a,c));this.mergeVertices()}function He(a,c){var e=(1+Math.sqrt(5))/2;jc.call(this,[-1,e,0,1,e,0,-1,-e,0,1,-e,0,0,-1,e,0,1,e,0,-1,-e,0,1,-e,e,0,-1,e,0,1,-e,0,-1,-e,0,1],[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],a,c);this.type="IcosahedronBufferGeometry";this.parameters={radius:a,detail:c}}function Jf(a,c){ya.call(this);this.type="DodecahedronGeometry";this.parameters={radius:a,detail:c};this.fromBufferGeometry(new Ie(a,c));this.mergeVertices()}function Ie(a,c){var e=(1+Math.sqrt(5))/2,g=1/e;jc.call(this,[-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,-g,-e,0,-g,e,0,g,-e,0,g,e,-g,-e,0,-g,e,0,g,
-e,0,g,e,0,-e,0,-g,e,0,-g,-e,0,g,e,0,g],[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],a,c);this.type="DodecahedronBufferGeometry";this.parameters={radius:a,detail:c}}function Kf(a,c,e,g,r,v){ya.call(this);this.type="TubeGeometry";this.parameters={path:a,tubularSegments:c,radius:e,
radialSegments:g,closed:r};void 0!==v&&console.warn("THREE.TubeGeometry: taper has been removed.");a=new Sd(a,c,e,g,r);this.tangents=a.tangents;this.normals=a.normals;this.binormals=a.binormals;this.fromBufferGeometry(a);this.mergeVertices()}function Sd(a,c,e,g,r){function v(qa){S=a.getPointAt(qa/c,S);var ua=F.normals[qa];qa=F.binormals[qa];for(W=0;W<=g;W++){var oa=W/g*Math.PI*2,ta=Math.sin(oa);oa=-Math.cos(oa);P.x=oa*ua.x+ta*qa.x;P.y=oa*ua.y+ta*qa.y;P.z=oa*ua.z+ta*qa.z;P.normalize();fa.push(P.x,
P.y,P.z);J.x=S.x+e*P.x;J.y=S.y+e*P.y;J.z=S.z+e*P.z;ha.push(J.x,J.y,J.z)}}function z(){for(W=1;W<=c;W++)for(V=1;V<=g;V++){var qa=(g+1)*W+(V-1),ua=(g+1)*W+V,oa=(g+1)*(W-1)+V;pa.push((g+1)*(W-1)+(V-1),qa,oa);pa.push(qa,ua,oa)}}function E(){for(V=0;V<=c;V++)for(W=0;W<=g;W++)R.x=V/c,R.y=W/g,ra.push(R.x,R.y)}va.call(this);this.type="TubeBufferGeometry";this.parameters={path:a,tubularSegments:c,radius:e,radialSegments:g,closed:r};c=c||64;e=e||1;g=g||8;r=r||!1;var F=a.computeFrenetFrames(c,r);this.tangents=
F.tangents;this.normals=F.normals;this.binormals=F.binormals;var J=new k,P=new k,R=new f,S=new k,V,W,ha=[],fa=[],ra=[],pa=[];(function(){for(V=0;V<c;V++)v(V);v(!1===r?c:0);E();z()})();this.setIndex(pa);this.addAttribute("position",new ca(ha,3));this.addAttribute("normal",new ca(fa,3));this.addAttribute("uv",new ca(ra,2))}function Lf(a,c,e,g,r,v,z){ya.call(this);this.type="TorusKnotGeometry";this.parameters={radius:a,tube:c,tubularSegments:e,radialSegments:g,p:r,q:v};void 0!==z&&console.warn("THREE.TorusKnotGeometry: heightScale has been deprecated. Use .scale( x, y, z ) instead.");
this.fromBufferGeometry(new Je(a,c,e,g,r,v));this.mergeVertices()}function Je(a,c,e,g,r,v){function z(ta,Ba,Ta,Ua,Ca){var Ha=Math.sin(ta);Ba=Ta/Ba*ta;Ta=Math.cos(Ba);Ca.x=Ua*(2+Ta)*.5*Math.cos(ta);Ca.y=Ua*(2+Ta)*Ha*.5;Ca.z=Ua*Math.sin(Ba)*.5}va.call(this);this.type="TorusKnotBufferGeometry";this.parameters={radius:a,tube:c,tubularSegments:e,radialSegments:g,p:r,q:v};a=a||1;c=c||.4;e=Math.floor(e)||64;g=Math.floor(g)||8;r=r||2;v=v||3;var E=[],F=[],J=[],P=[],R,S=new k,V=new k,W=new k,ha=new k,fa=new k,
ra=new k,pa=new k;for(R=0;R<=e;++R){var qa=R/e*r*Math.PI*2;z(qa,r,v,a,W);z(qa+.01,r,v,a,ha);ra.subVectors(ha,W);pa.addVectors(ha,W);fa.crossVectors(ra,pa);pa.crossVectors(fa,ra);fa.normalize();pa.normalize();for(qa=0;qa<=g;++qa){var ua=qa/g*Math.PI*2,oa=-c*Math.cos(ua);ua=c*Math.sin(ua);S.x=W.x+(oa*pa.x+ua*fa.x);S.y=W.y+(oa*pa.y+ua*fa.y);S.z=W.z+(oa*pa.z+ua*fa.z);F.push(S.x,S.y,S.z);V.subVectors(S,W).normalize();J.push(V.x,V.y,V.z);P.push(R/e);P.push(qa/g)}}for(qa=1;qa<=e;qa++)for(R=1;R<=g;R++)a=
(g+1)*qa+(R-1),c=(g+1)*qa+R,r=(g+1)*(qa-1)+R,E.push((g+1)*(qa-1)+(R-1),a,r),E.push(a,c,r);this.setIndex(E);this.addAttribute("position",new ca(F,3));this.addAttribute("normal",new ca(J,3));this.addAttribute("uv",new ca(P,2))}function Mf(a,c,e,g,r){ya.call(this);this.type="TorusGeometry";this.parameters={radius:a,tube:c,radialSegments:e,tubularSegments:g,arc:r};this.fromBufferGeometry(new Ke(a,c,e,g,r));this.mergeVertices()}function Ke(a,c,e,g,r){va.call(this);this.type="TorusBufferGeometry";this.parameters=
{radius:a,tube:c,radialSegments:e,tubularSegments:g,arc:r};a=a||1;c=c||.4;e=Math.floor(e)||8;g=Math.floor(g)||6;r=r||2*Math.PI;var v=[],z=[],E=[],F=[],J=new k,P=new k,R=new k,S,V;for(S=0;S<=e;S++)for(V=0;V<=g;V++){var W=V/g*r,ha=S/e*Math.PI*2;P.x=(a+c*Math.cos(ha))*Math.cos(W);P.y=(a+c*Math.cos(ha))*Math.sin(W);P.z=c*Math.sin(ha);z.push(P.x,P.y,P.z);J.x=a*Math.cos(W);J.y=a*Math.sin(W);R.subVectors(P,J).normalize();E.push(R.x,R.y,R.z);F.push(V/g);F.push(S/e)}for(S=1;S<=e;S++)for(V=1;V<=g;V++)a=(g+
1)*(S-1)+V-1,c=(g+1)*(S-1)+V,r=(g+1)*S+V,v.push((g+1)*S+V-1,a,r),v.push(a,c,r);this.setIndex(v);this.addAttribute("position",new ca(z,3));this.addAttribute("normal",new ca(E,3));this.addAttribute("uv",new ca(F,2))}function Gj(a,c,e,g,r){if(r===0<Xl(a,c,e,g))for(r=c;r<e;r+=g)var v=Hj(r,a[r],a[r+1],v);else for(r=e-g;r>=c;r-=g)v=Hj(r,a[r],a[r+1],v);v&&Td(v,v.next)&&(Nf(v),v=v.next);return v}function Of(a,c){if(!a)return a;c||(c=a);do{var e=!1;if(a.steiner||!Td(a,a.next)&&0!==Wb(a.prev,a,a.next))a=a.next;
else{Nf(a);a=c=a.prev;if(a===a.next)break;e=!0}}while(e||a!==c);return c}function Pf(a,c,e,g,r,v,z){if(a){!z&&v&&Yl(a,g,r,v);for(var E=a,F,J;a.prev!==a.next;)if(F=a.prev,J=a.next,v?Zl(a,g,r,v):$l(a))c.push(F.i/e),c.push(a.i/e),c.push(J.i/e),Nf(a),E=a=J.next;else if(a=J,a===E){z?1===z?(a=am(a,c,e),Pf(a,c,e,g,r,v,2)):2===z&&bm(a,c,e,g,r,v):Pf(Of(a),c,e,g,r,v,1);break}}}function $l(a){var c=a.prev,e=a.next;if(0<=Wb(c,a,e))return!1;for(var g=a.next.next;g!==a.prev;){if(Le(c.x,c.y,a.x,a.y,e.x,e.y,g.x,
g.y)&&0<=Wb(g.prev,g,g.next))return!1;g=g.next}return!0}function Zl(a,c,e,g){var r=a.prev,v=a.next;if(0<=Wb(r,a,v))return!1;var z=r.x>a.x?r.x>v.x?r.x:v.x:a.x>v.x?a.x:v.x,E=r.y>a.y?r.y>v.y?r.y:v.y:a.y>v.y?a.y:v.y,F=Yh(r.x<a.x?r.x<v.x?r.x:v.x:a.x<v.x?a.x:v.x,r.y<a.y?r.y<v.y?r.y:v.y:a.y<v.y?a.y:v.y,c,e,g);c=Yh(z,E,c,e,g);e=a.prevZ;for(g=a.nextZ;e&&e.z>=F&&g&&g.z<=c;){if(e!==a.prev&&e!==a.next&&Le(r.x,r.y,a.x,a.y,v.x,v.y,e.x,e.y)&&0<=Wb(e.prev,e,e.next))return!1;e=e.prevZ;if(g!==a.prev&&g!==a.next&&Le(r.x,
r.y,a.x,a.y,v.x,v.y,g.x,g.y)&&0<=Wb(g.prev,g,g.next))return!1;g=g.nextZ}for(;e&&e.z>=F;){if(e!==a.prev&&e!==a.next&&Le(r.x,r.y,a.x,a.y,v.x,v.y,e.x,e.y)&&0<=Wb(e.prev,e,e.next))return!1;e=e.prevZ}for(;g&&g.z<=c;){if(g!==a.prev&&g!==a.next&&Le(r.x,r.y,a.x,a.y,v.x,v.y,g.x,g.y)&&0<=Wb(g.prev,g,g.next))return!1;g=g.nextZ}return!0}function am(a,c,e){var g=a;do{var r=g.prev,v=g.next.next;!Td(r,v)&&Ij(r,g,g.next,v)&&Qf(r,v)&&Qf(v,r)&&(c.push(r.i/e),c.push(g.i/e),c.push(v.i/e),Nf(g),Nf(g.next),g=a=v);g=g.next}while(g!==
a);return g}function bm(a,c,e,g,r,v){var z=a;do{for(var E=z.next.next;E!==z.prev;){if(z.i!==E.i&&cm(z,E)){a=Jj(z,E);z=Of(z,z.next);a=Of(a,a.next);Pf(z,c,e,g,r,v);Pf(a,c,e,g,r,v);return}E=E.next}z=z.next}while(z!==a)}function dm(a,c,e,g){var r=[],v;var z=0;for(v=c.length;z<v;z++){var E=c[z]*g;var F=z<v-1?c[z+1]*g:a.length;E=Gj(a,E,F,g,!1);E===E.next&&(E.steiner=!0);r.push(em(E))}r.sort(fm);for(z=0;z<r.length;z++)gm(r[z],e),e=Of(e,e.next);return e}function fm(a,c){return a.x-c.x}function gm(a,c){if(c=
hm(a,c))a=Jj(c,a),Of(a,a.next)}function hm(a,c){var e=c,g=a.x,r=a.y,v=-Infinity;do{if(r<=e.y&&r>=e.next.y&&e.next.y!==e.y){var z=e.x+(r-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(z<=g&&z>v){v=z;if(z===g){if(r===e.y)return e;if(r===e.next.y)return e.next}var E=e.x<e.next.x?e:e.next}}e=e.next}while(e!==c);if(!E)return null;if(g===v)return E.prev;c=E;z=E.x;var F=E.y,J=Infinity;for(e=E.next;e!==c;){if(g>=e.x&&e.x>=z&&g!==e.x&&Le(r<F?g:v,r,z,F,r<F?v:g,r,e.x,e.y)){var P=Math.abs(r-e.y)/(g-e.x);(P<J||P===J&&
e.x>E.x)&&Qf(e,a)&&(E=e,J=P)}e=e.next}return E}function Yl(a,c,e,g){var r=a;do null===r.z&&(r.z=Yh(r.x,r.y,c,e,g)),r.prevZ=r.prev,r=r.nextZ=r.next;while(r!==a);r.prevZ.nextZ=null;r.prevZ=null;im(r)}function im(a){var c,e,g,r,v=1;do{var z=a;var E=a=null;for(e=0;z;){e++;var F=z;for(c=g=0;c<v&&(g++,F=F.nextZ,F);c++);for(r=v;0<g||0<r&&F;)0!==g&&(0===r||!F||z.z<=F.z)?(c=z,z=z.nextZ,g--):(c=F,F=F.nextZ,r--),E?E.nextZ=c:a=c,c.prevZ=E,E=c;z=F}E.nextZ=null;v*=2}while(1<e);return a}function Yh(a,c,e,g,r){a=
32767*(a-e)*r;c=32767*(c-g)*r;a=(a|a<<8)&16711935;a=(a|a<<4)&252645135;a=(a|a<<2)&858993459;c=(c|c<<8)&16711935;c=(c|c<<4)&252645135;c=(c|c<<2)&858993459;return(a|a<<1)&1431655765|((c|c<<1)&1431655765)<<1}function em(a){var c=a,e=a;do{if(c.x<e.x||c.x===e.x&&c.y<e.y)e=c;c=c.next}while(c!==a);return e}function Le(a,c,e,g,r,v,z,E){return 0<=(r-z)*(c-E)-(a-z)*(v-E)&&0<=(a-z)*(g-E)-(e-z)*(c-E)&&0<=(e-z)*(v-E)-(r-z)*(g-E)}function cm(a,c){return a.next.i!==c.i&&a.prev.i!==c.i&&!jm(a,c)&&Qf(a,c)&&Qf(c,a)&&
km(a,c)}function Wb(a,c,e){return(c.y-a.y)*(e.x-c.x)-(c.x-a.x)*(e.y-c.y)}function Td(a,c){return a.x===c.x&&a.y===c.y}function Ij(a,c,e,g){return Td(a,e)&&Td(c,g)||Td(a,g)&&Td(e,c)?!0:0<Wb(a,c,e)!==0<Wb(a,c,g)&&0<Wb(e,g,a)!==0<Wb(e,g,c)}function jm(a,c){var e=a;do{if(e.i!==a.i&&e.next.i!==a.i&&e.i!==c.i&&e.next.i!==c.i&&Ij(e,e.next,a,c))return!0;e=e.next}while(e!==a);return!1}function Qf(a,c){return 0>Wb(a.prev,a,a.next)?0<=Wb(a,c,a.next)&&0<=Wb(a,a.prev,c):0>Wb(a,c,a.prev)||0>Wb(a,a.next,c)}function km(a,
c){var e=a,g=!1,r=(a.x+c.x)/2;c=(a.y+c.y)/2;do e.y>c!==e.next.y>c&&e.next.y!==e.y&&r<(e.next.x-e.x)*(c-e.y)/(e.next.y-e.y)+e.x&&(g=!g),e=e.next;while(e!==a);return g}function Jj(a,c){var e=new Zh(a.i,a.x,a.y),g=new Zh(c.i,c.x,c.y),r=a.next,v=c.prev;a.next=c;c.prev=a;e.next=r;r.prev=e;g.next=e;e.prev=g;v.next=g;g.prev=v;return g}function Hj(a,c,e,g){a=new Zh(a,c,e);g?(a.next=g.next,a.prev=g,g.next.prev=a,g.next=a):(a.prev=a,a.next=a);return a}function Nf(a){a.next.prev=a.prev;a.prev.next=a.next;a.prevZ&&
(a.prevZ.nextZ=a.nextZ);a.nextZ&&(a.nextZ.prevZ=a.prevZ)}function Zh(a,c,e){this.i=a;this.x=c;this.y=e;this.nextZ=this.prevZ=this.z=this.next=this.prev=null;this.steiner=!1}function Xl(a,c,e,g){for(var r=0,v=e-g;c<e;c+=g)r+=(a[v]-a[c])*(a[c+1]+a[v+1]),v=c;return r}function Kj(a){var c=a.length;2<c&&a[c-1].equals(a[0])&&a.pop()}function Lj(a,c){for(var e=0;e<c.length;e++)a.push(c[e].x),a.push(c[e].y)}function Ud(a,c){ya.call(this);this.type="ExtrudeGeometry";this.parameters={shapes:a,options:c};this.fromBufferGeometry(new Rc(a,
c));this.mergeVertices()}function Rc(a,c){function e(F){function J(Qa,eb,mb){eb||console.error("THREE.ExtrudeGeometry: vec does not exist");return eb.clone().multiplyScalar(mb).add(Qa)}function P(Qa,eb,mb){var pb=Qa.x-eb.x;var sb=Qa.y-eb.y;var Kb=mb.x-Qa.x;var Sb=mb.y-Qa.y,nc=pb*pb+sb*sb;if(Math.abs(pb*Sb-sb*Kb)>Number.EPSILON){var Qc=Math.sqrt(nc),zc=Math.sqrt(Kb*Kb+Sb*Sb);nc=eb.x-sb/Qc;eb=eb.y+pb/Qc;Sb=((mb.x-Sb/zc-nc)*Sb-(mb.y+Kb/zc-eb)*Kb)/(pb*Sb-sb*Kb);Kb=nc+pb*Sb-Qa.x;pb=eb+sb*Sb-Qa.y;sb=Kb*
Kb+pb*pb;if(2>=sb)return new f(Kb,pb);sb=Math.sqrt(sb/2)}else Qa=!1,pb>Number.EPSILON?Kb>Number.EPSILON&&(Qa=!0):pb<-Number.EPSILON?Kb<-Number.EPSILON&&(Qa=!0):Math.sign(sb)===Math.sign(Sb)&&(Qa=!0),Qa?(Kb=-sb,sb=Math.sqrt(nc)):(Kb=pb,pb=sb,sb=Math.sqrt(nc/2));return new f(Kb/sb,pb/sb)}function R(Qa,eb){for(ja=Qa.length;0<=--ja;){var mb=ja;var pb=ja-1;0>pb&&(pb=Qa.length-1);var sb,Kb=qa+2*Ua;for(sb=0;sb<Kb;sb++){var Sb=Ya*sb,nc=Ya*(sb+1);W(eb+mb+Sb,eb+pb+Sb,eb+pb+nc,eb+mb+nc)}}}function S(Qa,eb,mb){ra.push(Qa);
ra.push(eb);ra.push(mb)}function V(Qa,eb,mb){ha(Qa);ha(eb);ha(mb);Qa=r.length/3;Qa=Ha.generateTopUV(g,r,Qa-3,Qa-2,Qa-1);fa(Qa[0]);fa(Qa[1]);fa(Qa[2])}function W(Qa,eb,mb,pb){ha(Qa);ha(eb);ha(pb);ha(eb);ha(mb);ha(pb);Qa=r.length/3;Qa=Ha.generateSideWallUV(g,r,Qa-6,Qa-3,Qa-2,Qa-1);fa(Qa[0]);fa(Qa[1]);fa(Qa[3]);fa(Qa[1]);fa(Qa[2]);fa(Qa[3])}function ha(Qa){r.push(ra[3*Qa]);r.push(ra[3*Qa+1]);r.push(ra[3*Qa+2])}function fa(Qa){v.push(Qa.x);v.push(Qa.y)}var ra=[],pa=void 0!==c.curveSegments?c.curveSegments:
12,qa=void 0!==c.steps?c.steps:1,ua=void 0!==c.depth?c.depth:100,oa=void 0!==c.bevelEnabled?c.bevelEnabled:!0,ta=void 0!==c.bevelThickness?c.bevelThickness:6,Ba=void 0!==c.bevelSize?c.bevelSize:ta-2,Ta=void 0!==c.bevelOffset?c.bevelOffset:0,Ua=void 0!==c.bevelSegments?c.bevelSegments:3,Ca=c.extrudePath,Ha=void 0!==c.UVGenerator?c.UVGenerator:lm;void 0!==c.amount&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),ua=c.amount);var Da=!1;if(Ca){var Ma=Ca.getSpacedPoints(qa);
Da=!0;oa=!1;var db=Ca.computeFrenetFrames(qa,!1);var tb=new k;var Ka=new k;var bb=new k}oa||(Ta=Ba=ta=Ua=0);var jb;pa=F.extractPoints(pa);F=pa.shape;var Eb=pa.holes;if(!ed.isClockWise(F)){F=F.reverse();var xb=0;for(jb=Eb.length;xb<jb;xb++){var ia=Eb[xb];ed.isClockWise(ia)&&(Eb[xb]=ia.reverse())}}var na=ed.triangulateShape(F,Eb),za=F;xb=0;for(jb=Eb.length;xb<jb;xb++)ia=Eb[xb],F=F.concat(ia);var Ja,Ya=F.length,Na,cb=na.length;pa=[];var ja=0;var Ga=za.length;var La=Ga-1;for(Ja=ja+1;ja<Ga;ja++,La++,Ja++)La===
Ga&&(La=0),Ja===Ga&&(Ja=0),pa[ja]=P(za[ja],za[La],za[Ja]);Ca=[];var nb=pa.concat();xb=0;for(jb=Eb.length;xb<jb;xb++){ia=Eb[xb];var Va=[];ja=0;Ga=ia.length;La=Ga-1;for(Ja=ja+1;ja<Ga;ja++,La++,Ja++)La===Ga&&(La=0),Ja===Ga&&(Ja=0),Va[ja]=P(ia[ja],ia[La],ia[Ja]);Ca.push(Va);nb=nb.concat(Va)}for(La=0;La<Ua;La++){Ga=La/Ua;var ib=ta*Math.cos(Ga*Math.PI/2);Ja=Ba*Math.sin(Ga*Math.PI/2)+Ta;ja=0;for(Ga=za.length;ja<Ga;ja++){var kb=J(za[ja],pa[ja],Ja);S(kb.x,kb.y,-ib)}xb=0;for(jb=Eb.length;xb<jb;xb++)for(ia=
Eb[xb],Va=Ca[xb],ja=0,Ga=ia.length;ja<Ga;ja++)kb=J(ia[ja],Va[ja],Ja),S(kb.x,kb.y,-ib)}Ja=Ba+Ta;for(ja=0;ja<Ya;ja++)kb=oa?J(F[ja],nb[ja],Ja):F[ja],Da?(Ka.copy(db.normals[0]).multiplyScalar(kb.x),tb.copy(db.binormals[0]).multiplyScalar(kb.y),bb.copy(Ma[0]).add(Ka).add(tb),S(bb.x,bb.y,bb.z)):S(kb.x,kb.y,0);for(Ga=1;Ga<=qa;Ga++)for(ja=0;ja<Ya;ja++)kb=oa?J(F[ja],nb[ja],Ja):F[ja],Da?(Ka.copy(db.normals[Ga]).multiplyScalar(kb.x),tb.copy(db.binormals[Ga]).multiplyScalar(kb.y),bb.copy(Ma[Ga]).add(Ka).add(tb),
S(bb.x,bb.y,bb.z)):S(kb.x,kb.y,ua/qa*Ga);for(La=Ua-1;0<=La;La--){Ga=La/Ua;ib=ta*Math.cos(Ga*Math.PI/2);Ja=Ba*Math.sin(Ga*Math.PI/2)+Ta;ja=0;for(Ga=za.length;ja<Ga;ja++)kb=J(za[ja],pa[ja],Ja),S(kb.x,kb.y,ua+ib);xb=0;for(jb=Eb.length;xb<jb;xb++)for(ia=Eb[xb],Va=Ca[xb],ja=0,Ga=ia.length;ja<Ga;ja++)kb=J(ia[ja],Va[ja],Ja),Da?S(kb.x,kb.y+Ma[qa-1].y,Ma[qa-1].x+ib):S(kb.x,kb.y,ua+ib)}(function(){var Qa=r.length/3;if(oa){var eb=0*Ya;for(ja=0;ja<cb;ja++)Na=na[ja],V(Na[2]+eb,Na[1]+eb,Na[0]+eb);eb=Ya*(qa+2*Ua);
for(ja=0;ja<cb;ja++)Na=na[ja],V(Na[0]+eb,Na[1]+eb,Na[2]+eb)}else{for(ja=0;ja<cb;ja++)Na=na[ja],V(Na[2],Na[1],Na[0]);for(ja=0;ja<cb;ja++)Na=na[ja],V(Na[0]+Ya*qa,Na[1]+Ya*qa,Na[2]+Ya*qa)}g.addGroup(Qa,r.length/3-Qa,0)})();(function(){var Qa=r.length/3,eb=0;R(za,eb);eb+=za.length;xb=0;for(jb=Eb.length;xb<jb;xb++)ia=Eb[xb],R(ia,eb),eb+=ia.length;g.addGroup(Qa,r.length/3-Qa,1)})()}va.call(this);this.type="ExtrudeBufferGeometry";this.parameters={shapes:a,options:c};a=Array.isArray(a)?a:[a];for(var g=this,
r=[],v=[],z=0,E=a.length;z<E;z++)e(a[z]);this.addAttribute("position",new ca(r,3));this.addAttribute("uv",new ca(v,2));this.computeVertexNormals()}function Mj(a,c,e){e.shapes=[];if(Array.isArray(a))for(var g=0,r=a.length;g<r;g++)e.shapes.push(a[g].uuid);else e.shapes.push(a.uuid);void 0!==c.extrudePath&&(e.options.extrudePath=c.extrudePath.toJSON());return e}function Rf(a,c){ya.call(this);this.type="TextGeometry";this.parameters={text:a,parameters:c};this.fromBufferGeometry(new Me(a,c));this.mergeVertices()}
function Me(a,c){c=c||{};var e=c.font;if(!e||!e.isFont)return console.error("THREE.TextGeometry: font parameter is not an instance of THREE.Font."),new ya;a=e.generateShapes(a,c.size);c.depth=void 0!==c.height?c.height:50;void 0===c.bevelThickness&&(c.bevelThickness=10);void 0===c.bevelSize&&(c.bevelSize=8);void 0===c.bevelEnabled&&(c.bevelEnabled=!1);Rc.call(this,a,c);this.type="TextBufferGeometry"}function Sf(a,c,e,g,r,v,z){ya.call(this);this.type="SphereGeometry";this.parameters={radius:a,widthSegments:c,
heightSegments:e,phiStart:g,phiLength:r,thetaStart:v,thetaLength:z};this.fromBufferGeometry(new Bd(a,c,e,g,r,v,z));this.mergeVertices()}function Bd(a,c,e,g,r,v,z){va.call(this);this.type="SphereBufferGeometry";this.parameters={radius:a,widthSegments:c,heightSegments:e,phiStart:g,phiLength:r,thetaStart:v,thetaLength:z};a=a||1;c=Math.max(3,Math.floor(c)||8);e=Math.max(2,Math.floor(e)||6);g=void 0!==g?g:0;r=void 0!==r?r:2*Math.PI;v=void 0!==v?v:0;z=void 0!==z?z:Math.PI;var E=Math.min(v+z,Math.PI),F,
J,P=0,R=[],S=new k,V=new k,W=[],ha=[],fa=[],ra=[];for(J=0;J<=e;J++){var pa=[],qa=J/e,ua=0;0==J&&0==v?ua=.5/c:J==e&&E==Math.PI&&(ua=-.5/c);for(F=0;F<=c;F++){var oa=F/c;S.x=-a*Math.cos(g+oa*r)*Math.sin(v+qa*z);S.y=a*Math.cos(v+qa*z);S.z=a*Math.sin(g+oa*r)*Math.sin(v+qa*z);ha.push(S.x,S.y,S.z);V.copy(S).normalize();fa.push(V.x,V.y,V.z);ra.push(oa+ua,1-qa);pa.push(P++)}R.push(pa)}for(J=0;J<e;J++)for(F=0;F<c;F++)a=R[J][F+1],g=R[J][F],r=R[J+1][F],z=R[J+1][F+1],(0!==J||0<v)&&W.push(a,g,z),(J!==e-1||E<Math.PI)&&
W.push(g,r,z);this.setIndex(W);this.addAttribute("position",new ca(ha,3));this.addAttribute("normal",new ca(fa,3));this.addAttribute("uv",new ca(ra,2))}function Tf(a,c,e,g,r,v){ya.call(this);this.type="RingGeometry";this.parameters={innerRadius:a,outerRadius:c,thetaSegments:e,phiSegments:g,thetaStart:r,thetaLength:v};this.fromBufferGeometry(new Ne(a,c,e,g,r,v));this.mergeVertices()}function Ne(a,c,e,g,r,v){va.call(this);this.type="RingBufferGeometry";this.parameters={innerRadius:a,outerRadius:c,thetaSegments:e,
phiSegments:g,thetaStart:r,thetaLength:v};a=a||.5;c=c||1;r=void 0!==r?r:0;v=void 0!==v?v:2*Math.PI;e=void 0!==e?Math.max(3,e):8;g=void 0!==g?Math.max(1,g):1;var z=[],E=[],F=[],J=[],P=a,R=(c-a)/g,S=new k,V=new f,W,ha;for(W=0;W<=g;W++){for(ha=0;ha<=e;ha++)a=r+ha/e*v,S.x=P*Math.cos(a),S.y=P*Math.sin(a),E.push(S.x,S.y,S.z),F.push(0,0,1),V.x=(S.x/c+1)/2,V.y=(S.y/c+1)/2,J.push(V.x,V.y);P+=R}for(W=0;W<g;W++)for(c=W*(e+1),ha=0;ha<e;ha++)a=ha+c,r=a+e+1,v=a+e+2,P=a+1,z.push(a,r,P),z.push(r,v,P);this.setIndex(z);
this.addAttribute("position",new ca(E,3));this.addAttribute("normal",new ca(F,3));this.addAttribute("uv",new ca(J,2))}function Uf(a,c,e,g){ya.call(this);this.type="LatheGeometry";this.parameters={points:a,segments:c,phiStart:e,phiLength:g};this.fromBufferGeometry(new Oe(a,c,e,g));this.mergeVertices()}function Oe(a,c,e,g){va.call(this);this.type="LatheBufferGeometry";this.parameters={points:a,segments:c,phiStart:e,phiLength:g};c=Math.floor(c)||12;e=e||0;g=g||2*Math.PI;g=hb.clamp(g,0,2*Math.PI);var r=
[],v=[],z=[],E=1/c,F=new k,J=new f,P;for(P=0;P<=c;P++){var R=e+P*E*g;var S=Math.sin(R),V=Math.cos(R);for(R=0;R<=a.length-1;R++)F.x=a[R].x*S,F.y=a[R].y,F.z=a[R].x*V,v.push(F.x,F.y,F.z),J.x=P/c,J.y=R/(a.length-1),z.push(J.x,J.y)}for(P=0;P<c;P++)for(R=0;R<a.length-1;R++)e=R+P*a.length,E=e+a.length,F=e+a.length+1,J=e+1,r.push(e,E,J),r.push(E,F,J);this.setIndex(r);this.addAttribute("position",new ca(v,3));this.addAttribute("uv",new ca(z,2));this.computeVertexNormals();if(g===2*Math.PI)for(g=this.attributes.normal.array,
r=new k,v=new k,z=new k,e=c*a.length*3,R=P=0;P<a.length;P++,R+=3)r.x=g[R+0],r.y=g[R+1],r.z=g[R+2],v.x=g[e+R+0],v.y=g[e+R+1],v.z=g[e+R+2],z.addVectors(r,v).normalize(),g[R+0]=g[e+R+0]=z.x,g[R+1]=g[e+R+1]=z.y,g[R+2]=g[e+R+2]=z.z}function Vd(a,c){ya.call(this);this.type="ShapeGeometry";"object"===typeof c&&(console.warn("THREE.ShapeGeometry: Options parameter has been removed."),c=c.curveSegments);this.parameters={shapes:a,curveSegments:c};this.fromBufferGeometry(new Wd(a,c));this.mergeVertices()}function Wd(a,
c){function e(P){var R,S=r.length/3;P=P.extractPoints(c);var V=P.shape,W=P.holes;!1===ed.isClockWise(V)&&(V=V.reverse());P=0;for(R=W.length;P<R;P++){var ha=W[P];!0===ed.isClockWise(ha)&&(W[P]=ha.reverse())}var fa=ed.triangulateShape(V,W);P=0;for(R=W.length;P<R;P++)ha=W[P],V=V.concat(ha);P=0;for(R=V.length;P<R;P++)ha=V[P],r.push(ha.x,ha.y,0),v.push(0,0,1),z.push(ha.x,ha.y);P=0;for(R=fa.length;P<R;P++)V=fa[P],g.push(V[0]+S,V[1]+S,V[2]+S),F+=3}va.call(this);this.type="ShapeBufferGeometry";this.parameters=
{shapes:a,curveSegments:c};c=c||12;var g=[],r=[],v=[],z=[],E=0,F=0;if(!1===Array.isArray(a))e(a);else for(var J=0;J<a.length;J++)e(a[J]),this.addGroup(E,F,J),E+=F,F=0;this.setIndex(g);this.addAttribute("position",new ca(r,3));this.addAttribute("normal",new ca(v,3));this.addAttribute("uv",new ca(z,2))}function Nj(a,c){c.shapes=[];if(Array.isArray(a))for(var e=0,g=a.length;e<g;e++)c.shapes.push(a[e].uuid);else c.shapes.push(a.uuid);return c}function Pe(a,c){va.call(this);this.type="EdgesGeometry";this.parameters=
{thresholdAngle:c};var e=[];c=Math.cos(hb.DEG2RAD*(void 0!==c?c:1));var g=[0,0],r={},v=["a","b","c"];if(a.isBufferGeometry){var z=new ya;z.fromBufferGeometry(a)}else z=a.clone();z.mergeVertices();z.computeFaceNormals();a=z.vertices;z=z.faces;for(var E=0,F=z.length;E<F;E++)for(var J=z[E],P=0;3>P;P++){var R=J[v[P]];var S=J[v[(P+1)%3]];g[0]=Math.min(R,S);g[1]=Math.max(R,S);R=g[0]+","+g[1];void 0===r[R]?r[R]={index1:g[0],index2:g[1],face1:E,face2:void 0}:r[R].face2=E}for(R in r)if(g=r[R],void 0===g.face2||
z[g.face1].normal.dot(z[g.face2].normal)<=c)v=a[g.index1],e.push(v.x,v.y,v.z),v=a[g.index2],e.push(v.x,v.y,v.z);this.addAttribute("position",new ca(e,3))}function Xd(a,c,e,g,r,v,z,E){ya.call(this);this.type="CylinderGeometry";this.parameters={radiusTop:a,radiusBottom:c,height:e,radialSegments:g,heightSegments:r,openEnded:v,thetaStart:z,thetaLength:E};this.fromBufferGeometry(new fd(a,c,e,g,r,v,z,E));this.mergeVertices()}function fd(a,c,e,g,r,v,z,E){function F(pa){var qa,ua=new f,oa=new k,ta=0,Ba=!0===
pa?a:c,Ta=!0===pa?1:-1;var Ua=W;for(qa=1;qa<=g;qa++)R.push(0,fa*Ta,0),S.push(0,Ta,0),V.push(.5,.5),W++;var Ca=W;for(qa=0;qa<=g;qa++){var Ha=qa/g*E+z,Da=Math.cos(Ha);Ha=Math.sin(Ha);oa.x=Ba*Ha;oa.y=fa*Ta;oa.z=Ba*Da;R.push(oa.x,oa.y,oa.z);S.push(0,Ta,0);ua.x=.5*Da+.5;ua.y=.5*Ha*Ta+.5;V.push(ua.x,ua.y);W++}for(qa=0;qa<g;qa++)ua=Ua+qa,oa=Ca+qa,!0===pa?P.push(oa,oa+1,ua):P.push(oa+1,oa,ua),ta+=3;J.addGroup(ra,ta,!0===pa?1:2);ra+=ta}va.call(this);this.type="CylinderBufferGeometry";this.parameters={radiusTop:a,
radiusBottom:c,height:e,radialSegments:g,heightSegments:r,openEnded:v,thetaStart:z,thetaLength:E};var J=this;a=void 0!==a?a:1;c=void 0!==c?c:1;e=e||1;g=Math.floor(g)||8;r=Math.floor(r)||1;v=void 0!==v?v:!1;z=void 0!==z?z:0;E=void 0!==E?E:2*Math.PI;var P=[],R=[],S=[],V=[],W=0,ha=[],fa=e/2,ra=0;(function(){var pa,qa,ua=new k,oa=new k,ta=0,Ba=(c-a)/e;for(qa=0;qa<=r;qa++){var Ta=[],Ua=qa/r,Ca=Ua*(c-a)+a;for(pa=0;pa<=g;pa++){var Ha=pa/g,Da=Ha*E+z,Ma=Math.sin(Da);Da=Math.cos(Da);oa.x=Ca*Ma;oa.y=-Ua*e+fa;
oa.z=Ca*Da;R.push(oa.x,oa.y,oa.z);ua.set(Ma,Ba,Da).normalize();S.push(ua.x,ua.y,ua.z);V.push(Ha,1-Ua);Ta.push(W++)}ha.push(Ta)}for(pa=0;pa<g;pa++)for(qa=0;qa<r;qa++)ua=ha[qa+1][pa],oa=ha[qa+1][pa+1],Ba=ha[qa][pa+1],P.push(ha[qa][pa],ua,Ba),P.push(ua,oa,Ba),ta+=6;J.addGroup(ra,ta,0);ra+=ta})();!1===v&&(0<a&&F(!0),0<c&&F(!1));this.setIndex(P);this.addAttribute("position",new ca(R,3));this.addAttribute("normal",new ca(S,3));this.addAttribute("uv",new ca(V,2))}function Vf(a,c,e,g,r,v,z){Xd.call(this,
0,a,c,e,g,r,v,z);this.type="ConeGeometry";this.parameters={radius:a,height:c,radialSegments:e,heightSegments:g,openEnded:r,thetaStart:v,thetaLength:z}}function Wf(a,c,e,g,r,v,z){fd.call(this,0,a,c,e,g,r,v,z);this.type="ConeBufferGeometry";this.parameters={radius:a,height:c,radialSegments:e,heightSegments:g,openEnded:r,thetaStart:v,thetaLength:z}}function Xf(a,c,e,g){ya.call(this);this.type="CircleGeometry";this.parameters={radius:a,segments:c,thetaStart:e,thetaLength:g};this.fromBufferGeometry(new Qe(a,
c,e,g));this.mergeVertices()}function Qe(a,c,e,g){va.call(this);this.type="CircleBufferGeometry";this.parameters={radius:a,segments:c,thetaStart:e,thetaLength:g};a=a||1;c=void 0!==c?Math.max(3,c):8;e=void 0!==e?e:0;g=void 0!==g?g:2*Math.PI;var r=[],v=[],z=[],E=[],F,J=new k,P=new f;v.push(0,0,0);z.push(0,0,1);E.push(.5,.5);var R=0;for(F=3;R<=c;R++,F+=3){var S=e+R/c*g;J.x=a*Math.cos(S);J.y=a*Math.sin(S);v.push(J.x,J.y,J.z);z.push(0,0,1);P.x=(v[F]/a+1)/2;P.y=(v[F+1]/a+1)/2;E.push(P.x,P.y)}for(F=1;F<=
c;F++)r.push(F,F+1,0);this.setIndex(r);this.addAttribute("position",new ca(v,3));this.addAttribute("normal",new ca(z,3));this.addAttribute("uv",new ca(E,2))}function Yd(a){M.call(this);this.type="ShadowMaterial";this.color=new I(0);this.transparent=!0;this.setValues(a)}function Re(a){qb.call(this,a);this.type="RawShaderMaterial"}function Sc(a){M.call(this);this.defines={STANDARD:""};this.type="MeshStandardMaterial";this.color=new I(16777215);this.metalness=this.roughness=.5;this.lightMap=this.map=
null;this.lightMapIntensity=1;this.aoMap=null;this.aoMapIntensity=1;this.emissive=new I(0);this.emissiveIntensity=1;this.bumpMap=this.emissiveMap=null;this.bumpScale=1;this.normalMap=null;this.normalMapType=0;this.normalScale=new f(1,1);this.displacementMap=null;this.displacementScale=1;this.displacementBias=0;this.envMap=this.alphaMap=this.metalnessMap=this.roughnessMap=null;this.envMapIntensity=1;this.refractionRatio=.98;this.wireframe=!1;this.wireframeLinewidth=1;this.wireframeLinejoin=this.wireframeLinecap=
"round";this.morphNormals=this.morphTargets=this.skinning=!1;this.setValues(a)}function Zd(a){Sc.call(this);this.defines={STANDARD:"",PHYSICAL:""};this.type="MeshPhysicalMaterial";this.reflectivity=.5;this.clearcoatRoughness=this.clearcoat=0;this.sheen=null;this.clearcoatNormalScale=new f(1,1);this.clearcoatNormalMap=null;this.transparency=0;this.setValues(a)}function Bc(a){M.call(this);this.type="MeshPhongMaterial";this.color=new I(16777215);this.specular=new I(1118481);this.shininess=30;this.lightMap=
this.map=null;this.lightMapIntensity=1;this.aoMap=null;this.aoMapIntensity=1;this.emissive=new I(0);this.emissiveIntensity=1;this.bumpMap=this.emissiveMap=null;this.bumpScale=1;this.normalMap=null;this.normalMapType=0;this.normalScale=new f(1,1);this.displacementMap=null;this.displacementScale=1;this.displacementBias=0;this.envMap=this.alphaMap=this.specularMap=null;this.combine=0;this.reflectivity=1;this.refractionRatio=.98;this.wireframe=!1;this.wireframeLinewidth=1;this.wireframeLinejoin=this.wireframeLinecap=
"round";this.morphNormals=this.morphTargets=this.skinning=!1;this.setValues(a)}function $d(a){Bc.call(this);this.defines={TOON:""};this.type="MeshToonMaterial";this.gradientMap=null;this.setValues(a)}function ae(a){M.call(this);this.type="MeshNormalMaterial";this.bumpMap=null;this.bumpScale=1;this.normalMap=null;this.normalMapType=0;this.normalScale=new f(1,1);this.displacementMap=null;this.displacementScale=1;this.displacementBias=0;this.wireframe=!1;this.wireframeLinewidth=1;this.morphNormals=this.morphTargets=
this.skinning=this.lights=this.fog=!1;this.setValues(a)}function be(a){M.call(this);this.type="MeshLambertMaterial";this.color=new I(16777215);this.lightMap=this.map=null;this.lightMapIntensity=1;this.aoMap=null;this.aoMapIntensity=1;this.emissive=new I(0);this.emissiveIntensity=1;this.envMap=this.alphaMap=this.specularMap=this.emissiveMap=null;this.combine=0;this.reflectivity=1;this.refractionRatio=.98;this.wireframe=!1;this.wireframeLinewidth=1;this.wireframeLinejoin=this.wireframeLinecap="round";
this.morphNormals=this.morphTargets=this.skinning=!1;this.setValues(a)}function ce(a){M.call(this);this.defines={MATCAP:""};this.type="MeshMatcapMaterial";this.color=new I(16777215);this.bumpMap=this.map=this.matcap=null;this.bumpScale=1;this.normalMap=null;this.normalMapType=0;this.normalScale=new f(1,1);this.displacementMap=null;this.displacementScale=1;this.displacementBias=0;this.alphaMap=null;this.lights=this.morphNormals=this.morphTargets=this.skinning=!1;this.setValues(a)}function de(a){Fb.call(this);
this.type="LineDashedMaterial";this.scale=1;this.dashSize=3;this.gapSize=1;this.setValues(a)}function oc(a,c,e,g){this.parameterPositions=a;this._cachedIndex=0;this.resultBuffer=void 0!==g?g:new c.constructor(e);this.sampleValues=c;this.valueSize=e}function Eg(a,c,e,g){oc.call(this,a,c,e,g);this._offsetNext=this._weightNext=this._offsetPrev=this._weightPrev=-0}function Yf(a,c,e,g){oc.call(this,a,c,e,g)}function Fg(a,c,e,g){oc.call(this,a,c,e,g)}function Xb(a,c,e,g){if(void 0===a)throw Error("THREE.KeyframeTrack: track name is undefined");
if(void 0===c||0===c.length)throw Error("THREE.KeyframeTrack: no keyframes in track named "+a);this.name=a;this.times=Tb.convertArray(c,this.TimeBufferType);this.values=Tb.convertArray(e,this.ValueBufferType);this.setInterpolation(g||this.DefaultInterpolation)}function Gg(a,c,e){Xb.call(this,a,c,e)}function Hg(a,c,e,g){Xb.call(this,a,c,e,g)}function Se(a,c,e,g){Xb.call(this,a,c,e,g)}function Ig(a,c,e,g){oc.call(this,a,c,e,g)}function Zf(a,c,e,g){Xb.call(this,a,c,e,g)}function Jg(a,c,e,g){Xb.call(this,
a,c,e,g)}function Te(a,c,e,g){Xb.call(this,a,c,e,g)}function tc(a,c,e){this.name=a;this.tracks=e;this.duration=void 0!==c?c:-1;this.uuid=hb.generateUUID();0>this.duration&&this.resetDuration()}function mm(a){switch(a.toLowerCase()){case "scalar":case "double":case "float":case "number":case "integer":return Se;case "vector":case "vector2":case "vector3":case "vector4":return Te;case "color":return Hg;case "quaternion":return Zf;case "bool":case "boolean":return Gg;case "string":return Jg}throw Error("THREE.KeyframeTrack: Unsupported typeName: "+
a);}function nm(a){if(void 0===a.type)throw Error("THREE.KeyframeTrack: track type undefined, can not parse");var c=mm(a.type);if(void 0===a.times){var e=[],g=[];Tb.flattenJSON(a.keys,e,g,"value");a.times=e;a.values=g}return void 0!==c.parse?c.parse(a):new c(a.name,a.times,a.values,a.interpolation)}function $h(a,c,e){var g=this,r=!1,v=0,z=0,E=void 0;this.onStart=void 0;this.onLoad=a;this.onProgress=c;this.onError=e;this.itemStart=function(F){z++;if(!1===r&&void 0!==g.onStart)g.onStart(F,v,z);r=!0};
this.itemEnd=function(F){v++;if(void 0!==g.onProgress)g.onProgress(F,v,z);if(v===z&&(r=!1,void 0!==g.onLoad))g.onLoad()};this.itemError=function(F){if(void 0!==g.onError)g.onError(F)};this.resolveURL=function(F){return E?E(F):F};this.setURLModifier=function(F){E=F;return this}}function Db(a){this.manager=void 0!==a?a:Oj;this.crossOrigin="anonymous";this.resourcePath=this.path=""}function uc(a){Db.call(this,a)}function ai(a){Db.call(this,a)}function bi(a){Db.call(this,a);this._parser=null}function Kg(a){Db.call(this,
a);this._parser=null}function Ue(a){Db.call(this,a)}function Lg(a){Db.call(this,a)}function Mg(a){Db.call(this,a)}function Za(){this.type="Curve";this.arcLengthDivisions=200}function pc(a,c,e,g,r,v,z,E){Za.call(this);this.type="EllipseCurve";this.aX=a||0;this.aY=c||0;this.xRadius=e||1;this.yRadius=g||1;this.aStartAngle=r||0;this.aEndAngle=v||2*Math.PI;this.aClockwise=z||!1;this.aRotation=E||0}function Ve(a,c,e,g,r,v){pc.call(this,a,c,e,e,g,r,v);this.type="ArcCurve"}function ci(){function a(v,z,E,
F){c=v;e=E;g=-3*v+3*z-2*E-F;r=2*v-2*z+E+F}var c=0,e=0,g=0,r=0;return{initCatmullRom:function(v,z,E,F,J){a(z,E,J*(E-v),J*(F-z))},initNonuniformCatmullRom:function(v,z,E,F,J,P,R){a(z,E,((z-v)/J-(E-v)/(J+P)+(E-z)/P)*P,((E-z)/P-(F-z)/(P+R)+(F-E)/R)*P)},calc:function(v){var z=v*v;return c+e*v+g*z+r*z*v}}}function Zb(a,c,e,g){Za.call(this);this.type="CatmullRomCurve3";this.points=a||[];this.closed=c||!1;this.curveType=e||"centripetal";this.tension=g||.5}function Pj(a,c,e,g,r){c=.5*(g-c);r=.5*(r-e);var v=
a*a;return(2*e-2*g+c+r)*a*v+(-3*e+3*g-2*c-r)*v+c*a+e}function om(a,c){a=1-a;return a*a*c}function pm(a,c){return 2*(1-a)*a*c}function qm(a,c){return a*a*c}function $f(a,c,e,g){return om(a,c)+pm(a,e)+qm(a,g)}function rm(a,c){a=1-a;return a*a*a*c}function sm(a,c){var e=1-a;return 3*e*e*a*c}function tm(a,c){return 3*(1-a)*a*a*c}function um(a,c){return a*a*a*c}function ag(a,c,e,g,r){return rm(a,c)+sm(a,e)+tm(a,g)+um(a,r)}function Cc(a,c,e,g){Za.call(this);this.type="CubicBezierCurve";this.v0=a||new f;
this.v1=c||new f;this.v2=e||new f;this.v3=g||new f}function Tc(a,c,e,g){Za.call(this);this.type="CubicBezierCurve3";this.v0=a||new k;this.v1=c||new k;this.v2=e||new k;this.v3=g||new k}function kc(a,c){Za.call(this);this.type="LineCurve";this.v1=a||new f;this.v2=c||new f}function Dc(a,c){Za.call(this);this.type="LineCurve3";this.v1=a||new k;this.v2=c||new k}function Ec(a,c,e){Za.call(this);this.type="QuadraticBezierCurve";this.v0=a||new f;this.v1=c||new f;this.v2=e||new f}function Uc(a,c,e){Za.call(this);
this.type="QuadraticBezierCurve3";this.v0=a||new k;this.v1=c||new k;this.v2=e||new k}function Fc(a){Za.call(this);this.type="SplineCurve";this.points=a||[]}function gd(){Za.call(this);this.type="CurvePath";this.curves=[];this.autoClose=!1}function Gc(a){gd.call(this);this.type="Path";this.currentPoint=new f;a&&this.setFromPoints(a)}function Cd(a){Gc.call(this,a);this.uuid=hb.generateUUID();this.type="Shape";this.holes=[]}function Jb(a,c){A.call(this);this.type="Light";this.color=new I(a);this.intensity=
void 0!==c?c:1;this.receiveShadow=void 0}function Ng(a,c,e){Jb.call(this,a,e);this.type="HemisphereLight";this.castShadow=void 0;this.position.copy(A.DefaultUp);this.updateMatrix();this.groundColor=new I(c)}function Vc(a){this.camera=a;this.bias=0;this.radius=1;this.mapSize=new f(512,512);this.mapPass=this.map=null;this.matrix=new q;this._frustum=new ic;this._frameExtents=new f(1,1);this._viewportCount=1;this._viewports=[new p(0,0,1,1)]}function Og(){Vc.call(this,new vb(50,1,.5,500))}function Pg(a,
c,e,g,r,v){Jb.call(this,a,c);this.type="SpotLight";this.position.copy(A.DefaultUp);this.updateMatrix();this.target=new A;Object.defineProperty(this,"power",{get:function(){return this.intensity*Math.PI},set:function(z){this.intensity=z/Math.PI}});this.distance=void 0!==e?e:0;this.angle=void 0!==g?g:Math.PI/3;this.penumbra=void 0!==r?r:0;this.decay=void 0!==v?v:1;this.shadow=new Og}function di(){Vc.call(this,new vb(90,1,.5,500));this._frameExtents=new f(4,2);this._viewportCount=6;this._viewports=[new p(2,
1,1,1),new p(0,1,1,1),new p(3,1,1,1),new p(1,1,1,1),new p(3,0,1,1),new p(1,0,1,1)];this._cubeDirections=[new k(1,0,0),new k(-1,0,0),new k(0,0,1),new k(0,0,-1),new k(0,1,0),new k(0,-1,0)];this._cubeUps=[new k(0,1,0),new k(0,1,0),new k(0,1,0),new k(0,1,0),new k(0,0,1),new k(0,0,-1)]}function Qg(a,c,e,g){Jb.call(this,a,c);this.type="PointLight";Object.defineProperty(this,"power",{get:function(){return 4*this.intensity*Math.PI},set:function(r){this.intensity=r/(4*Math.PI)}});this.distance=void 0!==e?
e:0;this.decay=void 0!==g?g:1;this.shadow=new di}function bg(a,c,e,g,r,v){zb.call(this);this.type="OrthographicCamera";this.zoom=1;this.view=null;this.left=void 0!==a?a:-1;this.right=void 0!==c?c:1;this.top=void 0!==e?e:1;this.bottom=void 0!==g?g:-1;this.near=void 0!==r?r:.1;this.far=void 0!==v?v:2E3;this.updateProjectionMatrix()}function Rg(){Vc.call(this,new bg(-5,5,5,-5,.5,500))}function Sg(a,c){Jb.call(this,a,c);this.type="DirectionalLight";this.position.copy(A.DefaultUp);this.updateMatrix();
this.target=new A;this.shadow=new Rg}function Tg(a,c){Jb.call(this,a,c);this.type="AmbientLight";this.castShadow=void 0}function Ug(a,c,e,g){Jb.call(this,a,c);this.type="RectAreaLight";this.width=void 0!==e?e:10;this.height=void 0!==g?g:10}function Vg(a){Db.call(this,a);this.textures={}}function Wg(){va.call(this);this.type="InstancedBufferGeometry";this.maxInstancedCount=void 0}function Xg(a,c,e,g){"number"===typeof e&&(g=e,e=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument."));
Q.call(this,a,c,e);this.meshPerAttribute=g||1}function Yg(a){Db.call(this,a)}function Zg(a){Db.call(this,a)}function ei(a){"undefined"===typeof createImageBitmap&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported.");"undefined"===typeof fetch&&console.warn("THREE.ImageBitmapLoader: fetch() not supported.");Db.call(this,a);this.options=void 0}function fi(){this.type="ShapePath";this.color=new I;this.subPaths=[];this.currentPath=null}function gi(a){this.type="Font";this.data=
a}function vm(a,c,e){a=Array.from?Array.from(a):String(a).split("");c/=e.resolution;for(var g=(e.boundingBox.yMax-e.boundingBox.yMin+e.underlineThickness)*c,r=[],v=0,z=0,E=0;E<a.length;E++){var F=a[E];"\n"===F?(v=0,z-=g):(F=wm(F,c,v,z,e),v+=F.offsetX,r.push(F.path))}return r}function wm(a,c,e,g,r){var v=r.glyphs[a]||r.glyphs["?"];if(v){a=new fi;if(v.o){r=v._cachedOutline||(v._cachedOutline=v.o.split(" "));for(var z=0,E=r.length;z<E;)switch(r[z++]){case "m":var F=r[z++]*c+e;var J=r[z++]*c+g;a.moveTo(F,
J);break;case "l":F=r[z++]*c+e;J=r[z++]*c+g;a.lineTo(F,J);break;case "q":F=r[z++]*c+e;J=r[z++]*c+g;var P=r[z++]*c+e;var R=r[z++]*c+g;a.quadraticCurveTo(P,R,F,J);break;case "b":F=r[z++]*c+e;J=r[z++]*c+g;P=r[z++]*c+e;R=r[z++]*c+g;var S=r[z++]*c+e;var V=r[z++]*c+g;a.bezierCurveTo(P,R,S,V,F,J)}}return{offsetX:v.ha*c,path:a}}console.error('THREE.Font: character "'+a+'" does not exists in font family '+r.familyName+".")}function hi(a){Db.call(this,a)}function $g(a){Db.call(this,a)}function ah(){this.coefficients=
[];for(var a=0;9>a;a++)this.coefficients.push(new k)}function Hc(a,c){Jb.call(this,void 0,c);this.sh=void 0!==a?a:new ah}function ii(a,c,e){Hc.call(this,void 0,e);a=(new I).set(a);e=(new I).set(c);c=new k(a.r,a.g,a.b);a=new k(e.r,e.g,e.b);e=Math.sqrt(Math.PI);var g=e*Math.sqrt(.75);this.sh.coefficients[0].copy(c).add(a).multiplyScalar(e);this.sh.coefficients[1].copy(c).sub(a).multiplyScalar(g)}function ji(a,c){Hc.call(this,void 0,c);a=(new I).set(a);this.sh.coefficients[0].set(a.r,a.g,a.b).multiplyScalar(2*
Math.sqrt(Math.PI))}function Qj(){this.type="StereoCamera";this.aspect=1;this.eyeSep=.064;this.cameraL=new vb;this.cameraL.layers.enable(1);this.cameraL.matrixAutoUpdate=!1;this.cameraR=new vb;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}}function ki(a){this.autoStart=void 0!==a?a:!0;this.elapsedTime=this.oldTime=this.startTime=0;this.running=!1}function li(){A.call(this);this.type="AudioListener";
this.context=mi.getContext();this.gain=this.context.createGain();this.gain.connect(this.context.destination);this.filter=null;this.timeDelta=0;this._clock=new ki}function We(a){A.call(this);this.type="Audio";this.listener=a;this.context=a.context;this.gain=this.context.createGain();this.gain.connect(a.getInput());this.autoplay=!1;this.buffer=null;this.detune=0;this.loop=!1;this.offset=this.startTime=0;this.duration=void 0;this.playbackRate=1;this.isPlaying=!1;this.hasPlaybackControl=!0;this.sourceType=
"empty";this.filters=[]}function ni(a){We.call(this,a);this.panner=this.context.createPanner();this.panner.panningModel="HRTF";this.panner.connect(this.gain)}function oi(a,c){this.analyser=a.context.createAnalyser();this.analyser.fftSize=void 0!==c?c:2048;this.data=new Uint8Array(this.analyser.frequencyBinCount);a.getOutput().connect(this.analyser)}function pi(a,c,e){this.binding=a;this.valueSize=e;a=Float64Array;switch(c){case "quaternion":c=this._slerp;break;case "string":case "bool":a=Array;c=
this._select;break;default:c=this._lerp}this.buffer=new a(4*e);this._mixBufferRegion=c;this.referenceCount=this.useCount=this.cumulativeWeight=0}function Rj(a,c,e){e=e||$b.parseTrackName(c);this._targetGroup=a;this._bindings=a.subscribe_(c,e)}function $b(a,c,e){this.path=c;this.parsedPath=e||$b.parseTrackName(c);this.node=$b.findNode(a,this.parsedPath.nodeName)||a;this.rootNode=a}function Sj(){this.uuid=hb.generateUUID();this._objects=Array.prototype.slice.call(arguments);this.nCachedObjects_=0;var a=
{};this._indicesByUUID=a;for(var c=0,e=arguments.length;c!==e;++c)a[arguments[c].uuid]=c;this._paths=[];this._parsedPaths=[];this._bindings=[];this._bindingsIndicesByPath={};var g=this;this.stats={objects:{get total(){return g._objects.length},get inUse(){return this.total-g.nCachedObjects_}},get bindingsPerObject(){return g._bindings.length}}}function Tj(a,c,e){this._mixer=a;this._clip=c;this._localRoot=e||null;a=c.tracks;c=a.length;e=Array(c);for(var g={endingStart:2400,endingEnd:2400},r=0;r!==
c;++r){var v=a[r].createInterpolant(null);e[r]=v;v.settings=g}this._interpolantSettings=g;this._interpolants=e;this._propertyBindings=Array(c);this._weightInterpolant=this._timeScaleInterpolant=this._byClipCacheIndex=this._cacheIndex=null;this.loop=2201;this._loopCount=-1;this._startTime=null;this.time=0;this._effectiveWeight=this.weight=this._effectiveTimeScale=this.timeScale=1;this.repetitions=Infinity;this.paused=!1;this.enabled=!0;this.clampWhenFinished=!1;this.zeroSlopeAtEnd=this.zeroSlopeAtStart=
!0}function qi(a){this._root=a;this._initMemoryManager();this.time=this._accuIndex=0;this.timeScale=1}function bh(a,c){"string"===typeof a&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),a=c);this.value=a}function ri(a,c,e){Qd.call(this,a,c);this.meshPerAttribute=e||1}function Uj(a,c,e,g){this.ray=new D(a,c);this.near=e||0;this.far=g||Infinity;this.camera=null;this.params={Mesh:{},Line:{},LOD:{},Points:{threshold:1},Sprite:{}};Object.defineProperties(this.params,{PointCloud:{get:function(){console.warn("THREE.Raycaster: params.PointCloud has been renamed to params.Points.");
return this.Points}}})}function Vj(a,c){return a.distance-c.distance}function si(a,c,e,g){if(!1!==a.visible&&(a.raycast(c,e),!0===g)){a=a.children;g=0;for(var r=a.length;g<r;g++)si(a[g],c,e,!0)}}function Wj(a,c,e){this.radius=void 0!==a?a:1;this.phi=void 0!==c?c:0;this.theta=void 0!==e?e:0;return this}function Xj(a,c,e){this.radius=void 0!==a?a:1;this.theta=void 0!==c?c:0;this.y=void 0!==e?e:0;return this}function ti(a,c){this.min=void 0!==a?a:new f(Infinity,Infinity);this.max=void 0!==c?c:new f(-Infinity,
-Infinity)}function ui(a,c){this.start=void 0!==a?a:new k;this.end=void 0!==c?c:new k}function cg(a){A.call(this);this.material=a;this.render=function(){}}function dg(a,c,e,g){this.object=a;this.size=void 0!==c?c:1;a=void 0!==e?e:16711680;g=void 0!==g?g:1;c=0;(e=this.object.geometry)&&e.isGeometry?c=3*e.faces.length:e&&e.isBufferGeometry&&(c=e.attributes.normal.count);e=new va;c=new ca(6*c,3);e.addAttribute("position",c);Ib.call(this,e,new Fb({color:a,linewidth:g}));this.matrixAutoUpdate=!1;this.update()}
function Xe(a,c){A.call(this);this.light=a;this.light.updateMatrixWorld();this.matrix=a.matrixWorld;this.matrixAutoUpdate=!1;this.color=c;a=new va;c=[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(var e=0,g=1;32>e;e++,g++){var r=e/32*Math.PI*2,v=g/32*Math.PI*2;c.push(Math.cos(r),Math.sin(r),1,Math.cos(v),Math.sin(v),1)}a.addAttribute("position",new ca(c,3));c=new Fb({fog:!1});this.cone=new Ib(a,c);this.add(this.cone);this.update()}function Yj(a){var c=[];a&&a.isBone&&c.push(a);
for(var e=0;e<a.children.length;e++)c.push.apply(c,Yj(a.children[e]));return c}function Ye(a){for(var c=Yj(a),e=new va,g=[],r=[],v=new I(0,0,1),z=new I(0,1,0),E=0;E<c.length;E++){var F=c[E];F.parent&&F.parent.isBone&&(g.push(0,0,0),g.push(0,0,0),r.push(v.r,v.g,v.b),r.push(z.r,z.g,z.b))}e.addAttribute("position",new ca(g,3));e.addAttribute("color",new ca(r,3));g=new Fb({vertexColors:2,depthTest:!1,depthWrite:!1,transparent:!0});Ib.call(this,e,g);this.root=a;this.bones=c;this.matrix=a.matrixWorld;this.matrixAutoUpdate=
!1}function Ze(a,c,e){this.light=a;this.light.updateMatrixWorld();this.color=e;a=new Bd(c,4,2);c=new L({wireframe:!0,fog:!1});xa.call(this,a,c);this.matrix=this.light.matrixWorld;this.matrixAutoUpdate=!1;this.update()}function $e(a,c){this.type="RectAreaLightHelper";this.light=a;this.color=c;a=new va;a.addAttribute("position",new ca([1,1,0,-1,1,0,-1,-1,0,1,-1,0,1,1,0],3));a.computeBoundingSphere();c=new Fb({fog:!1});Vb.call(this,a,c);a=new va;a.addAttribute("position",new ca([1,1,0,-1,1,0,-1,-1,0,
1,1,0,-1,-1,0,1,-1,0],3));a.computeBoundingSphere();this.add(new xa(a,new L({side:1,fog:!1})));this.update()}function af(a,c,e){A.call(this);this.light=a;this.light.updateMatrixWorld();this.matrix=a.matrixWorld;this.matrixAutoUpdate=!1;this.color=e;a=new Rd(c);a.rotateY(.5*Math.PI);this.material=new L({wireframe:!0,fog:!1});void 0===this.color&&(this.material.vertexColors=2);c=a.getAttribute("position");a.addAttribute("color",new Q(new Float32Array(3*c.count),3));this.add(new xa(a,this.material));
this.update()}function bf(a,c){this.lightProbe=a;this.size=c;a=new qb({defines:{GAMMA_OUTPUT:""},uniforms:{sh:{value:this.lightProbe.sh.coefficients},intensity:{value:this.lightProbe.intensity}},vertexShader:"varying vec3 vNormal;\nvoid main() {\n\tvNormal \x3d normalize( normalMatrix * normal );\n\tgl_Position \x3d projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",fragmentShader:"#define RECIPROCAL_PI 0.318309886\nvec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {\n\t// matrix is assumed to be orthogonal\n\treturn normalize( ( vec4( normal, 0.0 ) * matrix ).xyz );\n}\nvec3 linearToOutput( in vec3 a ) {\n\t#ifdef GAMMA_OUTPUT\n\t\treturn pow( a, vec3( 1.0 / float( GAMMA_FACTOR ) ) );\n\t#else\n\t\treturn a;\n\t#endif\n}\n// source: https://graphics.stanford.edu/papers/envmap/envmap.pdf\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\t// normal is assumed to have unit length\n\tfloat x \x3d normal.x, y \x3d normal.y, z \x3d normal.z;\n\t// band 0\n\tvec3 result \x3d shCoefficients[ 0 ] * 0.886227;\n\t// band 1\n\tresult +\x3d shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult +\x3d shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult +\x3d shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\t// band 2\n\tresult +\x3d shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult +\x3d shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult +\x3d shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult +\x3d shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult +\x3d shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nuniform vec3 sh[ 9 ]; // sh coefficients\nuniform float intensity; // light probe intensity\nvarying vec3 vNormal;\nvoid main() {\n\tvec3 normal \x3d normalize( vNormal );\n\tvec3 worldNormal \x3d inverseTransformDirection( normal, viewMatrix );\n\tvec3 irradiance \x3d shGetIrradianceAt( worldNormal, sh );\n\tvec3 outgoingLight \x3d RECIPROCAL_PI * irradiance * intensity;\n\toutgoingLight \x3d linearToOutput( outgoingLight );\n\tgl_FragColor \x3d vec4( outgoingLight, 1.0 );\n}"});
c=new Bd(1,32,16);xa.call(this,c,a);this.onBeforeRender()}function ch(a,c,e,g){a=a||10;c=c||10;e=new I(void 0!==e?e:4473924);g=new I(void 0!==g?g:8947848);var r=c/2,v=a/c,z=a/2;a=[];for(var E=[],F=0,J=0,P=-z;F<=c;F++,P+=v){a.push(-z,0,P,z,0,P);a.push(P,0,-z,P,0,z);var R=F===r?e:g;R.toArray(E,J);J+=3;R.toArray(E,J);J+=3;R.toArray(E,J);J+=3;R.toArray(E,J);J+=3}c=new va;c.addAttribute("position",new ca(a,3));c.addAttribute("color",new ca(E,3));e=new Fb({vertexColors:2});Ib.call(this,c,e)}function dh(a,
c,e,g,r,v){a=a||10;c=c||16;e=e||8;g=g||64;r=new I(void 0!==r?r:4473924);v=new I(void 0!==v?v:8947848);var z=[],E=[],F;for(F=0;F<=c;F++){var J=F/c*2*Math.PI;var P=Math.sin(J)*a;J=Math.cos(J)*a;z.push(0,0,0);z.push(P,0,J);var R=F&1?r:v;E.push(R.r,R.g,R.b);E.push(R.r,R.g,R.b)}for(F=0;F<=e;F++){R=F&1?r:v;var S=a-a/e*F;for(c=0;c<g;c++)J=c/g*2*Math.PI,P=Math.sin(J)*S,J=Math.cos(J)*S,z.push(P,0,J),E.push(R.r,R.g,R.b),J=(c+1)/g*2*Math.PI,P=Math.sin(J)*S,J=Math.cos(J)*S,z.push(P,0,J),E.push(R.r,R.g,R.b)}a=
new va;a.addAttribute("position",new ca(z,3));a.addAttribute("color",new ca(E,3));z=new Fb({vertexColors:2});Ib.call(this,a,z)}function cf(a,c,e,g){this.audio=a;this.range=c||1;this.divisionsInnerAngle=e||16;this.divisionsOuterAngle=g||2;a=new va;a.addAttribute("position",new Q(new Float32Array(3*(3*(this.divisionsInnerAngle+2*this.divisionsOuterAngle)+3)),3));c=new Fb({color:65280});e=new Fb({color:16776960});Vb.call(this,a,[e,c]);this.update()}function eg(a,c,e,g){this.object=a;this.size=void 0!==
c?c:1;a=void 0!==e?e:16776960;g=void 0!==g?g:1;c=0;(e=this.object.geometry)&&e.isGeometry?c=e.faces.length:console.warn("THREE.FaceNormalsHelper: only THREE.Geometry is supported. Use THREE.VertexNormalsHelper, instead.");e=new va;c=new ca(6*c,3);e.addAttribute("position",c);Ib.call(this,e,new Fb({color:a,linewidth:g}));this.matrixAutoUpdate=!1;this.update()}function df(a,c,e){A.call(this);this.light=a;this.light.updateMatrixWorld();this.matrix=a.matrixWorld;this.matrixAutoUpdate=!1;this.color=e;
void 0===c&&(c=1);a=new va;a.addAttribute("position",new ca([-c,c,0,c,c,0,c,-c,0,-c,-c,0,-c,c,0],3));c=new Fb({fog:!1});this.lightPlane=new Vb(a,c);this.add(this.lightPlane);a=new va;a.addAttribute("position",new ca([0,0,0,0,0,1],3));this.targetLine=new Vb(a,c);this.add(this.targetLine);this.update()}function fg(a){function c(V,W,ha){e(V,ha);e(W,ha)}function e(V,W){v.push(0,0,0);z.push(W.r,W.g,W.b);void 0===E[V]&&(E[V]=[]);E[V].push(v.length/3-1)}var g=new va,r=new Fb({color:16777215,vertexColors:1}),
v=[],z=[],E={},F=new I(16755200),J=new I(16711680),P=new I(43775),R=new I(16777215),S=new I(3355443);c("n1","n2",F);c("n2","n4",F);c("n4","n3",F);c("n3","n1",F);c("f1","f2",F);c("f2","f4",F);c("f4","f3",F);c("f3","f1",F);c("n1","f1",F);c("n2","f2",F);c("n3","f3",F);c("n4","f4",F);c("p","n1",J);c("p","n2",J);c("p","n3",J);c("p","n4",J);c("u1","u2",P);c("u2","u3",P);c("u3","u1",P);c("c","t",R);c("p","c",S);c("cn1","cn2",S);c("cn3","cn4",S);c("cf1","cf2",S);c("cf3","cf4",S);g.addAttribute("position",
new ca(v,3));g.addAttribute("color",new ca(z,3));Ib.call(this,g,r);this.camera=a;this.camera.updateProjectionMatrix&&this.camera.updateProjectionMatrix();this.matrix=a.matrixWorld;this.matrixAutoUpdate=!1;this.pointMap=E;this.update()}function Pb(a,c,e,g,r,v,z){eh.set(r,v,z).unproject(g);a=c[a];if(void 0!==a)for(e=e.getAttribute("position"),c=0,g=a.length;c<g;c++)e.setXYZ(a[c],eh.x,eh.y,eh.z)}function hd(a,c){this.object=a;void 0===c&&(c=16776960);a=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]);var e=new Float32Array(24),g=new va;g.setIndex(new Q(a,1));g.addAttribute("position",new Q(e,3));Ib.call(this,g,new Fb({color:c}));this.matrixAutoUpdate=!1;this.update()}function gg(a,c){this.type="Box3Helper";this.box=a;c=c||16776960;a=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]);var e=new va;e.setIndex(new Q(a,1));e.addAttribute("position",new ca([1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,-1,1,-1,-1,-1,-1,1,-1,-1],3));Ib.call(this,e,new Fb({color:c}));this.geometry.computeBoundingSphere()}
function hg(a,c,e){this.type="PlaneHelper";this.plane=a;this.size=void 0===c?1:c;a=void 0!==e?e:16776960;c=new va;c.addAttribute("position",new ca([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],3));c.computeBoundingSphere();Vb.call(this,c,new Fb({color:a}));c=new va;c.addAttribute("position",new ca([1,1,1,-1,1,1,-1,-1,1,1,1,1,-1,-1,1,1,-1,1],3));c.computeBoundingSphere();this.add(new xa(c,new L({color:a,opacity:.2,transparent:!0,depthWrite:!1})))}function id(a,c,e,g,r,v){A.call(this);
void 0===a&&(a=new k(0,0,1));void 0===c&&(c=new k(0,0,0));void 0===e&&(e=1);void 0===g&&(g=16776960);void 0===r&&(r=.2*e);void 0===v&&(v=.2*r);void 0===fh&&(fh=new va,fh.addAttribute("position",new ca([0,0,0,0,1,0],3)),vi=new fd(0,.5,1,5,1),vi.translate(0,-.5,0));this.position.copy(c);this.line=new Vb(fh,new Fb({color:g}));this.line.matrixAutoUpdate=!1;this.add(this.line);this.cone=new xa(vi,new L({color:g}));this.cone.matrixAutoUpdate=!1;this.add(this.cone);this.setDirection(a);this.setLength(e,
r,v)}function ig(a){a=a||1;var c=[0,0,0,a,0,0,0,0,0,0,a,0,0,0,0,0,0,a];a=new va;a.addAttribute("position",new ca(c,3));a.addAttribute("color",new ca([1,0,0,1,.6,0,0,1,0,.6,1,0,0,0,1,0,.6,1],3));c=new Fb({vertexColors:2});Ib.call(this,a,c)}function Zj(a){console.warn("THREE.ClosedSplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.");Zb.call(this,a);this.type="catmullrom";this.closed=!0}function ak(a){console.warn("THREE.SplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.");
Zb.call(this,a);this.type="catmullrom"}function wi(a){console.warn("THREE.Spline has been removed. Use THREE.CatmullRomCurve3 instead.");Zb.call(this,a);this.type="catmullrom"}void 0===Number.EPSILON&&(Number.EPSILON=Math.pow(2,-52));void 0===Number.isInteger&&(Number.isInteger=function(a){return"number"===typeof a&&isFinite(a)&&Math.floor(a)===a});void 0===Math.sign&&(Math.sign=function(a){return 0>a?-1:0<a?1:+a});!1==="name"in Function.prototype&&Object.defineProperty(Function.prototype,"name",
{get:function(){return this.toString().match(/^\s*function\s*([^\(\s]*)/)[1]}});void 0===Object.assign&&(Object.assign=function(a){if(void 0===a||null===a)throw new TypeError("Cannot convert undefined or null to object");for(var c=Object(a),e=1;e<arguments.length;e++){var g=arguments[e];if(void 0!==g&&null!==g)for(var r in g)Object.prototype.hasOwnProperty.call(g,r)&&(c[r]=g[r])}return c});Object.assign(d.prototype,{addEventListener:function(a,c){void 0===this._listeners&&(this._listeners={});var e=
this._listeners;void 0===e[a]&&(e[a]=[]);-1===e[a].indexOf(c)&&e[a].push(c)},hasEventListener:function(a,c){if(void 0===this._listeners)return!1;var e=this._listeners;return void 0!==e[a]&&-1!==e[a].indexOf(c)},removeEventListener:function(a,c){void 0!==this._listeners&&(a=this._listeners[a],void 0!==a&&(c=a.indexOf(c),-1!==c&&a.splice(c,1)))},dispatchEvent:function(a){if(void 0!==this._listeners){var c=this._listeners[a.type];if(void 0!==c){a.target=this;c=c.slice(0);for(var e=0,g=c.length;e<g;e++)c[e].call(this,
a)}}}});for(var Yb=[],jg=0;256>jg;jg++)Yb[jg]=(16>jg?"0":"")+jg.toString(16);var hb={DEG2RAD:Math.PI/180,RAD2DEG:180/Math.PI,generateUUID:function(){var a=4294967295*Math.random()|0,c=4294967295*Math.random()|0,e=4294967295*Math.random()|0,g=4294967295*Math.random()|0;return(Yb[a&255]+Yb[a>>8&255]+Yb[a>>16&255]+Yb[a>>24&255]+"-"+Yb[c&255]+Yb[c>>8&255]+"-"+Yb[c>>16&15|64]+Yb[c>>24&255]+"-"+Yb[e&63|128]+Yb[e>>8&255]+"-"+Yb[e>>16&255]+Yb[e>>24&255]+Yb[g&255]+Yb[g>>8&255]+Yb[g>>16&255]+Yb[g>>24&255]).toUpperCase()},
clamp:function(a,c,e){return Math.max(c,Math.min(e,a))},euclideanModulo:function(a,c){return(a%c+c)%c},mapLinear:function(a,c,e,g,r){return g+(a-c)*(r-g)/(e-c)},lerp:function(a,c,e){return(1-e)*a+e*c},smoothstep:function(a,c,e){if(a<=c)return 0;if(a>=e)return 1;a=(a-c)/(e-c);return a*a*(3-2*a)},smootherstep:function(a,c,e){if(a<=c)return 0;if(a>=e)return 1;a=(a-c)/(e-c);return a*a*a*(a*(6*a-15)+10)},randInt:function(a,c){return a+Math.floor(Math.random()*(c-a+1))},randFloat:function(a,c){return a+
Math.random()*(c-a)},randFloatSpread:function(a){return a*(.5-Math.random())},degToRad:function(a){return a*hb.DEG2RAD},radToDeg:function(a){return a*hb.RAD2DEG},isPowerOfTwo:function(a){return 0===(a&a-1)&&0!==a},ceilPowerOfTwo:function(a){return Math.pow(2,Math.ceil(Math.log(a)/Math.LN2))},floorPowerOfTwo:function(a){return Math.pow(2,Math.floor(Math.log(a)/Math.LN2))}};Object.defineProperties(f.prototype,{width:{get:function(){return this.x},set:function(a){this.x=a}},height:{get:function(){return this.y},
set:function(a){this.y=a}}});Object.assign(f.prototype,{isVector2:!0,set:function(a,c){this.x=a;this.y=c;return this},setScalar:function(a){this.y=this.x=a;return this},setX:function(a){this.x=a;return this},setY:function(a){this.y=a;return this},setComponent:function(a,c){switch(a){case 0:this.x=c;break;case 1:this.y=c;break;default:throw Error("index is out of range: "+a);}return this},getComponent:function(a){switch(a){case 0:return this.x;case 1:return this.y;default:throw Error("index is out of range: "+
a);}},clone:function(){return new this.constructor(this.x,this.y)},copy:function(a){this.x=a.x;this.y=a.y;return this},add:function(a,c){if(void 0!==c)return console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(a,c);this.x+=a.x;this.y+=a.y;return this},addScalar:function(a){this.x+=a;this.y+=a;return this},addVectors:function(a,c){this.x=a.x+c.x;this.y=a.y+c.y;return this},addScaledVector:function(a,c){this.x+=a.x*c;this.y+=a.y*c;return this},
sub:function(a,c){if(void 0!==c)return console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(a,c);this.x-=a.x;this.y-=a.y;return this},subScalar:function(a){this.x-=a;this.y-=a;return this},subVectors:function(a,c){this.x=a.x-c.x;this.y=a.y-c.y;return this},multiply:function(a){this.x*=a.x;this.y*=a.y;return this},multiplyScalar:function(a){this.x*=a;this.y*=a;return this},divide:function(a){this.x/=a.x;this.y/=a.y;return this},divideScalar:function(a){return this.multiplyScalar(1/
a)},applyMatrix3:function(a){var c=this.x,e=this.y;a=a.elements;this.x=a[0]*c+a[3]*e+a[6];this.y=a[1]*c+a[4]*e+a[7];return this},min:function(a){this.x=Math.min(this.x,a.x);this.y=Math.min(this.y,a.y);return this},max:function(a){this.x=Math.max(this.x,a.x);this.y=Math.max(this.y,a.y);return this},clamp:function(a,c){this.x=Math.max(a.x,Math.min(c.x,this.x));this.y=Math.max(a.y,Math.min(c.y,this.y));return this},clampScalar:function(a,c){this.x=Math.max(a,Math.min(c,this.x));this.y=Math.max(a,Math.min(c,
this.y));return this},clampLength:function(a,c){var e=this.length();return this.divideScalar(e||1).multiplyScalar(Math.max(a,Math.min(c,e)))},floor:function(){this.x=Math.floor(this.x);this.y=Math.floor(this.y);return this},ceil:function(){this.x=Math.ceil(this.x);this.y=Math.ceil(this.y);return this},round:function(){this.x=Math.round(this.x);this.y=Math.round(this.y);return this},roundToZero:function(){this.x=0>this.x?Math.ceil(this.x):Math.floor(this.x);this.y=0>this.y?Math.ceil(this.y):Math.floor(this.y);
return this},negate:function(){this.x=-this.x;this.y=-this.y;return this},dot:function(a){return this.x*a.x+this.y*a.y},cross:function(a){return this.x*a.y-this.y*a.x},lengthSq:function(){return this.x*this.x+this.y*this.y},length:function(){return Math.sqrt(this.x*this.x+this.y*this.y)},manhattanLength:function(){return Math.abs(this.x)+Math.abs(this.y)},normalize:function(){return this.divideScalar(this.length()||1)},angle:function(){var a=Math.atan2(this.y,this.x);0>a&&(a+=2*Math.PI);return a},
distanceTo:function(a){return Math.sqrt(this.distanceToSquared(a))},distanceToSquared:function(a){var c=this.x-a.x;a=this.y-a.y;return c*c+a*a},manhattanDistanceTo:function(a){return Math.abs(this.x-a.x)+Math.abs(this.y-a.y)},setLength:function(a){return this.normalize().multiplyScalar(a)},lerp:function(a,c){this.x+=(a.x-this.x)*c;this.y+=(a.y-this.y)*c;return this},lerpVectors:function(a,c,e){return this.subVectors(c,a).multiplyScalar(e).add(a)},equals:function(a){return a.x===this.x&&a.y===this.y},
fromArray:function(a,c){void 0===c&&(c=0);this.x=a[c];this.y=a[c+1];return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);a[c]=this.x;a[c+1]=this.y;return a},fromBufferAttribute:function(a,c,e){void 0!==e&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute().");this.x=a.getX(c);this.y=a.getY(c);return this},rotateAround:function(a,c){var e=Math.cos(c);c=Math.sin(c);var g=this.x-a.x,r=this.y-a.y;this.x=g*e-r*c+a.x;this.y=g*c+r*e+a.y;return this}});Object.assign(h,
{slerp:function(a,c,e,g){return e.copy(a).slerp(c,g)},slerpFlat:function(a,c,e,g,r,v,z){var E=e[g+0],F=e[g+1],J=e[g+2];e=e[g+3];g=r[v+0];var P=r[v+1],R=r[v+2];r=r[v+3];if(e!==r||E!==g||F!==P||J!==R){v=1-z;var S=E*g+F*P+J*R+e*r,V=0<=S?1:-1,W=1-S*S;W>Number.EPSILON&&(W=Math.sqrt(W),S=Math.atan2(W,S*V),v=Math.sin(v*S)/W,z=Math.sin(z*S)/W);V*=z;E=E*v+g*V;F=F*v+P*V;J=J*v+R*V;e=e*v+r*V;v===1-z&&(z=1/Math.sqrt(E*E+F*F+J*J+e*e),E*=z,F*=z,J*=z,e*=z)}a[c]=E;a[c+1]=F;a[c+2]=J;a[c+3]=e}});Object.defineProperties(h.prototype,
{x:{get:function(){return this._x},set:function(a){this._x=a;this._onChangeCallback()}},y:{get:function(){return this._y},set:function(a){this._y=a;this._onChangeCallback()}},z:{get:function(){return this._z},set:function(a){this._z=a;this._onChangeCallback()}},w:{get:function(){return this._w},set:function(a){this._w=a;this._onChangeCallback()}}});Object.assign(h.prototype,{isQuaternion:!0,set:function(a,c,e,g){this._x=a;this._y=c;this._z=e;this._w=g;this._onChangeCallback();return this},clone:function(){return new this.constructor(this._x,
this._y,this._z,this._w)},copy:function(a){this._x=a.x;this._y=a.y;this._z=a.z;this._w=a.w;this._onChangeCallback();return this},setFromEuler:function(a,c){if(!a||!a.isEuler)throw Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");var e=a._x,g=a._y,r=a._z;a=a.order;var v=Math.cos,z=Math.sin,E=v(e/2),F=v(g/2);v=v(r/2);e=z(e/2);g=z(g/2);r=z(r/2);"XYZ"===a?(this._x=e*F*v+E*g*r,this._y=E*g*v-e*F*r,this._z=E*F*r+e*g*v,this._w=E*F*v-e*g*r):"YXZ"===
a?(this._x=e*F*v+E*g*r,this._y=E*g*v-e*F*r,this._z=E*F*r-e*g*v,this._w=E*F*v+e*g*r):"ZXY"===a?(this._x=e*F*v-E*g*r,this._y=E*g*v+e*F*r,this._z=E*F*r+e*g*v,this._w=E*F*v-e*g*r):"ZYX"===a?(this._x=e*F*v-E*g*r,this._y=E*g*v+e*F*r,this._z=E*F*r-e*g*v,this._w=E*F*v+e*g*r):"YZX"===a?(this._x=e*F*v+E*g*r,this._y=E*g*v+e*F*r,this._z=E*F*r-e*g*v,this._w=E*F*v-e*g*r):"XZY"===a&&(this._x=e*F*v-E*g*r,this._y=E*g*v-e*F*r,this._z=E*F*r+e*g*v,this._w=E*F*v+e*g*r);!1!==c&&this._onChangeCallback();return this},setFromAxisAngle:function(a,
c){c/=2;var e=Math.sin(c);this._x=a.x*e;this._y=a.y*e;this._z=a.z*e;this._w=Math.cos(c);this._onChangeCallback();return this},setFromRotationMatrix:function(a){var c=a.elements,e=c[0];a=c[4];var g=c[8],r=c[1],v=c[5],z=c[9],E=c[2],F=c[6];c=c[10];var J=e+v+c;0<J?(e=.5/Math.sqrt(J+1),this._w=.25/e,this._x=(F-z)*e,this._y=(g-E)*e,this._z=(r-a)*e):e>v&&e>c?(e=2*Math.sqrt(1+e-v-c),this._w=(F-z)/e,this._x=.25*e,this._y=(a+r)/e,this._z=(g+E)/e):v>c?(e=2*Math.sqrt(1+v-e-c),this._w=(g-E)/e,this._x=(a+r)/e,
this._y=.25*e,this._z=(z+F)/e):(e=2*Math.sqrt(1+c-e-v),this._w=(r-a)/e,this._x=(g+E)/e,this._y=(z+F)/e,this._z=.25*e);this._onChangeCallback();return this},setFromUnitVectors:function(a,c){var e=a.dot(c)+1;1E-6>e?(e=0,Math.abs(a.x)>Math.abs(a.z)?(this._x=-a.y,this._y=a.x,this._z=0):(this._x=0,this._y=-a.z,this._z=a.y)):(this._x=a.y*c.z-a.z*c.y,this._y=a.z*c.x-a.x*c.z,this._z=a.x*c.y-a.y*c.x);this._w=e;return this.normalize()},angleTo:function(a){return 2*Math.acos(Math.abs(hb.clamp(this.dot(a),-1,
1)))},rotateTowards:function(a,c){var e=this.angleTo(a);if(0===e)return this;this.slerp(a,Math.min(1,c/e));return this},inverse:function(){return this.conjugate()},conjugate:function(){this._x*=-1;this._y*=-1;this._z*=-1;this._onChangeCallback();return this},dot:function(a){return this._x*a._x+this._y*a._y+this._z*a._z+this._w*a._w},lengthSq:function(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w},length:function(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*
this._z+this._w*this._w)},normalize:function(){var a=this.length();0===a?(this._z=this._y=this._x=0,this._w=1):(a=1/a,this._x*=a,this._y*=a,this._z*=a,this._w*=a);this._onChangeCallback();return this},multiply:function(a,c){return void 0!==c?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(a,c)):this.multiplyQuaternions(this,a)},premultiply:function(a){return this.multiplyQuaternions(a,this)},multiplyQuaternions:function(a,
c){var e=a._x,g=a._y,r=a._z;a=a._w;var v=c._x,z=c._y,E=c._z;c=c._w;this._x=e*c+a*v+g*E-r*z;this._y=g*c+a*z+r*v-e*E;this._z=r*c+a*E+e*z-g*v;this._w=a*c-e*v-g*z-r*E;this._onChangeCallback();return this},slerp:function(a,c){if(0===c)return this;if(1===c)return this.copy(a);var e=this._x,g=this._y,r=this._z,v=this._w,z=v*a._w+e*a._x+g*a._y+r*a._z;0>z?(this._w=-a._w,this._x=-a._x,this._y=-a._y,this._z=-a._z,z=-z):this.copy(a);if(1<=z)return this._w=v,this._x=e,this._y=g,this._z=r,this;a=1-z*z;if(a<=Number.EPSILON)return z=
1-c,this._w=z*v+c*this._w,this._x=z*e+c*this._x,this._y=z*g+c*this._y,this._z=z*r+c*this._z,this.normalize(),this._onChangeCallback(),this;a=Math.sqrt(a);var E=Math.atan2(a,z);z=Math.sin((1-c)*E)/a;c=Math.sin(c*E)/a;this._w=v*z+this._w*c;this._x=e*z+this._x*c;this._y=g*z+this._y*c;this._z=r*z+this._z*c;this._onChangeCallback();return this},equals:function(a){return a._x===this._x&&a._y===this._y&&a._z===this._z&&a._w===this._w},fromArray:function(a,c){void 0===c&&(c=0);this._x=a[c];this._y=a[c+1];
this._z=a[c+2];this._w=a[c+3];this._onChangeCallback();return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);a[c]=this._x;a[c+1]=this._y;a[c+2]=this._z;a[c+3]=this._w;return a},_onChange:function(a){this._onChangeCallback=a;return this},_onChangeCallback:function(){}});var xi=new k,bk=new h;Object.assign(k.prototype,{isVector3:!0,set:function(a,c,e){this.x=a;this.y=c;this.z=e;return this},setScalar:function(a){this.z=this.y=this.x=a;return this},setX:function(a){this.x=a;return this},
setY:function(a){this.y=a;return this},setZ:function(a){this.z=a;return this},setComponent:function(a,c){switch(a){case 0:this.x=c;break;case 1:this.y=c;break;case 2:this.z=c;break;default:throw Error("index is out of range: "+a);}return this},getComponent:function(a){switch(a){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw Error("index is out of range: "+a);}},clone:function(){return new this.constructor(this.x,this.y,this.z)},copy:function(a){this.x=a.x;this.y=a.y;
this.z=a.z;return this},add:function(a,c){if(void 0!==c)return console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(a,c);this.x+=a.x;this.y+=a.y;this.z+=a.z;return this},addScalar:function(a){this.x+=a;this.y+=a;this.z+=a;return this},addVectors:function(a,c){this.x=a.x+c.x;this.y=a.y+c.y;this.z=a.z+c.z;return this},addScaledVector:function(a,c){this.x+=a.x*c;this.y+=a.y*c;this.z+=a.z*c;return this},sub:function(a,c){if(void 0!==c)return console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),
this.subVectors(a,c);this.x-=a.x;this.y-=a.y;this.z-=a.z;return this},subScalar:function(a){this.x-=a;this.y-=a;this.z-=a;return this},subVectors:function(a,c){this.x=a.x-c.x;this.y=a.y-c.y;this.z=a.z-c.z;return this},multiply:function(a,c){if(void 0!==c)return console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(a,c);this.x*=a.x;this.y*=a.y;this.z*=a.z;return this},multiplyScalar:function(a){this.x*=a;this.y*=a;this.z*=
a;return this},multiplyVectors:function(a,c){this.x=a.x*c.x;this.y=a.y*c.y;this.z=a.z*c.z;return this},applyEuler:function(a){a&&a.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.");return this.applyQuaternion(bk.setFromEuler(a))},applyAxisAngle:function(a,c){return this.applyQuaternion(bk.setFromAxisAngle(a,c))},applyMatrix3:function(a){var c=this.x,e=this.y,g=this.z;a=a.elements;this.x=a[0]*c+a[3]*e+a[6]*g;this.y=a[1]*c+a[4]*e+a[7]*
g;this.z=a[2]*c+a[5]*e+a[8]*g;return this},applyMatrix4:function(a){var c=this.x,e=this.y,g=this.z;a=a.elements;var r=1/(a[3]*c+a[7]*e+a[11]*g+a[15]);this.x=(a[0]*c+a[4]*e+a[8]*g+a[12])*r;this.y=(a[1]*c+a[5]*e+a[9]*g+a[13])*r;this.z=(a[2]*c+a[6]*e+a[10]*g+a[14])*r;return this},applyQuaternion:function(a){var c=this.x,e=this.y,g=this.z,r=a.x,v=a.y,z=a.z;a=a.w;var E=a*c+v*g-z*e,F=a*e+z*c-r*g,J=a*g+r*e-v*c;c=-r*c-v*e-z*g;this.x=E*a+c*-r+F*-z-J*-v;this.y=F*a+c*-v+J*-r-E*-z;this.z=J*a+c*-z+E*-v-F*-r;return this},
project:function(a){return this.applyMatrix4(a.matrixWorldInverse).applyMatrix4(a.projectionMatrix)},unproject:function(a){return this.applyMatrix4(a.projectionMatrixInverse).applyMatrix4(a.matrixWorld)},transformDirection:function(a){var c=this.x,e=this.y,g=this.z;a=a.elements;this.x=a[0]*c+a[4]*e+a[8]*g;this.y=a[1]*c+a[5]*e+a[9]*g;this.z=a[2]*c+a[6]*e+a[10]*g;return this.normalize()},divide:function(a){this.x/=a.x;this.y/=a.y;this.z/=a.z;return this},divideScalar:function(a){return this.multiplyScalar(1/
a)},min:function(a){this.x=Math.min(this.x,a.x);this.y=Math.min(this.y,a.y);this.z=Math.min(this.z,a.z);return this},max:function(a){this.x=Math.max(this.x,a.x);this.y=Math.max(this.y,a.y);this.z=Math.max(this.z,a.z);return this},clamp:function(a,c){this.x=Math.max(a.x,Math.min(c.x,this.x));this.y=Math.max(a.y,Math.min(c.y,this.y));this.z=Math.max(a.z,Math.min(c.z,this.z));return this},clampScalar:function(a,c){this.x=Math.max(a,Math.min(c,this.x));this.y=Math.max(a,Math.min(c,this.y));this.z=Math.max(a,
Math.min(c,this.z));return this},clampLength:function(a,c){var e=this.length();return this.divideScalar(e||1).multiplyScalar(Math.max(a,Math.min(c,e)))},floor:function(){this.x=Math.floor(this.x);this.y=Math.floor(this.y);this.z=Math.floor(this.z);return this},ceil:function(){this.x=Math.ceil(this.x);this.y=Math.ceil(this.y);this.z=Math.ceil(this.z);return this},round:function(){this.x=Math.round(this.x);this.y=Math.round(this.y);this.z=Math.round(this.z);return this},roundToZero:function(){this.x=
0>this.x?Math.ceil(this.x):Math.floor(this.x);this.y=0>this.y?Math.ceil(this.y):Math.floor(this.y);this.z=0>this.z?Math.ceil(this.z):Math.floor(this.z);return this},negate:function(){this.x=-this.x;this.y=-this.y;this.z=-this.z;return this},dot:function(a){return this.x*a.x+this.y*a.y+this.z*a.z},lengthSq:function(){return this.x*this.x+this.y*this.y+this.z*this.z},length:function(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)},manhattanLength:function(){return Math.abs(this.x)+Math.abs(this.y)+
Math.abs(this.z)},normalize:function(){return this.divideScalar(this.length()||1)},setLength:function(a){return this.normalize().multiplyScalar(a)},lerp:function(a,c){this.x+=(a.x-this.x)*c;this.y+=(a.y-this.y)*c;this.z+=(a.z-this.z)*c;return this},lerpVectors:function(a,c,e){return this.subVectors(c,a).multiplyScalar(e).add(a)},cross:function(a,c){return void 0!==c?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(a,c)):this.crossVectors(this,
a)},crossVectors:function(a,c){var e=a.x,g=a.y;a=a.z;var r=c.x,v=c.y;c=c.z;this.x=g*c-a*v;this.y=a*r-e*c;this.z=e*v-g*r;return this},projectOnVector:function(a){var c=a.dot(this)/a.lengthSq();return this.copy(a).multiplyScalar(c)},projectOnPlane:function(a){xi.copy(this).projectOnVector(a);return this.sub(xi)},reflect:function(a){return this.sub(xi.copy(a).multiplyScalar(2*this.dot(a)))},angleTo:function(a){return Math.acos(hb.clamp(this.dot(a)/Math.sqrt(this.lengthSq()*a.lengthSq()),-1,1))},distanceTo:function(a){return Math.sqrt(this.distanceToSquared(a))},
distanceToSquared:function(a){var c=this.x-a.x,e=this.y-a.y;a=this.z-a.z;return c*c+e*e+a*a},manhattanDistanceTo:function(a){return Math.abs(this.x-a.x)+Math.abs(this.y-a.y)+Math.abs(this.z-a.z)},setFromSpherical:function(a){return this.setFromSphericalCoords(a.radius,a.phi,a.theta)},setFromSphericalCoords:function(a,c,e){var g=Math.sin(c)*a;this.x=g*Math.sin(e);this.y=Math.cos(c)*a;this.z=g*Math.cos(e);return this},setFromCylindrical:function(a){return this.setFromCylindricalCoords(a.radius,a.theta,
a.y)},setFromCylindricalCoords:function(a,c,e){this.x=a*Math.sin(c);this.y=e;this.z=a*Math.cos(c);return this},setFromMatrixPosition:function(a){a=a.elements;this.x=a[12];this.y=a[13];this.z=a[14];return this},setFromMatrixScale:function(a){var c=this.setFromMatrixColumn(a,0).length(),e=this.setFromMatrixColumn(a,1).length();a=this.setFromMatrixColumn(a,2).length();this.x=c;this.y=e;this.z=a;return this},setFromMatrixColumn:function(a,c){return this.fromArray(a.elements,4*c)},equals:function(a){return a.x===
this.x&&a.y===this.y&&a.z===this.z},fromArray:function(a,c){void 0===c&&(c=0);this.x=a[c];this.y=a[c+1];this.z=a[c+2];return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);a[c]=this.x;a[c+1]=this.y;a[c+2]=this.z;return a},fromBufferAttribute:function(a,c,e){void 0!==e&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute().");this.x=a.getX(c);this.y=a.getY(c);this.z=a.getZ(c);return this}});var ee=new k;Object.assign(t.prototype,{isMatrix3:!0,set:function(a,
c,e,g,r,v,z,E,F){var J=this.elements;J[0]=a;J[1]=g;J[2]=z;J[3]=c;J[4]=r;J[5]=E;J[6]=e;J[7]=v;J[8]=F;return this},identity:function(){this.set(1,0,0,0,1,0,0,0,1);return this},clone:function(){return(new this.constructor).fromArray(this.elements)},copy:function(a){var c=this.elements;a=a.elements;c[0]=a[0];c[1]=a[1];c[2]=a[2];c[3]=a[3];c[4]=a[4];c[5]=a[5];c[6]=a[6];c[7]=a[7];c[8]=a[8];return this},setFromMatrix4:function(a){a=a.elements;this.set(a[0],a[4],a[8],a[1],a[5],a[9],a[2],a[6],a[10]);return this},
applyToBufferAttribute:function(a){for(var c=0,e=a.count;c<e;c++)ee.x=a.getX(c),ee.y=a.getY(c),ee.z=a.getZ(c),ee.applyMatrix3(this),a.setXYZ(c,ee.x,ee.y,ee.z);return a},multiply:function(a){return this.multiplyMatrices(this,a)},premultiply:function(a){return this.multiplyMatrices(a,this)},multiplyMatrices:function(a,c){var e=a.elements,g=c.elements;c=this.elements;a=e[0];var r=e[3],v=e[6],z=e[1],E=e[4],F=e[7],J=e[2],P=e[5];e=e[8];var R=g[0],S=g[3],V=g[6],W=g[1],ha=g[4],fa=g[7],ra=g[2],pa=g[5];g=g[8];
c[0]=a*R+r*W+v*ra;c[3]=a*S+r*ha+v*pa;c[6]=a*V+r*fa+v*g;c[1]=z*R+E*W+F*ra;c[4]=z*S+E*ha+F*pa;c[7]=z*V+E*fa+F*g;c[2]=J*R+P*W+e*ra;c[5]=J*S+P*ha+e*pa;c[8]=J*V+P*fa+e*g;return this},multiplyScalar:function(a){var c=this.elements;c[0]*=a;c[3]*=a;c[6]*=a;c[1]*=a;c[4]*=a;c[7]*=a;c[2]*=a;c[5]*=a;c[8]*=a;return this},determinant:function(){var a=this.elements,c=a[0],e=a[1],g=a[2],r=a[3],v=a[4],z=a[5],E=a[6],F=a[7];a=a[8];return c*v*a-c*z*F-e*r*a+e*z*E+g*r*F-g*v*E},getInverse:function(a,c){a&&a.isMatrix4&&
console.error("THREE.Matrix3: .getInverse() no longer takes a Matrix4 argument.");var e=a.elements;a=this.elements;var g=e[0],r=e[1],v=e[2],z=e[3],E=e[4],F=e[5],J=e[6],P=e[7];e=e[8];var R=e*E-F*P,S=F*J-e*z,V=P*z-E*J,W=g*R+r*S+v*V;if(0===W){if(!0===c)throw Error("THREE.Matrix3: .getInverse() can't invert matrix, determinant is 0");console.warn("THREE.Matrix3: .getInverse() can't invert matrix, determinant is 0");return this.identity()}c=1/W;a[0]=R*c;a[1]=(v*P-e*r)*c;a[2]=(F*r-v*E)*c;a[3]=S*c;a[4]=
(e*g-v*J)*c;a[5]=(v*z-F*g)*c;a[6]=V*c;a[7]=(r*J-P*g)*c;a[8]=(E*g-r*z)*c;return this},transpose:function(){var a=this.elements;var c=a[1];a[1]=a[3];a[3]=c;c=a[2];a[2]=a[6];a[6]=c;c=a[5];a[5]=a[7];a[7]=c;return this},getNormalMatrix:function(a){return this.setFromMatrix4(a).getInverse(this).transpose()},transposeIntoArray:function(a){var c=this.elements;a[0]=c[0];a[1]=c[3];a[2]=c[6];a[3]=c[1];a[4]=c[4];a[5]=c[7];a[6]=c[2];a[7]=c[5];a[8]=c[8];return this},setUvTransform:function(a,c,e,g,r,v,z){var E=
Math.cos(r);r=Math.sin(r);this.set(e*E,e*r,-e*(E*v+r*z)+v+a,-g*r,g*E,-g*(-r*v+E*z)+z+c,0,0,1)},scale:function(a,c){var e=this.elements;e[0]*=a;e[3]*=a;e[6]*=a;e[1]*=c;e[4]*=c;e[7]*=c;return this},rotate:function(a){var c=Math.cos(a);a=Math.sin(a);var e=this.elements,g=e[0],r=e[3],v=e[6],z=e[1],E=e[4],F=e[7];e[0]=c*g+a*z;e[3]=c*r+a*E;e[6]=c*v+a*F;e[1]=-a*g+c*z;e[4]=-a*r+c*E;e[7]=-a*v+c*F;return this},translate:function(a,c){var e=this.elements;e[0]+=a*e[2];e[3]+=a*e[5];e[6]+=a*e[8];e[1]+=c*e[2];e[4]+=
c*e[5];e[7]+=c*e[8];return this},equals:function(a){var c=this.elements;a=a.elements;for(var e=0;9>e;e++)if(c[e]!==a[e])return!1;return!0},fromArray:function(a,c){void 0===c&&(c=0);for(var e=0;9>e;e++)this.elements[e]=a[e+c];return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);var e=this.elements;a[c]=e[0];a[c+1]=e[1];a[c+2]=e[2];a[c+3]=e[3];a[c+4]=e[4];a[c+5]=e[5];a[c+6]=e[6];a[c+7]=e[7];a[c+8]=e[8];return a}});var ef,Dd={getDataURL:function(a){if("undefined"==typeof HTMLCanvasElement)return a.src;
if(!(a instanceof HTMLCanvasElement)){void 0===ef&&(ef=document.createElementNS("http://www.w3.org/1999/xhtml","canvas"));ef.width=a.width;ef.height=a.height;var c=ef.getContext("2d");a instanceof ImageData?c.putImageData(a,0,0):c.drawImage(a,0,0,a.width,a.height);a=ef}return 2048<a.width||2048<a.height?a.toDataURL("image/jpeg",.6):a.toDataURL("image/png")}},Nk=0;l.DEFAULT_IMAGE=void 0;l.DEFAULT_MAPPING=300;l.prototype=Object.assign(Object.create(d.prototype),{constructor:l,isTexture:!0,updateMatrix:function(){this.matrix.setUvTransform(this.offset.x,
this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.name=a.name;this.image=a.image;this.mipmaps=a.mipmaps.slice(0);this.mapping=a.mapping;this.wrapS=a.wrapS;this.wrapT=a.wrapT;this.magFilter=a.magFilter;this.minFilter=a.minFilter;this.anisotropy=a.anisotropy;this.format=a.format;this.type=a.type;this.offset.copy(a.offset);this.repeat.copy(a.repeat);this.center.copy(a.center);this.rotation=
a.rotation;this.matrixAutoUpdate=a.matrixAutoUpdate;this.matrix.copy(a.matrix);this.generateMipmaps=a.generateMipmaps;this.premultiplyAlpha=a.premultiplyAlpha;this.flipY=a.flipY;this.unpackAlignment=a.unpackAlignment;this.encoding=a.encoding;return this},toJSON:function(a){var c=void 0===a||"string"===typeof a;if(!c&&void 0!==a.textures[this.uuid])return a.textures[this.uuid];var e={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){var g=this.image;void 0===g.uuid&&(g.uuid=hb.generateUUID());if(!c&&void 0===a.images[g.uuid]){if(Array.isArray(g)){var r=
[];for(var v=0,z=g.length;v<z;v++)r.push(Dd.getDataURL(g[v]))}else r=Dd.getDataURL(g);a.images[g.uuid]={uuid:g.uuid,url:r}}e.image=g.uuid}c||(a.textures[this.uuid]=e);return e},dispose:function(){this.dispatchEvent({type:"dispose"})},transformUv:function(a){if(300!==this.mapping)return a;a.applyMatrix3(this.matrix);if(0>a.x||1<a.x)switch(this.wrapS){case 1E3:a.x-=Math.floor(a.x);break;case 1001:a.x=0>a.x?0:1;break;case 1002:a.x=1===Math.abs(Math.floor(a.x)%2)?Math.ceil(a.x)-a.x:a.x-Math.floor(a.x)}if(0>
a.y||1<a.y)switch(this.wrapT){case 1E3:a.y-=Math.floor(a.y);break;case 1001:a.y=0>a.y?0:1;break;case 1002:a.y=1===Math.abs(Math.floor(a.y)%2)?Math.ceil(a.y)-a.y:a.y-Math.floor(a.y)}this.flipY&&(a.y=1-a.y);return a}});Object.defineProperty(l.prototype,"needsUpdate",{set:function(a){!0===a&&this.version++}});Object.defineProperties(p.prototype,{width:{get:function(){return this.z},set:function(a){this.z=a}},height:{get:function(){return this.w},set:function(a){this.w=a}}});Object.assign(p.prototype,
{isVector4:!0,set:function(a,c,e,g){this.x=a;this.y=c;this.z=e;this.w=g;return this},setScalar:function(a){this.w=this.z=this.y=this.x=a;return this},setX:function(a){this.x=a;return this},setY:function(a){this.y=a;return this},setZ:function(a){this.z=a;return this},setW:function(a){this.w=a;return this},setComponent:function(a,c){switch(a){case 0:this.x=c;break;case 1:this.y=c;break;case 2:this.z=c;break;case 3:this.w=c;break;default:throw Error("index is out of range: "+a);}return this},getComponent:function(a){switch(a){case 0:return this.x;
case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw Error("index is out of range: "+a);}},clone:function(){return new this.constructor(this.x,this.y,this.z,this.w)},copy:function(a){this.x=a.x;this.y=a.y;this.z=a.z;this.w=void 0!==a.w?a.w:1;return this},add:function(a,c){if(void 0!==c)return console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(a,c);this.x+=a.x;this.y+=a.y;this.z+=a.z;this.w+=a.w;return this},
addScalar:function(a){this.x+=a;this.y+=a;this.z+=a;this.w+=a;return this},addVectors:function(a,c){this.x=a.x+c.x;this.y=a.y+c.y;this.z=a.z+c.z;this.w=a.w+c.w;return this},addScaledVector:function(a,c){this.x+=a.x*c;this.y+=a.y*c;this.z+=a.z*c;this.w+=a.w*c;return this},sub:function(a,c){if(void 0!==c)return console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(a,c);this.x-=a.x;this.y-=a.y;this.z-=a.z;this.w-=a.w;return this},subScalar:function(a){this.x-=
a;this.y-=a;this.z-=a;this.w-=a;return this},subVectors:function(a,c){this.x=a.x-c.x;this.y=a.y-c.y;this.z=a.z-c.z;this.w=a.w-c.w;return this},multiplyScalar:function(a){this.x*=a;this.y*=a;this.z*=a;this.w*=a;return this},applyMatrix4:function(a){var c=this.x,e=this.y,g=this.z,r=this.w;a=a.elements;this.x=a[0]*c+a[4]*e+a[8]*g+a[12]*r;this.y=a[1]*c+a[5]*e+a[9]*g+a[13]*r;this.z=a[2]*c+a[6]*e+a[10]*g+a[14]*r;this.w=a[3]*c+a[7]*e+a[11]*g+a[15]*r;return this},divideScalar:function(a){return this.multiplyScalar(1/
a)},setAxisAngleFromQuaternion:function(a){this.w=2*Math.acos(a.w);var c=Math.sqrt(1-a.w*a.w);1E-4>c?(this.x=1,this.z=this.y=0):(this.x=a.x/c,this.y=a.y/c,this.z=a.z/c);return this},setAxisAngleFromRotationMatrix:function(a){a=a.elements;var c=a[0];var e=a[4];var g=a[8],r=a[1],v=a[5],z=a[9];var E=a[2];var F=a[6];var J=a[10];if(.01>Math.abs(e-r)&&.01>Math.abs(g-E)&&.01>Math.abs(z-F)){if(.1>Math.abs(e+r)&&.1>Math.abs(g+E)&&.1>Math.abs(z+F)&&.1>Math.abs(c+v+J-3))return this.set(1,0,0,0),this;a=Math.PI;
c=(c+1)/2;v=(v+1)/2;J=(J+1)/2;e=(e+r)/4;g=(g+E)/4;z=(z+F)/4;c>v&&c>J?.01>c?(F=0,e=E=.707106781):(F=Math.sqrt(c),E=e/F,e=g/F):v>J?.01>v?(F=.707106781,E=0,e=.707106781):(E=Math.sqrt(v),F=e/E,e=z/E):.01>J?(E=F=.707106781,e=0):(e=Math.sqrt(J),F=g/e,E=z/e);this.set(F,E,e,a);return this}a=Math.sqrt((F-z)*(F-z)+(g-E)*(g-E)+(r-e)*(r-e));.001>Math.abs(a)&&(a=1);this.x=(F-z)/a;this.y=(g-E)/a;this.z=(r-e)/a;this.w=Math.acos((c+v+J-1)/2);return this},min:function(a){this.x=Math.min(this.x,a.x);this.y=Math.min(this.y,
a.y);this.z=Math.min(this.z,a.z);this.w=Math.min(this.w,a.w);return this},max:function(a){this.x=Math.max(this.x,a.x);this.y=Math.max(this.y,a.y);this.z=Math.max(this.z,a.z);this.w=Math.max(this.w,a.w);return this},clamp:function(a,c){this.x=Math.max(a.x,Math.min(c.x,this.x));this.y=Math.max(a.y,Math.min(c.y,this.y));this.z=Math.max(a.z,Math.min(c.z,this.z));this.w=Math.max(a.w,Math.min(c.w,this.w));return this},clampScalar:function(a,c){this.x=Math.max(a,Math.min(c,this.x));this.y=Math.max(a,Math.min(c,
this.y));this.z=Math.max(a,Math.min(c,this.z));this.w=Math.max(a,Math.min(c,this.w));return this},clampLength:function(a,c){var e=this.length();return this.divideScalar(e||1).multiplyScalar(Math.max(a,Math.min(c,e)))},floor:function(){this.x=Math.floor(this.x);this.y=Math.floor(this.y);this.z=Math.floor(this.z);this.w=Math.floor(this.w);return this},ceil:function(){this.x=Math.ceil(this.x);this.y=Math.ceil(this.y);this.z=Math.ceil(this.z);this.w=Math.ceil(this.w);return this},round:function(){this.x=
Math.round(this.x);this.y=Math.round(this.y);this.z=Math.round(this.z);this.w=Math.round(this.w);return this},roundToZero:function(){this.x=0>this.x?Math.ceil(this.x):Math.floor(this.x);this.y=0>this.y?Math.ceil(this.y):Math.floor(this.y);this.z=0>this.z?Math.ceil(this.z):Math.floor(this.z);this.w=0>this.w?Math.ceil(this.w):Math.floor(this.w);return this},negate:function(){this.x=-this.x;this.y=-this.y;this.z=-this.z;this.w=-this.w;return this},dot:function(a){return this.x*a.x+this.y*a.y+this.z*
a.z+this.w*a.w},lengthSq:function(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w},length:function(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)},manhattanLength:function(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)},normalize:function(){return this.divideScalar(this.length()||1)},setLength:function(a){return this.normalize().multiplyScalar(a)},lerp:function(a,c){this.x+=(a.x-this.x)*c;this.y+=(a.y-this.y)*c;this.z+=(a.z-
this.z)*c;this.w+=(a.w-this.w)*c;return this},lerpVectors:function(a,c,e){return this.subVectors(c,a).multiplyScalar(e).add(a)},equals:function(a){return a.x===this.x&&a.y===this.y&&a.z===this.z&&a.w===this.w},fromArray:function(a,c){void 0===c&&(c=0);this.x=a[c];this.y=a[c+1];this.z=a[c+2];this.w=a[c+3];return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);a[c]=this.x;a[c+1]=this.y;a[c+2]=this.z;a[c+3]=this.w;return a},fromBufferAttribute:function(a,c,e){void 0!==e&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute().");
this.x=a.getX(c);this.y=a.getY(c);this.z=a.getZ(c);this.w=a.getW(c);return this}});m.prototype=Object.assign(Object.create(d.prototype),{constructor:m,isWebGLRenderTarget:!0,setSize:function(a,c){if(this.width!==a||this.height!==c)this.width=a,this.height=c,this.texture.image.width=a,this.texture.image.height=c,this.dispose();this.viewport.set(0,0,a,c);this.scissor.set(0,0,a,c)},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.width=a.width;this.height=a.height;this.viewport.copy(a.viewport);
this.texture=a.texture.clone();this.depthBuffer=a.depthBuffer;this.stencilBuffer=a.stencilBuffer;this.depthTexture=a.depthTexture;return this},dispose:function(){this.dispatchEvent({type:"dispose"})}});n.prototype=Object.assign(Object.create(m.prototype),{constructor:n,isWebGLMultisampleRenderTarget:!0,copy:function(a){m.prototype.copy.call(this,a);this.samples=a.samples;return this}});var qc=new k,Qb=new q,xm=new k(0,0,0),ym=new k(1,1,1),Ed=new k,gh=new k,fc=new k;Object.assign(q.prototype,{isMatrix4:!0,
set:function(a,c,e,g,r,v,z,E,F,J,P,R,S,V,W,ha){var fa=this.elements;fa[0]=a;fa[4]=c;fa[8]=e;fa[12]=g;fa[1]=r;fa[5]=v;fa[9]=z;fa[13]=E;fa[2]=F;fa[6]=J;fa[10]=P;fa[14]=R;fa[3]=S;fa[7]=V;fa[11]=W;fa[15]=ha;return this},identity:function(){this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1);return this},clone:function(){return(new q).fromArray(this.elements)},copy:function(a){var c=this.elements;a=a.elements;c[0]=a[0];c[1]=a[1];c[2]=a[2];c[3]=a[3];c[4]=a[4];c[5]=a[5];c[6]=a[6];c[7]=a[7];c[8]=a[8];c[9]=a[9];c[10]=
a[10];c[11]=a[11];c[12]=a[12];c[13]=a[13];c[14]=a[14];c[15]=a[15];return this},copyPosition:function(a){var c=this.elements;a=a.elements;c[12]=a[12];c[13]=a[13];c[14]=a[14];return this},extractBasis:function(a,c,e){a.setFromMatrixColumn(this,0);c.setFromMatrixColumn(this,1);e.setFromMatrixColumn(this,2);return this},makeBasis:function(a,c,e){this.set(a.x,c.x,e.x,0,a.y,c.y,e.y,0,a.z,c.z,e.z,0,0,0,0,1);return this},extractRotation:function(a){var c=this.elements,e=a.elements,g=1/qc.setFromMatrixColumn(a,
0).length(),r=1/qc.setFromMatrixColumn(a,1).length();a=1/qc.setFromMatrixColumn(a,2).length();c[0]=e[0]*g;c[1]=e[1]*g;c[2]=e[2]*g;c[3]=0;c[4]=e[4]*r;c[5]=e[5]*r;c[6]=e[6]*r;c[7]=0;c[8]=e[8]*a;c[9]=e[9]*a;c[10]=e[10]*a;c[11]=0;c[12]=0;c[13]=0;c[14]=0;c[15]=1;return this},makeRotationFromEuler:function(a){a&&a.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");var c=this.elements,e=a.x,g=a.y,r=a.z,v=Math.cos(e);e=Math.sin(e);
var z=Math.cos(g);g=Math.sin(g);var E=Math.cos(r);r=Math.sin(r);if("XYZ"===a.order){a=v*E;var F=v*r,J=e*E,P=e*r;c[0]=z*E;c[4]=-z*r;c[8]=g;c[1]=F+J*g;c[5]=a-P*g;c[9]=-e*z;c[2]=P-a*g;c[6]=J+F*g;c[10]=v*z}else"YXZ"===a.order?(a=z*E,F=z*r,J=g*E,P=g*r,c[0]=a+P*e,c[4]=J*e-F,c[8]=v*g,c[1]=v*r,c[5]=v*E,c[9]=-e,c[2]=F*e-J,c[6]=P+a*e,c[10]=v*z):"ZXY"===a.order?(a=z*E,F=z*r,J=g*E,P=g*r,c[0]=a-P*e,c[4]=-v*r,c[8]=J+F*e,c[1]=F+J*e,c[5]=v*E,c[9]=P-a*e,c[2]=-v*g,c[6]=e,c[10]=v*z):"ZYX"===a.order?(a=v*E,F=v*r,J=e*
E,P=e*r,c[0]=z*E,c[4]=J*g-F,c[8]=a*g+P,c[1]=z*r,c[5]=P*g+a,c[9]=F*g-J,c[2]=-g,c[6]=e*z,c[10]=v*z):"YZX"===a.order?(a=v*z,F=v*g,J=e*z,P=e*g,c[0]=z*E,c[4]=P-a*r,c[8]=J*r+F,c[1]=r,c[5]=v*E,c[9]=-e*E,c[2]=-g*E,c[6]=F*r+J,c[10]=a-P*r):"XZY"===a.order&&(a=v*z,F=v*g,J=e*z,P=e*g,c[0]=z*E,c[4]=-r,c[8]=g*E,c[1]=a*r+P,c[5]=v*E,c[9]=F*r-J,c[2]=J*r-F,c[6]=e*E,c[10]=P*r+a);c[3]=0;c[7]=0;c[11]=0;c[12]=0;c[13]=0;c[14]=0;c[15]=1;return this},makeRotationFromQuaternion:function(a){return this.compose(xm,a,ym)},lookAt:function(a,
c,e){var g=this.elements;fc.subVectors(a,c);0===fc.lengthSq()&&(fc.z=1);fc.normalize();Ed.crossVectors(e,fc);0===Ed.lengthSq()&&(1===Math.abs(e.z)?fc.x+=1E-4:fc.z+=1E-4,fc.normalize(),Ed.crossVectors(e,fc));Ed.normalize();gh.crossVectors(fc,Ed);g[0]=Ed.x;g[4]=gh.x;g[8]=fc.x;g[1]=Ed.y;g[5]=gh.y;g[9]=fc.y;g[2]=Ed.z;g[6]=gh.z;g[10]=fc.z;return this},multiply:function(a,c){return void 0!==c?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),
this.multiplyMatrices(a,c)):this.multiplyMatrices(this,a)},premultiply:function(a){return this.multiplyMatrices(a,this)},multiplyMatrices:function(a,c){var e=a.elements,g=c.elements;c=this.elements;a=e[0];var r=e[4],v=e[8],z=e[12],E=e[1],F=e[5],J=e[9],P=e[13],R=e[2],S=e[6],V=e[10],W=e[14],ha=e[3],fa=e[7],ra=e[11];e=e[15];var pa=g[0],qa=g[4],ua=g[8],oa=g[12],ta=g[1],Ba=g[5],Ta=g[9],Ua=g[13],Ca=g[2],Ha=g[6],Da=g[10],Ma=g[14],db=g[3],tb=g[7],Ka=g[11];g=g[15];c[0]=a*pa+r*ta+v*Ca+z*db;c[4]=a*qa+r*Ba+v*
Ha+z*tb;c[8]=a*ua+r*Ta+v*Da+z*Ka;c[12]=a*oa+r*Ua+v*Ma+z*g;c[1]=E*pa+F*ta+J*Ca+P*db;c[5]=E*qa+F*Ba+J*Ha+P*tb;c[9]=E*ua+F*Ta+J*Da+P*Ka;c[13]=E*oa+F*Ua+J*Ma+P*g;c[2]=R*pa+S*ta+V*Ca+W*db;c[6]=R*qa+S*Ba+V*Ha+W*tb;c[10]=R*ua+S*Ta+V*Da+W*Ka;c[14]=R*oa+S*Ua+V*Ma+W*g;c[3]=ha*pa+fa*ta+ra*Ca+e*db;c[7]=ha*qa+fa*Ba+ra*Ha+e*tb;c[11]=ha*ua+fa*Ta+ra*Da+e*Ka;c[15]=ha*oa+fa*Ua+ra*Ma+e*g;return this},multiplyScalar:function(a){var c=this.elements;c[0]*=a;c[4]*=a;c[8]*=a;c[12]*=a;c[1]*=a;c[5]*=a;c[9]*=a;c[13]*=a;c[2]*=
a;c[6]*=a;c[10]*=a;c[14]*=a;c[3]*=a;c[7]*=a;c[11]*=a;c[15]*=a;return this},applyToBufferAttribute:function(a){for(var c=0,e=a.count;c<e;c++)qc.x=a.getX(c),qc.y=a.getY(c),qc.z=a.getZ(c),qc.applyMatrix4(this),a.setXYZ(c,qc.x,qc.y,qc.z);return a},determinant:function(){var a=this.elements,c=a[0],e=a[4],g=a[8],r=a[12],v=a[1],z=a[5],E=a[9],F=a[13],J=a[2],P=a[6],R=a[10],S=a[14];return a[3]*(+r*E*P-g*F*P-r*z*R+e*F*R+g*z*S-e*E*S)+a[7]*(+c*E*S-c*F*R+r*v*R-g*v*S+g*F*J-r*E*J)+a[11]*(+c*F*P-c*z*S-r*v*P+e*v*S+
r*z*J-e*F*J)+a[15]*(-g*z*J-c*E*P+c*z*R+g*v*P-e*v*R+e*E*J)},transpose:function(){var a=this.elements;var c=a[1];a[1]=a[4];a[4]=c;c=a[2];a[2]=a[8];a[8]=c;c=a[6];a[6]=a[9];a[9]=c;c=a[3];a[3]=a[12];a[12]=c;c=a[7];a[7]=a[13];a[13]=c;c=a[11];a[11]=a[14];a[14]=c;return this},setPosition:function(a,c,e){var g=this.elements;a.isVector3?(g[12]=a.x,g[13]=a.y,g[14]=a.z):(g[12]=a,g[13]=c,g[14]=e);return this},getInverse:function(a,c){var e=this.elements,g=a.elements;a=g[0];var r=g[1],v=g[2],z=g[3],E=g[4],F=g[5],
J=g[6],P=g[7],R=g[8],S=g[9],V=g[10],W=g[11],ha=g[12],fa=g[13],ra=g[14];g=g[15];var pa=S*ra*P-fa*V*P+fa*J*W-F*ra*W-S*J*g+F*V*g,qa=ha*V*P-R*ra*P-ha*J*W+E*ra*W+R*J*g-E*V*g,ua=R*fa*P-ha*S*P+ha*F*W-E*fa*W-R*F*g+E*S*g,oa=ha*S*J-R*fa*J-ha*F*V+E*fa*V+R*F*ra-E*S*ra,ta=a*pa+r*qa+v*ua+z*oa;if(0===ta){if(!0===c)throw Error("THREE.Matrix4: .getInverse() can't invert matrix, determinant is 0");console.warn("THREE.Matrix4: .getInverse() can't invert matrix, determinant is 0");return this.identity()}c=1/ta;e[0]=
pa*c;e[1]=(fa*V*z-S*ra*z-fa*v*W+r*ra*W+S*v*g-r*V*g)*c;e[2]=(F*ra*z-fa*J*z+fa*v*P-r*ra*P-F*v*g+r*J*g)*c;e[3]=(S*J*z-F*V*z-S*v*P+r*V*P+F*v*W-r*J*W)*c;e[4]=qa*c;e[5]=(R*ra*z-ha*V*z+ha*v*W-a*ra*W-R*v*g+a*V*g)*c;e[6]=(ha*J*z-E*ra*z-ha*v*P+a*ra*P+E*v*g-a*J*g)*c;e[7]=(E*V*z-R*J*z+R*v*P-a*V*P-E*v*W+a*J*W)*c;e[8]=ua*c;e[9]=(ha*S*z-R*fa*z-ha*r*W+a*fa*W+R*r*g-a*S*g)*c;e[10]=(E*fa*z-ha*F*z+ha*r*P-a*fa*P-E*r*g+a*F*g)*c;e[11]=(R*F*z-E*S*z-R*r*P+a*S*P+E*r*W-a*F*W)*c;e[12]=oa*c;e[13]=(R*fa*v-ha*S*v+ha*r*V-a*fa*V-
R*r*ra+a*S*ra)*c;e[14]=(ha*F*v-E*fa*v-ha*r*J+a*fa*J+E*r*ra-a*F*ra)*c;e[15]=(E*S*v-R*F*v+R*r*J-a*S*J-E*r*V+a*F*V)*c;return this},scale:function(a){var c=this.elements,e=a.x,g=a.y;a=a.z;c[0]*=e;c[4]*=g;c[8]*=a;c[1]*=e;c[5]*=g;c[9]*=a;c[2]*=e;c[6]*=g;c[10]*=a;c[3]*=e;c[7]*=g;c[11]*=a;return this},getMaxScaleOnAxis:function(){var a=this.elements;return Math.sqrt(Math.max(a[0]*a[0]+a[1]*a[1]+a[2]*a[2],a[4]*a[4]+a[5]*a[5]+a[6]*a[6],a[8]*a[8]+a[9]*a[9]+a[10]*a[10]))},makeTranslation:function(a,c,e){this.set(1,
0,0,a,0,1,0,c,0,0,1,e,0,0,0,1);return this},makeRotationX:function(a){var c=Math.cos(a);a=Math.sin(a);this.set(1,0,0,0,0,c,-a,0,0,a,c,0,0,0,0,1);return this},makeRotationY:function(a){var c=Math.cos(a);a=Math.sin(a);this.set(c,0,a,0,0,1,0,0,-a,0,c,0,0,0,0,1);return this},makeRotationZ:function(a){var c=Math.cos(a);a=Math.sin(a);this.set(c,-a,0,0,a,c,0,0,0,0,1,0,0,0,0,1);return this},makeRotationAxis:function(a,c){var e=Math.cos(c);c=Math.sin(c);var g=1-e,r=a.x,v=a.y;a=a.z;var z=g*r,E=g*v;this.set(z*
r+e,z*v-c*a,z*a+c*v,0,z*v+c*a,E*v+e,E*a-c*r,0,z*a-c*v,E*a+c*r,g*a*a+e,0,0,0,0,1);return this},makeScale:function(a,c,e){this.set(a,0,0,0,0,c,0,0,0,0,e,0,0,0,0,1);return this},makeShear:function(a,c,e){this.set(1,c,e,0,a,1,e,0,a,c,1,0,0,0,0,1);return this},compose:function(a,c,e){var g=this.elements,r=c._x,v=c._y,z=c._z,E=c._w,F=r+r,J=v+v,P=z+z;c=r*F;var R=r*J;r*=P;var S=v*J;v*=P;z*=P;F*=E;J*=E;E*=P;P=e.x;var V=e.y;e=e.z;g[0]=(1-(S+z))*P;g[1]=(R+E)*P;g[2]=(r-J)*P;g[3]=0;g[4]=(R-E)*V;g[5]=(1-(c+z))*
V;g[6]=(v+F)*V;g[7]=0;g[8]=(r+J)*e;g[9]=(v-F)*e;g[10]=(1-(c+S))*e;g[11]=0;g[12]=a.x;g[13]=a.y;g[14]=a.z;g[15]=1;return this},decompose:function(a,c,e){var g=this.elements,r=qc.set(g[0],g[1],g[2]).length(),v=qc.set(g[4],g[5],g[6]).length(),z=qc.set(g[8],g[9],g[10]).length();0>this.determinant()&&(r=-r);a.x=g[12];a.y=g[13];a.z=g[14];Qb.copy(this);a=1/r;g=1/v;var E=1/z;Qb.elements[0]*=a;Qb.elements[1]*=a;Qb.elements[2]*=a;Qb.elements[4]*=g;Qb.elements[5]*=g;Qb.elements[6]*=g;Qb.elements[8]*=E;Qb.elements[9]*=
E;Qb.elements[10]*=E;c.setFromRotationMatrix(Qb);e.x=r;e.y=v;e.z=z;return this},makePerspective:function(a,c,e,g,r,v){void 0===v&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");var z=this.elements;z[0]=2*r/(c-a);z[4]=0;z[8]=(c+a)/(c-a);z[12]=0;z[1]=0;z[5]=2*r/(e-g);z[9]=(e+g)/(e-g);z[13]=0;z[2]=0;z[6]=0;z[10]=-(v+r)/(v-r);z[14]=-2*v*r/(v-r);z[3]=0;z[7]=0;z[11]=-1;z[15]=0;return this},makeOrthographic:function(a,c,e,g,r,v){var z=
this.elements,E=1/(c-a),F=1/(e-g),J=1/(v-r);z[0]=2*E;z[4]=0;z[8]=0;z[12]=-((c+a)*E);z[1]=0;z[5]=2*F;z[9]=0;z[13]=-((e+g)*F);z[2]=0;z[6]=0;z[10]=-2*J;z[14]=-((v+r)*J);z[3]=0;z[7]=0;z[11]=0;z[15]=1;return this},equals:function(a){var c=this.elements;a=a.elements;for(var e=0;16>e;e++)if(c[e]!==a[e])return!1;return!0},fromArray:function(a,c){void 0===c&&(c=0);for(var e=0;16>e;e++)this.elements[e]=a[e+c];return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);var e=this.elements;a[c]=e[0];
a[c+1]=e[1];a[c+2]=e[2];a[c+3]=e[3];a[c+4]=e[4];a[c+5]=e[5];a[c+6]=e[6];a[c+7]=e[7];a[c+8]=e[8];a[c+9]=e[9];a[c+10]=e[10];a[c+11]=e[11];a[c+12]=e[12];a[c+13]=e[13];a[c+14]=e[14];a[c+15]=e[15];return a}});var ck=new q,dk=new h;u.RotationOrders="XYZ YZX ZXY XZY YXZ ZYX".split(" ");u.DefaultOrder="XYZ";Object.defineProperties(u.prototype,{x:{get:function(){return this._x},set:function(a){this._x=a;this._onChangeCallback()}},y:{get:function(){return this._y},set:function(a){this._y=a;this._onChangeCallback()}},
z:{get:function(){return this._z},set:function(a){this._z=a;this._onChangeCallback()}},order:{get:function(){return this._order},set:function(a){this._order=a;this._onChangeCallback()}}});Object.assign(u.prototype,{isEuler:!0,set:function(a,c,e,g){this._x=a;this._y=c;this._z=e;this._order=g||this._order;this._onChangeCallback();return this},clone:function(){return new this.constructor(this._x,this._y,this._z,this._order)},copy:function(a){this._x=a._x;this._y=a._y;this._z=a._z;this._order=a._order;
this._onChangeCallback();return this},setFromRotationMatrix:function(a,c,e){var g=hb.clamp,r=a.elements;a=r[0];var v=r[4],z=r[8],E=r[1],F=r[5],J=r[9],P=r[2],R=r[6];r=r[10];c=c||this._order;"XYZ"===c?(this._y=Math.asin(g(z,-1,1)),.9999999>Math.abs(z)?(this._x=Math.atan2(-J,r),this._z=Math.atan2(-v,a)):(this._x=Math.atan2(R,F),this._z=0)):"YXZ"===c?(this._x=Math.asin(-g(J,-1,1)),.9999999>Math.abs(J)?(this._y=Math.atan2(z,r),this._z=Math.atan2(E,F)):(this._y=Math.atan2(-P,a),this._z=0)):"ZXY"===c?(this._x=
Math.asin(g(R,-1,1)),.9999999>Math.abs(R)?(this._y=Math.atan2(-P,r),this._z=Math.atan2(-v,F)):(this._y=0,this._z=Math.atan2(E,a))):"ZYX"===c?(this._y=Math.asin(-g(P,-1,1)),.9999999>Math.abs(P)?(this._x=Math.atan2(R,r),this._z=Math.atan2(E,a)):(this._x=0,this._z=Math.atan2(-v,F))):"YZX"===c?(this._z=Math.asin(g(E,-1,1)),.9999999>Math.abs(E)?(this._x=Math.atan2(-J,F),this._y=Math.atan2(-P,a)):(this._x=0,this._y=Math.atan2(z,r))):"XZY"===c?(this._z=Math.asin(-g(v,-1,1)),.9999999>Math.abs(v)?(this._x=
Math.atan2(R,F),this._y=Math.atan2(z,a)):(this._x=Math.atan2(-J,r),this._y=0)):console.warn("THREE.Euler: .setFromRotationMatrix() given unsupported order: "+c);this._order=c;!1!==e&&this._onChangeCallback();return this},setFromQuaternion:function(a,c,e){ck.makeRotationFromQuaternion(a);return this.setFromRotationMatrix(ck,c,e)},setFromVector3:function(a,c){return this.set(a.x,a.y,a.z,c||this._order)},reorder:function(a){dk.setFromEuler(this);return this.setFromQuaternion(dk,a)},equals:function(a){return a._x===
this._x&&a._y===this._y&&a._z===this._z&&a._order===this._order},fromArray:function(a){this._x=a[0];this._y=a[1];this._z=a[2];void 0!==a[3]&&(this._order=a[3]);this._onChangeCallback();return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);a[c]=this._x;a[c+1]=this._y;a[c+2]=this._z;a[c+3]=this._order;return a},toVector3:function(a){return a?a.set(this._x,this._y,this._z):new k(this._x,this._y,this._z)},_onChange:function(a){this._onChangeCallback=a;return this},_onChangeCallback:function(){}});
Object.assign(x.prototype,{set:function(a){this.mask=1<<a|0},enable:function(a){this.mask=this.mask|1<<a|0},enableAll:function(){this.mask=-1},toggle:function(a){this.mask^=1<<a|0},disable:function(a){this.mask&=~(1<<a|0)},disableAll:function(){this.mask=0},test:function(a){return 0!==(this.mask&a.mask)}});var Ok=0,ek=new k,ff=new h,jd=new q,hh=new k,kg=new k,zm=new k,Am=new h,fk=new k(1,0,0),gk=new k(0,1,0),hk=new k(0,0,1),Bm={type:"added"},Cm={type:"removed"};A.DefaultUp=new k(0,1,0);A.DefaultMatrixAutoUpdate=
!0;A.prototype=Object.assign(Object.create(d.prototype),{constructor:A,isObject3D:!0,onBeforeRender:function(){},onAfterRender:function(){},applyMatrix:function(a){this.matrixAutoUpdate&&this.updateMatrix();this.matrix.premultiply(a);this.matrix.decompose(this.position,this.quaternion,this.scale)},applyQuaternion:function(a){this.quaternion.premultiply(a);return this},setRotationFromAxisAngle:function(a,c){this.quaternion.setFromAxisAngle(a,c)},setRotationFromEuler:function(a){this.quaternion.setFromEuler(a,
!0)},setRotationFromMatrix:function(a){this.quaternion.setFromRotationMatrix(a)},setRotationFromQuaternion:function(a){this.quaternion.copy(a)},rotateOnAxis:function(a,c){ff.setFromAxisAngle(a,c);this.quaternion.multiply(ff);return this},rotateOnWorldAxis:function(a,c){ff.setFromAxisAngle(a,c);this.quaternion.premultiply(ff);return this},rotateX:function(a){return this.rotateOnAxis(fk,a)},rotateY:function(a){return this.rotateOnAxis(gk,a)},rotateZ:function(a){return this.rotateOnAxis(hk,a)},translateOnAxis:function(a,
c){ek.copy(a).applyQuaternion(this.quaternion);this.position.add(ek.multiplyScalar(c));return this},translateX:function(a){return this.translateOnAxis(fk,a)},translateY:function(a){return this.translateOnAxis(gk,a)},translateZ:function(a){return this.translateOnAxis(hk,a)},localToWorld:function(a){return a.applyMatrix4(this.matrixWorld)},worldToLocal:function(a){return a.applyMatrix4(jd.getInverse(this.matrixWorld))},lookAt:function(a,c,e){a.isVector3?hh.copy(a):hh.set(a,c,e);a=this.parent;this.updateWorldMatrix(!0,
!1);kg.setFromMatrixPosition(this.matrixWorld);this.isCamera||this.isLight?jd.lookAt(kg,hh,this.up):jd.lookAt(hh,kg,this.up);this.quaternion.setFromRotationMatrix(jd);a&&(jd.extractRotation(a.matrixWorld),ff.setFromRotationMatrix(jd),this.quaternion.premultiply(ff.inverse()))},add:function(a){if(1<arguments.length){for(var c=0;c<arguments.length;c++)this.add(arguments[c]);return this}if(a===this)return console.error("THREE.Object3D.add: object can't be added as a child of itself.",a),this;a&&a.isObject3D?
(null!==a.parent&&a.parent.remove(a),a.parent=this,this.children.push(a),a.dispatchEvent(Bm)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",a);return this},remove:function(a){if(1<arguments.length){for(var c=0;c<arguments.length;c++)this.remove(arguments[c]);return this}c=this.children.indexOf(a);-1!==c&&(a.parent=null,this.children.splice(c,1),a.dispatchEvent(Cm));return this},attach:function(a){this.updateWorldMatrix(!0,!1);jd.getInverse(this.matrixWorld);null!==
a.parent&&(a.parent.updateWorldMatrix(!0,!1),jd.multiply(a.parent.matrixWorld));a.applyMatrix(jd);a.updateWorldMatrix(!1,!1);this.add(a);return this},getObjectById:function(a){return this.getObjectByProperty("id",a)},getObjectByName:function(a){return this.getObjectByProperty("name",a)},getObjectByProperty:function(a,c){if(this[a]===c)return this;for(var e=0,g=this.children.length;e<g;e++){var r=this.children[e].getObjectByProperty(a,c);if(void 0!==r)return r}},getWorldPosition:function(a){void 0===
a&&(console.warn("THREE.Object3D: .getWorldPosition() target is now required"),a=new k);this.updateMatrixWorld(!0);return a.setFromMatrixPosition(this.matrixWorld)},getWorldQuaternion:function(a){void 0===a&&(console.warn("THREE.Object3D: .getWorldQuaternion() target is now required"),a=new h);this.updateMatrixWorld(!0);this.matrixWorld.decompose(kg,a,zm);return a},getWorldScale:function(a){void 0===a&&(console.warn("THREE.Object3D: .getWorldScale() target is now required"),a=new k);this.updateMatrixWorld(!0);
this.matrixWorld.decompose(kg,Am,a);return a},getWorldDirection:function(a){void 0===a&&(console.warn("THREE.Object3D: .getWorldDirection() target is now required"),a=new k);this.updateMatrixWorld(!0);var c=this.matrixWorld.elements;return a.set(c[8],c[9],c[10]).normalize()},raycast:function(){},traverse:function(a){a(this);for(var c=this.children,e=0,g=c.length;e<g;e++)c[e].traverse(a)},traverseVisible:function(a){if(!1!==this.visible){a(this);for(var c=this.children,e=0,g=c.length;e<g;e++)c[e].traverseVisible(a)}},
traverseAncestors:function(a){var c=this.parent;null!==c&&(a(c),c.traverseAncestors(a))},updateMatrix:function(){this.matrix.compose(this.position,this.quaternion,this.scale);this.matrixWorldNeedsUpdate=!0},updateMatrixWorld:function(a){this.matrixAutoUpdate&&this.updateMatrix();if(this.matrixWorldNeedsUpdate||a)null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,a=!0;for(var c=this.children,e=
0,g=c.length;e<g;e++)c[e].updateMatrixWorld(a)},updateWorldMatrix:function(a,c){var e=this.parent;!0===a&&null!==e&&e.updateWorldMatrix(!0,!1);this.matrixAutoUpdate&&this.updateMatrix();null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix);if(!0===c)for(a=this.children,c=0,e=a.length;c<e;c++)a[c].updateWorldMatrix(!1,!0)},toJSON:function(a){function c(P,R){void 0===P[R.uuid]&&(P[R.uuid]=R.toJSON(a));return R.uuid}function e(P){var R=
[],S;for(S in P){var V=P[S];delete V.metadata;R.push(V)}return R}var g=void 0===a||"string"===typeof a,r={};g&&(a={geometries:{},materials:{},textures:{},images:{},shapes:{}},r.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});var v={};v.uuid=this.uuid;v.type=this.type;""!==this.name&&(v.name=this.name);!0===this.castShadow&&(v.castShadow=!0);!0===this.receiveShadow&&(v.receiveShadow=!0);!1===this.visible&&(v.visible=!1);!1===this.frustumCulled&&(v.frustumCulled=!1);0!==this.renderOrder&&
(v.renderOrder=this.renderOrder);"{}"!==JSON.stringify(this.userData)&&(v.userData=this.userData);v.layers=this.layers.mask;v.matrix=this.matrix.toArray();!1===this.matrixAutoUpdate&&(v.matrixAutoUpdate=!1);this.isMesh&&0!==this.drawMode&&(v.drawMode=this.drawMode);if(this.isMesh||this.isLine||this.isPoints){v.geometry=c(a.geometries,this.geometry);var z=this.geometry.parameters;if(void 0!==z&&void 0!==z.shapes)if(z=z.shapes,Array.isArray(z))for(var E=0,F=z.length;E<F;E++)c(a.shapes,z[E]);else c(a.shapes,
z)}if(void 0!==this.material)if(Array.isArray(this.material)){z=[];E=0;for(F=this.material.length;E<F;E++)z.push(c(a.materials,this.material[E]));v.material=z}else v.material=c(a.materials,this.material);if(0<this.children.length)for(v.children=[],E=0;E<this.children.length;E++)v.children.push(this.children[E].toJSON(a).object);if(g){g=e(a.geometries);E=e(a.materials);F=e(a.textures);var J=e(a.images);z=e(a.shapes);0<g.length&&(r.geometries=g);0<E.length&&(r.materials=E);0<F.length&&(r.textures=F);
0<J.length&&(r.images=J);0<z.length&&(r.shapes=z)}r.object=v;return r},clone:function(a){return(new this.constructor).copy(this,a)},copy:function(a,c){void 0===c&&(c=!0);this.name=a.name;this.up.copy(a.up);this.position.copy(a.position);this.quaternion.copy(a.quaternion);this.scale.copy(a.scale);this.matrix.copy(a.matrix);this.matrixWorld.copy(a.matrixWorld);this.matrixAutoUpdate=a.matrixAutoUpdate;this.matrixWorldNeedsUpdate=a.matrixWorldNeedsUpdate;this.layers.mask=a.layers.mask;this.visible=a.visible;
this.castShadow=a.castShadow;this.receiveShadow=a.receiveShadow;this.frustumCulled=a.frustumCulled;this.renderOrder=a.renderOrder;this.userData=JSON.parse(JSON.stringify(a.userData));if(!0===c)for(c=0;c<a.children.length;c++)this.add(a.children[c].clone());return this}});y.prototype=Object.assign(Object.create(A.prototype),{constructor:y,isScene:!0,copy:function(a,c){A.prototype.copy.call(this,a,c);null!==a.background&&(this.background=a.background.clone());null!==a.fog&&(this.fog=a.fog.clone());
null!==a.overrideMaterial&&(this.overrideMaterial=a.overrideMaterial.clone());this.autoUpdate=a.autoUpdate;this.matrixAutoUpdate=a.matrixAutoUpdate;return this},toJSON:function(a){var c=A.prototype.toJSON.call(this,a);null!==this.background&&(c.object.background=this.background.toJSON(a));null!==this.fog&&(c.object.fog=this.fog.toJSON());return c},dispose:function(){this.dispatchEvent({type:"dispose"})}});var kd=[new k,new k,new k,new k,new k,new k,new k,new k],Wc=new k,gf=new k,hf=new k,jf=new k,
Fd=new k,Gd=new k,fe=new k,lg=new k,ih=new k,jh=new k,Kd=new k;Object.assign(w.prototype,{isBox3:!0,set:function(a,c){this.min.copy(a);this.max.copy(c);return this},setFromArray:function(a){for(var c=Infinity,e=Infinity,g=Infinity,r=-Infinity,v=-Infinity,z=-Infinity,E=0,F=a.length;E<F;E+=3){var J=a[E],P=a[E+1],R=a[E+2];J<c&&(c=J);P<e&&(e=P);R<g&&(g=R);J>r&&(r=J);P>v&&(v=P);R>z&&(z=R)}this.min.set(c,e,g);this.max.set(r,v,z);return this},setFromBufferAttribute:function(a){for(var c=Infinity,e=Infinity,
g=Infinity,r=-Infinity,v=-Infinity,z=-Infinity,E=0,F=a.count;E<F;E++){var J=a.getX(E),P=a.getY(E),R=a.getZ(E);J<c&&(c=J);P<e&&(e=P);R<g&&(g=R);J>r&&(r=J);P>v&&(v=P);R>z&&(z=R)}this.min.set(c,e,g);this.max.set(r,v,z);return this},setFromPoints:function(a){this.makeEmpty();for(var c=0,e=a.length;c<e;c++)this.expandByPoint(a[c]);return this},setFromCenterAndSize:function(a,c){c=Wc.copy(c).multiplyScalar(.5);this.min.copy(a).sub(c);this.max.copy(a).add(c);return this},setFromObject:function(a){this.makeEmpty();
return this.expandByObject(a)},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.min.copy(a.min);this.max.copy(a.max);return this},makeEmpty:function(){this.min.x=this.min.y=this.min.z=Infinity;this.max.x=this.max.y=this.max.z=-Infinity;return this},isEmpty:function(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z},getCenter:function(a){void 0===a&&(console.warn("THREE.Box3: .getCenter() target is now required"),a=new k);return this.isEmpty()?
a.set(0,0,0):a.addVectors(this.min,this.max).multiplyScalar(.5)},getSize:function(a){void 0===a&&(console.warn("THREE.Box3: .getSize() target is now required"),a=new k);return this.isEmpty()?a.set(0,0,0):a.subVectors(this.max,this.min)},expandByPoint:function(a){this.min.min(a);this.max.max(a);return this},expandByVector:function(a){this.min.sub(a);this.max.add(a);return this},expandByScalar:function(a){this.min.addScalar(-a);this.max.addScalar(a);return this},expandByObject:function(a){var c;a.updateWorldMatrix(!1,
!1);var e=a.geometry;if(void 0!==e)if(e.isGeometry){var g=e.vertices;e=0;for(c=g.length;e<c;e++)Wc.copy(g[e]),Wc.applyMatrix4(a.matrixWorld),this.expandByPoint(Wc)}else if(e.isBufferGeometry&&(g=e.attributes.position,void 0!==g))for(e=0,c=g.count;e<c;e++)Wc.fromBufferAttribute(g,e).applyMatrix4(a.matrixWorld),this.expandByPoint(Wc);a=a.children;e=0;for(c=a.length;e<c;e++)this.expandByObject(a[e]);return this},containsPoint:function(a){return a.x<this.min.x||a.x>this.max.x||a.y<this.min.y||a.y>this.max.y||
a.z<this.min.z||a.z>this.max.z?!1:!0},containsBox:function(a){return this.min.x<=a.min.x&&a.max.x<=this.max.x&&this.min.y<=a.min.y&&a.max.y<=this.max.y&&this.min.z<=a.min.z&&a.max.z<=this.max.z},getParameter:function(a,c){void 0===c&&(console.warn("THREE.Box3: .getParameter() target is now required"),c=new k);return c.set((a.x-this.min.x)/(this.max.x-this.min.x),(a.y-this.min.y)/(this.max.y-this.min.y),(a.z-this.min.z)/(this.max.z-this.min.z))},intersectsBox:function(a){return a.max.x<this.min.x||
a.min.x>this.max.x||a.max.y<this.min.y||a.min.y>this.max.y||a.max.z<this.min.z||a.min.z>this.max.z?!1:!0},intersectsSphere:function(a){this.clampPoint(a.center,Wc);return Wc.distanceToSquared(a.center)<=a.radius*a.radius},intersectsPlane:function(a){if(0<a.normal.x){var c=a.normal.x*this.min.x;var e=a.normal.x*this.max.x}else c=a.normal.x*this.max.x,e=a.normal.x*this.min.x;0<a.normal.y?(c+=a.normal.y*this.min.y,e+=a.normal.y*this.max.y):(c+=a.normal.y*this.max.y,e+=a.normal.y*this.min.y);0<a.normal.z?
(c+=a.normal.z*this.min.z,e+=a.normal.z*this.max.z):(c+=a.normal.z*this.max.z,e+=a.normal.z*this.min.z);return c<=-a.constant&&e>=-a.constant},intersectsTriangle:function(a){if(this.isEmpty())return!1;this.getCenter(lg);ih.subVectors(this.max,lg);gf.subVectors(a.a,lg);hf.subVectors(a.b,lg);jf.subVectors(a.c,lg);Fd.subVectors(hf,gf);Gd.subVectors(jf,hf);fe.subVectors(gf,jf);a=[0,-Fd.z,Fd.y,0,-Gd.z,Gd.y,0,-fe.z,fe.y,Fd.z,0,-Fd.x,Gd.z,0,-Gd.x,fe.z,0,-fe.x,-Fd.y,Fd.x,0,-Gd.y,Gd.x,0,-fe.y,fe.x,0];if(!C(a,
gf,hf,jf,ih))return!1;a=[1,0,0,0,1,0,0,0,1];if(!C(a,gf,hf,jf,ih))return!1;jh.crossVectors(Fd,Gd);a=[jh.x,jh.y,jh.z];return C(a,gf,hf,jf,ih)},clampPoint:function(a,c){void 0===c&&(console.warn("THREE.Box3: .clampPoint() target is now required"),c=new k);return c.copy(a).clamp(this.min,this.max)},distanceToPoint:function(a){return Wc.copy(a).clamp(this.min,this.max).sub(a).length()},getBoundingSphere:function(a){void 0===a&&console.error("THREE.Box3: .getBoundingSphere() target is now required");this.getCenter(a.center);
a.radius=.5*this.getSize(Wc).length();return a},intersect:function(a){this.min.max(a.min);this.max.min(a.max);this.isEmpty()&&this.makeEmpty();return this},union:function(a){this.min.min(a.min);this.max.max(a.max);return this},applyMatrix4:function(a){if(this.isEmpty())return this;kd[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(a);kd[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(a);kd[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(a);kd[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(a);
kd[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(a);kd[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(a);kd[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(a);kd[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(a);this.setFromPoints(kd);return this},translate:function(a){this.min.add(a);this.max.add(a);return this},equals:function(a){return a.min.equals(this.min)&&a.max.equals(this.max)}});var Dm=new w;Object.assign(G.prototype,{set:function(a,c){this.center.copy(a);this.radius=
c;return this},setFromPoints:function(a,c){var e=this.center;void 0!==c?e.copy(c):Dm.setFromPoints(a).getCenter(e);for(var g=c=0,r=a.length;g<r;g++)c=Math.max(c,e.distanceToSquared(a[g]));this.radius=Math.sqrt(c);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.center.copy(a.center);this.radius=a.radius;return this},empty:function(){return 0>=this.radius},containsPoint:function(a){return a.distanceToSquared(this.center)<=this.radius*this.radius},distanceToPoint:function(a){return a.distanceTo(this.center)-
this.radius},intersectsSphere:function(a){var c=this.radius+a.radius;return a.center.distanceToSquared(this.center)<=c*c},intersectsBox:function(a){return a.intersectsSphere(this)},intersectsPlane:function(a){return Math.abs(a.distanceToPoint(this.center))<=this.radius},clampPoint:function(a,c){var e=this.center.distanceToSquared(a);void 0===c&&(console.warn("THREE.Sphere: .clampPoint() target is now required"),c=new k);c.copy(a);e>this.radius*this.radius&&(c.sub(this.center).normalize(),c.multiplyScalar(this.radius).add(this.center));
return c},getBoundingBox:function(a){void 0===a&&(console.warn("THREE.Sphere: .getBoundingBox() target is now required"),a=new w);a.set(this.center,this.center);a.expandByScalar(this.radius);return a},applyMatrix4:function(a){this.center.applyMatrix4(a);this.radius*=a.getMaxScaleOnAxis();return this},translate:function(a){this.center.add(a);return this},equals:function(a){return a.center.equals(this.center)&&a.radius===this.radius}});var ld=new k,yi=new k,kh=new k,Hd=new k,zi=new k,lh=new k,Ai=new k;
Object.assign(D.prototype,{set:function(a,c){this.origin.copy(a);this.direction.copy(c);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.origin.copy(a.origin);this.direction.copy(a.direction);return this},at:function(a,c){void 0===c&&(console.warn("THREE.Ray: .at() target is now required"),c=new k);return c.copy(this.direction).multiplyScalar(a).add(this.origin)},lookAt:function(a){this.direction.copy(a).sub(this.origin).normalize();return this},recast:function(a){this.origin.copy(this.at(a,
ld));return this},closestPointToPoint:function(a,c){void 0===c&&(console.warn("THREE.Ray: .closestPointToPoint() target is now required"),c=new k);c.subVectors(a,this.origin);a=c.dot(this.direction);return 0>a?c.copy(this.origin):c.copy(this.direction).multiplyScalar(a).add(this.origin)},distanceToPoint:function(a){return Math.sqrt(this.distanceSqToPoint(a))},distanceSqToPoint:function(a){var c=ld.subVectors(a,this.origin).dot(this.direction);if(0>c)return this.origin.distanceToSquared(a);ld.copy(this.direction).multiplyScalar(c).add(this.origin);
return ld.distanceToSquared(a)},distanceSqToSegment:function(a,c,e,g){yi.copy(a).add(c).multiplyScalar(.5);kh.copy(c).sub(a).normalize();Hd.copy(this.origin).sub(yi);var r=.5*a.distanceTo(c),v=-this.direction.dot(kh),z=Hd.dot(this.direction),E=-Hd.dot(kh),F=Hd.lengthSq(),J=Math.abs(1-v*v);if(0<J){a=v*E-z;c=v*z-E;var P=r*J;0<=a?c>=-P?c<=P?(r=1/J,a*=r,c*=r,v=a*(a+v*c+2*z)+c*(v*a+c+2*E)+F):(c=r,a=Math.max(0,-(v*c+z)),v=-a*a+c*(c+2*E)+F):(c=-r,a=Math.max(0,-(v*c+z)),v=-a*a+c*(c+2*E)+F):c<=-P?(a=Math.max(0,
-(-v*r+z)),c=0<a?-r:Math.min(Math.max(-r,-E),r),v=-a*a+c*(c+2*E)+F):c<=P?(a=0,c=Math.min(Math.max(-r,-E),r),v=c*(c+2*E)+F):(a=Math.max(0,-(v*r+z)),c=0<a?r:Math.min(Math.max(-r,-E),r),v=-a*a+c*(c+2*E)+F)}else c=0<v?-r:r,a=Math.max(0,-(v*c+z)),v=-a*a+c*(c+2*E)+F;e&&e.copy(this.direction).multiplyScalar(a).add(this.origin);g&&g.copy(kh).multiplyScalar(c).add(yi);return v},intersectSphere:function(a,c){ld.subVectors(a.center,this.origin);var e=ld.dot(this.direction),g=ld.dot(ld)-e*e;a=a.radius*a.radius;
if(g>a)return null;a=Math.sqrt(a-g);g=e-a;e+=a;return 0>g&&0>e?null:0>g?this.at(e,c):this.at(g,c)},intersectsSphere:function(a){return this.distanceSqToPoint(a.center)<=a.radius*a.radius},distanceToPlane:function(a){var c=a.normal.dot(this.direction);if(0===c)return 0===a.distanceToPoint(this.origin)?0:null;a=-(this.origin.dot(a.normal)+a.constant)/c;return 0<=a?a:null},intersectPlane:function(a,c){a=this.distanceToPlane(a);return null===a?null:this.at(a,c)},intersectsPlane:function(a){var c=a.distanceToPoint(this.origin);
return 0===c||0>a.normal.dot(this.direction)*c?!0:!1},intersectBox:function(a,c){var e=1/this.direction.x;var g=1/this.direction.y;var r=1/this.direction.z,v=this.origin;if(0<=e){var z=(a.min.x-v.x)*e;e*=a.max.x-v.x}else z=(a.max.x-v.x)*e,e*=a.min.x-v.x;if(0<=g){var E=(a.min.y-v.y)*g;g*=a.max.y-v.y}else E=(a.max.y-v.y)*g,g*=a.min.y-v.y;if(z>g||E>e)return null;if(E>z||z!==z)z=E;if(g<e||e!==e)e=g;0<=r?(E=(a.min.z-v.z)*r,a=(a.max.z-v.z)*r):(E=(a.max.z-v.z)*r,a=(a.min.z-v.z)*r);if(z>a||E>e)return null;
if(E>z||z!==z)z=E;if(a<e||e!==e)e=a;return 0>e?null:this.at(0<=z?z:e,c)},intersectsBox:function(a){return null!==this.intersectBox(a,ld)},intersectTriangle:function(a,c,e,g,r){zi.subVectors(c,a);lh.subVectors(e,a);Ai.crossVectors(zi,lh);c=this.direction.dot(Ai);if(0<c){if(g)return null;g=1}else if(0>c)g=-1,c=-c;else return null;Hd.subVectors(this.origin,a);a=g*this.direction.dot(lh.crossVectors(Hd,lh));if(0>a)return null;e=g*this.direction.dot(zi.cross(Hd));if(0>e||a+e>c)return null;a=-g*Hd.dot(Ai);
return 0>a?null:this.at(a/c,r)},applyMatrix4:function(a){this.origin.applyMatrix4(a);this.direction.transformDirection(a);return this},equals:function(a){return a.origin.equals(this.origin)&&a.direction.equals(this.direction)}});var Ic=new k,md=new k,Bi=new k,nd=new k,kf=new k,lf=new k,ik=new k,Ci=new k,Di=new k,Ei=new k;Object.assign(B,{getNormal:function(a,c,e,g){void 0===g&&(console.warn("THREE.Triangle: .getNormal() target is now required"),g=new k);g.subVectors(e,c);Ic.subVectors(a,c);g.cross(Ic);
a=g.lengthSq();return 0<a?g.multiplyScalar(1/Math.sqrt(a)):g.set(0,0,0)},getBarycoord:function(a,c,e,g,r){Ic.subVectors(g,c);md.subVectors(e,c);Bi.subVectors(a,c);a=Ic.dot(Ic);c=Ic.dot(md);e=Ic.dot(Bi);var v=md.dot(md);g=md.dot(Bi);var z=a*v-c*c;void 0===r&&(console.warn("THREE.Triangle: .getBarycoord() target is now required"),r=new k);if(0===z)return r.set(-2,-1,-1);z=1/z;v=(v*e-c*g)*z;a=(a*g-c*e)*z;return r.set(1-v-a,a,v)},containsPoint:function(a,c,e,g){B.getBarycoord(a,c,e,g,nd);return 0<=nd.x&&
0<=nd.y&&1>=nd.x+nd.y},getUV:function(a,c,e,g,r,v,z,E){this.getBarycoord(a,c,e,g,nd);E.set(0,0);E.addScaledVector(r,nd.x);E.addScaledVector(v,nd.y);E.addScaledVector(z,nd.z);return E},isFrontFacing:function(a,c,e,g){Ic.subVectors(e,c);md.subVectors(a,c);return 0>Ic.cross(md).dot(g)?!0:!1}});Object.assign(B.prototype,{set:function(a,c,e){this.a.copy(a);this.b.copy(c);this.c.copy(e);return this},setFromPointsAndIndices:function(a,c,e,g){this.a.copy(a[c]);this.b.copy(a[e]);this.c.copy(a[g]);return this},
clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.a.copy(a.a);this.b.copy(a.b);this.c.copy(a.c);return this},getArea:function(){Ic.subVectors(this.c,this.b);md.subVectors(this.a,this.b);return.5*Ic.cross(md).length()},getMidpoint:function(a){void 0===a&&(console.warn("THREE.Triangle: .getMidpoint() target is now required"),a=new k);return a.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)},getNormal:function(a){return B.getNormal(this.a,this.b,this.c,a)},getPlane:function(a){void 0===
a&&(console.warn("THREE.Triangle: .getPlane() target is now required"),a=new k);return a.setFromCoplanarPoints(this.a,this.b,this.c)},getBarycoord:function(a,c){return B.getBarycoord(a,this.a,this.b,this.c,c)},getUV:function(a,c,e,g,r){return B.getUV(a,this.a,this.b,this.c,c,e,g,r)},containsPoint:function(a){return B.containsPoint(a,this.a,this.b,this.c)},isFrontFacing:function(a){return B.isFrontFacing(this.a,this.b,this.c,a)},intersectsBox:function(a){return a.intersectsTriangle(this)},closestPointToPoint:function(a,
c){void 0===c&&(console.warn("THREE.Triangle: .closestPointToPoint() target is now required"),c=new k);var e=this.a,g=this.b,r=this.c;kf.subVectors(g,e);lf.subVectors(r,e);Ci.subVectors(a,e);var v=kf.dot(Ci),z=lf.dot(Ci);if(0>=v&&0>=z)return c.copy(e);Di.subVectors(a,g);var E=kf.dot(Di),F=lf.dot(Di);if(0<=E&&F<=E)return c.copy(g);var J=v*F-E*z;if(0>=J&&0<=v&&0>=E)return g=v/(v-E),c.copy(e).addScaledVector(kf,g);Ei.subVectors(a,r);a=kf.dot(Ei);var P=lf.dot(Ei);if(0<=P&&a<=P)return c.copy(r);v=a*z-
v*P;if(0>=v&&0<=z&&0>=P)return J=z/(z-P),c.copy(e).addScaledVector(lf,J);z=E*P-a*F;if(0>=z&&0<=F-E&&0<=a-P)return ik.subVectors(r,g),J=(F-E)/(F-E+(a-P)),c.copy(g).addScaledVector(ik,J);r=1/(z+v+J);g=v*r;J*=r;return c.copy(e).addScaledVector(kf,g).addScaledVector(lf,J)},equals:function(a){return a.a.equals(this.a)&&a.b.equals(this.b)&&a.c.equals(this.c)}});var Em={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},lc={h:0,
s:0,l:0},mh={h:0,s:0,l:0};Object.assign(I.prototype,{isColor:!0,r:1,g:1,b:1,set:function(a){a&&a.isColor?this.copy(a):"number"===typeof a?this.setHex(a):"string"===typeof a&&this.setStyle(a);return this},setScalar:function(a){this.b=this.g=this.r=a;return this},setHex:function(a){a=Math.floor(a);this.r=(a>>16&255)/255;this.g=(a>>8&255)/255;this.b=(a&255)/255;return this},setRGB:function(a,c,e){this.r=a;this.g=c;this.b=e;return this},setHSL:function(a,c,e){a=hb.euclideanModulo(a,1);c=hb.clamp(c,0,
1);e=hb.clamp(e,0,1);0===c?this.r=this.g=this.b=e:(c=.5>=e?e*(1+c):e+c-e*c,e=2*e-c,this.r=N(e,c,a+1/3),this.g=N(e,c,a),this.b=N(e,c,a-1/3));return this},setStyle:function(a){function c(z){void 0!==z&&1>parseFloat(z)&&console.warn("THREE.Color: Alpha component of "+a+" will be ignored.")}var e;if(e=/^((?:rgb|hsl)a?)\(\s*([^\)]*)\)/.exec(a)){var g=e[2];switch(e[1]){case "rgb":case "rgba":if(e=/^(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(g))return this.r=Math.min(255,parseInt(e[1],
10))/255,this.g=Math.min(255,parseInt(e[2],10))/255,this.b=Math.min(255,parseInt(e[3],10))/255,c(e[5]),this;if(e=/^(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(g))return this.r=Math.min(100,parseInt(e[1],10))/100,this.g=Math.min(100,parseInt(e[2],10))/100,this.b=Math.min(100,parseInt(e[3],10))/100,c(e[5]),this;break;case "hsl":case "hsla":if(e=/^([0-9]*\.?[0-9]+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(g)){g=parseFloat(e[1])/360;var r=parseInt(e[2],
10)/100,v=parseInt(e[3],10)/100;c(e[5]);return this.setHSL(g,r,v)}}}else if(e=/^#([A-Fa-f0-9]+)$/.exec(a)){e=e[1];g=e.length;if(3===g)return this.r=parseInt(e.charAt(0)+e.charAt(0),16)/255,this.g=parseInt(e.charAt(1)+e.charAt(1),16)/255,this.b=parseInt(e.charAt(2)+e.charAt(2),16)/255,this;if(6===g)return this.r=parseInt(e.charAt(0)+e.charAt(1),16)/255,this.g=parseInt(e.charAt(2)+e.charAt(3),16)/255,this.b=parseInt(e.charAt(4)+e.charAt(5),16)/255,this}a&&0<a.length&&(e=Em[a],void 0!==e?this.setHex(e):
console.warn("THREE.Color: Unknown color "+a));return this},clone:function(){return new this.constructor(this.r,this.g,this.b)},copy:function(a){this.r=a.r;this.g=a.g;this.b=a.b;return this},copyGammaToLinear:function(a,c){void 0===c&&(c=2);this.r=Math.pow(a.r,c);this.g=Math.pow(a.g,c);this.b=Math.pow(a.b,c);return this},copyLinearToGamma:function(a,c){void 0===c&&(c=2);c=0<c?1/c:1;this.r=Math.pow(a.r,c);this.g=Math.pow(a.g,c);this.b=Math.pow(a.b,c);return this},convertGammaToLinear:function(a){this.copyGammaToLinear(this,
a);return this},convertLinearToGamma:function(a){this.copyLinearToGamma(this,a);return this},copySRGBToLinear:function(a){this.r=O(a.r);this.g=O(a.g);this.b=O(a.b);return this},copyLinearToSRGB:function(a){this.r=H(a.r);this.g=H(a.g);this.b=H(a.b);return this},convertSRGBToLinear:function(){this.copySRGBToLinear(this);return this},convertLinearToSRGB:function(){this.copyLinearToSRGB(this);return this},getHex:function(){return 255*this.r<<16^255*this.g<<8^255*this.b<<0},getHexString:function(){return("000000"+
this.getHex().toString(16)).slice(-6)},getHSL:function(a){void 0===a&&(console.warn("THREE.Color: .getHSL() target is now required"),a={h:0,s:0,l:0});var c=this.r,e=this.g,g=this.b,r=Math.max(c,e,g),v=Math.min(c,e,g),z,E=(v+r)/2;if(v===r)v=z=0;else{var F=r-v;v=.5>=E?F/(r+v):F/(2-r-v);switch(r){case c:z=(e-g)/F+(e<g?6:0);break;case e:z=(g-c)/F+2;break;case g:z=(c-e)/F+4}z/=6}a.h=z;a.s=v;a.l=E;return a},getStyle:function(){return"rgb("+(255*this.r|0)+","+(255*this.g|0)+","+(255*this.b|0)+")"},offsetHSL:function(a,
c,e){this.getHSL(lc);lc.h+=a;lc.s+=c;lc.l+=e;this.setHSL(lc.h,lc.s,lc.l);return this},add:function(a){this.r+=a.r;this.g+=a.g;this.b+=a.b;return this},addColors:function(a,c){this.r=a.r+c.r;this.g=a.g+c.g;this.b=a.b+c.b;return this},addScalar:function(a){this.r+=a;this.g+=a;this.b+=a;return this},sub:function(a){this.r=Math.max(0,this.r-a.r);this.g=Math.max(0,this.g-a.g);this.b=Math.max(0,this.b-a.b);return this},multiply:function(a){this.r*=a.r;this.g*=a.g;this.b*=a.b;return this},multiplyScalar:function(a){this.r*=
a;this.g*=a;this.b*=a;return this},lerp:function(a,c){this.r+=(a.r-this.r)*c;this.g+=(a.g-this.g)*c;this.b+=(a.b-this.b)*c;return this},lerpHSL:function(a,c){this.getHSL(lc);a.getHSL(mh);a=hb.lerp(lc.h,mh.h,c);var e=hb.lerp(lc.s,mh.s,c);c=hb.lerp(lc.l,mh.l,c);this.setHSL(a,e,c);return this},equals:function(a){return a.r===this.r&&a.g===this.g&&a.b===this.b},fromArray:function(a,c){void 0===c&&(c=0);this.r=a[c];this.g=a[c+1];this.b=a[c+2];return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===
c&&(c=0);a[c]=this.r;a[c+1]=this.g;a[c+2]=this.b;return a},toJSON:function(){return this.getHex()}});Object.assign(K.prototype,{clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.a=a.a;this.b=a.b;this.c=a.c;this.normal.copy(a.normal);this.color.copy(a.color);this.materialIndex=a.materialIndex;for(var c=0,e=a.vertexNormals.length;c<e;c++)this.vertexNormals[c]=a.vertexNormals[c].clone();c=0;for(e=a.vertexColors.length;c<e;c++)this.vertexColors[c]=a.vertexColors[c].clone();
return this}});var Pk=0;M.prototype=Object.assign(Object.create(d.prototype),{constructor:M,isMaterial:!0,onBeforeCompile:function(){},setValues:function(a){if(void 0!==a)for(var c in a){var e=a[c];if(void 0===e)console.warn("THREE.Material: '"+c+"' parameter is undefined.");else if("shading"===c)console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===e?!0:!1;else{var g=this[c];void 0===g?console.warn("THREE."+this.type+": '"+c+"' is not a property of this material."):
g&&g.isColor?g.set(e):g&&g.isVector3&&e&&e.isVector3?g.copy(e):this[c]=e}}},toJSON:function(a){function c(r){var v=[],z;for(z in r){var E=r[z];delete E.metadata;v.push(E)}return v}var e=void 0===a||"string"===typeof a;e&&(a={textures:{},images:{}});var g={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};g.uuid=this.uuid;g.type=this.type;""!==this.name&&(g.name=this.name);this.color&&this.color.isColor&&(g.color=this.color.getHex());void 0!==this.roughness&&(g.roughness=this.roughness);
void 0!==this.metalness&&(g.metalness=this.metalness);this.emissive&&this.emissive.isColor&&(g.emissive=this.emissive.getHex());this.emissiveIntensity&&1!==this.emissiveIntensity&&(g.emissiveIntensity=this.emissiveIntensity);this.specular&&this.specular.isColor&&(g.specular=this.specular.getHex());void 0!==this.shininess&&(g.shininess=this.shininess);void 0!==this.clearcoat&&(g.clearcoat=this.clearcoat);void 0!==this.clearcoatRoughness&&(g.clearcoatRoughness=this.clearcoatRoughness);this.clearcoatNormalMap&&
this.clearcoatNormalMap.isTexture&&(g.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(a).uuid,g.clearcoatNormalScale=this.clearcoatNormalScale.toArray());this.map&&this.map.isTexture&&(g.map=this.map.toJSON(a).uuid);this.matcap&&this.matcap.isTexture&&(g.matcap=this.matcap.toJSON(a).uuid);this.alphaMap&&this.alphaMap.isTexture&&(g.alphaMap=this.alphaMap.toJSON(a).uuid);this.lightMap&&this.lightMap.isTexture&&(g.lightMap=this.lightMap.toJSON(a).uuid);this.aoMap&&this.aoMap.isTexture&&(g.aoMap=this.aoMap.toJSON(a).uuid,
g.aoMapIntensity=this.aoMapIntensity);this.bumpMap&&this.bumpMap.isTexture&&(g.bumpMap=this.bumpMap.toJSON(a).uuid,g.bumpScale=this.bumpScale);this.normalMap&&this.normalMap.isTexture&&(g.normalMap=this.normalMap.toJSON(a).uuid,g.normalMapType=this.normalMapType,g.normalScale=this.normalScale.toArray());this.displacementMap&&this.displacementMap.isTexture&&(g.displacementMap=this.displacementMap.toJSON(a).uuid,g.displacementScale=this.displacementScale,g.displacementBias=this.displacementBias);this.roughnessMap&&
this.roughnessMap.isTexture&&(g.roughnessMap=this.roughnessMap.toJSON(a).uuid);this.metalnessMap&&this.metalnessMap.isTexture&&(g.metalnessMap=this.metalnessMap.toJSON(a).uuid);this.emissiveMap&&this.emissiveMap.isTexture&&(g.emissiveMap=this.emissiveMap.toJSON(a).uuid);this.specularMap&&this.specularMap.isTexture&&(g.specularMap=this.specularMap.toJSON(a).uuid);this.envMap&&this.envMap.isTexture&&(g.envMap=this.envMap.toJSON(a).uuid,g.reflectivity=this.reflectivity,g.refractionRatio=this.refractionRatio,
void 0!==this.combine&&(g.combine=this.combine),void 0!==this.envMapIntensity&&(g.envMapIntensity=this.envMapIntensity));this.gradientMap&&this.gradientMap.isTexture&&(g.gradientMap=this.gradientMap.toJSON(a).uuid);void 0!==this.size&&(g.size=this.size);void 0!==this.sizeAttenuation&&(g.sizeAttenuation=this.sizeAttenuation);1!==this.blending&&(g.blending=this.blending);!0===this.flatShading&&(g.flatShading=this.flatShading);0!==this.side&&(g.side=this.side);0!==this.vertexColors&&(g.vertexColors=
this.vertexColors);1>this.opacity&&(g.opacity=this.opacity);!0===this.transparent&&(g.transparent=this.transparent);g.depthFunc=this.depthFunc;g.depthTest=this.depthTest;g.depthWrite=this.depthWrite;g.stencilWrite=this.stencilWrite;g.stencilFunc=this.stencilFunc;g.stencilRef=this.stencilRef;g.stencilMask=this.stencilMask;g.stencilFail=this.stencilFail;g.stencilZFail=this.stencilZFail;g.stencilZPass=this.stencilZPass;this.rotation&&0!==this.rotation&&(g.rotation=this.rotation);!0===this.polygonOffset&&
(g.polygonOffset=!0);0!==this.polygonOffsetFactor&&(g.polygonOffsetFactor=this.polygonOffsetFactor);0!==this.polygonOffsetUnits&&(g.polygonOffsetUnits=this.polygonOffsetUnits);this.linewidth&&1!==this.linewidth&&(g.linewidth=this.linewidth);void 0!==this.dashSize&&(g.dashSize=this.dashSize);void 0!==this.gapSize&&(g.gapSize=this.gapSize);void 0!==this.scale&&(g.scale=this.scale);!0===this.dithering&&(g.dithering=!0);0<this.alphaTest&&(g.alphaTest=this.alphaTest);!0===this.premultipliedAlpha&&(g.premultipliedAlpha=
this.premultipliedAlpha);!0===this.wireframe&&(g.wireframe=this.wireframe);1<this.wireframeLinewidth&&(g.wireframeLinewidth=this.wireframeLinewidth);"round"!==this.wireframeLinecap&&(g.wireframeLinecap=this.wireframeLinecap);"round"!==this.wireframeLinejoin&&(g.wireframeLinejoin=this.wireframeLinejoin);!0===this.morphTargets&&(g.morphTargets=!0);!0===this.morphNormals&&(g.morphNormals=!0);!0===this.skinning&&(g.skinning=!0);!1===this.visible&&(g.visible=!1);!1===this.toneMapped&&(g.toneMapped=!1);
"{}"!==JSON.stringify(this.userData)&&(g.userData=this.userData);e&&(e=c(a.textures),a=c(a.images),0<e.length&&(g.textures=e),0<a.length&&(g.images=a));return g},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.name=a.name;this.fog=a.fog;this.lights=a.lights;this.blending=a.blending;this.side=a.side;this.flatShading=a.flatShading;this.vertexColors=a.vertexColors;this.opacity=a.opacity;this.transparent=a.transparent;this.blendSrc=a.blendSrc;this.blendDst=a.blendDst;this.blendEquation=
a.blendEquation;this.blendSrcAlpha=a.blendSrcAlpha;this.blendDstAlpha=a.blendDstAlpha;this.blendEquationAlpha=a.blendEquationAlpha;this.depthFunc=a.depthFunc;this.depthTest=a.depthTest;this.depthWrite=a.depthWrite;this.stencilWrite=a.stencilWrite;this.stencilFunc=a.stencilFunc;this.stencilRef=a.stencilRef;this.stencilMask=a.stencilMask;this.stencilFail=a.stencilFail;this.stencilZFail=a.stencilZFail;this.stencilZPass=a.stencilZPass;this.colorWrite=a.colorWrite;this.precision=a.precision;this.polygonOffset=
a.polygonOffset;this.polygonOffsetFactor=a.polygonOffsetFactor;this.polygonOffsetUnits=a.polygonOffsetUnits;this.dithering=a.dithering;this.alphaTest=a.alphaTest;this.premultipliedAlpha=a.premultipliedAlpha;this.visible=a.visible;this.toneMapped=a.toneMapped;this.userData=JSON.parse(JSON.stringify(a.userData));this.clipShadows=a.clipShadows;this.clipIntersection=a.clipIntersection;var c=a.clippingPlanes,e=null;if(null!==c){var g=c.length;e=Array(g);for(var r=0;r!==g;++r)e[r]=c[r].clone()}this.clippingPlanes=
e;this.shadowSide=a.shadowSide;return this},dispose:function(){this.dispatchEvent({type:"dispose"})}});L.prototype=Object.create(M.prototype);L.prototype.constructor=L;L.prototype.isMeshBasicMaterial=!0;L.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);this.map=a.map;this.lightMap=a.lightMap;this.lightMapIntensity=a.lightMapIntensity;this.aoMap=a.aoMap;this.aoMapIntensity=a.aoMapIntensity;this.specularMap=a.specularMap;this.alphaMap=a.alphaMap;this.envMap=a.envMap;
this.combine=a.combine;this.reflectivity=a.reflectivity;this.refractionRatio=a.refractionRatio;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.wireframeLinecap=a.wireframeLinecap;this.wireframeLinejoin=a.wireframeLinejoin;this.skinning=a.skinning;this.morphTargets=a.morphTargets;return this};Object.defineProperty(Q.prototype,"needsUpdate",{set:function(a){!0===a&&this.version++}});Object.assign(Q.prototype,{isBufferAttribute:!0,onUploadCallback:function(){},setArray:function(a){if(Array.isArray(a))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");
this.count=void 0!==a?a.length/this.itemSize:0;this.array=a;return this},setDynamic:function(a){this.dynamic=a;return this},copy:function(a){this.name=a.name;this.array=new a.array.constructor(a.array);this.itemSize=a.itemSize;this.count=a.count;this.normalized=a.normalized;this.dynamic=a.dynamic;return this},copyAt:function(a,c,e){a*=this.itemSize;e*=c.itemSize;for(var g=0,r=this.itemSize;g<r;g++)this.array[a+g]=c.array[e+g];return this},copyArray:function(a){this.array.set(a);return this},copyColorsArray:function(a){for(var c=
this.array,e=0,g=0,r=a.length;g<r;g++){var v=a[g];void 0===v&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",g),v=new I);c[e++]=v.r;c[e++]=v.g;c[e++]=v.b}return this},copyVector2sArray:function(a){for(var c=this.array,e=0,g=0,r=a.length;g<r;g++){var v=a[g];void 0===v&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",g),v=new f);c[e++]=v.x;c[e++]=v.y}return this},copyVector3sArray:function(a){for(var c=this.array,e=0,g=0,r=a.length;g<r;g++){var v=
a[g];void 0===v&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",g),v=new k);c[e++]=v.x;c[e++]=v.y;c[e++]=v.z}return this},copyVector4sArray:function(a){for(var c=this.array,e=0,g=0,r=a.length;g<r;g++){var v=a[g];void 0===v&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",g),v=new p);c[e++]=v.x;c[e++]=v.y;c[e++]=v.z;c[e++]=v.w}return this},set:function(a,c){void 0===c&&(c=0);this.array.set(a,c);return this},getX:function(a){return this.array[a*
this.itemSize]},setX:function(a,c){this.array[a*this.itemSize]=c;return this},getY:function(a){return this.array[a*this.itemSize+1]},setY:function(a,c){this.array[a*this.itemSize+1]=c;return this},getZ:function(a){return this.array[a*this.itemSize+2]},setZ:function(a,c){this.array[a*this.itemSize+2]=c;return this},getW:function(a){return this.array[a*this.itemSize+3]},setW:function(a,c){this.array[a*this.itemSize+3]=c;return this},setXY:function(a,c,e){a*=this.itemSize;this.array[a+0]=c;this.array[a+
1]=e;return this},setXYZ:function(a,c,e,g){a*=this.itemSize;this.array[a+0]=c;this.array[a+1]=e;this.array[a+2]=g;return this},setXYZW:function(a,c,e,g,r){a*=this.itemSize;this.array[a+0]=c;this.array[a+1]=e;this.array[a+2]=g;this.array[a+3]=r;return this},onUpload:function(a){this.onUploadCallback=a;return this},clone:function(){return(new this.constructor(this.array,this.itemSize)).copy(this)},toJSON:function(){return{itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),
normalized:this.normalized}}});T.prototype=Object.create(Q.prototype);T.prototype.constructor=T;X.prototype=Object.create(Q.prototype);X.prototype.constructor=X;aa.prototype=Object.create(Q.prototype);aa.prototype.constructor=aa;la.prototype=Object.create(Q.prototype);la.prototype.constructor=la;Z.prototype=Object.create(Q.prototype);Z.prototype.constructor=Z;ba.prototype=Object.create(Q.prototype);ba.prototype.constructor=ba;ea.prototype=Object.create(Q.prototype);ea.prototype.constructor=ea;ca.prototype=
Object.create(Q.prototype);ca.prototype.constructor=ca;ka.prototype=Object.create(Q.prototype);ka.prototype.constructor=ka;Object.assign(Y.prototype,{computeGroups:function(a){var c=[],e=void 0;a=a.faces;for(var g=0;g<a.length;g++){var r=a[g];if(r.materialIndex!==e){e=r.materialIndex;void 0!==v&&(v.count=3*g-v.start,c.push(v));var v={start:3*g,materialIndex:e}}}void 0!==v&&(v.count=3*g-v.start,c.push(v));this.groups=c},fromGeometry:function(a){var c=a.faces,e=a.vertices,g=a.faceVertexUvs,r=g[0]&&
0<g[0].length,v=g[1]&&0<g[1].length,z=a.morphTargets,E=z.length;if(0<E){var F=[];for(var J=0;J<E;J++)F[J]={name:z[J].name,data:[]};this.morphTargets.position=F}var P=a.morphNormals,R=P.length;if(0<R){var S=[];for(J=0;J<R;J++)S[J]={name:P[J].name,data:[]};this.morphTargets.normal=S}var V=a.skinIndices,W=a.skinWeights,ha=V.length===e.length,fa=W.length===e.length;0<e.length&&0===c.length&&console.error("THREE.DirectGeometry: Faceless geometries are not supported.");for(J=0;J<c.length;J++){var ra=c[J];
this.vertices.push(e[ra.a],e[ra.b],e[ra.c]);var pa=ra.vertexNormals;3===pa.length?this.normals.push(pa[0],pa[1],pa[2]):(pa=ra.normal,this.normals.push(pa,pa,pa));pa=ra.vertexColors;3===pa.length?this.colors.push(pa[0],pa[1],pa[2]):(pa=ra.color,this.colors.push(pa,pa,pa));!0===r&&(pa=g[0][J],void 0!==pa?this.uvs.push(pa[0],pa[1],pa[2]):(console.warn("THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ",J),this.uvs.push(new f,new f,new f)));!0===v&&(pa=g[1][J],void 0!==pa?this.uvs2.push(pa[0],
pa[1],pa[2]):(console.warn("THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ",J),this.uvs2.push(new f,new f,new f)));for(pa=0;pa<E;pa++){var qa=z[pa].vertices;F[pa].data.push(qa[ra.a],qa[ra.b],qa[ra.c])}for(pa=0;pa<R;pa++)qa=P[pa].vertexNormals[J],S[pa].data.push(qa.a,qa.b,qa.c);ha&&this.skinIndices.push(V[ra.a],V[ra.b],V[ra.c]);fa&&this.skinWeights.push(W[ra.a],W[ra.b],W[ra.c])}this.computeGroups(a);this.verticesNeedUpdate=a.verticesNeedUpdate;this.normalsNeedUpdate=a.normalsNeedUpdate;
this.colorsNeedUpdate=a.colorsNeedUpdate;this.uvsNeedUpdate=a.uvsNeedUpdate;this.groupsNeedUpdate=a.groupsNeedUpdate;null!==a.boundingSphere&&(this.boundingSphere=a.boundingSphere.clone());null!==a.boundingBox&&(this.boundingBox=a.boundingBox.clone());return this}});var Qk=1,Xc=new q,Fi=new A,nh=new k,ge=new w,Gi=new w,Jc=new k;va.prototype=Object.assign(Object.create(d.prototype),{constructor:va,isBufferGeometry:!0,getIndex:function(){return this.index},setIndex:function(a){this.index=Array.isArray(a)?
new (65535<Ea(a)?ea:Z)(a,1):a},addAttribute:function(a,c,e){if(!(c&&c.isBufferAttribute||c&&c.isInterleavedBufferAttribute))return console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.addAttribute(a,new Q(c,e));if("index"===a)return console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(c),this;this.attributes[a]=c;return this},getAttribute:function(a){return this.attributes[a]},removeAttribute:function(a){delete this.attributes[a];
return this},addGroup:function(a,c,e){this.groups.push({start:a,count:c,materialIndex:void 0!==e?e:0})},clearGroups:function(){this.groups=[]},setDrawRange:function(a,c){this.drawRange.start=a;this.drawRange.count=c},applyMatrix:function(a){var c=this.attributes.position;void 0!==c&&(a.applyToBufferAttribute(c),c.needsUpdate=!0);var e=this.attributes.normal;void 0!==e&&(c=(new t).getNormalMatrix(a),c.applyToBufferAttribute(e),e.needsUpdate=!0);e=this.attributes.tangent;void 0!==e&&(c=(new t).getNormalMatrix(a),
c.applyToBufferAttribute(e),e.needsUpdate=!0);null!==this.boundingBox&&this.computeBoundingBox();null!==this.boundingSphere&&this.computeBoundingSphere();return this},rotateX:function(a){Xc.makeRotationX(a);this.applyMatrix(Xc);return this},rotateY:function(a){Xc.makeRotationY(a);this.applyMatrix(Xc);return this},rotateZ:function(a){Xc.makeRotationZ(a);this.applyMatrix(Xc);return this},translate:function(a,c,e){Xc.makeTranslation(a,c,e);this.applyMatrix(Xc);return this},scale:function(a,c,e){Xc.makeScale(a,
c,e);this.applyMatrix(Xc);return this},lookAt:function(a){Fi.lookAt(a);Fi.updateMatrix();this.applyMatrix(Fi.matrix);return this},center:function(){this.computeBoundingBox();this.boundingBox.getCenter(nh).negate();this.translate(nh.x,nh.y,nh.z);return this},setFromObject:function(a){var c=a.geometry;if(a.isPoints||a.isLine){a=new ca(3*c.vertices.length,3);var e=new ca(3*c.colors.length,3);this.addAttribute("position",a.copyVector3sArray(c.vertices));this.addAttribute("color",e.copyColorsArray(c.colors));
c.lineDistances&&c.lineDistances.length===c.vertices.length&&(a=new ca(c.lineDistances.length,1),this.addAttribute("lineDistance",a.copyArray(c.lineDistances)));null!==c.boundingSphere&&(this.boundingSphere=c.boundingSphere.clone());null!==c.boundingBox&&(this.boundingBox=c.boundingBox.clone())}else a.isMesh&&c&&c.isGeometry&&this.fromGeometry(c);return this},setFromPoints:function(a){for(var c=[],e=0,g=a.length;e<g;e++){var r=a[e];c.push(r.x,r.y,r.z||0)}this.addAttribute("position",new ca(c,3));
return this},updateFromObject:function(a){var c=a.geometry;if(a.isMesh){var e=c.__directGeometry;!0===c.elementsNeedUpdate&&(e=void 0,c.elementsNeedUpdate=!1);if(void 0===e)return this.fromGeometry(c);e.verticesNeedUpdate=c.verticesNeedUpdate;e.normalsNeedUpdate=c.normalsNeedUpdate;e.colorsNeedUpdate=c.colorsNeedUpdate;e.uvsNeedUpdate=c.uvsNeedUpdate;e.groupsNeedUpdate=c.groupsNeedUpdate;c.verticesNeedUpdate=!1;c.normalsNeedUpdate=!1;c.colorsNeedUpdate=!1;c.uvsNeedUpdate=!1;c.groupsNeedUpdate=!1;
c=e}!0===c.verticesNeedUpdate&&(e=this.attributes.position,void 0!==e&&(e.copyVector3sArray(c.vertices),e.needsUpdate=!0),c.verticesNeedUpdate=!1);!0===c.normalsNeedUpdate&&(e=this.attributes.normal,void 0!==e&&(e.copyVector3sArray(c.normals),e.needsUpdate=!0),c.normalsNeedUpdate=!1);!0===c.colorsNeedUpdate&&(e=this.attributes.color,void 0!==e&&(e.copyColorsArray(c.colors),e.needsUpdate=!0),c.colorsNeedUpdate=!1);c.uvsNeedUpdate&&(e=this.attributes.uv,void 0!==e&&(e.copyVector2sArray(c.uvs),e.needsUpdate=
!0),c.uvsNeedUpdate=!1);c.lineDistancesNeedUpdate&&(e=this.attributes.lineDistance,void 0!==e&&(e.copyArray(c.lineDistances),e.needsUpdate=!0),c.lineDistancesNeedUpdate=!1);c.groupsNeedUpdate&&(c.computeGroups(a.geometry),this.groups=c.groups,c.groupsNeedUpdate=!1);return this},fromGeometry:function(a){a.__directGeometry=(new Y).fromGeometry(a);return this.fromDirectGeometry(a.__directGeometry)},fromDirectGeometry:function(a){this.addAttribute("position",(new Q(new Float32Array(3*a.vertices.length),
3)).copyVector3sArray(a.vertices));0<a.normals.length&&this.addAttribute("normal",(new Q(new Float32Array(3*a.normals.length),3)).copyVector3sArray(a.normals));0<a.colors.length&&this.addAttribute("color",(new Q(new Float32Array(3*a.colors.length),3)).copyColorsArray(a.colors));0<a.uvs.length&&this.addAttribute("uv",(new Q(new Float32Array(2*a.uvs.length),2)).copyVector2sArray(a.uvs));0<a.uvs2.length&&this.addAttribute("uv2",(new Q(new Float32Array(2*a.uvs2.length),2)).copyVector2sArray(a.uvs2));
this.groups=a.groups;for(var c in a.morphTargets){for(var e=[],g=a.morphTargets[c],r=0,v=g.length;r<v;r++){var z=g[r],E=new ca(3*z.data.length,3);E.name=z.name;e.push(E.copyVector3sArray(z.data))}this.morphAttributes[c]=e}0<a.skinIndices.length&&(c=new ca(4*a.skinIndices.length,4),this.addAttribute("skinIndex",c.copyVector4sArray(a.skinIndices)));0<a.skinWeights.length&&(c=new ca(4*a.skinWeights.length,4),this.addAttribute("skinWeight",c.copyVector4sArray(a.skinWeights)));null!==a.boundingSphere&&
(this.boundingSphere=a.boundingSphere.clone());null!==a.boundingBox&&(this.boundingBox=a.boundingBox.clone());return this},computeBoundingBox:function(){null===this.boundingBox&&(this.boundingBox=new w);var a=this.attributes.position,c=this.morphAttributes.position;if(void 0!==a){if(this.boundingBox.setFromBufferAttribute(a),c){a=0;for(var e=c.length;a<e;a++)ge.setFromBufferAttribute(c[a]),this.boundingBox.expandByPoint(ge.min),this.boundingBox.expandByPoint(ge.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:function(){null===this.boundingSphere&&(this.boundingSphere=new G);var a=this.attributes.position,c=this.morphAttributes.position;if(a){var e=this.boundingSphere.center;ge.setFromBufferAttribute(a);if(c)for(var g=0,r=c.length;g<r;g++){var v=
c[g];Gi.setFromBufferAttribute(v);ge.expandByPoint(Gi.min);ge.expandByPoint(Gi.max)}ge.getCenter(e);var z=0;g=0;for(r=a.count;g<r;g++)Jc.fromBufferAttribute(a,g),z=Math.max(z,e.distanceToSquared(Jc));if(c)for(g=0,r=c.length;g<r;g++){v=c[g];a=0;for(var E=v.count;a<E;a++)Jc.fromBufferAttribute(v,a),z=Math.max(z,e.distanceToSquared(Jc))}this.boundingSphere.radius=Math.sqrt(z);isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',
this)}},computeFaceNormals:function(){},computeVertexNormals:function(){var a=this.index,c=this.attributes;if(c.position){var e=c.position.array;if(void 0===c.normal)this.addAttribute("normal",new Q(new Float32Array(e.length),3));else for(var g=c.normal.array,r=0,v=g.length;r<v;r++)g[r]=0;g=c.normal.array;var z=new k,E=new k,F=new k,J=new k,P=new k;if(a){var R=a.array;r=0;for(v=a.count;r<v;r+=3){a=3*R[r+0];var S=3*R[r+1];var V=3*R[r+2];z.fromArray(e,a);E.fromArray(e,S);F.fromArray(e,V);J.subVectors(F,
E);P.subVectors(z,E);J.cross(P);g[a]+=J.x;g[a+1]+=J.y;g[a+2]+=J.z;g[S]+=J.x;g[S+1]+=J.y;g[S+2]+=J.z;g[V]+=J.x;g[V+1]+=J.y;g[V+2]+=J.z}}else for(r=0,v=e.length;r<v;r+=9)z.fromArray(e,r),E.fromArray(e,r+3),F.fromArray(e,r+6),J.subVectors(F,E),P.subVectors(z,E),J.cross(P),g[r]=J.x,g[r+1]=J.y,g[r+2]=J.z,g[r+3]=J.x,g[r+4]=J.y,g[r+5]=J.z,g[r+6]=J.x,g[r+7]=J.y,g[r+8]=J.z;this.normalizeNormals();c.normal.needsUpdate=!0}},merge:function(a,c){if(a&&a.isBufferGeometry){void 0===c&&(c=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset\x3d0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));
var e=this.attributes,g;for(g in e)if(void 0!==a.attributes[g]){var r=e[g].array,v=a.attributes[g],z=v.array,E=v.itemSize*c;v=Math.min(z.length,r.length-E);for(var F=0;F<v;F++,E++)r[E]=z[F]}return this}console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",a)},normalizeNormals:function(){for(var a=this.attributes.normal,c=0,e=a.count;c<e;c++)Jc.x=a.getX(c),Jc.y=a.getY(c),Jc.z=a.getZ(c),Jc.normalize(),a.setXYZ(c,Jc.x,Jc.y,Jc.z)},toNonIndexed:function(){function a(P,
R){var S=P.array;P=P.itemSize;for(var V=new S.constructor(R.length*P),W,ha=0,fa=0,ra=R.length;fa<ra;fa++){W=R[fa]*P;for(var pa=0;pa<P;pa++)V[ha++]=S[W++]}return new Q(V,P)}if(null===this.index)return console.warn("THREE.BufferGeometry.toNonIndexed(): Geometry is already non-indexed."),this;var c=new va,e=this.index.array,g=this.attributes,r;for(r in g){var v=g[r];v=a(v,e);c.addAttribute(r,v)}var z=this.morphAttributes;for(r in z){var E=[],F=z[r];g=0;for(var J=F.length;g<J;g++)v=F[g],v=a(v,e),E.push(v);
c.morphAttributes[r]=E}e=this.groups;g=0;for(r=e.length;g<r;g++)v=e[g],c.addGroup(v.start,v.count,v.materialIndex);return c},toJSON:function(){var a={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};a.uuid=this.uuid;a.type=this.type;""!==this.name&&(a.name=this.name);0<Object.keys(this.userData).length&&(a.userData=this.userData);if(void 0!==this.parameters){var c=this.parameters;for(J in c)void 0!==c[J]&&(a[J]=c[J]);return a}a.data={attributes:{}};c=this.index;null!==
c&&(a.data.index={type:c.array.constructor.name,array:Array.prototype.slice.call(c.array)});var e=this.attributes;for(J in e){c=e[J];var g=c.toJSON();""!==c.name&&(g.name=c.name);a.data.attributes[J]=g}e={};var r=!1;for(J in this.morphAttributes){for(var v=this.morphAttributes[J],z=[],E=0,F=v.length;E<F;E++)c=v[E],g=c.toJSON(),""!==c.name&&(g.name=c.name),z.push(g);0<z.length&&(e[J]=z,r=!0)}r&&(a.data.morphAttributes=e);var J=this.groups;0<J.length&&(a.data.groups=JSON.parse(JSON.stringify(J)));J=
this.boundingSphere;null!==J&&(a.data.boundingSphere={center:J.center.toArray(),radius:J.radius});return a},clone:function(){return(new va).copy(this)},copy:function(a){var c;this.index=null;this.attributes={};this.morphAttributes={};this.groups=[];this.boundingSphere=this.boundingBox=null;this.name=a.name;var e=a.index;null!==e&&this.setIndex(e.clone());e=a.attributes;for(z in e)this.addAttribute(z,e[z].clone());var g=a.morphAttributes;for(z in g){var r=[],v=g[z];e=0;for(c=v.length;e<c;e++)r.push(v[e].clone());
this.morphAttributes[z]=r}var z=a.groups;e=0;for(c=z.length;e<c;e++)g=z[e],this.addGroup(g.start,g.count,g.materialIndex);z=a.boundingBox;null!==z&&(this.boundingBox=z.clone());z=a.boundingSphere;null!==z&&(this.boundingSphere=z.clone());this.drawRange.start=a.drawRange.start;this.drawRange.count=a.drawRange.count;this.userData=a.userData;return this},dispose:function(){this.dispatchEvent({type:"dispose"})}});var jk=new q,he=new D,Hi=new G,Ld=new k,Md=new k,Nd=new k,$i=new k,aj=new k,bj=new k,Ih=
new k,Jh=new k,Kh=new k,oe=new f,pe=new f,qe=new f,sf=new k,sg=new k;xa.prototype=Object.assign(Object.create(A.prototype),{constructor:xa,isMesh:!0,setDrawMode:function(a){this.drawMode=a},copy:function(a){A.prototype.copy.call(this,a);this.drawMode=a.drawMode;void 0!==a.morphTargetInfluences&&(this.morphTargetInfluences=a.morphTargetInfluences.slice());void 0!==a.morphTargetDictionary&&(this.morphTargetDictionary=Object.assign({},a.morphTargetDictionary));return this},updateMorphTargets:function(){var a=
this.geometry;if(a.isBufferGeometry){a=a.morphAttributes;var c=Object.keys(a);if(0<c.length){var e=a[c[0]];if(void 0!==e)for(this.morphTargetInfluences=[],this.morphTargetDictionary={},a=0,c=e.length;a<c;a++){var g=e[a].name||String(a);this.morphTargetInfluences.push(0);this.morphTargetDictionary[g]=a}}}else a=a.morphTargets,void 0!==a&&0<a.length&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")},raycast:function(a,c){var e=this.geometry,
g=this.material,r=this.matrixWorld;if(void 0!==g&&(null===e.boundingSphere&&e.computeBoundingSphere(),Hi.copy(e.boundingSphere),Hi.applyMatrix4(r),!1!==a.ray.intersectsSphere(Hi)&&(jk.getInverse(r),he.copy(a.ray).applyMatrix4(jk),null===e.boundingBox||!1!==he.intersectsBox(e.boundingBox))))if(e.isBufferGeometry){var v=e.index;r=e.attributes.position;var z=e.morphAttributes.position,E=e.attributes.uv,F=e.attributes.uv2,J=e.groups,P=e.drawRange,R,S;if(null!==v)if(Array.isArray(g)){var V=0;for(R=J.length;V<
R;V++){var W=J[V];var ha=g[W.materialIndex];var fa=Math.max(W.start,P.start);for(S=e=Math.min(W.start+W.count,P.start+P.count);fa<S;fa+=3){e=v.getX(fa);var ra=v.getX(fa+1);var pa=v.getX(fa+2);if(e=Fa(this,ha,a,he,r,z,E,F,e,ra,pa))e.faceIndex=Math.floor(fa/3),e.face.materialIndex=W.materialIndex,c.push(e)}}}else for(fa=Math.max(0,P.start),e=Math.min(v.count,P.start+P.count),V=fa,R=e;V<R;V+=3){if(e=v.getX(V),ra=v.getX(V+1),pa=v.getX(V+2),e=Fa(this,g,a,he,r,z,E,F,e,ra,pa))e.faceIndex=Math.floor(V/3),
c.push(e)}else if(void 0!==r)if(Array.isArray(g))for(V=0,R=J.length;V<R;V++)for(W=J[V],ha=g[W.materialIndex],fa=Math.max(W.start,P.start),S=e=Math.min(W.start+W.count,P.start+P.count);fa<S;fa+=3){if(e=fa,ra=fa+1,pa=fa+2,e=Fa(this,ha,a,he,r,z,E,F,e,ra,pa))e.faceIndex=Math.floor(fa/3),e.face.materialIndex=W.materialIndex,c.push(e)}else for(fa=Math.max(0,P.start),e=Math.min(r.count,P.start+P.count),V=fa,R=e;V<R;V+=3)if(e=V,ra=V+1,pa=V+2,e=Fa(this,g,a,he,r,z,E,F,e,ra,pa))e.faceIndex=Math.floor(V/3),c.push(e)}else if(e.isGeometry)for(r=
Array.isArray(g),z=e.vertices,E=e.faces,e=e.faceVertexUvs[0],0<e.length&&(v=e),V=0,R=E.length;V<R;V++)if(W=E[V],e=r?g[W.materialIndex]:g,void 0!==e&&(F=z[W.a],J=z[W.b],P=z[W.c],e=Aa(this,e,a,he,F,J,P,sf)))v&&v[V]&&(ha=v[V],oe.copy(ha[0]),pe.copy(ha[1]),qe.copy(ha[2]),e.uv=B.getUV(sf,F,J,P,oe,pe,qe,new f)),e.face=W,e.faceIndex=V,c.push(e)},clone:function(){return(new this.constructor(this.geometry,this.material)).copy(this)}});var Rk=0,Yc=new q,Ii=new A,oh=new k;ya.prototype=Object.assign(Object.create(d.prototype),
{constructor:ya,isGeometry:!0,applyMatrix:function(a){for(var c=(new t).getNormalMatrix(a),e=0,g=this.vertices.length;e<g;e++)this.vertices[e].applyMatrix4(a);e=0;for(g=this.faces.length;e<g;e++){a=this.faces[e];a.normal.applyMatrix3(c).normalize();for(var r=0,v=a.vertexNormals.length;r<v;r++)a.vertexNormals[r].applyMatrix3(c).normalize()}null!==this.boundingBox&&this.computeBoundingBox();null!==this.boundingSphere&&this.computeBoundingSphere();this.normalsNeedUpdate=this.verticesNeedUpdate=!0;return this},
rotateX:function(a){Yc.makeRotationX(a);this.applyMatrix(Yc);return this},rotateY:function(a){Yc.makeRotationY(a);this.applyMatrix(Yc);return this},rotateZ:function(a){Yc.makeRotationZ(a);this.applyMatrix(Yc);return this},translate:function(a,c,e){Yc.makeTranslation(a,c,e);this.applyMatrix(Yc);return this},scale:function(a,c,e){Yc.makeScale(a,c,e);this.applyMatrix(Yc);return this},lookAt:function(a){Ii.lookAt(a);Ii.updateMatrix();this.applyMatrix(Ii.matrix);return this},fromBufferGeometry:function(a){function c(V,
W,ha,fa){var ra=void 0===E?[]:[e.colors[V].clone(),e.colors[W].clone(),e.colors[ha].clone()],pa=void 0===z?[]:[(new k).fromArray(z,3*V),(new k).fromArray(z,3*W),(new k).fromArray(z,3*ha)];fa=new K(V,W,ha,pa,ra,fa);e.faces.push(fa);void 0!==F&&e.faceVertexUvs[0].push([(new f).fromArray(F,2*V),(new f).fromArray(F,2*W),(new f).fromArray(F,2*ha)]);void 0!==J&&e.faceVertexUvs[1].push([(new f).fromArray(J,2*V),(new f).fromArray(J,2*W),(new f).fromArray(J,2*ha)])}var e=this,g=null!==a.index?a.index.array:
void 0,r=a.attributes,v=r.position.array,z=void 0!==r.normal?r.normal.array:void 0,E=void 0!==r.color?r.color.array:void 0,F=void 0!==r.uv?r.uv.array:void 0,J=void 0!==r.uv2?r.uv2.array:void 0;void 0!==J&&(this.faceVertexUvs[1]=[]);for(r=0;r<v.length;r+=3)e.vertices.push((new k).fromArray(v,r)),void 0!==E&&e.colors.push((new I).fromArray(E,r));var P=a.groups;if(0<P.length)for(r=0;r<P.length;r++){v=P[r];var R=v.start,S=R;for(R+=v.count;S<R;S+=3)void 0!==g?c(g[S],g[S+1],g[S+2],v.materialIndex):c(S,
S+1,S+2,v.materialIndex)}else if(void 0!==g)for(r=0;r<g.length;r+=3)c(g[r],g[r+1],g[r+2]);else for(r=0;r<v.length/3;r+=3)c(r,r+1,r+2);this.computeFaceNormals();null!==a.boundingBox&&(this.boundingBox=a.boundingBox.clone());null!==a.boundingSphere&&(this.boundingSphere=a.boundingSphere.clone());return this},center:function(){this.computeBoundingBox();this.boundingBox.getCenter(oh).negate();this.translate(oh.x,oh.y,oh.z);return this},normalize:function(){this.computeBoundingSphere();var a=this.boundingSphere.center,
c=this.boundingSphere.radius;c=0===c?1:1/c;var e=new q;e.set(c,0,0,-c*a.x,0,c,0,-c*a.y,0,0,c,-c*a.z,0,0,0,1);this.applyMatrix(e);return this},computeFaceNormals:function(){for(var a=new k,c=new k,e=0,g=this.faces.length;e<g;e++){var r=this.faces[e],v=this.vertices[r.a],z=this.vertices[r.b];a.subVectors(this.vertices[r.c],z);c.subVectors(v,z);a.cross(c);a.normalize();r.normal.copy(a)}},computeVertexNormals:function(a){void 0===a&&(a=!0);var c;var e=Array(this.vertices.length);var g=0;for(c=this.vertices.length;g<
c;g++)e[g]=new k;if(a){var r=new k,v=new k;a=0;for(g=this.faces.length;a<g;a++){c=this.faces[a];var z=this.vertices[c.a];var E=this.vertices[c.b];var F=this.vertices[c.c];r.subVectors(F,E);v.subVectors(z,E);r.cross(v);e[c.a].add(r);e[c.b].add(r);e[c.c].add(r)}}else for(this.computeFaceNormals(),a=0,g=this.faces.length;a<g;a++)c=this.faces[a],e[c.a].add(c.normal),e[c.b].add(c.normal),e[c.c].add(c.normal);g=0;for(c=this.vertices.length;g<c;g++)e[g].normalize();a=0;for(g=this.faces.length;a<g;a++)c=
this.faces[a],z=c.vertexNormals,3===z.length?(z[0].copy(e[c.a]),z[1].copy(e[c.b]),z[2].copy(e[c.c])):(z[0]=e[c.a].clone(),z[1]=e[c.b].clone(),z[2]=e[c.c].clone());0<this.faces.length&&(this.normalsNeedUpdate=!0)},computeFlatVertexNormals:function(){var a;this.computeFaceNormals();var c=0;for(a=this.faces.length;c<a;c++){var e=this.faces[c];var g=e.vertexNormals;3===g.length?(g[0].copy(e.normal),g[1].copy(e.normal),g[2].copy(e.normal)):(g[0]=e.normal.clone(),g[1]=e.normal.clone(),g[2]=e.normal.clone())}0<
this.faces.length&&(this.normalsNeedUpdate=!0)},computeMorphNormals:function(){var a,c;var e=0;for(c=this.faces.length;e<c;e++){var g=this.faces[e];g.__originalFaceNormal?g.__originalFaceNormal.copy(g.normal):g.__originalFaceNormal=g.normal.clone();g.__originalVertexNormals||(g.__originalVertexNormals=[]);var r=0;for(a=g.vertexNormals.length;r<a;r++)g.__originalVertexNormals[r]?g.__originalVertexNormals[r].copy(g.vertexNormals[r]):g.__originalVertexNormals[r]=g.vertexNormals[r].clone()}var v=new ya;
v.faces=this.faces;r=0;for(a=this.morphTargets.length;r<a;r++){if(!this.morphNormals[r]){this.morphNormals[r]={};this.morphNormals[r].faceNormals=[];this.morphNormals[r].vertexNormals=[];g=this.morphNormals[r].faceNormals;var z=this.morphNormals[r].vertexNormals;e=0;for(c=this.faces.length;e<c;e++){var E=new k;var F={a:new k,b:new k,c:new k};g.push(E);z.push(F)}}z=this.morphNormals[r];v.vertices=this.morphTargets[r].vertices;v.computeFaceNormals();v.computeVertexNormals();e=0;for(c=this.faces.length;e<
c;e++)g=this.faces[e],E=z.faceNormals[e],F=z.vertexNormals[e],E.copy(g.normal),F.a.copy(g.vertexNormals[0]),F.b.copy(g.vertexNormals[1]),F.c.copy(g.vertexNormals[2])}e=0;for(c=this.faces.length;e<c;e++)g=this.faces[e],g.normal=g.__originalFaceNormal,g.vertexNormals=g.__originalVertexNormals},computeBoundingBox:function(){null===this.boundingBox&&(this.boundingBox=new w);this.boundingBox.setFromPoints(this.vertices)},computeBoundingSphere:function(){null===this.boundingSphere&&(this.boundingSphere=
new G);this.boundingSphere.setFromPoints(this.vertices)},merge:function(a,c,e){if(a&&a.isGeometry){var g,r=this.vertices.length,v=this.vertices,z=a.vertices,E=this.faces,F=a.faces,J=this.colors,P=a.colors;void 0===e&&(e=0);void 0!==c&&(g=(new t).getNormalMatrix(c));for(var R=0,S=z.length;R<S;R++){var V=z[R].clone();void 0!==c&&V.applyMatrix4(c);v.push(V)}R=0;for(S=P.length;R<S;R++)J.push(P[R].clone());R=0;for(S=F.length;R<S;R++){z=F[R];var W=z.vertexNormals;P=z.vertexColors;J=new K(z.a+r,z.b+r,z.c+
r);J.normal.copy(z.normal);void 0!==g&&J.normal.applyMatrix3(g).normalize();c=0;for(v=W.length;c<v;c++)V=W[c].clone(),void 0!==g&&V.applyMatrix3(g).normalize(),J.vertexNormals.push(V);J.color.copy(z.color);c=0;for(v=P.length;c<v;c++)V=P[c],J.vertexColors.push(V.clone());J.materialIndex=z.materialIndex+e;E.push(J)}R=0;for(S=a.faceVertexUvs.length;R<S;R++)for(e=a.faceVertexUvs[R],void 0===this.faceVertexUvs[R]&&(this.faceVertexUvs[R]=[]),c=0,v=e.length;c<v;c++){g=e[c];r=[];E=0;for(F=g.length;E<F;E++)r.push(g[E].clone());
this.faceVertexUvs[R].push(r)}}else console.error("THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.",a)},mergeMesh:function(a){a&&a.isMesh?(a.matrixAutoUpdate&&a.updateMatrix(),this.merge(a.geometry,a.matrix)):console.error("THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.",a)},mergeVertices:function(){var a={},c=[],e=[],g=Math.pow(10,4),r;var v=0;for(r=this.vertices.length;v<r;v++){var z=this.vertices[v];z=Math.round(z.x*g)+"_"+Math.round(z.y*g)+"_"+Math.round(z.z*
g);void 0===a[z]?(a[z]=v,c.push(this.vertices[v]),e[v]=c.length-1):e[v]=e[a[z]]}a=[];v=0;for(r=this.faces.length;v<r;v++)for(g=this.faces[v],g.a=e[g.a],g.b=e[g.b],g.c=e[g.c],g=[g.a,g.b,g.c],z=0;3>z;z++)if(g[z]===g[(z+1)%3]){a.push(v);break}for(v=a.length-1;0<=v;v--)for(g=a[v],this.faces.splice(g,1),e=0,r=this.faceVertexUvs.length;e<r;e++)this.faceVertexUvs[e].splice(g,1);v=this.vertices.length-c.length;this.vertices=c;return v},setFromPoints:function(a){this.vertices=[];for(var c=0,e=a.length;c<e;c++){var g=
a[c];this.vertices.push(new k(g.x,g.y,g.z||0))}return this},sortFacesByMaterialIndex:function(){for(var a=this.faces,c=a.length,e=0;e<c;e++)a[e]._id=e;a.sort(function(F,J){return F.materialIndex-J.materialIndex});var g=this.faceVertexUvs[0],r=this.faceVertexUvs[1],v,z;g&&g.length===c&&(v=[]);r&&r.length===c&&(z=[]);for(e=0;e<c;e++){var E=a[e]._id;v&&v.push(g[E]);z&&z.push(r[E])}v&&(this.faceVertexUvs[0]=v);z&&(this.faceVertexUvs[1]=z)},toJSON:function(){function a(oa,ta,Ba){return Ba?oa|1<<ta:oa&
~(1<<ta)}function c(oa){var ta=oa.x.toString()+oa.y.toString()+oa.z.toString();if(void 0!==J[ta])return J[ta];J[ta]=F.length/3;F.push(oa.x,oa.y,oa.z);return J[ta]}function e(oa){var ta=oa.r.toString()+oa.g.toString()+oa.b.toString();if(void 0!==R[ta])return R[ta];R[ta]=P.length;P.push(oa.getHex());return R[ta]}function g(oa){var ta=oa.x.toString()+oa.y.toString();if(void 0!==V[ta])return V[ta];V[ta]=S.length/2;S.push(oa.x,oa.y);return V[ta]}var r={metadata:{version:4.5,type:"Geometry",generator:"Geometry.toJSON"}};
r.uuid=this.uuid;r.type=this.type;""!==this.name&&(r.name=this.name);if(void 0!==this.parameters){var v=this.parameters,z;for(z in v)void 0!==v[z]&&(r[z]=v[z]);return r}v=[];for(z=0;z<this.vertices.length;z++){var E=this.vertices[z];v.push(E.x,E.y,E.z)}E=[];var F=[],J={},P=[],R={},S=[],V={};for(z=0;z<this.faces.length;z++){var W=this.faces[z],ha=void 0!==this.faceVertexUvs[0][z],fa=0<W.normal.length(),ra=0<W.vertexNormals.length,pa=1!==W.color.r||1!==W.color.g||1!==W.color.b,qa=0<W.vertexColors.length,
ua=0;ua=a(ua,0,0);ua=a(ua,1,!0);ua=a(ua,2,!1);ua=a(ua,3,ha);ua=a(ua,4,fa);ua=a(ua,5,ra);ua=a(ua,6,pa);ua=a(ua,7,qa);E.push(ua);E.push(W.a,W.b,W.c);E.push(W.materialIndex);ha&&(ha=this.faceVertexUvs[0][z],E.push(g(ha[0]),g(ha[1]),g(ha[2])));fa&&E.push(c(W.normal));ra&&(fa=W.vertexNormals,E.push(c(fa[0]),c(fa[1]),c(fa[2])));pa&&E.push(e(W.color));qa&&(W=W.vertexColors,E.push(e(W[0]),e(W[1]),e(W[2])))}r.data={};r.data.vertices=v;r.data.normals=F;0<P.length&&(r.data.colors=P);0<S.length&&(r.data.uvs=
[S]);r.data.faces=E;return r},clone:function(){return(new ya).copy(this)},copy:function(a){var c,e,g;this.vertices=[];this.colors=[];this.faces=[];this.faceVertexUvs=[[]];this.morphTargets=[];this.morphNormals=[];this.skinWeights=[];this.skinIndices=[];this.lineDistances=[];this.boundingSphere=this.boundingBox=null;this.name=a.name;var r=a.vertices;var v=0;for(c=r.length;v<c;v++)this.vertices.push(r[v].clone());r=a.colors;v=0;for(c=r.length;v<c;v++)this.colors.push(r[v].clone());r=a.faces;v=0;for(c=
r.length;v<c;v++)this.faces.push(r[v].clone());v=0;for(c=a.faceVertexUvs.length;v<c;v++){var z=a.faceVertexUvs[v];void 0===this.faceVertexUvs[v]&&(this.faceVertexUvs[v]=[]);r=0;for(e=z.length;r<e;r++){var E=z[r],F=[];var J=0;for(g=E.length;J<g;J++)F.push(E[J].clone());this.faceVertexUvs[v].push(F)}}J=a.morphTargets;v=0;for(c=J.length;v<c;v++){g={};g.name=J[v].name;if(void 0!==J[v].vertices)for(g.vertices=[],r=0,e=J[v].vertices.length;r<e;r++)g.vertices.push(J[v].vertices[r].clone());if(void 0!==J[v].normals)for(g.normals=
[],r=0,e=J[v].normals.length;r<e;r++)g.normals.push(J[v].normals[r].clone());this.morphTargets.push(g)}J=a.morphNormals;v=0;for(c=J.length;v<c;v++){g={};if(void 0!==J[v].vertexNormals)for(g.vertexNormals=[],r=0,e=J[v].vertexNormals.length;r<e;r++)z=J[v].vertexNormals[r],E={},E.a=z.a.clone(),E.b=z.b.clone(),E.c=z.c.clone(),g.vertexNormals.push(E);if(void 0!==J[v].faceNormals)for(g.faceNormals=[],r=0,e=J[v].faceNormals.length;r<e;r++)g.faceNormals.push(J[v].faceNormals[r].clone());this.morphNormals.push(g)}r=
a.skinWeights;v=0;for(c=r.length;v<c;v++)this.skinWeights.push(r[v].clone());r=a.skinIndices;v=0;for(c=r.length;v<c;v++)this.skinIndices.push(r[v].clone());r=a.lineDistances;v=0;for(c=r.length;v<c;v++)this.lineDistances.push(r[v]);v=a.boundingBox;null!==v&&(this.boundingBox=v.clone());v=a.boundingSphere;null!==v&&(this.boundingSphere=v.clone());this.elementsNeedUpdate=a.elementsNeedUpdate;this.verticesNeedUpdate=a.verticesNeedUpdate;this.uvsNeedUpdate=a.uvsNeedUpdate;this.normalsNeedUpdate=a.normalsNeedUpdate;
this.colorsNeedUpdate=a.colorsNeedUpdate;this.lineDistancesNeedUpdate=a.lineDistancesNeedUpdate;this.groupsNeedUpdate=a.groupsNeedUpdate;return this},dispose:function(){this.dispatchEvent({type:"dispose"})}});Sa.prototype=Object.create(ya.prototype);Sa.prototype.constructor=Sa;Xa.prototype=Object.create(va.prototype);Xa.prototype.constructor=Xa;var Fm={clone:ub,merge:Bb};qb.prototype=Object.create(M.prototype);qb.prototype.constructor=qb;qb.prototype.isShaderMaterial=!0;qb.prototype.copy=function(a){M.prototype.copy.call(this,
a);this.fragmentShader=a.fragmentShader;this.vertexShader=a.vertexShader;this.uniforms=ub(a.uniforms);this.defines=Object.assign({},a.defines);this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.lights=a.lights;this.clipping=a.clipping;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;this.extensions=a.extensions;return this};qb.prototype.toJSON=function(a){var c=M.prototype.toJSON.call(this,a);c.uniforms={};for(var e in this.uniforms){var g=
this.uniforms[e].value;c.uniforms[e]=g&&g.isTexture?{type:"t",value:g.toJSON(a).uuid}:g&&g.isColor?{type:"c",value:g.getHex()}:g&&g.isVector2?{type:"v2",value:g.toArray()}:g&&g.isVector3?{type:"v3",value:g.toArray()}:g&&g.isVector4?{type:"v4",value:g.toArray()}:g&&g.isMatrix3?{type:"m3",value:g.toArray()}:g&&g.isMatrix4?{type:"m4",value:g.toArray()}:{value:g}}0<Object.keys(this.defines).length&&(c.defines=this.defines);c.vertexShader=this.vertexShader;c.fragmentShader=this.fragmentShader;a={};for(var r in this.extensions)!0===
this.extensions[r]&&(a[r]=!0);0<Object.keys(a).length&&(c.extensions=a);return c};zb.prototype=Object.assign(Object.create(A.prototype),{constructor:zb,isCamera:!0,copy:function(a,c){A.prototype.copy.call(this,a,c);this.matrixWorldInverse.copy(a.matrixWorldInverse);this.projectionMatrix.copy(a.projectionMatrix);this.projectionMatrixInverse.copy(a.projectionMatrixInverse);return this},getWorldDirection:function(a){void 0===a&&(console.warn("THREE.Camera: .getWorldDirection() target is now required"),
a=new k);this.updateMatrixWorld(!0);var c=this.matrixWorld.elements;return a.set(-c[8],-c[9],-c[10]).normalize()},updateMatrixWorld:function(a){A.prototype.updateMatrixWorld.call(this,a);this.matrixWorldInverse.getInverse(this.matrixWorld)},clone:function(){return(new this.constructor).copy(this)}});vb.prototype=Object.assign(Object.create(zb.prototype),{constructor:vb,isPerspectiveCamera:!0,copy:function(a,c){zb.prototype.copy.call(this,a,c);this.fov=a.fov;this.zoom=a.zoom;this.near=a.near;this.far=
a.far;this.focus=a.focus;this.aspect=a.aspect;this.view=null===a.view?null:Object.assign({},a.view);this.filmGauge=a.filmGauge;this.filmOffset=a.filmOffset;return this},setFocalLength:function(a){this.fov=2*hb.RAD2DEG*Math.atan(.5*this.getFilmHeight()/a);this.updateProjectionMatrix()},getFocalLength:function(){return.5*this.getFilmHeight()/Math.tan(.5*hb.DEG2RAD*this.fov)},getEffectiveFOV:function(){return 2*hb.RAD2DEG*Math.atan(Math.tan(.5*hb.DEG2RAD*this.fov)/this.zoom)},getFilmWidth:function(){return this.filmGauge*
Math.min(this.aspect,1)},getFilmHeight:function(){return this.filmGauge/Math.max(this.aspect,1)},setViewOffset:function(a,c,e,g,r,v){this.aspect=a/c;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=a;this.view.fullHeight=c;this.view.offsetX=e;this.view.offsetY=g;this.view.width=r;this.view.height=v;this.updateProjectionMatrix()},clearViewOffset:function(){null!==this.view&&(this.view.enabled=!1);this.updateProjectionMatrix()},
updateProjectionMatrix:function(){var a=this.near,c=a*Math.tan(.5*hb.DEG2RAD*this.fov)/this.zoom,e=2*c,g=this.aspect*e,r=-.5*g,v=this.view;if(null!==this.view&&this.view.enabled){var z=v.fullWidth,E=v.fullHeight;r+=v.offsetX*g/z;c-=v.offsetY*e/E;g*=v.width/z;e*=v.height/E}v=this.filmOffset;0!==v&&(r+=a*v/this.getFilmWidth());this.projectionMatrix.makePerspective(r,r+g,c,c-e,a,this.far);this.projectionMatrixInverse.getInverse(this.projectionMatrix)},toJSON:function(a){a=A.prototype.toJSON.call(this,
a);a.object.fov=this.fov;a.object.zoom=this.zoom;a.object.near=this.near;a.object.far=this.far;a.object.focus=this.focus;a.object.aspect=this.aspect;null!==this.view&&(a.object.view=Object.assign({},this.view));a.object.filmGauge=this.filmGauge;a.object.filmOffset=this.filmOffset;return a}});Gb.prototype=Object.create(A.prototype);Gb.prototype.constructor=Gb;Nb.prototype=Object.create(m.prototype);Nb.prototype.constructor=Nb;Nb.prototype.isWebGLRenderTargetCube=!0;Nb.prototype.fromEquirectangularTexture=
function(a,c){this.texture.type=c.type;this.texture.format=c.format;this.texture.encoding=c.encoding;var e=new y,g=new qb({type:"CubemapFromEquirect",uniforms:ub({tEquirect:{value:null}}),vertexShader:"varying vec3 vWorldDirection;\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvoid main() {\n\tvWorldDirection \x3d transformDirection( position, modelMatrix );\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n}",
fragmentShader:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#define RECIPROCAL_PI 0.31830988618\n#define RECIPROCAL_PI2 0.15915494\nvoid main() {\n\tvec3 direction \x3d normalize( vWorldDirection );\n\tvec2 sampleUV;\n\tsampleUV.y \x3d asin( clamp( direction.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\tsampleUV.x \x3d atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;\n\tgl_FragColor \x3d texture2D( tEquirect, sampleUV );\n}",side:1,blending:0});g.uniforms.tEquirect.value=c;
c=new xa(new Xa(5,5,5),g);e.add(c);g=new Gb(1,10,1);g.renderTarget=this;g.renderTarget.texture.name="CubeCameraTexture";g.update(a,e);c.geometry.dispose();c.material.dispose();return this};Ab.prototype=Object.create(l.prototype);Ab.prototype.constructor=Ab;Ab.prototype.isDataTexture=!0;var Ji=new k,Gm=new k,Hm=new t;Object.assign(Hb.prototype,{isPlane:!0,set:function(a,c){this.normal.copy(a);this.constant=c;return this},setComponents:function(a,c,e,g){this.normal.set(a,c,e);this.constant=g;return this},
setFromNormalAndCoplanarPoint:function(a,c){this.normal.copy(a);this.constant=-c.dot(this.normal);return this},setFromCoplanarPoints:function(a,c,e){c=Ji.subVectors(e,c).cross(Gm.subVectors(a,c)).normalize();this.setFromNormalAndCoplanarPoint(c,a);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.normal.copy(a.normal);this.constant=a.constant;return this},normalize:function(){var a=1/this.normal.length();this.normal.multiplyScalar(a);this.constant*=a;return this},
negate:function(){this.constant*=-1;this.normal.negate();return this},distanceToPoint:function(a){return this.normal.dot(a)+this.constant},distanceToSphere:function(a){return this.distanceToPoint(a.center)-a.radius},projectPoint:function(a,c){void 0===c&&(console.warn("THREE.Plane: .projectPoint() target is now required"),c=new k);return c.copy(this.normal).multiplyScalar(-this.distanceToPoint(a)).add(a)},intersectLine:function(a,c){void 0===c&&(console.warn("THREE.Plane: .intersectLine() target is now required"),
c=new k);var e=a.delta(Ji),g=this.normal.dot(e);if(0===g){if(0===this.distanceToPoint(a.start))return c.copy(a.start)}else if(g=-(a.start.dot(this.normal)+this.constant)/g,!(0>g||1<g))return c.copy(e).multiplyScalar(g).add(a.start)},intersectsLine:function(a){var c=this.distanceToPoint(a.start);a=this.distanceToPoint(a.end);return 0>c&&0<a||0>a&&0<c},intersectsBox:function(a){return a.intersectsPlane(this)},intersectsSphere:function(a){return a.intersectsPlane(this)},coplanarPoint:function(a){void 0===
a&&(console.warn("THREE.Plane: .coplanarPoint() target is now required"),a=new k);return a.copy(this.normal).multiplyScalar(-this.constant)},applyMatrix4:function(a,c){c=c||Hm.getNormalMatrix(a);a=this.coplanarPoint(Ji).applyMatrix4(a);c=this.normal.applyMatrix3(c).normalize();this.constant=-a.dot(c);return this},translate:function(a){this.constant-=a.dot(this.normal);return this},equals:function(a){return a.normal.equals(this.normal)&&a.constant===this.constant}});var mf=new G,ph=new k;Object.assign(ic.prototype,
{set:function(a,c,e,g,r,v){var z=this.planes;z[0].copy(a);z[1].copy(c);z[2].copy(e);z[3].copy(g);z[4].copy(r);z[5].copy(v);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){for(var c=this.planes,e=0;6>e;e++)c[e].copy(a.planes[e]);return this},setFromMatrix:function(a){var c=this.planes,e=a.elements;a=e[0];var g=e[1],r=e[2],v=e[3],z=e[4],E=e[5],F=e[6],J=e[7],P=e[8],R=e[9],S=e[10],V=e[11],W=e[12],ha=e[13],fa=e[14];e=e[15];c[0].setComponents(v-a,J-z,V-P,e-W).normalize();
c[1].setComponents(v+a,J+z,V+P,e+W).normalize();c[2].setComponents(v+g,J+E,V+R,e+ha).normalize();c[3].setComponents(v-g,J-E,V-R,e-ha).normalize();c[4].setComponents(v-r,J-F,V-S,e-fa).normalize();c[5].setComponents(v+r,J+F,V+S,e+fa).normalize();return this},intersectsObject:function(a){var c=a.geometry;null===c.boundingSphere&&c.computeBoundingSphere();mf.copy(c.boundingSphere).applyMatrix4(a.matrixWorld);return this.intersectsSphere(mf)},intersectsSprite:function(a){mf.center.set(0,0,0);mf.radius=
.7071067811865476;mf.applyMatrix4(a.matrixWorld);return this.intersectsSphere(mf)},intersectsSphere:function(a){var c=this.planes,e=a.center;a=-a.radius;for(var g=0;6>g;g++)if(c[g].distanceToPoint(e)<a)return!1;return!0},intersectsBox:function(a){for(var c=this.planes,e=0;6>e;e++){var g=c[e];ph.x=0<g.normal.x?a.max.x:a.min.x;ph.y=0<g.normal.y?a.max.y:a.min.y;ph.z=0<g.normal.z?a.max.z:a.min.z;if(0>g.distanceToPoint(ph))return!1}return!0},containsPoint:function(a){for(var c=this.planes,e=0;6>e;e++)if(0>
c[e].distanceToPoint(a))return!1;return!0}});var rb={alphamap_fragment:"#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *\x3d texture2D( alphaMap, vUv ).g;\n#endif",alphamap_pars_fragment:"#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",alphatest_fragment:"#ifdef ALPHATEST\n\tif ( diffuseColor.a \x3c ALPHATEST ) discard;\n#endif",aomap_fragment:"#ifdef USE_AOMAP\n\tfloat ambientOcclusion \x3d ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *\x3d ambientOcclusion;\n\t#if defined( USE_ENVMAP ) \x26\x26 defined( STANDARD )\n\t\tfloat dotNV \x3d saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *\x3d computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\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 \x3d vec3( position );",beginnormal_vertex:"vec3 objectNormal \x3d vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent \x3d vec3( tangent.xyz );\n#endif",bsdfs:"vec2 integrateSpecularBRDF( const in float dotNV, const in float roughness ) {\n\tconst vec4 c0 \x3d vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 \x3d vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r \x3d roughness * c0 + c1;\n\tfloat a004 \x3d min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\treturn vec2( -1.04, 1.04 ) * a004 + r.zw;\n}\nfloat punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n\tfloat distanceFalloff \x3d 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\tif( cutoffDistance \x3e 0.0 ) {\n\t\tdistanceFalloff *\x3d pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t}\n\treturn distanceFalloff;\n#else\n\tif( cutoffDistance \x3e 0.0 \x26\x26 decayExponent \x3e 0.0 ) {\n\t\treturn pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t}\n\treturn 1.0;\n#endif\n}\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\n\tfloat fresnel \x3d exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\n\treturn ( 1.0 - specularColor ) * fresnel + specularColor;\n}\nvec3 F_Schlick_RoughnessDependent( const in vec3 F0, const in float dotNV, const in float roughness ) {\n\tfloat fresnel \x3d exp2( ( -5.55473 * dotNV - 6.98316 ) * dotNV );\n\tvec3 Fr \x3d max( vec3( 1.0 - roughness ), F0 ) - F0;\n\treturn Fr * fresnel + F0;\n}\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 \x3d pow2( alpha );\n\tfloat gl \x3d dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\tfloat gv \x3d dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\treturn 1.0 / ( gl * gv );\n}\nfloat G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 \x3d pow2( alpha );\n\tfloat gv \x3d dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl \x3d 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 \x3d pow2( alpha );\n\tfloat denom \x3d pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat alpha \x3d pow2( roughness );\n\tvec3 halfDir \x3d normalize( incidentLight.direction + viewDir );\n\tfloat dotNL \x3d saturate( dot( normal, incidentLight.direction ) );\n\tfloat dotNV \x3d saturate( dot( normal, viewDir ) );\n\tfloat dotNH \x3d saturate( dot( normal, halfDir ) );\n\tfloat dotLH \x3d saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F \x3d F_Schlick( specularColor, dotLH );\n\tfloat G \x3d G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D \x3d D_GGX( alpha, dotNH );\n\treturn F * ( G * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE  \x3d 64.0;\n\tconst float LUT_SCALE \x3d ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS  \x3d 0.5 / LUT_SIZE;\n\tfloat dotNV \x3d saturate( dot( N, V ) );\n\tvec2 uv \x3d vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv \x3d uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l \x3d 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 \x3d dot( v1, v2 );\n\tfloat y \x3d abs( x );\n\tfloat a \x3d 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b \x3d 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v \x3d a / b;\n\tfloat theta_sintheta \x3d ( x \x3e 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 \x3d rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 \x3d rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal \x3d cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) \x3c 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 \x3d normalize( V - N * dot( V, N ) );\n\tT2 \x3d - cross( N, T1 );\n\tmat3 mat \x3d mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] \x3d mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] \x3d mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] \x3d mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] \x3d mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] \x3d normalize( coords[ 0 ] );\n\tcoords[ 1 ] \x3d normalize( coords[ 1 ] );\n\tcoords[ 2 ] \x3d normalize( coords[ 2 ] );\n\tcoords[ 3 ] \x3d normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor \x3d vec3( 0.0 );\n\tvectorFormFactor +\x3d LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor +\x3d LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor +\x3d LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor +\x3d LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result \x3d LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\nvec3 BRDF_Specular_GGX_Environment( const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat dotNV \x3d saturate( dot( normal, viewDir ) );\n\tvec2 brdf \x3d integrateSpecularBRDF( dotNV, roughness );\n\treturn specularColor * brdf.x + brdf.y;\n}\nvoid BRDF_Specular_Multiscattering_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n\tfloat dotNV \x3d saturate( dot( geometry.normal, geometry.viewDir ) );\n\tvec3 F \x3d F_Schlick_RoughnessDependent( specularColor, dotNV, roughness );\n\tvec2 brdf \x3d integrateSpecularBRDF( dotNV, roughness );\n\tvec3 FssEss \x3d F * brdf.x + brdf.y;\n\tfloat Ess \x3d brdf.x + brdf.y;\n\tfloat Ems \x3d 1.0 - Ess;\n\tvec3 Favg \x3d specularColor + ( 1.0 - specularColor ) * 0.047619;\tvec3 Fms \x3d FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter +\x3d FssEss;\n\tmultiScatter +\x3d Fms * Ems;\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_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir \x3d normalize( incidentLight.direction + geometry.viewDir );\n\tfloat dotNH \x3d saturate( dot( geometry.normal, halfDir ) );\n\tfloat dotLH \x3d saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F \x3d F_Schlick( specularColor, dotLH );\n\tfloat G \x3d G_BlinnPhong_Implicit( );\n\tfloat D \x3d D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n}\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\n\treturn ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );\n}\nfloat BlinnExponentToGGXRoughness( const in float blinnExponent ) {\n\treturn sqrt( 2.0 / ( blinnExponent + 2.0 ) );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie(float roughness, float NoH) {\n\tfloat invAlpha  \x3d 1.0 / roughness;\n\tfloat cos2h \x3d NoH * NoH;\n\tfloat sin2h \x3d max(1.0 - cos2h, 0.0078125);\treturn (2.0 + invAlpha) * pow(sin2h, invAlpha * 0.5) / (2.0 * PI);\n}\nfloat V_Neubelt(float NoV, float NoL) {\n\treturn saturate(1.0 / (4.0 * (NoL + NoV - NoL * NoV)));\n}\nvec3 BRDF_Specular_Sheen( const in float roughness, const in vec3 L, const in GeometricContext geometry, vec3 specularColor ) {\n\tvec3 N \x3d geometry.normal;\n\tvec3 V \x3d geometry.viewDir;\n\tvec3 H \x3d normalize( V + L );\n\tfloat dotNH \x3d saturate( dot( N, H ) );\n\treturn specularColor * D_Charlie( roughness, dotNH ) * V_Neubelt( dot(N, V), dot(N, L) );\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 \x3d dFdx( vUv );\n\t\tvec2 dSTdy \x3d dFdy( vUv );\n\t\tfloat Hll \x3d bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx \x3d bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy \x3d 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 ) {\n\t\tvec3 vSigmaX \x3d vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY \x3d vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\tvec3 vN \x3d surf_norm;\n\t\tvec3 R1 \x3d cross( vSigmaY, vN );\n\t\tvec3 R2 \x3d cross( vN, vSigmaX );\n\t\tfloat fDet \x3d dot( vSigmaX, R1 );\n\t\tfDet *\x3d ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\tvec3 vGrad \x3d 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 \x3e 0\n\tvec4 plane;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane \x3d clippingPlanes[ i ];\n\t\tif ( dot( vViewPosition, plane.xyz ) \x3e plane.w ) discard;\n\t}\n\t#if UNION_CLIPPING_PLANES \x3c NUM_CLIPPING_PLANES\n\t\tbool clipped \x3d true;\n\t\t#pragma unroll_loop\n\t\tfor ( int i \x3d UNION_CLIPPING_PLANES; i \x3c NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane \x3d clippingPlanes[ i ];\n\t\t\tclipped \x3d ( dot( vViewPosition, plane.xyz ) \x3e plane.w ) \x26\x26 clipped;\n\t\t}\n\t\tif ( clipped ) discard;\n\t#endif\n#endif",
clipping_planes_pars_fragment:"#if NUM_CLIPPING_PLANES \x3e 0\n\t#if ! defined( STANDARD ) \x26\x26 ! defined( PHONG ) \x26\x26 ! defined( MATCAP )\n\t\tvarying vec3 vViewPosition;\n\t#endif\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif",clipping_planes_pars_vertex:"#if NUM_CLIPPING_PLANES \x3e 0 \x26\x26 ! defined( STANDARD ) \x26\x26 ! defined( PHONG ) \x26\x26 ! defined( MATCAP )\n\tvarying vec3 vViewPosition;\n#endif",clipping_planes_vertex:"#if NUM_CLIPPING_PLANES \x3e 0 \x26\x26 ! defined( STANDARD ) \x26\x26 ! defined( PHONG ) \x26\x26 ! defined( MATCAP )\n\tvViewPosition \x3d - mvPosition.xyz;\n#endif",
color_fragment:"#ifdef USE_COLOR\n\tdiffuseColor.rgb *\x3d vColor;\n#endif",color_pars_fragment:"#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif",color_pars_vertex:"#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif",color_vertex:"#ifdef USE_COLOR\n\tvColor.xyz \x3d color.xyz;\n#endif",common:"#define PI 3.14159265359\n#define PI2 6.28318530718\n#define PI_HALF 1.5707963267949\n#define RECIPROCAL_PI 0.31830988618\n#define RECIPROCAL_PI2 0.15915494\n#define LOG2 1.442695\n#define EPSILON 1e-6\n#define saturate(a) clamp( a, 0.0, 1.0 )\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 \x3d x*x; return x2*x2; }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a \x3d 12.9898, b \x3d 78.233, c \x3d 43758.5453;\n\thighp float dt \x3d dot( uv.xy, vec2( a,b ) ), sn \x3d 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 max3( vec3 v ) { return max( max( v.x, v.y ), v.z ); }\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent \x3d 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 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}\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\tfloat distance \x3d dot( planeNormal, point - pointOnPlane );\n\treturn - distance * planeNormal + point;\n}\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn sign( dot( point - pointOnPlane, planeNormal ) );\n}\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] \x3d vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] \x3d vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] \x3d vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat linearToRelativeLuminance( const in vec3 color ) {\n\tvec3 weights \x3d vec3( 0.2126, 0.7152, 0.0722 );\n\treturn dot( weights, color.rgb );\n}",
cube_uv_reflection_fragment:"#ifdef ENVMAP_TYPE_CUBE_UV\n#define cubeUV_textureSize (1024.0)\nint getFaceFromDirection(vec3 direction) {\n\tvec3 absDirection \x3d abs(direction);\n\tint face \x3d -1;\n\tif( absDirection.x \x3e absDirection.z ) {\n\t\tif(absDirection.x \x3e absDirection.y )\n\t\t\tface \x3d direction.x \x3e 0.0 ? 0 : 3;\n\t\telse\n\t\t\tface \x3d direction.y \x3e 0.0 ? 1 : 4;\n\t}\n\telse {\n\t\tif(absDirection.z \x3e absDirection.y )\n\t\t\tface \x3d direction.z \x3e 0.0 ? 2 : 5;\n\t\telse\n\t\t\tface \x3d direction.y \x3e 0.0 ? 1 : 4;\n\t}\n\treturn face;\n}\n#define cubeUV_maxLods1  (log2(cubeUV_textureSize*0.25) - 1.0)\n#define cubeUV_rangeClamp (exp2((6.0 - 1.0) * 2.0))\nvec2 MipLevelInfo( vec3 vec, float roughnessLevel, float roughness ) {\n\tfloat scale \x3d exp2(cubeUV_maxLods1 - roughnessLevel);\n\tfloat dxRoughness \x3d dFdx(roughness);\n\tfloat dyRoughness \x3d dFdy(roughness);\n\tvec3 dx \x3d dFdx( vec * scale * dxRoughness );\n\tvec3 dy \x3d dFdy( vec * scale * dyRoughness );\n\tfloat d \x3d max( dot( dx, dx ), dot( dy, dy ) );\n\td \x3d clamp(d, 1.0, cubeUV_rangeClamp);\n\tfloat mipLevel \x3d 0.5 * log2(d);\n\treturn vec2(floor(mipLevel), fract(mipLevel));\n}\n#define cubeUV_maxLods2 (log2(cubeUV_textureSize*0.25) - 2.0)\n#define cubeUV_rcpTextureSize (1.0 / cubeUV_textureSize)\nvec2 getCubeUV(vec3 direction, float roughnessLevel, float mipLevel) {\n\tmipLevel \x3d roughnessLevel \x3e cubeUV_maxLods2 - 3.0 ? 0.0 : mipLevel;\n\tfloat a \x3d 16.0 * cubeUV_rcpTextureSize;\n\tvec2 exp2_packed \x3d exp2( vec2( roughnessLevel, mipLevel ) );\n\tvec2 rcp_exp2_packed \x3d vec2( 1.0 ) / exp2_packed;\n\tfloat powScale \x3d exp2_packed.x * exp2_packed.y;\n\tfloat scale \x3d rcp_exp2_packed.x * rcp_exp2_packed.y * 0.25;\n\tfloat mipOffset \x3d 0.75*(1.0 - rcp_exp2_packed.y) * rcp_exp2_packed.x;\n\tbool bRes \x3d mipLevel \x3d\x3d 0.0;\n\tscale \x3d  bRes \x26\x26 (scale \x3c a) ? a : scale;\n\tvec3 r;\n\tvec2 offset;\n\tint face \x3d getFaceFromDirection(direction);\n\tfloat rcpPowScale \x3d 1.0 / powScale;\n\tif( face \x3d\x3d 0) {\n\t\tr \x3d vec3(direction.x, -direction.z, direction.y);\n\t\toffset \x3d vec2(0.0+mipOffset,0.75 * rcpPowScale);\n\t\toffset.y \x3d bRes \x26\x26 (offset.y \x3c 2.0*a) ? a : offset.y;\n\t}\n\telse if( face \x3d\x3d 1) {\n\t\tr \x3d vec3(direction.y, direction.x, direction.z);\n\t\toffset \x3d vec2(scale+mipOffset, 0.75 * rcpPowScale);\n\t\toffset.y \x3d bRes \x26\x26 (offset.y \x3c 2.0*a) ? a : offset.y;\n\t}\n\telse if( face \x3d\x3d 2) {\n\t\tr \x3d vec3(direction.z, direction.x, direction.y);\n\t\toffset \x3d vec2(2.0*scale+mipOffset, 0.75 * rcpPowScale);\n\t\toffset.y \x3d bRes \x26\x26 (offset.y \x3c 2.0*a) ? a : offset.y;\n\t}\n\telse if( face \x3d\x3d 3) {\n\t\tr \x3d vec3(direction.x, direction.z, direction.y);\n\t\toffset \x3d vec2(0.0+mipOffset,0.5 * rcpPowScale);\n\t\toffset.y \x3d bRes \x26\x26 (offset.y \x3c 2.0*a) ? 0.0 : offset.y;\n\t}\n\telse if( face \x3d\x3d 4) {\n\t\tr \x3d vec3(direction.y, direction.x, -direction.z);\n\t\toffset \x3d vec2(scale+mipOffset, 0.5 * rcpPowScale);\n\t\toffset.y \x3d bRes \x26\x26 (offset.y \x3c 2.0*a) ? 0.0 : offset.y;\n\t}\n\telse {\n\t\tr \x3d vec3(direction.z, -direction.x, direction.y);\n\t\toffset \x3d vec2(2.0*scale+mipOffset, 0.5 * rcpPowScale);\n\t\toffset.y \x3d bRes \x26\x26 (offset.y \x3c 2.0*a) ? 0.0 : offset.y;\n\t}\n\tr \x3d normalize(r);\n\tfloat texelOffset \x3d 0.5 * cubeUV_rcpTextureSize;\n\tvec2 s \x3d ( r.yz / abs( r.x ) + vec2( 1.0 ) ) * 0.5;\n\tvec2 base \x3d offset + vec2( texelOffset );\n\treturn base + s * ( scale - 2.0 * texelOffset );\n}\n#define cubeUV_maxLods3 (log2(cubeUV_textureSize*0.25) - 3.0)\nvec4 textureCubeUV( sampler2D envMap, vec3 reflectedDirection, float roughness ) {\n\tfloat roughnessVal \x3d roughness* cubeUV_maxLods3;\n\tfloat r1 \x3d floor(roughnessVal);\n\tfloat r2 \x3d r1 + 1.0;\n\tfloat t \x3d fract(roughnessVal);\n\tvec2 mipInfo \x3d MipLevelInfo(reflectedDirection, r1, roughness);\n\tfloat s \x3d mipInfo.y;\n\tfloat level0 \x3d mipInfo.x;\n\tfloat level1 \x3d level0 + 1.0;\n\tlevel1 \x3d level1 \x3e 5.0 ? 5.0 : level1;\n\tlevel0 +\x3d min( floor( s + 0.5 ), 5.0 );\n\tvec2 uv_10 \x3d getCubeUV(reflectedDirection, r1, level0);\n\tvec4 color10 \x3d envMapTexelToLinear(texture2D(envMap, uv_10));\n\tvec2 uv_20 \x3d getCubeUV(reflectedDirection, r2, level0);\n\tvec4 color20 \x3d envMapTexelToLinear(texture2D(envMap, uv_20));\n\tvec4 result \x3d mix(color10, color20, t);\n\treturn vec4(result.rgb, 1.0);\n}\n#endif",
defaultnormal_vertex:"vec3 transformedNormal \x3d normalMatrix * objectNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal \x3d - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\tvec3 transformedTangent \x3d normalMatrix * objectTangent;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent \x3d - 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 +\x3d normalize( objectNormal ) * ( texture2D( displacementMap, uv ).x * displacementScale + displacementBias );\n#endif",
emissivemap_fragment:"#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor \x3d texture2D( emissiveMap, vUv );\n\temissiveColor.rgb \x3d emissiveMapTexelToLinear( emissiveColor ).rgb;\n\ttotalEmissiveRadiance *\x3d emissiveColor.rgb;\n#endif",emissivemap_pars_fragment:"#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif",encodings_fragment:"gl_FragColor \x3d linearToOutputTexel( gl_FragColor );",encodings_pars_fragment:"\nvec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( gammaFactor ) ), value.a );\n}\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( 1.0 / gammaFactor ) ), value.a );\n}\nvec4 sRGBToLinear( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.a );\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}\nvec4 RGBEToLinear( in vec4 value ) {\n\treturn vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\n}\nvec4 LinearToRGBE( in vec4 value ) {\n\tfloat maxComponent \x3d max( max( value.r, value.g ), value.b );\n\tfloat fExp \x3d clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\n\treturn vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\n}\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * value.a * maxRange, 1.0 );\n}\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\n\tfloat maxRGB \x3d max( value.r, max( value.g, value.b ) );\n\tfloat M \x3d clamp( maxRGB / maxRange, 0.0, 1.0 );\n\tM \x3d ceil( M * 255.0 ) / 255.0;\n\treturn vec4( value.rgb / ( M * maxRange ), M );\n}\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\n}\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\n\tfloat maxRGB \x3d max( value.r, max( value.g, value.b ) );\n\tfloat D \x3d max( maxRange / maxRGB, 1.0 );\n\tD \x3d min( floor( D ) / 255.0, 1.0 );\n\treturn vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\n}\nconst mat3 cLogLuvM \x3d mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\nvec4 LinearToLogLuv( in vec4 value )  {\n\tvec3 Xp_Y_XYZp \x3d cLogLuvM * value.rgb;\n\tXp_Y_XYZp \x3d max( Xp_Y_XYZp, vec3( 1e-6, 1e-6, 1e-6 ) );\n\tvec4 vResult;\n\tvResult.xy \x3d Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\n\tfloat Le \x3d 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\n\tvResult.w \x3d fract( Le );\n\tvResult.z \x3d ( Le - ( floor( vResult.w * 255.0 ) ) / 255.0 ) / 255.0;\n\treturn vResult;\n}\nconst mat3 cLogLuvInverseM \x3d mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\nvec4 LogLuvToLinear( in vec4 value ) {\n\tfloat Le \x3d value.z * 255.0 + value.w;\n\tvec3 Xp_Y_XYZp;\n\tXp_Y_XYZp.y \x3d exp2( ( Le - 127.0 ) / 2.0 );\n\tXp_Y_XYZp.z \x3d Xp_Y_XYZp.y / value.y;\n\tXp_Y_XYZp.x \x3d value.x * Xp_Y_XYZp.z;\n\tvec3 vRGB \x3d cLogLuvInverseM * Xp_Y_XYZp.rgb;\n\treturn vec4( max( vRGB, 0.0 ), 1.0 );\n}",
envmap_fragment:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToVertex \x3d normalize( vWorldPosition - cameraPosition );\n\t\tvec3 worldNormal \x3d inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec \x3d reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec \x3d refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec \x3d vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor \x3d textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_EQUIREC )\n\t\tvec2 sampleUV;\n\t\treflectVec \x3d normalize( reflectVec );\n\t\tsampleUV.y \x3d asin( clamp( reflectVec.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\t\tsampleUV.x \x3d atan( reflectVec.z, reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n\t\tvec4 envColor \x3d texture2D( envMap, sampleUV );\n\t#elif defined( ENVMAP_TYPE_SPHERE )\n\t\treflectVec \x3d normalize( reflectVec );\n\t\tvec3 reflectView \x3d normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0, 0.0, 1.0 ) );\n\t\tvec4 envColor \x3d texture2D( envMap, reflectView.xy * 0.5 + 0.5 );\n\t#else\n\t\tvec4 envColor \x3d vec4( 0.0 );\n\t#endif\n\tenvColor \x3d envMapTexelToLinear( envColor );\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight \x3d mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight \x3d mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight +\x3d 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\tuniform int maxMipLevel;\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 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\n\t\tvec3 worldNormal \x3d inverseTransformDirection( geometry.normal, viewMatrix );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryVec \x3d vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor \x3d textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor \x3d textureCube( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb \x3d envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 queryVec \x3d vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\tvec4 envMapColor \x3d textureCubeUV( envMap, queryVec, 1.0 );\n\t\t#else\n\t\t\tvec4 envMapColor \x3d vec4( 0.0 );\n\t\t#endif\n\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t}\n\tfloat getSpecularMIPLevel( const in float roughness, const in int maxMIPLevel ) {\n\t\tfloat maxMIPLevelScalar \x3d float( maxMIPLevel );\n\t\tfloat sigma \x3d PI * roughness * roughness / ( 1.0 + roughness );\n\t\tfloat desiredMIPLevel \x3d maxMIPLevelScalar + log2( sigma );\n\t\treturn clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\n\t}\n\tvec3 getLightProbeIndirectRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in int maxMIPLevel ) {\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t  vec3 reflectVec \x3d reflect( -viewDir, normal );\n\t\t  reflectVec \x3d normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t#else\n\t\t  vec3 reflectVec \x3d refract( -viewDir, normal, refractionRatio );\n\t\t#endif\n\t\treflectVec \x3d inverseTransformDirection( reflectVec, viewMatrix );\n\t\tfloat specularMIPLevel \x3d getSpecularMIPLevel( roughness, maxMIPLevel );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryReflectVec \x3d vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor \x3d textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor \x3d textureCube( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb \x3d envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 queryReflectVec \x3d vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n\t\t\tvec4 envMapColor \x3d textureCubeUV( envMap, queryReflectVec, roughness );\n\t\t#elif defined( ENVMAP_TYPE_EQUIREC )\n\t\t\tvec2 sampleUV;\n\t\t\tsampleUV.y \x3d asin( clamp( reflectVec.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\t\t\tsampleUV.x \x3d atan( reflectVec.z, reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor \x3d texture2DLodEXT( envMap, sampleUV, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor \x3d texture2D( envMap, sampleUV, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb \x3d envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_SPHERE )\n\t\t\tvec3 reflectView \x3d normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0,0.0,1.0 ) );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor \x3d texture2DLodEXT( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor \x3d texture2D( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb \x3d envMapTexelToLinear( envMapColor ).rgb;\n\t\t#endif\n\t\treturn envMapColor.rgb * envMapIntensity;\n\t}\n#endif",
envmap_vertex:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition \x3d worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex \x3d normalize( worldPosition.xyz - cameraPosition );\n\t\tvec3 worldNormal \x3d inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect \x3d reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect \x3d refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif",fog_vertex:"#ifdef USE_FOG\n\tfogDepth \x3d -mvPosition.z;\n#endif",
fog_pars_vertex:"#ifdef USE_FOG\n\tvarying float fogDepth;\n#endif",fog_fragment:"#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor \x3d 1.0 - exp( - fogDensity * fogDensity * fogDepth * fogDepth );\n\t#else\n\t\tfloat fogFactor \x3d smoothstep( fogNear, fogFar, fogDepth );\n\t#endif\n\tgl_FragColor.rgb \x3d mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif",fog_pars_fragment:"#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float fogDepth;\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 TOON\n\tuniform sampler2D gradientMap;\n\tvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\t\tfloat dotNL \x3d dot( normal, lightDirection );\n\t\tvec2 coord \x3d vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t\t#ifdef USE_GRADIENTMAP\n\t\t\treturn texture2D( gradientMap, coord ).rgb;\n\t\t#else\n\t\t\treturn ( coord.x \x3c 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t\t#endif\n\t}\n#endif",lightmap_fragment:"#ifdef USE_LIGHTMAP\n\treflectedLight.indirectDiffuse +\x3d PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n#endif",
lightmap_pars_fragment:"#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif",lights_lambert_vertex:"vec3 diffuse \x3d vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position \x3d mvPosition.xyz;\ngeometry.normal \x3d normalize( transformedNormal );\ngeometry.viewDir \x3d normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position \x3d geometry.position;\nbackGeometry.normal \x3d -geometry.normal;\nbackGeometry.viewDir \x3d geometry.viewDir;\nvLightFront \x3d vec3( 0.0 );\nvIndirectFront \x3d vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n\tvLightBack \x3d vec3( 0.0 );\n\tvIndirectBack \x3d vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\n#if NUM_POINT_LIGHTS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\n\t\tdotNL \x3d dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse \x3d PI * directLight.color;\n\t\tvLightFront +\x3d saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack +\x3d saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_SPOT_LIGHTS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\n\t\tdotNL \x3d dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse \x3d PI * directLight.color;\n\t\tvLightFront +\x3d saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack +\x3d saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_DIR_LIGHTS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\n\t\tdotNL \x3d dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse \x3d PI * directLight.color;\n\t\tvLightFront +\x3d saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack +\x3d saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_HEMI_LIGHTS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvIndirectFront +\x3d getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvIndirectBack +\x3d getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\n\t\t#endif\n\t}\n#endif",
lights_pars_begin:"uniform vec3 ambientLightColor;\nuniform vec3 lightProbe[ 9 ];\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x \x3d normal.x, y \x3d normal.y, z \x3d normal.z;\n\tvec3 result \x3d shCoefficients[ 0 ] * 0.886227;\n\tresult +\x3d shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult +\x3d shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult +\x3d shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult +\x3d shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult +\x3d shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult +\x3d shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult +\x3d shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult +\x3d shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in GeometricContext geometry ) {\n\tvec3 worldNormal \x3d inverseTransformDirection( geometry.normal, viewMatrix );\n\tvec3 irradiance \x3d shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance \x3d ambientLightColor;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *\x3d PI;\n\t#endif\n\treturn irradiance;\n}\n#if NUM_DIR_LIGHTS \x3e 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tdirectLight.color \x3d directionalLight.color;\n\t\tdirectLight.direction \x3d directionalLight.direction;\n\t\tdirectLight.visible \x3d true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS \x3e 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t\tfloat shadowCameraNear;\n\t\tfloat shadowCameraFar;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector \x3d pointLight.position - geometry.position;\n\t\tdirectLight.direction \x3d normalize( lVector );\n\t\tfloat lightDistance \x3d length( lVector );\n\t\tdirectLight.color \x3d pointLight.color;\n\t\tdirectLight.color *\x3d punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\n\t\tdirectLight.visible \x3d ( directLight.color !\x3d vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS \x3e 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\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight  ) {\n\t\tvec3 lVector \x3d spotLight.position - geometry.position;\n\t\tdirectLight.direction \x3d normalize( lVector );\n\t\tfloat lightDistance \x3d length( lVector );\n\t\tfloat angleCos \x3d dot( directLight.direction, spotLight.direction );\n\t\tif ( angleCos \x3e spotLight.coneCos ) {\n\t\t\tfloat spotEffect \x3d smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\t\tdirectLight.color \x3d spotLight.color;\n\t\t\tdirectLight.color *\x3d spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tdirectLight.visible \x3d true;\n\t\t} else {\n\t\t\tdirectLight.color \x3d vec3( 0.0 );\n\t\t\tdirectLight.visible \x3d false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS \x3e 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 \x3e 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 GeometricContext geometry ) {\n\t\tfloat dotNL \x3d dot( geometry.normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight \x3d 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance \x3d mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tirradiance *\x3d PI;\n\t\t#endif\n\t\treturn irradiance;\n\t}\n#endif",
lights_phong_fragment:"BlinnPhongMaterial material;\nmaterial.diffuseColor \x3d diffuseColor.rgb;\nmaterial.specularColor \x3d specular;\nmaterial.specularShininess \x3d shininess;\nmaterial.specularStrength \x3d specularStrength;",lights_phong_pars_fragment:"varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\nstruct BlinnPhongMaterial {\n\tvec3\tdiffuseColor;\n\tvec3\tspecularColor;\n\tfloat\tspecularShininess;\n\tfloat\tspecularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\t#ifdef TOON\n\t\tvec3 irradiance \x3d getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\t#else\n\t\tfloat dotNL \x3d saturate( dot( geometry.normal, directLight.direction ) );\n\t\tvec3 irradiance \x3d dotNL * directLight.color;\n\t#endif\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *\x3d PI;\n\t#endif\n\treflectedLight.directDiffuse +\x3d irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular +\x3d irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, 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 +\x3d irradiance * BRDF_Diffuse_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 \x3d diffuseColor.rgb * ( 1.0 - metalnessFactor );\nmaterial.specularRoughness \x3d clamp( roughnessFactor, 0.04, 1.0 );\n#ifdef REFLECTIVITY\n\tmaterial.specularColor \x3d mix( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor \x3d mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor.rgb, metalnessFactor );\n#endif\n#ifdef CLEARCOAT\n\tmaterial.clearcoat \x3d saturate( clearcoat );\tmaterial.clearcoatRoughness \x3d clamp( clearcoatRoughness, 0.04, 1.0 );\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor \x3d sheen;\n#endif",
lights_physical_pars_fragment:"struct PhysicalMaterial {\n\tvec3\tdiffuseColor;\n\tfloat\tspecularRoughness;\n\tvec3\tspecularColor;\n#ifdef CLEARCOAT\n\tfloat clearcoat;\n\tfloat clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tvec3 sheenColor;\n#endif\n};\n#define MAXIMUM_SPECULAR_COEFFICIENT 0.16\n#define DEFAULT_SPECULAR_COEFFICIENT 0.04\nfloat clearcoatDHRApprox( const in float roughness, const in float dotNL ) {\n\treturn DEFAULT_SPECULAR_COEFFICIENT + ( 1.0 - DEFAULT_SPECULAR_COEFFICIENT ) * ( pow( 1.0 - dotNL, 5.0 ) * pow( 1.0 - roughness, 2.0 ) );\n}\n#if NUM_RECT_AREA_LIGHTS \x3e 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 \x3d geometry.normal;\n\t\tvec3 viewDir \x3d geometry.viewDir;\n\t\tvec3 position \x3d geometry.position;\n\t\tvec3 lightPos \x3d rectAreaLight.position;\n\t\tvec3 halfWidth \x3d rectAreaLight.halfWidth;\n\t\tvec3 halfHeight \x3d rectAreaLight.halfHeight;\n\t\tvec3 lightColor \x3d rectAreaLight.color;\n\t\tfloat roughness \x3d material.specularRoughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] \x3d lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] \x3d lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] \x3d lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] \x3d lightPos + halfWidth + halfHeight;\n\t\tvec2 uv \x3d LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 \x3d texture2D( ltc_1, uv );\n\t\tvec4 t2 \x3d texture2D( ltc_2, uv );\n\t\tmat3 mInv \x3d 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 \x3d ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular +\x3d lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse +\x3d 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 \x3d saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance \x3d dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *\x3d PI;\n\t#endif\n\t#ifdef CLEARCOAT\n\t\tfloat ccDotNL \x3d saturate( dot( geometry.clearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance \x3d ccDotNL * directLight.color;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tccIrradiance *\x3d PI;\n\t\t#endif\n\t\tfloat clearcoatDHR \x3d material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t\treflectedLight.directSpecular +\x3d ccIrradiance * material.clearcoat * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t#else\n\t\tfloat clearcoatDHR \x3d 0.0;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\treflectedLight.directSpecular +\x3d ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_Sheen(\n\t\t\tmaterial.specularRoughness,\n\t\t\tdirectLight.direction,\n\t\t\tgeometry,\n\t\t\tmaterial.sheenColor\n\t\t);\n\t#else\n\t\treflectedLight.directSpecular +\x3d ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.normal, material.specularColor, material.specularRoughness);\n\t#endif\n\treflectedLight.directDiffuse +\x3d ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Diffuse_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 +\x3d irradiance * BRDF_Diffuse_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 CLEARCOAT\n\t\tfloat ccDotNV \x3d saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular +\x3d clearcoatRadiance * material.clearcoat * BRDF_Specular_GGX_Environment( geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t\tfloat ccDotNL \x3d ccDotNV;\n\t\tfloat clearcoatDHR \x3d material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t#else\n\t\tfloat clearcoatDHR \x3d 0.0;\n\t#endif\n\tfloat clearcoatInv \x3d 1.0 - clearcoatDHR;\n\tvec3 singleScattering \x3d vec3( 0.0 );\n\tvec3 multiScattering \x3d vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance \x3d irradiance * RECIPROCAL_PI;\n\tBRDF_Specular_Multiscattering_Environment( geometry, material.specularColor, material.specularRoughness, singleScattering, multiScattering );\n\tvec3 diffuse \x3d material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );\n\treflectedLight.indirectSpecular +\x3d clearcoatInv * radiance * singleScattering;\n\treflectedLight.indirectDiffuse +\x3d multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse +\x3d 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 \x3d - vViewPosition;\ngeometry.normal \x3d normal;\ngeometry.viewDir \x3d normalize( vViewPosition );\n#ifdef CLEARCOAT\n\tgeometry.clearcoatNormal \x3d clearcoatNormal;\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS \x3e 0 ) \x26\x26 defined( RE_Direct )\n\tPointLight pointLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight \x3d pointLights[ i ];\n\t\tgetPointDirectLightIrradiance( pointLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) \x26\x26 ( UNROLLED_LOOP_INDEX \x3c NUM_POINT_LIGHT_SHADOWS )\n\t\tdirectLight.color *\x3d all( bvec2( pointLight.shadow, directLight.visible ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_SPOT_LIGHTS \x3e 0 ) \x26\x26 defined( RE_Direct )\n\tSpotLight spotLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight \x3d spotLights[ i ];\n\t\tgetSpotDirectLightIrradiance( spotLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) \x26\x26 ( UNROLLED_LOOP_INDEX \x3c NUM_SPOT_LIGHT_SHADOWS )\n\t\tdirectLight.color *\x3d all( bvec2( spotLight.shadow, directLight.visible ) ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_DIR_LIGHTS \x3e 0 ) \x26\x26 defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight \x3d directionalLights[ i ];\n\t\tgetDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) \x26\x26 ( UNROLLED_LOOP_INDEX \x3c NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectLight.color *\x3d all( bvec2( directionalLight.shadow, directLight.visible ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_RECT_AREA_LIGHTS \x3e 0 ) \x26\x26 defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight \x3d rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance \x3d vec3( 0.0 );\n\tvec3 irradiance \x3d getAmbientLightIrradiance( ambientLightColor );\n\tirradiance +\x3d getLightProbeIrradiance( lightProbe, geometry );\n\t#if ( NUM_HEMI_LIGHTS \x3e 0 )\n\t\t#pragma unroll_loop\n\t\tfor ( int i \x3d 0; i \x3c NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance +\x3d getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t}\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance \x3d vec3( 0.0 );\n\tvec3 clearcoatRadiance \x3d vec3( 0.0 );\n#endif",
lights_fragment_maps:"#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec3 lightMapIrradiance \x3d texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *\x3d PI;\n\t\t#endif\n\t\tirradiance +\x3d lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) \x26\x26 defined( STANDARD ) \x26\x26 defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance +\x3d getLightProbeIndirectIrradiance( geometry, maxMipLevel );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) \x26\x26 defined( RE_IndirectSpecular )\n\tradiance +\x3d getLightProbeIndirectRadiance( geometry.viewDir, geometry.normal, material.specularRoughness, maxMipLevel );\n\t#ifdef CLEARCOAT\n\t\tclearcoatRadiance +\x3d getLightProbeIndirectRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness, maxMipLevel );\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 ) \x26\x26 defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT \x3d log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif",logdepthbuf_pars_fragment:"#if defined( USE_LOGDEPTHBUF ) \x26\x26 defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n#endif",
logdepthbuf_pars_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\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 \x3d 1.0 + gl_Position.w;\n\t#else\n\t\tgl_Position.z \x3d log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\tgl_Position.z *\x3d gl_Position.w;\n\t#endif\n#endif",map_fragment:"#ifdef USE_MAP\n\tvec4 texelColor \x3d texture2D( map, vUv );\n\ttexelColor \x3d mapTexelToLinear( texelColor );\n\tdiffuseColor *\x3d texelColor;\n#endif",
map_pars_fragment:"#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif",map_particle_fragment:"#ifdef USE_MAP\n\tvec2 uv \x3d ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n\tvec4 mapTexel \x3d texture2D( map, uv );\n\tdiffuseColor *\x3d mapTexelToLinear( mapTexel );\n#endif",map_particle_pars_fragment:"#ifdef USE_MAP\n\tuniform mat3 uvTransform;\n\tuniform sampler2D map;\n#endif",metalnessmap_fragment:"float metalnessFactor \x3d metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness \x3d texture2D( metalnessMap, vUv );\n\tmetalnessFactor *\x3d texelMetalness.b;\n#endif",
metalnessmap_pars_fragment:"#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif",morphnormal_vertex:"#ifdef USE_MORPHNORMALS\n\tobjectNormal +\x3d ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];\n\tobjectNormal +\x3d ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];\n\tobjectNormal +\x3d ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];\n\tobjectNormal +\x3d ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];\n#endif",morphtarget_pars_vertex:"#ifdef USE_MORPHTARGETS\n\t#ifndef USE_MORPHNORMALS\n\tuniform float morphTargetInfluences[ 8 ];\n\t#else\n\tuniform float morphTargetInfluences[ 4 ];\n\t#endif\n#endif",
morphtarget_vertex:"#ifdef USE_MORPHTARGETS\n\ttransformed +\x3d ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];\n\ttransformed +\x3d ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];\n\ttransformed +\x3d ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];\n\ttransformed +\x3d ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];\n\t#ifndef USE_MORPHNORMALS\n\ttransformed +\x3d ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];\n\ttransformed +\x3d ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];\n\ttransformed +\x3d ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];\n\ttransformed +\x3d ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];\n\t#endif\n#endif",
normal_fragment_begin:"#ifdef FLAT_SHADED\n\tvec3 fdx \x3d vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy \x3d vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal \x3d normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal \x3d normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal \x3d normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\t#ifdef USE_TANGENT\n\t\tvec3 tangent \x3d normalize( vTangent );\n\t\tvec3 bitangent \x3d normalize( vBitangent );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\ttangent \x3d tangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t\tbitangent \x3d bitangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t#endif\n\t#endif\n#endif\nvec3 geometryNormal \x3d normal;",
normal_fragment_maps:"#ifdef OBJECTSPACE_NORMALMAP\n\tnormal \x3d texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal \x3d - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal \x3d normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\tnormal \x3d normalize( normalMatrix * normal );\n#elif defined( TANGENTSPACE_NORMALMAP )\n\t#ifdef USE_TANGENT\n\t\tmat3 vTBN \x3d mat3( tangent, bitangent, normal );\n\t\tvec3 mapN \x3d texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t\tmapN.xy \x3d normalScale * mapN.xy;\n\t\tnormal \x3d normalize( vTBN * mapN );\n\t#else\n\t\tnormal \x3d perturbNormal2Arb( -vViewPosition, normal, normalScale, normalMap );\n\t#endif\n#elif defined( USE_BUMPMAP )\n\tnormal \x3d perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\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 ) \x26\x26 ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec2 normalScale, in sampler2D normalMap ) {\n\t\tvec3 q0 \x3d vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 \x3d vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 \x3d dFdx( vUv.st );\n\t\tvec2 st1 \x3d dFdy( vUv.st );\n\t\tfloat scale \x3d sign( st1.t * st0.s - st0.t * st1.s );\n\t\tvec3 S \x3d normalize( ( q0 * st1.t - q1 * st0.t ) * scale );\n\t\tvec3 T \x3d normalize( ( - q0 * st1.s + q1 * st0.s ) * scale );\n\t\tvec3 N \x3d normalize( surf_norm );\n\t\tvec3 mapN \x3d texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t\tmapN.xy *\x3d normalScale;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvec3 NfromST \x3d cross( S, T );\n\t\t\tif( dot( NfromST, N ) \x3e 0.0 ) {\n\t\t\t\tS *\x3d -1.0;\n\t\t\t\tT *\x3d -1.0;\n\t\t\t}\n\t\t#else\n\t\t\tmapN.xy *\x3d ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t#endif\n\t\tmat3 tsn \x3d mat3( S, T, N );\n\t\treturn normalize( tsn * mapN );\n\t}\n#endif",
clearcoat_normal_fragment_begin:"#ifdef CLEARCOAT\n\tvec3 clearcoatNormal \x3d geometryNormal;\n#endif",clearcoat_normal_fragment_maps:"#ifdef USE_CLEARCOAT_NORMALMAP\n\t#ifdef USE_TANGENT\n\t\tmat3 vTBN \x3d mat3( tangent, bitangent, clearcoatNormal );\n\t\tvec3 mapN \x3d texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t\tmapN.xy \x3d clearcoatNormalScale * mapN.xy;\n\t\tclearcoatNormal \x3d normalize( vTBN * mapN );\n\t#else\n\t\tclearcoatNormal \x3d perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatNormalScale, clearcoatNormalMap );\n\t#endif\n#endif",
clearcoat_normalmap_pars_fragment:"#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif",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 \x3d 256. / 255.;const float UnpackDownscale \x3d 255. / 256.;\nconst vec3 PackFactors \x3d vec3( 256. * 256. * 256., 256. * 256.,  256. );\nconst vec4 UnpackFactors \x3d UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 \x3d 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r \x3d vec4( fract( v * PackFactors ), v );\n\tr.yzw -\x3d r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec4 encodeHalfRGBA ( vec2 v ) {\n\tvec4 encoded \x3d vec4( 0.0 );\n\tconst vec2 offset \x3d vec2( 1.0 / 255.0, 0.0 );\n\tencoded.xy \x3d vec2( v.x, fract( v.x * 255.0 ) );\n\tencoded.xy \x3d encoded.xy - ( encoded.yy * offset );\n\tencoded.zw \x3d vec2( v.y, fract( v.y * 255.0 ) );\n\tencoded.zw \x3d encoded.zw - ( encoded.ww * offset );\n\treturn encoded;\n}\nvec2 decodeHalfRGBA( 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 *\x3d gl_FragColor.a;\n#endif",project_vertex:"vec4 mvPosition \x3d modelViewMatrix * vec4( transformed, 1.0 );\ngl_Position \x3d projectionMatrix * mvPosition;",dithering_fragment:"#ifdef DITHERING\n\tgl_FragColor.rgb \x3d dithering( gl_FragColor.rgb );\n#endif",dithering_pars_fragment:"#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position \x3d rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB \x3d vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB \x3d 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 \x3d roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness \x3d texture2D( roughnessMap, vUv );\n\troughnessFactor *\x3d 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 \x3e 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS \x3e 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS \x3e 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ 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 decodeHalfRGBA( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion \x3d 1.0;\n\t\tvec2 distribution \x3d texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow \x3d step( compare , distribution.x );\n\t\tif (hard_shadow !\x3d 1.0 ) {\n\t\t\tfloat distance \x3d compare - distribution.x ;\n\t\t\tfloat variance \x3d max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability \x3d variance / (variance + distance * distance );\t\t\tsoftness_probability \x3d clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion \x3d clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat texture2DShadowLerp( sampler2D depths, vec2 size, vec2 uv, float compare ) {\n\t\tconst vec2 offset \x3d vec2( 0.0, 1.0 );\n\t\tvec2 texelSize \x3d vec2( 1.0 ) / size;\n\t\tvec2 centroidUV \x3d ( floor( uv * size - 0.5 ) + 0.5 ) * texelSize;\n\t\tfloat lb \x3d texture2DCompare( depths, centroidUV + texelSize * offset.xx, compare );\n\t\tfloat lt \x3d texture2DCompare( depths, centroidUV + texelSize * offset.xy, compare );\n\t\tfloat rb \x3d texture2DCompare( depths, centroidUV + texelSize * offset.yx, compare );\n\t\tfloat rt \x3d texture2DCompare( depths, centroidUV + texelSize * offset.yy, compare );\n\t\tvec2 f \x3d fract( uv * size + 0.5 );\n\t\tfloat a \x3d mix( lb, lt, f.y );\n\t\tfloat b \x3d mix( rb, rt, f.y );\n\t\tfloat c \x3d mix( a, b, f.x );\n\t\treturn c;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow \x3d 1.0;\n\t\tshadowCoord.xyz /\x3d shadowCoord.w;\n\t\tshadowCoord.z +\x3d shadowBias;\n\t\tbvec4 inFrustumVec \x3d bvec4 ( shadowCoord.x \x3e\x3d 0.0, shadowCoord.x \x3c\x3d 1.0, shadowCoord.y \x3e\x3d 0.0, shadowCoord.y \x3c\x3d 1.0 );\n\t\tbool inFrustum \x3d all( inFrustumVec );\n\t\tbvec2 frustumTestVec \x3d bvec2( inFrustum, shadowCoord.z \x3c\x3d 1.0 );\n\t\tbool frustumTest \x3d all( frustumTestVec );\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize \x3d vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 \x3d - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 \x3d - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 \x3d + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 \x3d + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 \x3d dx0 / 2.0;\n\t\t\tfloat dy2 \x3d dy0 / 2.0;\n\t\t\tfloat dx3 \x3d dx1 / 2.0;\n\t\t\tfloat dy3 \x3d dy1 / 2.0;\n\t\t\tshadow \x3d (\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 \x3d vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 \x3d - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 \x3d - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 \x3d + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 \x3d + texelSize.y * shadowRadius;\n\t\t\tshadow \x3d (\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow \x3d VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow \x3d 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 \x3d abs( v );\n\t\tfloat scaleToCube \x3d 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *\x3d scaleToCube;\n\t\tv *\x3d scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar \x3d v.xy;\n\t\tfloat almostATexel \x3d 1.5 * texelSizeY;\n\t\tfloat almostOne \x3d 1.0 - almostATexel;\n\t\tif ( absV.z \x3e\x3d almostOne ) {\n\t\t\tif ( v.z \x3e 0.0 )\n\t\t\t\tplanar.x \x3d 4.0 - v.x;\n\t\t} else if ( absV.x \x3e\x3d almostOne ) {\n\t\t\tfloat signX \x3d sign( v.x );\n\t\t\tplanar.x \x3d v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y \x3e\x3d almostOne ) {\n\t\t\tfloat signY \x3d sign( v.y );\n\t\t\tplanar.x \x3d v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y \x3d 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 \x3d vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition \x3d shadowCoord.xyz;\n\t\tfloat dp \x3d ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp +\x3d shadowBias;\n\t\tvec3 bd3D \x3d normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset \x3d 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 \x3e 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS \x3e 0\n\t\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS \x3e 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif",
shadowmap_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tvDirectionalShadowCoord[ i ] \x3d directionalShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tvSpotShadowCoord[ i ] \x3d spotShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tvPointShadowCoord[ i ] \x3d pointShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n#endif",
shadowmask_pars_fragment:"float getShadowMask() {\n\tfloat shadow \x3d 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS \x3e 0\n\tDirectionalLight directionalLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight \x3d directionalLights[ i ];\n\t\tshadow *\x3d bool( directionalLight.shadow ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS \x3e 0\n\tSpotLight spotLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight \x3d spotLights[ i ];\n\t\tshadow *\x3d bool( spotLight.shadow ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t}\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS \x3e 0\n\tPointLight pointLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight \x3d pointLights[ i ];\n\t\tshadow *\x3d bool( pointLight.shadow ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#endif\n\t#endif\n\treturn shadow;\n}",
skinbase_vertex:"#ifdef USE_SKINNING\n\tmat4 boneMatX \x3d getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY \x3d getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ \x3d getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW \x3d 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 \x3d i * 4.0;\n\t\t\tfloat x \x3d mod( j, float( boneTextureSize ) );\n\t\t\tfloat y \x3d floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx \x3d 1.0 / float( boneTextureSize );\n\t\t\tfloat dy \x3d 1.0 / float( boneTextureSize );\n\t\t\ty \x3d dy * ( y + 0.5 );\n\t\t\tvec4 v1 \x3d texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 \x3d texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 \x3d texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 \x3d texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone \x3d 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 \x3d boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif",
skinning_vertex:"#ifdef USE_SKINNING\n\tvec4 skinVertex \x3d bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned \x3d vec4( 0.0 );\n\tskinned +\x3d boneMatX * skinVertex * skinWeight.x;\n\tskinned +\x3d boneMatY * skinVertex * skinWeight.y;\n\tskinned +\x3d boneMatZ * skinVertex * skinWeight.z;\n\tskinned +\x3d boneMatW * skinVertex * skinWeight.w;\n\ttransformed \x3d ( bindMatrixInverse * skinned ).xyz;\n#endif",skinnormal_vertex:"#ifdef USE_SKINNING\n\tmat4 skinMatrix \x3d mat4( 0.0 );\n\tskinMatrix +\x3d skinWeight.x * boneMatX;\n\tskinMatrix +\x3d skinWeight.y * boneMatY;\n\tskinMatrix +\x3d skinWeight.z * boneMatZ;\n\tskinMatrix +\x3d skinWeight.w * boneMatW;\n\tskinMatrix  \x3d bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal \x3d vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent \x3d vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif",
specularmap_fragment:"float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular \x3d texture2D( specularMap, vUv );\n\tspecularStrength \x3d texelSpecular.r;\n#else\n\tspecularStrength \x3d 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 \x3d toneMapping( gl_FragColor.rgb );\n#endif",tonemapping_pars_fragment:"#ifndef saturate\n\t#define saturate(a) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nuniform float toneMappingWhitePoint;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *\x3d toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\n#define Uncharted2Helper( x ) max( ( ( x * ( 0.15 * x + 0.10 * 0.50 ) + 0.20 * 0.02 ) / ( x * ( 0.15 * x + 0.50 ) + 0.20 * 0.30 ) ) - 0.02 / 0.30, vec3( 0.0 ) )\nvec3 Uncharted2ToneMapping( vec3 color ) {\n\tcolor *\x3d toneMappingExposure;\n\treturn saturate( Uncharted2Helper( color ) / Uncharted2Helper( vec3( toneMappingWhitePoint ) ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *\x3d toneMappingExposure;\n\tcolor \x3d 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 ACESFilmicToneMapping( vec3 color ) {\n\tcolor *\x3d toneMappingExposure;\n\treturn saturate( ( color * ( 2.51 * color + 0.03 ) ) / ( color * ( 2.43 * color + 0.59 ) + 0.14 ) );\n}",
uv_pars_fragment:"#ifdef USE_UV\n\tvarying vec2 vUv;\n#endif",uv_pars_vertex:"#ifdef USE_UV\n\tvarying vec2 vUv;\n\tuniform mat3 uvTransform;\n#endif",uv_vertex:"#ifdef USE_UV\n\tvUv \x3d ( 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#endif",uv2_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 \x3d uv2;\n#endif",
worldpos_vertex:"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )\n\tvec4 worldPosition \x3d modelMatrix * vec4( transformed, 1.0 );\n#endif",background_frag:"uniform sampler2D t2D;\nvarying vec2 vUv;\nvoid main() {\n\tvec4 texColor \x3d texture2D( t2D, vUv );\n\tgl_FragColor \x3d mapTexelToLinear( texColor );\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n}",background_vert:"varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv \x3d ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position \x3d vec4( position.xy, 1.0, 1.0 );\n}",
cube_frag:"uniform samplerCube tCube;\nuniform float tFlip;\nuniform float opacity;\nvarying vec3 vWorldDirection;\nvoid main() {\n\tvec4 texColor \x3d textureCube( tCube, vec3( tFlip * vWorldDirection.x, vWorldDirection.yz ) );\n\tgl_FragColor \x3d mapTexelToLinear( texColor );\n\tgl_FragColor.a *\x3d opacity;\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n}",cube_vert:"varying vec3 vWorldDirection;\n#include \x3ccommon\x3e\nvoid main() {\n\tvWorldDirection \x3d transformDirection( position, modelMatrix );\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\tgl_Position.z \x3d gl_Position.w;\n}",
depth_frag:"#if DEPTH_PACKING \x3d\x3d 3200\n\tuniform float opacity;\n#endif\n#include \x3ccommon\x3e\n#include \x3cpacking\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( 1.0 );\n\t#if DEPTH_PACKING \x3d\x3d 3200\n\t\tdiffuseColor.a \x3d opacity;\n\t#endif\n\t#include \x3cmap_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#if DEPTH_PACKING \x3d\x3d 3200\n\t\tgl_FragColor \x3d vec4( vec3( 1.0 - gl_FragCoord.z ), opacity );\n\t#elif DEPTH_PACKING \x3d\x3d 3201\n\t\tgl_FragColor \x3d packDepthToRGBA( gl_FragCoord.z );\n\t#endif\n}",
depth_vert:"#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cdisplacementmap_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include \x3cbeginnormal_vertex\x3e\n\t\t#include \x3cmorphnormal_vertex\x3e\n\t\t#include \x3cskinnormal_vertex\x3e\n\t#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cdisplacementmap_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n}",
distanceRGBA_frag:"#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include \x3ccommon\x3e\n#include \x3cpacking\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main () {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( 1.0 );\n\t#include \x3cmap_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\tfloat dist \x3d length( vWorldPosition - referencePosition );\n\tdist \x3d ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist \x3d saturate( dist );\n\tgl_FragColor \x3d packDepthToRGBA( dist );\n}",
distanceRGBA_vert:"#define DISTANCE\nvarying vec3 vWorldPosition;\n#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cdisplacementmap_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include \x3cbeginnormal_vertex\x3e\n\t\t#include \x3cmorphnormal_vertex\x3e\n\t\t#include \x3cskinnormal_vertex\x3e\n\t#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cdisplacementmap_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\tvWorldPosition \x3d worldPosition.xyz;\n}",
equirect_frag:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include \x3ccommon\x3e\nvoid main() {\n\tvec3 direction \x3d normalize( vWorldDirection );\n\tvec2 sampleUV;\n\tsampleUV.y \x3d asin( clamp( direction.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\tsampleUV.x \x3d atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;\n\tvec4 texColor \x3d texture2D( tEquirect, sampleUV );\n\tgl_FragColor \x3d mapTexelToLinear( texColor );\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n}",
equirect_vert:"varying vec3 vWorldDirection;\n#include \x3ccommon\x3e\nvoid main() {\n\tvWorldDirection \x3d transformDirection( position, modelMatrix );\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n}",linedashed_frag:"uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include \x3ccommon\x3e\n#include \x3ccolor_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tif ( mod( vLineDistance, totalSize ) \x3e dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight \x3d vec3( 0.0 );\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3ccolor_fragment\x3e\n\toutgoingLight \x3d diffuseColor.rgb;\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n}",
linedashed_vert:"uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include \x3ccommon\x3e\n#include \x3ccolor_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3ccolor_vertex\x3e\n\tvLineDistance \x3d scale * lineDistance;\n\tvec4 mvPosition \x3d modelViewMatrix * vec4( position, 1.0 );\n\tgl_Position \x3d projectionMatrix * mvPosition;\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}",
meshbasic_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include \x3ccommon\x3e\n#include \x3ccolor_pars_fragment\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cuv2_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3caomap_pars_fragment\x3e\n#include \x3clightmap_pars_fragment\x3e\n#include \x3cenvmap_common_pars_fragment\x3e\n#include \x3cenvmap_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3cspecularmap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_fragment\x3e\n\t#include \x3ccolor_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\t#include \x3cspecularmap_fragment\x3e\n\tReflectedLight reflectedLight \x3d ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\treflectedLight.indirectDiffuse +\x3d texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n\t#else\n\t\treflectedLight.indirectDiffuse +\x3d vec3( 1.0 );\n\t#endif\n\t#include \x3caomap_fragment\x3e\n\treflectedLight.indirectDiffuse *\x3d diffuseColor.rgb;\n\tvec3 outgoingLight \x3d reflectedLight.indirectDiffuse;\n\t#include \x3cenvmap_fragment\x3e\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n}",
meshbasic_vert:"#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cuv2_pars_vertex\x3e\n#include \x3cenvmap_pars_vertex\x3e\n#include \x3ccolor_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cuv2_vertex\x3e\n\t#include \x3ccolor_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#ifdef USE_ENVMAP\n\t#include \x3cbeginnormal_vertex\x3e\n\t#include \x3cmorphnormal_vertex\x3e\n\t#include \x3cskinnormal_vertex\x3e\n\t#include \x3cdefaultnormal_vertex\x3e\n\t#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\t#include \x3cenvmap_vertex\x3e\n\t#include \x3cfog_vertex\x3e\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 \x3ccommon\x3e\n#include \x3cpacking\x3e\n#include \x3cdithering_pars_fragment\x3e\n#include \x3ccolor_pars_fragment\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cuv2_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3caomap_pars_fragment\x3e\n#include \x3clightmap_pars_fragment\x3e\n#include \x3cemissivemap_pars_fragment\x3e\n#include \x3cenvmap_common_pars_fragment\x3e\n#include \x3cenvmap_pars_fragment\x3e\n#include \x3cbsdfs\x3e\n#include \x3clights_pars_begin\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3cshadowmap_pars_fragment\x3e\n#include \x3cshadowmask_pars_fragment\x3e\n#include \x3cspecularmap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\tReflectedLight reflectedLight \x3d ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance \x3d emissive;\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_fragment\x3e\n\t#include \x3ccolor_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\t#include \x3cspecularmap_fragment\x3e\n\t#include \x3cemissivemap_fragment\x3e\n\treflectedLight.indirectDiffuse \x3d getAmbientLightIrradiance( ambientLightColor );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.indirectDiffuse +\x3d ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;\n\t#else\n\t\treflectedLight.indirectDiffuse +\x3d vIndirectFront;\n\t#endif\n\t#include \x3clightmap_fragment\x3e\n\treflectedLight.indirectDiffuse *\x3d BRDF_Diffuse_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse \x3d ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse \x3d vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *\x3d BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include \x3caomap_fragment\x3e\n\tvec3 outgoingLight \x3d reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include \x3cenvmap_fragment\x3e\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3cdithering_fragment\x3e\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 \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cuv2_pars_vertex\x3e\n#include \x3cenvmap_pars_vertex\x3e\n#include \x3cbsdfs\x3e\n#include \x3clights_pars_begin\x3e\n#include \x3ccolor_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3cshadowmap_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cuv2_vertex\x3e\n\t#include \x3ccolor_vertex\x3e\n\t#include \x3cbeginnormal_vertex\x3e\n\t#include \x3cmorphnormal_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#include \x3cskinnormal_vertex\x3e\n\t#include \x3cdefaultnormal_vertex\x3e\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cenvmap_vertex\x3e\n\t#include \x3clights_lambert_vertex\x3e\n\t#include \x3cshadowmap_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}",
meshmatcap_frag:"#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include \x3ccommon\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3cbumpmap_pars_fragment\x3e\n#include \x3cnormalmap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\t#include \x3cnormal_fragment_begin\x3e\n\t#include \x3cnormal_fragment_maps\x3e\n\tvec3 viewDir \x3d normalize( vViewPosition );\n\tvec3 x \x3d normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y \x3d cross( viewDir, x );\n\tvec2 uv \x3d vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor \x3d texture2D( matcap, uv );\n\t\tmatcapColor \x3d matcapTexelToLinear( matcapColor );\n\t#else\n\t\tvec4 matcapColor \x3d vec4( 1.0 );\n\t#endif\n\tvec3 outgoingLight \x3d diffuseColor.rgb * matcapColor.rgb;\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n}",
meshmatcap_vert:"#define MATCAP\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cdisplacementmap_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cbeginnormal_vertex\x3e\n\t#include \x3cmorphnormal_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#include \x3cskinnormal_vertex\x3e\n\t#include \x3cdefaultnormal_vertex\x3e\n\t#ifndef FLAT_SHADED\n\t\tvNormal \x3d normalize( transformedNormal );\n\t#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cdisplacementmap_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n\tvViewPosition \x3d - mvPosition.xyz;\n}",
meshphong_frag:"#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include \x3ccommon\x3e\n#include \x3cpacking\x3e\n#include \x3cdithering_pars_fragment\x3e\n#include \x3ccolor_pars_fragment\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cuv2_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3caomap_pars_fragment\x3e\n#include \x3clightmap_pars_fragment\x3e\n#include \x3cemissivemap_pars_fragment\x3e\n#include \x3cenvmap_common_pars_fragment\x3e\n#include \x3cenvmap_pars_fragment\x3e\n#include \x3cgradientmap_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3cbsdfs\x3e\n#include \x3clights_pars_begin\x3e\n#include \x3clights_phong_pars_fragment\x3e\n#include \x3cshadowmap_pars_fragment\x3e\n#include \x3cbumpmap_pars_fragment\x3e\n#include \x3cnormalmap_pars_fragment\x3e\n#include \x3cspecularmap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\tReflectedLight reflectedLight \x3d ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance \x3d emissive;\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_fragment\x3e\n\t#include \x3ccolor_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\t#include \x3cspecularmap_fragment\x3e\n\t#include \x3cnormal_fragment_begin\x3e\n\t#include \x3cnormal_fragment_maps\x3e\n\t#include \x3cemissivemap_fragment\x3e\n\t#include \x3clights_phong_fragment\x3e\n\t#include \x3clights_fragment_begin\x3e\n\t#include \x3clights_fragment_maps\x3e\n\t#include \x3clights_fragment_end\x3e\n\t#include \x3caomap_fragment\x3e\n\tvec3 outgoingLight \x3d reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include \x3cenvmap_fragment\x3e\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3cdithering_fragment\x3e\n}",
meshphong_vert:"#define PHONG\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cuv2_pars_vertex\x3e\n#include \x3cdisplacementmap_pars_vertex\x3e\n#include \x3cenvmap_pars_vertex\x3e\n#include \x3ccolor_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3cshadowmap_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cuv2_vertex\x3e\n\t#include \x3ccolor_vertex\x3e\n\t#include \x3cbeginnormal_vertex\x3e\n\t#include \x3cmorphnormal_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#include \x3cskinnormal_vertex\x3e\n\t#include \x3cdefaultnormal_vertex\x3e\n#ifndef FLAT_SHADED\n\tvNormal \x3d normalize( transformedNormal );\n#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cdisplacementmap_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\tvViewPosition \x3d - mvPosition.xyz;\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cenvmap_vertex\x3e\n\t#include \x3cshadowmap_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}",
meshphysical_frag:"#define STANDARD\n#ifdef PHYSICAL\n\t#define REFLECTIVITY\n\t#define CLEARCOAT\n\t#define TRANSPARENCY\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef TRANSPARENCY\n\tuniform float transparency;\n#endif\n#ifdef REFLECTIVITY\n\tuniform float reflectivity;\n#endif\n#ifdef CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheen;\n#endif\nvarying vec3 vViewPosition;\n#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\n#include \x3ccommon\x3e\n#include \x3cpacking\x3e\n#include \x3cdithering_pars_fragment\x3e\n#include \x3ccolor_pars_fragment\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cuv2_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3caomap_pars_fragment\x3e\n#include \x3clightmap_pars_fragment\x3e\n#include \x3cemissivemap_pars_fragment\x3e\n#include \x3cbsdfs\x3e\n#include \x3ccube_uv_reflection_fragment\x3e\n#include \x3cenvmap_common_pars_fragment\x3e\n#include \x3cenvmap_physical_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3clights_pars_begin\x3e\n#include \x3clights_physical_pars_fragment\x3e\n#include \x3cshadowmap_pars_fragment\x3e\n#include \x3cbumpmap_pars_fragment\x3e\n#include \x3cnormalmap_pars_fragment\x3e\n#include \x3cclearcoat_normalmap_pars_fragment\x3e\n#include \x3croughnessmap_pars_fragment\x3e\n#include \x3cmetalnessmap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\tReflectedLight reflectedLight \x3d ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance \x3d emissive;\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_fragment\x3e\n\t#include \x3ccolor_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\t#include \x3croughnessmap_fragment\x3e\n\t#include \x3cmetalnessmap_fragment\x3e\n\t#include \x3cnormal_fragment_begin\x3e\n\t#include \x3cnormal_fragment_maps\x3e\n\t#include \x3cclearcoat_normal_fragment_begin\x3e\n\t#include \x3cclearcoat_normal_fragment_maps\x3e\n\t#include \x3cemissivemap_fragment\x3e\n\t#include \x3clights_physical_fragment\x3e\n\t#include \x3clights_fragment_begin\x3e\n\t#include \x3clights_fragment_maps\x3e\n\t#include \x3clights_fragment_end\x3e\n\t#include \x3caomap_fragment\x3e\n\tvec3 outgoingLight \x3d reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#ifdef TRANSPARENCY\n\t\tdiffuseColor.a *\x3d saturate( 1. - transparency + linearToRelativeLuminance( reflectedLight.directSpecular + reflectedLight.indirectSpecular ) );\n\t#endif\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3cdithering_fragment\x3e\n}",
meshphysical_vert:"#define STANDARD\nvarying vec3 vViewPosition;\n#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\n#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cuv2_pars_vertex\x3e\n#include \x3cdisplacementmap_pars_vertex\x3e\n#include \x3ccolor_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3cshadowmap_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cuv2_vertex\x3e\n\t#include \x3ccolor_vertex\x3e\n\t#include \x3cbeginnormal_vertex\x3e\n\t#include \x3cmorphnormal_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#include \x3cskinnormal_vertex\x3e\n\t#include \x3cdefaultnormal_vertex\x3e\n#ifndef FLAT_SHADED\n\tvNormal \x3d normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent \x3d normalize( transformedTangent );\n\t\tvBitangent \x3d normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cdisplacementmap_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\tvViewPosition \x3d - mvPosition.xyz;\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cshadowmap_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}",
normal_frag:"#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#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\n#include \x3cpacking\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cbumpmap_pars_fragment\x3e\n#include \x3cnormalmap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cnormal_fragment_begin\x3e\n\t#include \x3cnormal_fragment_maps\x3e\n\tgl_FragColor \x3d vec4( packNormalToRGB( normal ), opacity );\n}",
normal_vert:"#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#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\n#include \x3cuv_pars_vertex\x3e\n#include \x3cdisplacementmap_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cbeginnormal_vertex\x3e\n\t#include \x3cmorphnormal_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#include \x3cskinnormal_vertex\x3e\n\t#include \x3cdefaultnormal_vertex\x3e\n#ifndef FLAT_SHADED\n\tvNormal \x3d normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent \x3d normalize( transformedTangent );\n\t\tvBitangent \x3d normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cdisplacementmap_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvViewPosition \x3d - mvPosition.xyz;\n#endif\n}",
points_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include \x3ccommon\x3e\n#include \x3ccolor_pars_fragment\x3e\n#include \x3cmap_particle_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec3 outgoingLight \x3d vec3( 0.0 );\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_particle_fragment\x3e\n\t#include \x3ccolor_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\toutgoingLight \x3d diffuseColor.rgb;\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n}",
points_vert:"uniform float size;\nuniform float scale;\n#include \x3ccommon\x3e\n#include \x3ccolor_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3ccolor_vertex\x3e\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\tgl_PointSize \x3d size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective \x3d ( projectionMatrix[ 2 ][ 3 ] \x3d\x3d - 1.0 );\n\t\tif ( isPerspective ) gl_PointSize *\x3d ( scale / - mvPosition.z );\n\t#endif\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}",
shadow_frag:"uniform vec3 color;\nuniform float opacity;\n#include \x3ccommon\x3e\n#include \x3cpacking\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3cbsdfs\x3e\n#include \x3clights_pars_begin\x3e\n#include \x3cshadowmap_pars_fragment\x3e\n#include \x3cshadowmask_pars_fragment\x3e\nvoid main() {\n\tgl_FragColor \x3d vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include \x3cfog_fragment\x3e\n}",shadow_vert:"#include \x3cfog_pars_vertex\x3e\n#include \x3cshadowmap_pars_vertex\x3e\nvoid main() {\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cshadowmap_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}",
sprite_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include \x3ccommon\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec3 outgoingLight \x3d vec3( 0.0 );\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\toutgoingLight \x3d diffuseColor.rgb;\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n}",
sprite_vert:"uniform float rotation;\nuniform vec2 center;\n#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\tvec4 mvPosition \x3d modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x \x3d length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y \x3d length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective \x3d ( projectionMatrix[ 2 ][ 3 ] \x3d\x3d - 1.0 );\n\t\tif ( isPerspective ) scale *\x3d - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition \x3d ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x \x3d cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y \x3d sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy +\x3d rotatedPosition;\n\tgl_Position \x3d projectionMatrix * mvPosition;\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}"},
Wa={common:{diffuse:{value:new I(15658734)},opacity:{value:1},map:{value:null},uvTransform:{value:new t},alphaMap:{value:null}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},refractionRatio:{value:.98},maxMipLevel:{value:0}},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 f(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:2.5E-4},fogNear:{value:1},fogFar:{value:2E3},fogColor:{value:new I(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{},shadow:{},shadowBias:{},
shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{},shadow:{},shadowBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{},shadow:{},shadowBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},
pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}}},points:{diffuse:{value:new I(15658734)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},uvTransform:{value:new t}},sprite:{diffuse:{value:new I(15658734)},opacity:{value:1},center:{value:new f(.5,.5)},rotation:{value:0},map:{value:null},uvTransform:{value:new t}}},Mc=
{basic:{uniforms:Bb([Wa.common,Wa.specularmap,Wa.envmap,Wa.aomap,Wa.lightmap,Wa.fog]),vertexShader:rb.meshbasic_vert,fragmentShader:rb.meshbasic_frag},lambert:{uniforms:Bb([Wa.common,Wa.specularmap,Wa.envmap,Wa.aomap,Wa.lightmap,Wa.emissivemap,Wa.fog,Wa.lights,{emissive:{value:new I(0)}}]),vertexShader:rb.meshlambert_vert,fragmentShader:rb.meshlambert_frag},phong:{uniforms:Bb([Wa.common,Wa.specularmap,Wa.envmap,Wa.aomap,Wa.lightmap,Wa.emissivemap,Wa.bumpmap,Wa.normalmap,Wa.displacementmap,Wa.gradientmap,
Wa.fog,Wa.lights,{emissive:{value:new I(0)},specular:{value:new I(1118481)},shininess:{value:30}}]),vertexShader:rb.meshphong_vert,fragmentShader:rb.meshphong_frag},standard:{uniforms:Bb([Wa.common,Wa.envmap,Wa.aomap,Wa.lightmap,Wa.emissivemap,Wa.bumpmap,Wa.normalmap,Wa.displacementmap,Wa.roughnessmap,Wa.metalnessmap,Wa.fog,Wa.lights,{emissive:{value:new I(0)},roughness:{value:.5},metalness:{value:.5},envMapIntensity:{value:1}}]),vertexShader:rb.meshphysical_vert,fragmentShader:rb.meshphysical_frag},
matcap:{uniforms:Bb([Wa.common,Wa.bumpmap,Wa.normalmap,Wa.displacementmap,Wa.fog,{matcap:{value:null}}]),vertexShader:rb.meshmatcap_vert,fragmentShader:rb.meshmatcap_frag},points:{uniforms:Bb([Wa.points,Wa.fog]),vertexShader:rb.points_vert,fragmentShader:rb.points_frag},dashed:{uniforms:Bb([Wa.common,Wa.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:rb.linedashed_vert,fragmentShader:rb.linedashed_frag},depth:{uniforms:Bb([Wa.common,Wa.displacementmap]),vertexShader:rb.depth_vert,
fragmentShader:rb.depth_frag},normal:{uniforms:Bb([Wa.common,Wa.bumpmap,Wa.normalmap,Wa.displacementmap,{opacity:{value:1}}]),vertexShader:rb.normal_vert,fragmentShader:rb.normal_frag},sprite:{uniforms:Bb([Wa.sprite,Wa.fog]),vertexShader:rb.sprite_vert,fragmentShader:rb.sprite_frag},background:{uniforms:{uvTransform:{value:new t},t2D:{value:null}},vertexShader:rb.background_vert,fragmentShader:rb.background_frag},cube:{uniforms:{tCube:{value:null},tFlip:{value:-1},opacity:{value:1}},vertexShader:rb.cube_vert,
fragmentShader:rb.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:rb.equirect_vert,fragmentShader:rb.equirect_frag},distanceRGBA:{uniforms:Bb([Wa.common,Wa.displacementmap,{referencePosition:{value:new k},nearDistance:{value:1},farDistance:{value:1E3}}]),vertexShader:rb.distanceRGBA_vert,fragmentShader:rb.distanceRGBA_frag},shadow:{uniforms:Bb([Wa.lights,Wa.fog,{color:{value:new I(0)},opacity:{value:1}}]),vertexShader:rb.shadow_vert,fragmentShader:rb.shadow_frag}};Mc.physical=
{uniforms:Bb([Mc.standard.uniforms,{transparency:{value:0},clearcoat:{value:0},clearcoatRoughness:{value:0},sheen:{value:new I(0)},clearcoatNormalScale:{value:new f(1,1)},clearcoatNormalMap:{value:null}}]),vertexShader:rb.meshphysical_vert,fragmentShader:rb.meshphysical_frag};rd.prototype=Object.create(ya.prototype);rd.prototype.constructor=rd;Lc.prototype=Object.create(va.prototype);Lc.prototype.constructor=Lc;cd.prototype=Object.create(l.prototype);cd.prototype.constructor=cd;cd.prototype.isCubeTexture=
!0;Object.defineProperty(cd.prototype,"images",{get:function(){return this.image},set:function(a){this.image=a}});re.prototype=Object.create(l.prototype);re.prototype.constructor=re;re.prototype.isDataTexture2DArray=!0;se.prototype=Object.create(l.prototype);se.prototype.constructor=se;se.prototype.isDataTexture3D=!0;var ij=new l,el=new re,gl=new se,jj=new cd,cj=[],ej=[],hj=new Float32Array(16),gj=new Float32Array(9),fj=new Float32Array(4);kj.prototype.updateCache=function(a){var c=this.cache;a instanceof
Float32Array&&c.length!==a.length&&(this.cache=new Float32Array(a.length));mc(c,a)};lj.prototype.setValue=function(a,c,e){for(var g=this.seq,r=0,v=g.length;r!==v;++r){var z=g[r];z.setValue(a,c[z.id],e)}};var Lh=/([\w\d_]+)(\])?(\[|\.)?/g;ud.prototype.setValue=function(a,c,e,g){c=this.map[c];void 0!==c&&c.setValue(a,e,g)};ud.prototype.setOptional=function(a,c,e){c=c[e];void 0!==c&&this.setValue(a,e,c)};ud.upload=function(a,c,e,g){for(var r=0,v=c.length;r!==v;++r){var z=c[r],E=e[z.id];!1!==E.needsUpdate&&
z.setValue(a,E.value,g)}};ud.seqWithValue=function(a,c){for(var e=[],g=0,r=a.length;g!==r;++g){var v=a[g];v.id in c&&e.push(v)}return e};var Kl=0,Tl=0;vd.prototype=Object.create(M.prototype);vd.prototype.constructor=vd;vd.prototype.isMeshDepthMaterial=!0;vd.prototype.copy=function(a){M.prototype.copy.call(this,a);this.depthPacking=a.depthPacking;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.map=a.map;this.alphaMap=a.alphaMap;this.displacementMap=a.displacementMap;this.displacementScale=
a.displacementScale;this.displacementBias=a.displacementBias;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;return this};wd.prototype=Object.create(M.prototype);wd.prototype.constructor=wd;wd.prototype.isMeshDistanceMaterial=!0;wd.prototype.copy=function(a){M.prototype.copy.call(this,a);this.referencePosition.copy(a.referencePosition);this.nearDistance=a.nearDistance;this.farDistance=a.farDistance;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.map=a.map;this.alphaMap=
a.alphaMap;this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;return this};ue.prototype=Object.assign(Object.create(A.prototype),{constructor:ue,isGroup:!0});vf.prototype=Object.assign(Object.create(vb.prototype),{constructor:vf,isArrayCamera:!0});var yj=new k,zj=new k;Object.assign(Nh.prototype,d.prototype);Object.assign(Aj.prototype,d.prototype);Object.assign(zg.prototype,{isFogExp2:!0,clone:function(){return new zg(this.color,
this.density)},toJSON:function(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}});Object.assign(Ag.prototype,{isFog:!0,clone:function(){return new Ag(this.color,this.near,this.far)},toJSON:function(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}});Object.defineProperty(Qd.prototype,"needsUpdate",{set:function(a){!0===a&&this.version++}});Object.assign(Qd.prototype,{isInterleavedBuffer:!0,onUploadCallback:function(){},setArray:function(a){if(Array.isArray(a))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");
this.count=void 0!==a?a.length/this.stride:0;this.array=a;return this},setDynamic:function(a){this.dynamic=a;return this},copy:function(a){this.array=new a.array.constructor(a.array);this.count=a.count;this.stride=a.stride;this.dynamic=a.dynamic;return this},copyAt:function(a,c,e){a*=this.stride;e*=c.stride;for(var g=0,r=this.stride;g<r;g++)this.array[a+g]=c.array[e+g];return this},set:function(a,c){void 0===c&&(c=0);this.array.set(a,c);return this},clone:function(){return(new this.constructor).copy(this)},
onUpload:function(a){this.onUploadCallback=a;return this}});Object.defineProperties(xf.prototype,{count:{get:function(){return this.data.count}},array:{get:function(){return this.data.array}}});Object.assign(xf.prototype,{isInterleavedBufferAttribute:!0,setX:function(a,c){this.data.array[a*this.data.stride+this.offset]=c;return this},setY:function(a,c){this.data.array[a*this.data.stride+this.offset+1]=c;return this},setZ:function(a,c){this.data.array[a*this.data.stride+this.offset+2]=c;return this},
setW:function(a,c){this.data.array[a*this.data.stride+this.offset+3]=c;return this},getX:function(a){return this.data.array[a*this.data.stride+this.offset]},getY:function(a){return this.data.array[a*this.data.stride+this.offset+1]},getZ:function(a){return this.data.array[a*this.data.stride+this.offset+2]},getW:function(a){return this.data.array[a*this.data.stride+this.offset+3]},setXY:function(a,c,e){a=a*this.data.stride+this.offset;this.data.array[a+0]=c;this.data.array[a+1]=e;return this},setXYZ:function(a,
c,e,g){a=a*this.data.stride+this.offset;this.data.array[a+0]=c;this.data.array[a+1]=e;this.data.array[a+2]=g;return this},setXYZW:function(a,c,e,g,r){a=a*this.data.stride+this.offset;this.data.array[a+0]=c;this.data.array[a+1]=e;this.data.array[a+2]=g;this.data.array[a+3]=r;return this}});Ad.prototype=Object.create(M.prototype);Ad.prototype.constructor=Ad;Ad.prototype.isSpriteMaterial=!0;Ad.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);this.map=a.map;this.rotation=
a.rotation;this.sizeAttenuation=a.sizeAttenuation;return this};var Ae,mg=new k,nf=new k,of=new k,Be=new f,zf=new f,Fj=new q,qh=new k,ng=new k,rh=new k,kk=new f,Ki=new f,lk=new f;yf.prototype=Object.assign(Object.create(A.prototype),{constructor:yf,isSprite:!0,raycast:function(a,c){null===a.camera&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.');nf.setFromMatrixScale(this.matrixWorld);Fj.copy(a.camera.matrixWorld);this.modelViewMatrix.multiplyMatrices(a.camera.matrixWorldInverse,
this.matrixWorld);of.setFromMatrixPosition(this.modelViewMatrix);a.camera.isPerspectiveCamera&&!1===this.material.sizeAttenuation&&nf.multiplyScalar(-of.z);var e=this.material.rotation;if(0!==e){var g=Math.cos(e);var r=Math.sin(e)}e=this.center;Bg(qh.set(-.5,-.5,0),of,e,nf,r,g);Bg(ng.set(.5,-.5,0),of,e,nf,r,g);Bg(rh.set(.5,.5,0),of,e,nf,r,g);kk.set(0,0);Ki.set(1,0);lk.set(1,1);var v=a.ray.intersectTriangle(qh,ng,rh,!1,mg);if(null===v&&(Bg(ng.set(-.5,.5,0),of,e,nf,r,g),Ki.set(0,1),v=a.ray.intersectTriangle(qh,
rh,ng,!1,mg),null===v))return;r=a.ray.origin.distanceTo(mg);r<a.near||r>a.far||c.push({distance:r,point:mg.clone(),uv:B.getUV(mg,qh,ng,rh,kk,Ki,lk,new f),face:null,object:this})},clone:function(){return(new this.constructor(this.material)).copy(this)},copy:function(a){A.prototype.copy.call(this,a);void 0!==a.center&&this.center.copy(a.center);return this}});var sh=new k,mk=new k;Af.prototype=Object.assign(Object.create(A.prototype),{constructor:Af,isLOD:!0,copy:function(a){A.prototype.copy.call(this,
a,!1);a=a.levels;for(var c=0,e=a.length;c<e;c++){var g=a[c];this.addLevel(g.object.clone(),g.distance)}return this},addLevel:function(a,c){void 0===c&&(c=0);c=Math.abs(c);for(var e=this.levels,g=0;g<e.length&&!(c<e[g].distance);g++);e.splice(g,0,{distance:c,object:a});this.add(a);return this},getObjectForDistance:function(a){for(var c=this.levels,e=1,g=c.length;e<g&&!(a<c[e].distance);e++);return c[e-1].object},raycast:function(a,c){sh.setFromMatrixPosition(this.matrixWorld);this.getObjectForDistance(a.ray.origin.distanceTo(sh)).raycast(a,
c)},update:function(a){var c=this.levels;if(1<c.length){sh.setFromMatrixPosition(a.matrixWorld);mk.setFromMatrixPosition(this.matrixWorld);a=sh.distanceTo(mk);c[0].object.visible=!0;for(var e=1,g=c.length;e<g;e++)if(a>=c[e].distance)c[e-1].object.visible=!1,c[e].object.visible=!0;else break;for(;e<g;e++)c[e].object.visible=!1}},toJSON:function(a){a=A.prototype.toJSON.call(this,a);a.object.levels=[];for(var c=this.levels,e=0,g=c.length;e<g;e++){var r=c[e];a.object.levels.push({object:r.object.uuid,
distance:r.distance})}return a}});Bf.prototype=Object.assign(Object.create(xa.prototype),{constructor:Bf,isSkinnedMesh:!0,bind:function(a,c){this.skeleton=a;void 0===c&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),c=this.matrixWorld);this.bindMatrix.copy(c);this.bindMatrixInverse.getInverse(c)},pose:function(){this.skeleton.pose()},normalizeSkinWeights:function(){for(var a=new p,c=this.geometry.attributes.skinWeight,e=0,g=c.count;e<g;e++){a.x=c.getX(e);a.y=c.getY(e);a.z=c.getZ(e);
a.w=c.getW(e);var r=1/a.manhattanLength();Infinity!==r?a.multiplyScalar(r):a.set(1,0,0,0);c.setXYZW(e,a.x,a.y,a.z,a.w)}},updateMatrixWorld:function(a){xa.prototype.updateMatrixWorld.call(this,a);"attached"===this.bindMode?this.bindMatrixInverse.getInverse(this.matrixWorld):"detached"===this.bindMode?this.bindMatrixInverse.getInverse(this.bindMatrix):console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)},clone:function(){return(new this.constructor(this.geometry,this.material)).copy(this)}});
var nk=new q,Im=new q;Object.assign(Cg.prototype,{calculateInverses:function(){this.boneInverses=[];for(var a=0,c=this.bones.length;a<c;a++){var e=new q;this.bones[a]&&e.getInverse(this.bones[a].matrixWorld);this.boneInverses.push(e)}},pose:function(){var a,c;var e=0;for(c=this.bones.length;e<c;e++)(a=this.bones[e])&&a.matrixWorld.getInverse(this.boneInverses[e]);e=0;for(c=this.bones.length;e<c;e++)if(a=this.bones[e])a.parent&&a.parent.isBone?(a.matrix.getInverse(a.parent.matrixWorld),a.matrix.multiply(a.matrixWorld)):
a.matrix.copy(a.matrixWorld),a.matrix.decompose(a.position,a.quaternion,a.scale)},update:function(){for(var a=this.bones,c=this.boneInverses,e=this.boneMatrices,g=this.boneTexture,r=0,v=a.length;r<v;r++)nk.multiplyMatrices(a[r]?a[r].matrixWorld:Im,c[r]),nk.toArray(e,16*r);void 0!==g&&(g.needsUpdate=!0)},clone:function(){return new Cg(this.bones,this.boneInverses)},getBoneByName:function(a){for(var c=0,e=this.bones.length;c<e;c++){var g=this.bones[c];if(g.name===a)return g}}});Uh.prototype=Object.assign(Object.create(A.prototype),
{constructor:Uh,isBone:!0});Fb.prototype=Object.create(M.prototype);Fb.prototype.constructor=Fb;Fb.prototype.isLineBasicMaterial=!0;Fb.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);this.linewidth=a.linewidth;this.linecap=a.linecap;this.linejoin=a.linejoin;return this};var ok=new k,pk=new k,qk=new q,th=new D,og=new G;Vb.prototype=Object.assign(Object.create(A.prototype),{constructor:Vb,isLine:!0,computeLineDistances:function(){var a=this.geometry;if(a.isBufferGeometry)if(null===
a.index){for(var c=a.attributes.position,e=[0],g=1,r=c.count;g<r;g++)ok.fromBufferAttribute(c,g-1),pk.fromBufferAttribute(c,g),e[g]=e[g-1],e[g]+=ok.distanceTo(pk);a.addAttribute("lineDistance",new ca(e,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else if(a.isGeometry)for(c=a.vertices,e=a.lineDistances,e[0]=0,g=1,r=c.length;g<r;g++)e[g]=e[g-1],e[g]+=c[g-1].distanceTo(c[g]);return this},raycast:function(a,c){var e=a.linePrecision,
g=this.geometry,r=this.matrixWorld;null===g.boundingSphere&&g.computeBoundingSphere();og.copy(g.boundingSphere);og.applyMatrix4(r);og.radius+=e;if(!1!==a.ray.intersectsSphere(og)){qk.getInverse(r);th.copy(a.ray).applyMatrix4(qk);e/=(this.scale.x+this.scale.y+this.scale.z)/3;e*=e;var v=new k,z=new k;r=new k;var E=new k,F=this&&this.isLineSegments?2:1;if(g.isBufferGeometry){var J=g.index,P=g.attributes.position.array;if(null!==J){J=J.array;g=0;for(var R=J.length-1;g<R;g+=F){var S=J[g+1];v.fromArray(P,
3*J[g]);z.fromArray(P,3*S);S=th.distanceSqToSegment(v,z,E,r);S>e||(E.applyMatrix4(this.matrixWorld),S=a.ray.origin.distanceTo(E),S<a.near||S>a.far||c.push({distance:S,point:r.clone().applyMatrix4(this.matrixWorld),index:g,face:null,faceIndex:null,object:this}))}}else for(g=0,R=P.length/3-1;g<R;g+=F)v.fromArray(P,3*g),z.fromArray(P,3*g+3),S=th.distanceSqToSegment(v,z,E,r),S>e||(E.applyMatrix4(this.matrixWorld),S=a.ray.origin.distanceTo(E),S<a.near||S>a.far||c.push({distance:S,point:r.clone().applyMatrix4(this.matrixWorld),
index:g,face:null,faceIndex:null,object:this}))}else if(g.isGeometry)for(v=g.vertices,z=v.length,g=0;g<z-1;g+=F)S=th.distanceSqToSegment(v[g],v[g+1],E,r),S>e||(E.applyMatrix4(this.matrixWorld),S=a.ray.origin.distanceTo(E),S<a.near||S>a.far||c.push({distance:S,point:r.clone().applyMatrix4(this.matrixWorld),index:g,face:null,faceIndex:null,object:this}))}},clone:function(){return(new this.constructor(this.geometry,this.material)).copy(this)}});var uh=new k,vh=new k;Ib.prototype=Object.assign(Object.create(Vb.prototype),
{constructor:Ib,isLineSegments:!0,computeLineDistances:function(){var a=this.geometry;if(a.isBufferGeometry)if(null===a.index){for(var c=a.attributes.position,e=[],g=0,r=c.count;g<r;g+=2)uh.fromBufferAttribute(c,g),vh.fromBufferAttribute(c,g+1),e[g]=0===g?0:e[g-1],e[g+1]=e[g]+uh.distanceTo(vh);a.addAttribute("lineDistance",new ca(e,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else if(a.isGeometry)for(c=a.vertices,e=
a.lineDistances,g=0,r=c.length;g<r;g+=2)uh.copy(c[g]),vh.copy(c[g+1]),e[g]=0===g?0:e[g-1],e[g+1]=e[g]+uh.distanceTo(vh);return this}});Dg.prototype=Object.assign(Object.create(Vb.prototype),{constructor:Dg,isLineLoop:!0});Ac.prototype=Object.create(M.prototype);Ac.prototype.constructor=Ac;Ac.prototype.isPointsMaterial=!0;Ac.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);this.map=a.map;this.size=a.size;this.sizeAttenuation=a.sizeAttenuation;this.morphTargets=a.morphTargets;
return this};var rk=new q,Wh=new D,pg=new G,wh=new k;Ce.prototype=Object.assign(Object.create(A.prototype),{constructor:Ce,isPoints:!0,raycast:function(a,c){var e=this.geometry,g=this.matrixWorld,r=a.params.Points.threshold;null===e.boundingSphere&&e.computeBoundingSphere();pg.copy(e.boundingSphere);pg.applyMatrix4(g);pg.radius+=r;if(!1!==a.ray.intersectsSphere(pg))if(rk.getInverse(g),Wh.copy(a.ray).applyMatrix4(rk),r/=(this.scale.x+this.scale.y+this.scale.z)/3,r*=r,e.isBufferGeometry){var v=e.index;
e=e.attributes.position.array;if(null!==v){var z=v.array;v=0;for(var E=z.length;v<E;v++){var F=z[v];wh.fromArray(e,3*F);Vh(wh,F,r,g,a,c,this)}}else for(v=0,z=e.length/3;v<z;v++)wh.fromArray(e,3*v),Vh(wh,v,r,g,a,c,this)}else for(e=e.vertices,v=0,z=e.length;v<z;v++)Vh(e[v],v,r,g,a,c,this)},updateMorphTargets:function(){var a=this.geometry;if(a.isBufferGeometry){a=a.morphAttributes;var c=Object.keys(a);if(0<c.length){var e=a[c[0]];if(void 0!==e)for(this.morphTargetInfluences=[],this.morphTargetDictionary=
{},a=0,c=e.length;a<c;a++){var g=e[a].name||String(a);this.morphTargetInfluences.push(0);this.morphTargetDictionary[g]=a}}}else a=a.morphTargets,void 0!==a&&0<a.length&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")},clone:function(){return(new this.constructor(this.geometry,this.material)).copy(this)}});Xh.prototype=Object.assign(Object.create(l.prototype),{constructor:Xh,isVideoTexture:!0,update:function(){var a=this.image;a.readyState>=
a.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}});De.prototype=Object.create(l.prototype);De.prototype.constructor=De;De.prototype.isCompressedTexture=!0;Cf.prototype=Object.create(l.prototype);Cf.prototype.constructor=Cf;Cf.prototype.isCanvasTexture=!0;Df.prototype=Object.create(l.prototype);Df.prototype.constructor=Df;Df.prototype.isDepthTexture=!0;Ee.prototype=Object.create(va.prototype);Ee.prototype.constructor=Ee;Ef.prototype=Object.create(ya.prototype);Ef.prototype.constructor=Ef;Fe.prototype=Object.create(va.prototype);
Fe.prototype.constructor=Fe;Ff.prototype=Object.create(ya.prototype);Ff.prototype.constructor=Ff;jc.prototype=Object.create(va.prototype);jc.prototype.constructor=jc;Gf.prototype=Object.create(ya.prototype);Gf.prototype.constructor=Gf;Ge.prototype=Object.create(jc.prototype);Ge.prototype.constructor=Ge;Hf.prototype=Object.create(ya.prototype);Hf.prototype.constructor=Hf;Rd.prototype=Object.create(jc.prototype);Rd.prototype.constructor=Rd;If.prototype=Object.create(ya.prototype);If.prototype.constructor=
If;He.prototype=Object.create(jc.prototype);He.prototype.constructor=He;Jf.prototype=Object.create(ya.prototype);Jf.prototype.constructor=Jf;Ie.prototype=Object.create(jc.prototype);Ie.prototype.constructor=Ie;Kf.prototype=Object.create(ya.prototype);Kf.prototype.constructor=Kf;Sd.prototype=Object.create(va.prototype);Sd.prototype.constructor=Sd;Sd.prototype.toJSON=function(){var a=va.prototype.toJSON.call(this);a.path=this.parameters.path.toJSON();return a};Lf.prototype=Object.create(ya.prototype);
Lf.prototype.constructor=Lf;Je.prototype=Object.create(va.prototype);Je.prototype.constructor=Je;Mf.prototype=Object.create(ya.prototype);Mf.prototype.constructor=Mf;Ke.prototype=Object.create(va.prototype);Ke.prototype.constructor=Ke;var Jm={triangulate:function(a,c,e){e=e||2;var g=c&&c.length,r=g?c[0]*e:a.length,v=Gj(a,0,r,e,!0),z=[];if(!v||v.next===v.prev)return z;g&&(v=dm(a,c,v,e));if(a.length>80*e){var E=c=a[0];var F=g=a[1];for(var J=e;J<r;J+=e){var P=a[J];var R=a[J+1];P<E&&(E=P);R<F&&(F=R);
P>c&&(c=P);R>g&&(g=R)}P=Math.max(c-E,g-F);P=0!==P?1/P:0}Pf(v,z,e,E,F,P);return z}},ed={area:function(a){for(var c=a.length,e=0,g=c-1,r=0;r<c;g=r++)e+=a[g].x*a[r].y-a[r].x*a[g].y;return.5*e},isClockWise:function(a){return 0>ed.area(a)},triangulateShape:function(a,c){var e=[],g=[],r=[];Kj(a);Lj(e,a);var v=a.length;c.forEach(Kj);for(a=0;a<c.length;a++)g.push(v),v+=c[a].length,Lj(e,c[a]);c=Jm.triangulate(e,g);for(a=0;a<c.length;a+=3)r.push(c.slice(a,a+3));return r}};Ud.prototype=Object.create(ya.prototype);
Ud.prototype.constructor=Ud;Ud.prototype.toJSON=function(){var a=ya.prototype.toJSON.call(this);return Mj(this.parameters.shapes,this.parameters.options,a)};Rc.prototype=Object.create(va.prototype);Rc.prototype.constructor=Rc;Rc.prototype.toJSON=function(){var a=va.prototype.toJSON.call(this);return Mj(this.parameters.shapes,this.parameters.options,a)};var lm={generateTopUV:function(a,c,e,g,r){a=c[3*g];g=c[3*g+1];var v=c[3*r];r=c[3*r+1];return[new f(c[3*e],c[3*e+1]),new f(a,g),new f(v,r)]},generateSideWallUV:function(a,
c,e,g,r,v){a=c[3*e];var z=c[3*e+1];e=c[3*e+2];var E=c[3*g],F=c[3*g+1];g=c[3*g+2];var J=c[3*r],P=c[3*r+1];r=c[3*r+2];var R=c[3*v],S=c[3*v+1];c=c[3*v+2];return.01>Math.abs(z-F)?[new f(a,1-e),new f(E,1-g),new f(J,1-r),new f(R,1-c)]:[new f(z,1-e),new f(F,1-g),new f(P,1-r),new f(S,1-c)]}};Rf.prototype=Object.create(ya.prototype);Rf.prototype.constructor=Rf;Me.prototype=Object.create(Rc.prototype);Me.prototype.constructor=Me;Sf.prototype=Object.create(ya.prototype);Sf.prototype.constructor=Sf;Bd.prototype=
Object.create(va.prototype);Bd.prototype.constructor=Bd;Tf.prototype=Object.create(ya.prototype);Tf.prototype.constructor=Tf;Ne.prototype=Object.create(va.prototype);Ne.prototype.constructor=Ne;Uf.prototype=Object.create(ya.prototype);Uf.prototype.constructor=Uf;Oe.prototype=Object.create(va.prototype);Oe.prototype.constructor=Oe;Vd.prototype=Object.create(ya.prototype);Vd.prototype.constructor=Vd;Vd.prototype.toJSON=function(){var a=ya.prototype.toJSON.call(this);return Nj(this.parameters.shapes,
a)};Wd.prototype=Object.create(va.prototype);Wd.prototype.constructor=Wd;Wd.prototype.toJSON=function(){var a=va.prototype.toJSON.call(this);return Nj(this.parameters.shapes,a)};Pe.prototype=Object.create(va.prototype);Pe.prototype.constructor=Pe;Xd.prototype=Object.create(ya.prototype);Xd.prototype.constructor=Xd;fd.prototype=Object.create(va.prototype);fd.prototype.constructor=fd;Vf.prototype=Object.create(Xd.prototype);Vf.prototype.constructor=Vf;Wf.prototype=Object.create(fd.prototype);Wf.prototype.constructor=
Wf;Xf.prototype=Object.create(ya.prototype);Xf.prototype.constructor=Xf;Qe.prototype=Object.create(va.prototype);Qe.prototype.constructor=Qe;var gc=Object.freeze({WireframeGeometry:Ee,ParametricGeometry:Ef,ParametricBufferGeometry:Fe,TetrahedronGeometry:Gf,TetrahedronBufferGeometry:Ge,OctahedronGeometry:Hf,OctahedronBufferGeometry:Rd,IcosahedronGeometry:If,IcosahedronBufferGeometry:He,DodecahedronGeometry:Jf,DodecahedronBufferGeometry:Ie,PolyhedronGeometry:Ff,PolyhedronBufferGeometry:jc,TubeGeometry:Kf,
TubeBufferGeometry:Sd,TorusKnotGeometry:Lf,TorusKnotBufferGeometry:Je,TorusGeometry:Mf,TorusBufferGeometry:Ke,TextGeometry:Rf,TextBufferGeometry:Me,SphereGeometry:Sf,SphereBufferGeometry:Bd,RingGeometry:Tf,RingBufferGeometry:Ne,PlaneGeometry:rd,PlaneBufferGeometry:Lc,LatheGeometry:Uf,LatheBufferGeometry:Oe,ShapeGeometry:Vd,ShapeBufferGeometry:Wd,ExtrudeGeometry:Ud,ExtrudeBufferGeometry:Rc,EdgesGeometry:Pe,ConeGeometry:Vf,ConeBufferGeometry:Wf,CylinderGeometry:Xd,CylinderBufferGeometry:fd,CircleGeometry:Xf,
CircleBufferGeometry:Qe,BoxGeometry:Sa,BoxBufferGeometry:Xa});Yd.prototype=Object.create(M.prototype);Yd.prototype.constructor=Yd;Yd.prototype.isShadowMaterial=!0;Yd.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);return this};Re.prototype=Object.create(qb.prototype);Re.prototype.constructor=Re;Re.prototype.isRawShaderMaterial=!0;Sc.prototype=Object.create(M.prototype);Sc.prototype.constructor=Sc;Sc.prototype.isMeshStandardMaterial=!0;Sc.prototype.copy=function(a){M.prototype.copy.call(this,
a);this.defines={STANDARD:""};this.color.copy(a.color);this.roughness=a.roughness;this.metalness=a.metalness;this.map=a.map;this.lightMap=a.lightMap;this.lightMapIntensity=a.lightMapIntensity;this.aoMap=a.aoMap;this.aoMapIntensity=a.aoMapIntensity;this.emissive.copy(a.emissive);this.emissiveMap=a.emissiveMap;this.emissiveIntensity=a.emissiveIntensity;this.bumpMap=a.bumpMap;this.bumpScale=a.bumpScale;this.normalMap=a.normalMap;this.normalMapType=a.normalMapType;this.normalScale.copy(a.normalScale);
this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;this.roughnessMap=a.roughnessMap;this.metalnessMap=a.metalnessMap;this.alphaMap=a.alphaMap;this.envMap=a.envMap;this.envMapIntensity=a.envMapIntensity;this.refractionRatio=a.refractionRatio;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.wireframeLinecap=a.wireframeLinecap;this.wireframeLinejoin=a.wireframeLinejoin;this.skinning=a.skinning;this.morphTargets=
a.morphTargets;this.morphNormals=a.morphNormals;return this};Zd.prototype=Object.create(Sc.prototype);Zd.prototype.constructor=Zd;Zd.prototype.isMeshPhysicalMaterial=!0;Zd.prototype.copy=function(a){Sc.prototype.copy.call(this,a);this.defines={STANDARD:"",PHYSICAL:""};this.reflectivity=a.reflectivity;this.clearcoat=a.clearcoat;this.clearcoatRoughness=a.clearcoatRoughness;this.sheen=a.sheen?(this.sheen||new I).copy(a.sheen):null;this.clearcoatNormalMap=a.clearcoatNormalMap;this.clearcoatNormalScale.copy(a.clearcoatNormalScale);
this.transparency=a.transparency;return this};Bc.prototype=Object.create(M.prototype);Bc.prototype.constructor=Bc;Bc.prototype.isMeshPhongMaterial=!0;Bc.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);this.specular.copy(a.specular);this.shininess=a.shininess;this.map=a.map;this.lightMap=a.lightMap;this.lightMapIntensity=a.lightMapIntensity;this.aoMap=a.aoMap;this.aoMapIntensity=a.aoMapIntensity;this.emissive.copy(a.emissive);this.emissiveMap=a.emissiveMap;this.emissiveIntensity=
a.emissiveIntensity;this.bumpMap=a.bumpMap;this.bumpScale=a.bumpScale;this.normalMap=a.normalMap;this.normalMapType=a.normalMapType;this.normalScale.copy(a.normalScale);this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;this.specularMap=a.specularMap;this.alphaMap=a.alphaMap;this.envMap=a.envMap;this.combine=a.combine;this.reflectivity=a.reflectivity;this.refractionRatio=a.refractionRatio;this.wireframe=a.wireframe;this.wireframeLinewidth=
a.wireframeLinewidth;this.wireframeLinecap=a.wireframeLinecap;this.wireframeLinejoin=a.wireframeLinejoin;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};$d.prototype=Object.create(Bc.prototype);$d.prototype.constructor=$d;$d.prototype.isMeshToonMaterial=!0;$d.prototype.copy=function(a){Bc.prototype.copy.call(this,a);this.gradientMap=a.gradientMap;return this};ae.prototype=Object.create(M.prototype);ae.prototype.constructor=ae;ae.prototype.isMeshNormalMaterial=
!0;ae.prototype.copy=function(a){M.prototype.copy.call(this,a);this.bumpMap=a.bumpMap;this.bumpScale=a.bumpScale;this.normalMap=a.normalMap;this.normalMapType=a.normalMapType;this.normalScale.copy(a.normalScale);this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};
be.prototype=Object.create(M.prototype);be.prototype.constructor=be;be.prototype.isMeshLambertMaterial=!0;be.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);this.map=a.map;this.lightMap=a.lightMap;this.lightMapIntensity=a.lightMapIntensity;this.aoMap=a.aoMap;this.aoMapIntensity=a.aoMapIntensity;this.emissive.copy(a.emissive);this.emissiveMap=a.emissiveMap;this.emissiveIntensity=a.emissiveIntensity;this.specularMap=a.specularMap;this.alphaMap=a.alphaMap;this.envMap=
a.envMap;this.combine=a.combine;this.reflectivity=a.reflectivity;this.refractionRatio=a.refractionRatio;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.wireframeLinecap=a.wireframeLinecap;this.wireframeLinejoin=a.wireframeLinejoin;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};ce.prototype=Object.create(M.prototype);ce.prototype.constructor=ce;ce.prototype.isMeshMatcapMaterial=!0;ce.prototype.copy=function(a){M.prototype.copy.call(this,
a);this.defines={MATCAP:""};this.color.copy(a.color);this.matcap=a.matcap;this.map=a.map;this.bumpMap=a.bumpMap;this.bumpScale=a.bumpScale;this.normalMap=a.normalMap;this.normalMapType=a.normalMapType;this.normalScale.copy(a.normalScale);this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;this.alphaMap=a.alphaMap;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};de.prototype=
Object.create(Fb.prototype);de.prototype.constructor=de;de.prototype.isLineDashedMaterial=!0;de.prototype.copy=function(a){Fb.prototype.copy.call(this,a);this.scale=a.scale;this.dashSize=a.dashSize;this.gapSize=a.gapSize;return this};var Km=Object.freeze({ShadowMaterial:Yd,SpriteMaterial:Ad,RawShaderMaterial:Re,ShaderMaterial:qb,PointsMaterial:Ac,MeshPhysicalMaterial:Zd,MeshStandardMaterial:Sc,MeshPhongMaterial:Bc,MeshToonMaterial:$d,MeshNormalMaterial:ae,MeshLambertMaterial:be,MeshDepthMaterial:vd,
MeshDistanceMaterial:wd,MeshBasicMaterial:L,MeshMatcapMaterial:ce,LineDashedMaterial:de,LineBasicMaterial:Fb,Material:M}),Tb={arraySlice:function(a,c,e){return Tb.isTypedArray(a)?new a.constructor(a.subarray(c,void 0!==e?e:a.length)):a.slice(c,e)},convertArray:function(a,c,e){return!a||!e&&a.constructor===c?a:"number"===typeof c.BYTES_PER_ELEMENT?new c(a):Array.prototype.slice.call(a)},isTypedArray:function(a){return ArrayBuffer.isView(a)&&!(a instanceof DataView)},getKeyframeOrder:function(a){for(var c=
a.length,e=Array(c),g=0;g!==c;++g)e[g]=g;e.sort(function(r,v){return a[r]-a[v]});return e},sortedArray:function(a,c,e){for(var g=a.length,r=new a.constructor(g),v=0,z=0;z!==g;++v)for(var E=e[v]*c,F=0;F!==c;++F)r[z++]=a[E+F];return r},flattenJSON:function(a,c,e,g){for(var r=1,v=a[0];void 0!==v&&void 0===v[g];)v=a[r++];if(void 0!==v){var z=v[g];if(void 0!==z)if(Array.isArray(z)){do z=v[g],void 0!==z&&(c.push(v.time),e.push.apply(e,z)),v=a[r++];while(void 0!==v)}else if(void 0!==z.toArray){do z=v[g],
void 0!==z&&(c.push(v.time),z.toArray(e,e.length)),v=a[r++];while(void 0!==v)}else{do z=v[g],void 0!==z&&(c.push(v.time),e.push(z)),v=a[r++];while(void 0!==v)}}}};Object.assign(oc.prototype,{evaluate:function(a){var c=this.parameterPositions,e=this._cachedIndex,g=c[e],r=c[e-1];a:{b:{c:{d:if(!(a<g)){for(var v=e+2;;){if(void 0===g){if(a<r)break d;this._cachedIndex=e=c.length;return this.afterEnd_(e-1,a,r)}if(e===v)break;r=g;g=c[++e];if(a<g)break b}g=c.length;break c}if(a>=r)break a;else{v=c[1];a<v&&
(e=2,r=v);for(v=e-2;;){if(void 0===r)return this._cachedIndex=0,this.beforeStart_(0,a,g);if(e===v)break;g=r;r=c[--e-1];if(a>=r)break b}g=e;e=0}}for(;e<g;)r=e+g>>>1,a<c[r]?g=r:e=r+1;g=c[e];r=c[e-1];if(void 0===r)return this._cachedIndex=0,this.beforeStart_(0,a,g);if(void 0===g)return this._cachedIndex=e=c.length,this.afterEnd_(e-1,r,a)}this._cachedIndex=e;this.intervalChanged_(e,r,g)}return this.interpolate_(e,r,a,g)},settings:null,DefaultSettings_:{},getSettings_:function(){return this.settings||
this.DefaultSettings_},copySampleValue_:function(a){var c=this.resultBuffer,e=this.sampleValues,g=this.valueSize;a*=g;for(var r=0;r!==g;++r)c[r]=e[a+r];return c},interpolate_:function(){throw Error("call to abstract method");},intervalChanged_:function(){}});Object.assign(oc.prototype,{beforeStart_:oc.prototype.copySampleValue_,afterEnd_:oc.prototype.copySampleValue_});Eg.prototype=Object.assign(Object.create(oc.prototype),{constructor:Eg,DefaultSettings_:{endingStart:2400,endingEnd:2400},intervalChanged_:function(a,
c,e){var g=this.parameterPositions,r=a-2,v=a+1,z=g[r],E=g[v];if(void 0===z)switch(this.getSettings_().endingStart){case 2401:r=a;z=2*c-e;break;case 2402:r=g.length-2;z=c+g[r]-g[r+1];break;default:r=a,z=e}if(void 0===E)switch(this.getSettings_().endingEnd){case 2401:v=a;E=2*e-c;break;case 2402:v=1;E=e+g[1]-g[0];break;default:v=a-1,E=c}a=.5*(e-c);g=this.valueSize;this._weightPrev=a/(c-z);this._weightNext=a/(E-e);this._offsetPrev=r*g;this._offsetNext=v*g},interpolate_:function(a,c,e,g){var r=this.resultBuffer,
v=this.sampleValues,z=this.valueSize;a*=z;var E=a-z,F=this._offsetPrev,J=this._offsetNext,P=this._weightPrev,R=this._weightNext,S=(e-c)/(g-c);e=S*S;g=e*S;c=-P*g+2*P*e-P*S;P=(1+P)*g+(-1.5-2*P)*e+(-.5+P)*S+1;S=(-1-R)*g+(1.5+R)*e+.5*S;R=R*g-R*e;for(e=0;e!==z;++e)r[e]=c*v[F+e]+P*v[E+e]+S*v[a+e]+R*v[J+e];return r}});Yf.prototype=Object.assign(Object.create(oc.prototype),{constructor:Yf,interpolate_:function(a,c,e,g){var r=this.resultBuffer,v=this.sampleValues,z=this.valueSize;a*=z;var E=a-z;c=(e-c)/(g-
c);e=1-c;for(g=0;g!==z;++g)r[g]=v[E+g]*e+v[a+g]*c;return r}});Fg.prototype=Object.assign(Object.create(oc.prototype),{constructor:Fg,interpolate_:function(a){return this.copySampleValue_(a-1)}});Object.assign(Xb,{toJSON:function(a){var c=a.constructor;if(void 0!==c.toJSON)c=c.toJSON(a);else{c={name:a.name,times:Tb.convertArray(a.times,Array),values:Tb.convertArray(a.values,Array)};var e=a.getInterpolation();e!==a.DefaultInterpolation&&(c.interpolation=e)}c.type=a.ValueTypeName;return c}});Object.assign(Xb.prototype,
{constructor:Xb,TimeBufferType:Float32Array,ValueBufferType:Float32Array,DefaultInterpolation:2301,InterpolantFactoryMethodDiscrete:function(a){return new Fg(this.times,this.values,this.getValueSize(),a)},InterpolantFactoryMethodLinear:function(a){return new Yf(this.times,this.values,this.getValueSize(),a)},InterpolantFactoryMethodSmooth:function(a){return new Eg(this.times,this.values,this.getValueSize(),a)},setInterpolation:function(a){switch(a){case 2300:var c=this.InterpolantFactoryMethodDiscrete;
break;case 2301:c=this.InterpolantFactoryMethodLinear;break;case 2302:c=this.InterpolantFactoryMethodSmooth}if(void 0===c){c="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(void 0===this.createInterpolant)if(a!==this.DefaultInterpolation)this.setInterpolation(this.DefaultInterpolation);else throw Error(c);console.warn("THREE.KeyframeTrack:",c);return this}this.createInterpolant=c;return this},getInterpolation:function(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return 2300;
case this.InterpolantFactoryMethodLinear:return 2301;case this.InterpolantFactoryMethodSmooth:return 2302}},getValueSize:function(){return this.values.length/this.times.length},shift:function(a){if(0!==a)for(var c=this.times,e=0,g=c.length;e!==g;++e)c[e]+=a;return this},scale:function(a){if(1!==a)for(var c=this.times,e=0,g=c.length;e!==g;++e)c[e]*=a;return this},trim:function(a,c){for(var e=this.times,g=e.length,r=0,v=g-1;r!==g&&e[r]<a;)++r;for(;-1!==v&&e[v]>c;)--v;++v;if(0!==r||v!==g)r>=v&&(v=Math.max(v,
1),r=v-1),a=this.getValueSize(),this.times=Tb.arraySlice(e,r,v),this.values=Tb.arraySlice(this.values,r*a,v*a);return this},validate:function(){var a=!0,c=this.getValueSize();0!==c-Math.floor(c)&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),a=!1);var e=this.times;c=this.values;var g=e.length;0===g&&(console.error("THREE.KeyframeTrack: Track is empty.",this),a=!1);for(var r=null,v=0;v!==g;v++){var z=e[v];if("number"===typeof z&&isNaN(z)){console.error("THREE.KeyframeTrack: Time is not a valid number.",
this,v,z);a=!1;break}if(null!==r&&r>z){console.error("THREE.KeyframeTrack: Out of order keys.",this,v,z,r);a=!1;break}r=z}if(void 0!==c&&Tb.isTypedArray(c))for(v=0,e=c.length;v!==e;++v)if(g=c[v],isNaN(g)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,v,g);a=!1;break}return a},optimize:function(){for(var a=this.times,c=this.values,e=this.getValueSize(),g=2302===this.getInterpolation(),r=1,v=a.length-1,z=1;z<v;++z){var E=!1,F=a[z];if(F!==a[z+1]&&(1!==z||F!==F[0]))if(g)E=!0;
else{var J=z*e,P=J-e,R=J+e;for(F=0;F!==e;++F){var S=c[J+F];if(S!==c[P+F]||S!==c[R+F]){E=!0;break}}}if(E){if(z!==r)for(a[r]=a[z],E=z*e,J=r*e,F=0;F!==e;++F)c[J+F]=c[E+F];++r}}if(0<v){a[r]=a[v];E=v*e;J=r*e;for(F=0;F!==e;++F)c[J+F]=c[E+F];++r}r!==a.length&&(this.times=Tb.arraySlice(a,0,r),this.values=Tb.arraySlice(c,0,r*e));return this},clone:function(){var a=Tb.arraySlice(this.times,0),c=Tb.arraySlice(this.values,0);a=new this.constructor(this.name,a,c);a.createInterpolant=this.createInterpolant;return a}});
Gg.prototype=Object.assign(Object.create(Xb.prototype),{constructor:Gg,ValueTypeName:"bool",ValueBufferType:Array,DefaultInterpolation:2300,InterpolantFactoryMethodLinear:void 0,InterpolantFactoryMethodSmooth:void 0});Hg.prototype=Object.assign(Object.create(Xb.prototype),{constructor:Hg,ValueTypeName:"color"});Se.prototype=Object.assign(Object.create(Xb.prototype),{constructor:Se,ValueTypeName:"number"});Ig.prototype=Object.assign(Object.create(oc.prototype),{constructor:Ig,interpolate_:function(a,
c,e,g){var r=this.resultBuffer,v=this.sampleValues,z=this.valueSize;a*=z;c=(e-c)/(g-c);for(e=a+z;a!==e;a+=4)h.slerpFlat(r,0,v,a-z,v,a,c);return r}});Zf.prototype=Object.assign(Object.create(Xb.prototype),{constructor:Zf,ValueTypeName:"quaternion",DefaultInterpolation:2301,InterpolantFactoryMethodLinear:function(a){return new Ig(this.times,this.values,this.getValueSize(),a)},InterpolantFactoryMethodSmooth:void 0});Jg.prototype=Object.assign(Object.create(Xb.prototype),{constructor:Jg,ValueTypeName:"string",
ValueBufferType:Array,DefaultInterpolation:2300,InterpolantFactoryMethodLinear:void 0,InterpolantFactoryMethodSmooth:void 0});Te.prototype=Object.assign(Object.create(Xb.prototype),{constructor:Te,ValueTypeName:"vector"});Object.assign(tc,{parse:function(a){for(var c=[],e=a.tracks,g=1/(a.fps||1),r=0,v=e.length;r!==v;++r)c.push(nm(e[r]).scale(g));return new tc(a.name,a.duration,c)},toJSON:function(a){var c=[],e=a.tracks;a={name:a.name,duration:a.duration,tracks:c,uuid:a.uuid};for(var g=0,r=e.length;g!==
r;++g)c.push(Xb.toJSON(e[g]));return a},CreateFromMorphTargetSequence:function(a,c,e,g){for(var r=c.length,v=[],z=0;z<r;z++){var E=[],F=[];E.push((z+r-1)%r,z,(z+1)%r);F.push(0,1,0);var J=Tb.getKeyframeOrder(E);E=Tb.sortedArray(E,1,J);F=Tb.sortedArray(F,1,J);g||0!==E[0]||(E.push(r),F.push(F[0]));v.push((new Se(".morphTargetInfluences["+c[z].name+"]",E,F)).scale(1/e))}return new tc(a,-1,v)},findByName:function(a,c){var e=a;Array.isArray(a)||(e=a.geometry&&a.geometry.animations||a.animations);for(a=
0;a<e.length;a++)if(e[a].name===c)return e[a];return null},CreateClipsFromMorphTargetSequences:function(a,c,e){for(var g={},r=/^([\w-]*?)([\d]+)$/,v=0,z=a.length;v<z;v++){var E=a[v],F=E.name.match(r);if(F&&1<F.length){var J=F[1];(F=g[J])||(g[J]=F=[]);F.push(E)}}a=[];for(J in g)a.push(tc.CreateFromMorphTargetSequence(J,g[J],c,e));return a},parseAnimation:function(a,c){function e(ha,fa,ra,pa,qa){if(0!==ra.length){var ua=[],oa=[];Tb.flattenJSON(ra,ua,oa,pa);0!==ua.length&&qa.push(new ha(fa,ua,oa))}}
if(!a)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;var g=[],r=a.name||"default",v=a.length||-1,z=a.fps||30;a=a.hierarchy||[];for(var E=0;E<a.length;E++){var F=a[E].keys;if(F&&0!==F.length)if(F[0].morphTargets){v={};for(var J=0;J<F.length;J++)if(F[J].morphTargets)for(var P=0;P<F[J].morphTargets.length;P++)v[F[J].morphTargets[P]]=-1;for(var R in v){var S=[],V=[];for(P=0;P!==F[J].morphTargets.length;++P){var W=F[J];S.push(W.time);V.push(W.morphTarget===R?1:0)}g.push(new Se(".morphTargetInfluence["+
R+"]",S,V))}v=v.length*(z||1)}else J=".bones["+c[E].name+"]",e(Te,J+".position",F,"pos",g),e(Zf,J+".quaternion",F,"rot",g),e(Te,J+".scale",F,"scl",g)}return 0===g.length?null:new tc(r,v,g)}});Object.assign(tc.prototype,{resetDuration:function(){for(var a=0,c=0,e=this.tracks.length;c!==e;++c){var g=this.tracks[c];a=Math.max(a,g.times[g.times.length-1])}this.duration=a;return this},trim:function(){for(var a=0;a<this.tracks.length;a++)this.tracks[a].trim(0,this.duration);return this},validate:function(){for(var a=
!0,c=0;c<this.tracks.length;c++)a=a&&this.tracks[c].validate();return a},optimize:function(){for(var a=0;a<this.tracks.length;a++)this.tracks[a].optimize();return this},clone:function(){for(var a=[],c=0;c<this.tracks.length;c++)a.push(this.tracks[c].clone());return new tc(this.name,this.duration,a)}});var ie={enabled:!1,files:{},add:function(a,c){!1!==this.enabled&&(this.files[a]=c)},get:function(a){if(!1!==this.enabled)return this.files[a]},remove:function(a){delete this.files[a]},clear:function(){this.files=
{}}},Oj=new $h;Object.assign(Db.prototype,{load:function(){},parse:function(){},setCrossOrigin:function(a){this.crossOrigin=a;return this},setPath:function(a){this.path=a;return this},setResourcePath:function(a){this.resourcePath=a;return this}});Db.Handlers={handlers:[],add:function(a,c){this.handlers.push(a,c)},get:function(a){for(var c=this.handlers,e=0,g=c.length;e<g;e+=2){var r=c[e+1];if(c[e].test(a))return r}return null}};var Kc={};uc.prototype=Object.assign(Object.create(Db.prototype),{constructor:uc,
load:function(a,c,e,g){void 0===a&&(a="");void 0!==this.path&&(a=this.path+a);a=this.manager.resolveURL(a);var r=this,v=ie.get(a);if(void 0!==v)return r.manager.itemStart(a),setTimeout(function(){c&&c(v);r.manager.itemEnd(a)},0),v;if(void 0!==Kc[a])Kc[a].push({onLoad:c,onProgress:e,onError:g});else{var z=a.match(/^data:(.*?)(;base64)?,(.*)$/);if(z){e=z[1];var E=!!z[2];z=z[3];z=decodeURIComponent(z);E&&(z=atob(z));try{var F=(this.responseType||"").toLowerCase();switch(F){case "arraybuffer":case "blob":var J=
new Uint8Array(z.length);for(E=0;E<z.length;E++)J[E]=z.charCodeAt(E);var P="blob"===F?new Blob([J.buffer],{type:e}):J.buffer;break;case "document":P=(new DOMParser).parseFromString(z,e);break;case "json":P=JSON.parse(z);break;default:P=z}setTimeout(function(){c&&c(P);r.manager.itemEnd(a)},0)}catch(S){setTimeout(function(){g&&g(S);r.manager.itemError(a);r.manager.itemEnd(a)},0)}}else{Kc[a]=[];Kc[a].push({onLoad:c,onProgress:e,onError:g});var R=new XMLHttpRequest;R.open("GET",a,!0);R.addEventListener("load",
function(S){var V=this.response;ie.add(a,V);var W=Kc[a];delete Kc[a];if(200===this.status||0===this.status){0===this.status&&console.warn("THREE.FileLoader: HTTP Status 0 received.");for(var ha=0,fa=W.length;ha<fa;ha++){var ra=W[ha];if(ra.onLoad)ra.onLoad(V)}}else{ha=0;for(fa=W.length;ha<fa;ha++)if(ra=W[ha],ra.onError)ra.onError(S);r.manager.itemError(a)}r.manager.itemEnd(a)},!1);R.addEventListener("progress",function(S){for(var V=Kc[a],W=0,ha=V.length;W<ha;W++){var fa=V[W];if(fa.onProgress)fa.onProgress(S)}},
!1);R.addEventListener("error",function(S){var V=Kc[a];delete Kc[a];for(var W=0,ha=V.length;W<ha;W++){var fa=V[W];if(fa.onError)fa.onError(S)}r.manager.itemError(a);r.manager.itemEnd(a)},!1);R.addEventListener("abort",function(S){var V=Kc[a];delete Kc[a];for(var W=0,ha=V.length;W<ha;W++){var fa=V[W];if(fa.onError)fa.onError(S)}r.manager.itemError(a);r.manager.itemEnd(a)},!1);void 0!==this.responseType&&(R.responseType=this.responseType);void 0!==this.withCredentials&&(R.withCredentials=this.withCredentials);
R.overrideMimeType&&R.overrideMimeType(void 0!==this.mimeType?this.mimeType:"text/plain");for(E in this.requestHeader)R.setRequestHeader(E,this.requestHeader[E]);R.send(null)}r.manager.itemStart(a);return R}},setResponseType:function(a){this.responseType=a;return this},setWithCredentials:function(a){this.withCredentials=a;return this},setMimeType:function(a){this.mimeType=a;return this},setRequestHeader:function(a){this.requestHeader=a;return this}});ai.prototype=Object.assign(Object.create(Db.prototype),
{constructor:ai,load:function(a,c,e,g){var r=this,v=new uc(r.manager);v.setPath(r.path);v.load(a,function(z){c(r.parse(JSON.parse(z)))},e,g)},parse:function(a){for(var c=[],e=0;e<a.length;e++){var g=tc.parse(a[e]);c.push(g)}return c}});bi.prototype=Object.assign(Object.create(Db.prototype),{constructor:bi,load:function(a,c,e,g){function r(S){F.load(a[S],function(V){V=v._parser(V,!0);z[S]={width:V.width,height:V.height,format:V.format,mipmaps:V.mipmaps};J+=1;6===J&&(1===V.mipmapCount&&(E.minFilter=
1006),E.format=V.format,E.needsUpdate=!0,c&&c(E))},e,g)}var v=this,z=[],E=new De;E.image=z;var F=new uc(this.manager);F.setPath(this.path);F.setResponseType("arraybuffer");if(Array.isArray(a))for(var J=0,P=0,R=a.length;P<R;++P)r(P);else F.load(a,function(S){S=v._parser(S,!0);if(S.isCubemap)for(var V=S.mipmaps.length/S.mipmapCount,W=0;W<V;W++){z[W]={mipmaps:[]};for(var ha=0;ha<S.mipmapCount;ha++)z[W].mipmaps.push(S.mipmaps[W*S.mipmapCount+ha]),z[W].format=S.format,z[W].width=S.width,z[W].height=S.height}else E.image.width=
S.width,E.image.height=S.height,E.mipmaps=S.mipmaps;1===S.mipmapCount&&(E.minFilter=1006);E.format=S.format;E.needsUpdate=!0;c&&c(E)},e,g);return E}});Kg.prototype=Object.assign(Object.create(Db.prototype),{constructor:Kg,load:function(a,c,e,g){var r=this,v=new Ab,z=new uc(this.manager);z.setResponseType("arraybuffer");z.setPath(this.path);z.load(a,function(E){if(E=r._parser(E))void 0!==E.image?v.image=E.image:void 0!==E.data&&(v.image.width=E.width,v.image.height=E.height,v.image.data=E.data),v.wrapS=
void 0!==E.wrapS?E.wrapS:1001,v.wrapT=void 0!==E.wrapT?E.wrapT:1001,v.magFilter=void 0!==E.magFilter?E.magFilter:1006,v.minFilter=void 0!==E.minFilter?E.minFilter:1008,v.anisotropy=void 0!==E.anisotropy?E.anisotropy:1,void 0!==E.format&&(v.format=E.format),void 0!==E.type&&(v.type=E.type),void 0!==E.mipmaps&&(v.mipmaps=E.mipmaps),1===E.mipmapCount&&(v.minFilter=1006),v.needsUpdate=!0,c&&c(v,E)},e,g);return v}});Ue.prototype=Object.assign(Object.create(Db.prototype),{constructor:Ue,load:function(a,
c,e,g){function r(){F.removeEventListener("load",r,!1);F.removeEventListener("error",v,!1);ie.add(a,this);c&&c(this);z.manager.itemEnd(a)}function v(J){F.removeEventListener("load",r,!1);F.removeEventListener("error",v,!1);g&&g(J);z.manager.itemError(a);z.manager.itemEnd(a)}void 0!==this.path&&(a=this.path+a);a=this.manager.resolveURL(a);var z=this,E=ie.get(a);if(void 0!==E)return z.manager.itemStart(a),setTimeout(function(){c&&c(E);z.manager.itemEnd(a)},0),E;var F=document.createElementNS("http://www.w3.org/1999/xhtml",
"img");F.addEventListener("load",r,!1);F.addEventListener("error",v,!1);"data:"!==a.substr(0,5)&&void 0!==this.crossOrigin&&(F.crossOrigin=this.crossOrigin);z.manager.itemStart(a);F.src=a;return F}});Lg.prototype=Object.assign(Object.create(Db.prototype),{constructor:Lg,load:function(a,c,e,g){function r(F){z.load(a[F],function(J){v.images[F]=J;E++;6===E&&(v.needsUpdate=!0,c&&c(v))},void 0,g)}var v=new cd,z=new Ue(this.manager);z.setCrossOrigin(this.crossOrigin);z.setPath(this.path);var E=0;for(e=
0;e<a.length;++e)r(e);return v}});Mg.prototype=Object.assign(Object.create(Db.prototype),{constructor:Mg,load:function(a,c,e,g){var r=new l,v=new Ue(this.manager);v.setCrossOrigin(this.crossOrigin);v.setPath(this.path);v.load(a,function(z){r.image=z;z=0<a.search(/\.jpe?g($|\?)/i)||0===a.search(/^data:image\/jpeg/);r.format=z?1022:1023;r.needsUpdate=!0;void 0!==c&&c(r)},e,g);return r}});Object.assign(Za.prototype,{getPoint:function(){console.warn("THREE.Curve: .getPoint() not implemented.");return null},
getPointAt:function(a,c){a=this.getUtoTmapping(a);return this.getPoint(a,c)},getPoints:function(a){void 0===a&&(a=5);for(var c=[],e=0;e<=a;e++)c.push(this.getPoint(e/a));return c},getSpacedPoints:function(a){void 0===a&&(a=5);for(var c=[],e=0;e<=a;e++)c.push(this.getPointAt(e/a));return c},getLength:function(){var a=this.getLengths();return a[a.length-1]},getLengths:function(a){void 0===a&&(a=this.arcLengthDivisions);if(this.cacheArcLengths&&this.cacheArcLengths.length===a+1&&!this.needsUpdate)return this.cacheArcLengths;
this.needsUpdate=!1;var c=[],e=this.getPoint(0),g,r=0;c.push(0);for(g=1;g<=a;g++){var v=this.getPoint(g/a);r+=v.distanceTo(e);c.push(r);e=v}return this.cacheArcLengths=c},updateArcLengths:function(){this.needsUpdate=!0;this.getLengths()},getUtoTmapping:function(a,c){var e=this.getLengths(),g=e.length;c=c?c:a*e[g-1];for(var r=0,v=g-1,z;r<=v;)if(a=Math.floor(r+(v-r)/2),z=e[a]-c,0>z)r=a+1;else if(0<z)v=a-1;else{v=a;break}a=v;if(e[a]===c)return a/(g-1);r=e[a];return(a+(c-r)/(e[a+1]-r))/(g-1)},getTangent:function(a){var c=
a-1E-4;a+=1E-4;0>c&&(c=0);1<a&&(a=1);c=this.getPoint(c);return this.getPoint(a).clone().sub(c).normalize()},getTangentAt:function(a){a=this.getUtoTmapping(a);return this.getTangent(a)},computeFrenetFrames:function(a,c){var e=new k,g=[],r=[],v=[],z=new k,E=new q,F;for(F=0;F<=a;F++){var J=F/a;g[F]=this.getTangentAt(J);g[F].normalize()}r[0]=new k;v[0]=new k;F=Number.MAX_VALUE;J=Math.abs(g[0].x);var P=Math.abs(g[0].y),R=Math.abs(g[0].z);J<=F&&(F=J,e.set(1,0,0));P<=F&&(F=P,e.set(0,1,0));R<=F&&e.set(0,
0,1);z.crossVectors(g[0],e).normalize();r[0].crossVectors(g[0],z);v[0].crossVectors(g[0],r[0]);for(F=1;F<=a;F++)r[F]=r[F-1].clone(),v[F]=v[F-1].clone(),z.crossVectors(g[F-1],g[F]),z.length()>Number.EPSILON&&(z.normalize(),e=Math.acos(hb.clamp(g[F-1].dot(g[F]),-1,1)),r[F].applyMatrix4(E.makeRotationAxis(z,e))),v[F].crossVectors(g[F],r[F]);if(!0===c)for(e=Math.acos(hb.clamp(r[0].dot(r[a]),-1,1)),e/=a,0<g[0].dot(z.crossVectors(r[0],r[a]))&&(e=-e),F=1;F<=a;F++)r[F].applyMatrix4(E.makeRotationAxis(g[F],
e*F)),v[F].crossVectors(g[F],r[F]);return{tangents:g,normals:r,binormals:v}},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.arcLengthDivisions=a.arcLengthDivisions;return this},toJSON:function(){var a={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};a.arcLengthDivisions=this.arcLengthDivisions;a.type=this.type;return a},fromJSON:function(a){this.arcLengthDivisions=a.arcLengthDivisions;return this}});pc.prototype=Object.create(Za.prototype);pc.prototype.constructor=
pc;pc.prototype.isEllipseCurve=!0;pc.prototype.getPoint=function(a,c){c=c||new f;for(var e=2*Math.PI,g=this.aEndAngle-this.aStartAngle,r=Math.abs(g)<Number.EPSILON;0>g;)g+=e;for(;g>e;)g-=e;g<Number.EPSILON&&(g=r?0:e);!0!==this.aClockwise||r||(g=g===e?-e:g-e);e=this.aStartAngle+a*g;a=this.aX+this.xRadius*Math.cos(e);var v=this.aY+this.yRadius*Math.sin(e);0!==this.aRotation&&(e=Math.cos(this.aRotation),g=Math.sin(this.aRotation),r=a-this.aX,v-=this.aY,a=r*e-v*g+this.aX,v=r*g+v*e+this.aY);return c.set(a,
v)};pc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.aX=a.aX;this.aY=a.aY;this.xRadius=a.xRadius;this.yRadius=a.yRadius;this.aStartAngle=a.aStartAngle;this.aEndAngle=a.aEndAngle;this.aClockwise=a.aClockwise;this.aRotation=a.aRotation;return this};pc.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.aX=this.aX;a.aY=this.aY;a.xRadius=this.xRadius;a.yRadius=this.yRadius;a.aStartAngle=this.aStartAngle;a.aEndAngle=this.aEndAngle;a.aClockwise=this.aClockwise;a.aRotation=
this.aRotation;return a};pc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.aX=a.aX;this.aY=a.aY;this.xRadius=a.xRadius;this.yRadius=a.yRadius;this.aStartAngle=a.aStartAngle;this.aEndAngle=a.aEndAngle;this.aClockwise=a.aClockwise;this.aRotation=a.aRotation;return this};Ve.prototype=Object.create(pc.prototype);Ve.prototype.constructor=Ve;Ve.prototype.isArcCurve=!0;var xh=new k,Li=new ci,Mi=new ci,Ni=new ci;Zb.prototype=Object.create(Za.prototype);Zb.prototype.constructor=Zb;
Zb.prototype.isCatmullRomCurve3=!0;Zb.prototype.getPoint=function(a,c){c=c||new k;var e=this.points,g=e.length;a*=g-(this.closed?0:1);var r=Math.floor(a);a-=r;this.closed?r+=0<r?0:(Math.floor(Math.abs(r)/g)+1)*g:0===a&&r===g-1&&(r=g-2,a=1);if(this.closed||0<r)var v=e[(r-1)%g];else xh.subVectors(e[0],e[1]).add(e[0]),v=xh;var z=e[r%g];var E=e[(r+1)%g];this.closed||r+2<g?e=e[(r+2)%g]:(xh.subVectors(e[g-1],e[g-2]).add(e[g-1]),e=xh);if("centripetal"===this.curveType||"chordal"===this.curveType){var F=
"chordal"===this.curveType?.5:.25;g=Math.pow(v.distanceToSquared(z),F);r=Math.pow(z.distanceToSquared(E),F);F=Math.pow(E.distanceToSquared(e),F);1E-4>r&&(r=1);1E-4>g&&(g=r);1E-4>F&&(F=r);Li.initNonuniformCatmullRom(v.x,z.x,E.x,e.x,g,r,F);Mi.initNonuniformCatmullRom(v.y,z.y,E.y,e.y,g,r,F);Ni.initNonuniformCatmullRom(v.z,z.z,E.z,e.z,g,r,F)}else"catmullrom"===this.curveType&&(Li.initCatmullRom(v.x,z.x,E.x,e.x,this.tension),Mi.initCatmullRom(v.y,z.y,E.y,e.y,this.tension),Ni.initCatmullRom(v.z,z.z,E.z,
e.z,this.tension));c.set(Li.calc(a),Mi.calc(a),Ni.calc(a));return c};Zb.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.points=[];for(var c=0,e=a.points.length;c<e;c++)this.points.push(a.points[c].clone());this.closed=a.closed;this.curveType=a.curveType;this.tension=a.tension;return this};Zb.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.points=[];for(var c=0,e=this.points.length;c<e;c++)a.points.push(this.points[c].toArray());a.closed=this.closed;a.curveType=this.curveType;
a.tension=this.tension;return a};Zb.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.points=[];for(var c=0,e=a.points.length;c<e;c++){var g=a.points[c];this.points.push((new k).fromArray(g))}this.closed=a.closed;this.curveType=a.curveType;this.tension=a.tension;return this};Cc.prototype=Object.create(Za.prototype);Cc.prototype.constructor=Cc;Cc.prototype.isCubicBezierCurve=!0;Cc.prototype.getPoint=function(a,c){c=c||new f;var e=this.v0,g=this.v1,r=this.v2,v=this.v3;c.set(ag(a,
e.x,g.x,r.x,v.x),ag(a,e.y,g.y,r.y,v.y));return c};Cc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.v0.copy(a.v0);this.v1.copy(a.v1);this.v2.copy(a.v2);this.v3.copy(a.v3);return this};Cc.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.v0=this.v0.toArray();a.v1=this.v1.toArray();a.v2=this.v2.toArray();a.v3=this.v3.toArray();return a};Cc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.v0.fromArray(a.v0);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);
this.v3.fromArray(a.v3);return this};Tc.prototype=Object.create(Za.prototype);Tc.prototype.constructor=Tc;Tc.prototype.isCubicBezierCurve3=!0;Tc.prototype.getPoint=function(a,c){c=c||new k;var e=this.v0,g=this.v1,r=this.v2,v=this.v3;c.set(ag(a,e.x,g.x,r.x,v.x),ag(a,e.y,g.y,r.y,v.y),ag(a,e.z,g.z,r.z,v.z));return c};Tc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.v0.copy(a.v0);this.v1.copy(a.v1);this.v2.copy(a.v2);this.v3.copy(a.v3);return this};Tc.prototype.toJSON=function(){var a=
Za.prototype.toJSON.call(this);a.v0=this.v0.toArray();a.v1=this.v1.toArray();a.v2=this.v2.toArray();a.v3=this.v3.toArray();return a};Tc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.v0.fromArray(a.v0);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);this.v3.fromArray(a.v3);return this};kc.prototype=Object.create(Za.prototype);kc.prototype.constructor=kc;kc.prototype.isLineCurve=!0;kc.prototype.getPoint=function(a,c){c=c||new f;1===a?c.copy(this.v2):(c.copy(this.v2).sub(this.v1),
c.multiplyScalar(a).add(this.v1));return c};kc.prototype.getPointAt=function(a,c){return this.getPoint(a,c)};kc.prototype.getTangent=function(){return this.v2.clone().sub(this.v1).normalize()};kc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.v1.copy(a.v1);this.v2.copy(a.v2);return this};kc.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.v1=this.v1.toArray();a.v2=this.v2.toArray();return a};kc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.v1.fromArray(a.v1);
this.v2.fromArray(a.v2);return this};Dc.prototype=Object.create(Za.prototype);Dc.prototype.constructor=Dc;Dc.prototype.isLineCurve3=!0;Dc.prototype.getPoint=function(a,c){c=c||new k;1===a?c.copy(this.v2):(c.copy(this.v2).sub(this.v1),c.multiplyScalar(a).add(this.v1));return c};Dc.prototype.getPointAt=function(a,c){return this.getPoint(a,c)};Dc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.v1.copy(a.v1);this.v2.copy(a.v2);return this};Dc.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);
a.v1=this.v1.toArray();a.v2=this.v2.toArray();return a};Dc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);return this};Ec.prototype=Object.create(Za.prototype);Ec.prototype.constructor=Ec;Ec.prototype.isQuadraticBezierCurve=!0;Ec.prototype.getPoint=function(a,c){c=c||new f;var e=this.v0,g=this.v1,r=this.v2;c.set($f(a,e.x,g.x,r.x),$f(a,e.y,g.y,r.y));return c};Ec.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.v0.copy(a.v0);
this.v1.copy(a.v1);this.v2.copy(a.v2);return this};Ec.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.v0=this.v0.toArray();a.v1=this.v1.toArray();a.v2=this.v2.toArray();return a};Ec.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.v0.fromArray(a.v0);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);return this};Uc.prototype=Object.create(Za.prototype);Uc.prototype.constructor=Uc;Uc.prototype.isQuadraticBezierCurve3=!0;Uc.prototype.getPoint=function(a,c){c=c||
new k;var e=this.v0,g=this.v1,r=this.v2;c.set($f(a,e.x,g.x,r.x),$f(a,e.y,g.y,r.y),$f(a,e.z,g.z,r.z));return c};Uc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.v0.copy(a.v0);this.v1.copy(a.v1);this.v2.copy(a.v2);return this};Uc.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.v0=this.v0.toArray();a.v1=this.v1.toArray();a.v2=this.v2.toArray();return a};Uc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.v0.fromArray(a.v0);this.v1.fromArray(a.v1);
this.v2.fromArray(a.v2);return this};Fc.prototype=Object.create(Za.prototype);Fc.prototype.constructor=Fc;Fc.prototype.isSplineCurve=!0;Fc.prototype.getPoint=function(a,c){c=c||new f;var e=this.points,g=(e.length-1)*a;a=Math.floor(g);g-=a;var r=e[0===a?a:a-1],v=e[a],z=e[a>e.length-2?e.length-1:a+1];e=e[a>e.length-3?e.length-1:a+2];c.set(Pj(g,r.x,v.x,z.x,e.x),Pj(g,r.y,v.y,z.y,e.y));return c};Fc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.points=[];for(var c=0,e=a.points.length;c<
e;c++)this.points.push(a.points[c].clone());return this};Fc.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.points=[];for(var c=0,e=this.points.length;c<e;c++)a.points.push(this.points[c].toArray());return a};Fc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.points=[];for(var c=0,e=a.points.length;c<e;c++){var g=a.points[c];this.points.push((new f).fromArray(g))}return this};var Oi=Object.freeze({ArcCurve:Ve,CatmullRomCurve3:Zb,CubicBezierCurve:Cc,CubicBezierCurve3:Tc,
EllipseCurve:pc,LineCurve:kc,LineCurve3:Dc,QuadraticBezierCurve:Ec,QuadraticBezierCurve3:Uc,SplineCurve:Fc});gd.prototype=Object.assign(Object.create(Za.prototype),{constructor:gd,add:function(a){this.curves.push(a)},closePath:function(){var a=this.curves[0].getPoint(0),c=this.curves[this.curves.length-1].getPoint(1);a.equals(c)||this.curves.push(new kc(c,a))},getPoint:function(a){var c=a*this.getLength(),e=this.getCurveLengths();for(a=0;a<e.length;){if(e[a]>=c)return c=e[a]-c,a=this.curves[a],e=
a.getLength(),a.getPointAt(0===e?0:1-c/e);a++}return null},getLength:function(){var a=this.getCurveLengths();return a[a.length-1]},updateArcLengths:function(){this.needsUpdate=!0;this.cacheLengths=null;this.getCurveLengths()},getCurveLengths:function(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;for(var a=[],c=0,e=0,g=this.curves.length;e<g;e++)c+=this.curves[e].getLength(),a.push(c);return this.cacheLengths=a},getSpacedPoints:function(a){void 0===
a&&(a=40);for(var c=[],e=0;e<=a;e++)c.push(this.getPoint(e/a));this.autoClose&&c.push(c[0]);return c},getPoints:function(a){a=a||12;for(var c=[],e,g=0,r=this.curves;g<r.length;g++){var v=r[g];v=v.getPoints(v&&v.isEllipseCurve?2*a:v&&(v.isLineCurve||v.isLineCurve3)?1:v&&v.isSplineCurve?a*v.points.length:a);for(var z=0;z<v.length;z++){var E=v[z];e&&e.equals(E)||(c.push(E),e=E)}}this.autoClose&&1<c.length&&!c[c.length-1].equals(c[0])&&c.push(c[0]);return c},copy:function(a){Za.prototype.copy.call(this,
a);this.curves=[];for(var c=0,e=a.curves.length;c<e;c++)this.curves.push(a.curves[c].clone());this.autoClose=a.autoClose;return this},toJSON:function(){var a=Za.prototype.toJSON.call(this);a.autoClose=this.autoClose;a.curves=[];for(var c=0,e=this.curves.length;c<e;c++)a.curves.push(this.curves[c].toJSON());return a},fromJSON:function(a){Za.prototype.fromJSON.call(this,a);this.autoClose=a.autoClose;this.curves=[];for(var c=0,e=a.curves.length;c<e;c++){var g=a.curves[c];this.curves.push((new Oi[g.type]).fromJSON(g))}return this}});
Gc.prototype=Object.assign(Object.create(gd.prototype),{constructor:Gc,setFromPoints:function(a){this.moveTo(a[0].x,a[0].y);for(var c=1,e=a.length;c<e;c++)this.lineTo(a[c].x,a[c].y)},moveTo:function(a,c){this.currentPoint.set(a,c)},lineTo:function(a,c){var e=new kc(this.currentPoint.clone(),new f(a,c));this.curves.push(e);this.currentPoint.set(a,c)},quadraticCurveTo:function(a,c,e,g){a=new Ec(this.currentPoint.clone(),new f(a,c),new f(e,g));this.curves.push(a);this.currentPoint.set(e,g)},bezierCurveTo:function(a,
c,e,g,r,v){a=new Cc(this.currentPoint.clone(),new f(a,c),new f(e,g),new f(r,v));this.curves.push(a);this.currentPoint.set(r,v)},splineThru:function(a){var c=[this.currentPoint.clone()].concat(a);c=new Fc(c);this.curves.push(c);this.currentPoint.copy(a[a.length-1])},arc:function(a,c,e,g,r,v){this.absarc(a+this.currentPoint.x,c+this.currentPoint.y,e,g,r,v)},absarc:function(a,c,e,g,r,v){this.absellipse(a,c,e,e,g,r,v)},ellipse:function(a,c,e,g,r,v,z,E){this.absellipse(a+this.currentPoint.x,c+this.currentPoint.y,
e,g,r,v,z,E)},absellipse:function(a,c,e,g,r,v,z,E){a=new pc(a,c,e,g,r,v,z,E);0<this.curves.length&&(c=a.getPoint(0),c.equals(this.currentPoint)||this.lineTo(c.x,c.y));this.curves.push(a);a=a.getPoint(1);this.currentPoint.copy(a)},copy:function(a){gd.prototype.copy.call(this,a);this.currentPoint.copy(a.currentPoint);return this},toJSON:function(){var a=gd.prototype.toJSON.call(this);a.currentPoint=this.currentPoint.toArray();return a},fromJSON:function(a){gd.prototype.fromJSON.call(this,a);this.currentPoint.fromArray(a.currentPoint);
return this}});Cd.prototype=Object.assign(Object.create(Gc.prototype),{constructor:Cd,getPointsHoles:function(a){for(var c=[],e=0,g=this.holes.length;e<g;e++)c[e]=this.holes[e].getPoints(a);return c},extractPoints:function(a){return{shape:this.getPoints(a),holes:this.getPointsHoles(a)}},copy:function(a){Gc.prototype.copy.call(this,a);this.holes=[];for(var c=0,e=a.holes.length;c<e;c++)this.holes.push(a.holes[c].clone());return this},toJSON:function(){var a=Gc.prototype.toJSON.call(this);a.uuid=this.uuid;
a.holes=[];for(var c=0,e=this.holes.length;c<e;c++)a.holes.push(this.holes[c].toJSON());return a},fromJSON:function(a){Gc.prototype.fromJSON.call(this,a);this.uuid=a.uuid;this.holes=[];for(var c=0,e=a.holes.length;c<e;c++){var g=a.holes[c];this.holes.push((new Gc).fromJSON(g))}return this}});Jb.prototype=Object.assign(Object.create(A.prototype),{constructor:Jb,isLight:!0,copy:function(a){A.prototype.copy.call(this,a);this.color.copy(a.color);this.intensity=a.intensity;return this},toJSON:function(a){a=
A.prototype.toJSON.call(this,a);a.object.color=this.color.getHex();a.object.intensity=this.intensity;void 0!==this.groundColor&&(a.object.groundColor=this.groundColor.getHex());void 0!==this.distance&&(a.object.distance=this.distance);void 0!==this.angle&&(a.object.angle=this.angle);void 0!==this.decay&&(a.object.decay=this.decay);void 0!==this.penumbra&&(a.object.penumbra=this.penumbra);void 0!==this.shadow&&(a.object.shadow=this.shadow.toJSON());return a}});Ng.prototype=Object.assign(Object.create(Jb.prototype),
{constructor:Ng,isHemisphereLight:!0,copy:function(a){Jb.prototype.copy.call(this,a);this.groundColor.copy(a.groundColor);return this}});Object.assign(Vc.prototype,{_projScreenMatrix:new q,_lightPositionWorld:new k,_lookTarget:new k,getViewportCount:function(){return this._viewportCount},getFrustum:function(){return this._frustum},updateMatrices:function(a){var c=this.camera,e=this.matrix,g=this._projScreenMatrix,r=this._lookTarget,v=this._lightPositionWorld;v.setFromMatrixPosition(a.matrixWorld);
c.position.copy(v);r.setFromMatrixPosition(a.target.matrixWorld);c.lookAt(r);c.updateMatrixWorld();g.multiplyMatrices(c.projectionMatrix,c.matrixWorldInverse);this._frustum.setFromMatrix(g);e.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1);e.multiply(c.projectionMatrix);e.multiply(c.matrixWorldInverse)},getViewport:function(a){return this._viewports[a]},getFrameExtents:function(){return this._frameExtents},copy:function(a){this.camera=a.camera.clone();this.bias=a.bias;this.radius=a.radius;this.mapSize.copy(a.mapSize);
return this},clone:function(){return(new this.constructor).copy(this)},toJSON:function(){var a={};0!==this.bias&&(a.bias=this.bias);1!==this.radius&&(a.radius=this.radius);if(512!==this.mapSize.x||512!==this.mapSize.y)a.mapSize=this.mapSize.toArray();a.camera=this.camera.toJSON(!1).object;delete a.camera.matrix;return a}});Og.prototype=Object.assign(Object.create(Vc.prototype),{constructor:Og,isSpotLightShadow:!0,updateMatrices:function(a,c,e){var g=this.camera,r=2*hb.RAD2DEG*a.angle,v=this.mapSize.width/
this.mapSize.height,z=a.distance||g.far;if(r!==g.fov||v!==g.aspect||z!==g.far)g.fov=r,g.aspect=v,g.far=z,g.updateProjectionMatrix();Vc.prototype.updateMatrices.call(this,a,c,e)}});Pg.prototype=Object.assign(Object.create(Jb.prototype),{constructor:Pg,isSpotLight:!0,copy:function(a){Jb.prototype.copy.call(this,a);this.distance=a.distance;this.angle=a.angle;this.penumbra=a.penumbra;this.decay=a.decay;this.target=a.target.clone();this.shadow=a.shadow.clone();return this}});di.prototype=Object.assign(Object.create(Vc.prototype),
{constructor:di,isPointLightShadow:!0,updateMatrices:function(a,c,e){c=this.camera;var g=this.matrix,r=this._lightPositionWorld,v=this._lookTarget,z=this._projScreenMatrix;r.setFromMatrixPosition(a.matrixWorld);c.position.copy(r);v.copy(c.position);v.add(this._cubeDirections[e]);c.up.copy(this._cubeUps[e]);c.lookAt(v);c.updateMatrixWorld();g.makeTranslation(-r.x,-r.y,-r.z);z.multiplyMatrices(c.projectionMatrix,c.matrixWorldInverse);this._frustum.setFromMatrix(z)}});Qg.prototype=Object.assign(Object.create(Jb.prototype),
{constructor:Qg,isPointLight:!0,copy:function(a){Jb.prototype.copy.call(this,a);this.distance=a.distance;this.decay=a.decay;this.shadow=a.shadow.clone();return this}});bg.prototype=Object.assign(Object.create(zb.prototype),{constructor:bg,isOrthographicCamera:!0,copy:function(a,c){zb.prototype.copy.call(this,a,c);this.left=a.left;this.right=a.right;this.top=a.top;this.bottom=a.bottom;this.near=a.near;this.far=a.far;this.zoom=a.zoom;this.view=null===a.view?null:Object.assign({},a.view);return this},
setViewOffset:function(a,c,e,g,r,v){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=a;this.view.fullHeight=c;this.view.offsetX=e;this.view.offsetY=g;this.view.width=r;this.view.height=v;this.updateProjectionMatrix()},clearViewOffset:function(){null!==this.view&&(this.view.enabled=!1);this.updateProjectionMatrix()},updateProjectionMatrix:function(){var a=(this.right-this.left)/(2*this.zoom),c=(this.top-
this.bottom)/(2*this.zoom),e=(this.right+this.left)/2,g=(this.top+this.bottom)/2,r=e-a;e+=a;a=g+c;c=g-c;if(null!==this.view&&this.view.enabled){e=this.zoom/(this.view.width/this.view.fullWidth);c=this.zoom/(this.view.height/this.view.fullHeight);var v=(this.right-this.left)/this.view.width;g=(this.top-this.bottom)/this.view.height;r+=this.view.offsetX/e*v;e=r+this.view.width/e*v;a-=this.view.offsetY/c*g;c=a-this.view.height/c*g}this.projectionMatrix.makeOrthographic(r,e,a,c,this.near,this.far);this.projectionMatrixInverse.getInverse(this.projectionMatrix)},
toJSON:function(a){a=A.prototype.toJSON.call(this,a);a.object.zoom=this.zoom;a.object.left=this.left;a.object.right=this.right;a.object.top=this.top;a.object.bottom=this.bottom;a.object.near=this.near;a.object.far=this.far;null!==this.view&&(a.object.view=Object.assign({},this.view));return a}});Rg.prototype=Object.assign(Object.create(Vc.prototype),{constructor:Rg,isDirectionalLightShadow:!0,updateMatrices:function(a,c,e){Vc.prototype.updateMatrices.call(this,a,c,e)}});Sg.prototype=Object.assign(Object.create(Jb.prototype),
{constructor:Sg,isDirectionalLight:!0,copy:function(a){Jb.prototype.copy.call(this,a);this.target=a.target.clone();this.shadow=a.shadow.clone();return this}});Tg.prototype=Object.assign(Object.create(Jb.prototype),{constructor:Tg,isAmbientLight:!0});Ug.prototype=Object.assign(Object.create(Jb.prototype),{constructor:Ug,isRectAreaLight:!0,copy:function(a){Jb.prototype.copy.call(this,a);this.width=a.width;this.height=a.height;return this},toJSON:function(a){a=Jb.prototype.toJSON.call(this,a);a.object.width=
this.width;a.object.height=this.height;return a}});Vg.prototype=Object.assign(Object.create(Db.prototype),{constructor:Vg,load:function(a,c,e,g){var r=this,v=new uc(r.manager);v.setPath(r.path);v.load(a,function(z){c(r.parse(JSON.parse(z)))},e,g)},parse:function(a){function c(E){void 0===e[E]&&console.warn("THREE.MaterialLoader: Undefined texture",E);return e[E]}var e=this.textures,g=new Km[a.type];void 0!==a.uuid&&(g.uuid=a.uuid);void 0!==a.name&&(g.name=a.name);void 0!==a.color&&g.color.setHex(a.color);
void 0!==a.roughness&&(g.roughness=a.roughness);void 0!==a.metalness&&(g.metalness=a.metalness);void 0!==a.emissive&&g.emissive.setHex(a.emissive);void 0!==a.specular&&g.specular.setHex(a.specular);void 0!==a.shininess&&(g.shininess=a.shininess);void 0!==a.clearcoat&&(g.clearcoat=a.clearcoat);void 0!==a.clearcoatRoughness&&(g.clearcoatRoughness=a.clearcoatRoughness);void 0!==a.vertexColors&&(g.vertexColors=a.vertexColors);void 0!==a.fog&&(g.fog=a.fog);void 0!==a.flatShading&&(g.flatShading=a.flatShading);
void 0!==a.blending&&(g.blending=a.blending);void 0!==a.combine&&(g.combine=a.combine);void 0!==a.side&&(g.side=a.side);void 0!==a.opacity&&(g.opacity=a.opacity);void 0!==a.transparent&&(g.transparent=a.transparent);void 0!==a.alphaTest&&(g.alphaTest=a.alphaTest);void 0!==a.depthTest&&(g.depthTest=a.depthTest);void 0!==a.depthWrite&&(g.depthWrite=a.depthWrite);void 0!==a.colorWrite&&(g.colorWrite=a.colorWrite);void 0!==a.wireframe&&(g.wireframe=a.wireframe);void 0!==a.wireframeLinewidth&&(g.wireframeLinewidth=
a.wireframeLinewidth);void 0!==a.wireframeLinecap&&(g.wireframeLinecap=a.wireframeLinecap);void 0!==a.wireframeLinejoin&&(g.wireframeLinejoin=a.wireframeLinejoin);void 0!==a.rotation&&(g.rotation=a.rotation);1!==a.linewidth&&(g.linewidth=a.linewidth);void 0!==a.dashSize&&(g.dashSize=a.dashSize);void 0!==a.gapSize&&(g.gapSize=a.gapSize);void 0!==a.scale&&(g.scale=a.scale);void 0!==a.polygonOffset&&(g.polygonOffset=a.polygonOffset);void 0!==a.polygonOffsetFactor&&(g.polygonOffsetFactor=a.polygonOffsetFactor);
void 0!==a.polygonOffsetUnits&&(g.polygonOffsetUnits=a.polygonOffsetUnits);void 0!==a.skinning&&(g.skinning=a.skinning);void 0!==a.morphTargets&&(g.morphTargets=a.morphTargets);void 0!==a.morphNormals&&(g.morphNormals=a.morphNormals);void 0!==a.dithering&&(g.dithering=a.dithering);void 0!==a.visible&&(g.visible=a.visible);void 0!==a.toneMapped&&(g.toneMapped=a.toneMapped);void 0!==a.userData&&(g.userData=a.userData);if(void 0!==a.uniforms)for(var r in a.uniforms){var v=a.uniforms[r];g.uniforms[r]=
{};switch(v.type){case "t":g.uniforms[r].value=c(v.value);break;case "c":g.uniforms[r].value=(new I).setHex(v.value);break;case "v2":g.uniforms[r].value=(new f).fromArray(v.value);break;case "v3":g.uniforms[r].value=(new k).fromArray(v.value);break;case "v4":g.uniforms[r].value=(new p).fromArray(v.value);break;case "m3":g.uniforms[r].value=(new t).fromArray(v.value);case "m4":g.uniforms[r].value=(new q).fromArray(v.value);break;default:g.uniforms[r].value=v.value}}void 0!==a.defines&&(g.defines=a.defines);
void 0!==a.vertexShader&&(g.vertexShader=a.vertexShader);void 0!==a.fragmentShader&&(g.fragmentShader=a.fragmentShader);if(void 0!==a.extensions)for(var z in a.extensions)g.extensions[z]=a.extensions[z];void 0!==a.shading&&(g.flatShading=1===a.shading);void 0!==a.size&&(g.size=a.size);void 0!==a.sizeAttenuation&&(g.sizeAttenuation=a.sizeAttenuation);void 0!==a.map&&(g.map=c(a.map));void 0!==a.matcap&&(g.matcap=c(a.matcap));void 0!==a.alphaMap&&(g.alphaMap=c(a.alphaMap),g.transparent=!0);void 0!==
a.bumpMap&&(g.bumpMap=c(a.bumpMap));void 0!==a.bumpScale&&(g.bumpScale=a.bumpScale);void 0!==a.normalMap&&(g.normalMap=c(a.normalMap));void 0!==a.normalMapType&&(g.normalMapType=a.normalMapType);void 0!==a.normalScale&&(r=a.normalScale,!1===Array.isArray(r)&&(r=[r,r]),g.normalScale=(new f).fromArray(r));void 0!==a.displacementMap&&(g.displacementMap=c(a.displacementMap));void 0!==a.displacementScale&&(g.displacementScale=a.displacementScale);void 0!==a.displacementBias&&(g.displacementBias=a.displacementBias);
void 0!==a.roughnessMap&&(g.roughnessMap=c(a.roughnessMap));void 0!==a.metalnessMap&&(g.metalnessMap=c(a.metalnessMap));void 0!==a.emissiveMap&&(g.emissiveMap=c(a.emissiveMap));void 0!==a.emissiveIntensity&&(g.emissiveIntensity=a.emissiveIntensity);void 0!==a.specularMap&&(g.specularMap=c(a.specularMap));void 0!==a.envMap&&(g.envMap=c(a.envMap));void 0!==a.envMapIntensity&&(g.envMapIntensity=a.envMapIntensity);void 0!==a.reflectivity&&(g.reflectivity=a.reflectivity);void 0!==a.refractionRatio&&(g.refractionRatio=
a.refractionRatio);void 0!==a.lightMap&&(g.lightMap=c(a.lightMap));void 0!==a.lightMapIntensity&&(g.lightMapIntensity=a.lightMapIntensity);void 0!==a.aoMap&&(g.aoMap=c(a.aoMap));void 0!==a.aoMapIntensity&&(g.aoMapIntensity=a.aoMapIntensity);void 0!==a.gradientMap&&(g.gradientMap=c(a.gradientMap));void 0!==a.clearcoatNormalMap&&(g.clearcoatNormalMap=c(a.clearcoatNormalMap));void 0!==a.clearcoatNormalScale&&(g.clearcoatNormalScale=(new f).fromArray(a.clearcoatNormalScale));return g},setTextures:function(a){this.textures=
a;return this}});var Pi={decodeText:function(a){if("undefined"!==typeof TextDecoder)return(new TextDecoder).decode(a);for(var c="",e=0,g=a.length;e<g;e++)c+=String.fromCharCode(a[e]);try{return decodeURIComponent(escape(c))}catch(r){return c}},extractUrlBase:function(a){var c=a.lastIndexOf("/");return-1===c?"./":a.substr(0,c+1)}};Wg.prototype=Object.assign(Object.create(va.prototype),{constructor:Wg,isInstancedBufferGeometry:!0,copy:function(a){va.prototype.copy.call(this,a);this.maxInstancedCount=
a.maxInstancedCount;return this},clone:function(){return(new this.constructor).copy(this)},toJSON:function(){var a=va.prototype.toJSON.call(this);a.maxInstancedCount=this.maxInstancedCount;a.isInstancedBufferGeometry=!0;return a}});Xg.prototype=Object.assign(Object.create(Q.prototype),{constructor:Xg,isInstancedBufferAttribute:!0,copy:function(a){Q.prototype.copy.call(this,a);this.meshPerAttribute=a.meshPerAttribute;return this},toJSON:function(){var a=Q.prototype.toJSON.call(this);a.meshPerAttribute=
this.meshPerAttribute;a.isInstancedBufferAttribute=!0;return a}});Yg.prototype=Object.assign(Object.create(Db.prototype),{constructor:Yg,load:function(a,c,e,g){var r=this,v=new uc(r.manager);v.setPath(r.path);v.load(a,function(z){c(r.parse(JSON.parse(z)))},e,g)},parse:function(a){var c=a.isInstancedBufferGeometry?new Wg:new va,e=a.data.index;if(void 0!==e){var g=new Qi[e.type](e.array);c.setIndex(new Q(g,1))}e=a.data.attributes;for(var r in e){var v=e[r];g=new Qi[v.type](v.array);g=new (v.isInstancedBufferAttribute?
Xg:Q)(g,v.itemSize,v.normalized);void 0!==v.name&&(g.name=v.name);c.addAttribute(r,g)}var z=a.data.morphAttributes;if(z)for(r in z){var E=z[r],F=[];e=0;for(var J=E.length;e<J;e++)v=E[e],g=new Qi[v.type](v.array),g=new Q(g,v.itemSize,v.normalized),void 0!==v.name&&(g.name=v.name),F.push(g);c.morphAttributes[r]=F}r=a.data.groups||a.data.drawcalls||a.data.offsets;if(void 0!==r)for(e=0,v=r.length;e!==v;++e)g=r[e],c.addGroup(g.start,g.count,g.materialIndex);e=a.data.boundingSphere;void 0!==e&&(r=new k,
void 0!==e.center&&r.fromArray(e.center),c.boundingSphere=new G(r,e.radius));a.name&&(c.name=a.name);a.userData&&(c.userData=a.userData);return c}});var Qi={Int8Array,Uint8Array,Uint8ClampedArray:"undefined"!==typeof Uint8ClampedArray?Uint8ClampedArray:Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array};Zg.prototype=Object.assign(Object.create(Db.prototype),{constructor:Zg,load:function(a,c,e,g){var r=this,v=""===this.path?Pi.extractUrlBase(a):this.path;this.resourcePath=
this.resourcePath||v;v=new uc(r.manager);v.setPath(this.path);v.load(a,function(z){var E=null;try{E=JSON.parse(z)}catch(F){void 0!==g&&g(F);console.error("THREE:ObjectLoader: Can't parse "+a+".",F.message);return}z=E.metadata;void 0===z||void 0===z.type||"geometry"===z.type.toLowerCase()?console.error("THREE.ObjectLoader: Can't load "+a):r.parse(E,c)},e,g)},parse:function(a,c){var e=this.parseShape(a.shapes);e=this.parseGeometries(a.geometries,e);var g=this.parseImages(a.images,function(){void 0!==
c&&c(r)});g=this.parseTextures(a.textures,g);g=this.parseMaterials(a.materials,g);var r=this.parseObject(a.object,e,g);a.animations&&(r.animations=this.parseAnimations(a.animations));void 0!==a.images&&0!==a.images.length||void 0===c||c(r);return r},parseShape:function(a){var c={};if(void 0!==a)for(var e=0,g=a.length;e<g;e++){var r=(new Cd).fromJSON(a[e]);c[r.uuid]=r}return c},parseGeometries:function(a,c){var e={};if(void 0!==a)for(var g=new Yg,r=0,v=a.length;r<v;r++){var z=a[r];switch(z.type){case "PlaneGeometry":case "PlaneBufferGeometry":var E=
new gc[z.type](z.width,z.height,z.widthSegments,z.heightSegments);break;case "BoxGeometry":case "BoxBufferGeometry":case "CubeGeometry":E=new gc[z.type](z.width,z.height,z.depth,z.widthSegments,z.heightSegments,z.depthSegments);break;case "CircleGeometry":case "CircleBufferGeometry":E=new gc[z.type](z.radius,z.segments,z.thetaStart,z.thetaLength);break;case "CylinderGeometry":case "CylinderBufferGeometry":E=new gc[z.type](z.radiusTop,z.radiusBottom,z.height,z.radialSegments,z.heightSegments,z.openEnded,
z.thetaStart,z.thetaLength);break;case "ConeGeometry":case "ConeBufferGeometry":E=new gc[z.type](z.radius,z.height,z.radialSegments,z.heightSegments,z.openEnded,z.thetaStart,z.thetaLength);break;case "SphereGeometry":case "SphereBufferGeometry":E=new gc[z.type](z.radius,z.widthSegments,z.heightSegments,z.phiStart,z.phiLength,z.thetaStart,z.thetaLength);break;case "DodecahedronGeometry":case "DodecahedronBufferGeometry":case "IcosahedronGeometry":case "IcosahedronBufferGeometry":case "OctahedronGeometry":case "OctahedronBufferGeometry":case "TetrahedronGeometry":case "TetrahedronBufferGeometry":E=
new gc[z.type](z.radius,z.detail);break;case "RingGeometry":case "RingBufferGeometry":E=new gc[z.type](z.innerRadius,z.outerRadius,z.thetaSegments,z.phiSegments,z.thetaStart,z.thetaLength);break;case "TorusGeometry":case "TorusBufferGeometry":E=new gc[z.type](z.radius,z.tube,z.radialSegments,z.tubularSegments,z.arc);break;case "TorusKnotGeometry":case "TorusKnotBufferGeometry":E=new gc[z.type](z.radius,z.tube,z.tubularSegments,z.radialSegments,z.p,z.q);break;case "TubeGeometry":case "TubeBufferGeometry":E=
new gc[z.type]((new Oi[z.path.type]).fromJSON(z.path),z.tubularSegments,z.radius,z.radialSegments,z.closed);break;case "LatheGeometry":case "LatheBufferGeometry":E=new gc[z.type](z.points,z.segments,z.phiStart,z.phiLength);break;case "PolyhedronGeometry":case "PolyhedronBufferGeometry":E=new gc[z.type](z.vertices,z.indices,z.radius,z.details);break;case "ShapeGeometry":case "ShapeBufferGeometry":E=[];for(var F=0,J=z.shapes.length;F<J;F++){var P=c[z.shapes[F]];E.push(P)}E=new gc[z.type](E,z.curveSegments);
break;case "ExtrudeGeometry":case "ExtrudeBufferGeometry":E=[];F=0;for(J=z.shapes.length;F<J;F++)P=c[z.shapes[F]],E.push(P);F=z.options.extrudePath;void 0!==F&&(z.options.extrudePath=(new Oi[F.type]).fromJSON(F));E=new gc[z.type](E,z.options);break;case "BufferGeometry":case "InstancedBufferGeometry":E=g.parse(z);break;case "Geometry":"THREE"in window&&"LegacyJSONLoader"in THREE?E=(new THREE.LegacyJSONLoader).parse(z,this.resourcePath).geometry:console.error('THREE.ObjectLoader: You have to import LegacyJSONLoader in order load geometry data of type "Geometry".');
break;default:console.warn('THREE.ObjectLoader: Unsupported geometry type "'+z.type+'"');continue}E.uuid=z.uuid;void 0!==z.name&&(E.name=z.name);!0===E.isBufferGeometry&&void 0!==z.userData&&(E.userData=z.userData);e[z.uuid]=E}return e},parseMaterials:function(a,c){var e={},g={};if(void 0!==a){var r=new Vg;r.setTextures(c);c=0;for(var v=a.length;c<v;c++){var z=a[c];if("MultiMaterial"===z.type){for(var E=[],F=0;F<z.materials.length;F++){var J=z.materials[F];void 0===e[J.uuid]&&(e[J.uuid]=r.parse(J));
E.push(e[J.uuid])}g[z.uuid]=E}else void 0===e[z.uuid]&&(e[z.uuid]=r.parse(z)),g[z.uuid]=e[z.uuid]}}return g},parseAnimations:function(a){for(var c=[],e=0;e<a.length;e++){var g=a[e],r=tc.parse(g);void 0!==g.uuid&&(r.uuid=g.uuid);c.push(r)}return c},parseImages:function(a,c){function e(S){g.manager.itemStart(S);return v.load(S,function(){g.manager.itemEnd(S)},void 0,function(){g.manager.itemError(S);g.manager.itemEnd(S)})}var g=this,r={};if(void 0!==a&&0<a.length){c=new $h(c);var v=new Ue(c);v.setCrossOrigin(this.crossOrigin);
c=0;for(var z=a.length;c<z;c++){var E=a[c],F=E.url;if(Array.isArray(F)){r[E.uuid]=[];for(var J=0,P=F.length;J<P;J++){var R=F[J];R=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(R)?R:g.resourcePath+R;r[E.uuid].push(e(R))}}else R=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(E.url)?E.url:g.resourcePath+E.url,r[E.uuid]=e(R)}}return r},parseTextures:function(a,c){function e(F,J){if("number"===typeof F)return F;console.warn("THREE.ObjectLoader.parseTexture: Constant should be in numeric form.",F);return J[F]}var g={};if(void 0!==
a)for(var r=0,v=a.length;r<v;r++){var z=a[r];void 0===z.image&&console.warn('THREE.ObjectLoader: No "image" specified for',z.uuid);void 0===c[z.image]&&console.warn("THREE.ObjectLoader: Undefined image",z.image);var E=Array.isArray(c[z.image])?new cd(c[z.image]):new l(c[z.image]);E.needsUpdate=!0;E.uuid=z.uuid;void 0!==z.name&&(E.name=z.name);void 0!==z.mapping&&(E.mapping=e(z.mapping,Lm));void 0!==z.offset&&E.offset.fromArray(z.offset);void 0!==z.repeat&&E.repeat.fromArray(z.repeat);void 0!==z.center&&
E.center.fromArray(z.center);void 0!==z.rotation&&(E.rotation=z.rotation);void 0!==z.wrap&&(E.wrapS=e(z.wrap[0],sk),E.wrapT=e(z.wrap[1],sk));void 0!==z.format&&(E.format=z.format);void 0!==z.type&&(E.type=z.type);void 0!==z.encoding&&(E.encoding=z.encoding);void 0!==z.minFilter&&(E.minFilter=e(z.minFilter,tk));void 0!==z.magFilter&&(E.magFilter=e(z.magFilter,tk));void 0!==z.anisotropy&&(E.anisotropy=z.anisotropy);void 0!==z.flipY&&(E.flipY=z.flipY);void 0!==z.premultiplyAlpha&&(E.premultiplyAlpha=
z.premultiplyAlpha);void 0!==z.unpackAlignment&&(E.unpackAlignment=z.unpackAlignment);g[z.uuid]=E}return g},parseObject:function(a,c,e){function g(J){void 0===c[J]&&console.warn("THREE.ObjectLoader: Undefined geometry",J);return c[J]}function r(J){if(void 0!==J){if(Array.isArray(J)){for(var P=[],R=0,S=J.length;R<S;R++){var V=J[R];void 0===e[V]&&console.warn("THREE.ObjectLoader: Undefined material",V);P.push(e[V])}return P}void 0===e[J]&&console.warn("THREE.ObjectLoader: Undefined material",J);return e[J]}}
switch(a.type){case "Scene":var v=new y;void 0!==a.background&&Number.isInteger(a.background)&&(v.background=new I(a.background));void 0!==a.fog&&("Fog"===a.fog.type?v.fog=new Ag(a.fog.color,a.fog.near,a.fog.far):"FogExp2"===a.fog.type&&(v.fog=new zg(a.fog.color,a.fog.density)));break;case "PerspectiveCamera":v=new vb(a.fov,a.aspect,a.near,a.far);void 0!==a.focus&&(v.focus=a.focus);void 0!==a.zoom&&(v.zoom=a.zoom);void 0!==a.filmGauge&&(v.filmGauge=a.filmGauge);void 0!==a.filmOffset&&(v.filmOffset=
a.filmOffset);void 0!==a.view&&(v.view=Object.assign({},a.view));break;case "OrthographicCamera":v=new bg(a.left,a.right,a.top,a.bottom,a.near,a.far);void 0!==a.zoom&&(v.zoom=a.zoom);void 0!==a.view&&(v.view=Object.assign({},a.view));break;case "AmbientLight":v=new Tg(a.color,a.intensity);break;case "DirectionalLight":v=new Sg(a.color,a.intensity);break;case "PointLight":v=new Qg(a.color,a.intensity,a.distance,a.decay);break;case "RectAreaLight":v=new Ug(a.color,a.intensity,a.width,a.height);break;
case "SpotLight":v=new Pg(a.color,a.intensity,a.distance,a.angle,a.penumbra,a.decay);break;case "HemisphereLight":v=new Ng(a.color,a.groundColor,a.intensity);break;case "SkinnedMesh":console.warn("THREE.ObjectLoader.parseObject() does not support SkinnedMesh yet.");case "Mesh":v=g(a.geometry);var z=r(a.material);v=v.bones&&0<v.bones.length?new Bf(v,z):new xa(v,z);void 0!==a.drawMode&&v.setDrawMode(a.drawMode);break;case "LOD":v=new Af;break;case "Line":v=new Vb(g(a.geometry),r(a.material),a.mode);
break;case "LineLoop":v=new Dg(g(a.geometry),r(a.material));break;case "LineSegments":v=new Ib(g(a.geometry),r(a.material));break;case "PointCloud":case "Points":v=new Ce(g(a.geometry),r(a.material));break;case "Sprite":v=new yf(r(a.material));break;case "Group":v=new ue;break;default:v=new A}v.uuid=a.uuid;void 0!==a.name&&(v.name=a.name);void 0!==a.matrix?(v.matrix.fromArray(a.matrix),void 0!==a.matrixAutoUpdate&&(v.matrixAutoUpdate=a.matrixAutoUpdate),v.matrixAutoUpdate&&v.matrix.decompose(v.position,
v.quaternion,v.scale)):(void 0!==a.position&&v.position.fromArray(a.position),void 0!==a.rotation&&v.rotation.fromArray(a.rotation),void 0!==a.quaternion&&v.quaternion.fromArray(a.quaternion),void 0!==a.scale&&v.scale.fromArray(a.scale));void 0!==a.castShadow&&(v.castShadow=a.castShadow);void 0!==a.receiveShadow&&(v.receiveShadow=a.receiveShadow);a.shadow&&(void 0!==a.shadow.bias&&(v.shadow.bias=a.shadow.bias),void 0!==a.shadow.radius&&(v.shadow.radius=a.shadow.radius),void 0!==a.shadow.mapSize&&
v.shadow.mapSize.fromArray(a.shadow.mapSize),void 0!==a.shadow.camera&&(v.shadow.camera=this.parseObject(a.shadow.camera)));void 0!==a.visible&&(v.visible=a.visible);void 0!==a.frustumCulled&&(v.frustumCulled=a.frustumCulled);void 0!==a.renderOrder&&(v.renderOrder=a.renderOrder);void 0!==a.userData&&(v.userData=a.userData);void 0!==a.layers&&(v.layers.mask=a.layers);if(void 0!==a.children){z=a.children;for(var E=0;E<z.length;E++)v.add(this.parseObject(z[E],c,e))}if("LOD"===a.type)for(a=a.levels,z=
0;z<a.length;z++){E=a[z];var F=v.getObjectByProperty("uuid",E.object);void 0!==F&&v.addLevel(F,E.distance)}return v}});var Lm={UVMapping:300,CubeReflectionMapping:301,CubeRefractionMapping:302,EquirectangularReflectionMapping:303,EquirectangularRefractionMapping:304,SphericalReflectionMapping:305,CubeUVReflectionMapping:306,CubeUVRefractionMapping:307},sk={RepeatWrapping:1E3,ClampToEdgeWrapping:1001,MirroredRepeatWrapping:1002},tk={NearestFilter:1003,NearestMipmapNearestFilter:1004,NearestMipmapLinearFilter:1005,
LinearFilter:1006,LinearMipmapNearestFilter:1007,LinearMipmapLinearFilter:1008};ei.prototype=Object.assign(Object.create(Db.prototype),{constructor:ei,setOptions:function(a){this.options=a;return this},load:function(a,c,e,g){void 0===a&&(a="");void 0!==this.path&&(a=this.path+a);a=this.manager.resolveURL(a);var r=this,v=ie.get(a);if(void 0!==v)return r.manager.itemStart(a),setTimeout(function(){c&&c(v);r.manager.itemEnd(a)},0),v;fetch(a).then(function(z){return z.blob()}).then(function(z){return void 0===
r.options?createImageBitmap(z):createImageBitmap(z,r.options)}).then(function(z){ie.add(a,z);c&&c(z);r.manager.itemEnd(a)}).catch(function(z){g&&g(z);r.manager.itemError(a);r.manager.itemEnd(a)});r.manager.itemStart(a)}});Object.assign(fi.prototype,{moveTo:function(a,c){this.currentPath=new Gc;this.subPaths.push(this.currentPath);this.currentPath.moveTo(a,c)},lineTo:function(a,c){this.currentPath.lineTo(a,c)},quadraticCurveTo:function(a,c,e,g){this.currentPath.quadraticCurveTo(a,c,e,g)},bezierCurveTo:function(a,
c,e,g,r,v){this.currentPath.bezierCurveTo(a,c,e,g,r,v)},splineThru:function(a){this.currentPath.splineThru(a)},toShapes:function(a,c){function e(fa){for(var ra=[],pa=0,qa=fa.length;pa<qa;pa++){var ua=fa[pa],oa=new Cd;oa.curves=ua.curves;ra.push(oa)}return ra}function g(fa,ra){for(var pa=ra.length,qa=!1,ua=pa-1,oa=0;oa<pa;ua=oa++){var ta=ra[ua],Ba=ra[oa],Ta=Ba.x-ta.x,Ua=Ba.y-ta.y;if(Math.abs(Ua)>Number.EPSILON){if(0>Ua&&(ta=ra[oa],Ta=-Ta,Ba=ra[ua],Ua=-Ua),!(fa.y<ta.y||fa.y>Ba.y))if(fa.y===ta.y){if(fa.x===
ta.x)return!0}else{ua=Ua*(fa.x-ta.x)-Ta*(fa.y-ta.y);if(0===ua)return!0;0>ua||(qa=!qa)}}else if(fa.y===ta.y&&(Ba.x<=fa.x&&fa.x<=ta.x||ta.x<=fa.x&&fa.x<=Ba.x))return!0}return qa}var r=ed.isClockWise,v=this.subPaths;if(0===v.length)return[];if(!0===c)return e(v);c=[];if(1===v.length){var z=v[0];var E=new Cd;E.curves=z.curves;c.push(E);return c}var F=!r(v[0].getPoints());F=a?!F:F;E=[];var J=[],P=[],R=0;J[R]=void 0;P[R]=[];for(var S=0,V=v.length;S<V;S++){z=v[S];var W=z.getPoints();var ha=r(W);(ha=a?!ha:
ha)?(!F&&J[R]&&R++,J[R]={s:new Cd,p:W},J[R].s.curves=z.curves,F&&R++,P[R]=[]):P[R].push({h:z,p:W[0]})}if(!J[0])return e(v);if(1<J.length){S=!1;a=[];r=0;for(v=J.length;r<v;r++)E[r]=[];r=0;for(v=J.length;r<v;r++)for(z=P[r],ha=0;ha<z.length;ha++){F=z[ha];R=!0;for(W=0;W<J.length;W++)g(F.p,J[W].p)&&(r!==W&&a.push({froms:r,tos:W,hole:ha}),R?(R=!1,E[W].push(F)):S=!0);R&&E[r].push(F)}0<a.length&&(S||(P=E))}S=0;for(r=J.length;S<r;S++)for(E=J[S].s,c.push(E),a=P[S],v=0,z=a.length;v<z;v++)E.holes.push(a[v].h);
return c}});Object.assign(gi.prototype,{isFont:!0,generateShapes:function(a,c){void 0===c&&(c=100);var e=[];a=vm(a,c,this.data);c=0;for(var g=a.length;c<g;c++)Array.prototype.push.apply(e,a[c].toShapes());return e}});hi.prototype=Object.assign(Object.create(Db.prototype),{constructor:hi,load:function(a,c,e,g){var r=this,v=new uc(this.manager);v.setPath(this.path);v.load(a,function(z){try{var E=JSON.parse(z)}catch(F){console.warn("THREE.FontLoader: typeface.js support is being deprecated. Use typeface.json instead."),
E=JSON.parse(z.substring(65,z.length-2))}z=r.parse(E);c&&c(z)},e,g)},parse:function(a){return new gi(a)}});var yh,mi={getContext:function(){void 0===yh&&(yh=new (window.AudioContext||window.webkitAudioContext));return yh},setContext:function(a){yh=a}};$g.prototype=Object.assign(Object.create(Db.prototype),{constructor:$g,load:function(a,c,e,g){var r=new uc(this.manager);r.setResponseType("arraybuffer");r.setPath(this.path);r.load(a,function(v){v=v.slice(0);mi.getContext().decodeAudioData(v,function(z){c(z)})},
e,g)}});Object.assign(ah.prototype,{isSphericalHarmonics3:!0,set:function(a){for(var c=0;9>c;c++)this.coefficients[c].copy(a[c]);return this},zero:function(){for(var a=0;9>a;a++)this.coefficients[a].set(0,0,0);return this},getAt:function(a,c){var e=a.x,g=a.y;a=a.z;var r=this.coefficients;c.copy(r[0]).multiplyScalar(.282095);c.addScale(r[1],.488603*g);c.addScale(r[2],.488603*a);c.addScale(r[3],.488603*e);c.addScale(r[4],1.092548*e*g);c.addScale(r[5],1.092548*g*a);c.addScale(r[6],.315392*(3*a*a-1));
c.addScale(r[7],1.092548*e*a);c.addScale(r[8],.546274*(e*e-g*g));return c},getIrradianceAt:function(a,c){var e=a.x,g=a.y;a=a.z;var r=this.coefficients;c.copy(r[0]).multiplyScalar(.886227);c.addScale(r[1],1.023328*g);c.addScale(r[2],1.023328*a);c.addScale(r[3],1.023328*e);c.addScale(r[4],.858086*e*g);c.addScale(r[5],.858086*g*a);c.addScale(r[6],.743125*a*a-.247708);c.addScale(r[7],.858086*e*a);c.addScale(r[8],.429043*(e*e-g*g));return c},add:function(a){for(var c=0;9>c;c++)this.coefficients[c].add(a.coefficients[c]);
return this},scale:function(a){for(var c=0;9>c;c++)this.coefficients[c].multiplyScalar(a);return this},lerp:function(a,c){for(var e=0;9>e;e++)this.coefficients[e].lerp(a.coefficients[e],c);return this},equals:function(a){for(var c=0;9>c;c++)if(!this.coefficients[c].equals(a.coefficients[c]))return!1;return!0},copy:function(a){return this.set(a.coefficients)},clone:function(){return(new this.constructor).copy(this)},fromArray:function(a,c){void 0===c&&(c=0);for(var e=this.coefficients,g=0;9>g;g++)e[g].fromArray(a,
c+3*g);return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);for(var e=this.coefficients,g=0;9>g;g++)e[g].toArray(a,c+3*g);return a}});Object.assign(ah,{getBasisAt:function(a,c){var e=a.x,g=a.y;a=a.z;c[0]=.282095;c[1]=.488603*g;c[2]=.488603*a;c[3]=.488603*e;c[4]=1.092548*e*g;c[5]=1.092548*g*a;c[6]=.315392*(3*a*a-1);c[7]=1.092548*e*a;c[8]=.546274*(e*e-g*g)}});Hc.prototype=Object.assign(Object.create(Jb.prototype),{constructor:Hc,isLightProbe:!0,copy:function(a){Jb.prototype.copy.call(this,
a);this.sh.copy(a.sh);this.intensity=a.intensity;return this},toJSON:function(a){return Jb.prototype.toJSON.call(this,a)}});ii.prototype=Object.assign(Object.create(Hc.prototype),{constructor:ii,isHemisphereLightProbe:!0,copy:function(a){Hc.prototype.copy.call(this,a);return this},toJSON:function(a){return Hc.prototype.toJSON.call(this,a)}});ji.prototype=Object.assign(Object.create(Hc.prototype),{constructor:ji,isAmbientLightProbe:!0,copy:function(a){Hc.prototype.copy.call(this,a);return this},toJSON:function(a){return Hc.prototype.toJSON.call(this,
a)}});var uk=new q,vk=new q;Object.assign(Qj.prototype,{update:function(a){var c=this._cache;if(c.focus!==a.focus||c.fov!==a.fov||c.aspect!==a.aspect*this.aspect||c.near!==a.near||c.far!==a.far||c.zoom!==a.zoom||c.eyeSep!==this.eyeSep){c.focus=a.focus;c.fov=a.fov;c.aspect=a.aspect*this.aspect;c.near=a.near;c.far=a.far;c.zoom=a.zoom;c.eyeSep=this.eyeSep;var e=a.projectionMatrix.clone(),g=c.eyeSep/2,r=g*c.near/c.focus,v=c.near*Math.tan(hb.DEG2RAD*c.fov*.5)/c.zoom;vk.elements[12]=-g;uk.elements[12]=
g;g=-v*c.aspect+r;var z=v*c.aspect+r;e.elements[0]=2*c.near/(z-g);e.elements[8]=(z+g)/(z-g);this.cameraL.projectionMatrix.copy(e);g=-v*c.aspect-r;z=v*c.aspect-r;e.elements[0]=2*c.near/(z-g);e.elements[8]=(z+g)/(z-g);this.cameraR.projectionMatrix.copy(e)}this.cameraL.matrixWorld.copy(a.matrixWorld).multiply(vk);this.cameraR.matrixWorld.copy(a.matrixWorld).multiply(uk)}});Object.assign(ki.prototype,{start:function(){this.oldTime=this.startTime=("undefined"===typeof performance?Date:performance).now();
this.elapsedTime=0;this.running=!0},stop:function(){this.getElapsedTime();this.autoStart=this.running=!1},getElapsedTime:function(){this.getDelta();return this.elapsedTime},getDelta:function(){var a=0;if(this.autoStart&&!this.running)return this.start(),0;if(this.running){var c=("undefined"===typeof performance?Date:performance).now();a=(c-this.oldTime)/1E3;this.oldTime=c;this.elapsedTime+=a}return a}});var je=new k,wk=new h,Mm=new k,ke=new k;li.prototype=Object.assign(Object.create(A.prototype),
{constructor:li,getInput:function(){return this.gain},removeFilter:function(){null!==this.filter&&(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination),this.gain.connect(this.context.destination),this.filter=null);return this},getFilter:function(){return this.filter},setFilter:function(a){null!==this.filter?(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination)):this.gain.disconnect(this.context.destination);this.filter=a;this.gain.connect(this.filter);
this.filter.connect(this.context.destination);return this},getMasterVolume:function(){return this.gain.gain.value},setMasterVolume:function(a){this.gain.gain.setTargetAtTime(a,this.context.currentTime,.01);return this},updateMatrixWorld:function(a){A.prototype.updateMatrixWorld.call(this,a);a=this.context.listener;var c=this.up;this.timeDelta=this._clock.getDelta();this.matrixWorld.decompose(je,wk,Mm);ke.set(0,0,-1).applyQuaternion(wk);if(a.positionX){var e=this.context.currentTime+this.timeDelta;
a.positionX.linearRampToValueAtTime(je.x,e);a.positionY.linearRampToValueAtTime(je.y,e);a.positionZ.linearRampToValueAtTime(je.z,e);a.forwardX.linearRampToValueAtTime(ke.x,e);a.forwardY.linearRampToValueAtTime(ke.y,e);a.forwardZ.linearRampToValueAtTime(ke.z,e);a.upX.linearRampToValueAtTime(c.x,e);a.upY.linearRampToValueAtTime(c.y,e);a.upZ.linearRampToValueAtTime(c.z,e)}else a.setPosition(je.x,je.y,je.z),a.setOrientation(ke.x,ke.y,ke.z,c.x,c.y,c.z)}});We.prototype=Object.assign(Object.create(A.prototype),
{constructor:We,getOutput:function(){return this.gain},setNodeSource:function(a){this.hasPlaybackControl=!1;this.sourceType="audioNode";this.source=a;this.connect();return this},setMediaElementSource:function(a){this.hasPlaybackControl=!1;this.sourceType="mediaNode";this.source=this.context.createMediaElementSource(a);this.connect();return this},setBuffer:function(a){this.buffer=a;this.sourceType="buffer";this.autoplay&&this.play();return this},play:function(){if(!0===this.isPlaying)console.warn("THREE.Audio: Audio is already playing.");
else if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");else{var a=this.context.createBufferSource();a.buffer=this.buffer;a.loop=this.loop;a.onended=this.onEnded.bind(this);this.startTime=this.context.currentTime;a.start(this.startTime,this.offset,this.duration);this.isPlaying=!0;this.source=a;this.setDetune(this.detune);this.setPlaybackRate(this.playbackRate);return this.connect()}},pause:function(){if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");
else return!0===this.isPlaying&&(this.source.stop(),this.source.onended=null,this.offset+=(this.context.currentTime-this.startTime)*this.playbackRate,this.isPlaying=!1),this},stop:function(){if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");else return this.source.stop(),this.source.onended=null,this.offset=0,this.isPlaying=!1,this},connect:function(){if(0<this.filters.length){this.source.connect(this.filters[0]);for(var a=1,c=this.filters.length;a<c;a++)this.filters[a-
1].connect(this.filters[a]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this},disconnect:function(){if(0<this.filters.length){this.source.disconnect(this.filters[0]);for(var a=1,c=this.filters.length;a<c;a++)this.filters[a-1].disconnect(this.filters[a]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this},getFilters:function(){return this.filters},setFilters:function(a){a||
(a=[]);!0===this.isPlaying?(this.disconnect(),this.filters=a,this.connect()):this.filters=a;return this},setDetune:function(a){this.detune=a;if(void 0!==this.source.detune)return!0===this.isPlaying&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this},getDetune:function(){return this.detune},getFilter:function(){return this.getFilters()[0]},setFilter:function(a){return this.setFilters(a?[a]:[])},setPlaybackRate:function(a){if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");
else return this.playbackRate=a,!0===this.isPlaying&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this},getPlaybackRate:function(){return this.playbackRate},onEnded:function(){this.isPlaying=!1},getLoop:function(){return!1===this.hasPlaybackControl?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop},setLoop:function(a){if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");else return this.loop=
a,!0===this.isPlaying&&(this.source.loop=this.loop),this},getVolume:function(){return this.gain.gain.value},setVolume:function(a){this.gain.gain.setTargetAtTime(a,this.context.currentTime,.01);return this}});var le=new k,xk=new h,Nm=new k,me=new k;ni.prototype=Object.assign(Object.create(We.prototype),{constructor:ni,getOutput:function(){return this.panner},getRefDistance:function(){return this.panner.refDistance},setRefDistance:function(a){this.panner.refDistance=a;return this},getRolloffFactor:function(){return this.panner.rolloffFactor},
setRolloffFactor:function(a){this.panner.rolloffFactor=a;return this},getDistanceModel:function(){return this.panner.distanceModel},setDistanceModel:function(a){this.panner.distanceModel=a;return this},getMaxDistance:function(){return this.panner.maxDistance},setMaxDistance:function(a){this.panner.maxDistance=a;return this},setDirectionalCone:function(a,c,e){this.panner.coneInnerAngle=a;this.panner.coneOuterAngle=c;this.panner.coneOuterGain=e;return this},updateMatrixWorld:function(a){A.prototype.updateMatrixWorld.call(this,
a);if(!0!==this.hasPlaybackControl||!1!==this.isPlaying)if(this.matrixWorld.decompose(le,xk,Nm),me.set(0,0,1).applyQuaternion(xk),a=this.panner,a.positionX){var c=this.context.currentTime+this.listener.timeDelta;a.positionX.linearRampToValueAtTime(le.x,c);a.positionY.linearRampToValueAtTime(le.y,c);a.positionZ.linearRampToValueAtTime(le.z,c);a.orientationX.linearRampToValueAtTime(me.x,c);a.orientationY.linearRampToValueAtTime(me.y,c);a.orientationZ.linearRampToValueAtTime(me.z,c)}else a.setPosition(le.x,
le.y,le.z),a.setOrientation(me.x,me.y,me.z)}});Object.assign(oi.prototype,{getFrequencyData:function(){this.analyser.getByteFrequencyData(this.data);return this.data},getAverageFrequency:function(){for(var a=0,c=this.getFrequencyData(),e=0;e<c.length;e++)a+=c[e];return a/c.length}});Object.assign(pi.prototype,{accumulate:function(a,c){var e=this.buffer,g=this.valueSize;a=a*g+g;var r=this.cumulativeWeight;if(0===r){for(r=0;r!==g;++r)e[a+r]=e[r];r=c}else r+=c,this._mixBufferRegion(e,a,0,c/r,g);this.cumulativeWeight=
r},apply:function(a){var c=this.valueSize,e=this.buffer;a=a*c+c;var g=this.cumulativeWeight,r=this.binding;this.cumulativeWeight=0;1>g&&this._mixBufferRegion(e,a,3*c,1-g,c);g=c;for(var v=c+c;g!==v;++g)if(e[g]!==e[g+c]){r.setValue(e,a);break}},saveOriginalState:function(){var a=this.buffer,c=this.valueSize,e=3*c;this.binding.getValue(a,e);for(var g=c;g!==e;++g)a[g]=a[e+g%c];this.cumulativeWeight=0},restoreOriginalState:function(){this.binding.setValue(this.buffer,3*this.valueSize)},_select:function(a,
c,e,g,r){if(.5<=g)for(g=0;g!==r;++g)a[c+g]=a[e+g]},_slerp:function(a,c,e,g){h.slerpFlat(a,c,a,c,a,e,g)},_lerp:function(a,c,e,g,r){for(var v=1-g,z=0;z!==r;++z){var E=c+z;a[E]=a[E]*v+a[e+z]*g}}});var Om=/[\[\]\.:\/]/g,Pm="[^"+"\\[\\]\\.:\\/".replace("\\.","")+"]",Qm=/((?:WC+[\/:])*)/.source.replace("WC","[^\\[\\]\\.:\\/]"),Rm=/(WCOD+)?/.source.replace("WCOD",Pm),Sm=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC","[^\\[\\]\\.:\\/]"),Tm=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC","[^\\[\\]\\.:\\/]"),Um=
new RegExp("^"+Qm+Rm+Sm+Tm+"$"),Vm=["material","materials","bones"];Object.assign(Rj.prototype,{getValue:function(a,c){this.bind();var e=this._bindings[this._targetGroup.nCachedObjects_];void 0!==e&&e.getValue(a,c)},setValue:function(a,c){for(var e=this._bindings,g=this._targetGroup.nCachedObjects_,r=e.length;g!==r;++g)e[g].setValue(a,c)},bind:function(){for(var a=this._bindings,c=this._targetGroup.nCachedObjects_,e=a.length;c!==e;++c)a[c].bind()},unbind:function(){for(var a=this._bindings,c=this._targetGroup.nCachedObjects_,
e=a.length;c!==e;++c)a[c].unbind()}});Object.assign($b,{Composite:Rj,create:function(a,c,e){return a&&a.isAnimationObjectGroup?new $b.Composite(a,c,e):new $b(a,c,e)},sanitizeNodeName:function(a){return a.replace(/\s/g,"_").replace(Om,"")},parseTrackName:function(a){var c=Um.exec(a);if(!c)throw Error("PropertyBinding: Cannot parse trackName: "+a);c={nodeName:c[2],objectName:c[3],objectIndex:c[4],propertyName:c[5],propertyIndex:c[6]};var e=c.nodeName&&c.nodeName.lastIndexOf(".");if(void 0!==e&&-1!==
e){var g=c.nodeName.substring(e+1);-1!==Vm.indexOf(g)&&(c.nodeName=c.nodeName.substring(0,e),c.objectName=g)}if(null===c.propertyName||0===c.propertyName.length)throw Error("PropertyBinding: can not parse propertyName from trackName: "+a);return c},findNode:function(a,c){if(!c||""===c||"root"===c||"."===c||-1===c||c===a.name||c===a.uuid)return a;if(a.skeleton){var e=a.skeleton.getBoneByName(c);if(void 0!==e)return e}if(a.children){var g=function(r){for(var v=0;v<r.length;v++){var z=r[v];if(z.name===
c||z.uuid===c)return z;if(z=g(z.children))return z}return null};if(a=g(a.children))return a}return null}});Object.assign($b.prototype,{_getValue_unavailable:function(){},_setValue_unavailable:function(){},BindingType:{Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3},Versioning:{None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2},GetterByBindingType:[function(a,c){a[c]=this.node[this.propertyName]},function(a,c){for(var e=this.resolvedProperty,g=0,r=e.length;g!==r;++g)a[c++]=e[g]},function(a,c){a[c]=
this.resolvedProperty[this.propertyIndex]},function(a,c){this.resolvedProperty.toArray(a,c)}],SetterByBindingTypeAndVersioning:[[function(a,c){this.targetObject[this.propertyName]=a[c]},function(a,c){this.targetObject[this.propertyName]=a[c];this.targetObject.needsUpdate=!0},function(a,c){this.targetObject[this.propertyName]=a[c];this.targetObject.matrixWorldNeedsUpdate=!0}],[function(a,c){for(var e=this.resolvedProperty,g=0,r=e.length;g!==r;++g)e[g]=a[c++]},function(a,c){for(var e=this.resolvedProperty,
g=0,r=e.length;g!==r;++g)e[g]=a[c++];this.targetObject.needsUpdate=!0},function(a,c){for(var e=this.resolvedProperty,g=0,r=e.length;g!==r;++g)e[g]=a[c++];this.targetObject.matrixWorldNeedsUpdate=!0}],[function(a,c){this.resolvedProperty[this.propertyIndex]=a[c]},function(a,c){this.resolvedProperty[this.propertyIndex]=a[c];this.targetObject.needsUpdate=!0},function(a,c){this.resolvedProperty[this.propertyIndex]=a[c];this.targetObject.matrixWorldNeedsUpdate=!0}],[function(a,c){this.resolvedProperty.fromArray(a,
c)},function(a,c){this.resolvedProperty.fromArray(a,c);this.targetObject.needsUpdate=!0},function(a,c){this.resolvedProperty.fromArray(a,c);this.targetObject.matrixWorldNeedsUpdate=!0}]],getValue:function(a,c){this.bind();this.getValue(a,c)},setValue:function(a,c){this.bind();this.setValue(a,c)},bind:function(){var a=this.node,c=this.parsedPath,e=c.objectName,g=c.propertyName,r=c.propertyIndex;a||(this.node=a=$b.findNode(this.rootNode,c.nodeName)||this.rootNode);this.getValue=this._getValue_unavailable;
this.setValue=this._setValue_unavailable;if(a){if(e){var v=c.objectIndex;switch(e){case "materials":if(!a.material){console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);return}if(!a.material.materials){console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);return}a=a.material.materials;break;case "bones":if(!a.skeleton){console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",
this);return}a=a.skeleton.bones;for(e=0;e<a.length;e++)if(a[e].name===v){v=e;break}break;default:if(void 0===a[e]){console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);return}a=a[e]}if(void 0!==v){if(void 0===a[v]){console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,a);return}a=a[v]}}v=a[g];if(void 0===v)console.error("THREE.PropertyBinding: Trying to update property for track: "+c.nodeName+"."+g+" but it wasn't found.",
a);else{c=this.Versioning.None;this.targetObject=a;void 0!==a.needsUpdate?c=this.Versioning.NeedsUpdate:void 0!==a.matrixWorldNeedsUpdate&&(c=this.Versioning.MatrixWorldNeedsUpdate);e=this.BindingType.Direct;if(void 0!==r){if("morphTargetInfluences"===g){if(!a.geometry){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);return}if(a.geometry.isBufferGeometry){if(!a.geometry.morphAttributes){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",
this);return}for(e=0;e<this.node.geometry.morphAttributes.position.length;e++)if(a.geometry.morphAttributes.position[e].name===r){r=e;break}}else{if(!a.geometry.morphTargets){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphTargets.",this);return}for(e=0;e<this.node.geometry.morphTargets.length;e++)if(a.geometry.morphTargets[e].name===r){r=e;break}}}e=this.BindingType.ArrayElement;this.resolvedProperty=v;this.propertyIndex=r}else void 0!==
v.fromArray&&void 0!==v.toArray?(e=this.BindingType.HasFromToArray,this.resolvedProperty=v):Array.isArray(v)?(e=this.BindingType.EntireArray,this.resolvedProperty=v):this.propertyName=g;this.getValue=this.GetterByBindingType[e];this.setValue=this.SetterByBindingTypeAndVersioning[e][c]}}else console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.")},unbind:function(){this.node=null;this.getValue=this._getValue_unbound;this.setValue=this._setValue_unbound}});
Object.assign($b.prototype,{_getValue_unbound:$b.prototype.getValue,_setValue_unbound:$b.prototype.setValue});Object.assign(Sj.prototype,{isAnimationObjectGroup:!0,add:function(){for(var a=this._objects,c=a.length,e=this.nCachedObjects_,g=this._indicesByUUID,r=this._paths,v=this._parsedPaths,z=this._bindings,E=z.length,F=void 0,J=0,P=arguments.length;J!==P;++J){var R=arguments[J],S=R.uuid,V=g[S];if(void 0===V){V=c++;g[S]=V;a.push(R);S=0;for(var W=E;S!==W;++S)z[S].push(new $b(R,r[S],v[S]))}else if(V<
e){F=a[V];var ha=--e;W=a[ha];g[W.uuid]=V;a[V]=W;g[S]=ha;a[ha]=R;S=0;for(W=E;S!==W;++S){var fa=z[S],ra=fa[V];fa[V]=fa[ha];void 0===ra&&(ra=new $b(R,r[S],v[S]));fa[ha]=ra}}else a[V]!==F&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=e},remove:function(){for(var a=this._objects,c=this.nCachedObjects_,e=this._indicesByUUID,g=this._bindings,r=g.length,v=0,z=arguments.length;v!==
z;++v){var E=arguments[v],F=E.uuid,J=e[F];if(void 0!==J&&J>=c){var P=c++,R=a[P];e[R.uuid]=J;a[J]=R;e[F]=P;a[P]=E;E=0;for(F=r;E!==F;++E){R=g[E];var S=R[J];R[J]=R[P];R[P]=S}}}this.nCachedObjects_=c},uncache:function(){for(var a=this._objects,c=a.length,e=this.nCachedObjects_,g=this._indicesByUUID,r=this._bindings,v=r.length,z=0,E=arguments.length;z!==E;++z){var F=arguments[z].uuid,J=g[F];if(void 0!==J)if(delete g[F],J<e){F=--e;var P=a[F],R=--c,S=a[R];g[P.uuid]=J;a[J]=P;g[S.uuid]=F;a[F]=S;a.pop();P=
0;for(S=v;P!==S;++P){var V=r[P],W=V[R];V[J]=V[F];V[F]=W;V.pop()}}else for(R=--c,S=a[R],g[S.uuid]=J,a[J]=S,a.pop(),P=0,S=v;P!==S;++P)V=r[P],V[J]=V[R],V.pop()}this.nCachedObjects_=e},subscribe_:function(a,c){var e=this._bindingsIndicesByPath,g=e[a],r=this._bindings;if(void 0!==g)return r[g];var v=this._paths,z=this._parsedPaths,E=this._objects,F=this.nCachedObjects_,J=Array(E.length);g=r.length;e[a]=g;v.push(a);z.push(c);r.push(J);e=F;for(g=E.length;e!==g;++e)J[e]=new $b(E[e],a,c);return J},unsubscribe_:function(a){var c=
this._bindingsIndicesByPath,e=c[a];if(void 0!==e){var g=this._paths,r=this._parsedPaths,v=this._bindings,z=v.length-1,E=v[z];c[a[z]]=e;v[e]=E;v.pop();r[e]=r[z];r.pop();g[e]=g[z];g.pop()}}});Object.assign(Tj.prototype,{play:function(){this._mixer._activateAction(this);return this},stop:function(){this._mixer._deactivateAction(this);return this.reset()},reset:function(){this.paused=!1;this.enabled=!0;this.time=0;this._loopCount=-1;this._startTime=null;return this.stopFading().stopWarping()},isRunning:function(){return this.enabled&&
!this.paused&&0!==this.timeScale&&null===this._startTime&&this._mixer._isActiveAction(this)},isScheduled:function(){return this._mixer._isActiveAction(this)},startAt:function(a){this._startTime=a;return this},setLoop:function(a,c){this.loop=a;this.repetitions=c;return this},setEffectiveWeight:function(a){this.weight=a;this._effectiveWeight=this.enabled?a:0;return this.stopFading()},getEffectiveWeight:function(){return this._effectiveWeight},fadeIn:function(a){return this._scheduleFading(a,0,1)},fadeOut:function(a){return this._scheduleFading(a,
1,0)},crossFadeFrom:function(a,c,e){a.fadeOut(c);this.fadeIn(c);if(e){e=this._clip.duration;var g=a._clip.duration,r=e/g;a.warp(1,g/e,c);this.warp(r,1,c)}return this},crossFadeTo:function(a,c,e){return a.crossFadeFrom(this,c,e)},stopFading:function(){var a=this._weightInterpolant;null!==a&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(a));return this},setEffectiveTimeScale:function(a){this.timeScale=a;this._effectiveTimeScale=this.paused?0:a;return this.stopWarping()},getEffectiveTimeScale:function(){return this._effectiveTimeScale},
setDuration:function(a){this.timeScale=this._clip.duration/a;return this.stopWarping()},syncWith:function(a){this.time=a.time;this.timeScale=a.timeScale;return this.stopWarping()},halt:function(a){return this.warp(this._effectiveTimeScale,0,a)},warp:function(a,c,e){var g=this._mixer,r=g.time,v=this._timeScaleInterpolant,z=this.timeScale;null===v&&(this._timeScaleInterpolant=v=g._lendControlInterpolant());g=v.parameterPositions;v=v.sampleValues;g[0]=r;g[1]=r+e;v[0]=a/z;v[1]=c/z;return this},stopWarping:function(){var a=
this._timeScaleInterpolant;null!==a&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(a));return this},getMixer:function(){return this._mixer},getClip:function(){return this._clip},getRoot:function(){return this._localRoot||this._mixer._root},_update:function(a,c,e,g){if(this.enabled){var r=this._startTime;if(null!==r){c=(a-r)*e;if(0>c||0===e)return;this._startTime=null;c*=e}c*=this._updateTimeScale(a);e=this._updateTime(c);a=this._updateWeight(a);if(0<a){c=this._interpolants;
r=this._propertyBindings;for(var v=0,z=c.length;v!==z;++v)c[v].evaluate(e),r[v].accumulate(g,a)}}else this._updateWeight(a)},_updateWeight:function(a){var c=0;if(this.enabled){c=this.weight;var e=this._weightInterpolant;if(null!==e){var g=e.evaluate(a)[0];c*=g;a>e.parameterPositions[1]&&(this.stopFading(),0===g&&(this.enabled=!1))}}return this._effectiveWeight=c},_updateTimeScale:function(a){var c=0;if(!this.paused){c=this.timeScale;var e=this._timeScaleInterpolant;if(null!==e){var g=e.evaluate(a)[0];
c*=g;a>e.parameterPositions[1]&&(this.stopWarping(),0===c?this.paused=!0:this.timeScale=c)}}return this._effectiveTimeScale=c},_updateTime:function(a){var c=this.time+a,e=this._clip.duration,g=this.loop,r=this._loopCount,v=2202===g;if(0===a)return-1===r?c:v&&1===(r&1)?e-c:c;if(2200===g)a:{if(-1===r&&(this._loopCount=0,this._setEndings(!0,!0,!1)),c>=e)c=e;else if(0>c)c=0;else{this.time=c;break a}this.clampWhenFinished?this.paused=!0:this.enabled=!1;this.time=c;this._mixer.dispatchEvent({type:"finished",
action:this,direction:0>a?-1:1})}else{-1===r&&(0<=a?(r=0,this._setEndings(!0,0===this.repetitions,v)):this._setEndings(0===this.repetitions,!0,v));if(c>=e||0>c){g=Math.floor(c/e);c-=e*g;r+=Math.abs(g);var z=this.repetitions-r;0>=z?(this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=c=0<a?e:0,this._mixer.dispatchEvent({type:"finished",action:this,direction:0<a?1:-1})):(1===z?(a=0>a,this._setEndings(a,!a,v)):this._setEndings(!1,!1,v),this._loopCount=r,this.time=c,this._mixer.dispatchEvent({type:"loop",
action:this,loopDelta:g}))}else this.time=c;if(v&&1===(r&1))return e-c}return c},_setEndings:function(a,c,e){var g=this._interpolantSettings;e?(g.endingStart=2401,g.endingEnd=2401):(g.endingStart=a?this.zeroSlopeAtStart?2401:2400:2402,g.endingEnd=c?this.zeroSlopeAtEnd?2401:2400:2402)},_scheduleFading:function(a,c,e){var g=this._mixer,r=g.time,v=this._weightInterpolant;null===v&&(this._weightInterpolant=v=g._lendControlInterpolant());g=v.parameterPositions;v=v.sampleValues;g[0]=r;v[0]=c;g[1]=r+a;v[1]=
e;return this}});qi.prototype=Object.assign(Object.create(d.prototype),{constructor:qi,_bindAction:function(a,c){var e=a._localRoot||this._root,g=a._clip.tracks,r=g.length,v=a._propertyBindings;a=a._interpolants;var z=e.uuid,E=this._bindingsByRootAndName,F=E[z];void 0===F&&(F={},E[z]=F);for(E=0;E!==r;++E){var J=g[E],P=J.name,R=F[P];if(void 0===R){R=v[E];if(void 0!==R){null===R._cacheIndex&&(++R.referenceCount,this._addInactiveBinding(R,z,P));continue}R=new pi($b.create(e,P,c&&c._propertyBindings[E].binding.parsedPath),
J.ValueTypeName,J.getValueSize());++R.referenceCount;this._addInactiveBinding(R,z,P)}v[E]=R;a[E].resultBuffer=R.buffer}},_activateAction:function(a){if(!this._isActiveAction(a)){if(null===a._cacheIndex){var c=(a._localRoot||this._root).uuid,e=a._clip.uuid,g=this._actionsByClip[e];this._bindAction(a,g&&g.knownActions[0]);this._addInactiveAction(a,e,c)}c=a._propertyBindings;e=0;for(g=c.length;e!==g;++e){var r=c[e];0===r.useCount++&&(this._lendBinding(r),r.saveOriginalState())}this._lendAction(a)}},
_deactivateAction:function(a){if(this._isActiveAction(a)){for(var c=a._propertyBindings,e=0,g=c.length;e!==g;++e){var r=c[e];0===--r.useCount&&(r.restoreOriginalState(),this._takeBackBinding(r))}this._takeBackAction(a)}},_initMemoryManager:function(){this._actions=[];this._nActiveActions=0;this._actionsByClip={};this._bindings=[];this._nActiveBindings=0;this._bindingsByRootAndName={};this._controlInterpolants=[];this._nActiveControlInterpolants=0;var a=this;this.stats={actions:{get total(){return a._actions.length},
get inUse(){return a._nActiveActions}},bindings:{get total(){return a._bindings.length},get inUse(){return a._nActiveBindings}},controlInterpolants:{get total(){return a._controlInterpolants.length},get inUse(){return a._nActiveControlInterpolants}}}},_isActiveAction:function(a){a=a._cacheIndex;return null!==a&&a<this._nActiveActions},_addInactiveAction:function(a,c,e){var g=this._actions,r=this._actionsByClip,v=r[c];void 0===v?(v={knownActions:[a],actionByRoot:{}},a._byClipCacheIndex=0,r[c]=v):(c=
v.knownActions,a._byClipCacheIndex=c.length,c.push(a));a._cacheIndex=g.length;g.push(a);v.actionByRoot[e]=a},_removeInactiveAction:function(a){var c=this._actions,e=c[c.length-1],g=a._cacheIndex;e._cacheIndex=g;c[g]=e;c.pop();a._cacheIndex=null;c=a._clip.uuid;e=this._actionsByClip;g=e[c];var r=g.knownActions,v=r[r.length-1],z=a._byClipCacheIndex;v._byClipCacheIndex=z;r[z]=v;r.pop();a._byClipCacheIndex=null;delete g.actionByRoot[(a._localRoot||this._root).uuid];0===r.length&&delete e[c];this._removeInactiveBindingsForAction(a)},
_removeInactiveBindingsForAction:function(a){a=a._propertyBindings;for(var c=0,e=a.length;c!==e;++c){var g=a[c];0===--g.referenceCount&&this._removeInactiveBinding(g)}},_lendAction:function(a){var c=this._actions,e=a._cacheIndex,g=this._nActiveActions++,r=c[g];a._cacheIndex=g;c[g]=a;r._cacheIndex=e;c[e]=r},_takeBackAction:function(a){var c=this._actions,e=a._cacheIndex,g=--this._nActiveActions,r=c[g];a._cacheIndex=g;c[g]=a;r._cacheIndex=e;c[e]=r},_addInactiveBinding:function(a,c,e){var g=this._bindingsByRootAndName,
r=g[c],v=this._bindings;void 0===r&&(r={},g[c]=r);r[e]=a;a._cacheIndex=v.length;v.push(a)},_removeInactiveBinding:function(a){var c=this._bindings,e=a.binding,g=e.rootNode.uuid;e=e.path;var r=this._bindingsByRootAndName,v=r[g],z=c[c.length-1];a=a._cacheIndex;z._cacheIndex=a;c[a]=z;c.pop();delete v[e];0===Object.keys(v).length&&delete r[g]},_lendBinding:function(a){var c=this._bindings,e=a._cacheIndex,g=this._nActiveBindings++,r=c[g];a._cacheIndex=g;c[g]=a;r._cacheIndex=e;c[e]=r},_takeBackBinding:function(a){var c=
this._bindings,e=a._cacheIndex,g=--this._nActiveBindings,r=c[g];a._cacheIndex=g;c[g]=a;r._cacheIndex=e;c[e]=r},_lendControlInterpolant:function(){var a=this._controlInterpolants,c=this._nActiveControlInterpolants++,e=a[c];void 0===e&&(e=new Yf(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),e.__cacheIndex=c,a[c]=e);return e},_takeBackControlInterpolant:function(a){var c=this._controlInterpolants,e=a.__cacheIndex,g=--this._nActiveControlInterpolants,r=c[g];a.__cacheIndex=
g;c[g]=a;r.__cacheIndex=e;c[e]=r},_controlInterpolantsResultBuffer:new Float32Array(1),clipAction:function(a,c){var e=c||this._root,g=e.uuid;e="string"===typeof a?tc.findByName(e,a):a;a=null!==e?e.uuid:a;var r=this._actionsByClip[a],v=null;if(void 0!==r){v=r.actionByRoot[g];if(void 0!==v)return v;v=r.knownActions[0];null===e&&(e=v._clip)}if(null===e)return null;c=new Tj(this,e,c);this._bindAction(c,v);this._addInactiveAction(c,a,g);return c},existingAction:function(a,c){var e=c||this._root;c=e.uuid;
e="string"===typeof a?tc.findByName(e,a):a;a=this._actionsByClip[e?e.uuid:a];return void 0!==a?a.actionByRoot[c]||null:null},stopAllAction:function(){for(var a=this._actions,c=this._nActiveActions,e=this._bindings,g=this._nActiveBindings,r=this._nActiveBindings=this._nActiveActions=0;r!==c;++r)a[r].reset();for(r=0;r!==g;++r)e[r].useCount=0;return this},update:function(a){a*=this.timeScale;for(var c=this._actions,e=this._nActiveActions,g=this.time+=a,r=Math.sign(a),v=this._accuIndex^=1,z=0;z!==e;++z)c[z]._update(g,
a,r,v);a=this._bindings;c=this._nActiveBindings;for(z=0;z!==c;++z)a[z].apply(v);return this},getRoot:function(){return this._root},uncacheClip:function(a){var c=this._actions;a=a.uuid;var e=this._actionsByClip,g=e[a];if(void 0!==g){g=g.knownActions;for(var r=0,v=g.length;r!==v;++r){var z=g[r];this._deactivateAction(z);var E=z._cacheIndex,F=c[c.length-1];z._cacheIndex=null;z._byClipCacheIndex=null;F._cacheIndex=E;c[E]=F;c.pop();this._removeInactiveBindingsForAction(z)}delete e[a]}},uncacheRoot:function(a){a=
a.uuid;var c=this._actionsByClip;for(g in c){var e=c[g].actionByRoot[a];void 0!==e&&(this._deactivateAction(e),this._removeInactiveAction(e))}var g=this._bindingsByRootAndName[a];if(void 0!==g)for(var r in g)a=g[r],a.restoreOriginalState(),this._removeInactiveBinding(a)},uncacheAction:function(a,c){a=this.existingAction(a,c);null!==a&&(this._deactivateAction(a),this._removeInactiveAction(a))}});bh.prototype.clone=function(){return new bh(void 0===this.value.clone?this.value:this.value.clone())};ri.prototype=
Object.assign(Object.create(Qd.prototype),{constructor:ri,isInstancedInterleavedBuffer:!0,copy:function(a){Qd.prototype.copy.call(this,a);this.meshPerAttribute=a.meshPerAttribute;return this}});Object.assign(Uj.prototype,{linePrecision:1,set:function(a,c){this.ray.set(a,c)},setFromCamera:function(a,c){c&&c.isPerspectiveCamera?(this.ray.origin.setFromMatrixPosition(c.matrixWorld),this.ray.direction.set(a.x,a.y,.5).unproject(c).sub(this.ray.origin).normalize(),this.camera=c):c&&c.isOrthographicCamera?
(this.ray.origin.set(a.x,a.y,(c.near+c.far)/(c.near-c.far)).unproject(c),this.ray.direction.set(0,0,-1).transformDirection(c.matrixWorld),this.camera=c):console.error("THREE.Raycaster: Unsupported camera type.")},intersectObject:function(a,c,e){e=e||[];si(a,this,e,c);e.sort(Vj);return e},intersectObjects:function(a,c,e){e=e||[];if(!1===Array.isArray(a))return console.warn("THREE.Raycaster.intersectObjects: objects is not an Array."),e;for(var g=0,r=a.length;g<r;g++)si(a[g],this,e,c);e.sort(Vj);return e}});
Object.assign(Wj.prototype,{set:function(a,c,e){this.radius=a;this.phi=c;this.theta=e;return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.radius=a.radius;this.phi=a.phi;this.theta=a.theta;return this},makeSafe:function(){this.phi=Math.max(1E-6,Math.min(Math.PI-1E-6,this.phi));return this},setFromVector3:function(a){return this.setFromCartesianCoords(a.x,a.y,a.z)},setFromCartesianCoords:function(a,c,e){this.radius=Math.sqrt(a*a+c*c+e*e);0===this.radius?this.phi=
this.theta=0:(this.theta=Math.atan2(a,e),this.phi=Math.acos(hb.clamp(c/this.radius,-1,1)));return this}});Object.assign(Xj.prototype,{set:function(a,c,e){this.radius=a;this.theta=c;this.y=e;return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.radius=a.radius;this.theta=a.theta;this.y=a.y;return this},setFromVector3:function(a){return this.setFromCartesianCoords(a.x,a.y,a.z)},setFromCartesianCoords:function(a,c,e){this.radius=Math.sqrt(a*a+e*e);this.theta=Math.atan2(a,
e);this.y=c;return this}});var yk=new f;Object.assign(ti.prototype,{set:function(a,c){this.min.copy(a);this.max.copy(c);return this},setFromPoints:function(a){this.makeEmpty();for(var c=0,e=a.length;c<e;c++)this.expandByPoint(a[c]);return this},setFromCenterAndSize:function(a,c){c=yk.copy(c).multiplyScalar(.5);this.min.copy(a).sub(c);this.max.copy(a).add(c);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.min.copy(a.min);this.max.copy(a.max);return this},
makeEmpty:function(){this.min.x=this.min.y=Infinity;this.max.x=this.max.y=-Infinity;return this},isEmpty:function(){return this.max.x<this.min.x||this.max.y<this.min.y},getCenter:function(a){void 0===a&&(console.warn("THREE.Box2: .getCenter() target is now required"),a=new f);return this.isEmpty()?a.set(0,0):a.addVectors(this.min,this.max).multiplyScalar(.5)},getSize:function(a){void 0===a&&(console.warn("THREE.Box2: .getSize() target is now required"),a=new f);return this.isEmpty()?a.set(0,0):a.subVectors(this.max,
this.min)},expandByPoint:function(a){this.min.min(a);this.max.max(a);return this},expandByVector:function(a){this.min.sub(a);this.max.add(a);return this},expandByScalar:function(a){this.min.addScalar(-a);this.max.addScalar(a);return this},containsPoint:function(a){return a.x<this.min.x||a.x>this.max.x||a.y<this.min.y||a.y>this.max.y?!1:!0},containsBox:function(a){return this.min.x<=a.min.x&&a.max.x<=this.max.x&&this.min.y<=a.min.y&&a.max.y<=this.max.y},getParameter:function(a,c){void 0===c&&(console.warn("THREE.Box2: .getParameter() target is now required"),
c=new f);return c.set((a.x-this.min.x)/(this.max.x-this.min.x),(a.y-this.min.y)/(this.max.y-this.min.y))},intersectsBox:function(a){return a.max.x<this.min.x||a.min.x>this.max.x||a.max.y<this.min.y||a.min.y>this.max.y?!1:!0},clampPoint:function(a,c){void 0===c&&(console.warn("THREE.Box2: .clampPoint() target is now required"),c=new f);return c.copy(a).clamp(this.min,this.max)},distanceToPoint:function(a){return yk.copy(a).clamp(this.min,this.max).sub(a).length()},intersect:function(a){this.min.max(a.min);
this.max.min(a.max);return this},union:function(a){this.min.min(a.min);this.max.max(a.max);return this},translate:function(a){this.min.add(a);this.max.add(a);return this},equals:function(a){return a.min.equals(this.min)&&a.max.equals(this.max)}});var zk=new k,zh=new k;Object.assign(ui.prototype,{set:function(a,c){this.start.copy(a);this.end.copy(c);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.start.copy(a.start);this.end.copy(a.end);return this},getCenter:function(a){void 0===
a&&(console.warn("THREE.Line3: .getCenter() target is now required"),a=new k);return a.addVectors(this.start,this.end).multiplyScalar(.5)},delta:function(a){void 0===a&&(console.warn("THREE.Line3: .delta() target is now required"),a=new k);return a.subVectors(this.end,this.start)},distanceSq:function(){return this.start.distanceToSquared(this.end)},distance:function(){return this.start.distanceTo(this.end)},at:function(a,c){void 0===c&&(console.warn("THREE.Line3: .at() target is now required"),c=
new k);return this.delta(c).multiplyScalar(a).add(this.start)},closestPointToPointParameter:function(a,c){zk.subVectors(a,this.start);zh.subVectors(this.end,this.start);a=zh.dot(zk)/zh.dot(zh);c&&(a=hb.clamp(a,0,1));return a},closestPointToPoint:function(a,c,e){a=this.closestPointToPointParameter(a,c);void 0===e&&(console.warn("THREE.Line3: .closestPointToPoint() target is now required"),e=new k);return this.delta(e).multiplyScalar(a).add(this.start)},applyMatrix4:function(a){this.start.applyMatrix4(a);
this.end.applyMatrix4(a);return this},equals:function(a){return a.start.equals(this.start)&&a.end.equals(this.end)}});cg.prototype=Object.create(A.prototype);cg.prototype.constructor=cg;cg.prototype.isImmediateRenderObject=!0;var Zc=new k,od=new k,Ri=new t,Wm=["a","b","c"];dg.prototype=Object.create(Ib.prototype);dg.prototype.constructor=dg;dg.prototype.update=function(){this.object.updateMatrixWorld(!0);Ri.getNormalMatrix(this.object.matrixWorld);var a=this.object.matrixWorld,c=this.geometry.attributes.position,
e=this.object.geometry;if(e&&e.isGeometry)for(var g=e.vertices,r=e.faces,v=e=0,z=r.length;v<z;v++)for(var E=r[v],F=0,J=E.vertexNormals.length;F<J;F++){var P=E.vertexNormals[F];Zc.copy(g[E[Wm[F]]]).applyMatrix4(a);od.copy(P).applyMatrix3(Ri).normalize().multiplyScalar(this.size).add(Zc);c.setXYZ(e,Zc.x,Zc.y,Zc.z);e+=1;c.setXYZ(e,od.x,od.y,od.z);e+=1}else if(e&&e.isBufferGeometry)for(g=e.attributes.position,r=e.attributes.normal,F=e=0,J=g.count;F<J;F++)Zc.set(g.getX(F),g.getY(F),g.getZ(F)).applyMatrix4(a),
od.set(r.getX(F),r.getY(F),r.getZ(F)),od.applyMatrix3(Ri).normalize().multiplyScalar(this.size).add(Zc),c.setXYZ(e,Zc.x,Zc.y,Zc.z),e+=1,c.setXYZ(e,od.x,od.y,od.z),e+=1;c.needsUpdate=!0};var Ak=new k;Xe.prototype=Object.create(A.prototype);Xe.prototype.constructor=Xe;Xe.prototype.dispose=function(){this.cone.geometry.dispose();this.cone.material.dispose()};Xe.prototype.update=function(){this.light.updateMatrixWorld();var a=this.light.distance?this.light.distance:1E3,c=a*Math.tan(this.light.angle);
this.cone.scale.set(c,c,a);Ak.setFromMatrixPosition(this.light.target.matrixWorld);this.cone.lookAt(Ak);void 0!==this.color?this.cone.material.color.set(this.color):this.cone.material.color.copy(this.light.color)};var Id=new k,Ah=new q,Si=new q;Ye.prototype=Object.create(Ib.prototype);Ye.prototype.constructor=Ye;Ye.prototype.updateMatrixWorld=function(a){var c=this.bones,e=this.geometry,g=e.getAttribute("position");Si.getInverse(this.root.matrixWorld);for(var r=0,v=0;r<c.length;r++){var z=c[r];z.parent&&
z.parent.isBone&&(Ah.multiplyMatrices(Si,z.matrixWorld),Id.setFromMatrixPosition(Ah),g.setXYZ(v,Id.x,Id.y,Id.z),Ah.multiplyMatrices(Si,z.parent.matrixWorld),Id.setFromMatrixPosition(Ah),g.setXYZ(v+1,Id.x,Id.y,Id.z),v+=2)}e.getAttribute("position").needsUpdate=!0;A.prototype.updateMatrixWorld.call(this,a)};Ze.prototype=Object.create(xa.prototype);Ze.prototype.constructor=Ze;Ze.prototype.dispose=function(){this.geometry.dispose();this.material.dispose()};Ze.prototype.update=function(){void 0!==this.color?
this.material.color.set(this.color):this.material.color.copy(this.light.color)};$e.prototype=Object.create(Vb.prototype);$e.prototype.constructor=$e;$e.prototype.update=function(){this.scale.set(.5*this.light.width,.5*this.light.height,1);if(void 0!==this.color)this.material.color.set(this.color),this.children[0].material.color.set(this.color);else{this.material.color.copy(this.light.color).multiplyScalar(this.light.intensity);var a=this.material.color,c=Math.max(a.r,a.g,a.b);1<c&&a.multiplyScalar(1/
c);this.children[0].material.color.copy(this.material.color)}};$e.prototype.dispose=function(){this.geometry.dispose();this.material.dispose();this.children[0].geometry.dispose();this.children[0].material.dispose()};var Xm=new k,Bk=new I,Ck=new I;af.prototype=Object.create(A.prototype);af.prototype.constructor=af;af.prototype.dispose=function(){this.children[0].geometry.dispose();this.children[0].material.dispose()};af.prototype.update=function(){var a=this.children[0];if(void 0!==this.color)this.material.color.set(this.color);
else{var c=a.geometry.getAttribute("color");Bk.copy(this.light.color);Ck.copy(this.light.groundColor);for(var e=0,g=c.count;e<g;e++){var r=e<g/2?Bk:Ck;c.setXYZ(e,r.r,r.g,r.b)}c.needsUpdate=!0}a.lookAt(Xm.setFromMatrixPosition(this.light.matrixWorld).negate())};bf.prototype=Object.create(xa.prototype);bf.prototype.constructor=bf;bf.prototype.dispose=function(){this.geometry.dispose();this.material.dispose()};bf.prototype.onBeforeRender=function(){this.position.copy(this.lightProbe.position);this.scale.set(1,
1,1).multiplyScalar(this.size);this.material.uniforms.intensity.value=this.lightProbe.intensity};ch.prototype=Object.assign(Object.create(Ib.prototype),{constructor:ch,copy:function(a){Ib.prototype.copy.call(this,a);this.geometry.copy(a.geometry);this.material.copy(a.material);return this},clone:function(){return(new this.constructor).copy(this)}});dh.prototype=Object.create(Ib.prototype);dh.prototype.constructor=dh;cf.prototype=Object.create(Vb.prototype);cf.prototype.constructor=cf;cf.prototype.update=
function(){function a(W,ha,fa,ra){fa=(ha-W)/fa;V.setXYZ(F,0,0,0);J++;for(P=W;P<ha;P+=fa)R=F+J,V.setXYZ(R,Math.sin(P)*e,0,Math.cos(P)*e),V.setXYZ(R+1,Math.sin(Math.min(P+fa,ha))*e,0,Math.cos(Math.min(P+fa,ha))*e),V.setXYZ(R+2,0,0,0),J+=3;S.addGroup(F,J,ra);F+=J;J=0}var c=this.audio,e=this.range,g=this.divisionsInnerAngle,r=this.divisionsOuterAngle,v=hb.degToRad(c.panner.coneInnerAngle);c=hb.degToRad(c.panner.coneOuterAngle);var z=v/2,E=c/2,F=0,J=0,P,R,S=this.geometry,V=S.attributes.position;S.clearGroups();
a(-E,-z,r,0);a(-z,z,g,1);a(z,E,r,0);V.needsUpdate=!0;v===c&&(this.material[0].visible=!1)};cf.prototype.dispose=function(){this.geometry.dispose();this.material[0].dispose();this.material[1].dispose()};var qg=new k,Bh=new k,Dk=new t;eg.prototype=Object.create(Ib.prototype);eg.prototype.constructor=eg;eg.prototype.update=function(){this.object.updateMatrixWorld(!0);Dk.getNormalMatrix(this.object.matrixWorld);var a=this.object.matrixWorld,c=this.geometry.attributes.position,e=this.object.geometry,g=
e.vertices;e=e.faces;for(var r=0,v=0,z=e.length;v<z;v++){var E=e[v],F=E.normal;qg.copy(g[E.a]).add(g[E.b]).add(g[E.c]).divideScalar(3).applyMatrix4(a);Bh.copy(F).applyMatrix3(Dk).normalize().multiplyScalar(this.size).add(qg);c.setXYZ(r,qg.x,qg.y,qg.z);r+=1;c.setXYZ(r,Bh.x,Bh.y,Bh.z);r+=1}c.needsUpdate=!0};var Ek=new k,Ch=new k,Fk=new k;df.prototype=Object.create(A.prototype);df.prototype.constructor=df;df.prototype.dispose=function(){this.lightPlane.geometry.dispose();this.lightPlane.material.dispose();
this.targetLine.geometry.dispose();this.targetLine.material.dispose()};df.prototype.update=function(){Ek.setFromMatrixPosition(this.light.matrixWorld);Ch.setFromMatrixPosition(this.light.target.matrixWorld);Fk.subVectors(Ch,Ek);this.lightPlane.lookAt(Ch);void 0!==this.color?(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(Ch);
this.targetLine.scale.z=Fk.length()};var eh=new k,Ob=new zb;fg.prototype=Object.create(Ib.prototype);fg.prototype.constructor=fg;fg.prototype.update=function(){var a=this.geometry,c=this.pointMap;Ob.projectionMatrixInverse.copy(this.camera.projectionMatrixInverse);Pb("c",c,a,Ob,0,0,-1);Pb("t",c,a,Ob,0,0,1);Pb("n1",c,a,Ob,-1,-1,-1);Pb("n2",c,a,Ob,1,-1,-1);Pb("n3",c,a,Ob,-1,1,-1);Pb("n4",c,a,Ob,1,1,-1);Pb("f1",c,a,Ob,-1,-1,1);Pb("f2",c,a,Ob,1,-1,1);Pb("f3",c,a,Ob,-1,1,1);Pb("f4",c,a,Ob,1,1,1);Pb("u1",
c,a,Ob,.7,1.1,-1);Pb("u2",c,a,Ob,-.7,1.1,-1);Pb("u3",c,a,Ob,0,2,-1);Pb("cf1",c,a,Ob,-1,0,1);Pb("cf2",c,a,Ob,1,0,1);Pb("cf3",c,a,Ob,0,-1,1);Pb("cf4",c,a,Ob,0,1,1);Pb("cn1",c,a,Ob,-1,0,-1);Pb("cn2",c,a,Ob,1,0,-1);Pb("cn3",c,a,Ob,0,-1,-1);Pb("cn4",c,a,Ob,0,1,-1);a.getAttribute("position").needsUpdate=!0};var Dh=new w;hd.prototype=Object.create(Ib.prototype);hd.prototype.constructor=hd;hd.prototype.update=function(a){void 0!==a&&console.warn("THREE.BoxHelper: .update() has no longer arguments.");void 0!==
this.object&&Dh.setFromObject(this.object);if(!Dh.isEmpty()){a=Dh.min;var c=Dh.max,e=this.geometry.attributes.position,g=e.array;g[0]=c.x;g[1]=c.y;g[2]=c.z;g[3]=a.x;g[4]=c.y;g[5]=c.z;g[6]=a.x;g[7]=a.y;g[8]=c.z;g[9]=c.x;g[10]=a.y;g[11]=c.z;g[12]=c.x;g[13]=c.y;g[14]=a.z;g[15]=a.x;g[16]=c.y;g[17]=a.z;g[18]=a.x;g[19]=a.y;g[20]=a.z;g[21]=c.x;g[22]=a.y;g[23]=a.z;e.needsUpdate=!0;this.geometry.computeBoundingSphere()}};hd.prototype.setFromObject=function(a){this.object=a;this.update();return this};hd.prototype.copy=
function(a){Ib.prototype.copy.call(this,a);this.object=a.object;return this};hd.prototype.clone=function(){return(new this.constructor).copy(this)};gg.prototype=Object.create(Ib.prototype);gg.prototype.constructor=gg;gg.prototype.updateMatrixWorld=function(a){var c=this.box;c.isEmpty()||(c.getCenter(this.position),c.getSize(this.scale),this.scale.multiplyScalar(.5),A.prototype.updateMatrixWorld.call(this,a))};hg.prototype=Object.create(Vb.prototype);hg.prototype.constructor=hg;hg.prototype.updateMatrixWorld=
function(a){var c=-this.plane.constant;1E-8>Math.abs(c)&&(c=1E-8);this.scale.set(.5*this.size,.5*this.size,c);this.children[0].material.side=0>c?1:0;this.lookAt(this.plane.normal);A.prototype.updateMatrixWorld.call(this,a)};var Gk=new k,fh,vi;id.prototype=Object.create(A.prototype);id.prototype.constructor=id;id.prototype.setDirection=function(a){.99999<a.y?this.quaternion.set(0,0,0,1):-.99999>a.y?this.quaternion.set(1,0,0,0):(Gk.set(a.z,0,-a.x).normalize(),this.quaternion.setFromAxisAngle(Gk,Math.acos(a.y)))};
id.prototype.setLength=function(a,c,e){void 0===c&&(c=.2*a);void 0===e&&(e=.2*c);this.line.scale.set(1,Math.max(0,a-c),1);this.line.updateMatrix();this.cone.scale.set(e,c,e);this.cone.position.y=a;this.cone.updateMatrix()};id.prototype.setColor=function(a){this.line.material.color.set(a);this.cone.material.color.set(a)};id.prototype.copy=function(a){A.prototype.copy.call(this,a,!1);this.line.copy(a.line);this.cone.copy(a.cone);return this};id.prototype.clone=function(){return(new this.constructor).copy(this)};
ig.prototype=Object.create(Ib.prototype);ig.prototype.constructor=ig;Za.create=function(a,c){console.log("THREE.Curve.create() has been deprecated");a.prototype=Object.create(Za.prototype);a.prototype.constructor=a;a.prototype.getPoint=c;return a};Object.assign(gd.prototype,{createPointsGeometry:function(a){console.warn("THREE.CurvePath: .createPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.");a=this.getPoints(a);return this.createGeometry(a)},createSpacedPointsGeometry:function(a){console.warn("THREE.CurvePath: .createSpacedPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.");
a=this.getSpacedPoints(a);return this.createGeometry(a)},createGeometry:function(a){console.warn("THREE.CurvePath: .createGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.");for(var c=new ya,e=0,g=a.length;e<g;e++){var r=a[e];c.vertices.push(new k(r.x,r.y,r.z||0))}return c}});Object.assign(Gc.prototype,{fromPoints:function(a){console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints().");this.setFromPoints(a)}});Zj.prototype=Object.create(Zb.prototype);
ak.prototype=Object.create(Zb.prototype);wi.prototype=Object.create(Zb.prototype);Object.assign(wi.prototype,{initFromArray:function(){console.error("THREE.Spline: .initFromArray() has been removed.")},getControlPointsArray:function(){console.error("THREE.Spline: .getControlPointsArray() has been removed.")},reparametrizeByArcLength:function(){console.error("THREE.Spline: .reparametrizeByArcLength() has been removed.")}});ch.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")};
Ye.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")};Object.assign(Db.prototype,{extractUrlBase:function(a){console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead.");return Pi.extractUrlBase(a)}});Object.assign(Zg.prototype,{setTexturePath:function(a){console.warn("THREE.ObjectLoader: .setTexturePath() has been renamed to .setResourcePath().");return this.setResourcePath(a)}});Object.assign(ti.prototype,
{center:function(a){console.warn("THREE.Box2: .center() has been renamed to .getCenter().");return this.getCenter(a)},empty:function(){console.warn("THREE.Box2: .empty() has been renamed to .isEmpty().");return this.isEmpty()},isIntersectionBox:function(a){console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox().");return this.intersectsBox(a)},size:function(a){console.warn("THREE.Box2: .size() has been renamed to .getSize().");return this.getSize(a)}});Object.assign(w.prototype,
{center:function(a){console.warn("THREE.Box3: .center() has been renamed to .getCenter().");return this.getCenter(a)},empty:function(){console.warn("THREE.Box3: .empty() has been renamed to .isEmpty().");return this.isEmpty()},isIntersectionBox:function(a){console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox().");return this.intersectsBox(a)},isIntersectionSphere:function(a){console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere().");return this.intersectsSphere(a)},
size:function(a){console.warn("THREE.Box3: .size() has been renamed to .getSize().");return this.getSize(a)}});ui.prototype.center=function(a){console.warn("THREE.Line3: .center() has been renamed to .getCenter().");return this.getCenter(a)};Object.assign(hb,{random16:function(){console.warn("THREE.Math: .random16() has been deprecated. Use Math.random() instead.");return Math.random()},nearestPowerOfTwo:function(a){console.warn("THREE.Math: .nearestPowerOfTwo() has been renamed to .floorPowerOfTwo().");
return hb.floorPowerOfTwo(a)},nextPowerOfTwo:function(a){console.warn("THREE.Math: .nextPowerOfTwo() has been renamed to .ceilPowerOfTwo().");return hb.ceilPowerOfTwo(a)}});Object.assign(t.prototype,{flattenToArrayOffset:function(a,c){console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.");return this.toArray(a,c)},multiplyVector3:function(a){console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead.");return a.applyMatrix3(this)},
multiplyVector3Array:function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")},applyToBuffer:function(a){console.warn("THREE.Matrix3: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.");return this.applyToBufferAttribute(a)},applyToVector3Array:function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")}});Object.assign(q.prototype,{extractPosition:function(a){console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition().");
return this.copyPosition(a)},flattenToArrayOffset:function(a,c){console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.");return this.toArray(a,c)},getPosition:function(){console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead.");return(new k).setFromMatrixColumn(this,3)},setRotationFromQuaternion:function(a){console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion().");
return this.makeRotationFromQuaternion(a)},multiplyToArray:function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")},multiplyVector3:function(a){console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead.");return a.applyMatrix4(this)},multiplyVector4:function(a){console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead.");return a.applyMatrix4(this)},multiplyVector3Array:function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")},
rotateAxis:function(a){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead.");a.transformDirection(this)},crossVector:function(a){console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead.");return a.applyMatrix4(this)},translate:function(){console.error("THREE.Matrix4: .translate() has been removed.")},rotateX:function(){console.error("THREE.Matrix4: .rotateX() has been removed.")},rotateY:function(){console.error("THREE.Matrix4: .rotateY() has been removed.")},
rotateZ:function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")},rotateByAxis:function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")},applyToBuffer:function(a){console.warn("THREE.Matrix4: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.");return this.applyToBufferAttribute(a)},applyToVector3Array:function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")},makeFrustum:function(a,c,e,g,r,v){console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead.");
return this.makePerspective(a,c,g,e,r,v)}});Hb.prototype.isIntersectionLine=function(a){console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine().");return this.intersectsLine(a)};h.prototype.multiplyVector3=function(a){console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead.");return a.applyQuaternion(this)};Object.assign(D.prototype,{isIntersectionBox:function(a){console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox().");
return this.intersectsBox(a)},isIntersectionPlane:function(a){console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane().");return this.intersectsPlane(a)},isIntersectionSphere:function(a){console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere().");return this.intersectsSphere(a)}});Object.assign(B.prototype,{area:function(){console.warn("THREE.Triangle: .area() has been renamed to .getArea().");return this.getArea()},barycoordFromPoint:function(a,
c){console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord().");return this.getBarycoord(a,c)},midpoint:function(a){console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint().");return this.getMidpoint(a)},normal:function(a){console.warn("THREE.Triangle: .normal() has been renamed to .getNormal().");return this.getNormal(a)},plane:function(a){console.warn("THREE.Triangle: .plane() has been renamed to .getPlane().");return this.getPlane(a)}});Object.assign(B,
{barycoordFromPoint:function(a,c,e,g,r){console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord().");return B.getBarycoord(a,c,e,g,r)},normal:function(a,c,e,g){console.warn("THREE.Triangle: .normal() has been renamed to .getNormal().");return B.getNormal(a,c,e,g)}});Object.assign(Cd.prototype,{extractAllPoints:function(a){console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead.");return this.extractPoints(a)},extrude:function(a){console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead.");
return new Ud(this,a)},makeGeometry:function(a){console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead.");return new Vd(this,a)}});Object.assign(f.prototype,{fromAttribute:function(a,c,e){console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute().");return this.fromBufferAttribute(a,c,e)},distanceToManhattan:function(a){console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo().");return this.manhattanDistanceTo(a)},
lengthManhattan:function(){console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength().");return this.manhattanLength()}});Object.assign(k.prototype,{setEulerFromRotationMatrix:function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")},setEulerFromQuaternion:function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")},getPositionFromMatrix:function(a){console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().");
return this.setFromMatrixPosition(a)},getScaleFromMatrix:function(a){console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().");return this.setFromMatrixScale(a)},getColumnFromMatrix:function(a,c){console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().");return this.setFromMatrixColumn(c,a)},applyProjection:function(a){console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead.");return this.applyMatrix4(a)},
fromAttribute:function(a,c,e){console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute().");return this.fromBufferAttribute(a,c,e)},distanceToManhattan:function(a){console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo().");return this.manhattanDistanceTo(a)},lengthManhattan:function(){console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength().");return this.manhattanLength()}});Object.assign(p.prototype,
{fromAttribute:function(a,c,e){console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute().");return this.fromBufferAttribute(a,c,e)},lengthManhattan:function(){console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength().");return this.manhattanLength()}});Object.assign(ya.prototype,{computeTangents:function(){console.error("THREE.Geometry: .computeTangents() has been removed.")},computeLineDistances:function(){console.error("THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead.")}});
Object.assign(A.prototype,{getChildByName:function(a){console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName().");return this.getObjectByName(a)},renderDepth:function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")},translate:function(a,c){console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead.");return this.translateOnAxis(c,a)},getWorldRotation:function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")}});
Object.defineProperties(A.prototype,{eulerOrder:{get:function(){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order.");return this.rotation.order},set:function(a){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order.");this.rotation.order=a}},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.")}}});
Object.defineProperties(Af.prototype,{objects:{get:function(){console.warn("THREE.LOD: .objects has been renamed to .levels.");return this.levels}}});Object.defineProperty(Cg.prototype,"useVertexTexture",{get:function(){console.warn("THREE.Skeleton: useVertexTexture has been removed.")},set:function(){console.warn("THREE.Skeleton: useVertexTexture has been removed.")}});Bf.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")};Object.defineProperty(Za.prototype,
"__arcLengthDivisions",{get:function(){console.warn("THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.");return this.arcLengthDivisions},set:function(a){console.warn("THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.");this.arcLengthDivisions=a}});vb.prototype.setLens=function(a,c){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup.");void 0!==c&&(this.filmGauge=c);this.setFocalLength(a)};Object.defineProperties(Jb.prototype,
{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(a){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov.");this.shadow.camera.fov=a}},shadowCameraLeft:{set:function(a){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left.");this.shadow.camera.left=a}},shadowCameraRight:{set:function(a){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right.");this.shadow.camera.right=a}},shadowCameraTop:{set:function(a){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top.");
this.shadow.camera.top=a}},shadowCameraBottom:{set:function(a){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom.");this.shadow.camera.bottom=a}},shadowCameraNear:{set:function(a){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near.");this.shadow.camera.near=a}},shadowCameraFar:{set:function(a){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far.");this.shadow.camera.far=a}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},
shadowBias:{set:function(a){console.warn("THREE.Light: .shadowBias is now .shadow.bias.");this.shadow.bias=a}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(a){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width.");this.shadow.mapSize.width=a}},shadowMapHeight:{set:function(a){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height.");this.shadow.mapSize.height=a}}});Object.defineProperties(Q.prototype,
{length:{get:function(){console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead.");return this.array.length}},copyIndicesArray:function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")}});Object.assign(va.prototype,{addIndex:function(a){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex().");this.setIndex(a)},addDrawCall:function(a,c,e){void 0!==e&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset.");
console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup().");this.addGroup(a,c)},clearDrawCalls:function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups().");this.clearGroups()},computeTangents:function(){console.warn("THREE.BufferGeometry: .computeTangents() has been removed.")},computeOffsets:function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")}});Object.defineProperties(va.prototype,{drawcalls:{get:function(){console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups.");
return this.groups}},offsets:{get:function(){console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups.");return this.groups}}});Object.assign(Rc.prototype,{getArrays:function(){console.error("THREE.ExtrudeBufferGeometry: .getArrays() has been removed.")},addShapeList:function(){console.error("THREE.ExtrudeBufferGeometry: .addShapeList() has been removed.")},addShape:function(){console.error("THREE.ExtrudeBufferGeometry: .addShape() has been removed.")}});Object.defineProperties(bh.prototype,
{dynamic:{set:function(){console.warn("THREE.Uniform: .dynamic has been removed. Use object.onBeforeRender() instead.")}},onUpdate:{value:function(){console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead.");return this}}});Object.defineProperties(M.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(){console.warn("THREE.Material: .wrapRGB has been removed.");return new I}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(a){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.");this.flatShading=1===a}}});Object.defineProperties(Bc.prototype,{metal:{get:function(){console.warn("THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead.");
return!1},set:function(){console.warn("THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead")}}});Object.defineProperties(qb.prototype,{derivatives:{get:function(){console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives.");return this.extensions.derivatives},set:function(a){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives.");this.extensions.derivatives=a}}});Object.assign(Oh.prototype,
{clearTarget:function(a,c,e,g){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead.");this.setRenderTarget(a);this.clear(c,e,g)},animate:function(a){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop().");this.setAnimationLoop(a)},getCurrentRenderTarget:function(){console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget().");return this.getRenderTarget()},getMaxAnisotropy:function(){console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy().");
return this.capabilities.getMaxAnisotropy()},getPrecision:function(){console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision.");return this.capabilities.precision},resetGLState:function(){console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset().");return this.state.reset()},supportsFloatTextures:function(){console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' ).");return this.extensions.get("OES_texture_float")},
supportsHalfFloatTextures:function(){console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' ).");return this.extensions.get("OES_texture_half_float")},supportsStandardDerivatives:function(){console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' ).");return this.extensions.get("OES_standard_derivatives")},supportsCompressedTextureS3TC:function(){console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' ).");
return this.extensions.get("WEBGL_compressed_texture_s3tc")},supportsCompressedTexturePVRTC:function(){console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' ).");return this.extensions.get("WEBGL_compressed_texture_pvrtc")},supportsBlendMinMax:function(){console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' ).");return this.extensions.get("EXT_blend_minmax")},supportsVertexTextures:function(){console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures.");
return this.capabilities.vertexTextures},supportsInstancedArrays:function(){console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' ).");return this.extensions.get("ANGLE_instanced_arrays")},enableScissorTest:function(a){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest().");this.setScissorTest(a)},initMaterial:function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")},addPrePlugin:function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")},
addPostPlugin:function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")},updateShadowMap:function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")},setFaceCulling:function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")},allocTextureUnit:function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")},setTexture:function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")},setTexture2D:function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")},
setTextureCube:function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")},getActiveMipMapLevel:function(){console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel().");return this.getActiveMipmapLevel()}});Object.defineProperties(Oh.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(a){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled.");this.shadowMap.enabled=a}},shadowMapType:{get:function(){return this.shadowMap.type},
set:function(a){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type.");this.shadowMap.type=a}},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(){console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead.");return this.getContext()}}});
Object.defineProperties(vj.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(Nb.prototype,{activeCubeFace:{set:function(){console.warn("THREE.WebGLRenderTargetCube: .activeCubeFace has been removed. It is now the second parameter of WebGLRenderer.setRenderTarget().")}},
activeMipMapLevel:{set:function(){console.warn("THREE.WebGLRenderTargetCube: .activeMipMapLevel has been removed. It is now the third parameter of WebGLRenderer.setRenderTarget().")}}});Object.defineProperties(m.prototype,{wrapS:{get:function(){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.");return this.texture.wrapS},set:function(a){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.");this.texture.wrapS=a}},wrapT:{get:function(){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.");
return this.texture.wrapT},set:function(a){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.");this.texture.wrapT=a}},magFilter:{get:function(){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.");return this.texture.magFilter},set:function(a){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.");this.texture.magFilter=a}},minFilter:{get:function(){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.");return this.texture.minFilter},
set:function(a){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.");this.texture.minFilter=a}},anisotropy:{get:function(){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.");return this.texture.anisotropy},set:function(a){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.");this.texture.anisotropy=a}},offset:{get:function(){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset.");return this.texture.offset},
set:function(a){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset.");this.texture.offset=a}},repeat:{get:function(){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat.");return this.texture.repeat},set:function(a){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat.");this.texture.repeat=a}},format:{get:function(){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format.");return this.texture.format},set:function(a){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format.");
this.texture.format=a}},type:{get:function(){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type.");return this.texture.type},set:function(a){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type.");this.texture.type=a}},generateMipmaps:{get:function(){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.");return this.texture.generateMipmaps},set:function(a){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.");
this.texture.generateMipmaps=a}}});Object.defineProperties(Nh.prototype,{standing:{set:function(){console.warn("THREE.WebVRManager: .standing has been removed.")}},userHeight:{set:function(){console.warn("THREE.WebVRManager: .userHeight has been removed.")}}});We.prototype.load=function(a){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");var c=this;(new $g).load(a,function(e){c.setBuffer(e)});return this};oi.prototype.getData=function(){console.warn("THREE.AudioAnalyser: .getData() is now .getFrequencyData().");
return this.getFrequencyData()};Gb.prototype.updateCubeMap=function(a,c){console.warn("THREE.CubeCamera: .updateCubeMap() is now .update().");return this.update(a,c)};Dd.crossOrigin=void 0;Dd.loadTexture=function(a,c,e,g){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");var r=new Mg;r.setCrossOrigin(this.crossOrigin);a=r.load(a,e,void 0,g);c&&(a.mapping=c);return a};Dd.loadTextureCube=function(a,c,e,g){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");
var r=new Lg;r.setCrossOrigin(this.crossOrigin);a=r.load(a,e,void 0,g);c&&(a.mapping=c);return a};Dd.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")};Dd.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")};b.ACESFilmicToneMapping=5;b.AddEquation=100;b.AddOperation=2;b.AdditiveBlending=2;b.AlphaFormat=1021;b.AlwaysDepth=
1;b.AlwaysStencilFunc=519;b.AmbientLight=Tg;b.AmbientLightProbe=ji;b.AnimationClip=tc;b.AnimationLoader=ai;b.AnimationMixer=qi;b.AnimationObjectGroup=Sj;b.AnimationUtils=Tb;b.ArcCurve=Ve;b.ArrayCamera=vf;b.ArrowHelper=id;b.Audio=We;b.AudioAnalyser=oi;b.AudioContext=mi;b.AudioListener=li;b.AudioLoader=$g;b.AxesHelper=ig;b.AxisHelper=function(a){console.warn("THREE.AxisHelper has been renamed to THREE.AxesHelper.");return new ig(a)};b.BackSide=1;b.BasicDepthPacking=3200;b.BasicShadowMap=0;b.BinaryTextureLoader=
function(a){console.warn("THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader.");return new Kg(a)};b.Bone=Uh;b.BooleanKeyframeTrack=Gg;b.BoundingBoxHelper=function(a,c){console.warn("THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead.");return new hd(a,c)};b.Box2=ti;b.Box3=w;b.Box3Helper=gg;b.BoxBufferGeometry=Xa;b.BoxGeometry=Sa;b.BoxHelper=hd;b.BufferAttribute=Q;b.BufferGeometry=va;b.BufferGeometryLoader=Yg;b.ByteType=1010;b.Cache=ie;b.Camera=zb;b.CameraHelper=
fg;b.CanvasRenderer=function(){console.error("THREE.CanvasRenderer has been removed")};b.CanvasTexture=Cf;b.CatmullRomCurve3=Zb;b.CineonToneMapping=4;b.CircleBufferGeometry=Qe;b.CircleGeometry=Xf;b.ClampToEdgeWrapping=1001;b.Clock=ki;b.ClosedSplineCurve3=Zj;b.Color=I;b.ColorKeyframeTrack=Hg;b.CompressedTexture=De;b.CompressedTextureLoader=bi;b.ConeBufferGeometry=Wf;b.ConeGeometry=Vf;b.CubeCamera=Gb;b.CubeGeometry=Sa;b.CubeReflectionMapping=301;b.CubeRefractionMapping=302;b.CubeTexture=cd;b.CubeTextureLoader=
Lg;b.CubeUVReflectionMapping=306;b.CubeUVRefractionMapping=307;b.CubicBezierCurve=Cc;b.CubicBezierCurve3=Tc;b.CubicInterpolant=Eg;b.CullFaceBack=1;b.CullFaceFront=2;b.CullFaceFrontBack=3;b.CullFaceNone=0;b.Curve=Za;b.CurvePath=gd;b.CustomBlending=5;b.CylinderBufferGeometry=fd;b.CylinderGeometry=Xd;b.Cylindrical=Xj;b.DataTexture=Ab;b.DataTexture2DArray=re;b.DataTexture3D=se;b.DataTextureLoader=Kg;b.DecrementStencilOp=7683;b.DecrementWrapStencilOp=34056;b.DefaultLoadingManager=Oj;b.DepthFormat=1026;
b.DepthStencilFormat=1027;b.DepthTexture=Df;b.DirectionalLight=Sg;b.DirectionalLightHelper=df;b.DirectionalLightShadow=Rg;b.DiscreteInterpolant=Fg;b.DodecahedronBufferGeometry=Ie;b.DodecahedronGeometry=Jf;b.DoubleSide=2;b.DstAlphaFactor=206;b.DstColorFactor=208;b.DynamicBufferAttribute=function(a,c){console.warn("THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setDynamic( true ) instead.");return(new Q(a,c)).setDynamic(!0)};b.EdgesGeometry=Pe;b.EdgesHelper=function(a,
c){console.warn("THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead.");return new Ib(new Pe(a.geometry),new Fb({color:void 0!==c?c:16777215}))};b.EllipseCurve=pc;b.EqualDepth=4;b.EqualStencilFunc=514;b.EquirectangularReflectionMapping=303;b.EquirectangularRefractionMapping=304;b.Euler=u;b.EventDispatcher=d;b.ExtrudeBufferGeometry=Rc;b.ExtrudeGeometry=Ud;b.Face3=K;b.Face4=function(a,c,e,g,r,v,z){console.warn("THREE.Face4 has been removed. A THREE.Face3 will be created instead.");return new K(a,
c,e,r,v,z)};b.FaceColors=1;b.FaceNormalsHelper=eg;b.FileLoader=uc;b.FlatShading=1;b.Float32Attribute=function(a,c){console.warn("THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead.");return new ca(a,c)};b.Float32BufferAttribute=ca;b.Float64Attribute=function(a,c){console.warn("THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead.");return new ka(a,c)};b.Float64BufferAttribute=ka;b.FloatType=1015;b.Fog=Ag;b.FogExp2=zg;b.Font=gi;
b.FontLoader=hi;b.FrontFaceDirectionCCW=1;b.FrontFaceDirectionCW=0;b.FrontSide=0;b.Frustum=ic;b.GammaEncoding=3007;b.Geometry=ya;b.GeometryUtils={merge:function(a,c,e){console.warn("THREE.GeometryUtils: .merge() has been moved to Geometry. Use geometry.merge( geometry2, matrix, materialIndexOffset ) instead.");if(c.isMesh){c.matrixAutoUpdate&&c.updateMatrix();var g=c.matrix;c=c.geometry}a.merge(c,g,e)},center:function(a){console.warn("THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead.");
return a.center()}};b.GreaterDepth=6;b.GreaterEqualDepth=5;b.GreaterEqualStencilFunc=518;b.GreaterStencilFunc=516;b.GridHelper=ch;b.Group=ue;b.HalfFloatType=1016;b.HemisphereLight=Ng;b.HemisphereLightHelper=af;b.HemisphereLightProbe=ii;b.IcosahedronBufferGeometry=He;b.IcosahedronGeometry=If;b.ImageBitmapLoader=ei;b.ImageLoader=Ue;b.ImageUtils=Dd;b.ImmediateRenderObject=cg;b.IncrementStencilOp=7682;b.IncrementWrapStencilOp=34055;b.InstancedBufferAttribute=Xg;b.InstancedBufferGeometry=Wg;b.InstancedInterleavedBuffer=
ri;b.Int16Attribute=function(a,c){console.warn("THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead.");return new la(a,c)};b.Int16BufferAttribute=la;b.Int32Attribute=function(a,c){console.warn("THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead.");return new ba(a,c)};b.Int32BufferAttribute=ba;b.Int8Attribute=function(a,c){console.warn("THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead.");return new T(a,
c)};b.Int8BufferAttribute=T;b.IntType=1013;b.InterleavedBuffer=Qd;b.InterleavedBufferAttribute=xf;b.Interpolant=oc;b.InterpolateDiscrete=2300;b.InterpolateLinear=2301;b.InterpolateSmooth=2302;b.InvertStencilOp=5386;b.JSONLoader=function(){console.error("THREE.JSONLoader has been removed.")};b.KeepStencilOp=7680;b.KeyframeTrack=Xb;b.LOD=Af;b.LatheBufferGeometry=Oe;b.LatheGeometry=Uf;b.Layers=x;b.LensFlare=function(){console.error("THREE.LensFlare has been moved to /examples/js/objects/Lensflare.js")};
b.LessDepth=2;b.LessEqualDepth=3;b.LessEqualStencilFunc=515;b.LessStencilFunc=513;b.Light=Jb;b.LightProbe=Hc;b.LightProbeHelper=bf;b.LightShadow=Vc;b.Line=Vb;b.Line3=ui;b.LineBasicMaterial=Fb;b.LineCurve=kc;b.LineCurve3=Dc;b.LineDashedMaterial=de;b.LineLoop=Dg;b.LinePieces=1;b.LineSegments=Ib;b.LineStrip=0;b.LinearEncoding=3E3;b.LinearFilter=1006;b.LinearInterpolant=Yf;b.LinearMipMapLinearFilter=1008;b.LinearMipMapNearestFilter=1007;b.LinearMipmapLinearFilter=1008;b.LinearMipmapNearestFilter=1007;
b.LinearToneMapping=1;b.Loader=Db;b.LoaderUtils=Pi;b.LoadingManager=$h;b.LogLuvEncoding=3003;b.LoopOnce=2200;b.LoopPingPong=2202;b.LoopRepeat=2201;b.LuminanceAlphaFormat=1025;b.LuminanceFormat=1024;b.MOUSE={LEFT:0,MIDDLE:1,RIGHT:2,ROTATE:0,DOLLY:1,PAN:2};b.Material=M;b.MaterialLoader=Vg;b.Math=hb;b.Matrix3=t;b.Matrix4=q;b.MaxEquation=104;b.Mesh=xa;b.MeshBasicMaterial=L;b.MeshDepthMaterial=vd;b.MeshDistanceMaterial=wd;b.MeshFaceMaterial=function(a){console.warn("THREE.MeshFaceMaterial has been removed. Use an Array instead.");
return a};b.MeshLambertMaterial=be;b.MeshMatcapMaterial=ce;b.MeshNormalMaterial=ae;b.MeshPhongMaterial=Bc;b.MeshPhysicalMaterial=Zd;b.MeshStandardMaterial=Sc;b.MeshToonMaterial=$d;b.MinEquation=103;b.MirroredRepeatWrapping=1002;b.MixOperation=1;b.MultiMaterial=function(a){void 0===a&&(a=[]);console.warn("THREE.MultiMaterial has been removed. Use an Array instead.");a.isMultiMaterial=!0;a.materials=a;a.clone=function(){return a.slice()};return a};b.MultiplyBlending=4;b.MultiplyOperation=0;b.NearestFilter=
1003;b.NearestMipMapLinearFilter=1005;b.NearestMipMapNearestFilter=1004;b.NearestMipmapLinearFilter=1005;b.NearestMipmapNearestFilter=1004;b.NeverDepth=0;b.NeverStencilFunc=512;b.NoBlending=0;b.NoColors=0;b.NoToneMapping=0;b.NormalBlending=1;b.NotEqualDepth=7;b.NotEqualStencilFunc=517;b.NumberKeyframeTrack=Se;b.Object3D=A;b.ObjectLoader=Zg;b.ObjectSpaceNormalMap=1;b.OctahedronBufferGeometry=Rd;b.OctahedronGeometry=Hf;b.OneFactor=201;b.OneMinusDstAlphaFactor=207;b.OneMinusDstColorFactor=209;b.OneMinusSrcAlphaFactor=
205;b.OneMinusSrcColorFactor=203;b.OrthographicCamera=bg;b.PCFShadowMap=1;b.PCFSoftShadowMap=2;b.ParametricBufferGeometry=Fe;b.ParametricGeometry=Ef;b.Particle=function(a){console.warn("THREE.Particle has been renamed to THREE.Sprite.");return new yf(a)};b.ParticleBasicMaterial=function(a){console.warn("THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial.");return new Ac(a)};b.ParticleSystem=function(a,c){console.warn("THREE.ParticleSystem has been renamed to THREE.Points.");return new Ce(a,
c)};b.ParticleSystemMaterial=function(a){console.warn("THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial.");return new Ac(a)};b.Path=Gc;b.PerspectiveCamera=vb;b.Plane=Hb;b.PlaneBufferGeometry=Lc;b.PlaneGeometry=rd;b.PlaneHelper=hg;b.PointCloud=function(a,c){console.warn("THREE.PointCloud has been renamed to THREE.Points.");return new Ce(a,c)};b.PointCloudMaterial=function(a){console.warn("THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial.");return new Ac(a)};b.PointLight=
Qg;b.PointLightHelper=Ze;b.Points=Ce;b.PointsMaterial=Ac;b.PolarGridHelper=dh;b.PolyhedronBufferGeometry=jc;b.PolyhedronGeometry=Ff;b.PositionalAudio=ni;b.PositionalAudioHelper=cf;b.PropertyBinding=$b;b.PropertyMixer=pi;b.QuadraticBezierCurve=Ec;b.QuadraticBezierCurve3=Uc;b.Quaternion=h;b.QuaternionKeyframeTrack=Zf;b.QuaternionLinearInterpolant=Ig;b.REVISION="108";b.RGBADepthPacking=3201;b.RGBAFormat=1023;b.RGBA_ASTC_10x10_Format=37819;b.RGBA_ASTC_10x5_Format=37816;b.RGBA_ASTC_10x6_Format=37817;b.RGBA_ASTC_10x8_Format=
37818;b.RGBA_ASTC_12x10_Format=37820;b.RGBA_ASTC_12x12_Format=37821;b.RGBA_ASTC_4x4_Format=37808;b.RGBA_ASTC_5x4_Format=37809;b.RGBA_ASTC_5x5_Format=37810;b.RGBA_ASTC_6x5_Format=37811;b.RGBA_ASTC_6x6_Format=37812;b.RGBA_ASTC_8x5_Format=37813;b.RGBA_ASTC_8x6_Format=37814;b.RGBA_ASTC_8x8_Format=37815;b.RGBA_PVRTC_2BPPV1_Format=35843;b.RGBA_PVRTC_4BPPV1_Format=35842;b.RGBA_S3TC_DXT1_Format=33777;b.RGBA_S3TC_DXT3_Format=33778;b.RGBA_S3TC_DXT5_Format=33779;b.RGBDEncoding=3006;b.RGBEEncoding=3002;b.RGBEFormat=
1023;b.RGBFormat=1022;b.RGBM16Encoding=3005;b.RGBM7Encoding=3004;b.RGB_ETC1_Format=36196;b.RGB_PVRTC_2BPPV1_Format=35841;b.RGB_PVRTC_4BPPV1_Format=35840;b.RGB_S3TC_DXT1_Format=33776;b.RawShaderMaterial=Re;b.Ray=D;b.Raycaster=Uj;b.RectAreaLight=Ug;b.RectAreaLightHelper=$e;b.RedFormat=1028;b.ReinhardToneMapping=2;b.RepeatWrapping=1E3;b.ReplaceStencilOp=7681;b.ReverseSubtractEquation=102;b.RingBufferGeometry=Ne;b.RingGeometry=Tf;b.Scene=y;b.SceneUtils={createMultiMaterialObject:function(){console.error("THREE.SceneUtils has been moved to /examples/js/utils/SceneUtils.js")},
detach:function(){console.error("THREE.SceneUtils has been moved to /examples/js/utils/SceneUtils.js")},attach:function(){console.error("THREE.SceneUtils has been moved to /examples/js/utils/SceneUtils.js")}};b.ShaderChunk=rb;b.ShaderLib=Mc;b.ShaderMaterial=qb;b.ShadowMaterial=Yd;b.Shape=Cd;b.ShapeBufferGeometry=Wd;b.ShapeGeometry=Vd;b.ShapePath=fi;b.ShapeUtils=ed;b.ShortType=1011;b.Skeleton=Cg;b.SkeletonHelper=Ye;b.SkinnedMesh=Bf;b.SmoothShading=2;b.Sphere=G;b.SphereBufferGeometry=Bd;b.SphereGeometry=
Sf;b.Spherical=Wj;b.SphericalHarmonics3=ah;b.SphericalReflectionMapping=305;b.Spline=wi;b.SplineCurve=Fc;b.SplineCurve3=ak;b.SpotLight=Pg;b.SpotLightHelper=Xe;b.SpotLightShadow=Og;b.Sprite=yf;b.SpriteMaterial=Ad;b.SrcAlphaFactor=204;b.SrcAlphaSaturateFactor=210;b.SrcColorFactor=202;b.StereoCamera=Qj;b.StringKeyframeTrack=Jg;b.SubtractEquation=101;b.SubtractiveBlending=3;b.TOUCH={ROTATE:0,PAN:1,DOLLY_PAN:2,DOLLY_ROTATE:3};b.TangentSpaceNormalMap=0;b.TetrahedronBufferGeometry=Ge;b.TetrahedronGeometry=
Gf;b.TextBufferGeometry=Me;b.TextGeometry=Rf;b.Texture=l;b.TextureLoader=Mg;b.TorusBufferGeometry=Ke;b.TorusGeometry=Mf;b.TorusKnotBufferGeometry=Je;b.TorusKnotGeometry=Lf;b.Triangle=B;b.TriangleFanDrawMode=2;b.TriangleStripDrawMode=1;b.TrianglesDrawMode=0;b.TubeBufferGeometry=Sd;b.TubeGeometry=Kf;b.UVMapping=300;b.Uint16Attribute=function(a,c){console.warn("THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead.");return new Z(a,c)};b.Uint16BufferAttribute=Z;b.Uint32Attribute=
function(a,c){console.warn("THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead.");return new ea(a,c)};b.Uint32BufferAttribute=ea;b.Uint8Attribute=function(a,c){console.warn("THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead.");return new X(a,c)};b.Uint8BufferAttribute=X;b.Uint8ClampedAttribute=function(a,c){console.warn("THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead.");return new aa(a,
c)};b.Uint8ClampedBufferAttribute=aa;b.Uncharted2ToneMapping=3;b.Uniform=bh;b.UniformsLib=Wa;b.UniformsUtils=Fm;b.UnsignedByteType=1009;b.UnsignedInt248Type=1020;b.UnsignedIntType=1014;b.UnsignedShort4444Type=1017;b.UnsignedShort5551Type=1018;b.UnsignedShort565Type=1019;b.UnsignedShortType=1012;b.VSMShadowMap=3;b.Vector2=f;b.Vector3=k;b.Vector4=p;b.VectorKeyframeTrack=Te;b.Vertex=function(a,c,e){console.warn("THREE.Vertex has been removed. Use THREE.Vector3 instead.");return new k(a,c,e)};b.VertexColors=
2;b.VertexNormalsHelper=dg;b.VideoTexture=Xh;b.WebGLMultisampleRenderTarget=n;b.WebGLRenderTarget=m;b.WebGLRenderTargetCube=Nb;b.WebGLRenderer=Oh;b.WebGLUtils=wj;b.WireframeGeometry=Ee;b.WireframeHelper=function(a,c){console.warn("THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead.");return new Ib(new Ee(a.geometry),new Fb({color:void 0!==c?c:16777215}))};b.WrapAroundEnding=2402;b.XHRLoader=function(a){console.warn("THREE.XHRLoader has been renamed to THREE.FileLoader.");
return new uc(a)};b.ZeroCurvatureEnding=2400;b.ZeroFactor=200;b.ZeroSlopeEnding=2401;b.ZeroStencilOp=0;b.sRGBEncoding=3001;Object.defineProperty(b,"__esModule",{value:!0})});

//# sourceURL=build://tf-imports/OrbitControls.js
THREE.OrbitControls=function(b,d){function f(){return 2*Math.PI/60/60*Y.autoRotateSpeed}function h(){return Math.pow(.95,Y.zoomSpeed)}function k(sa){Xa.theta-=sa}function t(sa){Xa.phi-=sa}function l(sa){Y.object.isPerspectiveCamera?ub/=sa:Y.object.isOrthographicCamera?(Y.object.zoom=Math.max(Y.minZoom,Math.min(Y.maxZoom,Y.object.zoom*sa)),Y.object.updateProjectionMatrix(),qb=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),Y.enableZoom=!1)}function p(sa){Y.object.isPerspectiveCamera?
ub*=sa:Y.object.isOrthographicCamera?(Y.object.zoom=Math.max(Y.minZoom,Math.min(Y.maxZoom,Y.object.zoom/sa)),Y.object.updateProjectionMatrix(),qb=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),Y.enableZoom=!1)}function m(sa){zb.set(sa.clientX,sa.clientY)}function n(sa){ic.set(sa.clientX,sa.clientY)}function q(sa){Nb.set(sa.clientX,sa.clientY)}function u(sa){vb.set(sa.clientX,sa.clientY);Gb.subVectors(vb,zb).multiplyScalar(Y.rotateSpeed);sa=
Y.domElement===document?Y.domElement.body:Y.domElement;k(2*Math.PI*Gb.x/sa.clientHeight);t(2*Math.PI*Gb.y/sa.clientHeight);zb.copy(vb);Y.update()}function x(sa){bc.set(sa.clientX,sa.clientY);Od.subVectors(bc,ic);0<Od.y?l(h()):0>Od.y&&p(h());ic.copy(bc);Y.update()}function A(sa){Ab.set(sa.clientX,sa.clientY);Hb.subVectors(Ab,Nb).multiplyScalar(Y.panSpeed);sd(Hb.x,Hb.y);Nb.copy(Ab);Y.update()}function y(){}function w(sa){0>sa.deltaY?p(h()):0<sa.deltaY&&l(h());Y.update()}function C(sa){var Mb=!1;switch(sa.keyCode){case Y.keys.UP:sd(0,
Y.keyPanSpeed);Mb=!0;break;case Y.keys.BOTTOM:sd(0,-Y.keyPanSpeed);Mb=!0;break;case Y.keys.LEFT:sd(Y.keyPanSpeed,0);Mb=!0;break;case Y.keys.RIGHT:sd(-Y.keyPanSpeed,0),Mb=!0}Mb&&(sa.preventDefault(),Y.update())}function G(sa){1==sa.touches.length?zb.set(sa.touches[0].pageX,sa.touches[0].pageY):zb.set(.5*(sa.touches[0].pageX+sa.touches[1].pageX),.5*(sa.touches[0].pageY+sa.touches[1].pageY))}function D(sa){1==sa.touches.length?Nb.set(sa.touches[0].pageX,sa.touches[0].pageY):Nb.set(.5*(sa.touches[0].pageX+
sa.touches[1].pageX),.5*(sa.touches[0].pageY+sa.touches[1].pageY))}function B(sa){var Mb=sa.touches[0].pageX-sa.touches[1].pageX;sa=sa.touches[0].pageY-sa.touches[1].pageY;ic.set(0,Math.sqrt(Mb*Mb+sa*sa))}function I(sa){Y.enableZoom&&B(sa);Y.enablePan&&D(sa)}function N(sa){Y.enableZoom&&B(sa);Y.enableRotate&&G(sa)}function O(sa){1==sa.touches.length?vb.set(sa.touches[0].pageX,sa.touches[0].pageY):vb.set(.5*(sa.touches[0].pageX+sa.touches[1].pageX),.5*(sa.touches[0].pageY+sa.touches[1].pageY));Gb.subVectors(vb,
zb).multiplyScalar(Y.rotateSpeed);sa=Y.domElement===document?Y.domElement.body:Y.domElement;k(2*Math.PI*Gb.x/sa.clientHeight);t(2*Math.PI*Gb.y/sa.clientHeight);zb.copy(vb)}function H(sa){1==sa.touches.length?Ab.set(sa.touches[0].pageX,sa.touches[0].pageY):Ab.set(.5*(sa.touches[0].pageX+sa.touches[1].pageX),.5*(sa.touches[0].pageY+sa.touches[1].pageY));Hb.subVectors(Ab,Nb).multiplyScalar(Y.panSpeed);sd(Hb.x,Hb.y);Nb.copy(Ab)}function K(sa){var Mb=sa.touches[0].pageX-sa.touches[1].pageX;sa=sa.touches[0].pageY-
sa.touches[1].pageY;bc.set(0,Math.sqrt(Mb*Mb+sa*sa));Od.set(0,Math.pow(bc.y/ic.y,Y.zoomSpeed));l(Od.y);ic.copy(bc)}function M(sa){Y.enableZoom&&K(sa);Y.enablePan&&H(sa)}function L(sa){Y.enableZoom&&K(sa);Y.enableRotate&&O(sa)}function Q(){}function T(sa){if(!1!==Y.enabled){sa.preventDefault();Y.domElement.focus?Y.domElement.focus():window.focus();switch(sa.button){case 0:switch(Y.mouseButtons.LEFT){case THREE.MOUSE.ROTATE:if(sa.ctrlKey||sa.metaKey||sa.shiftKey){if(!1===Y.enablePan)return;q(sa);Fa=
Aa.PAN}else{if(!1===Y.enableRotate)return;m(sa);Fa=Aa.ROTATE}break;case THREE.MOUSE.PAN:if(sa.ctrlKey||sa.metaKey||sa.shiftKey){if(!1===Y.enableRotate)return;m(sa);Fa=Aa.ROTATE}else{if(!1===Y.enablePan)return;q(sa);Fa=Aa.PAN}break;default:Fa=Aa.NONE}break;case 1:switch(Y.mouseButtons.MIDDLE){case THREE.MOUSE.DOLLY:if(!1===Y.enableZoom)return;n(sa);Fa=Aa.DOLLY;break;default:Fa=Aa.NONE}break;case 2:switch(Y.mouseButtons.RIGHT){case THREE.MOUSE.ROTATE:if(!1===Y.enableRotate)return;m(sa);Fa=Aa.ROTATE;
break;case THREE.MOUSE.PAN:if(!1===Y.enablePan)return;q(sa);Fa=Aa.PAN;break;default:Fa=Aa.NONE}}Fa!==Aa.NONE&&(document.addEventListener("mousemove",X,!1),document.addEventListener("mouseup",aa,!1),Y.dispatchEvent(va))}}function X(sa){if(!1!==Y.enabled)switch(sa.preventDefault(),Fa){case Aa.ROTATE:if(!1===Y.enableRotate)break;u(sa);break;case Aa.DOLLY:if(!1===Y.enableZoom)break;x(sa);break;case Aa.PAN:!1!==Y.enablePan&&A(sa)}}function aa(sa){!1!==Y.enabled&&(y(sa),document.removeEventListener("mousemove",
X,!1),document.removeEventListener("mouseup",aa,!1),Y.dispatchEvent(xa),Fa=Aa.NONE)}function la(sa){!1===Y.enabled||!1===Y.enableZoom||Fa!==Aa.NONE&&Fa!==Aa.ROTATE||(sa.preventDefault(),sa.stopPropagation(),Y.dispatchEvent(va),w(sa),Y.dispatchEvent(xa))}function Z(sa){!1!==Y.enabled&&!1!==Y.enableKeys&&!1!==Y.enablePan&&C(sa)}function ba(sa){if(!1!==Y.enabled){sa.preventDefault();switch(sa.touches.length){case 1:switch(Y.touches.ONE){case THREE.TOUCH.ROTATE:if(!1===Y.enableRotate)return;G(sa);Fa=
Aa.TOUCH_ROTATE;break;case THREE.TOUCH.PAN:if(!1===Y.enablePan)return;D(sa);Fa=Aa.TOUCH_PAN;break;default:Fa=Aa.NONE}break;case 2:switch(Y.touches.TWO){case THREE.TOUCH.DOLLY_PAN:if(!1===Y.enableZoom&&!1===Y.enablePan)return;I(sa);Fa=Aa.TOUCH_DOLLY_PAN;break;case THREE.TOUCH.DOLLY_ROTATE:if(!1===Y.enableZoom&&!1===Y.enableRotate)return;N(sa);Fa=Aa.TOUCH_DOLLY_ROTATE;break;default:Fa=Aa.NONE}break;default:Fa=Aa.NONE}Fa!==Aa.NONE&&Y.dispatchEvent(va)}}function ea(sa){if(!1!==Y.enabled)switch(sa.preventDefault(),
sa.stopPropagation(),Fa){case Aa.TOUCH_ROTATE:if(!1===Y.enableRotate)break;O(sa);Y.update();break;case Aa.TOUCH_PAN:if(!1===Y.enablePan)break;H(sa);Y.update();break;case Aa.TOUCH_DOLLY_PAN:if(!1===Y.enableZoom&&!1===Y.enablePan)break;M(sa);Y.update();break;case Aa.TOUCH_DOLLY_ROTATE:if(!1===Y.enableZoom&&!1===Y.enableRotate)break;L(sa);Y.update();break;default:Fa=Aa.NONE}}function ca(sa){!1!==Y.enabled&&(Q(sa),Y.dispatchEvent(xa),Fa=Aa.NONE)}function ka(sa){!1!==Y.enabled&&sa.preventDefault()}this.object=
b;this.domElement=void 0!==d?d:document;this.enabled=!0;this.target=new THREE.Vector3;this.minDistance=0;this.maxDistance=Infinity;this.minZoom=0;this.maxZoom=Infinity;this.minPolarAngle=0;this.maxPolarAngle=Math.PI;this.minAzimuthAngle=-Infinity;this.maxAzimuthAngle=Infinity;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=!1;this.keyPanSpeed=7;this.autoRotate=!1;this.autoRotateSpeed=
2;this.enableKeys=!0;this.keys={LEFT:37,UP:38,RIGHT:39,BOTTOM:40};this.mouseButtons={LEFT:THREE.MOUSE.ROTATE,MIDDLE:THREE.MOUSE.DOLLY,RIGHT:THREE.MOUSE.PAN};this.touches={ONE:THREE.TOUCH.ROTATE,TWO:THREE.TOUCH.DOLLY_PAN};this.target0=this.target.clone();this.position0=this.object.position.clone();this.zoom0=this.object.zoom;this.getPolarAngle=function(){return Sa.phi};this.getAzimuthalAngle=function(){return Sa.theta};this.saveState=function(){Y.target0.copy(Y.target);Y.position0.copy(Y.object.position);
Y.zoom0=Y.object.zoom};this.reset=function(){Y.target.copy(Y.target0);Y.object.position.copy(Y.position0);Y.object.zoom=Y.zoom0;Y.object.updateProjectionMatrix();Y.dispatchEvent(Ea);Y.update();Fa=Aa.NONE};this.update=function(){var sa=new THREE.Vector3,Mb=(new THREE.Quaternion).setFromUnitVectors(b.up,new THREE.Vector3(0,1,0)),wc=Mb.clone().inverse(),bd=new THREE.Vector3,td=new THREE.Quaternion;return function(){var tg=Y.object.position;sa.copy(tg).sub(Y.target);sa.applyQuaternion(Mb);Sa.setFromVector3(sa);
Y.autoRotate&&Fa===Aa.NONE&&k(f());Y.enableDamping?(Sa.theta+=Xa.theta*Y.dampingFactor,Sa.phi+=Xa.phi*Y.dampingFactor):(Sa.theta+=Xa.theta,Sa.phi+=Xa.phi);Sa.theta=Math.max(Y.minAzimuthAngle,Math.min(Y.maxAzimuthAngle,Sa.theta));Sa.phi=Math.max(Y.minPolarAngle,Math.min(Y.maxPolarAngle,Sa.phi));Sa.makeSafe();Sa.radius*=ub;Sa.radius=Math.max(Y.minDistance,Math.min(Y.maxDistance,Sa.radius));!0===Y.enableDamping?Y.target.addScaledVector(Bb,Y.dampingFactor):Y.target.add(Bb);sa.setFromSpherical(Sa);sa.applyQuaternion(wc);
tg.copy(Y.target).add(sa);Y.object.lookAt(Y.target);!0===Y.enableDamping?(Xa.theta*=1-Y.dampingFactor,Xa.phi*=1-Y.dampingFactor,Bb.multiplyScalar(1-Y.dampingFactor)):(Xa.set(0,0,0),Bb.set(0,0,0));ub=1;return qb||bd.distanceToSquared(Y.object.position)>ya||8*(1-td.dot(Y.object.quaternion))>ya?(Y.dispatchEvent(Ea),bd.copy(Y.object.position),td.copy(Y.object.quaternion),qb=!1,!0):!1}}();this.dispose=function(){Y.domElement.removeEventListener("contextmenu",ka,!1);Y.domElement.removeEventListener("mousedown",
T,!1);Y.domElement.removeEventListener("wheel",la,!1);Y.domElement.removeEventListener("touchstart",ba,!1);Y.domElement.removeEventListener("touchend",ca,!1);Y.domElement.removeEventListener("touchmove",ea,!1);document.removeEventListener("mousemove",X,!1);document.removeEventListener("mouseup",aa,!1);window.removeEventListener("keydown",Z,!1)};var Y=this,Ea={type:"change"},va={type:"start"},xa={type:"end"},Aa={NONE:-1,ROTATE:0,DOLLY:1,PAN:2,TOUCH_ROTATE:3,TOUCH_PAN:4,TOUCH_DOLLY_PAN:5,TOUCH_DOLLY_ROTATE:6},
Fa=Aa.NONE,ya=1E-6,Sa=new THREE.Spherical,Xa=new THREE.Spherical,ub=1,Bb=new THREE.Vector3,qb=!1,zb=new THREE.Vector2,vb=new THREE.Vector2,Gb=new THREE.Vector2,Nb=new THREE.Vector2,Ab=new THREE.Vector2,Hb=new THREE.Vector2,ic=new THREE.Vector2,bc=new THREE.Vector2,Od=new THREE.Vector2,rd=function(){var sa=new THREE.Vector3;return function(Mb,wc){sa.setFromMatrixColumn(wc,0);sa.multiplyScalar(-Mb);Bb.add(sa)}}(),Lc=function(){var sa=new THREE.Vector3;return function(Mb,wc){!0===Y.screenSpacePanning?
sa.setFromMatrixColumn(wc,1):(sa.setFromMatrixColumn(wc,0),sa.crossVectors(Y.object.up,sa));sa.multiplyScalar(Mb);Bb.add(sa)}}(),sd=function(){var sa=new THREE.Vector3;return function(Mb,wc){var bd=Y.domElement===document?Y.domElement.body:Y.domElement;if(Y.object.isPerspectiveCamera){sa.copy(Y.object.position).sub(Y.target);var td=sa.length();td*=Math.tan(Y.object.fov/2*Math.PI/180);rd(2*Mb*td/bd.clientHeight,Y.object.matrix);Lc(2*wc*td/bd.clientHeight,Y.object.matrix)}else Y.object.isOrthographicCamera?
(rd(Mb*(Y.object.right-Y.object.left)/Y.object.zoom/bd.clientWidth,Y.object.matrix),Lc(wc*(Y.object.top-Y.object.bottom)/Y.object.zoom/bd.clientHeight,Y.object.matrix)):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."),Y.enablePan=!1)}}();Y.domElement.addEventListener("contextmenu",ka,!1);Y.domElement.addEventListener("mousedown",T,!1);Y.domElement.addEventListener("wheel",la,!1);Y.domElement.addEventListener("touchstart",ba,!1);Y.domElement.addEventListener("touchend",
ca,!1);Y.domElement.addEventListener("touchmove",ea,!1);window.addEventListener("keydown",Z,!1);this.update()};THREE.OrbitControls.prototype=Object.create(THREE.EventDispatcher.prototype);THREE.OrbitControls.prototype.constructor=THREE.OrbitControls;THREE.MapControls=function(b,d){THREE.OrbitControls.call(this,b,d);this.mouseButtons.LEFT=THREE.MOUSE.PAN;this.mouseButtons.RIGHT=THREE.MOUSE.ROTATE;this.touches.ONE=THREE.TOUCH.PAN;this.touches.TWO=THREE.TOUCH.DOLLY_ROTATE};
THREE.MapControls.prototype=Object.create(THREE.EventDispatcher.prototype);THREE.MapControls.prototype.constructor=THREE.MapControls;

//# sourceURL=build://tf-imports/array-buffer-data-provider.js
var Lk;
(function(b){b.ErrorCodes={CANCELLED:1};const d={VERTEX:1,FACE:2,COLOR:3},f={VERTEX:"float32",FACE:"int32",COLOR:"uint8"};class h{constructor(k){this._requestManager=k;this._canceller=new vc.Canceller}reload(k,t,l){this._canceller.cancelAll();return this._fetchMetadata(k,t,l)}_fetchDataByStep(k,t,l,p,m,n){function q(u){let x=[];for(let A=0;A<u.length/3;A++){let y=[];for(let w=0;3>w;w++)y.push(u[3*A+w]);x.push(y)}return x}k=vc.getRouter().pluginRoute("mesh","/data",new URLSearchParams({tag:t,run:k,
content_type:l,sample:p,step:m}));t=this._canceller.cancellable(u=>{if(u.cancelled)return Promise.reject({code:b.ErrorCodes.CANCELLED,message:"Response was invalidated."});u=u.value;switch(l){case "VERTEX":n.vertices=q(new Float32Array(u));break;case "FACE":n.faces=q(new Int32Array(u));break;case "COLOR":n.colors=q(new Uint8Array(u))}return n});return this._requestManager.fetch(k,null,"arraybuffer",f[l]).then(u=>u.arrayBuffer()).then(t)}fetchData(k,t,l,p){let m=[],n=new Map;Object.keys(d).forEach(q=>
{k.components&1<<d[q]&&m.push(this._fetchDataByStep(t,l,q,p,k.step,n))});return Promise.all(m)}_fetchMetadata(k,t,l){this._canceller.cancelAll();k=vc.getRouter().pluginRoute("mesh","/meshes",new URLSearchParams({tag:t,run:k,sample:l}));t=this._canceller.cancellable(p=>p.cancelled?Promise.reject({code:b.ErrorCodes.CANCELLED,message:"Response was invalidated."}):p.value);return this._requestManager.fetch(k).then(p=>p.json()).then(t).then(this._processMetadata.bind(this))}_processMetadata(k){if(k){var t=
new Map;for(let p=0;p<k.length;p++){let m=k[p];t.has(m.step)||t.set(m.step,[]);t.get(m.step).push(m)}var l=[];t.forEach(p=>{p=this._createStepDatum(p[0]);l.push(p)});return l}}_createStepDatum(k){return{wall_time:new Date(1E3*k.wall_time),step:k.step,config:k.config,content_type:k.content_type,components:k.components}}}b.ArrayBufferDataProvider=h})(Lk||(Lk={}));

//# sourceURL=build://tf-imports/mesh-viewer.js
(function(b){class d extends THREE.EventDispatcher{constructor(f){super();this._lastMesh=null;this._clock=new THREE.Clock;this._canvasSize=null;this._runColor=f}_isObject(f){return"object"==typeof f&&null!=f&&!Array.isArray(f)}_applyDefaults(f,h){let k={};f=[f,h];for(h=0;h<f.length;h++){const t=f[h];for(let l in t){const p=l in k;this._isObject(t[l])?k[l]=this._applyDefaults(k[l]||{},t[l]):p||(k[l]=t[l])}}return k}_createWorld(f,h){this.isReady()||(this._scene=new THREE.Scene,this._camera=f=new THREE[f.camera.cls](f.camera.fov,
this._canvasSize.width/this._canvasSize.height,f.camera.near,f.camera.far),h=new THREE.OrbitControls(f,h),h.lookSpeed=.4,h.movementSpeed=20,h.noFly=!0,h.lookVertical=!0,h.constrainVertical=!0,h.verticalMin=1,h.verticalMax=2,h.addEventListener("change",this._onCameraPositionChange.bind(this)),this._cameraControls=h,this._renderer=new THREE.WebGLRenderer({antialias:!0}),this._renderer.setPixelRatio(),this._renderer.setSize(this._canvasSize.width,this._canvasSize.height),this._renderer.setClearColor(16777215,
1))}_clearScene(){for(;0<this._scene.children.length;)this._scene.remove(this._scene.children[0])}getRenderer(){return this._renderer}getCameraControls(){return this._cameraControls}isReady(){return!!this._camera&&!!this._cameraControls}getCameraPosition(){return{far:this._camera.far,position:this._camera.position.clone(),target:this._cameraControls.target.clone()}}setCanvasSize(f){this._canvasSize=f}draw(){this._animationFrameIndex&&cancelAnimationFrame(this._animationFrameIndex);this._camera.aspect=
this._canvasSize.width/this._canvasSize.height;this._camera.updateProjectionMatrix();this._renderer.setSize(this._canvasSize.width,this._canvasSize.height);const f=function(){var h=this._clock.getDelta();this._cameraControls.update(h);this._animationFrameIndex=requestAnimationFrame(f);this._renderer.render(this._scene,this._camera)}.bind(this);f()}updateScene(f,h){let k={};"config"in f&&f.config&&(k=JSON.parse(f.config));this.dispatchEvent({type:"beforeUpdateScene"});k=this._applyDefaults(k,{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]}]});this._createWorld(k,h);this._clearScene();this._createLights(this._scene,k);this._createGeometry(f,k);this.draw()}resetView(){if(this.isReady()){this._cameraControls.reset();if(!f&&this._lastMesh)var f=this._lastMesh;f&&(this._fitObjectToViewport(f),this._lastMesh=f);this._cameraControls.update()}}_createGeometry(f,h){f=f.mesh;f.vertices&&f.faces&&
f.faces.length?this._createMesh(f,h):this._createPointCloud(f,h)}_createPointCloud(f,h){var k=f.vertices;f=f.colors;let t={material:{cls:"PointsMaterial",size:.005}};f&&f.length==k.length?t.material.vertexColors=THREE.VertexColors:t.material.color=this._runColor;h=this._applyDefaults(h,t);var l=new THREE.Geometry;k.forEach(function(p){var m=new THREE.Vector3(p[0],p[1],p[2]);m.x=1*p[0];m.y=1*p[1];m.z=1*p[2];l.vertices.push(m)});f&&f.length==k.length&&f.forEach(function(p){p=new THREE.Color(p[0]/255,
p[1]/255,p[2]/255);l.colors.push(p)});k=new THREE[h.material.cls](h.material);k=new THREE.Points(l,k);this._scene.add(k);this._lastMesh=k}setCameraViewpoint(f,h,k){this._silent=!0;this._camera.far=h;this._camera.position.set(f.x,f.y,f.z);this._camera.lookAt(k.clone());this._camera.updateProjectionMatrix();this._cameraControls.target=k.clone();this._cameraControls.update();this._silent=!1}_onCameraPositionChange(f){this._silent||this.dispatchEvent({type:"cameraPositionChange",event:f})}_fitObjectToViewport(f){var h=
new THREE.Box3;h.setFromObject(f);f=h.center();var k=h.size();k=1.25*Math.abs(Math.max(k.x,k.y,k.z)/(2*Math.tan(Math.PI/180*this._camera.fov/2)));h=h.min.z;this.setCameraViewpoint({x:f.x,y:f.y,z:k},3*(0>h?-h+k:k-h),f)}_createMesh(f,h){var k=f.vertices;const t=f.faces,l=f.colors;f=this._applyDefaults(h,{material:{cls:"MeshStandardMaterial",color:"#a0a0a0",roughness:1,metalness:0}});let p=new THREE.Geometry;k.forEach(function(m){let n=new THREE.Vector3(m[0],m[1],m[2]);n.x=1*m[0];n.y=1*m[1];n.z=1*m[2];
p.vertices.push(n)});t.forEach(function(m){let n=new THREE.Face3(m[0],m[1],m[2]);if(l&&l.length){m=[l[m[0]],l[m[1]],l[m[2]]];for(let u=0;u<m.length;u++){var q=m[u];q=new THREE.Color(q[0]/255,q[1]/255,q[2]/255);n.vertexColors.push(q)}}p.faces.push(n)});l&&l.length&&(f.material=f.material||{},f.material.vertexColors=THREE.VertexColors);p.center();p.computeBoundingSphere();p.computeVertexNormals();k=new THREE[f.material.cls](f.material);k=new THREE.Mesh(p,k);k.castShadow=!0;k.receiveShadow=!0;this._scene.add(k);
this._lastMesh=k}_createLights(f,h){for(let k=0;k<h.lights.length;k++){const t=h.lights[k];let l=new THREE[t.cls](t.color,t.intensity);t.position&&l.position.set(t.position[0],t.position[1],t.position[2]);f.add(l)}}}b.MeshViewer=d})(Lk||(Lk={}));

//# sourceURL=build://tf-mesh-dashboard/mesh-loader.js
(function(b){Polymer({is:"tf-mesh-loader",properties:{run:String,tag:String,sample:Number,ofSamples:Number,selectedView:{type:String,value:"all"},active:{type:Boolean,value:!1},requestManager:Object,_meshViewer:{type:Object},_dataProvider:{type:Object},_colorScaleFunction:{type:Object,value:()=>pf.runsColorScale},_runColor:{type:String,computed:"_computeRunColor(run)"},_steps:{type:Array,value:()=>[],notify:!0},_stepIndex:{type:Number,notify:!0},_currentStep:{type:Object,computed:"_computeCurrentStep(_steps, _stepIndex)"},
_meshViewerAttached:{type:Boolean,value:!1},_cameraPositionInitialized:{type:Boolean,value:!1},_stepValue:{type:Number,computed:"_computeStepValue(_currentStep)"},_currentWallTime:{type:String,computed:"_computeCurrentWallTime(_currentStep)"},_isMeshLoading:{type:Boolean,value:!1}},observers:["reload(run, tag, active, _dataProvider, _meshViewer)","_updateScene(_currentStep.*, _meshViewer)","_debouncedFetchMesh(_currentStep)","_updateView(selectedView)"],_computeRunColor:function(d){return this._colorScaleFunction(d)},
attached:function(){this._dataProvider=new b.ArrayBufferDataProvider(this.requestManager);const d=new b.MeshViewer(this._runColor);d.addEventListener("beforeUpdateScene",this._updateCanvasSize.bind(this));d.addEventListener("cameraPositionChange",this._onCameraPositionChange.bind(this));this._meshViewer=d},reload:function(){this.active&&this._dataProvider&&(this.set("_isMeshLoading",!0),this._dataProvider.reload(this.run,this.tag,this.sample).then(d=>{d&&(this.set("_steps",d),this.set("_stepIndex",
d.length-1))}).catch(d=>{if(!d||!d.code||d.code!=b.ErrorCodes.CANCELLED)throw Error(d||"Response processing failed.");}))},_updateScene:function(){const d=this._currentStep;d&&d.mesh&&(this._meshViewer.updateScene(d,this),this._cameraPositionInitialized||(this._meshViewer.resetView(),this._cameraPositionInitialized=!0),this._meshViewerAttached||(this.root.appendChild(this._meshViewer.getRenderer().domElement),this._meshViewerAttached=!0))},_debouncedFetchMesh(){this.debounce("fetchMesh",()=>this._maybeFetchMesh(),
100)},_maybeFetchMesh(){const d=this;return hc(function*(){const f=d._currentStep;if(f&&!f.mesh&&!f.meshFetching){f.meshFetching=!0;d._isMeshLoading=!0;try{const h=yield d._dataProvider.fetchData(f,d.run,d.tag,d.sample);f.mesh=h[0];d.notifyPath("_currentStep.mesh")}catch(h){if(!h||!h.code||h.code!=b.ErrorCodes.CANCELLED)throw h=h||"Response processing failed.",Error(h);}finally{d._isMeshLoading=!1,f.meshFetching=!1}}})},_onCameraPositionChange:function(){if(this._meshViewer.isReady()){var d=new CustomEvent("camera-position-change",
{detail:this._meshViewer.getCameraPosition()});this.dispatchEvent(d)}},setCameraViewpoint:function(d,f,h){this._meshViewer.setCameraViewpoint(d,f,h)},_updateCanvasSize:function(){const d=this.offsetWidth,f=this.$$(".tf-mesh-loader-header").offsetHeight;this._meshViewer.setCanvasSize({width:d,height:d-f})},redraw:function(){this._updateCanvasSize();this.isConnected&&this._meshViewer.draw()},_hasAtLeastOneStep:function(d){return!!d&&0<d.length},_hasMultipleSteps:function(d){return!!d&&1<d.length},_computeCurrentStep:function(d,
f){return d[f]||null},_computeStepValue:function(d){return d?d.step:0},_computeCurrentWallTime:function(d){return d?Hh.formatDate(d.wall_time):""},_getMaxStepIndex:function(d){return d.length-1},_getSampleText:function(d){return String(d+1)},_hasMultipleSamples:function(d){return 1<d},_updateView:function(d){this._meshViewer&&"all"==d&&this._meshViewer.resetView()},toLocaleString_:function(d){return d.toLocaleString()}})})(Lk||(Lk={}));

//# sourceURL=build://tf-mesh-dashboard/tf-mesh-dashboard.html.js
(function(){Polymer({is:"mesh-dashboard",properties:{_selectedRuns:Array,_runToTagInfo:Object,_dataNotFound:Boolean,_tagFilter:{type:String,value:".*"},_selectedView:{type:String,notify:!0,value:"all"},_categories:{type:Array,computed:"_makeCategories(_runToTagInfo, _selectedRuns, _tagFilter)"},_requestManager:{type:Object,value:()=>new vc.RequestManager}},ready(){window.addEventListener("resize",()=>{this._handleWindowResize()},!1);this.reload()},_getAllChildren(){return this.root.querySelectorAll("tf-mesh-loader")},
_onCameraPositionChanged(b){"share"==this._selectedView&&this._getAllChildren().forEach(d=>{b.target!=d&&d.setCameraViewpoint(b.detail.position,b.detail.far,b.detail.target)})},_shouldOpen(b){return 2>=b},reload(){this._fetchTags().then(this._reloadMeshes.bind(this))},_handleWindowResize(){this._getAllChildren().forEach(b=>{b.redraw()})},_fetchTags(){const b=vc.getRouter().pluginRoute("mesh","/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,this._runToTagInfo)){var f=_.mapValues(d,
h=>Object.keys(h));f=vc.getTags(f);this.set("_dataNotFound",0===f.length);this.set("_runToTagInfo",d)}})},_reloadMeshes(){this._getAllChildren().forEach(b=>{b.reload()})},_makeCategories(b,d,f){function h(t){const l=b[t.run][t.tag].samples;return _.range(l).map(p=>Object.assign({},t,{sample:p,ofSamples:l}))}const k=_.mapValues(b,t=>Object.keys(t));return $c.categorizeRunTagCombinations(k,d,f).map(t=>Object.assign({},t,{items:[].concat.apply([],t.items.map(h))}))}})})();

//# sourceURL=build://tf-plugin-util/message.js
Ui=this&&this.__awaiter||function(b,d,f,h){return new (f||(f=Promise))(function(k,t){function l(n){try{m(h.next(n))}catch(q){t(q)}}function p(n){try{m(h["throw"](n))}catch(q){t(q)}}function m(n){n.done?k(n.value):(new f(function(q){q(n.value)})).then(l,p)}m((h=h.apply(b,d||[])).next())})};var Mk;
(function(b){(function(d){(function(f){class h{constructor(k){this.port=k;this.id=0;this.responseWaits=new Map;this.listeners=new Map;this.port.addEventListener("message",t=>this.onMessage(t))}listen(k,t){this.listeners.set(k,t)}unlisten(k){this.listeners.delete(k)}onMessage(k){return Ui(this,void 0,void 0,function*(){var t=JSON.parse(k.data);const l=t.type,p=t.id,m=t.payload;var n=t.error;if(t.isReply){if(this.responseWaits.has(p)){var {resolve:q,reject:u}=this.responseWaits.get(p);this.responseWaits.delete(p);
n?u(Error(n)):q(m)}}else{n=t=null;if(this.listeners.has(l)){const x=this.listeners.get(l);try{t=yield x(m)}catch(A){n=A}}this.postMessage({["type"]:l,["id"]:p,["payload"]:t,["error"]:n,["isReply"]:!0})}})}postMessage(k){this.port.postMessage(JSON.stringify(k))}sendMessage(k){const t=this.id++;this.postMessage({type:"experimental.RunsChanged",id:t,payload:k,error:null,isReply:!1});return new Promise((l,p)=>{this.responseWaits.set(t,{resolve:l,reject:p})})}}f.IPC=h})(d.DO_NOT_USE_INTERNAL||(d.DO_NOT_USE_INTERNAL=
{}))})(b.lib||(b.lib={}))})(Mk||(Mk={}));

//# sourceURL=build://tf-plugin-util/plugin-host-ipc.js
(function(b){(function(d){function f(m,n){const q=new b.lib.DO_NOT_USE_INTERNAL.IPC(m);t.add(q);p.set(q,n);m.start();for(const [u,x]of l)m=h(x,q),q.listen(u,m)}function h(m,n){return q=>{var u=p.get(n);u=k.get(u)||null;return m(u,q)}}d.registerPluginIframe=function(m,n){k.set(m,{pluginName:n})};const k=new WeakMap,t=new Set,l=new Map,p=new Map;window.addEventListener("message",m=>{if("experimental.bootstrap"===m.data){var n=m.ports[0];n&&(m=m.source?m.source.frameElement:null)&&f(n,m)}});d.broadcast=
function(){var m=vc.runsStore.getRuns();for(var n of t)p.get(n).isConnected||(t.delete(n),p.delete(n));n=[...t].map(q=>q.sendMessage(m));return Promise.all(n)};d.listen=function(m,n){l.set(m,n);for(const q of t){const u=h(n,q);q.listen(m,u)}};d.unlisten=function(m){l.delete(m);for(const n of t)n.unlisten(m)}})(b.host||(b.host={}))})(Mk||(Mk={}));

//# sourceURL=build://tf-plugin-util/core-host-impl.js
Mk.host.listen("experimental.GetURLPluginData",b=>{if(b){b=`p.${b.pluginName}.`;var d={};for(let f in pd.urlDict)f.startsWith(b)&&(d[f.substring(b.length)]=pd.urlDict[f]);return d}});

//# sourceURL=build://tf-plugin-util/runs-host-impl.js
Mk.host.listen("experimental.GetRuns",()=>vc.runsStore.getRuns());vc.runsStore.addListener(()=>Mk.host.broadcast());

//# sourceURL=build://tf-tensorboard/autoReloadBehavior.js
(function(b){function d(){return(new URLSearchParams(window.location.search)).has("_DisableAutoReload")}b.AUTORELOAD_LOCALSTORAGE_KEY="TF.TensorBoard.autoReloadEnabled";b.AutoReloadBehavior={properties:{autoReloadEnabled:{type:Boolean,observer:"_autoReloadObserver",value:()=>{var f=window.localStorage.getItem(b.AUTORELOAD_LOCALSTORAGE_KEY);return"true"===f||null==f}},_autoReloadId:{type:Number},_missedAutoReload:{type:Boolean,value:!1},_boundHandleVisibilityChange:{type:Object},autoReloadIntervalSecs:{type:Number,
value:30}},attached:function(){this._boundHandleVisibilityChange=this._handleVisibilityChange.bind(this);document.addEventListener("visibilitychange",this._boundHandleVisibilityChange)},detached:function(){window.clearTimeout(this._autoReloadId);document.removeEventListener("visibilitychange",this._boundHandleVisibilityChange)},_autoReloadObserver:function(f){window.localStorage.setItem(b.AUTORELOAD_LOCALSTORAGE_KEY,f);f&&!d()?this._autoReloadId=window.setTimeout(()=>this._doAutoReload(),1E3*this.autoReloadIntervalSecs):
window.clearTimeout(this._autoReloadId)},_doAutoReload:function(){this._isDocumentVisible()?this._doReload():this._missedAutoReload=!0;this._autoReloadId=window.setTimeout(()=>this._doAutoReload(),1E3*this.autoReloadIntervalSecs)},_doReload:function(){if(null==this.reload)throw Error("AutoReloadBehavior requires a reload method");this.reload()},_handleVisibilityChange:function(){this._isDocumentVisible()&&this._missedAutoReload&&(this._missedAutoReload=!1,this._doReload())},_isDocumentVisible:function(){return"visible"===
document.visibilityState}}})(qf||(qf={}));

//# sourceURL=build://tf-tensorboard/tf-tensorboard.html.js
const Ym={getLocation(){return window.location}};
Polymer({is:"tf-tensorboard",behaviors:[qf.AutoReloadBehavior],properties:{brand:{type:String,value:"TensorBoard-X"},homePath:{type:String,value:""},_homePath:{type:String,computed:"_sanitizeHomePath(homePath)"},title:{type:String,observer:"_updateTitle"},router:{type:Object,observer:"_updateRouter"},demoDir:{type:String,value:null},useHash:{type:Boolean,value:!1},disabledDashboards:{type:String,value:""},_dashboardData:{type:Array,computed:"_computeDashboardData(_dashboardRegistry)"},_dashboardRegistry:{type:Object,
computed:"_computeDashboardRegistry(_pluginsListing)"},_pluginsListing:{type:Object,value:()=>({})},_activeDashboards:{type:Array,computed:"_computeActiveDashboard(_dashboardData, _pluginsListing)"},_activeDashboardsLoadState:{type:String,value:qf.ActiveDashboardsLoadState.NOT_LOADED},_activeDashboardsNotLoaded:{type:Boolean,computed:"_computeActiveDashboardsNotLoaded(_activeDashboardsLoadState)"},_activeDashboardsLoaded:{type:Boolean,computed:"_computeActiveDashboardsLoaded(_activeDashboardsLoadState)"},
_activeDashboardsFailedToLoad:{type:Boolean,computed:"_computeActiveDashboardsFailedToLoad(_activeDashboardsLoadState)"},_showNoDashboardsMessage:{type:Boolean,computed:"_computeShowNoDashboardsMessage(_activeDashboardsLoaded, _activeDashboards, _selectedDashboard)"},_showNoSuchDashboardMessage:{type:Boolean,computed:"_computeShowNoSuchDashboardMessage(_activeDashboardsLoaded, _dashboardRegistry, _selectedDashboard)"},_selectedDashboard:{type:String,value:pd.getString(pd.TAB)||null,observer:"_selectedDashboardChanged"},
_dashboardToMaybeRemove:String,_dashboardContainersStamped:{type:Object,value:()=>({})},_isReloadDisabled:{type:Boolean,value:!1},_lastReloadTime:{type:String,value:"not yet loaded"},_lastReloadTimeShort:{type:String,value:"Not yet loaded"},_dataLocation:{type:String,value:null},_requestManager:{type:Object,value:()=>new vc.RequestManager},_canceller:{type:Object,value:()=>new vc.Canceller},_refreshing:{type:Boolean,value:!1}},observers:["_updateSelectedDashboardFromActive(_selectedDashboard, _activeDashboards)",
"_ensureSelectedDashboardStamped(_dashboardRegistry, _dashboardContainersStamped, _activeDashboards, _selectedDashboard)"],_sanitizeHomePath(b){if(!b)return"";const d=Ym.getLocation(),f=new URL(b,d.href),h="http:"===f.protocol||"https:"===f.protocol,k=f.origin===d.origin;if(!h)throw new RangeError(`Expect 'homePath' to be of http: or https:. ${b}`);if(!k)throw new RangeError(`Expect 'homePath' be a path or have the same origin. ${b} vs. ${d.origin}`);return h&&k?f.toString():""},_activeDashboardsUpdated(){},
_isDashboardActive(b,d,f){return 0<=(b||"").split(",").indexOf(f.plugin)||!(d||[]).includes(f.plugin)?!1:!0},_isDashboardInactive(b,d,f){return 0<=(b||"").split(",").indexOf(f.plugin)?!1:(d||[]).includes(f.plugin)?!1:!0},_inactiveDashboardsExist(b,d,f){if(!f)return!1;const h=new Set;b.forEach(k=>{h.add(k.plugin)});(d||"").split(",").forEach(k=>{h.delete(k.plugin)});f.forEach(k=>{h.delete(k)});return 0<h.size},_getDashboardFromIndex(b,d){return b[d]},_selectedStatus(b,d){return b===d},_selectedDashboardChanged(b){b=
b||"";pd.setString(pd.TAB,b);let d=window.location.pathname;d+=d.endsWith("/")?b:"/"+b;ga("set","page",d);ga("send","pageview")},_updateSelectedDashboardFromActive(b,d){d&&null==b&&(b=d[0]||null,null!=b&&(pd.setString(pd.TAB,b,{useLocationReplace:!0}),this._selectedDashboard=b))},_updateSelectedDashboardFromHash(){const b=pd.getString(pd.TAB);this.set("_selectedDashboard",b||null)},_ensureSelectedDashboardStamped(b,d,f,h){if(f&&h&&d[h]&&(d=this._dashboardToMaybeRemove,this._dashboardToMaybeRemove=
h,d&&d!=h&&b[d].removeDom&&(d=this.$$(`.dashboard-container[data-dashboard=${d}]`),d.firstChild&&d.firstChild.remove()),d=this.$$(`.dashboard-container[data-dashboard=${h}]`))){b=b[h];if(0===d.children.length)switch(f=b.loadingMechanism,f.type){case "CUSTOM_ELEMENT":h=document.createElement(f.elementName);h.id="dashboard";d.appendChild(h);break;case "IFRAME":this._renderPluginIframe(d,h,f);break;default:console.warn("Invariant violation:",f)}this.set("_isReloadDisabled",b.disableReload)}},_renderPluginIframe(b,
d){const f=document.createElement("iframe");f.id="dashboard";Mk.host.registerPluginIframe(f,d);const h=new URL("data/plugin_entry.html",window.location.href);h.searchParams.set("name",d);f.setAttribute("src",h.toString());b.appendChild(f)},_selectedDashboardComponent(){return this.$$(`.dashboard-container[data-dashboard=${this._selectedDashboard}] #dashboard`)},ready(){ad.setUseHash(this.useHash);this._updateSelectedDashboardFromHash();window.addEventListener("hashchange",()=>{this._updateSelectedDashboardFromHash()},
!1);vc.environmentStore.addListener(()=>{this._dataLocation=vc.environmentStore.getDataLocation();const b=vc.environmentStore.getWindowTitle();b&&(window.document.title=b)});pd.migrateLegacyURLScheme();this._reloadData();this._lastReloadTime=(new Date).toString()},_computeActiveDashboard(){return this._dashboardData?this._dashboardData.map(b=>b.plugin).filter(b=>{b=this._pluginsListing[b];return"boolean"===typeof b?b:b&&b.enabled}):[]},_onTemplateChanged(){const b={};for(const d of this.root.querySelectorAll(".dashboard-container"))b[d.dataset.dashboard]=
!0;this._dashboardContainersStamped=b},_computeDashboardRegistry(b){const d={};for(const [h,k]of Object.entries(qf.dashboardRegistry))d[h]={plugin:k.plugin,loadingMechanism:{type:"CUSTOM_ELEMENT",elementName:k.elementName},tabName:k.tabName.toUpperCase(),disableReload:k.isReloadDisabled||!1,removeDom:k.removeDom||!1};if(null!=b)for(const [h,k]of Object.entries(b))if("boolean"!==typeof k){switch(k.loading_mechanism.type){case "NONE":null==d[h]&&console.warn("Plugin has no loading mechanism and no baked-in registry entry: %s",
h);continue;case "CUSTOM_ELEMENT":var f={type:"CUSTOM_ELEMENT",elementName:k.loading_mechanism.element_name};break;case "IFRAME":f={type:"IFRAME",modulePath:k.loading_mechanism.module_path};break;default:console.warn("Unknown loading mechanism for plugin %s: %s",h,k.loading_mechanism);continue}null==f&&console.error("Invariant violation: loadingMechanism is %s for %s",f,h);d[h]={plugin:h,loadingMechanism:f,tabName:k.tab_name.toUpperCase(),disableReload:k.disable_reload,removeDom:k.remove_dom}}f={};
for(const h of Object.keys(b))d[h]&&(f[h]=d[h]);Object.assign(f,d);return f},_computeDashboardData(b){return Object.values(b)},_fetchPluginsListing(){this._canceller.cancelAll();const b=this._canceller.cancellable(d=>{d.cancelled||(this._pluginsListing=d.value,this._activeDashboardsLoadState=qf.ActiveDashboardsLoadState.LOADED)});return this._requestManager.request(vc.getRouter().pluginsListing()).then(b,()=>{this._activeDashboardsLoadState===qf.ActiveDashboardsLoadState.NOT_LOADED?this._activeDashboardsLoadState=
qf.ActiveDashboardsLoadState.FAILED:console.warn("Failed to reload the set of active plugins; using old value.")})},_computeActiveDashboardsNotLoaded(b){return b===qf.ActiveDashboardsLoadState.NOT_LOADED},_computeActiveDashboardsLoaded(b){return b===qf.ActiveDashboardsLoadState.LOADED},_computeActiveDashboardsFailedToLoad(b){return b===qf.ActiveDashboardsLoadState.FAILED},_computeShowNoDashboardsMessage(b,d,f){return b&&0===d.length&&null==f},_computeShowNoSuchDashboardMessage(b,d,f){return b&&!!f&&
null==d[f]},_updateRouter(b){vc.setRouter(b)},_updateTitle(b){b&&this.set("brand",b)},reload(){this._isReloadDisabled||(this._reloadData().then(()=>{const b=this._selectedDashboardComponent();b&&b.reload&&b.reload()}),this._lastReloadTime=(new Date).toString())},_reloadData(){this._refreshing=!0;return Promise.all([this._fetchPluginsListing(),vc.environmentStore.refresh(),vc.runsStore.refresh(),vc.experimentsStore.refresh()]).then(()=>{this._lastReloadTimeShort=(new Date).toLocaleDateString(void 0,
{month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"})}).finally(()=>{this._refreshing=!1})},_getDataRefreshingClass(){return this._refreshing?"refreshing":""},openSettings(){this.$.settings.open();this.$.paginationLimitInput.value=ne.getLimit()},_paginationLimitValidate(b){b.target.validate()},_paginationLimitChanged(b){b=Number.parseInt(b.target.value,10);b===+b&&0<b&&ne.setLimit(b)}});
",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/javascript; charset=utf-8"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/runs": {
+ "data": "WyJ2ZXJzaW9uXzAiLCAidmVyc2lvbl8xIl0=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/environment": {
+ "data": "eyJkYXRhX2xvY2F0aW9uIjogImxpZ2h0bmluZ19sb2dzLyIsICJ3aW5kb3dfdGl0bGUiOiAiIn0=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "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/experiments": {
+ "data": "W10=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/tags": {
+ "data": "eyJ2ZXJzaW9uXzAiOiB7InRyYWluX2xvc3MiOiB7ImRpc3BsYXlOYW1lIjogInRyYWluX2xvc3MiLCAiZGVzY3JpcHRpb24iOiAiIn0sICJlcG9jaCI6IHsiZGlzcGxheU5hbWUiOiAiZXBvY2giLCAiZGVzY3JpcHRpb24iOiAiIn0sICJ2YWxfbG9zcyI6IHsiZGlzcGxheU5hbWUiOiAidmFsX2xvc3MiLCAiZGVzY3JpcHRpb24iOiAiIn0sICJBY2N1cmFjeSI6IHsiZGlzcGxheU5hbWUiOiAiQWNjdXJhY3kiLCAiZGVzY3JpcHRpb24iOiAiIn19LCAidmVyc2lvbl8xIjogeyJ0cmFpbl9sb3NzIjogeyJkaXNwbGF5TmFtZSI6ICJ0cmFpbl9sb3NzIiwgImRlc2NyaXB0aW9uIjogIiJ9LCAiZXBvY2giOiB7ImRpc3BsYXlOYW1lIjogImVwb2NoIiwgImRlc2NyaXB0aW9uIjogIiJ9LCAidmFsX2xvc3MiOiB7ImRpc3BsYXlOYW1lIjogInZhbF9sb3NzIiwgImRlc2NyaXB0aW9uIjogIiJ9LCAiQWNjdXJhY3kiOiB7ImRpc3BsYXlOYW1lIjogIkFjY3VyYWN5IiwgImRlc2NyaXB0aW9uIjogIiJ9LCAibG9zcyI6IHsiZGlzcGxheU5hbWUiOiAibG9zcyIsICJkZXNjcmlwdGlvbiI6ICIifX19",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy&run=version_1": {
+ "data": "W1sxNTkwOTU2ODIzLjk1MDE1NCwgNDI5LCAwLjk2NjAwMDAyMDUwMzk5NzhdLCBbMTU5MDk1NjgyMy45NTc3NDE1LCA0MzAsIDAuODIxNDkwODgzODI3MjA5NV0sIFsxNTkwOTU2ODQwLjY2NDk3MjMsIDg1OSwgMC45Nzk3OTk5ODU4ODU2MjAxXSwgWzE1OTA5NTY4NDAuNjc2NjIyNiwgODYwLCAwLjk0NjQzNjM0NTU3NzI0XSwgWzE1OTA5NTY4NTcuMTA3NzI1LCAxMjg5LCAwLjk4NDYwMDAwNzUzNDAyNzFdLCBbMTU5MDk1Njg1Ny4xMTcwOTcsIDEyOTAsIDAuOTU5ODU0NTQzMjA5MDc1OV0sIFsxNTkwOTU2ODczLjQwMzM0NDQsIDE3MTksIDAuOTg2MDAwMDAxNDMwNTExNV0sIFsxNTkwOTU2ODczLjQxMjI5NTgsIDE3MjAsIDAuOTY3MDM2MzY2NDYyNzA3NV0sIFsxNTkwOTU2ODkwLjAyNDc4MywgMjE0OSwgMC45ODg3OTk5ODkyMjM0ODAyXSwgWzE1OTA5NTY4OTAuMDM0MTAwMywgMjE1MCwgMC45NzAyNTQ1NDA0NDM0MjA0XSwgWzE1OTA5NTY5MDYuMjczNDUxMywgMjU3OSwgMC45ODk0MDAwMjkxODI0MzQxXSwgWzE1OTA5NTY5MDYuMjkyNTYwMywgMjU4MCwgMC45NzI1NjM2MjQzODIwMTldLCBbMTU5MDk1NjkyMi42MjAxMjc3LCAzMDA5LCAwLjk5MDU5OTk4OTg5MTA1MjJdLCBbMTU5MDk1NjkyMi42Mzg4MDU5LCAzMDEwLCAwLjk3NDg3MjcwODMyMDYxNzddLCBbMTU5MDk1NjkzOS4yODc0NTYzLCAzNDM5LCAwLjk5MTk5OTk4Mzc4NzUzNjZdLCBbMTU5MDk1NjkzOS4yOTYyMjI0LCAzNDQwLCAwLjk3NzE0NTQzMzQyNTkwMzNdLCBbMTU5MDk1Njk1NS41NTM2OTUsIDM4NjksIDAuOTkxMTk5OTcwMjQ1MzYxM10sIFsxNTkwOTU2OTU1LjU2Mjg3MSwgMzg3MCwgMC45NzczNjM2NDYwMzA0MjZdLCBbMTU5MDk1Njk3MS43NzYxNTg4LCA0Mjk5LCAwLjk5MjIwMDAxNjk3NTQwMjhdLCBbMTU5MDk1Njk3MS43OTYyNzM1LCA0MzAwLCAwLjk3OTYwMDAxMjMwMjM5ODddXQ==",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy&run=version_0": {
+ "data": "W1sxNTkwOTU2Njk3LjY5ODUxMzUsIDQyOSwgMC45NTQ1OTk5NzY1Mzk2MTE4XV0=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=epoch&run=version_1": {
+ "data": "[[1590956808.6910298, 0, 0.0], [1590956809.0531673, 10, 0.0], [1590956809.3608425, 20, 0.0], [1590956809.680957, 30, 0.0], [1590956809.9840417, 40, 0.0], [1590956810.2782314, 50, 0.0], [1590956810.590057, 60, 0.0], [1590956810.884758, 70, 0.0], [1590956811.1925356, 80, 0.0], [1590956811.488656, 90, 0.0], [1590956811.7898476, 100, 0.0], [1590956812.1017432, 110, 0.0], [1590956812.4056091, 120, 0.0], [1590956812.6914427, 130, 0.0], [1590956813.00135, 140, 0.0], [1590956813.327231, 150, 0.0], [1590956813.634908, 160, 0.0], [1590956813.9503257, 170, 0.0], [1590956814.2925096, 180, 0.0], [1590956814.585703, 190, 0.0], [1590956814.8843656, 200, 0.0], [1590956815.20024, 210, 0.0], [1590956815.4993198, 220, 0.0], [1590956815.7932978, 230, 0.0], [1590956816.0958495, 240, 0.0], [1590956816.394595, 250, 0.0], [1590956816.696339, 260, 0.0], [1590956817.0166903, 270, 0.0], [1590956817.343934, 280, 0.0], [1590956817.643069, 290, 0.0], [1590956817.9447622, 300, 0.0], [1590956818.2499669, 310, 0.0], [1590956818.5530283, 320, 0.0], [1590956818.8479273, 330, 0.0], [1590956819.1667442, 340, 0.0], [1590956819.4605997, 350, 0.0], [1590956819.7538874, 360, 0.0], [1590956820.0241706, 370, 0.0], [1590956820.2675738, 380, 0.0], [1590956820.5015414, 390, 0.0], [1590956820.7277741, 400, 0.0], [1590956820.947797, 410, 0.0], [1590956821.17168, 420, 0.0], [1590956823.9502053, 429, 0.0], [1590956823.9578066, 430, 0.0], [1590956825.521443, 430, 1.0], [1590956825.9497423, 440, 1.0], [1590956826.2365422, 450, 1.0], [1590956826.5651984, 460, 1.0], [1590956826.8533535, 470, 1.0], [1590956827.1226099, 480, 1.0], [1590956827.42619, 490, 1.0], [1590956827.727476, 500, 1.0], [1590956828.0302722, 510, 1.0], [1590956828.3142684, 520, 1.0], [1590956828.618715, 530, 1.0], [1590956828.922164, 540, 1.0], [1590956829.2442248, 550, 1.0], [1590956829.5562224, 560, 1.0], [1590956829.8710318, 570, 1.0], [1590956830.165118, 580, 1.0], [1590956830.4704561, 590, 1.0], [1590956830.772014, 600, 1.0], [1590956831.063514, 610, 1.0], [1590956831.3568914, 620, 1.0], [1590956831.6514955, 630, 1.0], [1590956831.9547315, 640, 1.0], [1590956832.2538273, 650, 1.0], [1590956832.5536277, 660, 1.0], [1590956832.8591964, 670, 1.0], [1590956833.158075, 680, 1.0], [1590956833.46704, 690, 1.0], [1590956833.7823362, 700, 1.0], [1590956834.0778346, 710, 1.0], [1590956834.3638525, 720, 1.0], [1590956834.6638348, 730, 1.0], [1590956834.9698703, 740, 1.0], [1590956835.2573688, 750, 1.0], [1590956835.562157, 760, 1.0], [1590956835.8784466, 770, 1.0], [1590956836.179208, 780, 1.0], [1590956836.4702466, 790, 1.0], [1590956836.7282004, 800, 1.0], [1590956836.9624057, 810, 1.0], [1590956837.1892445, 820, 1.0], [1590956837.415714, 830, 1.0], [1590956837.641558, 840, 1.0], [1590956837.8650122, 850, 1.0], [1590956840.6650643, 859, 1.0], [1590956840.6766965, 860, 1.0], [1590956842.3118532, 860, 2.0], [1590956842.6542525, 870, 2.0], [1590956842.9434857, 880, 2.0], [1590956843.2626336, 890, 2.0], [1590956843.5394263, 900, 2.0], [1590956843.8212795, 910, 2.0], [1590956844.135135, 920, 2.0], [1590956844.4124343, 930, 2.0], [1590956844.7195501, 940, 2.0], [1590956845.0215127, 950, 2.0], [1590956845.3143554, 960, 2.0], [1590956845.6085298, 970, 2.0], [1590956845.9088812, 980, 2.0], [1590956846.1912394, 990, 2.0], [1590956846.5066853, 1000, 2.0], [1590956846.7948093, 1010, 2.0], [1590956847.0870106, 1020, 2.0], [1590956847.3909056, 1030, 2.0], [1590956847.680583, 1040, 2.0], [1590956847.9746954, 1050, 2.0], [1590956848.2821553, 1060, 2.0], [1590956848.5728548, 1070, 2.0], [1590956848.8588874, 1080, 2.0], [1590956849.1525216, 1090, 2.0], [1590956849.4577036, 1100, 2.0], [1590956849.7443652, 1110, 2.0], [1590956850.044088, 1120, 2.0], [1590956850.3487918, 1130, 2.0], [1590956850.6424286, 1140, 2.0], [1590956850.947733, 1150, 2.0], [1590956851.2395759, 1160, 2.0], [1590956851.532728, 1170, 2.0], [1590956851.8116949, 1180, 2.0], [1590956852.1095252, 1190, 2.0], [1590956852.4091754, 1200, 2.0], [1590956852.7075777, 1210, 2.0], [1590956853.009278, 1220, 2.0], [1590956853.2508302, 1230, 2.0], [1590956853.471797, 1240, 2.0], [1590956853.675815, 1250, 2.0], [1590956853.9020743, 1260, 2.0], [1590956854.1258647, 1270, 2.0], [1590956854.3491228, 1280, 2.0], [1590956857.1077695, 1289, 2.0], [1590956857.1171575, 1290, 2.0], [1590956858.686226, 1290, 3.0], [1590956859.1063406, 1300, 3.0], [1590956859.3766909, 1310, 3.0], [1590956859.6836193, 1320, 3.0], [1590956859.9657135, 1330, 3.0], [1590956860.2466142, 1340, 3.0], [1590956860.549412, 1350, 3.0], [1590956860.8258963, 1360, 3.0], [1590956861.1305249, 1370, 3.0], [1590956861.4196403, 1380, 3.0], [1590956861.722169, 1390, 3.0], [1590956862.0121143, 1400, 3.0], [1590956862.3073325, 1410, 3.0], [1590956862.5961487, 1420, 3.0], [1590956862.8906581, 1430, 3.0], [1590956863.1742303, 1440, 3.0], [1590956863.4587011, 1450, 3.0], [1590956863.7564054, 1460, 3.0], [1590956864.051096, 1470, 3.0], [1590956864.3388045, 1480, 3.0], [1590956864.6332448, 1490, 3.0], [1590956864.9125977, 1500, 3.0], [1590956865.1925478, 1510, 3.0], [1590956865.4823148, 1520, 3.0], [1590956865.7675624, 1530, 3.0], [1590956866.0589151, 1540, 3.0], [1590956866.3527648, 1550, 3.0], [1590956866.6278949, 1560, 3.0], [1590956866.9227414, 1570, 3.0], [1590956867.2228422, 1580, 3.0], [1590956867.5128238, 1590, 3.0], [1590956867.811566, 1600, 3.0], [1590956868.0954201, 1610, 3.0], [1590956868.404074, 1620, 3.0], [1590956868.6993334, 1630, 3.0], [1590956868.9812815, 1640, 3.0], [1590956869.2658494, 1650, 3.0], [1590956869.520022, 1660, 3.0], [1590956869.7547953, 1670, 3.0], [1590956869.973937, 1680, 3.0], [1590956870.185153, 1690, 3.0], [1590956870.405841, 1700, 3.0], [1590956870.6222484, 1710, 3.0], [1590956873.4034047, 1719, 3.0], [1590956873.4123683, 1720, 3.0], [1590956874.9942026, 1720, 4.0], [1590956875.383531, 1730, 4.0], [1590956875.6757538, 1740, 4.0], [1590956876.0089033, 1750, 4.0], [1590956876.2926683, 1760, 4.0], [1590956876.5816646, 1770, 4.0], [1590956876.8740203, 1780, 4.0], [1590956877.1857903, 1790, 4.0], [1590956877.487718, 1800, 4.0], [1590956877.7777321, 1810, 4.0], [1590956878.0903695, 1820, 4.0], [1590956878.3848612, 1830, 4.0], [1590956878.6815867, 1840, 4.0], [1590956878.9897022, 1850, 4.0], [1590956879.2920454, 1860, 4.0], [1590956879.5889766, 1870, 4.0], [1590956879.8921454, 1880, 4.0], [1590956880.1946547, 1890, 4.0], [1590956880.4883637, 1900, 4.0], [1590956880.7757645, 1910, 4.0], [1590956881.0843637, 1920, 4.0], [1590956881.3759458, 1930, 4.0], [1590956881.6843088, 1940, 4.0], [1590956881.9810257, 1950, 4.0], [1590956882.275819, 1960, 4.0], [1590956882.574251, 1970, 4.0], [1590956882.861549, 1980, 4.0], [1590956883.1601777, 1990, 4.0], [1590956883.450806, 2000, 4.0], [1590956883.7470696, 2010, 4.0], [1590956884.04061, 2020, 4.0], [1590956884.342202, 2030, 4.0], [1590956884.63852, 2040, 4.0], [1590956884.9352546, 2050, 4.0], [1590956885.2453883, 2060, 4.0], [1590956885.5470622, 2070, 4.0], [1590956885.8622434, 2080, 4.0], [1590956886.1118999, 2090, 4.0], [1590956886.35317, 2100, 4.0], [1590956886.5645108, 2110, 4.0], [1590956886.7812092, 2120, 4.0], [1590956887.0014608, 2130, 4.0], [1590956887.2234974, 2140, 4.0], [1590956890.0248287, 2149, 4.0], [1590956890.0341964, 2150, 4.0], [1590956891.6661544, 2150, 5.0], [1590956892.0321848, 2160, 5.0], [1590956892.3357215, 2170, 5.0], [1590956892.6518366, 2180, 5.0], [1590956892.9369447, 2190, 5.0], [1590956893.1990995, 2200, 5.0], [1590956893.4882681, 2210, 5.0], [1590956893.7695603, 2220, 5.0], [1590956894.0602393, 2230, 5.0], [1590956894.3370292, 2240, 5.0], [1590956894.636721, 2250, 5.0], [1590956894.9205134, 2260, 5.0], [1590956895.2138221, 2270, 5.0], [1590956895.495665, 2280, 5.0], [1590956895.7868557, 2290, 5.0], [1590956896.079214, 2300, 5.0], [1590956896.3615854, 2310, 5.0], [1590956896.6456108, 2320, 5.0], [1590956896.9328117, 2330, 5.0], [1590956897.214866, 2340, 5.0], [1590956897.493379, 2350, 5.0], [1590956897.7781422, 2360, 5.0], [1590956898.0802948, 2370, 5.0], [1590956898.3830848, 2380, 5.0], [1590956898.6711652, 2390, 5.0], [1590956898.9547129, 2400, 5.0], [1590956899.2496126, 2410, 5.0], [1590956899.5515244, 2420, 5.0], [1590956899.838194, 2430, 5.0], [1590956900.13663, 2440, 5.0], [1590956900.4181657, 2450, 5.0], [1590956900.7019472, 2460, 5.0], [1590956901.00854, 2470, 5.0], [1590956901.2919388, 2480, 5.0], [1590956901.5845819, 2490, 5.0], [1590956901.865969, 2500, 5.0], [1590956902.164094, 2510, 5.0], [1590956902.4005682, 2520, 5.0], [1590956902.627197, 2530, 5.0], [1590956902.837278, 2540, 5.0], [1590956903.0636168, 2550, 5.0], [1590956903.2726047, 2560, 5.0], [1590956903.4867892, 2570, 5.0], [1590956906.2734954, 2579, 5.0], [1590956906.2926114, 2580, 5.0], [1590956907.951732, 2580, 6.0], [1590956908.2758822, 2590, 6.0], [1590956908.5569139, 2600, 6.0], [1590956908.8987758, 2610, 6.0], [1590956909.1834667, 2620, 6.0], [1590956909.4534953, 2630, 6.0], [1590956909.7311044, 2640, 6.0], [1590956910.0346448, 2650, 6.0], [1590956910.3321004, 2660, 6.0], [1590956910.614867, 2670, 6.0], [1590956910.9118552, 2680, 6.0], [1590956911.219141, 2690, 6.0], [1590956911.5115547, 2700, 6.0], [1590956911.8011203, 2710, 6.0], [1590956912.1219049, 2720, 6.0], [1590956912.4243317, 2730, 6.0], [1590956912.7187533, 2740, 6.0], [1590956913.0042446, 2750, 6.0], [1590956913.2940729, 2760, 6.0], [1590956913.57824, 2770, 6.0], [1590956913.8680766, 2780, 6.0], [1590956914.1651852, 2790, 6.0], [1590956914.4478257, 2800, 6.0], [1590956914.7315135, 2810, 6.0], [1590956915.0264266, 2820, 6.0], [1590956915.317204, 2830, 6.0], [1590956915.5936098, 2840, 6.0], [1590956915.875798, 2850, 6.0], [1590956916.173834, 2860, 6.0], [1590956916.461141, 2870, 6.0], [1590956916.751319, 2880, 6.0], [1590956917.048554, 2890, 6.0], [1590956917.3525069, 2900, 6.0], [1590956917.6390405, 2910, 6.0], [1590956917.9212148, 2920, 6.0], [1590956918.2095544, 2930, 6.0], [1590956918.4920952, 2940, 6.0], [1590956918.7278874, 2950, 6.0], [1590956918.9545386, 2960, 6.0], [1590956919.1760123, 2970, 6.0], [1590956919.4056478, 2980, 6.0], [1590956919.6259432, 2990, 6.0], [1590956919.8541563, 3000, 6.0], [1590956922.6201756, 3009, 6.0], [1590956922.6389766, 3010, 6.0], [1590956924.2531056, 3010, 7.0], [1590956924.6137817, 3020, 7.0], [1590956924.919445, 3030, 7.0], [1590956925.2242715, 3040, 7.0], [1590956925.5077786, 3050, 7.0], [1590956925.7865303, 3060, 7.0], [1590956926.0842524, 3070, 7.0], [1590956926.374713, 3080, 7.0], [1590956926.6789072, 3090, 7.0], [1590956926.9667525, 3100, 7.0], [1590956927.2603712, 3110, 7.0], [1590956927.560527, 3120, 7.0], [1590956927.8576677, 3130, 7.0], [1590956928.152759, 3140, 7.0], [1590956928.4573867, 3150, 7.0], [1590956928.7633822, 3160, 7.0], [1590956929.0552118, 3170, 7.0], [1590956929.365471, 3180, 7.0], [1590956929.6802623, 3190, 7.0], [1590956929.9982831, 3200, 7.0], [1590956930.2864413, 3210, 7.0], [1590956930.5871425, 3220, 7.0], [1590956930.886954, 3230, 7.0], [1590956931.1998866, 3240, 7.0], [1590956931.4890635, 3250, 7.0], [1590956931.8084857, 3260, 7.0], [1590956932.099553, 3270, 7.0], [1590956932.4049587, 3280, 7.0], [1590956932.705354, 3290, 7.0], [1590956933.0068853, 3300, 7.0], [1590956933.3031335, 3310, 7.0], [1590956933.5975933, 3320, 7.0], [1590956933.900101, 3330, 7.0], [1590956934.1805062, 3340, 7.0], [1590956934.4942238, 3350, 7.0], [1590956934.7890081, 3360, 7.0], [1590956935.0846984, 3370, 7.0], [1590956935.350063, 3380, 7.0], [1590956935.5943007, 3390, 7.0], [1590956935.8307831, 3400, 7.0], [1590956936.0607655, 3410, 7.0], [1590956936.2852197, 3420, 7.0], [1590956936.5142856, 3430, 7.0], [1590956939.2875195, 3439, 7.0], [1590956939.296294, 3440, 7.0], [1590956940.9110196, 3440, 8.0], [1590956941.2593026, 3450, 8.0], [1590956941.5475194, 3460, 8.0], [1590956941.8721955, 3470, 8.0], [1590956942.1479168, 3480, 8.0], [1590956942.4160805, 3490, 8.0], [1590956942.7167487, 3500, 8.0], [1590956942.9973705, 3510, 8.0], [1590956943.2880666, 3520, 8.0], [1590956943.5800743, 3530, 8.0], [1590956943.897738, 3540, 8.0], [1590956944.175149, 3550, 8.0], [1590956944.4561741, 3560, 8.0], [1590956944.7457454, 3570, 8.0], [1590956945.0405657, 3580, 8.0], [1590956945.327267, 3590, 8.0], [1590956945.5974941, 3600, 8.0], [1590956945.9086285, 3610, 8.0], [1590956946.1927142, 3620, 8.0], [1590956946.4924793, 3630, 8.0], [1590956946.7858636, 3640, 8.0], [1590956947.0723226, 3650, 8.0], [1590956947.3576124, 3660, 8.0], [1590956947.6457644, 3670, 8.0], [1590956947.9501593, 3680, 8.0], [1590956948.2314637, 3690, 8.0], [1590956948.5182486, 3700, 8.0], [1590956948.7992656, 3710, 8.0], [1590956949.1035268, 3720, 8.0], [1590956949.385198, 3730, 8.0], [1590956949.6741545, 3740, 8.0], [1590956949.9665656, 3750, 8.0], [1590956950.2561603, 3760, 8.0], [1590956950.5414717, 3770, 8.0], [1590956950.834882, 3780, 8.0], [1590956951.1375024, 3790, 8.0], [1590956951.4190624, 3800, 8.0], [1590956951.6662107, 3810, 8.0], [1590956951.8983722, 3820, 8.0], [1590956952.121252, 3830, 8.0], [1590956952.3346822, 3840, 8.0], [1590956952.5545, 3850, 8.0], [1590956952.7764068, 3860, 8.0], [1590956955.5537395, 3869, 8.0], [1590956955.5629494, 3870, 8.0], [1590956957.170829, 3870, 9.0], [1590956957.5213706, 3880, 9.0], [1590956957.815752, 3890, 9.0], [1590956958.1478426, 3900, 9.0], [1590956958.4111, 3910, 9.0], [1590956958.6795805, 3920, 9.0], [1590956958.9810448, 3930, 9.0], [1590956959.2721379, 3940, 9.0], [1590956959.557523, 3950, 9.0], [1590956959.8444421, 3960, 9.0], [1590956960.156313, 3970, 9.0], [1590956960.4528136, 3980, 9.0], [1590956960.743098, 3990, 9.0], [1590956961.0332105, 4000, 9.0], [1590956961.3348925, 4010, 9.0], [1590956961.6071458, 4020, 9.0], [1590956961.8971908, 4030, 9.0], [1590956962.1895115, 4040, 9.0], [1590956962.4910388, 4050, 9.0], [1590956962.775675, 4060, 9.0], [1590956963.0596216, 4070, 9.0], [1590956963.3492517, 4080, 9.0], [1590956963.6282365, 4090, 9.0], [1590956963.902082, 4100, 9.0], [1590956964.1853101, 4110, 9.0], [1590956964.4858048, 4120, 9.0], [1590956964.7622576, 4130, 9.0], [1590956965.0382528, 4140, 9.0], [1590956965.3262799, 4150, 9.0], [1590956965.617661, 4160, 9.0], [1590956965.8998754, 4170, 9.0], [1590956966.1881762, 4180, 9.0], [1590956966.4806674, 4190, 9.0], [1590956966.7675207, 4200, 9.0], [1590956967.0648131, 4210, 9.0], [1590956967.358591, 4220, 9.0], [1590956967.6502082, 4230, 9.0], [1590956967.900673, 4240, 9.0], [1590956968.1137788, 4250, 9.0], [1590956968.325924, 4260, 9.0], [1590956968.5550969, 4270, 9.0], [1590956968.7728205, 4280, 9.0], [1590956968.987775, 4290, 9.0], [1590956971.7762046, 4299, 9.0], [1590956971.7963223, 4300, 9.0]]",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=epoch&run=version_0": {
+ "data": "W1sxNTkwOTU2NjgyLjQ1MTMyMTEsIDAsIDAuMF0sIFsxNTkwOTU2NjgyLjc2MDU4NCwgMTAsIDAuMF0sIFsxNTkwOTU2NjgzLjA2OTIwMTcsIDIwLCAwLjBdLCBbMTU5MDk1NjY4My4zOTAyMjI4LCAzMCwgMC4wXSwgWzE1OTA5NTY2ODMuNjkzNjQzNiwgNDAsIDAuMF0sIFsxNTkwOTU2NjgzLjk5NjM1MSwgNTAsIDAuMF0sIFsxNTkwOTU2Njg0LjI5NTg5MywgNjAsIDAuMF0sIFsxNTkwOTU2Njg0LjU4OTIzNTgsIDcwLCAwLjBdLCBbMTU5MDk1NjY4NC45MDM2OTAzLCA4MCwgMC4wXSwgWzE1OTA5NTY2ODUuMjIyNTQzNywgOTAsIDAuMF0sIFsxNTkwOTU2Njg1LjUyMDQ3OCwgMTAwLCAwLjBdLCBbMTU5MDk1NjY4NS44MjMwOTM0LCAxMTAsIDAuMF0sIFsxNTkwOTU2Njg2LjEyMDgwNTMsIDEyMCwgMC4wXSwgWzE1OTA5NTY2ODYuNDE3NjI1NCwgMTMwLCAwLjBdLCBbMTU5MDk1NjY4Ni43MjMxMDg1LCAxNDAsIDAuMF0sIFsxNTkwOTU2Njg3LjAyOTkwOTYsIDE1MCwgMC4wXSwgWzE1OTA5NTY2ODcuMzIyMjI1LCAxNjAsIDAuMF0sIFsxNTkwOTU2Njg3LjYzMzg4NzgsIDE3MCwgMC4wXSwgWzE1OTA5NTY2ODcuOTQ1MTkyMywgMTgwLCAwLjBdLCBbMTU5MDk1NjY4OC4yNjcxNTQ1LCAxOTAsIDAuMF0sIFsxNTkwOTU2Njg4LjU4ODI5NzgsIDIwMCwgMC4wXSwgWzE1OTA5NTY2ODguOTAxNjUwMiwgMjEwLCAwLjBdLCBbMTU5MDk1NjY4OS4yMDk2MjA3LCAyMjAsIDAuMF0sIFsxNTkwOTU2Njg5LjUwNTY2MjIsIDIzMCwgMC4wXSwgWzE1OTA5NTY2ODkuODI1MzAxNiwgMjQwLCAwLjBdLCBbMTU5MDk1NjY5MC4xMjcxMzAzLCAyNTAsIDAuMF0sIFsxNTkwOTU2NjkwLjQzMjMyNSwgMjYwLCAwLjBdLCBbMTU5MDk1NjY5MC43NDcwNzgsIDI3MCwgMC4wXSwgWzE1OTA5NTY2OTEuMDY0MTAxNywgMjgwLCAwLjBdLCBbMTU5MDk1NjY5MS4zNTU2ODEyLCAyOTAsIDAuMF0sIFsxNTkwOTU2NjkxLjY2NzMxNjIsIDMwMCwgMC4wXSwgWzE1OTA5NTY2OTEuOTc0MzU0LCAzMTAsIDAuMF0sIFsxNTkwOTU2NjkyLjI2OTQ5OCwgMzIwLCAwLjBdLCBbMTU5MDk1NjY5Mi41NjI4NjI5LCAzMzAsIDAuMF0sIFsxNTkwOTU2NjkyLjg3MTEyNzgsIDM0MCwgMC4wXSwgWzE1OTA5NTY2OTMuMTcxMjE0NiwgMzUwLCAwLjBdLCBbMTU5MDk1NjY5My40NzM5MDUzLCAzNjAsIDAuMF0sIFsxNTkwOTU2NjkzLjczODA0NjQsIDM3MCwgMC4wXSwgWzE1OTA5NTY2OTMuOTc0OTYzNCwgMzgwLCAwLjBdLCBbMTU5MDk1NjY5NC4yMTIxODIzLCAzOTAsIDAuMF0sIFsxNTkwOTU2Njk0LjQ2MDEyOCwgNDAwLCAwLjBdLCBbMTU5MDk1NjY5NC43MDAyMTEzLCA0MTAsIDAuMF0sIFsxNTkwOTU2Njk0LjkzOTA5MTcsIDQyMCwgMC4wXSwgWzE1OTA5NTY2OTcuNjk4NTU3OSwgNDI5LCAwLjBdXQ==",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ }
+ },
+ "base_uri": "https://localhost:8080/",
+ "height": 821
+ },
+ "outputId": "ea04489a-c5bc-43af-911a-d2b25694f6b1"
+ },
+ "source": [
+ "%load_ext tensorboard\n",
+ "%tensorboard --logdir lightning_logs/"
+ ],
+ "execution_count": 6,
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/javascript": [
+ "\n",
+ " (async () => {\n",
+ " const url = await google.colab.kernel.proxyPort(6006, {\"cache\": 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",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7pZ1d3CGaLZz",
+ "colab_type": "text"
+ },
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "e4so8_e-RYUZ",
+ "colab_type": "text"
+ },
+ "source": [
+ "# **2. Using Lightning's TensorBoard Logger**\n",
+ "The code contains the implementation of Lightning logger to\n",
+ "\n",
+ "\n",
+ "**1. Draw Graphs(Log Scalars)**\n",
+ "\n",
+ "**2. View Commputational Graph**\n",
+ "\n",
+ "**3. View Histograms**\n",
+ "\n",
+ "**4. View Activations**\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "kAYqu14qeLz-",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "'''\n",
+ "Neural Network architecture inspired from: \n",
+ "https://towardsdatascience.com/convolutional-neural-network-for-image-classification-with-implementation-on-python-using-pytorch-7b88342c9ca9\n",
+ "'''\n",
+ "\n",
+ "#importing necessary libraries\n",
+ "import os\n",
+ "import torch\n",
+ "from torch.nn import functional as F\n",
+ "from torch.utils.data import DataLoader,random_split\n",
+ "from torchvision.datasets import MNIST\n",
+ "from torchvision import transforms\n",
+ "import pytorch_lightning as pl\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "import torchvision\n",
+ "\n",
+ "\n",
+ "#defining the model\n",
+ "class smallAndSmartModelWithLogger(pl.LightningModule):\n",
+ "\n",
+ " def __init__(self):\n",
+ " # this is the init function where we will defnine the architecture\n",
+ " super(smallAndSmartModelWithLogger, self).__init__()\n",
+ " \n",
+ " self.layer1 = torch.nn.Sequential(\n",
+ " torch.nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1),\n",
+ " torch.nn.ReLU(),\n",
+ " torch.nn.MaxPool2d(kernel_size=2, stride=2),\n",
+ " torch.nn.Dropout(p=0.5))\n",
+ " self.layer2 = torch.nn.Sequential(\n",
+ " torch.nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),\n",
+ " torch.nn.ReLU(),\n",
+ " torch.nn.MaxPool2d(kernel_size=2, stride=2),\n",
+ " torch.nn.Dropout(p=0.5))\n",
+ " self.layer3 = torch.nn.Sequential(\n",
+ " torch.nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),\n",
+ " torch.nn.ReLU(),\n",
+ " torch.nn.MaxPool2d(kernel_size=2, stride=2, padding=1),\n",
+ " torch.nn.Dropout(p=0.5))\n",
+ "\n",
+ " self.fc1 = torch.nn.Linear(4 * 4 * 128, 625, bias=True)\n",
+ " torch.nn.init.xavier_uniform(self.fc1.weight)\n",
+ " self.layer4 = torch.nn.Sequential(\n",
+ " self.fc1,\n",
+ " torch.nn.ReLU(),\n",
+ " torch.nn.Dropout(p=0.5))\n",
+ " self.dense1_bn = torch.nn.BatchNorm1d(625)\n",
+ " self.fc2 = torch.nn.Linear(625, 10, bias=True)\n",
+ " self.dense2_bn = torch.nn.BatchNorm1d(10)\n",
+ " torch.nn.init.xavier_uniform_(self.fc2.weight) # initialize parameters\n",
+ "\n",
+ " # reference dummy image for logging graph \n",
+ " self.reference_image=torch.rand((1,1,28,28))\n",
+ "\n",
+ " def prepare_data(self):\n",
+ " \n",
+ " # This contains the manupulation on data that needs to be done only once such as downloading it\n",
+ "\n",
+ " #download the MNIST dataset\n",
+ " MNIST(os.getcwd(), train=True, download =True)\n",
+ " MNIST(os.getcwd(), train=False, download =True)\n",
+ " \n",
+ " # See here I have set download to false as it is already downloaded\n",
+ " mnist_train=MNIST(os.getcwd(), train=True, download =False,transform=transforms.ToTensor())\n",
+ "\n",
+ " #dividing into validation and training set\n",
+ " self.train_set, self.val_set= random_split(mnist_train,[55000,5000])\n",
+ " \n",
+ " def train_dataloader(self):\n",
+ " # REQUIRED\n",
+ " # This is an essential function. Needs to be included in the code\n",
+ " \n",
+ " return DataLoader(self.train_set,batch_size=128,num_workers=32)\n",
+ " \n",
+ " def val_dataloader(self):\n",
+ " # OPTIONAL\n",
+ " #loading validation dataset\n",
+ " return DataLoader(self.val_set, batch_size=128,num_workers=32)\n",
+ "\n",
+ " def test_dataloader(self):\n",
+ " # OPTIONAL\n",
+ " # loading test dataset\n",
+ " return DataLoader(MNIST(os.getcwd(), train=False, download=False, transform=transforms.ToTensor()), batch_size=128,num_workers=32)\n",
+ "\n",
+ "\n",
+ " def forward(self,x):\n",
+ " #evaluating the batch data as it moves forward in the netowrk\n",
+ " out = self.layer1(x)\n",
+ " out = self.layer2(out)\n",
+ " out = self.layer3(out)\n",
+ " out = out.view(out.size(0), -1) # Flatten them for FC\n",
+ " # out = self.fc1(out)\n",
+ " out = self.dense1_bn(self.fc1(out))\n",
+ " # out = self.fc2(out)\n",
+ " out = self.dense2_bn(self.fc2(out))\n",
+ " return F.softmax(out,dim=1)\n",
+ "\n",
+ " def validation_step(self, batch, batch_nb):\n",
+ " # OPTIONAL\n",
+ " # The code that runs as we forward pass a validation batch\n",
+ " x, y = batch\n",
+ " y_hat = self(x)\n",
+ " correct=y_hat.argmax(dim=1).eq(y).sum().item()\n",
+ " total=len(y)\n",
+ " return {'val_loss': F.cross_entropy(y_hat, y),\"correct\": correct,\"total\": total}\n",
+ "\n",
+ " def validation_epoch_end(self, outputs):\n",
+ " # OPTIONAL\n",
+ " # The code that runs as a validation epoch finished\n",
+ " # Used for metric evaluation\n",
+ " avg_loss = torch.stack([x['val_loss'] for x in outputs]).mean()\n",
+ " correct=sum([x[\"correct\"] for x in outputs])\n",
+ " total=sum([x[\"total\"] for x in outputs])\n",
+ " print(\"Loss val= {}\".format(avg_loss))\n",
+ " print(\"Number of Correctly identified Validation Images {} from aset of {}. \\nAccuracy= {} \".format(correct,total,correct/total))\n",
+ " \n",
+ " # Adding logs to TensorBoard\n",
+ " self.logger.experiment.add_scalar(\"Loss/Val\",avg_loss,self.current_epoch)\n",
+ " self.logger.experiment.add_scalar(\"Accuracy/Val\",correct/total,self.current_epoch)\n",
+ " \n",
+ " return {'val_loss': avg_loss}\n",
+ "\n",
+ " def test_step(self, batch, batch_nb):\n",
+ " # OPTIONAL\n",
+ " # The code that runs as we forward pass a test batch\n",
+ "\n",
+ " x, y = batch\n",
+ " y_hat = self(x)\n",
+ " correct=y_hat.argmax(dim=1).eq(y).sum().item()\n",
+ " total=len(y)\n",
+ " return {'test_loss': F.cross_entropy(y_hat, y),\n",
+ " \"correct\": correct,\n",
+ " \"total\": total}\n",
+ "\n",
+ "\n",
+ "\n",
+ " \n",
+ " def test_epoch_end(self, outputs):\n",
+ " # OPTIONAL\n",
+ " # The code that runs as a validation epoch finished\n",
+ " # Used for metric evaluation\n",
+ " correct=sum([x[\"correct\"] for x in outputs])\n",
+ " total=sum([x[\"total\"] for x in outputs])\n",
+ " print(\"Number of Correctly identified Testing Images {} from aset of {}. \\nAccuracy= {} \".format(testCorrect,testTotal,testCorrect/testTotal))\n",
+ " avg_loss = torch.stack([x['test_loss'] for x in outputs]).mean()\n",
+ " print(\"Loss= {}\".format(avg_loss))\n",
+ "\n",
+ " # Logging Data to TensorBoard\n",
+ " self.logger.experiment.add_scalar(\"Loss/Test\",avg_loss,self.current_epoch)\n",
+ " self.logger.experiment.add_scalar(\"Accuracy/Test\",correct/total,self.current_epoch)\n",
+ "\n",
+ " return {'test_loss': avg_loss}\n",
+ "\n",
+ " def configure_optimizers(self):\n",
+ " # REQUIRED\n",
+ " # Can return multiple optimizers and learning_rate schedulers\n",
+ " return torch.optim.Adam(self.parameters(), lr=0.0005)\n",
+ " \n",
+ " def custom_histogram_adder(self):\n",
+ " # A custom defined function that adds Histogram to TensorBoard\n",
+ "\n",
+ " # Iterating over all parameters and logging them\n",
+ " for name,params in self.named_parameters():\n",
+ " self.logger.experiment.add_histogram(name,params,self.current_epoch)\n",
+ "\n",
+ " def training_step(self,batch,batch_idx):\n",
+ " #REQUIRED\n",
+ " # print(batch)\n",
+ " if(batch_idx==0):\n",
+ " self.reference_image=(batch[0][0]).unsqueeze(0)\n",
+ " # self.reference_image.resize((1,1,28,28))\n",
+ " print(self.reference_image.shape)\n",
+ "\n",
+ " #extracting input and output from the batch\n",
+ " x,labels=batch\n",
+ " pred=self.forward(x)\n",
+ " \n",
+ " correct=pred.argmax(dim=1).eq(labels).sum().item()\n",
+ " total=len(labels)\n",
+ " #calculating the loss\n",
+ " train_loss = F.cross_entropy(pred, labels)\n",
+ "\n",
+ " logs={\"train_loss\": train_loss}\n",
+ "\n",
+ " output={\n",
+ " #REQUIRED: It ie required for us to return \"loss\"\n",
+ " \"loss\": train_loss,\n",
+ " #optional for logging purposes\n",
+ " \"log\": logs,\n",
+ " \"correct\": correct,\n",
+ " \"total\": total\n",
+ " }\n",
+ "\n",
+ " return output\n",
+ "\n",
+ " def showActivations(self,x):\n",
+ " # Evaluating the batch data as it moves forward in the netowrk\n",
+ " # Custom made function for this model to log activations\n",
+ " print(x.shape)\n",
+ " plt.imshow(torch.Tensor.cpu(x[0][0]))\n",
+ "\n",
+ " # Logging the input image\n",
+ " self.logger.experiment.add_image(\"input\",torch.Tensor.cpu(x[0][0]),self.current_epoch,dataformats=\"HW\")\n",
+ " plt.show()\n",
+ " plt.clf()\n",
+ " out = self.layer1(x)\n",
+ " outer=(torch.Tensor.cpu(out).detach())\n",
+ " plt.figure(figsize=(20,5))\n",
+ " b=np.array([]).reshape(0,outer.shape[2])\n",
+ " c=np.array([]).reshape(4*outer.shape[2],0)\n",
+ " \n",
+ " # Plotting for layer 1\n",
+ " i=0\n",
+ " j=0\n",
+ " while(i<32):\n",
+ " img=outer[0][i]\n",
+ " b=np.concatenate((img,b),axis=0)\n",
+ " j+=1\n",
+ " if(j==4):\n",
+ " c=np.concatenate((c,b),axis=1)\n",
+ " b=np.array([]).reshape(0,outer.shape[2])\n",
+ " j=0\n",
+ " \n",
+ " i+=1\n",
+ " \n",
+ "\n",
+ " plt.imshow(c)\n",
+ " plt.show()\n",
+ " plt.clf()\n",
+ " self.logger.experiment.add_image(\"layer 1\",c,self.current_epoch,dataformats=\"HW\")\n",
+ " \n",
+ " out = self.layer2(out)\n",
+ " outer=(torch.Tensor.cpu(out).detach())\n",
+ " plt.figure(figsize=(10,10))\n",
+ " b=np.array([]).reshape(0,outer.shape[2])\n",
+ " c=np.array([]).reshape(8*outer.shape[2],0)\n",
+ " \n",
+ " # Plotting for layer2\n",
+ " i=0\n",
+ " j=0\n",
+ " while(i<64):\n",
+ " img=outer[0][i]\n",
+ " b=np.concatenate((img,b),axis=0)\n",
+ " j+=1\n",
+ " if(j==8):\n",
+ " c=np.concatenate((c,b),axis=1)\n",
+ " b=np.array([]).reshape(0,outer.shape[2])\n",
+ " j=0\n",
+ " \n",
+ " i+=1\n",
+ "\n",
+ " self.logger.experiment.add_image(\"layer 2\",c,self.current_epoch,dataformats=\"HW\")\n",
+ " plt.imshow(c)\n",
+ " plt.show()\n",
+ " plt.clf()\n",
+ " \n",
+ " # print(out.shape)\n",
+ " out = self.layer3(out)\n",
+ " outer=(torch.Tensor.cpu(out).detach())\n",
+ " plt.figure(figsize=(20,5))\n",
+ " b=np.array([]).reshape(0,outer.shape[2])\n",
+ " c=np.array([]).reshape(8*outer.shape[2],0)\n",
+ " \n",
+ " # Plotting for layer3\n",
+ " j=0\n",
+ " i=0\n",
+ " while(i<128):\n",
+ " img=outer[0][i]\n",
+ " b=np.concatenate((img,b),axis=0)\n",
+ " j+=1\n",
+ " if(j==8):\n",
+ " c=np.concatenate((c,b),axis=1)\n",
+ " b=np.array([]).reshape(0,outer.shape[2])\n",
+ " j=0\n",
+ " \n",
+ " i+=1\n",
+ " # print(c.shape)\n",
+ "\n",
+ " self.logger.experiment.add_image(\"layer 3\",c,self.current_epoch,dataformats=\"HW\")\n",
+ " plt.imshow(c)\n",
+ " plt.show()\n",
+ " \n",
+ " def training_epoch_end(self,outputs):\n",
+ "\n",
+ " # Logging activations\n",
+ " self.showActivations(self.reference_image)\n",
+ " \n",
+ " # Logging graph\n",
+ " if(self.current_epoch==1):\n",
+ " sampleImg=torch.rand((1,1,28,28))\n",
+ " self.logger.experiment.add_graph(smallAndSmartModel(),sampleImg)\n",
+ "\n",
+ " avg_loss = torch.stack([x['loss'] for x in outputs]).mean()\n",
+ " print(\"Loss train= {}\".format(avg_loss))\n",
+ " correct=sum([x[\"correct\"] for x in outputs])\n",
+ " total=sum([x[\"total\"] for x in outputs])\n",
+ "\n",
+ " # Loggig scalars\n",
+ " self.logger.experiment.add_scalar(\"Loss/Train\",avg_loss,self.current_epoch)\n",
+ " self.logger.experiment.add_scalar(\"Accuracy/Train\",correct/total,self.current_epoch)\n",
+ " \n",
+ " # Logging histograms\n",
+ " self.custom_histogram_adder()\n",
+ "\n",
+ " print(\"Number of Correctly identified Training Set Images {} from a set of {}. \\nAccuracy= {} \".format(correct,total,correct/total))\n",
+ " return {'loss': avg_loss}"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "vVXlYjjydZ6b",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Defining Model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "BifQyqxr9pjb",
+ "colab_type": "code",
+ "outputId": "22ed7466-aee5-424d-d267-5be6166d815d",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 86
+ }
+ },
+ "source": [
+ "# Using the Lightning trainer and specifing the requied parameters as arguments\n",
+ "from pytorch_lightning.loggers import TensorBoardLogger\n",
+ "logger = TensorBoardLogger('tb_logs', name='testing_for_activations')\n",
+ "\n",
+ "myTrainerWithLogger=pl.Trainer(gpus=1,max_nb_epochs=10,checkpoint_callback=False,logger=logger)\n",
+ "\n",
+ "myModelWithLogger=smallAndSmartModelWithLogger()"
+ ],
+ "execution_count": 16,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "text": [
+ "GPU available: True, used: True\n",
+ "No environment variable for node rank defined. Set as 0.\n",
+ "CUDA_VISIBLE_DEVICES: [0]\n",
+ "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:43: UserWarning: nn.init.xavier_uniform is now deprecated in favor of nn.init.xavier_uniform_.\n"
+ ],
+ "name": "stderr"
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4p8-iXtwdkeL",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Train"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "qGGulxsvxQuS",
+ "colab_type": "code",
+ "outputId": "dea3815a-b8f0-4941-e692-05a42a91c1ac",
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000,
+ "referenced_widgets": [
+ "f6b418ac9a784cf39f537e93b9712b0f",
+ "bbb09b3b11454d3d902c981c1874e227",
+ "727f101faa1147dca0bab10a1b867754",
+ "4ffae6daab15469181ad62dcf4b6755f",
+ "b067a85aa69c4acc8f38077444b0b62b",
+ "702e0c51876d491d84eeb7b93e021416",
+ "695279db98734f72b5a8187f484ed4eb",
+ "b801e6dda709479fb28a11ccff2e9fd2",
+ "b0caff9a0db3449da90c4696ff0c6dc0",
+ "23f2a1c6eadb415c9253c74dbefd701e",
+ "8d61e6981653498dbfe5cd863d1d4abf",
+ "bbbf9723a0214db3a55f7c643650a59e",
+ "e0543446503d4548bf7b49a1ba1c8811",
+ "a0b0e0209c5d4148bb50ef2defc83cef",
+ "c863ca4c52dd45bbb4b8d04ac7bbf13e",
+ "69c58acf0f1b477fb9486b214ed10ef8",
+ "cfe1eb2121444a0a84266c3d75fcd963",
+ "3756191380f34b33a371f7956c88dfe6",
+ "6e0b815542c94c2a8d3f7c5272ae87b2",
+ "fe1bd530a464467d915d23b7bf82dbe7",
+ "2bb4b7c9b0104bfbb4699c0ae914fc53",
+ "aa0cc4c7dce948bdaa0857e028eadbc6",
+ "c62dcf23227f4cbcbaa2ea8297455c76",
+ "7329aace66ce4a5290e0b8acb9273aba",
+ "86169559e322466f9868a541c1f6724c",
+ "448a75c288ab40e59b8e9efbf083ba06",
+ "478a909bdccb44949182a485aa4c7aac",
+ "83cc7e5988fa4699843a873408375ec7",
+ "ccec043d8c8c47dd826612978a1d8fec",
+ "37a1ca16333841039c6b1b3b260aebb9",
+ "3813ceefeb3841d9887c82ba0a3e659f",
+ "d1c400398bc74762b2f7882d1cc57702",
+ "40180487115c473a872d7c896bacb3ff",
+ "f00cd38365174318af3c49ba42d67bc5",
+ "704f7b19739a4c05ae46a0d6ffa7a865",
+ "33306403471c4538abdab5bfa05b4610",
+ "ffcb6cca375c4c8b9dfd9190671ff348",
+ "149e414e1c9441019eb052a4c36d19a9",
+ "fb7cab66a2474ab6bcd7946a2fb60f42",
+ "5e54c83fcc3a4efba43349a1b08061fd",
+ "02ec7b2afb7d4456bbfed4efe0ed3df4",
+ "7d8abb71feeb4a64a7e21e645d5da2f4",
+ "26cf343f24e44198808769ff76958275",
+ "e755ff286a074c42a236062a763ed59c",
+ "d5a5178a43c1418092f7dd604b8f1305",
+ "67161adc5d514547a036374dee270d7d",
+ "59a1f9c386db47e7b4d263adaa4a720b",
+ "6a9b117e0050412f85013848881988de"
+ ]
+ }
+ },
+ "source": [
+ "myTrainerWithLogger.fit(myModelWithLogger)"
+ ],
+ "execution_count": 17,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "text": [
+ "\n",
+ " | Name | Type | Params\n",
+ "--------------------------------------\n",
+ "0 | layer1 | Sequential | 320 \n",
+ "1 | layer1.0 | Conv2d | 320 \n",
+ "2 | layer1.1 | ReLU | 0 \n",
+ "3 | layer1.2 | MaxPool2d | 0 \n",
+ "4 | layer1.3 | Dropout | 0 \n",
+ "5 | layer2 | Sequential | 18 K \n",
+ "6 | layer2.0 | Conv2d | 18 K \n",
+ "7 | layer2.1 | ReLU | 0 \n",
+ "8 | layer2.2 | MaxPool2d | 0 \n",
+ "9 | layer2.3 | Dropout | 0 \n",
+ "10 | layer3 | Sequential | 73 K \n",
+ "11 | layer3.0 | Conv2d | 73 K \n",
+ "12 | layer3.1 | ReLU | 0 \n",
+ "13 | layer3.2 | MaxPool2d | 0 \n",
+ "14 | layer3.3 | Dropout | 0 \n",
+ "15 | fc1 | Linear | 1 M \n",
+ "16 | layer4 | Sequential | 1 M \n",
+ "17 | layer4.1 | ReLU | 0 \n",
+ "18 | layer4.2 | Dropout | 0 \n",
+ "19 | dense1_bn | BatchNorm1d | 1 K \n",
+ "20 | fc2 | Linear | 6 K \n",
+ "21 | dense2_bn | BatchNorm1d | 20 \n"
+ ],
+ "name": "stderr"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "f6b418ac9a784cf39f537e93b9712b0f",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validation sanity check', layout=Layout…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 2.3020882606506348\n",
+ "Number of Correctly identified Validation Images 17 from aset of 256. \n",
+ "Accuracy= 0.06640625 \n",
+ "\r"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "b0caff9a0db3449da90c4696ff0c6dc0",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Training', layout=Layout(flex='2'), max…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "torch.Size([1, 1, 28, 28])\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "cfe1eb2121444a0a84266c3d75fcd963",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.7506769895553589\n",
+ "Number of Correctly identified Validation Images 4826 from aset of 5000. \n",
+ "Accuracy= 0.9652 \n",
+ "torch.Size([1, 1, 28, 28])\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss train= 1.8867101669311523\n",
+ "Number of Correctly identified Training Set Images 45009 from a set of 55000. \n",
+ "Accuracy= 0.8183454545454546 \n",
+ "torch.Size([1, 1, 28, 28])\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "86169559e322466f9868a541c1f6724c",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.6459505558013916\n",
+ "Number of Correctly identified Validation Images 4896 from aset of 5000. \n",
+ "Accuracy= 0.9792 \n",
+ "torch.Size([1, 1, 28, 28])\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:43: UserWarning: nn.init.xavier_uniform is now deprecated in favor of nn.init.xavier_uniform_.\n"
+ ],
+ "name": "stderr"
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss train= 1.7053251266479492\n",
+ "Number of Correctly identified Training Set Images 52016 from a set of 55000. \n",
+ "Accuracy= 0.9457454545454546 \n",
+ "torch.Size([1, 1, 28, 28])\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "40180487115c473a872d7c896bacb3ff",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss val= 1.5884579420089722\n",
+ "Number of Correctly identified Validation Images 4912 from aset of 5000. \n",
+ "Accuracy= 0.9824 \n",
+ "torch.Size([1, 1, 28, 28])\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": [],
+ "needs_background": "light"
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Loss train= 1.6423791646957397\n",
+ "Number of Correctly identified Training Set Images 52775 from a set of 55000. \n",
+ "Accuracy= 0.9595454545454546 \n",
+ "torch.Size([1, 1, 28, 28])\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "02ec7b2afb7d4456bbfed4efe0ed3df4",
+ "version_minor": 0,
+ "version_major": 2
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=1.0, bar_style='info', description='Validating', layout=Layout(flex='2'), m…"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "Detected KeyboardInterrupt, attempting graceful shutdown...\n"
+ ],
+ "name": "stderr"
+ },
+ {
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "execute_result",
+ "data": {
+ "text/plain": [
+ "1"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "execution_count": 17
+ }
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "n-JXnWy0oQi6",
+ "colab_type": "code",
+ "outputId": "3c5e11aa-f17d-421a-edba-f050053c0573",
+ "colab": {
+ "resources": {
+ "https://localhost:6006/": {
+ "data": "<!doctype html><!--
@license
Copyright 2016 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 lang="en"><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>
  html,
  body {
    margin: 0;
    padding: 0;
    height: 100%;
    font-family: Roboto, sans-serif;
  }
</style>






<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>





















<dom-module id="paper-ripple">

  <template>
    <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>
  </template>
</dom-module>











<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>




<dom-module id="paper-material-styles">
  <template>
    <style>
      :host, 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;
        };
      }
      :host(.paper-material), .paper-material {
        @apply --paper-material;
      }
      :host(.paper-material[elevation="1"]), .paper-material[elevation="1"] {
        @apply --paper-material-elevation-1;
      }
      :host(.paper-material[elevation="2"]), .paper-material[elevation="2"] {
        @apply --paper-material-elevation-2;
      }
      :host(.paper-material[elevation="3"]), .paper-material[elevation="3"] {
        @apply --paper-material-elevation-3;
      }
      :host(.paper-material[elevation="4"]), .paper-material[elevation="4"] {
        @apply --paper-material-elevation-4;
      }
      :host(.paper-material[elevation="5"]), .paper-material[elevation="5"] {
        @apply --paper-material-elevation-5;
      }
    </style>
  </template>
</dom-module>




<dom-module id="paper-button">
  <template strip-whitespace>
    <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: #eaeaea;
        color: #a8a8a8;
        cursor: auto;
        pointer-events: none;

        @apply --paper-button-disabled;
      }

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

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

    <slot></slot>
  </template>

  
</dom-module>





<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>




<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.html 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>
































<dom-module id="paper-checkbox">
  <template strip-whitespace>
    <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;
      }

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

      @-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>
  </template>

  
</dom-module>












<dom-module id="iron-icon">
  <template>
    <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>
  </template>

  

</dom-module>









<dom-module id="iron-a11y-announcer">
  <template>
    <style>
      :host {
        display: inline-block;
        position: fixed;
        clip: rect(0px,0px,0px,0px);
      }
    </style>
    <div aria-live$="[[mode]]">[[_text]]</div>
  </template>

  
</dom-module>





<dom-module id="iron-input">
  <template>
    <style>
      :host {
        display: inline-block;
      }
    </style>
    <slot id="content"></slot>
  </template>
  
</dom-module>












<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>








<dom-module id="paper-input-char-counter">
  <template>
    <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>
  </template>
</dom-module>










<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: bottom;

        @apply --paper-font-subhead;
      };
    }
  </style>
</custom-style>

<dom-module id="paper-input-container">
  <template>
    <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.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>
  </template>
</dom-module>










<dom-module id="paper-input-error">
  <template>
    <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;
      };
    </style>

    <slot></slot>
  </template>
</dom-module>






<dom-module id="paper-input">
  <template>
    <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>

      <span id="template-placeholder"></span>

      <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>
  </template>

  
  <template id="v0">
    <input is="iron-input" slot="input" class="input-element" id$="[[_inputId]]" aria-labelledby$="[[_ariaLabelledBy]]" aria-describedby$="[[_ariaDescribedBy]]" disabled$="[[disabled]]" title$="[[title]]" bind-value="{{value}}" invalid="{{invalid}}" prevent-invalid-input="[[preventInvalidInput]]" allowed-pattern="[[allowedPattern]]" validator="[[validator]]" 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]]">
  </template>

  <template id="v1">
    
    <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]]">
    </iron-input>
  </template>

</dom-module>























<dom-module id="iron-overlay-backdrop">

  <template>
    <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>
  </template>

</dom-module>
































<dom-module id="iron-dropdown">
  <template>
    <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>
  </template>

  
</dom-module>





























<dom-module id="paper-menu-button">
  <template>
    <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">
      <div slot="dropdown-content" class="dropdown-content">
        <slot id="content" name="dropdown-content"></slot>
      </div>
    </iron-dropdown>
  </template>

  
</dom-module>










<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>



<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;
      }

      :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>




<dom-module id="paper-dropdown-menu">
  <template>
    <style include="paper-dropdown-menu-shared-styles"></style>

    
    <span role="button"></span>
    <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]]">
      
      <div class="dropdown-trigger" slot="dropdown-trigger">
        <paper-ripple></paper-ripple>
        
        <paper-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]]">
          
          <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>
  </template>

  
</dom-module>























<dom-module id="paper-listbox">
  <template>
    <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>
  </template>

  
</dom-module>

















<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>




<dom-module id="paper-item">
  <template>
    <style include="paper-item-shared-styles">
      :host {
        @apply --layout-horizontal;
        @apply --layout-center;
        @apply --paper-font-subhead;

        @apply --paper-item;
      }
    </style>
    <slot></slot>
  </template>

  
</dom-module>


















<dom-module id="tf-backend">
  
</dom-module>




















<dom-module id="tf-storage">
  
</dom-module>



<dom-module id="tf-tag-filterer">
  <template>
    <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>
  </template>
  
</dom-module>






<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>


<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>


<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>

<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>









<style is="custom-style">
  :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-graph-faded: #e0d4b3;
  }
</style>


<dom-module id="dashboard-style">
  <template>
    <style include="iron-flex"></style>
    <style>
      :host {
        --sidebar-vertical-padding: 15px;
        --sidebar-left-padding: 30px;
      }

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

      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 rgba(0, 0, 0, 0.12);
        padding: var(--sidebar-vertical-padding) 0
          var(--sidebar-vertical-padding) var(--sidebar-left-padding);
        position: relative;
      }

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

      .sidebar-section:last-of-type {
        flex-grow: 1;
        display: flex;
      }

      .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(--paper-grey-800);
        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;
      }
    </style>
  </template>
</dom-module>





<dom-module id="scrollbar-style">
  <template>
    <style>
      .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;
      }
    </style>
  </template>
</dom-module>




<dom-module id="tf-dashboard-layout">
  <template>
    <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 {
        display: flex;
        flex-direction: row;
        height: 100%;
      }

      #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']) {
        height: 100%;
        overflow-x: hidden;
        overflow-y: auto;
        width: 100%;
        will-change: transform;
      }

      .tf-graph-dashboard #center {
        background: #fff;
      }
    </style>
  </template>
  
</dom-module>





<dom-module id="tf-option-selector">
  <template>
    <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(--paper-grey-800);
        display: block;
        font-size: 14px;
        font-weight: normal;
        margin: 0 0 5px;
        pointer-events: none;
      }
    </style>
  </template>
  
</dom-module>









<dom-module id="iron-collapse">

  <template>

    <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>

  </template>

</dom-module>



















<dom-module id="tf-category-paginated-view">
  <template>
    <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>
      
      <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: white;
        border: none;
        cursor: pointer;
        width: 100%;
        font-size: 15px;
        line-height: 1;
        box-shadow: 0 1px 5px rgba(0, 0, 0, 0.2);
        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: white;
        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;
      }

      #page-input {
        display: inline-block;
        width: var(--tf-category-paginated-view-page-input-width, 100%);
      }
    </style>
  </template>
  
</dom-module>

















<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>



<dom-module id="paper-dialog">
  <template>
    <style include="paper-dialog-shared-styles"></style>
    <slot></slot>
  </template>
</dom-module>











<dom-module id="tf-color-scale">
  
  
</dom-module>




<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" /></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" /></g>
<g id="accessible"><circle cx="12" cy="4" r="2" /><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" /></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" /></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" /></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" /></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" /></g>
<g id="add"><path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="arrow-drop-down"><path d="M7 10l5 5 5-5z" /></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" /></g>
<g id="arrow-drop-up"><path d="M7 14l5-5 5 5z" /></g>
<g id="arrow-forward"><path d="M12 4l-1.41 1.41L16.17 11H4v2h12.17l-5.58 5.59L12 20l8-8z" /></g>
<g id="arrow-upward"><path d="M4 12l1.41 1.41L11 7.83V20h2V7.83l5.58 5.59L20 12l-8-8-8 8z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="change-history"><path d="M12 7.77L18.39 18H5.61L12 7.77M12 4L2 20h20L12 4z" /></g>
<g id="check"><path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z" /></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" /></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" /></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" /></g>
<g id="chevron-left"><path d="M15.41 7.41L14 6l-6 6 6 6 1.41-1.41L10.83 12z" /></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="compare-arrows"><path d="M9.01 14H2v2h7.01v3L13 15l-3.99-4v3zm5.98-1v-3H22V8h-7.01V5L11 9l3.99 4z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="dashboard"><path d="M3 13h8V3H3v10zm0 8h8v-6H3v6zm10 0h8V11h-8v10zm0-18v6h8V3h-8z" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="done"><path d="M9 16.2L4.8 12l-1.4 1.4L9 19 21 7l-1.4-1.4L9 16.2z" /></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" /></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" /></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" /></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" /></g>
<g id="eject"><path d="M5 17h14v2H5zm7-12L5.33 15h13.34z" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="expand-less"><path d="M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z" /></g>
<g id="expand-more"><path d="M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="file-download"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z" /></g>
<g id="file-upload"><path d="M9 16h6v-6h4l-7-7-7 7h4zm-4 2h14v2H5z" /></g>
<g id="filter-list"><path d="M10 18h4v-2h-4v2zM3 6v2h18V6H3zm3 7h12v-2H6v2z" /></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" /></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" /></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" /></g>
<g id="first-page"><path d="M18.41 16.59L13.82 12l4.59-4.59L17 6l-6 6 6 6zM6 6h2v12H6z" /></g>
<g id="flag"><path d="M14.4 6L14 4H5v17h2v-7h5.6l.4 2h7V6z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="forward"><path d="M12 8V4l8 8-8 8v-4H4V8z" /></g>
<g id="fullscreen"><path d="M7 14H5v5h5v-2H7v-3zm-2-4h2V7h3V5H5v5zm12 7h-3v2h5v-5h-2v3zM14 5v2h3v3h2V5h-5z" /></g>
<g id="fullscreen-exit"><path d="M5 16h3v3h2v-5H5v2zm3-8H5v2h5V5H8v3zm6 11h2v-3h3v-2h-5v5zm2-11V5h-2v5h5V8h-3z" /></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" /></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" /></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" /></g>
<g id="get-app"><path d="M19 9h-4V3H9v6H5l7 7 7-7zM5 18v2h14v-2H5z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="home"><path d="M10 20v-6h4v6h5v-8h3L12 3 2 12h3v8z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="last-page"><path d="M5.59 7.41L10.18 12l-4.59 4.59L7 18l6-6-6-6zM16 6h2v12h-2z" /></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" /></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" /></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" /></g>
<g id="line-weight"><path d="M3 17h18v-2H3v2zm0 3h18v-1H3v1zm0-7h18v-3H3v3zm0-9v4h18V4H3z" /></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" /></g>
<g id="list"><path d="M3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm4 4h14v-2H7v2zm0 4h14v-2H7v2zM7 7v2h14V7H7z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="menu"><path d="M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="pets"><circle cx="4.5" cy="9.5" r="2.5" /><circle cx="9" cy="5.5" r="2.5" /><circle cx="15" cy="5.5" r="2.5" /><circle cx="19.5" cy="9.5" r="2.5" /><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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="record-voice-over"><circle cx="9" cy="9" r="4" /><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" /></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" /></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" /></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" /></g>
<g id="remove"><path d="M19 13H5v-2h14v2z" /></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" /></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" /></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" /></g>
<g id="reorder"><path d="M3 15h18v-2H3v2zm0 4h18v-2H3v2zm0-8h18V9H3v2zm0-6v2h18V5H3z" /></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" /></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" /></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" /></g>
<g id="report-problem"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="send"><path d="M2.01 21L23 12 2.01 3 2 10l15 2-15 2z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="sort"><path d="M3 18h6v-2H3v2zM3 6v2h18V6H3zm0 7h12v-2H3v2z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="store"><path d="M20 4H4v2h16V4zm1 10v-2l-1-5H4l-1 5v2h1v6h10v-6h4v6h2v-6h1zm-9 4H6v-4h6v4z" /></g>
<g id="subdirectory-arrow-left"><path d="M11 9l1.42 1.42L8.83 14H18V4h2v12H8.83l3.59 3.58L11 21l-6-6 6-6z" /></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" /></g>
<g id="subject"><path d="M14 17H4v2h10v-2zm6-8H4v2h16V9zM4 15h16v-2H4v2zM4 5v2h16V5H4z" /></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" /></g>
<g id="swap-horiz"><path d="M6.99 11L3 15l3.99 4v-3H14v-2H6.99v-3zM21 9l-3.99-4v3H10v2h7.01v3L21 9z" /></g>
<g id="swap-vert"><path d="M16 17.01V10h-2v7.01h-3L15 21l4-3.99h-3zM9 3L5 6.99h3V14h2V6.99h3L9 3z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="toc"><path d="M3 9h14V7H3v2zm0 4h14v-2H3v2zm0 4h14v-2H3v2zm16 0h2v-2h-2v2zm0-10v2h2V7h-2zm0 6h2v-2h-2v2z" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="trending-flat"><path d="M22 12l-4-4v3H3v2h15v3z" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
<g id="view-array"><path d="M4 18h3V5H4v13zM18 5v13h3V5h-3zM8 18h9V5H8v13z" /></g>
<g id="view-carousel"><path d="M7 19h10V4H7v15zm-5-2h4V6H2v11zM18 6v11h4V6h-4z" /></g>
<g id="view-column"><path d="M10 18h5V5h-5v13zm-6 0h5V5H4v13zM16 5v13h5V5h-5z" /></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" /></g>
<g id="view-headline"><path d="M4 15h16v-2H4v2zm0 4h16v-2H4v2zm0-8h16V9H4v2zm0-6v2h16V5H4z" /></g>
<g id="view-list"><path d="M4 14h4v-4H4v4zm0 5h4v-4H4v4zM4 9h4V5H4v4zm5 5h12v-4H9v4zm0 5h12v-4H9v4zM9 5v4h12V5H9z" /></g>
<g id="view-module"><path d="M4 11h5V5H4v6zm0 7h5v-6H4v6zm6 0h5v-6h-5v6zm6 0h5v-6h-5v6zm-6-7h5V5h-5v6zm6-6v6h5V5h-5z" /></g>
<g id="view-quilt"><path d="M10 18h5v-6h-5v6zm-6 0h5V5H4v13zm12 0h5v-6h-5v6zM10 5v6h11V5H10z" /></g>
<g id="view-stream"><path d="M4 18h17v-6H4v6zM4 5v6h17V5H4z" /></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" /></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" /></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" /></g>
<g id="warning"><path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z" /></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" /></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" /></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" /></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" /></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" /></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" /></g>
</defs></svg>
</iron-iconset-svg>









<dom-module id="paper-icon-button">
  <template strip-whitespace>
    <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>
  </template>

  
</dom-module>








<dom-module id="run-color-style">
  <template>
    <style>
      [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);
      }
    </style>
  </template>
</dom-module>




<dom-module id="tf-multi-checkbox">
  <template>
    <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 {
        overflow-y: auto;
        overflow-x: hidden;
        width: 100%;
        flex-grow: 1;
        flex-shrink: 1;
        word-wrap: break-word;
      }
      .name-row {
        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>
  </template>
  
</dom-module>




<dom-module id="tf-wbr-string">
  <template>
    
    <template is="dom-repeat" items="[[_parts]]" as="part">[[part]]<wbr></template>
  </template>
  
</dom-module>



<dom-module id="tf-runs-selector">
  <template>
    <paper-dialog with-backdrop id="data-location-dialog">
      <h2>Data Location</h2>
      <tf-wbr-string value="[[dataLocation]]" />
    </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]]" /><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 {
        width: 100%;
        flex-grow: 0;
        flex-shrink: 0;
        padding-right: 16px;
        box-sizing: border-box;
        color: var(--paper-grey-800);
      }
      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(--paper-grey-800);
        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>
  </template>
  
</dom-module>




















<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 {
        left: 45%;
        width: 10%;
        border-top-style: solid;
      }

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

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

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

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

      .active .gap-patch::after,
      .active .circle-clipper::after {
        -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::after {
        -webkit-animation-name: left-spin;
        animation-name: left-spin;
      }

      .active .circle-clipper.right::after {
        -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>




<dom-module id="paper-spinner-lite">
  <template strip-whitespace>
    <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>
        <div class="circle-clipper right"></div>
      </div>
    </div>
  </template>

  
</dom-module>











<style>
.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 {
  font-family: "Helvetica Neue", sans-serif;
  fill: #32313F;
}

.plottable .bar-label-text-area text {
  font-family: "Helvetica Neue", sans-serif;
  font-size: 12px;
}

.plottable .label-area text {
  fill: #32313F;
  font-family: "Helvetica Neue", sans-serif;
  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-family: "Helvetica Neue", sans-serif;
  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-family: "Helvetica Neue", sans-serif;
  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;
}
</style>

<dom-module id="plottable-style">
  <template>
    <style>
.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 {
  font-family: "Helvetica Neue", sans-serif;
  fill: #32313F;
}

.plottable .bar-label-text-area text {
  font-family: "Helvetica Neue", sans-serif;
  font-size: 12px;
}

.plottable .label-area text {
  fill: #32313F;
  font-family: "Helvetica Neue", sans-serif;
  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-family: "Helvetica Neue", sans-serif;
  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-family: "Helvetica Neue", sans-serif;
  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;
}
</style>
  </template>
</dom-module>













<dom-module id="vz-chart-tooltip">
  
</dom-module>











<dom-module id="vz-pan-zoom-style">
  <template>
    <style>
      .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;
        }
      }
    </style>
  </template>
</dom-module>



<dom-module id="vz-line-chart2">
  <template>
    <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 {
        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 line.guide-line {
        stroke: #999;
        stroke-width: 1.5px;
      }
      #chartdiv:hover {
        will-change: transform;
      }

      .ghost {
        opacity: 0.2;
        stroke-width: 1px;
      }
    </style>
  </template>
  
  
  
  
  
</dom-module>

<dom-module id="vz-line-chart-tooltip">
  <template>
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-line-chart-data-loader">
  <template>
    <div id="chart-and-spinner-container">
      <vz-line-chart2 id="chart" data-loading$="[[dataLoading]]" 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>
  </template>
  
  
</dom-module>










<dom-module id="paper-dialog-scrollable">

  <template>
    <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>
  </template>

</dom-module>







<dom-module id="tf-markdown-view">
  <template>
    <div id="markdown" inner-h-t-m-l="[[html]]"></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 #dfe2e5;
      }
      #markdown table tr {
        background-color: #fff;
        border-top: 1px solid #c6cbd1;
      }
    </style>
  </template>
  
</dom-module>

<dom-module id="tf-card-heading-style">
  <template>
    <style>
      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;
      }
    </style>
  </template>
</dom-module>





<dom-module id="tf-card-heading">
  <template>
    <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]]">
            
            
            <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>
  </template>
  
</dom-module>






<dom-module id="tf-downloader">
  <template>
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-scalar-card">
  <template>
    <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>
  </template>
  
</dom-module>




















<dom-module id="paper-progress">
  <template>
    <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>
  </template>
</dom-module>







<dom-module id="paper-slider">
  <template strip-whitespace>
    <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
       * compatability, 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;
        top: calc(14px + var(--paper-slider-height,2px)/2);
        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>
  </template>

  
</dom-module>





<dom-module id="tf-smoothing-input">
  <template>
    <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(--paper-grey-800);
        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>
  </template>
  
</dom-module>



<dom-module id="tf-scalar-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <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 class="sidebar-section">
          <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:
            <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>
              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.
            
          </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]]"></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>
  </template>

  
</dom-module>
































<dom-module id="tf-custom-scalar-card-style">
  <template>
    <style>
      :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;
        }
      }
    </style>
  </template>
</dom-module>





<dom-module id="tf-custom-scalar-margin-chart-card">
  <template>
    <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]]" get-data-load-url="[[_dataUrl]]" fill-area="[[_fillArea]]" ignore-y-outliers="[[ignoreYOutliers]]" load-key="[[_tagFilter]]" data-to-load="[[runs]]" 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>

    
    <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>
  </template>
  
</dom-module>


















<dom-module id="tf-custom-scalar-multi-line-chart-card">
  <template>
    <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]]" get-data-load-url="[[_dataUrl]]" ignore-y-outliers="[[ignoreYOutliers]]" load-key="[[_tagFilter]]" data-to-load="[[runs]]" 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>
  </template>
  
</dom-module>



<dom-module id="tf-custom-scalar-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <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 class="sidebar-section">
          <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:
            <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,
            
            <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>.
            
          </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>
                <div>
                  <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>
                </div>
              </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>
  </template>

  
</dom-module>





























<dom-module id="tf-image-loader">
  <template>
    <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>

    
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-image-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <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 class="sidebar-section">
          <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:
            <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>
              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.
            
          </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>
  </template>
  
</dom-module>























<dom-module id="tf-audio-loader">
  <template>
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-audio-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section">
          <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:
            <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>
              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.
            
          </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>
  </template>
  
</dom-module>













<dom-module id="iron-autogrow-textarea">
  <template>
    <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>

    
    
    <div id="mirror" class="mirror-text" aria-hidden="true">&nbsp;</div>

    
    <div class="textarea-container fit">
      <textarea id="textarea" name$="[[name]]" aria-label$="[[label]]" autocomplete$="[[autocomplete]]" autofocus$="[[autofocus]]" inputmode$="[[inputmode]]" placeholder$="[[placeholder]]" readonly$="[[readonly]]" required$="[[required]]" disabled$="[[disabled]]" rows$="[[rows]]" minlength$="[[minlength]]" maxlength$="[[maxlength]]"></textarea>
    </div>
  </template>
</dom-module>











<dom-module id="paper-textarea">
  <template>
    <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>
  </template>
</dom-module>













<dom-module id="paper-toast">
  <template>
    <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>
  </template>

  
</dom-module>

















<dom-module id="paper-toggle-button">
  <template strip-whitespace>

    <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>

  </template>

  
</dom-module>








































<dom-module id="tf-graph-minimap">
  <template>
    <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>
    
    <canvas class="second"></canvas>
    <canvas class="download"></canvas>
  </template>
  
</dom-module>



<dom-module id="tf-graph-scene">
  <template>
    <style>
      :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;
      }

      /* --- 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 > 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>
        
        <path id="reference-arrowhead-path" d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0" />
        <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" />
        </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" />
        </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" />
        </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" />
        </marker>

        
        <path id="dataflow-arrowhead-path" d="M 0,0 L 10,5 L 0,10 C 3,7 3,3 0,0" />
        <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" />
        </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" />
        </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" />
        </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" />
        </marker>

        
        <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" />
        </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" />
        </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" />
        </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" />
        </marker>
        
        <ellipse id="op-node-stamp" rx="7.5" ry="3" stroke="inherit" fill="inherit" />
        
        <ellipse id="op-node-annotation-stamp" rx="5" ry="2" stroke="inherit" fill="inherit" />
        
        <g id="op-series-vertical-stamp">
          <use xlink:href="#op-node-stamp" x="8" y="9" />
          <use xlink:href="#op-node-stamp" x="8" y="6" />
          <use xlink:href="#op-node-stamp" x="8" y="3" />
        </g>
        
        <g id="op-series-horizontal-stamp">
          <use xlink:href="#op-node-stamp" x="16" y="4" />
          <use xlink:href="#op-node-stamp" x="12" y="4" />
          <use xlink:href="#op-node-stamp" x="8" y="4" />
        </g>
        
        <g id="op-series-annotation-stamp">
          <use xlink:href="#op-node-annotation-stamp" x="9" y="2" />
          <use xlink:href="#op-node-annotation-stamp" x="7" y="2" />
          <use xlink:href="#op-node-annotation-stamp" x="5" y="2" />
        </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" />
        </svg>

        
        <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" />
        </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" />
        </pattern>

        
        <filter id="health-pill-shadow" x="-40%" y="-40%" width="180%" height="180%">
          <fegaussianblur in="SourceAlpha" stdDeviation="0.8" />
          <feoffset dx="0" dy="0" result="offsetblur" />
          <feflood flood-color="#000000" />
          <fecomposite in2="offsetblur" operator="in" />
          <femerge>
            <femergenode />
            <femergenode in="SourceGraphic" />
          </femerge>
        </filter>
      </defs>
      
      <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>
  </template>
  
</dom-module>


<dom-module id="tf-graph">
  <template>
    <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>
  </template>
</dom-module>




















<dom-module id="tf-debugger-continue-dialog">
  <template>
    <paper-button raised class="continue-button" on-click="_continueButtonCallback">
      <span>[[_continueButtonText]]</span>
    </paper-button>
    <paper-dialog with-backdrop id="continueDialog">
      <h2>Continue...</h2>
      <div class="continue-to-type">
        <div class="continue-to-type-name">
          Over Session Runs:
        </div>
        <paper-input id="continueNum" class="input-box" label="Number of Session Runs (including the current one):" always-float-label type="number" min="1" step="1" value="{{continueNum}}"></paper-input>
        <paper-icon-button class="go-button" icon="arrow-forward" title="Session Runs Go" on-tap="_sessionRunGoButtonCallback">
        </paper-icon-button>
      </div>
      <div class="continue-to-type">
        <div class="continue-to-type-name">
          Till Condition Met by Watched Tensor
        </div>
        <paper-dropdown-menu id="tensorConditionDropdown" class="input-box" no-label-float="true" label="Tensor Condition" selected-item-label="{{_selectedTensorCondition}}">
          
          <paper-listbox id="tensorConditionMenu" class="dropdown-content" slot="dropdown-content">
            <paper-item no-label-float="true">Contains +/-∞ or NaN</paper-item>
            <paper-item no-label-float="true">Contains +/-∞</paper-item>
            <paper-item no-label-float="true">Contains NaN</paper-item>
            <paper-item no-label-float="true">Max &gt;</paper-item>
            <paper-item no-label-float="true">Max &lt;</paper-item>
            <paper-item no-label-float="true">Min &gt;</paper-item>
            <paper-item no-label-float="true">Min &lt;</paper-item>
            <paper-item no-label-float="true">Max - Min &gt;</paper-item>
            <paper-item no-label-float="true">Max - Min &lt;</paper-item>
            <paper-item no-label-float="true">Mean &gt;</paper-item>
            <paper-item no-label-float="true">Mean &lt;</paper-item>
            <paper-item no-label-float="true">Standard deviation &gt;</paper-item>
            <paper-item no-label-float="true">Standard deviation &lt;</paper-item>
          </paper-listbox>
        </paper-dropdown-menu>
        <paper-icon-button class="go-button" icon="arrow-forward" title="Tensor Condition Go" on-tap="_tensorContinueGoButtonCallback">
        </paper-icon-button>
        <paper-input id="ref-value" class="input-box" label="Reference value to compare to" type="number" value="{{_tensorConditionRefValue}}" hidden="[[_isRefValueInputHidden]]">
        </paper-input>
      </div>
    </paper-dialog>
    <style include="dashboard-style"></style>
    <style>
      :host .continue-to-type-name {
        font-weight: bold;
      }
      :host paper-dialog {
        width: 36vw;
      }
      :host .input-box {
        display: inline-block;
        position: relative;
        width: 80%;
        font-size: 110%;
      }
      :host .go-button {
        position: relative;
        width: 15%;
        display: inline-block;
      }
    </style>
  </template>
  
</dom-module>




<dom-module id="tf-debugger-initial-dialog">
  <template>
    
    <template is="dom-if" if="[[_open]]">
      <div id="dashboard-backdrop"></div>
    </template>
    <paper-dialog id="dialog" no-cancel-on-outside-click no-cancel-on-esc-key opened="{{_open}}">
      <h2 id="dialog-title">[[_title]]</h2>
      <template is="dom-if" if="[[_hasCustomMessage]]">
        <div class="custom-message">[[_customMessage]]</div>
      </template>
      <template is="dom-if" if="[[!_hasCustomMessage]]">
        <div class="code-example">
          <div class="code-example-section">
            <div class="code-example-section-title">
              <a href="https://www.tensorflow.org/api_docs/python/tf/Session" target="_blank" rel="noopener noreferrer">tf.Session</a>:
            </div>
            <pre class="code-snippet">import tensorflow as tf
from tensorflow.python import debug as tf_debug

sess = tf.Session()
sess = tf_debug.TensorBoardDebugWrapperSession(sess, "[[_host]]:[[_port]]")
sess.run(my_fetches)
          </pre>
          </div>
          <div class="code-example-section">
            <div class="code-example-section-title">
              <a href="https://www.tensorflow.org/programmers_guide/estimators" target="_blank" rel="noopener noreferrer">Estimator</a>
              |
              <a href="https://www.tensorflow.org/api_docs/python/tf/train/MonitoredSession" target="_blank" rel="noopener noreferrer">MonitoredSession</a>:
            </div>
            <pre class="code-snippet">import tensorflow as tf
from tensorflow.python import debug as tf_debug

hook = tf_debug.TensorBoardDebugHook("[[_host]]:[[_port]]")
my_estimator.fit(x=x_data, y=y_data, steps=1000, monitors=[hook])
            </pre>
          </div>
          <div class="code-example-section">
            <div class="code-example-section-title">
              <a href="https://keras.io/models/model/" target="_blank" rel="noopener noreferrer">Keras Model</a>:
            </div>
            <pre class="code-snippet">import tensorflow as tf
from tensorflow.python import debug as tf_debug
import keras

keras.backend.set_session(
    tf_debug.TensorBoardDebugWrapperSession(tf.Session(), "[[_host]]:[[_port]]"))
# Define your keras model, called "model".
model.fit(...)
            </pre>
          </div>
        </div>
      </template>
    </paper-dialog>
    <style>
      /** We rely on a separate `_hidden` property instead of directly making use
          of the `_open` attribute because this CSS specification may strangely
          affect other elements throughout TensorBoard. See #899. */
      :host([_hidden]) {
        display: none;
      }
      :host,
      #dashboard-backdrop {
        position: absolute;
        top: 0;
        bottom: 0;
        left: 0;
        right: 0;
      }

      #dashboard-backdrop {
        background: rgba(0, 0, 0, 0.6);
      }

      .code-example {
        margin: 10px;
        font-family: monospace;
      }
      .code-example-section {
        padding-bottom: 15px;
      }
      .code-example-section-title {
        font-weight: bold;
      }
      .code-snippet {
        padding-left: 1em;
      }

      #dialog-title {
        padding-bottom: 15px;
      }

      .custom-message {
        margin-top: 0;
        margin-bottom: 15px;
      }
    </style>
  </template>
  
</dom-module>





<dom-module id="tf-debugger-resizer">
  <template>
    <div class="bars">
      <div class="bars-rotator">
        <span class="bars-text">| |</span>
      </div>
    </div>
    <style>
      :host([_resizer-identifier]) {
        position: absolute;
        background: #ccc;
        user-select: none;
      }

      :host([is-horizontal]) {
        cursor: row-resize;
        height: 10px;
        left: 0;
        right: 0;
      }

      :host([_is-vertical]) {
        cursor: col-resize;
        right: -15px;
        top: 0;
        bottom: 0;
        width: 10px;
      }

      .bars {
        width: 80%;
        text-align: center;
        position: absolute;
        top: 50%;
        left: 50%;
        font-size: 5px;
        transform: translate(-50%, -50%);
      }

      /** This block prevents the bars rotator from having a height that is
          the entire viewport, thus occluding it and giving it an undesired cursor
          value. */
      .bars-rotator {
        display: inline-block;
      }

      :host([is-horizontal]) .bars-rotator {
        transform: rotate(90deg);
      }

      .bars-text {
        transform: scaleY(15);
        white-space: nowrap;
        display: block;
        font-weight: 400;
      }
    </style>
  </template>
  
</dom-module>












<dom-module id="tf-op-selector">
  <template>
    <div>
      <paper-dropdown-menu id="filter-mode" no-label-float="true" label="Filter Mode" selected-item-label="{{_filterMode}}">
        <paper-listbox class="dropdown-content" slot="dropdown-content">
          <paper-item no-label-float="true">Node Name</paper-item>
          <paper-item no-label-float="true">Op Type</paper-item>
        </paper-listbox>
      </paper-dropdown-menu>
      <paper-input id="filter-input" label="Filter Regex" always-float-label value="{{_filterInput}}"></paper-input>
    </div>
    <paper-spinner-lite active class="spinner" id="loading-spinner" hidden="[[!_isLoading]]">
    </paper-spinner-lite>
    <div id="selector-hierarchy"></div>
    <style>
      .indented-level-container .content-container {
        margin: 0 0 0 20px;
      }

      .level-container iron-collapse {
        padding: 0 0 0 20px;
      }

      paper-checkbox {
        display: inline-block;
        width: 18px;
        height: 18px;
        margin: 0 8px 0 0;
      }

      .op-type {
        padding-right: 10px;
        color: #444;
      }

      .op-title-leaf {
        text-decoration: underline;
        cursor: pointer;
      }

      .op-title-leaf:hover {
        color: blue;
      }

      .partial-checkbox {
        background: #f57c00;
      }

      .node-expand-button {
        margin: 0 0 0 -13px;
      }

      .level-title-text {
        display: inline-block;
        font-weight: 800;
        margin: 0 0 0 -1px;
      }

      .op-description {
        font-weight: 300;
        margin: 0 0 0 27px;
        padding: 10px 0;
      }

      .spinner {
        width: 20px;
        height: 20px;
        vertical-align: middle;
      }

      #filter-mode {
        width: 150px;
        display: inline-block;
      }

      #filter-input {
        width: 250px;
        display: inline-block;
      }

      .highlighted {
        color: red;
      }
      .highlighted > .op-type {
        color: red;
      }

      #selector-hierarchy {
        width: 100%;
      }

      [hidden] {
        display: none;
      }
    </style>
  </template>
  
  
</dom-module>





<dom-module id="tf-session-runs-view">
  <template>
    <div class="session-runs-div">
      <div class="section-title">Session Runs</div>
      <table id="session-runs-table" align="left" class="session-runs-table">
        <tr align="left">
          <th>Feeds</th>
          <th>Fetches</th>
          <th>Targets</th>
          <th>#(Devices)</th>
          <th>Count</th>
        </tr>
      </table>
    </div>
    <style>
      :host {
        display: block;
        padding: 20px 0;
      }

      .section-title {
        font-size: 110%;
        font-weight: bold;
      }
      :host .indented-level-container .content-container {
        margin: 0 0 0 10px;
      }

      /* TODO(cais): This needs work: the table shouldn't get too wide when
         there are many feeds/fetches/targte names. */
      .session-runs-table {
        align-content: left;
        align-items: left;
        text-align: left;
        font-size: 90%;
        border-style: solid 1px black;
        table-layout: fixed;
        width: 100%;
        word-break: break-all;
        padding-top: 3px;
        padding-left: 3px;
        padding-right: 3px;
        box-shadow: 3px 3px #ddd;
      }
      .active-session-run {
        background-color: #ffffe0;
        font-weight: bold;
      }
      .sole-active-session-run {
        background-color: rgb(172, 232, 188);
        font-weight: bold;
      }

      .node-or-tensor-element {
        text-decoration: underline;
        cursor: pointer;
      }

      .node-or-tensor-element:hover {
        color: blue;
      }
    </style>
  </template>
  
</dom-module>





<dom-module id="tf-source-code-view">
  <template>
    <div id="fullStackDialog" hidden$="[[!_fullStackShown]]">
      <div id="full-stack-title">
        <paper-icon-button icon="filter-list" disabled="true">
        </paper-icon-button>
        Full Stack Trace of Node:
        <div id="full-stack-node-name">"[[_fullStackNodeName]]"</div>
        <paper-icon-button icon="close" id="close-full-stack-button" title="Close Full Stack" on-tap="_closeFullStackDialog">
        </paper-icon-button>
      </div>
      <ul id="full-stack-content"></ul>
    </div>
    <paper-tabs id="source-files-tabs" selected="{{_filePathSelected}}">
      <template is="dom-repeat" items="[[_shortFilePaths]]">
        <paper-tab id="[[item.id]]">[[item.name]]</paper-tab>
      </template>
    </paper-tabs>
    <div id="source-file-content" class="source-content">
      <template is="dom-repeat" items="[[_fileLines]]">
        <div class$="{{item.sourceClass}}" id="source-line-[[item.lineno]]">
          <span class="source-line-number" id="source-lineno-[[item.lineno]]">
            [[item.lineno]]
          </span>
          <span class="source-line-node-toggle" id="source-line-node-toggle-[[item.lineno]]">
            [[item.numNodes]]
          </span>
          <span class="source-line-text" id="source-line-text-[[item.lineno]]">
            [[item.text]]
          </span>
          <div class="source-line-nodes" id="source-line-nodes-[[item.lineno]]"></div>
        </div>
      </template>
    </div>
    <style>
      #source-files-tabs {
        position: relative;
        height: 8%;
      }
      .source-content {
        position: relative;
        height: 90%;
        font-family: monospace;
        font-size: 90%;
        overflow-x: scroll;
        overflow-y: scroll;
      }
      .source-content :hover {
        background-color: #ffff00;
      }
      .highlighted-source-line {
        background-color: #ffffe0;
      }
      .source-line-number {
        display: inline-block;
        color: lightblue;
        width: 2em;
        text-align: right;
        padding-right: 1em;
      }
      .source-line-node-toggle {
        display: inline-block;
        color: blue;
        width: 5em;
        text-align: right;
        padding-right: 1em;
        text-decoration: underline;
        cursor: pointer;
      }
      .source-line-nodes {
        padding-left: 4em;
        text-decoration: underline;
        cursor: pointer;
        color: blue;
        margin-top: 0em;
        margin-bottom: 0em;
        margin-right: 1em;
      }
      .source-line-node-entry {
        margin-right: 1em;
        background-color: yellow;
      }
      .source-line-nodes span {
        text-decoration: none;
        background-color: yellow;
      }
      .source-line-text {
        display: inline;
        word-wrap: break-word;
      }
      #fullStackDialog {
        z-index: 1000;
        position: absolute;
        top: 10%;
        left: 50%;
        width: 45%;
        height: 85%;
        background-color: white;
        border: 1px solid gray;
        font-family: monospace;
        box-shadow: 3px 3px #ddd;
        overflow-y: auto;
      }
      #full-stack-title {
        font-size: 110%;
        position: relative;
        width: 100%;
        background-color: #eee;
        text-align: center;
        font-weight: bold;
      }
      #full-stack-node-name {
        color: blue;
      }
      :host #full-stack-content {
        padding-top: 1em;
        padding-right: 0.5em;
        margin-top: 0.5em;
        font-size: 90%;
        word-wrap: break-word;
        overflow: auto;
      }
      .stack-frame-clickable {
        color: blue;
        text-decoration: underline;
        cursor: pointer;
      }
      .stack-frame-nonclickable {
        color: #555;
      }
      #close-full-stack-button {
        float: right;
      }
    </style>
  </template>
  
</dom-module>





<dom-module id="tf-tensor-data-summary">
  <template>
    <span class="section-title">Tensor Value Overview</span>
    <div id="tensor-data-div" class="tensor-data-div">
      <table id="tensor-data-table" align="left" class="tensor-data-table">
        <thead>
          <tr align="left">
            <th>Tensor</th>
            <th>Count</th>
            <th>DType</th>
            <th>Shape</th>
            <th width="25%">Value</th>
            <th width="25%">
              Health Pill
              <paper-toggle-button id="show-health-pills" checked="{{_healthPillsEnabled}}">
              </paper-toggle-button>
              <paper-card>
                <div class="health-pill-legend" id="health-pill-legend"></div>
              </paper-card>
            </th>
            <th width="5%"></th>
          </tr>
        </thead>
        <tbody></tbody>
      </table>
    </div>
    <style>
      :host #tensor-data-div {
        height: 100%;
        overflow-y: auto;
      }
      .section-title {
        font-size: 110%;
        font-weight: bold;
      }
      :host .indented-level-container .content-container {
        margin: 0 0 0 10px;
      }
      :host .tensor-data-table {
        align-content: left;
        align-items: left;
        display: block;
        text-align: left;
        vertical-align: middle;
        width: 100%;
        padding-top: 3px;
        padding-left: 3px;
        padding-right: 3px;
        box-shadow: 3px 3px #ddd;
      }
      :host #tensor-data-table th {
        vertical-align: top;
      }
      :host .active-tensor {
        background-color: #ffffe0;
        font-weight: bold;
        border: solid 1px #888;
      }
      :host .highlighted {
        color: red;
      }
      :host .health-pill-legend {
        float: right;
        font-weight: normal;
      }
      :host #show-health-pills {
        display: inline-block;
      }
      .value-expansion-link {
        text-decoration: underline;
        cursor: pointer;
      }
      .value-expansion-link :hover {
        color: blue;
      }
      .health-pill :hover {
        cursor: pointer;
      }
      .tensor-name {
        text-decoration: underline;
        cursor: pointer;
      }
      .tensor-name :hover {
        color: blue;
      }
    </style>
  </template>
  
</dom-module>



<style>/* 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.
==============================================================================*/

.tensor-widget {
  font-family: monospace;
  font-size: 14px;
  overflow-x: hidden;
  overflow-y: hidden;
  position: relative;
}

.tensor-widget-dim {
  border: 1px solid rgb(160, 160, 160);
  display: inline-block;
  font-size: 12px;
  height: 14px;
  line-height: 14px;
  margin-left: 15px;
  margin-right: 15px;
  padding: 2px;
}

.tensor-widget-dim-comma {
  color: rgb(128, 128, 128);
  display: inline-block;
  font-size: 12px;
  height: 14px;
  line-height: 14px;
}

.tensor-widget-dim-highlighted {
  border: 1px solid rgb(100, 180, 255);
  font-weight: bold;
}

.tensor-widget-dim-brackets {
  color: rgb(128, 128, 128);
  display: inline-block;
  font-size: 8pt;
}

.tensor-widget-dim-dropdown {
  background-color: rgb(255, 255, 255);
  border: 1px solid rgb(128, 128, 128);
  box-shadow: 2px 2px 2px #b0b0b0;
  cursor: pointer;
  width: 180px;
  z-index: 1000;
}

.tensor-widget-dim-dropdown-menu-item {
  border-bottom: 1px solid rgb(180, 180, 180);
  font-size: 12px;
  padding: 3px;
  user-select: none;
}

.tensor-widget-dim-dropdown-menu-item-active {
  background-color: rgb(100, 180, 255);
}

.tensor-widget-dim-dropdown-menu-item-disabled {
  color: rgb(128, 128, 128);
}

.tensor-widget-dtype {
  align-content: center;
  color: rgb(60, 60, 60);
  display: inline-block;
  font-size: 8pt;
  height: 48px;
  line-height: 22px;
  max-height: 22px;
  padding-left: 14px;
  padding-right: 10px;
  position: relative;
  vertical-align: middle;
}

.tensor-widget-dtype-label {
  color: rgb(128, 128, 128);
}

.tensor-widget-header {
  background-color: rgb(252, 252, 252);
  box-shadow: 2px 2px 2px #b0b0b0;
  height: 40px;
  line-height: 40px;
  max-height: 40px;
  position: relative;
  vertical-align: middle;
  width: 100%;
}

.tensor-widget-info {
  align-content: center;
  color: rgb(0, 0, 255);
  display: inline-block;
  font-size: 8pt;
  height: 22px;
  line-height: 22px;
  margin-left: 8px;
  max-height: 22px;
  position: relative;
  vertical-align: middle;
}

.tensor-widget-menu-thumb {
  color: rgb(32, 33, 36);
  cursor: pointer;
  display: inline-block;
  font-weight: bold;
  font-size: 16px;
  margin-left: 10px;
  margin-right: 5px;
  position: relative;
  user-select: none;
}

.tensor-widget-menu-thumb:hover {
  color: rgb(227, 116, 0);
}

.tensor-widget-shape {
  color: rgb(60, 60, 60);
  display: inline-block;
  margin-left: 12px;
}

.tensor-widget-shape-label {
  color: rgb(128, 128, 128);
  display: inline-block;
}

.tensor-widget-shape-value {
  display: inline-block;
}

.tensor-widget-slicing-group {
  background-color: rgb(250, 250, 250);
  border-bottom: 1px solid rgb(190, 190, 190);
  display: block;
  height: 18px;
  text-align: center;
  padding-bottom: 5px;
  padding-top: 5px;
}

.tensor-widget-tensor-name {
  color: black;
  display: inline-block;
  font-weight: bold;
}

.tensor-widget-left-ruler-tick {
  background-color: var(--ruler-background-color);
  border-bottom: var(--border-style);
  border-top: var(--border-style);
  box-shadow: var(--border-style);
  color: rgb(110, 110, 110);
  cursor: pointer;
  display: inline-block;
  font-size: 12px;
  height: 29px;
  line-height: 29px;
  margin-left: 0px;
  max-width: 45px;
  text-align: center;
  user-select: none;
  vertical-align: middle;
  width: 45px;
}

.tensor-widget-top-ruler {
  height: 24px;
  white-space: nowrap;
}

.tensor-widget-value-tooltip {
  background-color: rgb(240, 240, 240);
  border: 1px solid rgb(160, 160, 160);
  box-shadow: 1px 1px 1px #b0b0b0;
  display: none;
  font-size: 13px;
  padding: 5px;
  position: absolute;
  user-select: none;
  width: 240px;
}

.tensor-widget-value-tooltip-colorbar {
  height: 24px;
  width: 95%;
}

.tensor-widget-value-tooltip-indices {
  font-weight: bold;
}

.tensor-widget-value-tooltip-value {
  margin-top: 20px;
}

.tensor-widget-top-ruler-tick {
  background-color: var(--ruler-background-color);
  border-bottom: var(--border-style);
  border-right: var(--border-style);
  color: rgb(110, 110, 110);
  cursor: pointer;
  display: inline-block;
  font-size: 12px;
  height: 24px;
  line-height: 24px;
  padding-right: 2px;
  text-align: center;
  user-select: none;
  vertical-align: middle;
  width: 45px;
}

.tensor-widget-value-div {
  border-bottom: var(--border-style);
  border-right: var(--border-style);
  cursor: pointer;
  display: inline-block;
  font-size: 80%;
  height: 24px;
  line-height: 24px;
  max-width: 45px;
  padding-right: 2px;
  text-align: right;
  user-select: none;
  vertical-align: middle;
  width: 45px;
}

.tensor-widget-value-div-selection {
  font-weight: bold;
}

.tensor-widget-value-div-selection-bottom {
  border-bottom: 0.5px solid blue;
}

.tensor-widget-value-div-selection-left {
  border-left: 0.5px solid blue;
}

.tensor-widget-value-div-selection-right {
  border-right: 0.5px solid blue;
}

.tensor-widget-value-div-selection-top {
  border-top: 0.5px solid blue;
}

.tensor-widget-value-section {
  --border-style: 1px solid rgb(140, 140, 140);
  --ruler-background-color: rgb(210, 210, 210);
  -moz-user-select: none;
  -ms-user-select: none;
  -khtml-user-select: none;
  -webkit-touch-callout: none;
  -webkit-user-select: none;
}

.tensor-widget-value-row {
  height: 25px;
  line-height: 25px;
  white-space: nowrap;
}
</style>

<dom-module id="tensor-widget-style">
  <template>
    <style>/* 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.
==============================================================================*/

.tensor-widget {
  font-family: monospace;
  font-size: 14px;
  overflow-x: hidden;
  overflow-y: hidden;
  position: relative;
}

.tensor-widget-dim {
  border: 1px solid rgb(160, 160, 160);
  display: inline-block;
  font-size: 12px;
  height: 14px;
  line-height: 14px;
  margin-left: 15px;
  margin-right: 15px;
  padding: 2px;
}

.tensor-widget-dim-comma {
  color: rgb(128, 128, 128);
  display: inline-block;
  font-size: 12px;
  height: 14px;
  line-height: 14px;
}

.tensor-widget-dim-highlighted {
  border: 1px solid rgb(100, 180, 255);
  font-weight: bold;
}

.tensor-widget-dim-brackets {
  color: rgb(128, 128, 128);
  display: inline-block;
  font-size: 8pt;
}

.tensor-widget-dim-dropdown {
  background-color: rgb(255, 255, 255);
  border: 1px solid rgb(128, 128, 128);
  box-shadow: 2px 2px 2px #b0b0b0;
  cursor: pointer;
  width: 180px;
  z-index: 1000;
}

.tensor-widget-dim-dropdown-menu-item {
  border-bottom: 1px solid rgb(180, 180, 180);
  font-size: 12px;
  padding: 3px;
  user-select: none;
}

.tensor-widget-dim-dropdown-menu-item-active {
  background-color: rgb(100, 180, 255);
}

.tensor-widget-dim-dropdown-menu-item-disabled {
  color: rgb(128, 128, 128);
}

.tensor-widget-dtype {
  align-content: center;
  color: rgb(60, 60, 60);
  display: inline-block;
  font-size: 8pt;
  height: 48px;
  line-height: 22px;
  max-height: 22px;
  padding-left: 14px;
  padding-right: 10px;
  position: relative;
  vertical-align: middle;
}

.tensor-widget-dtype-label {
  color: rgb(128, 128, 128);
}

.tensor-widget-header {
  background-color: rgb(252, 252, 252);
  box-shadow: 2px 2px 2px #b0b0b0;
  height: 40px;
  line-height: 40px;
  max-height: 40px;
  position: relative;
  vertical-align: middle;
  width: 100%;
}

.tensor-widget-info {
  align-content: center;
  color: rgb(0, 0, 255);
  display: inline-block;
  font-size: 8pt;
  height: 22px;
  line-height: 22px;
  margin-left: 8px;
  max-height: 22px;
  position: relative;
  vertical-align: middle;
}

.tensor-widget-menu-thumb {
  color: rgb(32, 33, 36);
  cursor: pointer;
  display: inline-block;
  font-weight: bold;
  font-size: 16px;
  margin-left: 10px;
  margin-right: 5px;
  position: relative;
  user-select: none;
}

.tensor-widget-menu-thumb:hover {
  color: rgb(227, 116, 0);
}

.tensor-widget-shape {
  color: rgb(60, 60, 60);
  display: inline-block;
  margin-left: 12px;
}

.tensor-widget-shape-label {
  color: rgb(128, 128, 128);
  display: inline-block;
}

.tensor-widget-shape-value {
  display: inline-block;
}

.tensor-widget-slicing-group {
  background-color: rgb(250, 250, 250);
  border-bottom: 1px solid rgb(190, 190, 190);
  display: block;
  height: 18px;
  text-align: center;
  padding-bottom: 5px;
  padding-top: 5px;
}

.tensor-widget-tensor-name {
  color: black;
  display: inline-block;
  font-weight: bold;
}

.tensor-widget-left-ruler-tick {
  background-color: var(--ruler-background-color);
  border-bottom: var(--border-style);
  border-top: var(--border-style);
  box-shadow: var(--border-style);
  color: rgb(110, 110, 110);
  cursor: pointer;
  display: inline-block;
  font-size: 12px;
  height: 29px;
  line-height: 29px;
  margin-left: 0px;
  max-width: 45px;
  text-align: center;
  user-select: none;
  vertical-align: middle;
  width: 45px;
}

.tensor-widget-top-ruler {
  height: 24px;
  white-space: nowrap;
}

.tensor-widget-value-tooltip {
  background-color: rgb(240, 240, 240);
  border: 1px solid rgb(160, 160, 160);
  box-shadow: 1px 1px 1px #b0b0b0;
  display: none;
  font-size: 13px;
  padding: 5px;
  position: absolute;
  user-select: none;
  width: 240px;
}

.tensor-widget-value-tooltip-colorbar {
  height: 24px;
  width: 95%;
}

.tensor-widget-value-tooltip-indices {
  font-weight: bold;
}

.tensor-widget-value-tooltip-value {
  margin-top: 20px;
}

.tensor-widget-top-ruler-tick {
  background-color: var(--ruler-background-color);
  border-bottom: var(--border-style);
  border-right: var(--border-style);
  color: rgb(110, 110, 110);
  cursor: pointer;
  display: inline-block;
  font-size: 12px;
  height: 24px;
  line-height: 24px;
  padding-right: 2px;
  text-align: center;
  user-select: none;
  vertical-align: middle;
  width: 45px;
}

.tensor-widget-value-div {
  border-bottom: var(--border-style);
  border-right: var(--border-style);
  cursor: pointer;
  display: inline-block;
  font-size: 80%;
  height: 24px;
  line-height: 24px;
  max-width: 45px;
  padding-right: 2px;
  text-align: right;
  user-select: none;
  vertical-align: middle;
  width: 45px;
}

.tensor-widget-value-div-selection {
  font-weight: bold;
}

.tensor-widget-value-div-selection-bottom {
  border-bottom: 0.5px solid blue;
}

.tensor-widget-value-div-selection-left {
  border-left: 0.5px solid blue;
}

.tensor-widget-value-div-selection-right {
  border-right: 0.5px solid blue;
}

.tensor-widget-value-div-selection-top {
  border-top: 0.5px solid blue;
}

.tensor-widget-value-section {
  --border-style: 1px solid rgb(140, 140, 140);
  --ruler-background-color: rgb(210, 210, 210);
  -moz-user-select: none;
  -ms-user-select: none;
  -khtml-user-select: none;
  -webkit-touch-callout: none;
  -webkit-user-select: none;
}

.tensor-widget-value-row {
  height: 25px;
  line-height: 25px;
  white-space: nowrap;
}
</style>
  </template>
</dom-module>








<dom-module id="tf-debugger-line-chart">
  <template>
    <vz-line-chart2 x-components-creation-method="[[_lineChartXComponentsCreationMethod]]" y-value-accessor="[[_lineChartYValueAccessor]]" tooltip-columns="[[_lineChartTooltipColumns]]" smoothing-enabled="[[_lineChartSmoothingEnabled]]"></vz-line-chart2>
    <style>
      vz-line-chart2 {
        height: 300px;
        position: relative;
      }
    </style>
  </template>

  
</dom-module>



<dom-module id="tf-tensor-value-view">
  <template>
    <paper-toast id="tensorValueToast" text="" always-on-top></paper-toast>
    <table class="tensor-value-view-table">
      <tr>
        <td colspan="2">
          <div>
            <paper-item id="tensor-name" on-tap="tensorNameCallback">
              <span class="tensor-name-text">[[tensorName]]</span>
            </paper-item>
            <paper-icon-button icon="close" class="value-view-icon-button" id="value-view-icon-button" title="Close" on-tap="closeButtonCallback"></paper-icon-button>
            <paper-icon-button icon="forward" class="value-view-icon-button" id="value-view-icon-button" title="Continue to" on-tap="continueToButtonCallback"></paper-icon-button>
          </div>
        </td>
      </tr>
      <tr class="tensor-value-value-tr">
        <td>
          <template is="dom-if" if="[[_useTensorWidget]]">
            <div id="tensor-widget"></div>
          </template>

          <template is="dom-if" if="[[!_useTensorWidget]]">
            <paper-item id="debug-op"></paper-item>
            <div>
              <paper-input class="inline value-card-input" label="Slicing" id="slicing" value="{{slicing}}" on-change="refresh">
              </paper-input>
              <div>
                <paper-input class="inline value-card-input" label="Time Indices" id="time-indices" value="{{timeIndices}}" on-change="refresh">
                </paper-input>
                <paper-button raised id="time-indices-toggle-button" class="tensor-value-buttons" on-click="_timeIndicesToggleButtonCallback">Full History</paper-button>
              </div>

              </div></template></td><td class="tensor-value-view-td">
                <template is="dom-if" if="[[_isValueScalar]]">
                  <paper-input class="inline" label="Scalar Value" id="value-scalar" value="[[_dataScalar]]">
                  </paper-input>
                </template>
                <template is="dom-if" if="[[_isValueLineChart]]">
                  <tf-debugger-line-chart data="[[_lineChartData]]"></tf-debugger-line-chart>
                </template>
                <template is="dom-if" if="[[_isValueImage]]">
                  <img class="value-image" height="250px" width="250px" src$="[[_dataImageSrc]]">
                </template>
              </td>
            
          
        
      </tr>
    </table>

    <style include="tensor-widget-style"></style>
    <style>
      .tensor-value-buttons {
        height: 75%;
        font-size: 10px;
      }
      .tensor-value-view-table {
        width: 500px;
        display: inline-table;
        border-spacing: 5px;
        padding-top: 3px;
        padding-bottom: 3px;
        padding-left: 3px;
        padding-right: 3px;
        background-color: #f8f8f8;
        box-shadow: 3px 3px 1px 1px #d8d8d8;
      }
      .tensor-value-view-td {
        width: 350px;
      }
      .value-card-input {
        width: 150px;
      }
      #tensor-name {
        display: inline-block;
        position: relative;
        width: 50%;
        cursor: pointer;
      }
      .tensor-name-text {
        color: blue;
        text-decoration: underline;
      }
      #debug-op {
        font-size: 90%;
      }
      .value-image {
        image-rendering: pixelated;
      }
      .value-view-icon-button {
        display: inline-block;
        float: right;
        text-align: right;
        width: 20%;
        text-decoration: underline;
        cursor: pointer;
        font-size: 90%;
        color: blue;
      }
      #tensor-widget {
        border: 1px solid rgb(160, 160, 160);
        /* box-sizing: content-box;
        -moz-box-sizing: content-box;
        -webkit-box-sizing: content-box; */
        height: 280px;
        width: 484px;
      }
      #slicing,
      #time-indices {
        --paper-input-container-input: {
          font-family: monospace;
        }
      }
    </style>
  </template>
  
</dom-module>


<dom-module id="tf-tensor-value-multi-view">
  <template>
    <div id="multiView">
      <div class="section-title">Tensor Values</div>
      <div id="multi-tensor-view-container"></div>
    </div>
    <style>
      .section-title {
        font-size: 110%;
        font-weight: bold;
      }
      #multiView {
        background-color: #fff;
        padding-top: 3px;
        padding-left: 3px;
        padding-right: 3px;
        box-shadow: 3px 3px #eee;
      }
    </style>
  </template>
  
</dom-module>


<dom-module id="tf-debugger-dashboard">
  <template>
    <paper-toast id="toast" text="" always-on-top></paper-toast>
    <tf-debugger-initial-dialog id="initialDialog"></tf-debugger-initial-dialog>
    
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar" id="left-pane">
        <div id="node-entries" class="node-entries">
          <div class="debugger-section-title">Runtime Node List</div>
          <div class="toggle-source-code">
            Show Code:
            <paper-toggle-button class="toggle-source-code" id="show-source-code" checked="{{_sourceCodeShown}}"></paper-toggle-button>
          </div>
          <tf-op-selector debug-watches="[[_debugWatches]]" debug-watch-change="[[_createDebugWatchChangeHandler()]]" node-clicked="[[_createNodeClickedHandler()]]" force-expand-and-check-node-name="[[_forceExpandAndCheckNodeName]]" force-expand-node-name="[[_forceExpandNodeName]]">
          </tf-op-selector>
        </div>
        <div id="source-code-view-div" class="source-code-view-div" hidden$="{{!_sourceCodeShown}}">
          <div class="debugger-section-title">Source Code</div>
          <tf-source-code-view id="sourceCodeView" request-manager="[[_requestManager]]" debug-watches="[[_debugWatches]]" focus-node-name="[[_sourceFocusNodeName]]" node-clicked="[[_createNodeClickedHandler()]]" continue-to-node="[[_createContinueToNodeHandler()]]"></tf-source-code-view>
        </div>
        <tf-debugger-resizer current-length="{{_leftPaneWidth}}" min-length="[[_minleftPaneWidth]]" max-length="[[_maxleftPaneWidth]]">
        </tf-debugger-resizer>
        <div>
          <tf-session-runs-view id="sessionRunsView" latest-session-run="[[_latestSessionRun]]" session-run-key-to-device-names="[[_sessionRunKey2DeviceNames]]" sole-active="[[_sessionRunSoleActive]]" node-or-tensor-clicked="[[_createFeedFetchTargetClickedHandler()]]">
          </tf-session-runs-view>
        </div>
        <div class="buttons-container">
          <paper-button raised class="continue-button" on-click="_step">
            <span>[[_stepButtonText]]</span>
          </paper-button>
          <tf-debugger-continue-dialog id="continueDialog" session-run-go="[[_createSessionRunGo()]]" tensor-condition-go="[[_createTensorConditionGo()]]" force-continuation-stop="[[_createForceContinuationStop()]]">
          </tf-debugger-continue-dialog>
        </div>
        <div class="container">
          <tf-graph-loader id="loader" out-graph-hierarchy="{{graphHierarchy}}" out-graph="{{graph}}" out-stats="{{stats}}" progress="{{_graphProgress}}"></tf-graph-loader>
        </div>
      </div>
      <div class="center" slot="center" id="center-content">
        <div id="top-right-quadrant">
          <paper-tabs selected="{{_topRightSelected}}">
            <template is="dom-repeat" items="[[_topRightTabs]]">
              <paper-tab id="[[item.id]]">[[item.name]]</paper-tab>
            </template>
          </paper-tabs>
          <div class="runtime-graph-device">
            <span id="runtime-graph-device-name"> </span>
            <paper-dropdown-menu id="active-runtime-graph-device-name" no-label-float="true" label="Device name" selected-item-label="{{_activeRuntimeGraphDeviceName}}">
              <paper-listbox class="dropdown-content" slot="dropdown-content">
                <template is="dom-repeat" items="[[_activeSessionRunDevices]]">
                  <paper-item no-label-float="true">[[item]]</paper-item>
                </template>
              </paper-listbox>
            </paper-dropdown-menu>
            <paper-spinner-lite class="spinner" id="top-right-spinner" hidden="[[!_busy]]" active="[[_busy]]">
            </paper-spinner-lite>
          </div>
          <paper-progress id="top-right-progress-bar" value="0"></paper-progress>
          <template is="dom-if" if="[[_isTopRightRuntimeGraphsActive]]">
            <div id="graph-container">
              <tf-graph id="graph" graph-hierarchy="[[graphHierarchy]]" basic-graph="[[graph]]" stats="[[stats]]" progress="{{_graphProgress}}" color-by="structure" color-by-params="{{colorByParams}}" render-hierarchy="{{_renderHierarchy}}" node-context-menu-items="[[_createNodeContextMenuItems()]]"></tf-graph>
              <div class="context-menu"></div>
            </div>
          </template>
          <template is="dom-if" if="[[_isTopRightTensorValuesActive]]">
            <tf-tensor-value-multi-view id="tensorValueMultiView" continue-to-callback="[[_createContinueToCallback()]]" tensor-name-clicked="[[_createNodeClickedHandler()]]" get-health-pill="[[_createGetHealthPill()]]">
            </tf-tensor-value-multi-view>
          </template>
        </div>

        <tf-debugger-resizer is-horizontal="true" current-length="{{_topRightQuadrantHeight}}" min-length="[[_minTopRightQuadrantHeight]]" max-length="[[_maxTopRightQuadrantHeight]]">
        </tf-debugger-resizer>

        <div id="tensor-data" class="tensor-data">
          <tf-tensor-data-summary id="tensorDataSummary" latest-tensor-data="[[_latestTensorData]]" expand-handler="[[_createTensorDataExpandHandler()]]" continue-to-callback="[[_createContinueToCallback()]]" highlighted-node-name="[[_highlightNodeName]]" tensor-name-clicked="[[_createNodeClickedHandler()]]" get-health-pill="[[_createGetHealthPill()]]">
          </tf-tensor-data-summary>
        </div>
      </div>
    </tf-dashboard-layout>

    <style include="dashboard-style"></style>
    <style>
      :host {
        display: block;
        position: absolute;
        left: 0;
        right: 0;
        top: 0;
        bottom: 0;
        overflow: hidden;
      }
      paper-toast {
        text-align: center;
        font-size: 110%;
        width: 40vw;
        margin-left: 30vw;
      }
      tf-dashboard-layout {
        --tf-dashboard-layout-sidebar-basis: auto;
        --tf-dashboard-layout-sidebar-max-width: none;
        --tf-dashboard-layout-sidebar-min-width: none;
      }
      .debugger-section-title {
        font-size: 110%;
        font-weight: bold;
      }
      paper-tabs {
        color: #555;
        font-weight: normal;
      }
      paper-tab.iron-selected {
        color: black;
        font-weight: bold;
      }
      #initialDialog {
        /** This matches the default z-index of paper-dialog backdrops. */
        z-index: 102;
      }
      /** Resize the region for the graph as the user resizes the region. */
      #graph-container {
        height: calc(100% - 120px);
        /** Clip the minimap if the height of the graph container is small. */
        overflow: hidden;
        position: relative;
      }
      #graph {
        position: relative;
        display: block;
        width: 100%;
        height: 100%;
      }
      #tooltip-sorting {
        display: flex;
        font-size: 14px;
        margin-top: 5px;
      }
      #tooltip-sorting-label {
        margin-top: 13px;
      }
      #tooltip-sorting paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }
      #x-type-selector paper-button {
        margin: 5px 3px;
      }
      .runtime-graph-device {
        align-items: center;
        display: flex;
        flex-wrap: wrap;
      }
      #runtime-graph-device-name {
        font-size: 85%;
        word-break: break-all;
        display: inline-block;
      }
      #active-runtime-graph-device-name {
        font-size: 85%;
        width: 350px;
        display: inline-block;
      }
      #top-right-progress-bar {
        width: 100%;
        display: inline-block;
        vertical-align: middle;
      }
      .line-item {
        display: block;
        padding-top: 5px;
      }
      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }
      .sidebar {
        height: 100%;
        overflow-x: visible;
        position: relative;
      }
      .center {
        position: relative;
        height: 100%;
      }
      tf-debugger-resizer {
        right: -10px;
      }
      #center-content {
        position: absolute;
        right: 0;
      }
      /** The resizer should have no space to the left of it. */
      #center-content tf-debugger-resizer[is-horizontal] {
        margin-left: -23px;
      }
      .context-menu {
        position: absolute;
        display: none;
        background-color: #e2e2e2;
        border-radius: 2px;
        font-size: 14px;
        min-width: 150px;
        border: 1px solid #d4d4d4;
      }
      .spinner {
        width: 20px;
        height: 20px;
        vertical-align: middle;
      }
      .node-entries {
        box-shadow: 3px 3px #ddd;
        box-sizing: border-box;
        height: 80%;
        overflow: auto;
        padding-left: 3px;
        padding-right: 3px;
        padding-top: 3px;
        position: relative;
        vertical-align: top;
        width: 100%;
      }
      .source-code-view-div {
        position: relative;
        height: 40%;
        width: 100%;
        vertical-align: top;
        overflow: hidden;
        padding-top: 3px;
        padding-left: 3px;
        padding-right: 3px;
        box-shadow: 3px 3px #ddd;
      }
      #sessionRunsView {
        position: relative;
        width: 100%;
        overflow: auto;
        max-height: 25vh;
      }
      .buttons-container {
        padding: 20px 0;
      }
      #tensor-data {
        position: absolute;
        bottom: 0;
        left: 0;
        right: 0;
        padding: 20px 0;
        margin: 0 0 20px 0;
      }
      #tensorDataSummary {
        position: absolute;
        bottom: 0;
        left: 0;
        right: 0;
        top: 0;
      }
      #top-right-quadrant {
        height: 66%;
        overflow: auto;
      }
      .toggle-source-code {
        margin-right: 1em;
        font-size: 80%;
        float: right;
      }
      .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;
      }

      paper-input {
        width: 200px;
      }
      .inline,
      paper-item {
        display: inline;
      }

      vz-line-chart {
        height: 300px;
        position: relative;
      }
      [hidden] {
        display: none;
      }
    </style>
  </template>
  
  
</dom-module>











<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>




<dom-module id="paper-material">
  <template>
    <style include="paper-material-shared-styles"></style>
    <style>
      :host([animated]) {
        @apply --shadow-transition;
      }
      :host {
        @apply --paper-material;
      }
    </style>

    <slot></slot>
  </template>
</dom-module>













<dom-module id="tf-graph-debugger-data-card">
  <template>
    <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.
        
        <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.
        
      
    
  
  













<dom-module id="iron-list">
  <template>
    <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>

    </template></dom-module><div id="items">
      <slot></slot>
    </div>

  </template>
</paper-material></template></dom-module>













<dom-module id="paper-item-body">
  <template>
    <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>
  </template>

  
</dom-module>








<dom-module id="tf-graph-icon">
  <template>
    <style>
      :host {
        font-size: 0;
      }

      .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 height="0" width="0" id="svgDefs">
      <defs>
        
        <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" />
        </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" />
        </pattern>
        
        <ellipse id="op-node-stamp" rx="7.5" ry="3" stroke="inherit" fill="inherit" />
        
        <ellipse id="op-node-annotation-stamp" rx="5" ry="2" stroke="inherit" fill="inherit" />
        
        <g id="op-series-vertical-stamp">
          <use xlink:href="#op-node-stamp" x="8" y="9" />
          <use xlink:href="#op-node-stamp" x="8" y="6" />
          <use xlink:href="#op-node-stamp" x="8" y="3" />
        </g>
        <g id="op-series-horizontal-stamp">
          <use xlink:href="#op-node-stamp" x="16" y="4" />
          <use xlink:href="#op-node-stamp" x="12" y="4" />
          <use xlink:href="#op-node-stamp" x="8" y="4" />
        </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" />
        </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]]" />
      </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" />
      </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" />
      </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" />
      </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" />
        </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" />
        </svg>
      </template>
    </template>
  </template>

  
</dom-module>


<dom-module id="tf-node-icon">
  <template>
    <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>
  </template>

  
</dom-module>


<dom-module id="tf-graph-op-compat-list-item">
  <template>
    <style>
      #list-item {
        width: 100%;
        color: #565656;
        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>
  </template>

  
</dom-module>


<dom-module id="tf-graph-op-compat-card">
  <template>
    <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: #e9e9e9;
      }

      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 {
        font-size: 12pt;
        color: #5e5e5e;
      }

      .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;
      }

      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');" />
              </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>
  </template>

  
</dom-module>














<dom-module id="tf-node-list-item">
  <template>
    <style>
      #list-item {
        width: 100%;
        color: #565656;
        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>
        <span class="edge-label">[[edgeLabel]]</span>
      </div>
    </div>
  </template>

  
</dom-module>


<dom-module id="tf-node-info">
  <template>
    <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: #565656;
        font-size: 11pt;
        font-weight: 400;
      }

      .attr-right {
        margin-left: 30%;
        word-wrap: break-word;
        color: #565656;
        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: #565656;
        display: table-cell;
        font-size: 11pt;
        font-weight: 400;
        max-width: 200px;
        padding: 0 4px;
      }

      paper-item {
        padding: 0;
        background: #e9e9e9;
      }

      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 {
        font-size: 12pt;
        color: #5e5e5e;
      }

      .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" id="nodetitle"></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>
  </template>

  
</dom-module>


<dom-module id="tf-graph-info">
  <template>
    <style>
      :host {
        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]]" hierarchy-params="[[hierarchyParams]]" 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>
  </template>
  
</dom-module>




<dom-module id="tf-graph-board">
  <template>
    <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]]"></tf-graph>
      </div>
      <div id="info">
        <tf-graph-info id="graph-info" title="selected" graph-hierarchy="[[graphHierarchy]]" hierarchy-params="[[hierarchyParams]]" 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>
  </template>
</dom-module>























<dom-module id="paper-radio-button">
  <template strip-whitespace>
    <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>
  </template>

  
</dom-module>




<dom-module id="paper-radio-group">
  <template>
    <style>
      :host {
        display: inline-block;
      }

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

    <slot></slot>
  </template>
</dom-module>









<dom-module id="paper-tooltip">
  <template>
    <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>
  </template>

  
</dom-module>










<dom-module id="tf-graph-node-search">
  <template>
    <div id="search-container">
      <paper-input id="runs-regex" label="Search nodes. Regexes supported." 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>
  </template>
  
</dom-module>


<dom-module id="tf-graph-controls">
  <template>
    <style>
      :host {
        color: gray;
        display: flex;
        flex-direction: column;
        font-size: 12px;
        width: 100%;
      }

      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: 8px 0 8px 10px;
        }
      }

      .color-dropdown {
        --paper-input-container: {
          padding: 9px 0 0 13px;
        }
      }

      table {
        border-collapse: collapse;
        border-spacing: 0;
      }

      table td {
        padding: 0;
        margin: 0;
      }

      .allcontrols {
        padding: 0 20px 20px;
        flex-grow: 1;
        overflow-y: auto;
      }

      .legend-holder {
        background: #e9e9e9;
        border-top: 1px solid #ccc;
        box-sizing: border-box;
        color: #555;
        padding: 15px 20px;
        width: 100%;
      }

      .toggle-legend-button {
        max-height: 20px;
        max-width: 20px;
        padding: 0;
      }

      .toggle-legend-text {
        vertical-align: middle;
      }

      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: 16px;
        margin: 8px 5px 8px 0;
        color: black;
      }
      .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: 14px;
        margin: 0 -5px;
        padding: 5px;
      }

      .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 {
        height: 0px;
        width: 0px;
        overflow: hidden;
      }

      .allcontrols .control-holder {
        clear: both;
        display: flex;
        justify-content: space-between;
      }

      .allcontrols .control-holder paper-radio-group {
        margin-top: 5px;
      }

      span.counter {
        font-size: 13px;
        color: gray;
      }

      .runs 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;
      }

      /** 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>
        <a href="#" id="graphdownload" class="title" download="graph.png"></a>
      </div>
      <div class="control-holder runs">
        <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">
          <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>
      <template is="dom-if" if="[[showUploadButton]]">
        <div class="control-holder">
          <div class="title">Upload</div>
          <paper-button raised class="upload-button" on-click="_getFile" title="Upload a graph pbtxt file to view the graph">
            Choose File
          </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">
        <paper-radio-group selected="{{_selectedGraphType}}">
          
          <paper-radio-button name="op_graph" disabled="[[_getSelectionOpGraphDisabled(datasets, _selectedRunIndex, _selectedTagIndex)]]">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="control-holder">
        <div>
          <paper-toggle-button checked="{{traceInputs}}" class="title">
            Trace inputs
          </paper-toggle-button>
        </div>
      </div>
      <template is="dom-if" if="[[healthPillsFeatureEnabled]]">
        <div class="control-holder">
          <paper-toggle-button checked="{{healthPillsToggledOn}}" class="title">Show health pills</paper-toggle-button>
        </div>
      </template>
      <div class="control-holder">
        <div class="title">Color</div>
        <paper-radio-group selected="{{colorBy}}">
          <paper-radio-button name="structure">Structure</paper-radio-button>

          <paper-radio-button name="device">Device</paper-radio-button>

          <paper-radio-button id="xla-cluster-radio-button" name="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="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="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="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>
        <template is="dom-if" if="[[_isGradientColoring(stats, colorBy)]]">
          <svg width="140" height="20" style="margin: 0 5px" class="color-text">
            <defs>
              <lineargradient id="linearGradient" x1="0%" y1="0%" x2="100%" y2="0%">
                <stop class="start" offset="0%" stop-color$="[[_currentGradientParams.startColor]]" />
                <stop class="end" offset="100%" stop-color$="[[_currentGradientParams.endColor]]" />
              </lineargradient>
            </defs>
            <rect x="0" y="0" width="135" height="20" fill="url(#linearGradient)" stroke="black" />
          </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]]" />
                </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" />
              </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>
    </div>
    <div class="legend-holder">
      <paper-icon-button icon="[[_getToggleLegendIcon(_legendOpened)]]" on-click="_toggleLegendOpen" class="toggle-legend-button">
      </paper-icon-button>
      <span class="toggle-legend-text">
        [[_getToggleText(_legendOpened)]]
      </span>
      <iron-collapse opened="[[_legendOpened]]">
        <div>
          <table>
            <tr>
              <td><div class="title">Graph</div></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" />
                </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" />
                    </marker>
                  </defs>
                  <path marker-end="url(#dataflow-arrowhead-legend)" stroke="#bbb" d="M2 9 l 29 0" stroke-linecap="round" />
                </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" />
                </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" />
                    </marker>
                  </defs>
                  <path marker-end="url(#reference-arrowhead-legend)" stroke="#FFB74D" d="M2 9 l 29 0" stroke-linecap="round" />
                </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>
          </table>
        </div>
      </iron-collapse>
    </div>
  </template>
</dom-module>















<dom-module id="tf-graph-dashboard">
  <template>
    <paper-dialog id="error-dialog" with-backdrop></paper-dialog>
    <template is="dom-if" if="[[_datasetsState(_datasetsFetched, _datasets, 'EMPTY')]]">
      <div style="max-width: 540px; margin: 80px auto 0 auto;">
        <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/get_started/graph_viz">graph visualizer tutorial</a>.
        

        <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>
          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.
        
      </div>
    </template>
    <template is="dom-if" if="[[_datasetsState(_datasetsFetched, _datasets, 'PRESENT')]]">
      <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}}"></tf-graph-controls>
        <div class="center" 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>
          <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]]"></tf-graph-board>
        </div>
      </tf-dashboard-layout>
    </template>
    <style>
      :host /deep/ {
        font-family: 'Roboto', sans-serif;
      }

      .sidebar {
        display: flex;
        height: 100%;
      }

      .center {
        position: relative;
        height: 100%;
      }

      paper-dialog {
        padding: 20px;
      }
    </style>
  </template>
</dom-module>



























<dom-module id="vz-distribution-chart">
  <template>
    <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;
      }
    </style>
  </template>
  
</dom-module>



<dom-module id="tf-distribution-loader">
  <template>
    <tf-card-heading tag="[[tag]]" run="[[run]]" display-name="[[tagMetadata.displayName]]" description="[[tagMetadata.description]]" color="[[_runColor]]"></tf-card-heading>
    
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-distribution-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <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 class="sidebar-section">
          <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:
            <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>
              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.
            
          </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>
  </template>

  
</dom-module>

























<dom-module id="vz-histogram-timeseries">
  <template>
    <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 {
        display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 1;
        position: relative;
      }

      svg {
        font-family: roboto, sans-serif;
        overflow: visible;
        display: block;
        width: 100%;
        flex-grow: 1;
        flex-shrink: 1;
      }

      #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: black !important;
      }

      .hover.hover-closest text {
        opacity: 1;
      }

      .baseline {
        stroke: black;
        stroke-opacity: 0.1;
      }

      .outline {
        fill: none;
        stroke: white;
        stroke-opacity: 0.5;
      }

      .outline.outline-hover {
        stroke: black !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: black;
      }

      .x-axis-hover rect,
      .y-axis-hover rect,
      .y-slice-axis-hover rect {
        fill: white;
      }

      .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>
  </template>

  
</dom-module>







<dom-module id="tf-histogram-loader">
  <template>
    <tf-card-heading tag="[[tag]]" run="[[run]]" display-name="[[tagMetadata.displayName]]" description="[[tagMetadata.description]]" color="[[_runColor]]"></tf-card-heading>
    
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-histogram-dashboard">
  <template>
    <tf-dashboard-layout>
      <div slot="sidebar">
        <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 class="sidebar-section">
          <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:
            <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>
              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.
            
          </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>
  </template>

  
</dom-module>























<dom-module id="tf-text-loader">
  <template>
    <tf-card-heading run="[[run]]" tag="[[tag]]" color="[[_runColor]]">
    </tf-card-heading>
    <paper-material elevation="1" id="steps-container" class="container scrollbar" style="border-color: [[_runColor]]">
      <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;
      }
      .text {
        background-color: white;
        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 #ccc;
        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>
  </template>
  
</dom-module>



<dom-module id="tf-text-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <div class="sidebar-section">
          <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:
            <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>
              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.
            
          </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]]"></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>
  </template>
  
</dom-module>

























<dom-module id="tf-pr-curve-card">
  <template>
    <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]]" get-data-load-url="[[_dataUrl]]" 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>
  </template>
  
</dom-module>








<dom-module id="tf-pr-curve-steps-selector">
  <template>
    <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>
  </template>
  
</dom-module>



<dom-module id="tf-pr-curve-dashboard">
  <template>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <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 class="sidebar-section">
          <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:
            <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>
              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.
            
          </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]]"></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: 40%;
        overflow-y: auto;
      }
    </style>
  </template>

  
</dom-module>





<dom-module id="tf-profile-redirect-dashboard">
  <template>
    <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:
      
      <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>
      .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>
  </template>

  
</dom-module>













<dom-module id="tf-plugin-dialog">
  <template>
    
    <template is="dom-if" if="[[_open]]">
      <div id="dashboard-backdrop"></div>
    </template>
    <paper-dialog id="dialog" modal opened="{{_open}}" with-backdrop="[[_useNativeBackdrop]]">
      <h2 id="dialog-title">[[_title]]</h2>
      <div class="custom-message">[[_customMessage]]</div>
    </paper-dialog>
    <style>
      /** We rely on a separate `_hidden` property instead of directly making use
          of the `_open` attribute because this CSS specification may strangely
          affect other elements throughout TensorBoard. See #899. */
      #dashboard-backdrop {
        background: rgba(0, 0, 0, 0.6);
        width: 100%;
        height: 100%;
      }

      #dialog-title {
        padding-bottom: 15px;
      }

      .custom-message {
        margin-top: 0;
        margin-bottom: 15px;
      }
    </style>
  </template>
  
</dom-module>





<dom-module id="tf-beholder-video">
  <template>
    <div id="container">
      <img id="video" src$="[[_imageURL]]">
    </div>

    <style>
      img {
        image-rendering: pixelated;
        margin-right: 10px;
      }
    </style>
  </template>

  
</dom-module>




<dom-module id="tf-beholder-info">
  <template>
    <template is="dom-repeat" items="[[_items]]">
      <div class="section-info" style$="height: [[item.height]]px">
        <ul>
          <li>[[item.name]]</li>
          <li>shape: [[item.shape]]</li>
          <li>range: [ [[item.min]], [[item.max]] ]</li>
          <li>mean: [[item.mean]]</li>
        </ul>
      </div>
    </template>

    <style>
      .section-info {
        margin: 0 0 5px 0;
      }
      .section-info ul {
        list-style-type: none;
        margin: 0;
        padding-left: 10px;
      }
    </style>
  </template>

  
</dom-module>


<dom-module id="tf-beholder-dashboard">
  <template>
    <tf-plugin-dialog id="initialDialog"></tf-plugin-dialog>
    <tf-dashboard-layout>
      <div class="sidebar" slot="sidebar">
        <template is="dom-if" if="[[_controls_disabled]]">
          <div class="sidebar-section">
            <p class="controls-disabled-message">
              Controls disabled: directory is not writeable.
            
            <p class="disclaimer">
              Beholder requires write access to the log directory in order to
              communicate visualization changes to the <code>Beholder</code>
              instance in your model.
            
          </div>
        </template>
        <div class="sidebar-section">
          <h3>Values</h3>
          <paper-radio-group id="valuesSelector" selected="{{_values}}">
            <paper-radio-button name="trainable_variables" disabled="[[_controls_disabled]]">
              <pre>tf.trainable_variables()</pre>
            </paper-radio-button>
            <paper-radio-button id="option-arrays" name="arrays" disabled="[[_controls_disabled]]">
              <pre>b.update(arrays=[NP_ARRAYS])</pre>
            </paper-radio-button>
            <paper-radio-button id="option-frames" name="frames" disabled="[[_controls_disabled]]">
              <pre>b.update(frame=NP_ARRAY)</pre>
            </paper-radio-button>
          </paper-radio-group>

          <template is="dom-if" if="[[_valuesNotFrame(_values)]]">
            <paper-checkbox checked="{{_showAll}}" disabled="[[_controls_disabled]]">Show all data <i>(can be resource intensive)</i></paper-checkbox>
          </template>
        </div>

        <template is="dom-if" if="[[_valuesNotFrame(_values)]]">
          <div class="sidebar-section">
            <h3>Mode</h3>
            <paper-radio-group id="modeSelector" selected="{{_mode}}">
              <paper-radio-button name="current" disabled="[[_controls_disabled]]">
                current values
              </paper-radio-button>
              <paper-radio-button name="variance" disabled="[[_controls_disabled]]">
                variance over train steps
              </paper-radio-button>
            </paper-radio-group>
            <template is="dom-if" if="[[_varianceSelected(_mode)]]">
              <h4>Variance timesteps: {{_windowSize}}</h4>
              <paper-slider id="windowSlider" value="{{_windowSize}}" type="number" step="1" min="2" max="20" pin="true" disabled="[[_controls_disabled]]">
              </paper-slider>
            </template>
          </div>

          <div class="sidebar-section">
            <h3>Image scaling</h3>
            <paper-radio-group id="scalingSelector" selected="{{_scaling}}">
              <paper-radio-button id="option-layer" name="layer" disabled="[[_controls_disabled]]">
                per section
              </paper-radio-button>
              <paper-tooltip for="option-layer" position="right">
                Black is the lowest value in that section, white is that largest
                value in that section.
              </paper-tooltip>

              <paper-radio-button id="option-network" name="network" disabled="[[_controls_disabled]]">
                all sections
              </paper-radio-button>
              <paper-tooltip for="option-network" position="right">
                Black is the smallest value in all sections, white is the
                largest value in all sections.
              </paper-tooltip>
            </paper-radio-group>

            <div id="colormap-selection">
              <div id="colormap-selection-label">Colormap:</div>
              <paper-dropdown-menu no-label-float selected-item-label="{{_colormap}}" disabled="[[_controls_disabled]]">
                <paper-listbox slot="dropdown-content" selected="0">
                  <paper-item>magma</paper-item>
                  <paper-item>inferno</paper-item>
                  <paper-item>plasma</paper-item>
                  <paper-item>viridis</paper-item>
                  <paper-item>grayscale</paper-item>
                </paper-listbox>
              </paper-dropdown-menu>
            </div>
          </div>
        </template>

        <div class="sidebar-section">
          <h3>Updates per second: {{_FPS}}</h3>
          <paper-slider id="FPSSlider" value="{{_FPS}}" type="number" step="1" min="0" max="30" pin="true" disabled="[[_controls_disabled]]">
          </paper-slider>
        </div>

        <div class="sidebar-section">
          <div>
            <paper-button class="x-button" id="record_button" on-tap="_toggleRecord" disabled="[[_controls_disabled]]">
              [[_recordText]]
            </paper-button>
          </div>
        </div>

        <div class="sidebar-section">
          <p class="disclaimer">
            Note: Beholder currently only works well on local file systems.
          
        </div>
      </div>
      <div class="center" slot="center">
        <template is="dom-if" if="[[!_is_active]]">
          <div class="no-data-warning">
            <h3>No Beholder data was found.</h3>

            <p>Probable causes:
            <ul>
              <li>Your script isn't running.</li>
              <li>You aren't calling <code>beholder.update()</code>.</li>
            </ul>

            <p>
              To use Beholder, import and instantiate the
              <code>Beholder</code> class, and call its
              <code>update</code> method with a <code>Session</code> argument
              after every train step:
            

            <pre>from tensorboard.plugins.beholder import Beholder
beholder = Beholder(LOG_DIRECTORY)

# inside train loop
beholder.update(
  session=sess,
  arrays=list_of_np_arrays,  # optional argument
  frame=two_dimensional_np_array,  # optional argument
)</pre>
            <p>
              If using <code>tf.train.MonitoredSession</code>, you can use
              <code>BeholderHook</code>:
            

            <pre>from tensorboard.plugins.beholder import BeholderHook
beholder_hook = BeholderHook(LOG_DIRECTORY)
with MonitoredSession(..., hooks=[beholder_hook]) as sess:
  sess.run(train_op)</pre>

            <p>
              If you think everything is set up properly, please see
              <a href="https://github.com/tensorflow/tensorboard/blob/master/tensorboard/plugins/beholder/README.md">the README</a>
              for more information and consider filing an issue on GitHub.
            

            <p class="disclaimer">
              Note: Beholder currently only works well on local file systems.
            
          </div>
        </template>

        <template is="dom-if" if="[[_is_active]]">
          <tf-beholder-video id="video" fps="[[_FPS]]"></tf-beholder-video>

          <template is="dom-if" if="[[_valuesNotFrame(_values)]]">
            <tf-beholder-info id="info" fps="[[_FPS]]"> </tf-beholder-info>
          </template>
        </template>
      </div>
    </tf-dashboard-layout>
    <style include="dashboard-style"></style>
    <style>
      .center {
        height: 100%;
        display: flex;
        padding: 0;
      }

      .no-data-warning {
        max-width: 540px;
        margin: 80px auto 0;
      }

      paper-checkbox {
        display: block;
        padding: 4px;
      }

      paper-radio-button {
        display: flex;
        padding: 5px;

        --paper-radio-button-radio-container: {
          flex-grow: 0;
          flex-shrink: 0;
        }

        --paper-radio-button-label: {
          font-size: 13px;
          overflow: hidden;
          text-overflow: ellipsis;
        }
      }

      paper-radio-group {
        margin-top: 5px;
        width: 100%;
      }

      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;
      }

      pre {
        display: inline;
      }

      paper-button#record_button {
        color: #d32f2f;
      }

      paper-button#record_button.is-recording {
        background: #d32f2f;
        color: white;
      }

      .sidebar-section.beholder-dashboard:last-child {
        flex-grow: 0;
      }

      #colormap-selection {
        display: flex;
        margin-top: 5px;
      }

      #colormap-selection-label {
        margin-top: 13px;
      }

      #colormap-selection paper-dropdown-menu {
        margin-left: 10px;
        --paper-input-container-focus-color: var(--tb-orange-strong);
        width: 105px;
      }

      h4 {
        font-size: 14px;
        font-weight: normal;
        margin: 5px 0;
      }

      p.disclaimer {
        color: #999;
        font-style: italic;
      }

      p.controls-disabled-message {
        color: #c00;
        font-weight: bold;
      }

      .sidebar {
        font-size: 14px;
      }
    </style>
  </template>
  
</dom-module>




















<dom-module id="vaadin-split-layout">
  <template>
    <style>
      :host {
        display: flex;
        overflow: hidden !important;
        transform: translateZ(0);
      }

      :host([vertical]) {
        flex-direction: column;
      }

      :host ::slotted(*) {
        flex: 1 1 auto;
        overflow: auto;
      }

      :host > #splitter {
        flex: none;
        position: relative;
        z-index: 1;
        overflow: visible;
        min-width: 8px;
        min-height: 8px;
        background: var(--divider-color, #ccc);
        fill: var(--primary-background-color, #fff);
        @apply --vaadin-split-layout-splitter;
      }

      :host(:not([vertical])) > #splitter {
        cursor: ew-resize;
      }

      :host([vertical]) > #splitter {
        cursor: ns-resize;
      }

      #handle,
      #splitter ::slotted([slot=handle]) {
        position: absolute;
        top: 50%;
        left: 50%;
        transform: translate(-50%, -50%);
      }

      :host([vertical]) > #splitter #handle {
        transform: translate(-50%, -50%) rotate(90deg);
      }
    </style>
    <slot id="primary" name="primary"></slot>
    <div id="splitter" on-track="_onHandleTrack" on-down="_preventDefault">
      <slot name="handle">
        <svg id="handle" width="40" height="40">
          <rect x="19" y="8" width="2" height="24"></rect>
        </svg>
      </slot>
    </div>
    <slot id="secondary" name="secondary"></slot>
  </template>

  
</dom-module>




<dom-module id="tf-hparams-query-pane">
  <template>
    <div class="pane">
      <vaadin-split-layout vertical>
        <vaadin-split-layout vertical id="hyperparameters-metrics-statuses">
          <vaadin-split-layout vertical id="hyperparameters-metrics">
            <div 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>
                  
                  
                  <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>
                  
                  <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>
                  
                  <template is="dom-if" if="[[hparam.filter.regexp]]">
                    <paper-input label="Regular expression" value="{{hparam.filter.regexp}}" on-value-changed="_queryServer">
                    </paper-input>
                  </template>
                </div>
              </template>
            </div>
            <div class="section metrics">
              <div class="section-title">Metrics</div>
              <template is="dom-repeat" items="{{_metrics}}" as="metric">
                <div class="metric">
                  
                  <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>
          </vaadin-split-layout>
          <div 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>
        </vaadin-split-layout>
        <vaadin-split-layout vertical id="sorting-paging">
          <div 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>
          <vaadin-split-layout vertical id="paging-download">
            <div 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 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>
          </vaadin-split-layout>
        </vaadin-split-layout>
      </vaadin-split-layout>
    </div>
    <style>
      .pane {
        display: flex;
        flex-direction: column;
        height: 100%;
      }
      .section {
        margin: 5px 10px 5px 10px;
        overflow-y: auto;
      }
      .section-title {
        display: block;
        font-weight: bold;
        text-decoration: underline;
        margin-bottom: 7px;
      }
      #hyperparameters-metrics-statuses {
        flex-basis: 70%;
        flex-shrink: 1;
        flex-grow: 1;
      }
      #hyperparameters-metrics {
        flex-basis: 90%;
        flex-shrink: 1;
        flex-grow: 1;
      }
      .hyperparameters {
        flex-basis: auto;
        flex-shrink: 1;
        flex-grow: 1;
      }
      .metrics {
        flex-basis: auto;
        flex-shrink: 1;
        flex-grow: 1;
      }
      .statuses {
        flex-basis: auto;
        flex-shrink: 0;
        flex-grow: 0;
      }
      #sorting-paging {
        flex-basis: 30%;
        flex-shrink: 0;
        flex-grow: 0;
      }
      #paging-download {
        flex-basis: 90%;
        flex-shrink: 1;
        flex-grow: 1;
      }
      .sorting {
        flex-basis: auto;
        flex-shrink: 0;
        flex-grow: 0;
      }
      .paging {
        flex-basis: auto;
        flex-shrink: 0;
        flex-grow: 0;
      }
      .download {
        flex-basis: auto;
        flex-shrink: 0;
        flex-grow: 0;
      }
      .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>
  </template>
  
</dom-module>







<dom-module id="iron-pages">

  <template>
    <style>
      :host {
        display: block;
      }

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

    <slot></slot>
  </template>

  
</dom-module>







<dom-module id="paper-header-panel">
  <template>
    <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>
  </template>

  
</dom-module>










<dom-module id="paper-tab">
  <template>
    <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;
      }

      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>
  </template>

  
</dom-module>










<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" /></g>
<g id="chevron-right"><path d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z" /></g>
</defs></svg>
</iron-iconset-svg>





<dom-module id="paper-tabs">
  <template>
    <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>

  </template>

  
</dom-module>








<dom-module id="paper-toolbar">
  <template>
    <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>
  </template>

  
</dom-module>











<dom-module id="tf-hparams-scale-and-color-controls">
  <template>
    <div class="control-panel">
      
      <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>

      
      <div class="columns-container">
        
        <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>
                  
                  <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>
  </template>

  
</dom-module>












<dom-module id="vaadin-grid-active-item-themability-styles">
  <template>
    <style>
      vaadin-grid-table .vaadin-grid-row[active] .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        @apply(--vaadin-grid-body-row-active-cell);
      }
    </style>
  </template>
</dom-module>





<dom-module id="vaadin-grid-table-table-scroll-styles">
  <template>
    <style>
      #table {
        position: relative;
        overflow: auto;
        -webkit-overflow-scrolling: touch;
        z-index: -2;
      }

      vaadin-grid-table[ios] #table {
        transform: none;
      }

      vaadin-grid-table[fixed-sections] #table {
        transform: none;
      }
    </style>
  </template>
</dom-module>

<dom-module id="vaadin-grid-table-scroll-styles">
  <template>
    <style>
      vaadin-grid-table {
        transform: translateZ(0);
      }

      vaadin-grid-table-header {
        position: absolute;
        top: 0;
        width: 100%;
      }

      vaadin-grid-table-footer {
        position: absolute;
        bottom: 0;
        width: 100%;
      }

      vaadin-grid-table-body {
        z-index: -1;
      }

      vaadin-grid-table[fixed-sections] {
        /* Any value other than ‘none’ for the transform results in the creation of both a stacking context and
        a containing block. The object acts as a containing block for fixed positioned descendants. */
        transform: translateZ(0);
        overflow: hidden;
      }

      vaadin-grid-table[fixed-sections] vaadin-grid-table-header,
      vaadin-grid-table[fixed-sections] vaadin-grid-table-footer {
        position: fixed;
      }

      vaadin-grid-table[fixed-sections] vaadin-grid-table-body#items {
        position: fixed;
        width: 100%;
        will-change: transform;
      }
    </style>
  </template>
</dom-module>









<dom-module id="vaadin-grid-table-cell"></dom-module>
<dom-module id="vaadin-grid-table-header-cell"></dom-module>
<dom-module id="vaadin-grid-table-footer-cell"></dom-module>
<dom-module id="vaadin-grid-sizer-cell"></dom-module>




<dom-module id="vaadin-grid-sizer">
  <template>
    <style>
      :host {
        display: flex;
        visibility: hidden;
      }

      .cell {
        display: block;
        flex-shrink: 0;
        line-height: 0;
        font-size: 1px;
        margin-top: -1em;
      }

      .cell[hidden] {
        display: none;
      }
    </style>

    <template is="dom-repeat" items="[[_columns]]" as="column">
      <vaadin-grid-sizer-cell class="cell" column="[[column]]">&nbsp;</vaadin-grid-sizer-cell>
    </template>

  </template>
  
</dom-module>


<dom-module id="vaadin-grid-table-outer-scroller">
  <template>
    <style>
      :host {
        display: block;
        height: 100%;
        width: 100%;
        position: absolute;
        top: 0;
        box-sizing: border-box;
        overflow: auto;
      }

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

      :host([ios]) {
        pointer-events: all;
        z-index: -3;
      }

      :host([ios][scrolling]) {
        z-index: 0;
      }
    </style>

    <slot></slot>

  </template>
  
</dom-module>









<dom-module id="vaadin-grid-table-focus-trap">
  <template>
    <style>
     :host {
       position: absolute;
       z-index: -3;
       height: 0;
       overflow: hidden;
     }

     :host(:focus),
     .primary:focus,
     ::slotted(.primary:focus),
     .secondary:focus,
     ::slotted(.secondary:focus) {
       outline: none;
     }
    </style>

    
    <div class="primary" tabindex="0" role="gridcell" on-focus="_onBaitFocus" on-blur="_onBaitBlur"><div aria-hidden="true">&nbsp;</div></div>
    <div class="secondary" tabindex="-1" role="gridcell" on-focus="_onBaitFocus" on-blur="_onBaitBlur"><div aria-hidden="true">&nbsp;</div></div>

    <slot></slot>
  </template>
  
</dom-module>



<dom-module id="vaadin-grid-table-row"></dom-module>
<dom-module id="vaadin-grid-table-header-row"></dom-module>








<dom-module id="vaadin-grid-row-details-styles">
  <template>
    <style>
      [detailscell] {
        position: absolute;
        bottom: 0;
        left: 0;
        width: 100%;
      }
    </style>
  </template>
</dom-module>
<dom-module id="vaadin-grid-row-details-themability-styles">
  <template>
    <style>
      .vaadin-grid-cell[detailscell] ::slotted(vaadin-grid-cell-content) {
        background: #fff;
        @apply(--vaadin-grid-body-row-details-cell);
      }
    </style>
  </template>
</dom-module>




<dom-module id="vaadin-grid-data-provider-themability-styles">
  <template>
    <style>

      /* Anim */
      @keyframes vaadin-grid-spin-360 {
        100% {
          transform: rotate(360deg);
        }
      }
      @-webkit-keyframes vaadin-grid-spin-360 {
        100% {
          -webkit-transform: rotate(360deg);
          transform: rotate(360deg);
        }
      }

      #spinner {
        border: 2px solid var(--primary-color, #03A9F4);
        border-radius: 50%;
        border-right-color: transparent;
        border-top-color: transparent;
        content: "";
        height: 16px;
        left: 50%;
        margin-left: -8px;
        margin-top: -8px;
        position: absolute;
        top: 50%;
        width: 16px;
        pointer-events: none;
        opacity: 0;
        @apply(--vaadin-grid-loading-spinner);
      }

      :host([loading]) #spinner {
        opacity: 1;
        -webkit-animation: vaadin-grid-spin-360 400ms linear infinite;
        animation: vaadin-grid-spin-360 400ms linear infinite;
      }

      :host([loading]) #items {
        opacity: 0.5;
      }

    </style>
  </template>
</dom-module>






<dom-module id="vaadin-grid-selection-themability-styles">
  <template>
    <style>
      vaadin-grid-table .vaadin-grid-row[selected] .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        background-color: var(--paper-grey-100, rgb(243, 243, 243));
        @apply(--vaadin-grid-body-row-selected-cell);
      }
    </style>
  </template>
</dom-module>




<dom-module id="vaadin-grid-navigation-themability-styles">
  <template>
    <style>
      :host(:focus),
      #table:focus {
        outline: none;
      }

      :host([navigating]:not([interacting])) [focused] > .vaadin-grid-row[focused] > [focused] ::slotted(vaadin-grid-cell-content) {
        box-shadow: inset 0 0 0 3px rgba(0, 0, 0, 0.3);
        @apply(--vaadin-grid-focused-cell);
      }
    </style>
  </template>
</dom-module>



<dom-module id="vaadin-grid-column-reordering-themability-styles">
  <template>
    <style>
      vaadin-grid-table[reordering] .vaadin-grid-cell {
        background: #000;
      }

      :host([reordering]) .vaadin-grid-cell[reorder-status="dragging"] {
        background: var(--primary-color, #000);
      }

      vaadin-grid-table[reordering] .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        transition: opacity 300ms;
        transform: translateZ(0);
        opacity: 0.8;
      }

      #scroller .vaadin-grid-cell[reorder-status="allowed"] ::slotted(vaadin-grid-cell-content) {
        opacity: 1;
      }

      #scroller .vaadin-grid-cell[reorder-status="dragging"] {
        background: var(--primary-color, #000);
      }

      #scroller .vaadin-grid-cell[reorder-status="dragging"] ::slotted(vaadin-grid-cell-content) {
        opacity: 0.95;
      }
    </style>
  </template>
</dom-module>









<dom-module id="vaadin-grid-table-styles">
  <template>
    <style>

      @keyframes appear {
        to {
          opacity: 1;
        }
      }

      vaadin-grid-table {
        display: block;
        position: relative;
        animation: 1ms appear;
      }

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

      #items {
        position: relative;
      }

      #items {
        border-top: 0 solid transparent;
        border-bottom: 0 solid transparent;
      }

      #items > .vaadin-grid-row {
        box-sizing: border-box;
        margin: 0;
        position: absolute;
      }

      vaadin-grid-table-body {
        display: block;
      }

      vaadin-grid-table-header .vaadin-grid-cell,
      vaadin-grid-table-footer .vaadin-grid-cell {
        top: 0;
      }

      .vaadin-grid-cell {
        padding: 0;
        flex-shrink: 0;
        flex-grow: 1;
        box-sizing: border-box;
        display: flex;
      }

      .vaadin-grid-cell:not([detailscell]) {
        position: relative;
      }

      .vaadin-grid-cell ::slotted(vaadin-grid-cell-content) {
         width: 100%;
         display: inline-flex;
         justify-content: center;
         flex-direction: column;
         white-space: nowrap;
         overflow: hidden;
      }

      .vaadin-grid-column-resize-handle {
        position: absolute;
        right: 0;
        height: 100%;
        cursor: col-resize;
        z-index: 1;
      }

      .vaadin-grid-column-resize-handle::before {
        position: absolute;
        content: "";
        height: 100%;
        width: 35px;
        transform: translateX(-50%);
      }

      [lastcolumn] .vaadin-grid-column-resize-handle::before,
      [last-frozen] .vaadin-grid-column-resize-handle::before {
        width: 18px;
        transform: translateX(-100%);
      }

      vaadin-grid-table[column-reordering-allowed] #header,
      vaadin-grid-table[column-resizing] {
        -ms-user-select: none;
        -moz-user-select: none;
        -webkit-user-select: none;
        user-select: none;
      }

      vaadin-grid-table[column-resizing] {
        cursor: col-resize;
      }

      .vaadin-grid-row:not([hidden]) {
        display: flex;
        width: 100%;
      }

      [frozen] {
        z-index: 2;
      }

      [hidden] {
        display: none;
      }

      vaadin-grid-table[no-content-pointer-events] .vaadin-grid-cell ::slotted(vaadin-grid-cell-content) {
        pointer-events: none;
      }
    </style>
  </template>
</dom-module>

<dom-module id="vaadin-grid-table-table-styles">
  <template>
    <style>
      :host([ios][column-resizing]) #outerscroller {
        overflow: hidden;
      }

      #fixedsizer,
      #outersizer {
        border-top: 0 solid transparent;
        border-bottom: 0 solid transparent;
      }

      #table {
        height: 100%;
        width: 100%;
        display: block;
        overflow: auto;
        box-sizing: border-box;
      }

      #table[overflow-hidden],
      #outerscroller[overflow-hidden] {
        overflow: hidden;
      }

      vaadin-grid-sizer {
        position: relative;
        width: 100%;
      }

      #sizerwrapper {
        position: absolute;
        width: 100%;
        z-index: -100;
      }

      #reorderghost {
        visibility: hidden;
        position: fixed;
        opacity: 0.5;
        pointer-events: none;
      }

      ::slotted(vaadin-grid-column),
      ::slotted(vaadin-grid-selection-column),
      ::slotted(vaadin-grid-column-group) {
        display: none;
      }

    </style>
  </template>
</dom-module>

<dom-module id="vaadin-grid-table-themability-styles">
  <template>
    <style>

      /* Default borders */
      vaadin-grid-table-header .vaadin-grid-row:last-child .vaadin-grid-cell ::slotted(vaadin-grid-cell-content) {
        border-bottom: 1px solid var(--divider-color, rgba(0, 0, 0, 0.08));
      }

      vaadin-grid-table-footer .vaadin-grid-row:first-child .vaadin-grid-cell ::slotted(vaadin-grid-cell-content) {
        border-top: 1px solid var(--divider-color, rgba(0, 0, 0, 0.08));
      }

      vaadin-grid-table-body .vaadin-grid-row:not([lastrow]) .vaadin-grid-cell ::slotted(vaadin-grid-cell-content) {
        border-bottom: 1px solid var(--divider-color, rgba(0, 0, 0, 0.08));
      }

      [last-frozen] ::slotted(vaadin-grid-cell-content) {
        border-right: 1px solid var(--divider-color, rgba(0, 0, 0, 0.08));
      }

      /* Column resize handle */

      .vaadin-grid-column-resize-handle {
        border-right: 1px solid var(--divider-color, rgba(0, 0, 0, 0.08));
        @apply(--vaadin-grid-column-resize-handle);
      }

      /* Cells */
      vaadin-grid-table .vaadin-grid-row .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        background: #fff;
        text-align: left;
        padding: 8px;
        box-sizing: border-box;
        @apply(--vaadin-grid-cell);
      }

      vaadin-grid-table-header .vaadin-grid-row .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        font-weight: 500;
        @apply(--vaadin-grid-header-cell);
      }

      vaadin-grid-table-footer .vaadin-grid-row .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        font-weight: 500;
        @apply(--vaadin-grid-footer-cell);
      }

      vaadin-grid-table-body .vaadin-grid-row .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        @apply(--vaadin-grid-body-cell);
      }

      vaadin-grid-table-body [odd] .vaadin-grid-cell:not([detailscell]) ::slotted(vaadin-grid-cell-content) {
        @apply(--vaadin-grid-body-row-odd-cell);
      }

      vaadin-grid-table .vaadin-grid-row .vaadin-grid-cell:not([detailscell])[last-frozen] ::slotted(vaadin-grid-cell-content) {
        @apply(--vaadin-grid-cell-last-frozen);
      }

      vaadin-grid-table:not([scrolling]) vaadin-grid-table-body .vaadin-grid-row:hover .vaadin-grid-cell ::slotted(vaadin-grid-cell-content) {
        @apply(--vaadin-grid-body-row-hover-cell);
      }

      vaadin-grid-table .vaadin-grid-row .vaadin-grid-cell.vaadin-grid-cell[lastcolumn] ::slotted(vaadin-grid-cell-content) {
        border-right: none;
      }

    </style>
  </template>
</dom-module>

<dom-module id="vaadin-grid-table">
  <template>
      <style include="vaadin-grid-table-table-scroll-styles"></style>
      <style include="vaadin-grid-table-table-styles"></style>

      <style include="vaadin-grid-data-provider-themability-styles"></style>

      <div id="spinner"></div>
      <div id="table" tabindex="-1" overflow-hidden$="[[_hideTableOverflow(scrollbarWidth, safari)]]">
        <div id="sizerwrapper">
          <vaadin-grid-sizer id="fixedsizer" top="[[_estScrollHeight]]" column-tree="[[columnTree]]"></vaadin-grid-sizer>
        </div>
        <slot name="header"></slot>
        <slot name="items"></slot>
        <slot name="footer"></slot>
      </div>

      <div id="reorderghost"></div>
      <vaadin-grid-table-outer-scroller id="outerscroller" scroll-target="[[scrollTarget]]" overflow-hidden$="[[_hideOuterScroller(scrollbarWidth, safari)]]" ios$="[[ios]]" scrolling$="[[scrolling]]">
      <vaadin-grid-sizer id="outersizer" top="[[_estScrollHeight]]" column-tree="[[columnTree]]"></vaadin-grid-sizer>
    </vaadin-grid-table-outer-scroller>
    <slot></slot>
    <slot name="footerFocusTrap"></slot>
  </template>
</dom-module>








<dom-module id="vaadin-grid-column">
  
</dom-module>















<dom-module id="vaadin-grid">
  <template>
    <style>
      :host {
        display: block;
        height: 400px;
        background: var(--primary-background-color, #fff);
        box-sizing: border-box;
        border: 1px solid var(--divider-color, rgba(0, 0, 0, 0.08));
      }

      :host(:focus) {
        -webkit-tap-highlight-color: transparent;
      }

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

      #scroller {
        height: 100%;
        width: 100%;
      }
    </style>

    <style include="vaadin-grid-table-scroll-styles"></style>
    <style include="vaadin-grid-row-details-styles"></style>
    <style include="vaadin-grid-table-styles"></style>

    <style include="vaadin-grid-table-themability-styles"></style>
    <style include="vaadin-grid-selection-themability-styles"></style>
    <style include="vaadin-grid-navigation-themability-styles"></style>
    <style include="vaadin-grid-active-item-themability-styles"></style>
    <style include="vaadin-grid-row-details-themability-styles"></style>
    <style include="vaadin-grid-column-reordering-themability-styles"></style>

    <vaadin-grid-table id="scroller" loading$="[[_loading]]" bind-data="[[_bindData]]" size="[[size]]" column-tree="[[_columnTree]]" row-details-template="[[_rowDetailsTemplate]]" column-reordering-allowed="[[columnReorderingAllowed]]">
      <vaadin-grid-table-header id="header" slot="header" target="[[_getContentTarget()]]" column-tree="[[_columnTree]]"></vaadin-grid-table-header>
      <vaadin-grid-table-body id="items" slot="items"></vaadin-grid-table-body>
      <vaadin-grid-table-footer id="footer" slot="footer" target="[[_getContentTarget()]]" column-tree="[[_columnTree]]"></vaadin-grid-table-footer>

      
      <slot name="footerFocusTrap"></slot>

      
      
      <slot></slot>

      <vaadin-grid-table-focus-trap id="footerFocusTrap" slot="footerFocusTrap" on-focus-gained="_onFooterFocus" on-focus-lost="_onFocusout">
      </vaadin-grid-table-focus-trap>
    </vaadin-grid-table>
  </template>
</dom-module>












<dom-module id="tf-hparams-session-group-details">
  <template>
    <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.
      </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.
      </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">
          
          <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>
    
    <style include="iron-flex">
      :host {
        display: block;
      }
    </style>
  </template>
  
</dom-module>



<dom-module id="tf-hparams-table-view">
  <template>
    <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" width="5em" resizable>
          <template class="header">
            <div class="table-header table-cell">Show Metrics</div>
          </template>
          <template>
            <paper-checkbox class="table-cell" checked="{{expanded}}">
            </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: block;
      }
      .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>
  </template>

  
</dom-module>


<dom-module id="tf-hparams-session-group-values">
  <template>
    
    <template is="dom-if" if="[[_propertiesArePopulated(visibleSchema, sessionGroup)]]">
      
      <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>
  </template>
  
</dom-module>







<dom-module id="tf-hparams-parallel-coords-plot">
  <template>
    <div id="container">
      <svg id="svg"></svg>
    </div>
    <style>
      :host {
        display: block;
      }
      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: 0 1px 0 #fff, 1px 0 0 #fff, 0 -1px 0 #fff, -1px 0 0 #fff;
        fill: #000;
        cursor: move;
      }
    </style>
  </template>

  
  
  
  
</dom-module>





<dom-module id="tf-hparams-parallel-coords-view">
  <template>
    
    <div class="pane">
      <vaadin-split-layout vertical>
        
        <tf-hparams-scale-and-color-controls id="controls" class="section" configuration="[[configuration]]" session-groups="[[sessionGroups]]" options="{{_options}}">
        </tf-hparams-scale-and-color-controls>
        <vaadin-split-layout vertical>
          
          <tf-hparams-parallel-coords-plot id="plot" class="section" session-groups="[[sessionGroups]]" selected-session-group="{{_selectedGroup}}" closest-session-group="{{_closestGroup}}" options="[[_options]]">
          </tf-hparams-parallel-coords-plot>
          <vaadin-split-layout vertical>
            <tf-hparams-session-group-values id="values" class="section" visible-schema="[[configuration.visibleSchema]]" session-group="[[_closestOrSelected(
                             _closestGroup, _selectedGroup)]]">
            </tf-hparams-session-group-values>
            <tf-hparams-session-group-details id="details" class="section" backend="[[backend]]" experiment-name="[[experimentName]]" session-group="[[_selectedGroup]]" visible-schema="[[configuration.visibleSchema]]">
            </tf-hparams-session-group-details>
          </vaadin-split-layout>
        </vaadin-split-layout>
      </vaadin-split-layout>
    </div>

    <style>
      .pane {
        display: flex;
        flex-direction: column;
        height: 100%;
      }
      .section {
        margin: 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: 100%;
        overflow-y: auto;
      }
      #values {
        flex-grow: 0;
        flex-shrink: 0;
        flex-basis: auto;
        height: 95px;
        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>
  </template>

  
</dom-module>








<dom-module id="tf-hparams-scatter-plot-matrix-plot">
  <template>
    <div id="container">
      <svg id="svg"></svg>
    </div>

    <style>
      :host {
        display: block;
      }
      svg {
        font: 10px sans-serif;
      }

      /* 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>
  </template>

  
</dom-module>





<dom-module id="tf-hparams-scatter-plot-matrix-view">
  <template>
    <div class="pane">
      <vaadin-split-layout vertical>
        
        <tf-hparams-scale-and-color-controls class="section" id="controls" configuration="[[configuration]]" session-groups="[[sessionGroups]]" options="{{_options}}">
        </tf-hparams-scale-and-color-controls>
        <vaadin-split-layout vertical>
          
          <tf-hparams-scatter-plot-matrix-plot 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>
          <vaadin-split-layout vertical>
            <tf-hparams-session-group-values class="section" id="values" visible-schema="[[configuration.visibleSchema]]" session-group="[[_closestOrSelected(
                                 _closestGroup, _selectedGroup)]]">
            </tf-hparams-session-group-values>
            
            <tf-hparams-session-group-details class="section" id="details" backend="[[backend]]" experiment-name="[[experimentName]]" session-group="[[_selectedGroup]]" visible-schema="[[configuration.visibleSchema]]">
            </tf-hparams-session-group-details>
          </vaadin-split-layout>
        </vaadin-split-layout>
      </vaadin-split-layout>
    </div>
    <style>
      .pane {
        display: flex;
        flex-direction: column;
        height: 100%;
      }
      .section {
        margin: 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: 95px;
        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>
  </template>

  
</dom-module>




<dom-module id="tf-hparams-sessions-pane">
  <template>
    <paper-header-panel>
      <paper-toolbar slot="header" class="tab-bar">
        <paper-tabs selected="{{_selectedTab}}" slot="top">
          
          <paper-tab view-id="table-view">
            TABLE VIEW
          </paper-tab>
          <paper-tab view-id="parallel-coords-view">
            PARALLEL COORDINATES VIEW
          </paper-tab>
          <paper-tab 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>
  </template>

  
</dom-module>










<dom-module id="tf-hparams-main">
  <template>
    <vaadin-split-layout>
      <div class="sidebar" slot="sidebar">
        <tf-hparams-query-pane id="query-pane" backend="[[backend]]" experiment-name="[[experimentName]]" configuration="{{_configuration}}" session-groups="{{_sessionGroups}}">
        </tf-hparams-query-pane>
      </div>
      <div class="center" slot="center">
        <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>
      </div>
    </vaadin-split-layout>
    <tf-hparams-google-analytics-tracker id="tracker" tracking-id="[[trackingId]]" name="tf_hparams">
    </tf-hparams-google-analytics-tracker>

    <style>
      vaadin-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%;
      }
    </style>
  </template>

  
</dom-module>







<dom-module id="tf-hparams-dashboard">
  <template>
    
    <tf-hparams-main id="hparams-main" backend="[[_backend]]" experiment-name="">
    </tf-hparams-main>
  </template>
  
</dom-module>

























<dom-module id="tf-mesh-loader">
  <template>
    <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>
  </template>
  
</dom-module>



<dom-module id="mesh-dashboard">
  <template>
    <tf-dashboard-layout>
      <div slot="sidebar" class="all-controls">
        <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 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:
            <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>
              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.
            
          </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.title {
        color: var(--paper-grey-800);
        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>
  </template>

  
</dom-module>































<dom-module id="tf-tensorboard">
  <template>
    <paper-dialog with-backdrop id="settings">
      <h2>Settings</h2>
      <paper-checkbox id="auto-reload-checkbox" checked="{{autoReloadEnabled}}">
        Reload data every <span>[[autoReloadIntervalSecs]]</span>s.
      </paper-checkbox>
      <paper-input id="paginationLimitInput" label="Pagination limit" always-float-label type="number" min="1" step="1" on-change="_paginationLimitChanged" on-value-changed="_paginationLimitValidate"></paper-input>
    </paper-dialog>
    <paper-header-panel>
      <paper-toolbar id="toolbar" slot="header" class="header">
        <div id="toolbar-content" slot="top">
          <template is="dom-if" if="[[!_homePath]]">
            <div class="toolbar-title">[[brand]]</div>
          </template>
          <template is="dom-if" if="[[_homePath]]">
            <a href="[[_homePath]]" rel="noopener noreferrer" class="toolbar-title">[[brand]]</a>
          </template>
          <template is="dom-if" if="[[_activeDashboardsNotLoaded]]">
            <span class="toolbar-message">
              Loading active dashboards…
            </span>
          </template>
          <template is="dom-if" if="[[_activeDashboardsLoaded]]">
            <paper-tabs noink scrollable selected="{{_selectedDashboard}}" attr-for-selected="data-dashboard">
              <template is="dom-repeat" items="[[_dashboardData]]" as="dashboardDatum">
                <template is="dom-if" if="[[_isDashboardActive(disabledDashboards, _activeDashboards, dashboardDatum)]]">
                  <paper-tab data-dashboard$="[[dashboardDatum.plugin]]" title="[[dashboardDatum.tabName]]">
                    [[dashboardDatum.tabName]]
                  </paper-tab>
                </template>
              </template>
            </paper-tabs>
            <template is="dom-if" if="[[_inactiveDashboardsExist(_dashboardData, disabledDashboards, _activeDashboards)]]">
              <paper-dropdown-menu label="INACTIVE" no-label-float noink style="margin-left: 12px">
                <paper-listbox id="inactive-dashboards-menu" slot="dropdown-content" selected="{{_selectedDashboard}}" attr-for-selected="data-dashboard">
                  <template is="dom-repeat" items="[[_dashboardData]]" as="dashboardDatum">
                    <template is="dom-if" if="[[_isDashboardInactive(disabledDashboards, _activeDashboards, dashboardDatum)]]" restamp>
                      <paper-item data-dashboard$="[[dashboardDatum.plugin]]">[[dashboardDatum.tabName]]</paper-item>
                    </template>
                  </template>
                </paper-listbox>
              </paper-dropdown-menu>
            </template>
          </template>
          <div class="global-actions">
            <slot name="injected-header-items"></slot>
            <paper-icon-button id="reload-button" class$="[[_getDataRefreshingClass(_refreshing)]]" disabled$="[[_isReloadDisabled]]" icon="refresh" on-tap="reload" title$="Last updated: [[_lastReloadTimeShort]]"></paper-icon-button>
            <paper-icon-button icon="settings" on-tap="openSettings" id="settings-button"></paper-icon-button>
            <a href="https://github.com/tensorflow/tensorboard/blob/master/README.md" rel="noopener noreferrer" tabindex="-1" target="_blank">
              <paper-icon-button icon="help-outline"></paper-icon-button>
            </a>
          </div>
        </div>
      </paper-toolbar>

      <div id="content-pane" class="fit">
        <slot name="injected-overview"></slot>
        <div id="content">
          <template is="dom-if" if="[[_activeDashboardsFailedToLoad]]">
            <div class="warning-message">
              <h3>Failed to load the set of active dashboards.</h3>
              <p>
                This can occur if the TensorBoard backend is no longer running.
                Perhaps this page is cached?
              

              <p>
                If you think that you’ve fixed the problem, click the reload
                button in the top-right.
                <template is="dom-if" if="[[autoReloadEnabled]]">
                  We’ll try to reload every
                  [[autoReloadIntervalSecs]]&nbsp;seconds as well.
                </template>
              

              <p>
                <i>Last reload: [[_lastReloadTime]]</i>
                <template is="dom-if" if="[[_dataLocation]]">
                  </template><p>
                    <i>Log directory:
                      <span id="data_location">[[_dataLocation]]</span></i>
                  
                
              <p>
            </div>
          </template>
          <template is="dom-if" if="[[_showNoDashboardsMessage]]">
            <div class="warning-message">
              <h3>No dashboards are active for the current data set.</h3>
              <p>Probable causes:
              <ul>
                <li>You haven’t written any data to your event files.</li>
                <li>TensorBoard can’t find your event files.</li>
              </ul>

              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>
                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>
                <i>Last reload: [[_lastReloadTime]]</i>
                <template is="dom-if" if="[[_dataLocation]]">
                  </template><p>
                    <i>Data location:
                      <span id="data_location">[[_dataLocation]]</span></i>
                  
                
              <p>
            </div>
          </template>
          <template is="dom-if" if="[[_showNoSuchDashboardMessage]]">
            <div class="warning-message">
              <h3>
                There’s no dashboard by the name of
                “<tt>[[_selectedDashboard]]</tt>.”
              </h3>
              <template is="dom-if" if="[[_activeDashboardsLoaded]]">
                <p>You can select a dashboard from the list above.

              <p>
                <i>Last reload: [[_lastReloadTime]]</i>
                <template is="dom-if" if="[[_dataLocation]]">
                  </template><p>
                    <i>Data location:
                      <span id="data_location">[[_dataLocation]]</span></i>
                  
                
              <p>
            </template></div>
          </template>
          <template is="dom-repeat" id="dashboards-template" items="[[_dashboardData]]" as="dashboardDatum" on-dom-change="_onTemplateChanged">
            <div class="dashboard-container" data-dashboard$="[[dashboardDatum.plugin]]" data-selected$="[[_selectedStatus(_selectedDashboard, dashboardDatum.plugin)]]">
              
            </div>
          </template>
        </div>
      </div>
    </paper-header-panel>

    <style>
      :host {
        height: 100%;
        display: block;
        background-color: var(--paper-grey-100);
      }

      #toolbar {
        background-color: var(
          --tb-toolbar-background-color,
          var(--tb-orange-strong)
        );
        -webkit-font-smoothing: antialiased;
      }

      .toolbar-title {
        font-size: 20px;
        margin-left: 6px;
        /* Increase clickable area for case where title is an anchor. */
        padding: 4px;
        text-rendering: optimizeLegibility;
        letter-spacing: -0.025em;
        font-weight: 500;
        display: var(--tb-toolbar-title-display, block);
      }

      a.toolbar-title {
        /* Override default anchor color. */
        color: inherit;
        /* Override default anchor text-decoration. */
        text-decoration: none;
      }

      .toolbar-message {
        opacity: 0.7;
        -webkit-font-smoothing: antialiased;
        font-size: 14px;
        font-weight: 500;
      }

      paper-tabs {
        flex-grow: 1;
        width: 100%;
        height: 100%;
        --paper-tabs-selection-bar-color: white;
        --paper-tabs-content: {
          -webkit-font-smoothing: antialiased;
          text-transform: uppercase;
        }
      }

      paper-dropdown-menu {
        --paper-input-container-color: rgba(255, 255, 255, 0.8);
        --paper-input-container-focus-color: white;
        --paper-input-container-input-color: white;
        --paper-dropdown-menu-icon: {
          color: white;
        }
        --paper-dropdown-menu-input: {
          -webkit-font-smoothing: antialiased;
          font-size: 14px;
          font-weight: 500;
        }
        --paper-input-container-label: {
          -webkit-font-smoothing: antialiased;
          font-size: 14px;
          font-weight: 500;
        }
      }

      paper-dropdown-menu paper-item {
        -webkit-font-smoothing: antialiased;
        font-size: 14px;
        font-weight: 500;
        text-transform: uppercase;
      }

      #inactive-dashboards-menu {
        --paper-listbox-background-color: var(
          --tb-toolbar-background-color,
          var(--tb-orange-strong)
        );
        --paper-listbox-color: white;
      }

      .global-actions {
        display: inline-flex; /* Ensure that icons stay aligned */
        justify-content: flex-end;
        align-items: center;
        text-align: right;
        color: white;
      }

      .global-actions a {
        color: white;
      }

      #toolbar-content {
        width: 100%;
        height: 100%;
        display: flex;
        flex-direction: row;
        justify-content: space-between;
        align-items: center;
      }

      #content-pane {
        align-items: stretch;
        display: flex;
        flex-direction: column;
        height: 100%;
        justify-content: stretch;
        width: 100%;
      }

      #content {
        flex: 1 1;
        overflow: hidden;
      }

      .dashboard-container {
        height: 100%;
      }

      /* Hide unselected dashboards. We still display them within a container
         of height 0 since Plottable produces degenerate charts when charts are
         reloaded while not displayed. */
      .dashboard-container:not([data-selected]) {
        max-height: 0;
        overflow: hidden;
        position: relative;
        /** We further make containers invisible. Some elements may anchor to
            the viewport instead of the container, in which case setting the max
            height here to 0 will not hide them. */
        visibility: hidden;
      }

      .dashboard-container iframe {
        border: none;
        height: 100%;
        width: 100%;
      }

      .warning-message {
        max-width: 540px;
        margin: 80px auto 0 auto;
      }

      [disabled] {
        opacity: 0.2;
        color: white;
      }

      #reload-button.refreshing {
        animation: rotate 2s linear infinite;
      }

      @keyframes rotate {
        0% {
          transform: rotate(0deg);
        }
        50% {
          transform: rotate(180deg);
        }
        100% {
          transform: rotate(360deg);
        }
      }
    </style>
  </template>
  
  
</dom-module>


  <body>
    <tf-tensorboard use-hash brand="TensorBoard"></tf-tensorboard>
  

<script src="index.js"></script>",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "text/html; charset=utf-8"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/font-roboto/oMMgfZMQthOryQo9n22dcuvvDin1pK8aKteLpeZ5c0A.woff2": {
+ "data": "d09GMgABAAAAACn8AA4AAAAAUjgAACmjAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGmQbmUAcg0oGYACGTBEMCu1810YLg14AATYCJAOHNgQgBYJ0ByAbL0RFB2LYOGCA7DduwB2DjQOQz3hJ9n+ZwI0hWB/YxYSYMBRSFENBsWqrAkWbJBHpUKamYBECLd7YUy2OVYvlKX1dMf05+T/7LtU4wMKUW3v6cz1MLF0FGyHJLEG01r/VMHufgpZJIoGKBHQMKsYkFpgU4tsDmtv9xsaIGoiNiIJRtJKSElLSIdGjQuiRIypl0JtBlKISJSqZZnH/Oq0ZWaYZyYoPCFpukb7+N+xuwk6iBRZMI8WdlLQH1F3R7l157zoCyXjA9AD36nWBrP07PZhwgBLSeMnLEQ4VqJsqlv8siGuabsED3LeKFnxrugO3hMah9NJJ/ipRkvNo0bWSH6xvN8TX2qedvrqte1s1/yDEW6dCUB4tkIxQEeoDTSYMiiaAuBEGJLK/dSEgoaIi0Ua4CGXj/7vX2aa3YewLW7L1Fw6EC+fgxB/7NWWpMKZaUyFMhaxEyArLmA7J/62Zdje5MjlgYyvcOTf7ZycwswkX9oD2CklKoSNIzN4VWFXVET5/gKgKaO9USZgKCaxcreurQxDS1KS6SqUxAJqz+B+OtbQOoul9mcsgjITAKKN32318dn4Bhdn5t38EFHq8pCEUmUMECIAIFw4RKRIiRgxEnDiIBEkQpSqgdDmAQKCAVcCaECAgAiDACvyk0ex3gJounDg3gOACJy4k2DnDicusvN3gBBrAILTCpecT3AAH9C0NYpDo+7rNUJuyf/BUQ/cM42KIV0v11FyNhkyiUDj0XDKjjuX1lEnr9K7FjMnEPpZVifqZhCWKr4SbqzTQwLYaKjSBrueqpWpPjRbN9WixjymuFFH/CwqFBhYDRux4XXDRJZfdwE+IMBGibhEnQYq021SoUqPpHm069BkyZsKMhXQZsmTrQkH1yGNPPNWtR68+/Z4b8cJLr0x66515C1atWbdh05Z9BxC3mkNDHAcJeFI4TeKEYI8bP9Y44ePEm77r41+ewEGxRUrtUWZUuIsOetH6bTJql3HbzKjlpPZkximHvICSPiqPeMwTngZTLZpmhlleMxe8ac9b3jHPAmuss8EmW8F2u3bYZS/Yb9vBNIRJvask5+7FELPwimHcaoZ46yTaJ9WCSTY0DsjmwGD82Y7DoWmOfu1MGuY6fi64i8JTF1OyuErRYMJBFtuDaaussAMsMLJnmS0vuQHreu+JDYwyxjgTDXPAYsWQxpkTT6ltykCFu+glcU3S4tKxymCyyA7etO0t75hnoWEGSu1TRoW76JHEG97yjnkWzo2mioUhQSbYYOmYZg2ss8EmWw1jsBYFTyY55CV9Yp999tlnP46GGajhpolWtE5hDEphgsHaYdbBBptsWWTntaOdq59hH5i0BI2pTbJ9tW44FNXel24XIjwwjRl9q3SNYW6MMqPqdvrNMVySVP2Trj0U3CvhlYipV1w9cpuCyIgMoYoJ6uAoNADzvug45Zj7yoBXfrjWup4FNpUP90w83Gjmo+puO/m8JAbcN3D4dUpCw6N96EFl/RgLIB76ETisxR/w6aPfR7D+NjfOfbeHOYYeHrwM6cPqaG0C4EDa+qeN8E9UN/umlSM27Cex9S8bW/9cmENaN4plychcK2z/rnfLbrbSThvtiLBzSrZHuO7Wmpvu9U1ldbZfCTb4hlrtIxcAHO5g65ppXrrnhMPC1kvnK5fWHKkuAKxYS2ygcV0rlvjEtGOxglUm6USA2od7bZ7ZA0zgcMNXu6Vq96DjVnaFuUnt8GvYm+2/bLjrmx9odH8OHtYJcBgN/b8kxzn07RsPkp7oNsv+PxY7vLXhbI0B2O6kbBr78YIaGQ9mNpD/ZDn01If3Bh8OOu7XP4HYqD7kLYGVOfcyTk47aKYl0X7mMjiMDjPg7M42er6j3/abnabFTbZeexnmm/4ZPQMO37lXsuKw1GmniQNWEawkgpUo+P+g8bqExlXC6NwiDU+RkuNUiKeoeU+7RxcXffIw9p5jytx58d4L0uW4KO/t67osuGHVFr1lzLkJFBG7OIqjOKlO+kwUPh53gWwuEnGJGNdJ7wYZ8JOTEBHC5HCLTMRIT5wnSPAYSbKSIiNpslAk1h3SUiqP+NULp2hOtdHQAdF0S1ofe7ErOh/EMyMdczKLF9olnjsqE3JyqeeOygFPyuNJXV4ExVMo3X9j06MfxnOvIEZNoDdJXkZT5mC98R7x1gKc1fs01mxBk9dJBzawOQ5sKDkp7MUhWOFQrjBRrvMoIaKIEOVmyUxYL3rQ4QjYwQIGsIZUnapA3GVBSAIaNA5ND0QYkJFRiSHMgAOcYxIJoiQSJek+IlUaTgrBBg6wgcNx6IRwArCCIg8o0IFB0e4sQGgD2sfstj0Yi/vtsrpEq52XqxUx7wXavU9R5AbVfbV1p6EDtGWnJA/XVOMRsvo8RlPdHad9NxBpoVtpYHLL0QrVHnveFe6uwPf/7jyBq5c52luBaALJx8pX+LgSQAvlHBSU/jQISHSdPDXyK0T8EDNBpjzkeaygcCLzJqgiKV9QtldXCkW9eOkpVFBLmWjZoyokvMYGYuM3q7LDGjTAj7sPXGsYBaVQYdkTHmY1/zyKJHrVqlSqUatOvQaNHgpOvOwmgbx4I2vWolWbdigIDqeB6phIgQHjoSEEYoO3GfWG+xmO9H2b14EtgH09CwceqakEMmDjtbHwH1ywyEvghjwO6F0GGbeagAYru65f6TdFf8NxEZpQA3bCjcYxgDMmoUrc/1DdhozZ9MEhMsFlbnKRv254PFwOt8PD8DLMhvlhdVifRh0CAEy4lSj1fMkew8Zt+fiWtyg/Gs6H67an546+N+CsD3294PDnwOcHM058+/z/7Vt/15TJ8MUb+x/6/XXxtmRzAC4jjHlHw5q/XvcP1+XZL9e/HyHSqDHjJkyKEm3KtBmzXpsTI/YX7U0Txdm2Y9eeffEOMAIAZPHeNcAFkH5MT6DhJhQar4QOSmnAxmukk4d0404Pg1C8IcIZ7jem0m8c6GKCWZ7xmjkieMMCoyyyRBTLbDDlbRLDFh94430klk98Z5Uf/ITIL/6x7f0n3jtUBxqZCCT4yEItBRI1aiOQrFEfAiSN+hJI8bmP1LFAqs99ri4F0n3ua3UrkKW5HwRyNfeLQJ7PPVUzgXzNPRco1NwrgSLNvRYo1jyHQ6BkqJuBg+pwqVfwfijyRYUwvQnHv6TWp0PyKigaNh96H4GBhmyOegPVB40f59xGEvqhc+sAD9WxCKjVXrZAVDdIs68AhHKCotyajCaMMM33GHhE96JFqxBPQEEEoqpC8iJOGGL05OS/t6P7dswwoetDgYYOgzlyg98MT+zFf0ajcoEikxZ3w24atFBdBAG0lP/g72LZuroeHO2D0lGazKLkzmMauyiDCdhr2a5txrOVjSChgd2ova0t77MhhbcusVxATqdNzYG/FtlUbXRQPRO4OeZ3jE2LIpfa374QSXm/jXcJ1RlLGxZ+dBY1t4Brn0S4YIb5A885pd4Nm4nTxHTsncPU/uJFsrvfCo55+xh0RpRwlNVFmRZ5JT0a8vqz7YKjXITu0NETuTeLgWx0wlG1ZKwnE8zEIEPVAl29KW8grf5KvdJSAaHPwFwMFyKZcNGCzUM5o39uRYwWpCG2syOpPpQYJcOaFn+YiakAyoJBWW1PdQ3gky5Lyrv1Qu08YS8gSdFMp6Xw8V//1cwtjV/OeuogqHw10Ysw1TOlp8shZnahTTWfy4ZZH3Bv01/rq0FPiwuORTUH3Rr39SnJaRmeqQkMhbRqn4TlQFNuBzh2XJgnuDqHspyu0HjUXsMzfPUKBo4oQFl/59ra8oQdbCz13uBAOQ+7IIF6czUJA1lU66Bw5NYfWV31oNN7ypngGeWsuTqsEsrhFQEqG1WQZkIcz5vH8rsZjFklUsoKdqUiEv68IaVRHWA1ltQdWoR4IBbvBaMNWXDw7xohT2WjEINN7BucggQF7qiNneY8xhDhaJpbjN+TprJdqRJ68eUpZ5QTOoqiy71R/rGSuGKW/zv5f6bK+V+XqNf9bxu3tMVwufyHCz+PSnKjrh9+fWXoqLsUjumye4LFDWIi7dtumjw+brjklOBI+ScdTjXMTJQ4+jRhyjVAOkeCkt30cx/S2Z8qaXHhEDOrpWN7sCJd6FjeIVEmfARcWahxPLsI1sVRRvQyvF1z0BOqq/mw7dXZ5YiDWzSTRl1gQmV52yFfjGnz20KQxu571VcjSo6/lSSUtDza2mZJtR3ssJefgx5bpVWyM8HDYK/wkP5JPnL6UqVarauNUmfRkTOho3FTlGoP6PIFDRtZeBq6BcMRkGuIiNY4MYmDV0ujHNQz+aSb3NheHTbPCEeU8Mg3wvEIObtW60VLwLt7tL9LwT6HZUmRTfWEN7twFXImIwjFDI64QVhZ3NhBFt8eBbxHMZ8CaIe7H1C8xvXMdyxLPb6VIsSjjQ5Tu6SCqgAr05exOiWSIOmZeqYl2yAKsJ4IfFNStZo5LrDOMVUi2QHIrmqZ8dR/Sd8CWKfN1Wr8Mskb5eGEuUnILSj6pq4YSmagxspkGt6pTX8GqCojM8mUjwKb6kdQiWqQsEttHrQP39bBMb/jp+WMbYfEKRvFj3/DjHhrj/gV5E+5wKkhbQbvSCZBg9oF+S042qt+KCNAGgjS24pSDB1vg0HdlcYmpwORmpccTd0pV+zgEtazSNPfQ0pIHnElz5rKRywGsg04LtCsfnVCrglVCXW2UwSoJrdok1FMXuGCi+3BkEsTB73xIylxRo9pfLYQYxLuUC1A6WAXzk0miNkeiw1OG6sUC1JVAcxx+9QSh5gpb4ljMlXlQ8qQQ3dgkoicYMp93+rZewvB1cgE6qFuCI/w2OaxiJkb+/Jx6REGfgqeugr5MzGoCXlAhbvvgpRRatUGSqa0aT40UTVEIniStK2KkQNSWnadTS44MC0ZcShqn/tNbjSpzhJPWqmVtdIahqMy4JIurfISwFqdDknlN/ZkJWaJOfPmu0hCIViLEiCXeDo1fx31S8zs39RXB2funyM/h/4qJvzk1FE1AlLSBoRckNzDUC2Vie0A3dVydpP2+nlQlXWLmsM6kpxf2qNAnzxXE9I8zbaSdNBbUmBp9qN4v7SdxKEPSQw7OPKYqmGDHU1G25UrXOzQT8UESQ8gg7ZI7KplJNU1l8Ei8eqUd9TGu/Hq7MDh3qFLtVYpmTYB1RVu8jGGn+HIKixbp7pl08klbTB60qEpikY9sjLo9EaglvU96Bz3EvfEcLRjtkf+1rba2RopIJY4orU7uObY3Y9SlGnOR8UZRdWYYRWrEpkS6FgkfdvN4lxqew4RQe5mP6W+wnEkhvXYbXxIZd2qOGV+DxkBE9TT6D3p7Zq2VzJUAseOmluQLiocOOkAKDVWaXR015dYYhhgYrCcD6ml8QGDF/GOWXf4pN3DFIOvh2olo92vyup7stXa0MvaZcUB90LXMpfiqT0HdGwvKlR7KYetkJMa2zJ/eArTc+pPLwuQVoRD7jxII8nWDhElbFkfTa6MUhEyZ1g5yvyhBBlM5pzxUDZLT/37WD/EMrpTwTbt4IhlG7ZotGO0+OI4aZ8Go5MwWJcz21FJpnoSIFY/ccFOPVCPGOEsSkbF/PQIj5jGOrVbVnfwRTqNq6nNasQEQSYH7oLXLiW31UgXpk8J44vqKc0GKe+BUadt3wUGAkJHB7zFtQeGQxccdSieReslSPWf21E+PxPTi3gAyczhLgUOemFaBT28Nb0szb2eFfH0QV74/FTUWTUSxGVUnmvtGSxEF+eUJztVfeYpr5KlNEbYbqQ/w8UBwJAH0HamgKFli1D0/cDgt1aKRsyIiBkajPOqYfpIH2OmzjUXl2DjQBcnYNPzP23nDgeJTLHZjvA3F6eZS+qL+hBHp2CFSjh9r5hEHI5LWf8yYeu+fiXuj2dEpxTy4BSscCAS7mcaFpIjOC3TN15a8XSiiv1d5nw1J3XvVVdSdCXBLyTQ7X6UP791na9WoVPtyKsOfHdGN4V1cnOIkpCaGROZGQLYjJzIqtrI6Io6olJUVVV4RG1VQhxWw8BWVUnfSk9FQ88uQ89O+1zrjciqGmx1dYKSoDTFEzCaH0DKetZ6qpr6NipKhta6Pz/vyl71JjjIgm2Mo3dThbeljyxJqar/UU1W/8NoQ8MMt3tOGvIR8uHF1YdJ9djPRUuCiuyQgv0MsjKrmh7gbl1DWxUY4ZuThDq3YelD8tGWvyGgLy1vY6imbeEGLDOpHO7hsJgJURqr/sUfdMIUeQNS3akvcKdANyLxpG6ttwWvR5SKf+OeDogqLHnnfDSKVObzyPWhfkSuc08aOBScttLk84hUfq/nmw8c5a+vGV3LuuaOM8ilM73oei1b0HiQOciMcqb1WLAxXFpjymrKekl9Wf4AqqVC9FkHJbMIdHx1e6qd9XNg5NrO3gaSJT+J0MR/vZGQBOTgYj7stSKQKXNVXJDY31kSRgv+kF24ebC3cBUl1sW4FzlLSg6fQRYu7hOXE+KiplBr8IY64U2sYRs6DULU6B833EN1i/QIcale8TkFiZTnqB9vXuxNN79muxhd9Q6O2QgmRCCZ0QQ4jJKJnpTGv+v9oztv+iwCmx2v+PFGND0YOBw/gIUOqldmXGhMUkLkg/zYNCQBblntjGSPaFO1s10v9n8avPBleHDEAF69UZnZrVe/kugkTRzewS6vfEa97f0yw/q4iTWYFOobntaUn1ZEjgpQEKYF4W/NhTyv0Yd/jpcJkcNPVxmmV74yjU6gZf4ppenXaNNMkCyKPbn0FNpK3wWEJHdmZqV0gZyeMm+7ch9v5jGOnDmQHhB2JdRa3fDkj3rk9+T/0vjk3+XHvmFPPPktb7jXunTtve7t2X9N52URmJf7Oyv7Z1pSZER6MpvtCdeYGG/3KOJiemfEJYDQapiYQomOZSg1yG6ZmOa28yKIOPdT7qhorWaMNs35ggvr6G+bbL/MCjzP6ah2FK4FBKZTczOTe4A20vPvgNDZoDTV5MABkCq/LlcqJyNXIgcCLfEZqKciVoFpdFmDesA2F/EViFPTiYjRMXd1dPV1vB/kbEJBSleHOp5MjjQ3lda6OCtr5fRIdt1PHpfS7wyfXh9tfyRcLaIbr62anLqFf8lc4Y96mu5478FlTWmhS/jNdM+EJUwrPupOtsbzm0OtfvTfGH6QXPh6JozbrrScJ8y+FHD8bb/cUsVwggG/0BH0/sMvm6XGSpkVD6YkrWxDSTe7c+a4a9+DZXxyDkByItiaGDTEM0iu4ZkhD7Yc//CjBmoBQ54/eN/fc9+rwOayDzexK2zg39L2rRpGqZi8+EBartu5PKFZIS7+CS6kU6AePnpik+v3e5Sop2jiixQhuoqm7aMozvXeY41V+Vld4yx/kg4Gj7aU1KWcbDU7WvOfnqsuEoFnZqNFInyV/QiTCN5nZPE7+yH+3MbPICCNKvWjWSgsBAw5vWhq2g8k+yJtInsAQ44pGvpsA+o93SqOOAdyC3tVlhAy8kBF0JFz/cg210yPCDdP7xAzQPhtibvbpfSGstK9AlbQCoPe0sXS0v49hEVCL/h99hL428m9tBO/9ybefFp41hNCTIjwS8uEGDhR0dy1v7/a8ZixbckIvvJrm+BY0FLoZabrhRNHyKcHKnr6S5R8k83m9Hp++unpHLzlzRK4Kve1aWvrXsVreu2rvX03aKXVzpKkaavJDXQ1abeQV46TqbL0dQ1N9DUkmZmnCHqM41HHOAfqm/OfSS4K9QUz6i84iIkjPTGOf2D+8nwat/5Dv8AorzwlLqI8PxllC1r42qlofn899IsIf8EvSmxaRteT6WtFppluQF5yPm0H5ff4GW+Z9FRNX92p9/Tqd9zSLDHteYSAniPjaOrOBVJNenBsCSkb+ECP+P3O8mhOA355PmvXK+xFQG9UdVZuclGwu1FWoJPdy0Drcvdm9umtLDQhcfhBb1RfTnlOadBspjeo+OCnAYPvBgx+qug+qFaSF+EVYN6xnP1wEkFWlp++LWp8WFre0Fj0DuL/n6Bpnjw7SK47206egNWRk90XG/Don2Vs6T8vNHH1M59b7+U8Qm7CD/ByunG6sXvzNnHWWfcvykeYXlt9MTG7sG530/7m2uuFlxMrYDsd9PbtGZvUMz1npmGdh1sFsoXnUwTWI9iKfiQBd/t2N2CJ3TkBQNsVAKhoMpkPe40M8E5YoCEH5vQGfmL1womKR09WGi7PPrg0Ww9iYdkZ2RlwuuJtMcK7BBcPd0eHRbeWvGxLqAXqTpuelRfB0ybaRol6j5A1YOD7aIqKLv+cyWvA+jXRIN+IR2kxVXfYwMsK5FBsP9eu9rxyT8EF1wEWKFLu8fHLl9BdNE9SX8V1atZO69a2Rae/AqkIm3Q/WqMmGlOf6gEbtwUaPjhT5PVtLjaj4+Mb2sYmWofkGMekvJGec49yn4M576+9691P3cKFKYCFOpyXW+zQ432hn13YruyxGLJW4SftnAZi9gSosc+zc3/mKQ38O58cPrVzBK2+gC5uGYi3jtUUlPUwiB3He414ZJexpXEx0ybG5sFWfT2p3v0h5UmdzDJd5raIsZWDNWGLtFUPFrz/di73Drkl4PxquSd/fvrZZ8lGXN/CzTetITYrO97M7UHP010ByufOzPHYpntF73Xz6mKzJ4BDpzMwa9AAFfGC8hK8HdzdjWMteNXRFMACBfQo4pRhrmuuLiHGQS7OwNEm3nnrpJRAxg9haRk5nUd4rqtuIqKZvwlQvnr5B2uUXmrtq2WzUtE/4/MG9JI3MrBXiNP4+SaMrN1rFFFvsPC1xfjPUEa8HQkh9rGB9Paj1MH9rQ65PE6KOLC3iWNig/KfOSOIf67GfMXB/xbjSAusAv+Zivx/LyekzbMK/KXg2qreJCZVzg+31MwnxlW/AdlVth8r13oHPYLpKIB5W4vz80h43r/Ki+1Cd+ZPEWt0MjDa6fXRBZNgznu4PjDY4xZG61IHmLcUGnc/6sA2/98uWmrBVHSlfireILkspnAaLnllZAl0yOQBRbwNFWycUi36BPjPnrnroX1MokJHw0srermzqWv9SQZVLczV2s7TQEneUZ5Dql5P298gdeshJWLYxKPCkkJjGu9CcAzVhWM+MtgR0kixrIiMLHdQljK7YnBIZnzxIGkQC4Jhzs6hE41tz2Cgh/Lo+7NpxUJ2ijgZPv5e6b/95JiCeNKxKPEnoFBy6JYEhb1NPIvVS5gVLZzFXiHexaRzmaX/ciZ8f/ghfs6K04Vn9lfGr4zXLjxWnLNwwMzSf2XopPCKLdM8jwJjFru5w92zthddj52/PgJiWQHZJkReneNqucKR4OdKFmhZfzz8ZTp1+vM40vFwuUWQlzAud2JkrcqwymhjFIV/JQvyTJmAfZoJ+N8jMli6+a02nbZ7Oy9OjMvxEsgCzcvQNflhOnX6y8jjtpWHAqDxha6IOhen/EC4Jl3l3GUNHSfzEqSk81WCWsLtppJfvWrmXhZQW18D0xx9jJlqUfd4qETYpvvTGjZhQgafkY7vUHZbzg6fnD83/fwUmXuVspTJ2T2FyWx/XN5I63GlfZcnZbwABbhCdX+BCMQCRztfWViCQw9/PXj2dGGquds5NMjdMTw3BIe+XQgKHz2KIifGisKjY8Nj4hPt80dG3cvSssJj0zIL/foHivwzsiOJWbmuZS8G7IqSSZGx4qigIMJUf8Bqf6DHZNCww4C/h2e/370LcLb1uFDWjNsYJkShUiFYQa5XTjpYulI6hJZG+RykMR2lHn1G/U4FpdSmJxRdBX6lWNsa9NC6x7ObirfiPV5RkIjWrAJipbelUZLDuFT7jW430zx3aruBLP+dWNsq+uHFbfTKK0pIdV5CcgnBWvGmZowMl2aNkoelWBhXndFR1ROaeFVbxTsimlGyJ++R1dl1bBUN410Aq2cyj4Fgrmu8HNb/FBQ/6+U2lBQVPp7scCM/ncwvqS/PTLMx1zUxd44L8vR3jjM3NdWx+x/ZUHweXynDVll8vqGu8Cy+qrSEvaLoHKF2hGqkOhSmMkQ1GhlsNVAdHxpUHW03AMeeZr27emF+4UH27lV+DS7CscGKGiJCJQz29eFx0bnJMZJWx7VMAq8YXKAme2iDobSQOUis+FFx0aW3wWgO0UEYcqC8klL2moKzDfUF3Ozpp1v3V+2kexy5NREhQQ9kAgQgV0ofw5o6ReFmsSCgmx4UKCEGsqIq6pK28SC4wVlCKgHc+R6HjHwnh7Q8R6e0TAfHzMz/R0RV7oiJq6iK3lTVcFFVgYvp+i7ZLkXVReHZ4YXVHBxf5HPkoS7PwOXKcRc7RYG/knfv3BUrJFSl43JD3RycnHQ0mlJIwJpxX1dVSZL/2s4dMVXBS4XWZYHBcfn+DjcVjWWPZVwkOdUGE6MqQ5yLrmlIyN9RlhDyzEcMgX0Ilhl4M+GIsHgAlN3P9x6WyuamilfjCKYxdelayjMUwLyFGJzuJu7f7Azd/00mwJAhbe73yGi98ZCQDKdbc06kWRV7kLBOmvpCN67+ssKdiYb3eYVGr2+FWXvjgbbCpuhRX17+o54q1WJqr/CT3soyjK2lp66OOcFOw8bSU+eehStiCXerwfFiqIVPZw+9NYerF8HVNtjDhIKULL/oHJh51tpY/NDFQ1Y9rUcyfuzXrqbD6OMBXsyWwi8tV29iyJ05reyzGtnKR/C9emz+z7jmwVBZRVNJwzdQWUN5mq+koaJpVdXq8iy6yqyPuGeZl0zafNLtoDNDavVsevD9iqSi/0QqwislY/PVKvGcPNHOrWoRVqaAFlPHzQgeHU/j2wGzsc9NTgyZ92j6Owff3tA+2s01vBgVMGTKY54jycVZ/kHFWbEAz1AMxkd3qW0DLcUhD0YUhVTNH5H0YtWKR5o77rVdMbmcxxJzRcTZw0xbWMXicZp+3D2j+FFdc3snw7e8oLHMgYltldFbMUuqftSQXbjauLCk5+wa6OCY4HqvE0/61PbIq0lbQFtao1HfcXILdrzmsE2NTzMz/O++vx1b6H/bI0u5UOXIwbo3kuCqo+5oKoIW9sqoY40/cSYqOg2EFI/8pM01K/L++5oUE/suzH8pJt19ezQ8vNzf80ZfYuKbdGXr7ohI4w7+W0XvRR7GPw5TtsFGMh1ljFc2TS19Wp1Y1R8WkrPSBXKThptdmxZiMZHcSEhC/WAVfhwwcr7SgX+X40luZpeU04PtXvblyhQF/Vsipjjo8ahkBNuMvMzoEu2zdNNvX1KOr35j19ah76bT5CCXUPWWAnKE0fTiaUsooh6RfbKHelRxKnikgFYzB6HsX2YCM9SJNMSz/ssqC65lv/Nj4Uuu0I9mQUnmpKcdU7ILs0tj7zoyKjbVtwuWfCX+/94Sk+OeeUvayNj1EzzGdv7teY9ia8sHYh77OauEECO/xb50l7aRsh7yiJmnvfG/C9dZ/Dohrnh2tKNkLj62dEZufNYms+xIHPOJEGIm8Nu+p8/NrM2ozWX8xuIBPD5hBkHeJqaBPg2BAV2BAap6N+TkBfjlZa3lFAQEZRVBaGPeJTDa9FKrpVTDqUtFAkFYZ/8Es3NeFmJnz1y5JX8NWDfZHZVMQ1FpxC7v+5bDQJfB6aBkGo4ipXRGgI3lECSecFA2DkWl+lJs7ayfQ+JVByVjIiqHQqlwsZ6cv50bQmqFs+U44MppDNzcTU08Xcx4DVxdzc3c3AzhNC+SmMQXyc4XlQTMXu2zkGVMRpKQZChztf9XC2d/bUXwp8PQfa0Tld52Z9mL/U77/zx1HsPQEtwS1xLSQoc5xfXFKYaLvdSFx62CPIJ59CAkLC4MpFsS5LPlYWTu2FLT9tHnTzzqJLnygwU8/RycnM0XSAv1Ko2WUQhjE8Su9mzSeT5JKQc+HL7Q0N3ZbHdZEjBzlLlngRRjHMHL0cV8kbT46iml1KdRxEuEMJrPJpQ6HKgfYi0ferUX0wUKZdmNSQn59VCcXJ7XmJCUXY8UFGB74qPRra19CVHoNsCNDMfvAs3LzhHOtYW1fhg7f0xp0M7SWQZwjxBIXYwyO7JVVStzSjUsmRgQXJwSE1AVgrF9mM76elklVQVpdTVVlTrguZFrzMYI54dKhxF8Y1L8vItyoxKqKrOFflz46uUOuVPolSssPMdp696WUtcIvnMXKp40pVaZpg1GBBC/j6+vaLz42KnYn7Uv2klOxfL31Tv42mf5hISqKoiDwupi0rdVxYRF7oqF4k2b8OHmOv/1LY/vTvvDtz33k7HzTYwLDSgrDo/Lr0Cl7/5RIvvag6xIq8BC80t3JHU0NCUl7urIy6qow/BDX2R/8eCH/sKLD/7dvqB0/Tw9bdbyF/8BbA7/B8ACfv5RXi4s/FISFuuq3TPy/xld+aEw/7/MKFgNXAXhBB65quZ3mSNchXEMzjWjNmffEVy77YdFatbn0cri6o3s6doSBL/VEMh8d5R8AGqv7OXj7Ca4f4GMTaYvg+n0kAfMWAUnGXGbq5WubLETFC6/WIYgF1AL8uFFVasHdK2u0/W6QTfiIbHA5gvygmuF4A/RnOkT3Way54spBkO81cmv3dOk0ApZXJgOiMn5By5dK/gTcmD6RLyZLGPEyQCumQpztelDxEyeZUacZg8r6CL+WCHfqB23tFDzijCT7c2n2ArJAFtxcrcVQzi4EqKJ6RNUM9nAiJOvVkoJxLqiODYDRAJrtvBsknxFNpJyCU2M1VykPk3yDYNVohi3tQoHgVZp6OZCZDnjOkFDskq4nijcegh9PuvE5JKvQ50g+jd1bdeqZ1sdixjTOjCv6diLvkJ1nJdYR4410sawNoJ+zUjOShINpFgzFZyEmXM6HtqB8mpjAeduDMj/r/PZkuf+D7hl/haureDS0u+otzR8X3bZVuu5csq/2umBcedopEW8gHvF349HyjOhk4pHKvnj+bNyaIF8NLGTbM6MmQDumb/1qAmimZ+PBplWJmXh6LqSU9bIxFQDfVc/Ooi7qETTFD9xKpmamfyj8OaZZEJ1OAXGegvRs0KesdMf8OOk8lvar+fGgFrQByzkYE7awz8Q118VeWAeDX/e4QBmRp+xoE2+m7GMlofvvD/oaG9B4fka2H8Se6HrFqJLTH+wgH5KKNfdqN0JIDb2+w0mUSZMl/ar/dZgRnxZN8SfnmUeAnHhOHQfyB3h9xrb8lTF+40BiaA+G/tMsBstPAFki2qMQUS/5tcNCQScSy8XOQVfxRiEALnJ2ldCUowtWCR/bx1fBoCnf+puD8A7of3bP+v8X7X5l3kBy6EAAiwuW1oFsPzgUpZe2gHEfVPfVyJbQ+Pfi3eaa0BJkhD7gF+HchvzHPsXu7Bjn49F5zN8RXCq42hEmtMpgjdPSik1+KfGC9Rhhjki5BGFOh7P2jY+iolml5qNctvK6etiatjdxQ1O45ZT/UftEOE3bqvtRDIu1wZeAkdbRF7T2U5EBo1LadSY/qpN8LQwvoPx7dm69oGa7qbVQwQGv8Rx1KnFcVKDBsR6FEuP0M8z0krZRXo2dGVIpgrQZACxNubaIRKbn2lHsmgpZjlM0jyXZTtIjE+SYmfuBjMu9EnBAg0J7SSxU5jouEQW2Q64r7UQXTsi1rKzExqu1A+X6jlOatkw28nEF02OfXiKPKIS2pJjVzEZbbh3ISyxJ723GZchu0mFSaVLr173282DSdX1rOok5z8RfYdVfiCXH0hnhKAmyqsd8skpPf7wplGBVT7cT4/7Y57eJEJrEuNezyksAufPrcCIunfeVFXdJ2HqpdFkoZ1KqYlMukBm/Ja/KOWwUGBVA2qzUUANCRoyyqbbUiKXJc7FH9nO5zSHfEcye4+oFvHDWEbe54KHMapyEvmBaIey6DQ17eZMJ5Ccps8yPphAoIU0opigjziaqITS2h0IHAZOJg0ztFwK+wTcwrzSCwDrvIzxyBPmHfMMp0JDJH6JwCfgTFgBHAL+5BPz43dD42VNaMz8iDuhIZIjIvBGKEtHgB+QcNKFyZXG6iChNoVd1bfMfWhI0wE4A1wvQzAyX4bCzEmN3qWmgWUYfPyXYZ1S1F1muqjkufMQgMCRPQfeuAniJ9At5KbEXeAZLuxWVeHGxnWjrMG7WLQ1mFfOaLe47BD4atnWdUN2Z13y3lDgbc+HC6sgr7+IwIsjc7PHX98u5CYJ6wVv6hZ2bQUWvb15EHej0/q5rrPikXjbcGDnOhsJmr8hO7LRvBu4V/sNalTIU6RBh6Jrts38i4GTzfts3QMAAAA=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "font/woff2"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/index.js": {
+ "data": "var CLOSURE_NO_DEPS = true;
// Copyright 2006 The Closure Library 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.

/**
 * @fileoverview Bootstrap for the Google JS Library (Closure).
 *
 * In uncompiled mode base.js will attempt to load Closure's deps file, unless
 * the global <code>CLOSURE_NO_DEPS</code> is set to true.  This allows projects
 * to include their own deps file(s) from different locations.
 *
 * Avoid including base.js more than once. This is strictly discouraged and not
 * supported. goog.require(...) won't work properly in that case.
 *
 * @provideGoog
 */


/**
 * @define {boolean} Overridden to true by the compiler.
 */
var COMPILED = false;


/**
 * Base namespace for the Closure library.  Checks to see goog is already
 * defined in the current scope before assigning to prevent clobbering if
 * base.js is loaded more than once.
 *
 * @const
 */
var goog = goog || {};

/**
 * Reference to the global object.
 * https://www.ecma-international.org/ecma-262/9.0/index.html#sec-global-object
 *
 * More info on this implementation here:
 * https://docs.google.com/document/d/1NAeW4Wk7I7FV0Y2tcUFvQdGMc89k2vdgSXInw8_nvCI/edit
 *
 * @const
 * @suppress {undefinedVars} self won't be referenced unless `this` is falsy.
 * @type {!Global}
 */
goog.global =
    // Check `this` first for backwards compatibility.
    // Valid unless running as an ES module or in a function wrapper called
    //   without setting `this` properly.
    // Note that base.js can't usefully be imported as an ES module, but it may
    // be compiled into bundles that are loadable as ES modules.
    this ||
    // https://developer.mozilla.org/en-US/docs/Web/API/Window/self
    // For in-page browser environments and workers.
    self;


/**
 * A hook for overriding the define values in uncompiled mode.
 *
 * In uncompiled mode, `CLOSURE_UNCOMPILED_DEFINES` may be defined before
 * loading base.js.  If a key is defined in `CLOSURE_UNCOMPILED_DEFINES`,
 * `goog.define` will use the value instead of the default value.  This
 * allows flags to be overwritten without compilation (this is normally
 * accomplished with the compiler's "define" flag).
 *
 * Example:
 * <pre>
 *   var CLOSURE_UNCOMPILED_DEFINES = {'goog.DEBUG': false};
 * </pre>
 *
 * @type {Object<string, (string|number|boolean)>|undefined}
 */
goog.global.CLOSURE_UNCOMPILED_DEFINES;


/**
 * A hook for overriding the define values in uncompiled or compiled mode,
 * like CLOSURE_UNCOMPILED_DEFINES but effective in compiled code.  In
 * uncompiled code CLOSURE_UNCOMPILED_DEFINES takes precedence.
 *
 * Also unlike CLOSURE_UNCOMPILED_DEFINES the values must be number, boolean or
 * string literals or the compiler will emit an error.
 *
 * While any @define value may be set, only those set with goog.define will be
 * effective for uncompiled code.
 *
 * Example:
 * <pre>
 *   var CLOSURE_DEFINES = {'goog.DEBUG': false} ;
 * </pre>
 *
 * @type {Object<string, (string|number|boolean)>|undefined}
 */
goog.global.CLOSURE_DEFINES;


/**
 * Returns true if the specified value is not undefined.
 *
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is defined.
 * @deprecated Use `val !== undefined` instead.
 */
goog.isDef = function(val) {
  // void 0 always evaluates to undefined and hence we do not need to depend on
  // the definition of the global variable named 'undefined'.
  return val !== void 0;
};

/**
 * Returns true if the specified value is a string.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a string.
 * @deprecated Use `typeof val === 'string'` instead.
 */
goog.isString = function(val) {
  return typeof val == 'string';
};


/**
 * Returns true if the specified value is a boolean.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is boolean.
 * @deprecated Use `typeof val === 'boolean'` instead.
 */
goog.isBoolean = function(val) {
  return typeof val == 'boolean';
};


/**
 * Returns true if the specified value is a number.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a number.
 * @deprecated Use `typeof val === 'number'` instead.
 */
goog.isNumber = function(val) {
  return typeof val == 'number';
};


/**
 * Builds an object structure for the provided namespace path, ensuring that
 * names that already exist are not overwritten. For example:
 * "a.b.c" -> a = {};a.b={};a.b.c={};
 * Used by goog.provide and goog.exportSymbol.
 * @param {string} name name of the object that this file defines.
 * @param {*=} opt_object the object to expose at the end of the path.
 * @param {Object=} opt_objectToExportTo The object to add the path to; default
 *     is `goog.global`.
 * @private
 */
goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
  var parts = name.split('.');
  var cur = opt_objectToExportTo || goog.global;

  // Internet Explorer exhibits strange behavior when throwing errors from
  // methods externed in this manner.  See the testExportSymbolExceptions in
  // base_test.html for an example.
  if (!(parts[0] in cur) && typeof cur.execScript != 'undefined') {
    cur.execScript('var ' + parts[0]);
  }

  for (var part; parts.length && (part = parts.shift());) {
    if (!parts.length && opt_object !== undefined) {
      // last part and we have an object; use it
      cur[part] = opt_object;
    } else if (cur[part] && cur[part] !== Object.prototype[part]) {
      cur = cur[part];
    } else {
      cur = cur[part] = {};
    }
  }
};


/**
 * Defines a named value. In uncompiled mode, the value is retrieved from
 * CLOSURE_DEFINES or CLOSURE_UNCOMPILED_DEFINES if the object is defined and
 * has the property specified, and otherwise used the defined defaultValue.
 * When compiled the default can be overridden using the compiler options or the
 * value set in the CLOSURE_DEFINES object. Returns the defined value so that it
 * can be used safely in modules. Note that the value type MUST be either
 * boolean, number, or string.
 *
 * @param {string} name The distinguished name to provide.
 * @param {T} defaultValue
 * @return {T} The defined value.
 * @template T
 */
goog.define = function(name, defaultValue) {
  var value = defaultValue;
  if (!COMPILED) {
    var uncompiledDefines = goog.global.CLOSURE_UNCOMPILED_DEFINES;
    var defines = goog.global.CLOSURE_DEFINES;
    if (uncompiledDefines &&
        // Anti DOM-clobbering runtime check (b/37736576).
        /** @type {?} */ (uncompiledDefines).nodeType === undefined &&
        Object.prototype.hasOwnProperty.call(uncompiledDefines, name)) {
      value = uncompiledDefines[name];
    } else if (
        defines &&
        // Anti DOM-clobbering runtime check (b/37736576).
        /** @type {?} */ (defines).nodeType === undefined &&
        Object.prototype.hasOwnProperty.call(defines, name)) {
      value = defines[name];
    }
  }
  return value;
};


/**
 * @define {number} Integer year indicating the set of browser features that are
 * guaranteed to be present.  This is defined to include exactly features that
 * work correctly on all "modern" browsers that are stable on January 1 of the
 * specified year.  For example,
 * ```js
 * if (goog.FEATURESET_YEAR >= 2019) {
 *   // use APIs known to be available on all major stable browsers Jan 1, 2019
 * } else {
 *   // polyfill for older browsers
 * }
 * ```
 * This is intended to be the primary define for removing
 * unnecessary browser compatibility code (such as ponyfills and workarounds),
 * and should inform the default value for most other defines:
 * ```js
 * const ASSUME_NATIVE_PROMISE =
 *     goog.define('ASSUME_NATIVE_PROMISE', goog.FEATURESET_YEAR >= 2016);
 * ```
 *
 * The default assumption is that IE9 is the lowest supported browser, which was
 * first available Jan 1, 2012.
 *
 * TODO(user): Reference more thorough documentation when it's available.
 */
goog.FEATURESET_YEAR = goog.define('goog.FEATURESET_YEAR', 2012);


/**
 * @define {boolean} DEBUG is provided as a convenience so that debugging code
 * that should not be included in a production. It can be easily stripped
 * by specifying --define goog.DEBUG=false to the Closure Compiler aka
 * JSCompiler. For example, most toString() methods should be declared inside an
 * "if (goog.DEBUG)" conditional because they are generally used for debugging
 * purposes and it is difficult for the JSCompiler to statically determine
 * whether they are used.
 */
goog.DEBUG = goog.define('goog.DEBUG', true);


/**
 * @define {string} LOCALE defines the locale being used for compilation. It is
 * used to select locale specific data to be compiled in js binary. BUILD rule
 * can specify this value by "--define goog.LOCALE=<locale_name>" as a compiler
 * option.
 *
 * Take into account that the locale code format is important. You should use
 * the canonical Unicode format with hyphen as a delimiter. Language must be
 * lowercase, Language Script - Capitalized, Region - UPPERCASE.
 * There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.
 *
 * See more info about locale codes here:
 * http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers
 *
 * For language codes you should use values defined by ISO 693-1. See it here
 * http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from
 * this rule: the Hebrew language. For legacy reasons the old code (iw) should
 * be used instead of the new code (he).
 *
 */
goog.LOCALE = goog.define('goog.LOCALE', 'en');  // default to en


/**
 * @define {boolean} Whether this code is running on trusted sites.
 *
 * On untrusted sites, several native functions can be defined or overridden by
 * external libraries like Prototype, Datejs, and JQuery and setting this flag
 * to false forces closure to use its own implementations when possible.
 *
 * If your JavaScript can be loaded by a third party site and you are wary about
 * relying on non-standard implementations, specify
 * "--define goog.TRUSTED_SITE=false" to the compiler.
 */
goog.TRUSTED_SITE = goog.define('goog.TRUSTED_SITE', true);


/**
 * @define {boolean} Whether a project is expected to be running in strict mode.
 *
 * This define can be used to trigger alternate implementations compatible with
 * running in EcmaScript Strict mode or warn about unavailable functionality.
 * @see https://goo.gl/PudQ4y
 *
 */
goog.STRICT_MODE_COMPATIBLE = goog.define('goog.STRICT_MODE_COMPATIBLE', false);


/**
 * @define {boolean} Whether code that calls {@link goog.setTestOnly} should
 *     be disallowed in the compilation unit.
 */
goog.DISALLOW_TEST_ONLY_CODE =
    goog.define('goog.DISALLOW_TEST_ONLY_CODE', COMPILED && !goog.DEBUG);


/**
 * @define {boolean} Whether to use a Chrome app CSP-compliant method for
 *     loading scripts via goog.require. @see appendScriptSrcNode_.
 */
goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING =
    goog.define('goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING', false);


/**
 * Defines a namespace in Closure.
 *
 * A namespace may only be defined once in a codebase. It may be defined using
 * goog.provide() or goog.module().
 *
 * The presence of one or more goog.provide() calls in a file indicates
 * that the file defines the given objects/namespaces.
 * Provided symbols must not be null or undefined.
 *
 * In addition, goog.provide() creates the object stubs for a namespace
 * (for example, goog.provide("goog.foo.bar") will create the object
 * goog.foo.bar if it does not already exist).
 *
 * Build tools also scan for provide/require/module statements
 * to discern dependencies, build dependency files (see deps.js), etc.
 *
 * @see goog.require
 * @see goog.module
 * @param {string} name Namespace provided by this file in the form
 *     "goog.package.part".
 */
goog.provide = function(name) {
  if (goog.isInModuleLoader_()) {
    throw new Error('goog.provide cannot be used within a module.');
  }
  if (!COMPILED) {
    // Ensure that the same namespace isn't provided twice.
    // A goog.module/goog.provide maps a goog.require to a specific file
    if (goog.isProvided_(name)) {
      throw new Error('Namespace "' + name + '" already declared.');
    }
  }

  goog.constructNamespace_(name);
};


/**
 * @param {string} name Namespace provided by this file in the form
 *     "goog.package.part".
 * @param {Object=} opt_obj The object to embed in the namespace.
 * @private
 */
goog.constructNamespace_ = function(name, opt_obj) {
  if (!COMPILED) {
    delete goog.implicitNamespaces_[name];

    var namespace = name;
    while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {
      if (goog.getObjectByName(namespace)) {
        break;
      }
      goog.implicitNamespaces_[namespace] = true;
    }
  }

  goog.exportPath_(name, opt_obj);
};


/**
 * Returns CSP nonce, if set for any script tag.
 * @param {?Window=} opt_window The window context used to retrieve the nonce.
 *     Defaults to global context.
 * @return {string} CSP nonce or empty string if no nonce is present.
 */
goog.getScriptNonce = function(opt_window) {
  if (opt_window && opt_window != goog.global) {
    return goog.getScriptNonce_(opt_window.document);
  }
  if (goog.cspNonce_ === null) {
    goog.cspNonce_ = goog.getScriptNonce_(goog.global.document);
  }
  return goog.cspNonce_;
};


/**
 * According to the CSP3 spec a nonce must be a valid base64 string.
 * @see https://www.w3.org/TR/CSP3/#grammardef-base64-value
 * @private @const
 */
goog.NONCE_PATTERN_ = /^[\w+/_-]+[=]{0,2}$/;


/**
 * @private {?string}
 */
goog.cspNonce_ = null;


/**
 * Returns CSP nonce, if set for any script tag.
 * @param {!Document} doc
 * @return {string} CSP nonce or empty string if no nonce is present.
 * @private
 */
goog.getScriptNonce_ = function(doc) {
  var script = doc.querySelector && doc.querySelector('script[nonce]');
  if (script) {
    // Try to get the nonce from the IDL property first, because browsers that
    // implement additional nonce protection features (currently only Chrome) to
    // prevent nonce stealing via CSS do not expose the nonce via attributes.
    // See https://github.com/whatwg/html/issues/2369
    var nonce = script['nonce'] || script.getAttribute('nonce');
    if (nonce && goog.NONCE_PATTERN_.test(nonce)) {
      return nonce;
    }
  }
  return '';
};


/**
 * Module identifier validation regexp.
 * Note: This is a conservative check, it is very possible to be more lenient,
 *   the primary exclusion here is "/" and "\" and a leading ".", these
 *   restrictions are intended to leave the door open for using goog.require
 *   with relative file paths rather than module identifiers.
 * @private
 */
goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;


/**
 * Defines a module in Closure.
 *
 * Marks that this file must be loaded as a module and claims the namespace.
 *
 * A namespace may only be defined once in a codebase. It may be defined using
 * goog.provide() or goog.module().
 *
 * goog.module() has three requirements:
 * - goog.module may not be used in the same file as goog.provide.
 * - goog.module must be the first statement in the file.
 * - only one goog.module is allowed per file.
 *
 * When a goog.module annotated file is loaded, it is enclosed in
 * a strict function closure. This means that:
 * - any variables declared in a goog.module file are private to the file
 * (not global), though the compiler is expected to inline the module.
 * - The code must obey all the rules of "strict" JavaScript.
 * - the file will be marked as "use strict"
 *
 * NOTE: unlike goog.provide, goog.module does not declare any symbols by
 * itself. If declared symbols are desired, use
 * goog.module.declareLegacyNamespace().
 *
 *
 * See the public goog.module proposal: http://goo.gl/Va1hin
 *
 * @param {string} name Namespace provided by this file in the form
 *     "goog.package.part", is expected but not required.
 * @return {void}
 */
goog.module = function(name) {
  if (typeof name !== 'string' || !name ||
      name.search(goog.VALID_MODULE_RE_) == -1) {
    throw new Error('Invalid module identifier');
  }
  if (!goog.isInGoogModuleLoader_()) {
    throw new Error(
        'Module ' + name + ' has been loaded incorrectly. Note, ' +
        'modules cannot be loaded as normal scripts. They require some kind of ' +
        'pre-processing step. You\'re likely trying to load a module via a ' +
        'script tag or as a part of a concatenated bundle without rewriting the ' +
        'module. For more info see: ' +
        'https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.');
  }
  if (goog.moduleLoaderState_.moduleName) {
    throw new Error('goog.module may only be called once per module.');
  }

  // Store the module name for the loader.
  goog.moduleLoaderState_.moduleName = name;
  if (!COMPILED) {
    // Ensure that the same namespace isn't provided twice.
    // A goog.module/goog.provide maps a goog.require to a specific file
    if (goog.isProvided_(name)) {
      throw new Error('Namespace "' + name + '" already declared.');
    }
    delete goog.implicitNamespaces_[name];
  }
};


/**
 * @param {string} name The module identifier.
 * @return {?} The module exports for an already loaded module or null.
 *
 * Note: This is not an alternative to goog.require, it does not
 * indicate a hard dependency, instead it is used to indicate
 * an optional dependency or to access the exports of a module
 * that has already been loaded.
 * @suppress {missingProvide}
 */
goog.module.get = function(name) {
  return goog.module.getInternal_(name);
};


/**
 * @param {string} name The module identifier.
 * @return {?} The module exports for an already loaded module or null.
 * @private
 */
goog.module.getInternal_ = function(name) {
  if (!COMPILED) {
    if (name in goog.loadedModules_) {
      return goog.loadedModules_[name].exports;
    } else if (!goog.implicitNamespaces_[name]) {
      var ns = goog.getObjectByName(name);
      return ns != null ? ns : null;
    }
  }
  return null;
};


/**
 * Types of modules the debug loader can load.
 * @enum {string}
 */
goog.ModuleType = {
  ES6: 'es6',
  GOOG: 'goog'
};


/**
 * @private {?{
 *   moduleName: (string|undefined),
 *   declareLegacyNamespace:boolean,
 *   type: ?goog.ModuleType
 * }}
 */
goog.moduleLoaderState_ = null;


/**
 * @private
 * @return {boolean} Whether a goog.module or an es6 module is currently being
 *     initialized.
 */
goog.isInModuleLoader_ = function() {
  return goog.isInGoogModuleLoader_() || goog.isInEs6ModuleLoader_();
};


/**
 * @private
 * @return {boolean} Whether a goog.module is currently being initialized.
 */
goog.isInGoogModuleLoader_ = function() {
  return !!goog.moduleLoaderState_ &&
      goog.moduleLoaderState_.type == goog.ModuleType.GOOG;
};


/**
 * @private
 * @return {boolean} Whether an es6 module is currently being initialized.
 */
goog.isInEs6ModuleLoader_ = function() {
  var inLoader = !!goog.moduleLoaderState_ &&
      goog.moduleLoaderState_.type == goog.ModuleType.ES6;

  if (inLoader) {
    return true;
  }

  var jscomp = goog.global['$jscomp'];

  if (jscomp) {
    // jscomp may not have getCurrentModulePath if this is a compiled bundle
    // that has some of the runtime, but not all of it. This can happen if
    // optimizations are turned on so the unused runtime is removed but renaming
    // and Closure pass are off (so $jscomp is still named $jscomp and the
    // goog.provide/require calls still exist).
    if (typeof jscomp.getCurrentModulePath != 'function') {
      return false;
    }

    // Bundled ES6 module.
    return !!jscomp.getCurrentModulePath();
  }

  return false;
};


/**
 * Provide the module's exports as a globally accessible object under the
 * module's declared name.  This is intended to ease migration to goog.module
 * for files that have existing usages.
 * @suppress {missingProvide}
 */
goog.module.declareLegacyNamespace = function() {
  if (!COMPILED && !goog.isInGoogModuleLoader_()) {
    throw new Error(
        'goog.module.declareLegacyNamespace must be called from ' +
        'within a goog.module');
  }
  if (!COMPILED && !goog.moduleLoaderState_.moduleName) {
    throw new Error(
        'goog.module must be called prior to ' +
        'goog.module.declareLegacyNamespace.');
  }
  goog.moduleLoaderState_.declareLegacyNamespace = true;
};


/**
 * Associates an ES6 module with a Closure module ID so that is available via
 * goog.require. The associated ID  acts like a goog.module ID - it does not
 * create any global names, it is merely available via goog.require /
 * goog.module.get / goog.forwardDeclare / goog.requireType. goog.require and
 * goog.module.get will return the entire module as if it was import *'d. This
 * allows Closure files to reference ES6 modules for the sake of migration.
 *
 * @param {string} namespace
 * @suppress {missingProvide}
 */
goog.declareModuleId = function(namespace) {
  if (!COMPILED) {
    if (!goog.isInEs6ModuleLoader_()) {
      throw new Error(
          'goog.declareModuleId may only be called from ' +
          'within an ES6 module');
    }
    if (goog.moduleLoaderState_ && goog.moduleLoaderState_.moduleName) {
      throw new Error(
          'goog.declareModuleId may only be called once per module.');
    }
    if (namespace in goog.loadedModules_) {
      throw new Error(
          'Module with namespace "' + namespace + '" already exists.');
    }
  }
  if (goog.moduleLoaderState_) {
    // Not bundled - debug loading.
    goog.moduleLoaderState_.moduleName = namespace;
  } else {
    // Bundled - not debug loading, no module loader state.
    var jscomp = goog.global['$jscomp'];
    if (!jscomp || typeof jscomp.getCurrentModulePath != 'function') {
      throw new Error(
          'Module with namespace "' + namespace +
          '" has been loaded incorrectly.');
    }
    var exports = jscomp.require(jscomp.getCurrentModulePath());
    goog.loadedModules_[namespace] = {
      exports: exports,
      type: goog.ModuleType.ES6,
      moduleId: namespace
    };
  }
};


/**
 * Marks that the current file should only be used for testing, and never for
 * live code in production.
 *
 * In the case of unit tests, the message may optionally be an exact namespace
 * for the test (e.g. 'goog.stringTest'). The linter will then ignore the extra
 * provide (if not explicitly defined in the code).
 *
 * @param {string=} opt_message Optional message to add to the error that's
 *     raised when used in production code.
 */
goog.setTestOnly = function(opt_message) {
  if (goog.DISALLOW_TEST_ONLY_CODE) {
    opt_message = opt_message || '';
    throw new Error(
        'Importing test-only code into non-debug environment' +
        (opt_message ? ': ' + opt_message : '.'));
  }
};


/**
 * Forward declares a symbol. This is an indication to the compiler that the
 * symbol may be used in the source yet is not required and may not be provided
 * in compilation.
 *
 * The most common usage of forward declaration is code that takes a type as a
 * function parameter but does not need to require it. By forward declaring
 * instead of requiring, no hard dependency is made, and (if not required
 * elsewhere) the namespace may never be required and thus, not be pulled
 * into the JavaScript binary. If it is required elsewhere, it will be type
 * checked as normal.
 *
 * Before using goog.forwardDeclare, please read the documentation at
 * https://github.com/google/closure-compiler/wiki/Bad-Type-Annotation to
 * understand the options and tradeoffs when working with forward declarations.
 *
 * @param {string} name The namespace to forward declare in the form of
 *     "goog.package.part".
 */
goog.forwardDeclare = function(name) {};


/**
 * Forward declare type information. Used to assign types to goog.global
 * referenced object that would otherwise result in unknown type references
 * and thus block property disambiguation.
 */
goog.forwardDeclare('Document');
goog.forwardDeclare('HTMLScriptElement');
goog.forwardDeclare('XMLHttpRequest');


if (!COMPILED) {
  /**
   * Check if the given name has been goog.provided. This will return false for
   * names that are available only as implicit namespaces.
   * @param {string} name name of the object to look for.
   * @return {boolean} Whether the name has been provided.
   * @private
   */
  goog.isProvided_ = function(name) {
    return (name in goog.loadedModules_) ||
        (!goog.implicitNamespaces_[name] && goog.getObjectByName(name) != null);
  };

  /**
   * Namespaces implicitly defined by goog.provide. For example,
   * goog.provide('goog.events.Event') implicitly declares that 'goog' and
   * 'goog.events' must be namespaces.
   *
   * @type {!Object<string, (boolean|undefined)>}
   * @private
   */
  goog.implicitNamespaces_ = {'goog.module': true};

  // NOTE: We add goog.module as an implicit namespace as goog.module is defined
  // here and because the existing module package has not been moved yet out of
  // the goog.module namespace. This satisifies both the debug loader and
  // ahead-of-time dependency management.
}


/**
 * Returns an object based on its fully qualified external name.  The object
 * is not found if null or undefined.  If you are using a compilation pass that
 * renames property names beware that using this function will not find renamed
 * properties.
 *
 * @param {string} name The fully qualified name.
 * @param {Object=} opt_obj The object within which to look; default is
 *     |goog.global|.
 * @return {?} The value (object or primitive) or, if not found, null.
 */
goog.getObjectByName = function(name, opt_obj) {
  var parts = name.split('.');
  var cur = opt_obj || goog.global;
  for (var i = 0; i < parts.length; i++) {
    cur = cur[parts[i]];
    if (cur == null) {
      return null;
    }
  }
  return cur;
};


/**
 * Globalizes a whole namespace, such as goog or goog.lang.
 *
 * @param {!Object} obj The namespace to globalize.
 * @param {Object=} opt_global The object to add the properties to.
 * @deprecated Properties may be explicitly exported to the global scope, but
 *     this should no longer be done in bulk.
 */
goog.globalize = function(obj, opt_global) {
  var global = opt_global || goog.global;
  for (var x in obj) {
    global[x] = obj[x];
  }
};


/**
 * Adds a dependency from a file to the files it requires.
 * @param {string} relPath The path to the js file.
 * @param {!Array<string>} provides An array of strings with
 *     the names of the objects this file provides.
 * @param {!Array<string>} requires An array of strings with
 *     the names of the objects this file requires.
 * @param {boolean|!Object<string>=} opt_loadFlags Parameters indicating
 *     how the file must be loaded.  The boolean 'true' is equivalent
 *     to {'module': 'goog'} for backwards-compatibility.  Valid properties
 *     and values include {'module': 'goog'} and {'lang': 'es6'}.
 */
goog.addDependency = function(relPath, provides, requires, opt_loadFlags) {
  if (!COMPILED && goog.DEPENDENCIES_ENABLED) {
    goog.debugLoader_.addDependency(relPath, provides, requires, opt_loadFlags);
  }
};




// NOTE(nnaze): The debug DOM loader was included in base.js as an original way
// to do "debug-mode" development.  The dependency system can sometimes be
// confusing, as can the debug DOM loader's asynchronous nature.
//
// With the DOM loader, a call to goog.require() is not blocking -- the script
// will not load until some point after the current script.  If a namespace is
// needed at runtime, it needs to be defined in a previous script, or loaded via
// require() with its registered dependencies.
//
// User-defined namespaces may need their own deps file. For a reference on
// creating a deps file, see:
// Externally: https://developers.google.com/closure/library/docs/depswriter
//
// Because of legacy clients, the DOM loader can't be easily removed from
// base.js.  Work was done to make it disableable or replaceable for
// different environments (DOM-less JavaScript interpreters like Rhino or V8,
// for example). See bootstrap/ for more information.


/**
 * @define {boolean} Whether to enable the debug loader.
 *
 * If enabled, a call to goog.require() will attempt to load the namespace by
 * appending a script tag to the DOM (if the namespace has been registered).
 *
 * If disabled, goog.require() will simply assert that the namespace has been
 * provided (and depend on the fact that some outside tool correctly ordered
 * the script).
 */
goog.ENABLE_DEBUG_LOADER = goog.define('goog.ENABLE_DEBUG_LOADER', true);


/**
 * @param {string} msg
 * @private
 */
goog.logToConsole_ = function(msg) {
  if (goog.global.console) {
    goog.global.console['error'](msg);
  }
};


/**
 * Implements a system for the dynamic resolution of dependencies that works in
 * parallel with the BUILD system.
 *
 * Note that all calls to goog.require will be stripped by the compiler.
 *
 * @see goog.provide
 * @param {string} namespace Namespace (as was given in goog.provide,
 *     goog.module, or goog.declareModuleId) in the form
 *     "goog.package.part".
 * @return {?} If called within a goog.module or ES6 module file, the associated
 *     namespace or module otherwise null.
 */
goog.require = function(namespace) {
  if (!COMPILED) {
    // Might need to lazy load on old IE.
    if (goog.ENABLE_DEBUG_LOADER) {
      goog.debugLoader_.requested(namespace);
    }

    // If the object already exists we do not need to do anything.
    if (goog.isProvided_(namespace)) {
      if (goog.isInModuleLoader_()) {
        return goog.module.getInternal_(namespace);
      }
    } else if (goog.ENABLE_DEBUG_LOADER) {
      var moduleLoaderState = goog.moduleLoaderState_;
      goog.moduleLoaderState_ = null;
      try {
        goog.debugLoader_.load_(namespace);
      } finally {
        goog.moduleLoaderState_ = moduleLoaderState;
      }
    }

    return null;
  }
};


/**
 * Requires a symbol for its type information. This is an indication to the
 * compiler that the symbol may appear in type annotations, yet it is not
 * referenced at runtime.
 *
 * When called within a goog.module or ES6 module file, the return value may be
 * assigned to or destructured into a variable, but it may not be otherwise used
 * in code outside of a type annotation.
 *
 * Note that all calls to goog.requireType will be stripped by the compiler.
 *
 * @param {string} namespace Namespace (as was given in goog.provide,
 *     goog.module, or goog.declareModuleId) in the form
 *     "goog.package.part".
 * @return {?}
 */
goog.requireType = function(namespace) {
  // Return an empty object so that single-level destructuring of the return
  // value doesn't crash at runtime when using the debug loader. Multi-level
  // destructuring isn't supported.
  return {};
};


/**
 * Path for included scripts.
 * @type {string}
 */
goog.basePath = '';


/**
 * A hook for overriding the base path.
 * @type {string|undefined}
 */
goog.global.CLOSURE_BASE_PATH;


/**
 * Whether to attempt to load Closure's deps file. By default, when uncompiled,
 * deps files will attempt to be loaded.
 * @type {boolean|undefined}
 */
goog.global.CLOSURE_NO_DEPS;


/**
 * A function to import a single script. This is meant to be overridden when
 * Closure is being run in non-HTML contexts, such as web workers. It's defined
 * in the global scope so that it can be set before base.js is loaded, which
 * allows deps.js to be imported properly.
 *
 * The first parameter the script source, which is a relative URI. The second,
 * optional parameter is the script contents, in the event the script needed
 * transformation. It should return true if the script was imported, false
 * otherwise.
 * @type {(function(string, string=): boolean)|undefined}
 */
goog.global.CLOSURE_IMPORT_SCRIPT;


/**
 * Null function used for default values of callbacks, etc.
 * @return {void} Nothing.
 */
goog.nullFunction = function() {};


/**
 * When defining a class Foo with an abstract method bar(), you can do:
 * Foo.prototype.bar = goog.abstractMethod
 *
 * Now if a subclass of Foo fails to override bar(), an error will be thrown
 * when bar() is invoked.
 *
 * @type {!Function}
 * @throws {Error} when invoked to indicate the method should be overridden.
 * @deprecated Use "@abstract" annotation instead of goog.abstractMethod in new
 *     code. See
 *     https://github.com/google/closure-compiler/wiki/@abstract-classes-and-methods
 */
goog.abstractMethod = function() {
  throw new Error('unimplemented abstract method');
};


/**
 * Adds a `getInstance` static method that always returns the same
 * instance object.
 * @param {!Function} ctor The constructor for the class to add the static
 *     method to.
 * @suppress {missingProperties} 'instance_' isn't a property on 'Function'
 *     but we don't have a better type to use here.
 */
goog.addSingletonGetter = function(ctor) {
  // instance_ is immediately set to prevent issues with sealed constructors
  // such as are encountered when a constructor is returned as the export object
  // of a goog.module in unoptimized code.
  // Delcare type to avoid conformance violations that ctor.instance_ is unknown
  /** @type {undefined|!Object} @suppress {underscore} */
  ctor.instance_ = undefined;
  ctor.getInstance = function() {
    if (ctor.instance_) {
      return ctor.instance_;
    }
    if (goog.DEBUG) {
      // NOTE: JSCompiler can't optimize away Array#push.
      goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;
    }
    // Cast to avoid conformance violations that ctor.instance_ is unknown
    return /** @type {!Object|undefined} */ (ctor.instance_) = new ctor;
  };
};


/**
 * All singleton classes that have been instantiated, for testing. Don't read
 * it directly, use the `goog.testing.singleton` module. The compiler
 * removes this variable if unused.
 * @type {!Array<!Function>}
 * @private
 */
goog.instantiatedSingletons_ = [];


/**
 * @define {boolean} Whether to load goog.modules using `eval` when using
 * the debug loader.  This provides a better debugging experience as the
 * source is unmodified and can be edited using Chrome Workspaces or similar.
 * However in some environments the use of `eval` is banned
 * so we provide an alternative.
 */
goog.LOAD_MODULE_USING_EVAL = goog.define('goog.LOAD_MODULE_USING_EVAL', true);


/**
 * @define {boolean} Whether the exports of goog.modules should be sealed when
 * possible.
 */
goog.SEAL_MODULE_EXPORTS = goog.define('goog.SEAL_MODULE_EXPORTS', goog.DEBUG);


/**
 * The registry of initialized modules:
 * The module identifier or path to module exports map.
 * @private @const {!Object<string, {exports:?,type:string,moduleId:string}>}
 */
goog.loadedModules_ = {};


/**
 * True if the debug loader enabled and used.
 * @const {boolean}
 */
goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;


/**
 * @define {string} How to decide whether to transpile.  Valid values
 * are 'always', 'never', and 'detect'.  The default ('detect') is to
 * use feature detection to determine which language levels need
 * transpilation.
 */
// NOTE(sdh): we could expand this to accept a language level to bypass
// detection: e.g. goog.TRANSPILE == 'es5' would transpile ES6 files but
// would leave ES3 and ES5 files alone.
goog.TRANSPILE = goog.define('goog.TRANSPILE', 'detect');

/**
 * @define {boolean} If true assume that ES modules have already been
 * transpiled by the jscompiler (in the same way that transpile.js would
 * transpile them - to jscomp modules). Useful only for servers that wish to use
 * the debug loader and transpile server side. Thus this is only respected if
 * goog.TRANSPILE is "never".
 */
goog.ASSUME_ES_MODULES_TRANSPILED =
    goog.define('goog.ASSUME_ES_MODULES_TRANSPILED', false);


/**
 * @define {string} If a file needs to be transpiled what the output language
 * should be. By default this is the highest language level this file detects
 * the current environment supports. Generally this flag should not be set, but
 * it could be useful to override. Example: If the current environment supports
 * ES6 then by default ES7+ files will be transpiled to ES6, unless this is
 * overridden.
 *
 * Valid values include: es3, es5, es6, es7, and es8. Anything not recognized
 * is treated as es3.
 *
 * Note that setting this value does not force transpilation. Just if
 * transpilation occurs this will be the output. So this is most useful when
 * goog.TRANSPILE is set to 'always' and then forcing the language level to be
 * something lower than what the environment detects.
 */
goog.TRANSPILE_TO_LANGUAGE = goog.define('goog.TRANSPILE_TO_LANGUAGE', '');


/**
 * @define {string} Path to the transpiler.  Executing the script at this
 * path (relative to base.js) should define a function $jscomp.transpile.
 */
goog.TRANSPILER = goog.define('goog.TRANSPILER', 'transpile.js');


/**
 * @package {?boolean}
 * Visible for testing.
 */
goog.hasBadLetScoping = null;


/**
 * @return {boolean}
 * @package Visible for testing.
 */
goog.useSafari10Workaround = function() {
  if (goog.hasBadLetScoping == null) {
    var hasBadLetScoping;
    try {
      hasBadLetScoping = !eval(
          '"use strict";' +
          'let x = 1; function f() { return typeof x; };' +
          'f() == "number";');
    } catch (e) {
      // Assume that ES6 syntax isn't supported.
      hasBadLetScoping = false;
    }
    goog.hasBadLetScoping = hasBadLetScoping;
  }
  return goog.hasBadLetScoping;
};


/**
 * @param {string} moduleDef
 * @return {string}
 * @package Visible for testing.
 */
goog.workaroundSafari10EvalBug = function(moduleDef) {
  return '(function(){' + moduleDef +
      '\n' +  // Terminate any trailing single line comment.
      ';' +   // Terminate any trailing expression.
      '})();\n';
};


/**
 * @param {function(?):?|string} moduleDef The module definition.
 */
goog.loadModule = function(moduleDef) {
  // NOTE: we allow function definitions to be either in the from
  // of a string to eval (which keeps the original source intact) or
  // in a eval forbidden environment (CSP) we allow a function definition
  // which in its body must call `goog.module`, and return the exports
  // of the module.
  var previousState = goog.moduleLoaderState_;
  try {
    goog.moduleLoaderState_ = {
      moduleName: '',
      declareLegacyNamespace: false,
      type: goog.ModuleType.GOOG
    };
    var exports;
    if (goog.isFunction(moduleDef)) {
      exports = moduleDef.call(undefined, {});
    } else if (typeof moduleDef === 'string') {
      if (goog.useSafari10Workaround()) {
        moduleDef = goog.workaroundSafari10EvalBug(moduleDef);
      }

      exports = goog.loadModuleFromSource_.call(undefined, moduleDef);
    } else {
      throw new Error('Invalid module definition');
    }

    var moduleName = goog.moduleLoaderState_.moduleName;
    if (typeof moduleName === 'string' && moduleName) {
      // Don't seal legacy namespaces as they may be used as a parent of
      // another namespace
      if (goog.moduleLoaderState_.declareLegacyNamespace) {
        goog.constructNamespace_(moduleName, exports);
      } else if (
          goog.SEAL_MODULE_EXPORTS && Object.seal &&
          typeof exports == 'object' && exports != null) {
        Object.seal(exports);
      }

      var data = {
        exports: exports,
        type: goog.ModuleType.GOOG,
        moduleId: goog.moduleLoaderState_.moduleName
      };
      goog.loadedModules_[moduleName] = data;
    } else {
      throw new Error('Invalid module name \"' + moduleName + '\"');
    }
  } finally {
    goog.moduleLoaderState_ = previousState;
  }
};


/**
 * @private @const
 */
goog.loadModuleFromSource_ = /** @type {function(string):?} */ (function() {
  // NOTE: we avoid declaring parameters or local variables here to avoid
  // masking globals or leaking values into the module definition.
  'use strict';
  var exports = {};
  eval(arguments[0]);
  return exports;
});


/**
 * Normalize a file path by removing redundant ".." and extraneous "." file
 * path components.
 * @param {string} path
 * @return {string}
 * @private
 */
goog.normalizePath_ = function(path) {
  var components = path.split('/');
  var i = 0;
  while (i < components.length) {
    if (components[i] == '.') {
      components.splice(i, 1);
    } else if (
        i && components[i] == '..' && components[i - 1] &&
        components[i - 1] != '..') {
      components.splice(--i, 2);
    } else {
      i++;
    }
  }
  return components.join('/');
};


/**
 * Provides a hook for loading a file when using Closure's goog.require() API
 * with goog.modules.  In particular this hook is provided to support Node.js.
 *
 * @type {(function(string):string)|undefined}
 */
goog.global.CLOSURE_LOAD_FILE_SYNC;


/**
 * Loads file by synchronous XHR. Should not be used in production environments.
 * @param {string} src Source URL.
 * @return {?string} File contents, or null if load failed.
 * @private
 */
goog.loadFileSync_ = function(src) {
  if (goog.global.CLOSURE_LOAD_FILE_SYNC) {
    return goog.global.CLOSURE_LOAD_FILE_SYNC(src);
  } else {
    try {
      /** @type {XMLHttpRequest} */
      var xhr = new goog.global['XMLHttpRequest']();
      xhr.open('get', src, false);
      xhr.send();
      // NOTE: Successful http: requests have a status of 200, but successful
      // file: requests may have a status of zero.  Any other status, or a
      // thrown exception (particularly in case of file: requests) indicates
      // some sort of error, which we treat as a missing or unavailable file.
      return xhr.status == 0 || xhr.status == 200 ? xhr.responseText : null;
    } catch (err) {
      // No need to rethrow or log, since errors should show up on their own.
      return null;
    }
  }
};


/**
 * Lazily retrieves the transpiler and applies it to the source.
 * @param {string} code JS code.
 * @param {string} path Path to the code.
 * @param {string} target Language level output.
 * @return {string} The transpiled code.
 * @private
 */
goog.transpile_ = function(code, path, target) {
  var jscomp = goog.global['$jscomp'];
  if (!jscomp) {
    goog.global['$jscomp'] = jscomp = {};
  }
  var transpile = jscomp.transpile;
  if (!transpile) {
    var transpilerPath = goog.basePath + goog.TRANSPILER;
    var transpilerCode = goog.loadFileSync_(transpilerPath);
    if (transpilerCode) {
      // This must be executed synchronously, since by the time we know we
      // need it, we're about to load and write the ES6 code synchronously,
      // so a normal script-tag load will be too slow. Wrapped in a function
      // so that code is eval'd in the global scope.
      (function() {
        (0, eval)(transpilerCode + '\n//# sourceURL=' + transpilerPath);
      }).call(goog.global);
      // Even though the transpiler is optional, if $gwtExport is found, it's
      // a sign the transpiler was loaded and the $jscomp.transpile *should*
      // be there.
      if (goog.global['$gwtExport'] && goog.global['$gwtExport']['$jscomp'] &&
          !goog.global['$gwtExport']['$jscomp']['transpile']) {
        throw new Error(
            'The transpiler did not properly export the "transpile" ' +
            'method. $gwtExport: ' + JSON.stringify(goog.global['$gwtExport']));
      }
      // transpile.js only exports a single $jscomp function, transpile. We
      // grab just that and add it to the existing definition of $jscomp which
      // contains the polyfills.
      goog.global['$jscomp'].transpile =
          goog.global['$gwtExport']['$jscomp']['transpile'];
      jscomp = goog.global['$jscomp'];
      transpile = jscomp.transpile;
    }
  }
  if (!transpile) {
    // The transpiler is an optional component.  If it's not available then
    // replace it with a pass-through function that simply logs.
    var suffix = ' requires transpilation but no transpiler was found.';
    transpile = jscomp.transpile = function(code, path) {
      // TODO(sdh): figure out some way to get this error to show up
      // in test results, noting that the failure may occur in many
      // different ways, including in loadModule() before the test
      // runner even comes up.
      goog.logToConsole_(path + suffix);
      return code;
    };
  }
  // Note: any transpilation errors/warnings will be logged to the console.
  return transpile(code, path, target);
};

//==============================================================================
// Language Enhancements
//==============================================================================


/**
 * This is a "fixed" version of the typeof operator.  It differs from the typeof
 * operator in such a way that null returns 'null' and arrays return 'array'.
 * @param {?} value The value to get the type of.
 * @return {string} The name of the type.
 */
goog.typeOf = function(value) {
  var s = typeof value;
  if (s == 'object') {
    if (value) {
      // Check these first, so we can avoid calling Object.prototype.toString if
      // possible.
      //
      // IE improperly marshals typeof across execution contexts, but a
      // cross-context object will still return false for "instanceof Object".
      if (value instanceof Array) {
        return 'array';
      } else if (value instanceof Object) {
        return s;
      }

      // HACK: In order to use an Object prototype method on the arbitrary
      //   value, the compiler requires the value be cast to type Object,
      //   even though the ECMA spec explicitly allows it.
      var className = Object.prototype.toString.call(
          /** @type {!Object} */ (value));
      // In Firefox 3.6, attempting to access iframe window objects' length
      // property throws an NS_ERROR_FAILURE, so we need to special-case it
      // here.
      if (className == '[object Window]') {
        return 'object';
      }

      // We cannot always use constructor == Array or instanceof Array because
      // different frames have different Array objects. In IE6, if the iframe
      // where the array was created is destroyed, the array loses its
      // prototype. Then dereferencing val.splice here throws an exception, so
      // we can't use goog.isFunction. Calling typeof directly returns 'unknown'
      // so that will work. In this case, this function will return false and
      // most array functions will still work because the array is still
      // array-like (supports length and []) even though it has lost its
      // prototype.
      // Mark Miller noticed that Object.prototype.toString
      // allows access to the unforgeable [[Class]] property.
      //  15.2.4.2 Object.prototype.toString ( )
      //  When the toString method is called, the following steps are taken:
      //      1. Get the [[Class]] property of this object.
      //      2. Compute a string value by concatenating the three strings
      //         "[object ", Result(1), and "]".
      //      3. Return Result(2).
      // and this behavior survives the destruction of the execution context.
      if ((className == '[object Array]' ||
           // In IE all non value types are wrapped as objects across window
           // boundaries (not iframe though) so we have to do object detection
           // for this edge case.
           typeof value.length == 'number' &&
               typeof value.splice != 'undefined' &&
               typeof value.propertyIsEnumerable != 'undefined' &&
               !value.propertyIsEnumerable('splice')

               )) {
        return 'array';
      }
      // HACK: There is still an array case that fails.
      //     function ArrayImpostor() {}
      //     ArrayImpostor.prototype = [];
      //     var impostor = new ArrayImpostor;
      // this can be fixed by getting rid of the fast path
      // (value instanceof Array) and solely relying on
      // (value && Object.prototype.toString.vall(value) === '[object Array]')
      // but that would require many more function calls and is not warranted
      // unless closure code is receiving objects from untrusted sources.

      // IE in cross-window calls does not correctly marshal the function type
      // (it appears just as an object) so we cannot use just typeof val ==
      // 'function'. However, if the object has a call property, it is a
      // function.
      if ((className == '[object Function]' ||
           typeof value.call != 'undefined' &&
               typeof value.propertyIsEnumerable != 'undefined' &&
               !value.propertyIsEnumerable('call'))) {
        return 'function';
      }

    } else {
      return 'null';
    }

  } else if (s == 'function' && typeof value.call == 'undefined') {
    // In Safari typeof nodeList returns 'function', and on Firefox typeof
    // behaves similarly for HTML{Applet,Embed,Object}, Elements and RegExps. We
    // would like to return object for those and we can detect an invalid
    // function by making sure that the function object has a call method.
    return 'object';
  }
  return s;
};


/**
 * Returns true if the specified value is null.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is null.
 * @deprecated Use `val === null` instead.
 */
goog.isNull = function(val) {
  return val === null;
};


/**
 * Returns true if the specified value is defined and not null.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is defined and not null.
 * @deprecated Use `val != null` instead.
 */
goog.isDefAndNotNull = function(val) {
  // Note that undefined == null.
  return val != null;
};


/**
 * Returns true if the specified value is an array.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is an array.
 */
goog.isArray = function(val) {
  return goog.typeOf(val) == 'array';
};


/**
 * Returns true if the object looks like an array. To qualify as array like
 * the value needs to be either a NodeList or an object with a Number length
 * property. Note that for this function neither strings nor functions are
 * considered "array-like".
 *
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is an array.
 */
goog.isArrayLike = function(val) {
  var type = goog.typeOf(val);
  // We do not use goog.isObject here in order to exclude function values.
  return type == 'array' || type == 'object' && typeof val.length == 'number';
};


/**
 * Returns true if the object looks like a Date. To qualify as Date-like the
 * value needs to be an object and have a getFullYear() function.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a like a Date.
 */
goog.isDateLike = function(val) {
  return goog.isObject(val) && typeof val.getFullYear == 'function';
};


/**
 * Returns true if the specified value is a function.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is a function.
 */
goog.isFunction = function(val) {
  return goog.typeOf(val) == 'function';
};


/**
 * Returns true if the specified value is an object.  This includes arrays and
 * functions.
 * @param {?} val Variable to test.
 * @return {boolean} Whether variable is an object.
 */
goog.isObject = function(val) {
  var type = typeof val;
  return type == 'object' && val != null || type == 'function';
  // return Object(val) === val also works, but is slower, especially if val is
  // not an object.
};


/**
 * Gets a unique ID for an object. This mutates the object so that further calls
 * with the same object as a parameter returns the same value. The unique ID is
 * guaranteed to be unique across the current session amongst objects that are
 * passed into `getUid`. There is no guarantee that the ID is unique or
 * consistent across sessions. It is unsafe to generate unique ID for function
 * prototypes.
 *
 * @param {Object} obj The object to get the unique ID for.
 * @return {number} The unique ID for the object.
 */
goog.getUid = function(obj) {
  // TODO(arv): Make the type stricter, do not accept null.

  // In Opera window.hasOwnProperty exists but always returns false so we avoid
  // using it. As a consequence the unique ID generated for BaseClass.prototype
  // and SubClass.prototype will be the same.
  // TODO(b/141512323): UUIDs are broken for ctors with class-side inheritance.
  return obj[goog.UID_PROPERTY_] ||
      (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);
};


/**
 * Whether the given object is already assigned a unique ID.
 *
 * This does not modify the object.
 *
 * @param {!Object} obj The object to check.
 * @return {boolean} Whether there is an assigned unique id for the object.
 */
goog.hasUid = function(obj) {
  return !!obj[goog.UID_PROPERTY_];
};


/**
 * Removes the unique ID from an object. This is useful if the object was
 * previously mutated using `goog.getUid` in which case the mutation is
 * undone.
 * @param {Object} obj The object to remove the unique ID field from.
 */
goog.removeUid = function(obj) {
  // TODO(arv): Make the type stricter, do not accept null.

  // In IE, DOM nodes are not instances of Object and throw an exception if we
  // try to delete.  Instead we try to use removeAttribute.
  if (obj !== null && 'removeAttribute' in obj) {
    obj.removeAttribute(goog.UID_PROPERTY_);
  }

  try {
    delete obj[goog.UID_PROPERTY_];
  } catch (ex) {
  }
};


/**
 * Name for unique ID property. Initialized in a way to help avoid collisions
 * with other closure JavaScript on the same page.
 * @type {string}
 * @private
 */
goog.UID_PROPERTY_ = 'closure_uid_' + ((Math.random() * 1e9) >>> 0);


/**
 * Counter for UID.
 * @type {number}
 * @private
 */
goog.uidCounter_ = 0;


/**
 * Adds a hash code field to an object. The hash code is unique for the
 * given object.
 * @param {Object} obj The object to get the hash code for.
 * @return {number} The hash code for the object.
 * @deprecated Use goog.getUid instead.
 */
goog.getHashCode = goog.getUid;


/**
 * Removes the hash code field from an object.
 * @param {Object} obj The object to remove the field from.
 * @deprecated Use goog.removeUid instead.
 */
goog.removeHashCode = goog.removeUid;


/**
 * Clones a value. The input may be an Object, Array, or basic type. Objects and
 * arrays will be cloned recursively.
 *
 * WARNINGS:
 * <code>goog.cloneObject</code> does not detect reference loops. Objects that
 * refer to themselves will cause infinite recursion.
 *
 * <code>goog.cloneObject</code> is unaware of unique identifiers, and copies
 * UIDs created by <code>getUid</code> into cloned results.
 *
 * @param {*} obj The value to clone.
 * @return {*} A clone of the input value.
 * @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.
 */
goog.cloneObject = function(obj) {
  var type = goog.typeOf(obj);
  if (type == 'object' || type == 'array') {
    if (typeof obj.clone === 'function') {
      return obj.clone();
    }
    var clone = type == 'array' ? [] : {};
    for (var key in obj) {
      clone[key] = goog.cloneObject(obj[key]);
    }
    return clone;
  }

  return obj;
};


/**
 * A native implementation of goog.bind.
 * @param {?function(this:T, ...)} fn A function to partially apply.
 * @param {T} selfObj Specifies the object which this should point to when the
 *     function is run.
 * @param {...*} var_args Additional arguments that are partially applied to the
 *     function.
 * @return {!Function} A partially-applied form of the function goog.bind() was
 *     invoked as a method of.
 * @template T
 * @private
 */
goog.bindNative_ = function(fn, selfObj, var_args) {
  return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));
};


/**
 * A pure-JS implementation of goog.bind.
 * @param {?function(this:T, ...)} fn A function to partially apply.
 * @param {T} selfObj Specifies the object which this should point to when the
 *     function is run.
 * @param {...*} var_args Additional arguments that are partially applied to the
 *     function.
 * @return {!Function} A partially-applied form of the function goog.bind() was
 *     invoked as a method of.
 * @template T
 * @private
 */
goog.bindJs_ = function(fn, selfObj, var_args) {
  if (!fn) {
    throw new Error();
  }

  if (arguments.length > 2) {
    var boundArgs = Array.prototype.slice.call(arguments, 2);
    return function() {
      // Prepend the bound arguments to the current arguments.
      var newArgs = Array.prototype.slice.call(arguments);
      Array.prototype.unshift.apply(newArgs, boundArgs);
      return fn.apply(selfObj, newArgs);
    };

  } else {
    return function() {
      return fn.apply(selfObj, arguments);
    };
  }
};


/**
 * Partially applies this function to a particular 'this object' and zero or
 * more arguments. The result is a new function with some arguments of the first
 * function pre-filled and the value of this 'pre-specified'.
 *
 * Remaining arguments specified at call-time are appended to the pre-specified
 * ones.
 *
 * Also see: {@link #partial}.
 *
 * Usage:
 * <pre>var barMethBound = goog.bind(myFunction, myObj, 'arg1', 'arg2');
 * barMethBound('arg3', 'arg4');</pre>
 *
 * @param {?function(this:T, ...)} fn A function to partially apply.
 * @param {T} selfObj Specifies the object which this should point to when the
 *     function is run.
 * @param {...*} var_args Additional arguments that are partially applied to the
 *     function.
 * @return {!Function} A partially-applied form of the function goog.bind() was
 *     invoked as a method of.
 * @template T
 * @suppress {deprecated} See above.
 */
goog.bind = function(fn, selfObj, var_args) {
  // TODO(nicksantos): narrow the type signature.
  if (Function.prototype.bind &&
      // NOTE(nicksantos): Somebody pulled base.js into the default Chrome
      // extension environment. This means that for Chrome extensions, they get
      // the implementation of Function.prototype.bind that calls goog.bind
      // instead of the native one. Even worse, we don't want to introduce a
      // circular dependency between goog.bind and Function.prototype.bind, so
      // we have to hack this to make sure it works correctly.
      Function.prototype.bind.toString().indexOf('native code') != -1) {
    goog.bind = goog.bindNative_;
  } else {
    goog.bind = goog.bindJs_;
  }
  return goog.bind.apply(null, arguments);
};


/**
 * Like goog.bind(), except that a 'this object' is not required. Useful when
 * the target function is already bound.
 *
 * Usage:
 * var g = goog.partial(f, arg1, arg2);
 * g(arg3, arg4);
 *
 * @param {Function} fn A function to partially apply.
 * @param {...*} var_args Additional arguments that are partially applied to fn.
 * @return {!Function} A partially-applied form of the function goog.partial()
 *     was invoked as a method of.
 */
goog.partial = function(fn, var_args) {
  var args = Array.prototype.slice.call(arguments, 1);
  return function() {
    // Clone the array (with slice()) and append additional arguments
    // to the existing arguments.
    var newArgs = args.slice();
    newArgs.push.apply(newArgs, arguments);
    return fn.apply(/** @type {?} */ (this), newArgs);
  };
};


/**
 * Copies all the members of a source object to a target object. This method
 * does not work on all browsers for all objects that contain keys such as
 * toString or hasOwnProperty. Use goog.object.extend for this purpose.
 *
 * NOTE: Some have advocated for the use of goog.mixin to setup classes
 * with multiple inheritence (traits, mixins, etc).  However, as it simply
 * uses "for in", this is not compatible with ES6 classes whose methods are
 * non-enumerable.  Changing this, would break cases where non-enumerable
 * properties are not expected.
 *
 * @param {Object} target Target.
 * @param {Object} source Source.
 * @deprecated Prefer Object.assign
 */
goog.mixin = function(target, source) {
  for (var x in source) {
    target[x] = source[x];
  }

  // For IE7 or lower, the for-in-loop does not contain any properties that are
  // not enumerable on the prototype object (for example, isPrototypeOf from
  // Object.prototype) but also it will not include 'replace' on objects that
  // extend String and change 'replace' (not that it is common for anyone to
  // extend anything except Object).
};


/**
 * @return {number} An integer value representing the number of milliseconds
 *     between midnight, January 1, 1970 and the current time.
 * @deprecated Use Date.now
 */
goog.now = (goog.TRUSTED_SITE && Date.now) || (function() {
             // Unary plus operator converts its operand to a number which in
             // the case of
             // a date is done by calling getTime().
             return +new Date();
           });


/**
 * Evals JavaScript in the global scope.  In IE this uses execScript, other
 * browsers use goog.global.eval. If goog.global.eval does not evaluate in the
 * global scope (for example, in Safari), appends a script tag instead.
 * Throws an exception if neither execScript or eval is defined.
 * @param {string} script JavaScript string.
 */
goog.globalEval = function(script) {
  if (goog.global.execScript) {
    goog.global.execScript(script, 'JavaScript');
  } else if (goog.global.eval) {
    // Test to see if eval works
    if (goog.evalWorksForGlobals_ == null) {
      try {
        goog.global.eval('var _evalTest_ = 1;');
      } catch (ignore) {
      }
      if (typeof goog.global['_evalTest_'] != 'undefined') {
        try {
          delete goog.global['_evalTest_'];
        } catch (ignore) {
          // Microsoft edge fails the deletion above in strict mode.
        }
        goog.evalWorksForGlobals_ = true;
      } else {
        goog.evalWorksForGlobals_ = false;
      }
    }

    if (goog.evalWorksForGlobals_) {
      goog.global.eval(script);
    } else {
      /** @type {!Document} */
      var doc = goog.global.document;
      var scriptElt =
          /** @type {!HTMLScriptElement} */ (doc.createElement('script'));
      scriptElt.type = 'text/javascript';
      scriptElt.defer = false;
      // Note(user): can't use .innerHTML since "t('<test>')" will fail and
      // .text doesn't work in Safari 2.  Therefore we append a text node.
      scriptElt.appendChild(doc.createTextNode(script));
      doc.head.appendChild(scriptElt);
      doc.head.removeChild(scriptElt);
    }
  } else {
    throw new Error('goog.globalEval not available');
  }
};


/**
 * Indicates whether or not we can call 'eval' directly to eval code in the
 * global scope. Set to a Boolean by the first call to goog.globalEval (which
 * empirically tests whether eval works for globals). @see goog.globalEval
 * @type {?boolean}
 * @private
 */
goog.evalWorksForGlobals_ = null;


/**
 * Optional map of CSS class names to obfuscated names used with
 * goog.getCssName().
 * @private {!Object<string, string>|undefined}
 * @see goog.setCssNameMapping
 */
goog.cssNameMapping_;


/**
 * Optional obfuscation style for CSS class names. Should be set to either
 * 'BY_WHOLE' or 'BY_PART' if defined.
 * @type {string|undefined}
 * @private
 * @see goog.setCssNameMapping
 */
goog.cssNameMappingStyle_;



/**
 * A hook for modifying the default behavior goog.getCssName. The function
 * if present, will receive the standard output of the goog.getCssName as
 * its input.
 *
 * @type {(function(string):string)|undefined}
 */
goog.global.CLOSURE_CSS_NAME_MAP_FN;


/**
 * Handles strings that are intended to be used as CSS class names.
 *
 * This function works in tandem with @see goog.setCssNameMapping.
 *
 * Without any mapping set, the arguments are simple joined with a hyphen and
 * passed through unaltered.
 *
 * When there is a mapping, there are two possible styles in which these
 * mappings are used. In the BY_PART style, each part (i.e. in between hyphens)
 * of the passed in css name is rewritten according to the map. In the BY_WHOLE
 * style, the full css name is looked up in the map directly. If a rewrite is
 * not specified by the map, the compiler will output a warning.
 *
 * When the mapping is passed to the compiler, it will replace calls to
 * goog.getCssName with the strings from the mapping, e.g.
 *     var x = goog.getCssName('foo');
 *     var y = goog.getCssName(this.baseClass, 'active');
 *  becomes:
 *     var x = 'foo';
 *     var y = this.baseClass + '-active';
 *
 * If one argument is passed it will be processed, if two are passed only the
 * modifier will be processed, as it is assumed the first argument was generated
 * as a result of calling goog.getCssName.
 *
 * @param {string} className The class name.
 * @param {string=} opt_modifier A modifier to be appended to the class name.
 * @return {string} The class name or the concatenation of the class name and
 *     the modifier.
 */
goog.getCssName = function(className, opt_modifier) {
  // String() is used for compatibility with compiled soy where the passed
  // className can be non-string objects.
  if (String(className).charAt(0) == '.') {
    throw new Error(
        'className passed in goog.getCssName must not start with ".".' +
        ' You passed: ' + className);
  }

  var getMapping = function(cssName) {
    return goog.cssNameMapping_[cssName] || cssName;
  };

  var renameByParts = function(cssName) {
    // Remap all the parts individually.
    var parts = cssName.split('-');
    var mapped = [];
    for (var i = 0; i < parts.length; i++) {
      mapped.push(getMapping(parts[i]));
    }
    return mapped.join('-');
  };

  var rename;
  if (goog.cssNameMapping_) {
    rename =
        goog.cssNameMappingStyle_ == 'BY_WHOLE' ? getMapping : renameByParts;
  } else {
    rename = function(a) {
      return a;
    };
  }

  var result =
      opt_modifier ? className + '-' + rename(opt_modifier) : rename(className);

  // The special CLOSURE_CSS_NAME_MAP_FN allows users to specify further
  // processing of the class name.
  if (goog.global.CLOSURE_CSS_NAME_MAP_FN) {
    return goog.global.CLOSURE_CSS_NAME_MAP_FN(result);
  }

  return result;
};


/**
 * Sets the map to check when returning a value from goog.getCssName(). Example:
 * <pre>
 * goog.setCssNameMapping({
 *   "goog": "a",
 *   "disabled": "b",
 * });
 *
 * var x = goog.getCssName('goog');
 * // The following evaluates to: "a a-b".
 * goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')
 * </pre>
 * When declared as a map of string literals to string literals, the JSCompiler
 * will replace all calls to goog.getCssName() using the supplied map if the
 * --process_closure_primitives flag is set.
 *
 * @param {!Object} mapping A map of strings to strings where keys are possible
 *     arguments to goog.getCssName() and values are the corresponding values
 *     that should be returned.
 * @param {string=} opt_style The style of css name mapping. There are two valid
 *     options: 'BY_PART', and 'BY_WHOLE'.
 * @see goog.getCssName for a description.
 */
goog.setCssNameMapping = function(mapping, opt_style) {
  goog.cssNameMapping_ = mapping;
  goog.cssNameMappingStyle_ = opt_style;
};


/**
 * To use CSS renaming in compiled mode, one of the input files should have a
 * call to goog.setCssNameMapping() with an object literal that the JSCompiler
 * can extract and use to replace all calls to goog.getCssName(). In uncompiled
 * mode, JavaScript code should be loaded before this base.js file that declares
 * a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is
 * to ensure that the mapping is loaded before any calls to goog.getCssName()
 * are made in uncompiled mode.
 *
 * A hook for overriding the CSS name mapping.
 * @type {!Object<string, string>|undefined}
 */
goog.global.CLOSURE_CSS_NAME_MAPPING;


if (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {
  // This does not call goog.setCssNameMapping() because the JSCompiler
  // requires that goog.setCssNameMapping() be called with an object literal.
  goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;
}


/**
 * Gets a localized message.
 *
 * This function is a compiler primitive. If you give the compiler a localized
 * message bundle, it will replace the string at compile-time with a localized
 * version, and expand goog.getMsg call to a concatenated string.
 *
 * Messages must be initialized in the form:
 * <code>
 * var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});
 * </code>
 *
 * This function produces a string which should be treated as plain text. Use
 * {@link goog.html.SafeHtmlFormatter} in conjunction with goog.getMsg to
 * produce SafeHtml.
 *
 * @param {string} str Translatable string, places holders in the form {$foo}.
 * @param {Object<string, string>=} opt_values Maps place holder name to value.
 * @param {{html: boolean}=} opt_options Options:
 *     html: Escape '<' in str to '&lt;'. Used by Closure Templates where the
 *     generated code size and performance is critical which is why {@link
 *     goog.html.SafeHtmlFormatter} is not used. The value must be literal true
 *     or false.
 * @return {string} message with placeholders filled.
 */
goog.getMsg = function(str, opt_values, opt_options) {
  if (opt_options && opt_options.html) {
    // Note that '&' is not replaced because the translation can contain HTML
    // entities.
    str = str.replace(/</g, '&lt;');
  }
  if (opt_values) {
    str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
      return (opt_values != null && key in opt_values) ? opt_values[key] :
                                                         match;
    });
  }
  return str;
};


/**
 * Gets a localized message. If the message does not have a translation, gives a
 * fallback message.
 *
 * This is useful when introducing a new message that has not yet been
 * translated into all languages.
 *
 * This function is a compiler primitive. Must be used in the form:
 * <code>var x = goog.getMsgWithFallback(MSG_A, MSG_B);</code>
 * where MSG_A and MSG_B were initialized with goog.getMsg.
 *
 * @param {string} a The preferred message.
 * @param {string} b The fallback message.
 * @return {string} The best translated message.
 */
goog.getMsgWithFallback = function(a, b) {
  return a;
};


/**
 * Exposes an unobfuscated global namespace path for the given object.
 * Note that fields of the exported object *will* be obfuscated, unless they are
 * exported in turn via this function or goog.exportProperty.
 *
 * Also handy for making public items that are defined in anonymous closures.
 *
 * ex. goog.exportSymbol('public.path.Foo', Foo);
 *
 * ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);
 *     public.path.Foo.staticFunction();
 *
 * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',
 *                       Foo.prototype.myMethod);
 *     new public.path.Foo().myMethod();
 *
 * @param {string} publicPath Unobfuscated name to export.
 * @param {*} object Object the name should point to.
 * @param {Object=} opt_objectToExportTo The object to add the path to; default
 *     is goog.global.
 */
goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
  goog.exportPath_(publicPath, object, opt_objectToExportTo);
};


/**
 * Exports a property unobfuscated into the object's namespace.
 * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);
 * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);
 * @param {Object} object Object whose static property is being exported.
 * @param {string} publicName Unobfuscated name to export.
 * @param {*} symbol Object the name should point to.
 */
goog.exportProperty = function(object, publicName, symbol) {
  object[publicName] = symbol;
};


/**
 * Inherit the prototype methods from one constructor into another.
 *
 * Usage:
 * <pre>
 * function ParentClass(a, b) { }
 * ParentClass.prototype.foo = function(a) { };
 *
 * function ChildClass(a, b, c) {
 *   ChildClass.base(this, 'constructor', a, b);
 * }
 * goog.inherits(ChildClass, ParentClass);
 *
 * var child = new ChildClass('a', 'b', 'see');
 * child.foo(); // This works.
 * </pre>
 *
 * @param {!Function} childCtor Child class.
 * @param {!Function} parentCtor Parent class.
 * @suppress {strictMissingProperties} superClass_ and base is not defined on
 *    Function.
 */
goog.inherits = function(childCtor, parentCtor) {
  /** @constructor */
  function tempCtor() {}
  tempCtor.prototype = parentCtor.prototype;
  childCtor.superClass_ = parentCtor.prototype;
  childCtor.prototype = new tempCtor();
  /** @override */
  childCtor.prototype.constructor = childCtor;

  /**
   * Calls superclass constructor/method.
   *
   * This function is only available if you use goog.inherits to
   * express inheritance relationships between classes.
   *
   * NOTE: This is a replacement for goog.base and for superClass_
   * property defined in childCtor.
   *
   * @param {!Object} me Should always be "this".
   * @param {string} methodName The method name to call. Calling
   *     superclass constructor can be done with the special string
   *     'constructor'.
   * @param {...*} var_args The arguments to pass to superclass
   *     method/constructor.
   * @return {*} The return value of the superclass method/constructor.
   */
  childCtor.base = function(me, methodName, var_args) {
    // Copying using loop to avoid deop due to passing arguments object to
    // function. This is faster in many JS engines as of late 2014.
    var args = new Array(arguments.length - 2);
    for (var i = 2; i < arguments.length; i++) {
      args[i - 2] = arguments[i];
    }
    return parentCtor.prototype[methodName].apply(me, args);
  };
};


/**
 * Call up to the superclass.
 *
 * If this is called from a constructor, then this calls the superclass
 * constructor with arguments 1-N.
 *
 * If this is called from a prototype method, then you must pass the name of the
 * method as the second argument to this function. If you do not, you will get a
 * runtime error. This calls the superclass' method with arguments 2-N.
 *
 * This function only works if you use goog.inherits to express inheritance
 * relationships between your classes.
 *
 * This function is a compiler primitive. At compile-time, the compiler will do
 * macro expansion to remove a lot of the extra overhead that this function
 * introduces. The compiler will also enforce a lot of the assumptions that this
 * function makes, and treat it as a compiler error if you break them.
 *
 * @param {!Object} me Should always be "this".
 * @param {*=} opt_methodName The method name if calling a super method.
 * @param {...*} var_args The rest of the arguments.
 * @return {*} The return value of the superclass method.
 * @suppress {es5Strict} This method can not be used in strict mode, but
 *     all Closure Library consumers must depend on this file.
 * @deprecated goog.base is not strict mode compatible.  Prefer the static
 *     "base" method added to the constructor by goog.inherits
 *     or ES6 classes and the "super" keyword.
 */
goog.base = function(me, opt_methodName, var_args) {
  var caller = arguments.callee.caller;

  if (goog.STRICT_MODE_COMPATIBLE || (goog.DEBUG && !caller)) {
    throw new Error(
        'arguments.caller not defined.  goog.base() cannot be used ' +
        'with strict mode code. See ' +
        'http://www.ecma-international.org/ecma-262/5.1/#sec-C');
  }

  if (typeof caller.superClass_ !== 'undefined') {
    // Copying using loop to avoid deop due to passing arguments object to
    // function. This is faster in many JS engines as of late 2014.
    var ctorArgs = new Array(arguments.length - 1);
    for (var i = 1; i < arguments.length; i++) {
      ctorArgs[i - 1] = arguments[i];
    }
    // This is a constructor. Call the superclass constructor.
    return /** @type {!Function} */ (caller.superClass_)
        .constructor.apply(me, ctorArgs);
  }

  if (typeof opt_methodName != 'string' && typeof opt_methodName != 'symbol') {
    throw new Error(
        'method names provided to goog.base must be a string or a symbol');
  }

  // Copying using loop to avoid deop due to passing arguments object to
  // function. This is faster in many JS engines as of late 2014.
  var args = new Array(arguments.length - 2);
  for (var i = 2; i < arguments.length; i++) {
    args[i - 2] = arguments[i];
  }
  var foundCaller = false;
  for (var proto = me.constructor.prototype; proto;
       proto = Object.getPrototypeOf(proto)) {
    if (proto[opt_methodName] === caller) {
      foundCaller = true;
    } else if (foundCaller) {
      return proto[opt_methodName].apply(me, args);
    }
  }

  // If we did not find the caller in the prototype chain, then one of two
  // things happened:
  // 1) The caller is an instance method.
  // 2) This method was not called by the right caller.
  if (me[opt_methodName] === caller) {
    return me.constructor.prototype[opt_methodName].apply(me, args);
  } else {
    throw new Error(
        'goog.base called from a method of one name ' +
        'to a method of a different name');
  }
};


/**
 * Allow for aliasing within scope functions.  This function exists for
 * uncompiled code - in compiled code the calls will be inlined and the aliases
 * applied.  In uncompiled code the function is simply run since the aliases as
 * written are valid JavaScript.
 *
 *
 * @param {function()} fn Function to call.  This function can contain aliases
 *     to namespaces (e.g. "var dom = goog.dom") or classes
 *     (e.g. "var Timer = goog.Timer").
 */
goog.scope = function(fn) {
  if (goog.isInModuleLoader_()) {
    throw new Error('goog.scope is not supported within a module.');
  }
  fn.call(goog.global);
};


/*
 * To support uncompiled, strict mode bundles that use eval to divide source
 * like so:
 *    eval('someSource;//# sourceUrl sourcefile.js');
 * We need to export the globally defined symbols "goog" and "COMPILED".
 * Exporting "goog" breaks the compiler optimizations, so we required that
 * be defined externally.
 * NOTE: We don't use goog.exportSymbol here because we don't want to trigger
 * extern generation when that compiler option is enabled.
 */
if (!COMPILED) {
  goog.global['COMPILED'] = COMPILED;
}


//==============================================================================
// goog.defineClass implementation
//==============================================================================


/**
 * Creates a restricted form of a Closure "class":
 *   - from the compiler's perspective, the instance returned from the
 *     constructor is sealed (no new properties may be added).  This enables
 *     better checks.
 *   - the compiler will rewrite this definition to a form that is optimal
 *     for type checking and optimization (initially this will be a more
 *     traditional form).
 *
 * @param {Function} superClass The superclass, Object or null.
 * @param {goog.defineClass.ClassDescriptor} def
 *     An object literal describing
 *     the class.  It may have the following properties:
 *     "constructor": the constructor function
 *     "statics": an object literal containing methods to add to the constructor
 *        as "static" methods or a function that will receive the constructor
 *        function as its only parameter to which static properties can
 *        be added.
 *     all other properties are added to the prototype.
 * @return {!Function} The class constructor.
 * @deprecated Use ES6 class syntax instead.
 */
goog.defineClass = function(superClass, def) {
  // TODO(johnlenz): consider making the superClass an optional parameter.
  var constructor = def.constructor;
  var statics = def.statics;
  // Wrap the constructor prior to setting up the prototype and static methods.
  if (!constructor || constructor == Object.prototype.constructor) {
    constructor = function() {
      throw new Error(
          'cannot instantiate an interface (no constructor defined).');
    };
  }

  var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
  if (superClass) {
    goog.inherits(cls, superClass);
  }

  // Remove all the properties that should not be copied to the prototype.
  delete def.constructor;
  delete def.statics;

  goog.defineClass.applyProperties_(cls.prototype, def);
  if (statics != null) {
    if (statics instanceof Function) {
      statics(cls);
    } else {
      goog.defineClass.applyProperties_(cls, statics);
    }
  }

  return cls;
};


/**
 * @typedef {{
 *   constructor: (!Function|undefined),
 *   statics: (Object|undefined|function(Function):void)
 * }}
 */
goog.defineClass.ClassDescriptor;


/**
 * @define {boolean} Whether the instances returned by goog.defineClass should
 *     be sealed when possible.
 *
 * When sealing is disabled the constructor function will not be wrapped by
 * goog.defineClass, making it incompatible with ES6 class methods.
 */
goog.defineClass.SEAL_CLASS_INSTANCES =
    goog.define('goog.defineClass.SEAL_CLASS_INSTANCES', goog.DEBUG);


/**
 * If goog.defineClass.SEAL_CLASS_INSTANCES is enabled and Object.seal is
 * defined, this function will wrap the constructor in a function that seals the
 * results of the provided constructor function.
 *
 * @param {!Function} ctr The constructor whose results maybe be sealed.
 * @param {Function} superClass The superclass constructor.
 * @return {!Function} The replacement constructor.
 * @private
 */
goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
  if (!goog.defineClass.SEAL_CLASS_INSTANCES) {
    // Do now wrap the constructor when sealing is disabled. Angular code
    // depends on this for injection to work properly.
    return ctr;
  }

  // Compute whether the constructor is sealable at definition time, rather
  // than when the instance is being constructed.
  var superclassSealable = !goog.defineClass.isUnsealable_(superClass);

  /**
   * @this {Object}
   * @return {?}
   */
  var wrappedCtr = function() {
    // Don't seal an instance of a subclass when it calls the constructor of
    // its super class as there is most likely still setup to do.
    var instance = ctr.apply(this, arguments) || this;
    instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];

    if (this.constructor === wrappedCtr && superclassSealable &&
        Object.seal instanceof Function) {
      Object.seal(instance);
    }
    return instance;
  };

  return wrappedCtr;
};


/**
 * @param {Function} ctr The constructor to test.
 * @return {boolean} Whether the constructor has been tagged as unsealable
 *     using goog.tagUnsealableClass.
 * @private
 */
goog.defineClass.isUnsealable_ = function(ctr) {
  return ctr && ctr.prototype &&
      ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_];
};


// TODO(johnlenz): share these values with the goog.object
/**
 * The names of the fields that are defined on Object.prototype.
 * @type {!Array<string>}
 * @private
 * @const
 */
goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [
  'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',
  'toLocaleString', 'toString', 'valueOf'
];


// TODO(johnlenz): share this function with the goog.object
/**
 * @param {!Object} target The object to add properties to.
 * @param {!Object} source The object to copy properties from.
 * @private
 */
goog.defineClass.applyProperties_ = function(target, source) {
  // TODO(johnlenz): update this to support ES5 getters/setters

  var key;
  for (key in source) {
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      target[key] = source[key];
    }
  }

  // For IE the for-in-loop does not contain any properties that are not
  // enumerable on the prototype object (for example isPrototypeOf from
  // Object.prototype) and it will also not include 'replace' on objects that
  // extend String and change 'replace' (not that it is common for anyone to
  // extend anything except Object).
  for (var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {
    key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];
    if (Object.prototype.hasOwnProperty.call(source, key)) {
      target[key] = source[key];
    }
  }
};


/**
 * Sealing classes breaks the older idiom of assigning properties on the
 * prototype rather than in the constructor. As such, goog.defineClass
 * must not seal subclasses of these old-style classes until they are fixed.
 * Until then, this marks a class as "broken", instructing defineClass
 * not to seal subclasses.
 * @param {!Function} ctr The legacy constructor to tag as unsealable.
 */
goog.tagUnsealableClass = function(ctr) {
  if (!COMPILED && goog.defineClass.SEAL_CLASS_INSTANCES) {
    ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_] = true;
  }
};


/**
 * Name for unsealable tag property.
 * @const @private {string}
 */
goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = 'goog_defineClass_legacy_unsealable';


// There's a bug in the compiler where without collapse properties the
// Closure namespace defines do not guard code correctly. To help reduce code
// size also check for !COMPILED even though it redundant until this is fixed.
if (!COMPILED && goog.DEPENDENCIES_ENABLED) {

  /**
   * Tries to detect whether is in the context of an HTML document.
   * @return {boolean} True if it looks like HTML document.
   * @private
   */
  goog.inHtmlDocument_ = function() {
    /** @type {!Document} */
    var doc = goog.global.document;
    return doc != null && 'write' in doc;  // XULDocument misses write.
  };


  /**
   * We'd like to check for if the document readyState is 'loading'; however
   * there are bugs on IE 10 and below where the readyState being anything other
   * than 'complete' is not reliable.
   * @return {boolean}
   * @private
   */
  goog.isDocumentLoading_ = function() {
    // attachEvent is available on IE 6 thru 10 only, and thus can be used to
    // detect those browsers.
    /** @type {!HTMLDocument} */
    var doc = goog.global.document;
    return doc.attachEvent ? doc.readyState != 'complete' :
                             doc.readyState == 'loading';
  };


  /**
   * Tries to detect the base path of base.js script that bootstraps Closure.
   * @private
   */
  goog.findBasePath_ = function() {
    if (goog.global.CLOSURE_BASE_PATH != undefined &&
        // Anti DOM-clobbering runtime check (b/37736576).
        typeof goog.global.CLOSURE_BASE_PATH === 'string') {
      goog.basePath = goog.global.CLOSURE_BASE_PATH;
      return;
    } else if (!goog.inHtmlDocument_()) {
      return;
    }
    /** @type {!Document} */
    var doc = goog.global.document;
    // If we have a currentScript available, use it exclusively.
    var currentScript = doc.currentScript;
    if (currentScript) {
      var scripts = [currentScript];
    } else {
      var scripts = doc.getElementsByTagName('SCRIPT');
    }
    // Search backwards since the current script is in almost all cases the one
    // that has base.js.
    for (var i = scripts.length - 1; i >= 0; --i) {
      var script = /** @type {!HTMLScriptElement} */ (scripts[i]);
      var src = script.src;
      var qmark = src.lastIndexOf('?');
      var l = qmark == -1 ? src.length : qmark;
      if (src.substr(l - 7, 7) == 'base.js') {
        goog.basePath = src.substr(0, l - 7);
        return;
      }
    }
  };

  goog.findBasePath_();

  /** @struct @constructor @final */
  goog.Transpiler = function() {
    /** @private {?Object<string, boolean>} */
    this.requiresTranspilation_ = null;
    /** @private {string} */
    this.transpilationTarget_ = goog.TRANSPILE_TO_LANGUAGE;
  };


  /**
   * Returns a newly created map from language mode string to a boolean
   * indicating whether transpilation should be done for that mode as well as
   * the highest level language that this environment supports.
   *
   * Guaranteed invariant:
   * For any two modes, l1 and l2 where l2 is a newer mode than l1,
   * `map[l1] == true` implies that `map[l2] == true`.
   *
   * Note this method is extracted and used elsewhere, so it cannot rely on
   * anything external (it should easily be able to be transformed into a
   * standalone, top level function).
   *
   * @private
   * @return {{
   *   target: string,
   *   map: !Object<string, boolean>
   * }}
   */
  goog.Transpiler.prototype.createRequiresTranspilation_ = function() {
    var transpilationTarget = 'es3';
    var /** !Object<string, boolean> */ requiresTranspilation = {'es3': false};
    var transpilationRequiredForAllLaterModes = false;

    /**
     * Adds an entry to requiresTranspliation for the given language mode.
     *
     * IMPORTANT: Calls must be made in order from oldest to newest language
     * mode.
     * @param {string} modeName
     * @param {function(): boolean} isSupported Returns true if the JS engine
     *     supports the given mode.
     */
    function addNewerLanguageTranspilationCheck(modeName, isSupported) {
      if (transpilationRequiredForAllLaterModes) {
        requiresTranspilation[modeName] = true;
      } else if (isSupported()) {
        transpilationTarget = modeName;
        requiresTranspilation[modeName] = false;
      } else {
        requiresTranspilation[modeName] = true;
        transpilationRequiredForAllLaterModes = true;
      }
    }

    /**
     * Does the given code evaluate without syntax errors and return a truthy
     * result?
     */
    function /** boolean */ evalCheck(/** string */ code) {
      try {
        return !!eval(code);
      } catch (ignored) {
        return false;
      }
    }

    var userAgent = goog.global.navigator && goog.global.navigator.userAgent ?
        goog.global.navigator.userAgent :
        '';

    // Identify ES3-only browsers by their incorrect treatment of commas.
    addNewerLanguageTranspilationCheck('es5', function() {
      return evalCheck('[1,].length==1');
    });
    addNewerLanguageTranspilationCheck('es6', function() {
      // Edge has a non-deterministic (i.e., not reproducible) bug with ES6:
      // https://github.com/Microsoft/ChakraCore/issues/1496.
      var re = /Edge\/(\d+)(\.\d)*/i;
      var edgeUserAgent = userAgent.match(re);
      if (edgeUserAgent) {
        // The Reflect.construct test below is flaky on Edge. It can sometimes
        // pass or fail on 40 15.15063, so just exit early for Edge and treat
        // it as ES5. Until we're on a more up to date version just always use
        // ES5. See https://github.com/Microsoft/ChakraCore/issues/3217.
        return false;
      }
      // Test es6: [FF50 (?), Edge 14 (?), Chrome 50]
      //   (a) default params (specifically shadowing locals),
      //   (b) destructuring, (c) block-scoped functions,
      //   (d) for-of (const), (e) new.target/Reflect.construct
      var es6fullTest =
          'class X{constructor(){if(new.target!=String)throw 1;this.x=42}}' +
          'let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof ' +
          'String))throw 1;for(const a of[2,3]){if(a==2)continue;function ' +
          'f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()' +
          '==3}';

      return evalCheck('(()=>{"use strict";' + es6fullTest + '})()');
    });
    // ** and **= are the only new features in 'es7'
    addNewerLanguageTranspilationCheck('es7', function() {
      return evalCheck('2 ** 2 == 4');
    });
    // async functions are the only new features in 'es8'
    addNewerLanguageTranspilationCheck('es8', function() {
      return evalCheck('async () => 1, true');
    });
    addNewerLanguageTranspilationCheck('es9', function() {
      return evalCheck('({...rest} = {}), true');
    });
    addNewerLanguageTranspilationCheck('es_next', function() {
      return false;  // assume it always need to transpile
    });
    return {target: transpilationTarget, map: requiresTranspilation};
  };


  /**
   * Determines whether the given language needs to be transpiled.
   * @param {string} lang
   * @param {string|undefined} module
   * @return {boolean}
   */
  goog.Transpiler.prototype.needsTranspile = function(lang, module) {
    if (goog.TRANSPILE == 'always') {
      return true;
    } else if (goog.TRANSPILE == 'never') {
      return false;
    } else if (!this.requiresTranspilation_) {
      var obj = this.createRequiresTranspilation_();
      this.requiresTranspilation_ = obj.map;
      this.transpilationTarget_ = this.transpilationTarget_ || obj.target;
    }
    if (lang in this.requiresTranspilation_) {
      if (this.requiresTranspilation_[lang]) {
        return true;
      } else if (
          goog.inHtmlDocument_() && module == 'es6' &&
          !('noModule' in goog.global.document.createElement('script'))) {
        return true;
      } else {
        return false;
      }
    } else {
      throw new Error('Unknown language mode: ' + lang);
    }
  };


  /**
   * Lazily retrieves the transpiler and applies it to the source.
   * @param {string} code JS code.
   * @param {string} path Path to the code.
   * @return {string} The transpiled code.
   */
  goog.Transpiler.prototype.transpile = function(code, path) {
    // TODO(johnplaisted): We should delete goog.transpile_ and just have this
    // function. But there's some compile error atm where goog.global is being
    // stripped incorrectly without this.
    return goog.transpile_(code, path, this.transpilationTarget_);
  };


  /** @private @final {!goog.Transpiler} */
  goog.transpiler_ = new goog.Transpiler();

  /**
   * Rewrites closing script tags in input to avoid ending an enclosing script
   * tag.
   *
   * @param {string} str
   * @return {string}
   * @private
   */
  goog.protectScriptTag_ = function(str) {
    return str.replace(/<\/(SCRIPT)/ig, '\\x3c/$1');
  };


  /**
   * A debug loader is responsible for downloading and executing javascript
   * files in an unbundled, uncompiled environment.
   *
   * This can be custimized via the setDependencyFactory method, or by
   * CLOSURE_IMPORT_SCRIPT/CLOSURE_LOAD_FILE_SYNC.
   *
   * @struct @constructor @final @private
   */
  goog.DebugLoader_ = function() {
    /** @private @const {!Object<string, !goog.Dependency>} */
    this.dependencies_ = {};
    /** @private @const {!Object<string, string>} */
    this.idToPath_ = {};
    /** @private @const {!Object<string, boolean>} */
    this.written_ = {};
    /** @private @const {!Array<!goog.Dependency>} */
    this.loadingDeps_ = [];
    /** @private {!Array<!goog.Dependency>} */
    this.depsToLoad_ = [];
    /** @private {boolean} */
    this.paused_ = false;
    /** @private {!goog.DependencyFactory} */
    this.factory_ = new goog.DependencyFactory(goog.transpiler_);
    /** @private @const {!Object<string, !Function>} */
    this.deferredCallbacks_ = {};
    /** @private @const {!Array<string>} */
    this.deferredQueue_ = [];
  };

  /**
   * @param {!Array<string>} namespaces
   * @param {function(): undefined} callback Function to call once all the
   *     namespaces have loaded.
   */
  goog.DebugLoader_.prototype.bootstrap = function(namespaces, callback) {
    var cb = callback;
    function resolve() {
      if (cb) {
        goog.global.setTimeout(cb, 0);
        cb = null;
      }
    }

    if (!namespaces.length) {
      resolve();
      return;
    }

    var deps = [];
    for (var i = 0; i < namespaces.length; i++) {
      var path = this.getPathFromDeps_(namespaces[i]);
      if (!path) {
        throw new Error('Unregonized namespace: ' + namespaces[i]);
      }
      deps.push(this.dependencies_[path]);
    }

    var require = goog.require;
    var loaded = 0;
    for (var i = 0; i < namespaces.length; i++) {
      require(namespaces[i]);
      deps[i].onLoad(function() {
        if (++loaded == namespaces.length) {
          resolve();
        }
      });
    }
  };


  /**
   * Loads the Closure Dependency file.
   *
   * Exposed a public function so CLOSURE_NO_DEPS can be set to false, base
   * loaded, setDependencyFactory called, and then this called. i.e. allows
   * custom loading of the deps file.
   */
  goog.DebugLoader_.prototype.loadClosureDeps = function() {
    // Circumvent addDependency, which would try to transpile deps.js if
    // transpile is set to always.
    var relPath = 'deps.js';
    this.depsToLoad_.push(this.factory_.createDependency(
        goog.normalizePath_(goog.basePath + relPath), relPath, [], [], {},
        false));
    this.loadDeps_();
  };


  /**
   * Notifies the debug loader when a dependency has been requested.
   *
   * @param {string} absPathOrId Path of the dependency or goog id.
   * @param {boolean=} opt_force
   */
  goog.DebugLoader_.prototype.requested = function(absPathOrId, opt_force) {
    var path = this.getPathFromDeps_(absPathOrId);
    if (path &&
        (opt_force || this.areDepsLoaded_(this.dependencies_[path].requires))) {
      var callback = this.deferredCallbacks_[path];
      if (callback) {
        delete this.deferredCallbacks_[path];
        callback();
      }
    }
  };


  /**
   * Sets the dependency factory, which can be used to create custom
   * goog.Dependency implementations to control how dependencies are loaded.
   *
   * @param {!goog.DependencyFactory} factory
   */
  goog.DebugLoader_.prototype.setDependencyFactory = function(factory) {
    this.factory_ = factory;
  };


  /**
   * Travserses the dependency graph and queues the given dependency, and all of
   * its transitive dependencies, for loading and then starts loading if not
   * paused.
   *
   * @param {string} namespace
   * @private
   */
  goog.DebugLoader_.prototype.load_ = function(namespace) {
    if (!this.getPathFromDeps_(namespace)) {
      var errorMessage = 'goog.require could not find: ' + namespace;

      goog.logToConsole_(errorMessage);
      throw Error(errorMessage);
    } else {
      var loader = this;

      var deps = [];

      /** @param {string} namespace */
      var visit = function(namespace) {
        var path = loader.getPathFromDeps_(namespace);

        if (!path) {
          throw new Error('Bad dependency path or symbol: ' + namespace);
        }

        if (loader.written_[path]) {
          return;
        }

        loader.written_[path] = true;

        var dep = loader.dependencies_[path];
        for (var i = 0; i < dep.requires.length; i++) {
          if (!goog.isProvided_(dep.requires[i])) {
            visit(dep.requires[i]);
          }
        }

        deps.push(dep);
      };

      visit(namespace);

      var wasLoading = !!this.depsToLoad_.length;
      this.depsToLoad_ = this.depsToLoad_.concat(deps);

      if (!this.paused_ && !wasLoading) {
        this.loadDeps_();
      }
    }
  };


  /**
   * Loads any queued dependencies until they are all loaded or paused.
   *
   * @private
   */
  goog.DebugLoader_.prototype.loadDeps_ = function() {
    var loader = this;
    var paused = this.paused_;

    while (this.depsToLoad_.length && !paused) {
      (function() {
        var loadCallDone = false;
        var dep = loader.depsToLoad_.shift();

        var loaded = false;
        loader.loading_(dep);

        var controller = {
          pause: function() {
            if (loadCallDone) {
              throw new Error('Cannot call pause after the call to load.');
            } else {
              paused = true;
            }
          },
          resume: function() {
            if (loadCallDone) {
              loader.resume_();
            } else {
              // Some dep called pause and then resume in the same load call.
              // Just keep running this same loop.
              paused = false;
            }
          },
          loaded: function() {
            if (loaded) {
              throw new Error('Double call to loaded.');
            }

            loaded = true;
            loader.loaded_(dep);
          },
          pending: function() {
            // Defensive copy.
            var pending = [];
            for (var i = 0; i < loader.loadingDeps_.length; i++) {
              pending.push(loader.loadingDeps_[i]);
            }
            return pending;
          },
          /**
           * @param {goog.ModuleType} type
           */
          setModuleState: function(type) {
            goog.moduleLoaderState_ = {
              type: type,
              moduleName: '',
              declareLegacyNamespace: false
            };
          },
          /** @type {function(string, string, string=)} */
          registerEs6ModuleExports: function(
              path, exports, opt_closureNamespace) {
            if (opt_closureNamespace) {
              goog.loadedModules_[opt_closureNamespace] = {
                exports: exports,
                type: goog.ModuleType.ES6,
                moduleId: opt_closureNamespace || ''
              };
            }
          },
          /** @type {function(string, ?)} */
          registerGoogModuleExports: function(moduleId, exports) {
            goog.loadedModules_[moduleId] = {
              exports: exports,
              type: goog.ModuleType.GOOG,
              moduleId: moduleId
            };
          },
          clearModuleState: function() {
            goog.moduleLoaderState_ = null;
          },
          defer: function(callback) {
            if (loadCallDone) {
              throw new Error(
                  'Cannot register with defer after the call to load.');
            }
            loader.defer_(dep, callback);
          },
          areDepsLoaded: function() {
            return loader.areDepsLoaded_(dep.requires);
          }
        };

        try {
          dep.load(controller);
        } finally {
          loadCallDone = true;
        }
      })();
    }

    if (paused) {
      this.pause_();
    }
  };


  /** @private */
  goog.DebugLoader_.prototype.pause_ = function() {
    this.paused_ = true;
  };


  /** @private */
  goog.DebugLoader_.prototype.resume_ = function() {
    if (this.paused_) {
      this.paused_ = false;
      this.loadDeps_();
    }
  };


  /**
   * Marks the given dependency as loading (load has been called but it has not
   * yet marked itself as finished). Useful for dependencies that want to know
   * what else is loading. Example: goog.modules cannot eval if there are
   * loading dependencies.
   *
   * @param {!goog.Dependency} dep
   * @private
   */
  goog.DebugLoader_.prototype.loading_ = function(dep) {
    this.loadingDeps_.push(dep);
  };


  /**
   * Marks the given dependency as having finished loading and being available
   * for require.
   *
   * @param {!goog.Dependency} dep
   * @private
   */
  goog.DebugLoader_.prototype.loaded_ = function(dep) {
    for (var i = 0; i < this.loadingDeps_.length; i++) {
      if (this.loadingDeps_[i] == dep) {
        this.loadingDeps_.splice(i, 1);
        break;
      }
    }

    for (var i = 0; i < this.deferredQueue_.length; i++) {
      if (this.deferredQueue_[i] == dep.path) {
        this.deferredQueue_.splice(i, 1);
        break;
      }
    }

    if (this.loadingDeps_.length == this.deferredQueue_.length &&
        !this.depsToLoad_.length) {
      // Something has asked to load these, but they may not be directly
      // required again later, so load them now that we know we're done loading
      // everything else. e.g. a goog module entry point.
      while (this.deferredQueue_.length) {
        this.requested(this.deferredQueue_.shift(), true);
      }
    }

    dep.loaded();
  };


  /**
   * @param {!Array<string>} pathsOrIds
   * @return {boolean}
   * @private
   */
  goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {
    for (var i = 0; i < pathsOrIds.length; i++) {
      var path = this.getPathFromDeps_(pathsOrIds[i]);
      if (!path ||
          (!(path in this.deferredCallbacks_) &&
           !goog.isProvided_(pathsOrIds[i]))) {
        return false;
      }
    }

    return true;
  };


  /**
   * @param {string} absPathOrId
   * @return {?string}
   * @private
   */
  goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {
    if (absPathOrId in this.idToPath_) {
      return this.idToPath_[absPathOrId];
    } else if (absPathOrId in this.dependencies_) {
      return absPathOrId;
    } else {
      return null;
    }
  };


  /**
   * @param {!goog.Dependency} dependency
   * @param {!Function} callback
   * @private
   */
  goog.DebugLoader_.prototype.defer_ = function(dependency, callback) {
    this.deferredCallbacks_[dependency.path] = callback;
    this.deferredQueue_.push(dependency.path);
  };


  /**
   * Interface for goog.Dependency implementations to have some control over
   * loading of dependencies.
   *
   * @record
   */
  goog.LoadController = function() {};


  /**
   * Tells the controller to halt loading of more dependencies.
   */
  goog.LoadController.prototype.pause = function() {};


  /**
   * Tells the controller to resume loading of more dependencies if paused.
   */
  goog.LoadController.prototype.resume = function() {};


  /**
   * Tells the controller that this dependency has finished loading.
   *
   * This causes this to be removed from pending() and any load callbacks to
   * fire.
   */
  goog.LoadController.prototype.loaded = function() {};


  /**
   * List of dependencies on which load has been called but which have not
   * called loaded on their controller. This includes the current dependency.
   *
   * @return {!Array<!goog.Dependency>}
   */
  goog.LoadController.prototype.pending = function() {};


  /**
   * Registers an object as an ES6 module's exports so that goog.modules may
   * require it by path.
   *
   * @param {string} path Full path of the module.
   * @param {?} exports
   * @param {string=} opt_closureNamespace Closure namespace to associate with
   *     this module.
   */
  goog.LoadController.prototype.registerEs6ModuleExports = function(
      path, exports, opt_closureNamespace) {};


  /**
   * Sets the current module state.
   *
   * @param {goog.ModuleType} type Type of module.
   */
  goog.LoadController.prototype.setModuleState = function(type) {};


  /**
   * Clears the current module state.
   */
  goog.LoadController.prototype.clearModuleState = function() {};


  /**
   * Registers a callback to call once the dependency is actually requested
   * via goog.require + all of the immediate dependencies have been loaded or
   * all other files have been loaded. Allows for lazy loading until
   * require'd without pausing dependency loading, which is needed on old IE.
   *
   * @param {!Function} callback
   */
  goog.LoadController.prototype.defer = function(callback) {};


  /**
   * @return {boolean}
   */
  goog.LoadController.prototype.areDepsLoaded = function() {};


  /**
   * Basic super class for all dependencies Closure Library can load.
   *
   * This default implementation is designed to load untranspiled, non-module
   * scripts in a web broswer.
   *
   * For transpiled non-goog.module files {@see goog.TranspiledDependency}.
   * For goog.modules see {@see goog.GoogModuleDependency}.
   * For untranspiled ES6 modules {@see goog.Es6ModuleDependency}.
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @struct @constructor
   */
  goog.Dependency = function(
      path, relativePath, provides, requires, loadFlags) {
    /** @const */
    this.path = path;
    /** @const */
    this.relativePath = relativePath;
    /** @const */
    this.provides = provides;
    /** @const */
    this.requires = requires;
    /** @const */
    this.loadFlags = loadFlags;
    /** @private {boolean} */
    this.loaded_ = false;
    /** @private {!Array<function()>} */
    this.loadCallbacks_ = [];
  };


  /**
   * @return {string} The pathname part of this dependency's path if it is a
   *     URI.
   */
  goog.Dependency.prototype.getPathName = function() {
    var pathName = this.path;
    var protocolIndex = pathName.indexOf('://');
    if (protocolIndex >= 0) {
      pathName = pathName.substring(protocolIndex + 3);
      var slashIndex = pathName.indexOf('/');
      if (slashIndex >= 0) {
        pathName = pathName.substring(slashIndex + 1);
      }
    }
    return pathName;
  };


  /**
   * @param {function()} callback Callback to fire as soon as this has loaded.
   * @final
   */
  goog.Dependency.prototype.onLoad = function(callback) {
    if (this.loaded_) {
      callback();
    } else {
      this.loadCallbacks_.push(callback);
    }
  };


  /**
   * Marks this dependency as loaded and fires any callbacks registered with
   * onLoad.
   * @final
   */
  goog.Dependency.prototype.loaded = function() {
    this.loaded_ = true;
    var callbacks = this.loadCallbacks_;
    this.loadCallbacks_ = [];
    for (var i = 0; i < callbacks.length; i++) {
      callbacks[i]();
    }
  };


  /**
   * Whether or not document.written / appended script tags should be deferred.
   *
   * @private {boolean}
   */
  goog.Dependency.defer_ = false;


  /**
   * Map of script ready / state change callbacks. Old IE cannot handle putting
   * these properties on goog.global.
   *
   * @private @const {!Object<string, function(?):undefined>}
   */
  goog.Dependency.callbackMap_ = {};


  /**
   * @param {function(...?):?} callback
   * @return {string}
   * @private
   */
  goog.Dependency.registerCallback_ = function(callback) {
    var key = Math.random().toString(32);
    goog.Dependency.callbackMap_[key] = callback;
    return key;
  };


  /**
   * @param {string} key
   * @private
   */
  goog.Dependency.unregisterCallback_ = function(key) {
    delete goog.Dependency.callbackMap_[key];
  };


  /**
   * @param {string} key
   * @param {...?} var_args
   * @private
   * @suppress {unusedPrivateMembers}
   */
  goog.Dependency.callback_ = function(key, var_args) {
    if (key in goog.Dependency.callbackMap_) {
      var callback = goog.Dependency.callbackMap_[key];
      var args = [];
      for (var i = 1; i < arguments.length; i++) {
        args.push(arguments[i]);
      }
      callback.apply(undefined, args);
    } else {
      var errorMessage = 'Callback key ' + key +
          ' does not exist (was base.js loaded more than once?).';
      throw Error(errorMessage);
    }
  };


  /**
   * Starts loading this dependency. This dependency can pause loading if it
   * needs to and resume it later via the controller interface.
   *
   * When this is loaded it should call controller.loaded(). Note that this will
   * end up calling the loaded method of this dependency; there is no need to
   * call it explicitly.
   *
   * @param {!goog.LoadController} controller
   */
  goog.Dependency.prototype.load = function(controller) {
    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
      if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }

    if (!goog.inHtmlDocument_()) {
      goog.logToConsole_(
          'Cannot use default debug loader outside of HTML documents.');
      if (this.relativePath == 'deps.js') {
        // Some old code is relying on base.js auto loading deps.js failing with
        // no error before later setting CLOSURE_IMPORT_SCRIPT.
        // CLOSURE_IMPORT_SCRIPT should be set *before* base.js is loaded, or
        // CLOSURE_NO_DEPS set to true.
        goog.logToConsole_(
            'Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, ' +
            'or setting CLOSURE_NO_DEPS to true.');
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }

    /** @type {!HTMLDocument} */
    var doc = goog.global.document;

    // If the user tries to require a new symbol after document load,
    // something has gone terribly wrong. Doing a document.write would
    // wipe out the page. This does not apply to the CSP-compliant method
    // of writing script tags.
    if (doc.readyState == 'complete' &&
        !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {
      // Certain test frameworks load base.js multiple times, which tries
      // to write deps.js each time. If that happens, just fail silently.
      // These frameworks wipe the page between each load of base.js, so this
      // is OK.
      var isDeps = /\bdeps.js$/.test(this.path);
      if (isDeps) {
        controller.loaded();
        return;
      } else {
        throw Error('Cannot write "' + this.path + '" after document load');
      }
    }

    if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
        goog.isDocumentLoading_()) {
      var key = goog.Dependency.registerCallback_(function(script) {
        if (!goog.DebugLoader_.IS_OLD_IE_ || script.readyState == 'complete') {
          goog.Dependency.unregisterCallback_(key);
          controller.loaded();
        }
      });
      var nonceAttr = !goog.DebugLoader_.IS_OLD_IE_ && goog.getScriptNonce() ?
          ' nonce="' + goog.getScriptNonce() + '"' :
          '';
      var event =
          goog.DebugLoader_.IS_OLD_IE_ ? 'onreadystatechange' : 'onload';
      var defer = goog.Dependency.defer_ ? 'defer' : '';
      var script = '<script src="' + this.path + '" ' + event +
          '="goog.Dependency.callback_(\'' + key +
          '\', this)" type="text/javascript" ' + defer + nonceAttr + '><' +
          '/script>';
      doc.write(
          goog.TRUSTED_TYPES_POLICY_ ?
              goog.TRUSTED_TYPES_POLICY_.createHTML(script) :
              script);
    } else {
      var scriptEl =
          /** @type {!HTMLScriptElement} */ (doc.createElement('script'));
      scriptEl.defer = goog.Dependency.defer_;
      scriptEl.async = false;
      scriptEl.type = 'text/javascript';

      // If CSP nonces are used, propagate them to dynamically created scripts.
      // This is necessary to allow nonce-based CSPs without 'strict-dynamic'.
      var nonce = goog.getScriptNonce();
      if (nonce) {
        scriptEl.setAttribute('nonce', nonce);
      }

      if (goog.DebugLoader_.IS_OLD_IE_) {
        // Execution order is not guaranteed on old IE, halt loading and write
        // these scripts one at a time, after each loads.
        controller.pause();
        scriptEl.onreadystatechange = function() {
          if (scriptEl.readyState == 'loaded' ||
              scriptEl.readyState == 'complete') {
            controller.loaded();
            controller.resume();
          }
        };
      } else {
        scriptEl.onload = function() {
          scriptEl.onload = null;
          controller.loaded();
        };
      }

      scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ?
          goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path) :
          this.path;
      doc.head.appendChild(scriptEl);
    }
  };


  /**
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides Should be an empty array.
   *     TODO(johnplaisted) add support for adding closure namespaces to ES6
   *     modules for interop purposes.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @struct @constructor
   * @extends {goog.Dependency}
   */
  goog.Es6ModuleDependency = function(
      path, relativePath, provides, requires, loadFlags) {
    goog.Es6ModuleDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
  };
  goog.inherits(goog.Es6ModuleDependency, goog.Dependency);


  /** @override */
  goog.Es6ModuleDependency.prototype.load = function(controller) {
    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
      if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }

    if (!goog.inHtmlDocument_()) {
      goog.logToConsole_(
          'Cannot use default debug loader outside of HTML documents.');
      controller.pause();
      return;
    }

    /** @type {!HTMLDocument} */
    var doc = goog.global.document;

    var dep = this;

    // TODO(johnplaisted): Does document.writing really speed up anything? Any
    // difference between this and just waiting for interactive mode and then
    // appending?
    function write(src, contents) {
      if (contents) {
        var script = '<script type="module" crossorigin>' + contents + '</' +
            'script>';
        doc.write(
            goog.TRUSTED_TYPES_POLICY_ ?
                goog.TRUSTED_TYPES_POLICY_.createHTML(script) :
                script);
      } else {
        var script = '<script type="module" crossorigin src="' + src + '"></' +
            'script>';
        doc.write(
            goog.TRUSTED_TYPES_POLICY_ ?
                goog.TRUSTED_TYPES_POLICY_.createHTML(script) :
                script);
      }
    }

    function append(src, contents) {
      var scriptEl =
          /** @type {!HTMLScriptElement} */ (doc.createElement('script'));
      scriptEl.defer = true;
      scriptEl.async = false;
      scriptEl.type = 'module';
      scriptEl.setAttribute('crossorigin', true);

      // If CSP nonces are used, propagate them to dynamically created scripts.
      // This is necessary to allow nonce-based CSPs without 'strict-dynamic'.
      var nonce = goog.getScriptNonce();
      if (nonce) {
        scriptEl.setAttribute('nonce', nonce);
      }

      if (contents) {
        scriptEl.textContent = goog.TRUSTED_TYPES_POLICY_ ?
            goog.TRUSTED_TYPES_POLICY_.createScript(contents) :
            contents;
      } else {
        scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ?
            goog.TRUSTED_TYPES_POLICY_.createScriptURL(src) :
            src;
      }

      doc.head.appendChild(scriptEl);
    }

    var create;

    if (goog.isDocumentLoading_()) {
      create = write;
      // We can ONLY call document.write if we are guaranteed that any
      // non-module script tags document.written after this are deferred.
      // Small optimization, in theory document.writing is faster.
      goog.Dependency.defer_ = true;
    } else {
      create = append;
    }

    // Write 4 separate tags here:
    // 1) Sets the module state at the correct time (just before execution).
    // 2) A src node for this, which just hopefully lets the browser load it a
    //    little early (no need to parse #3).
    // 3) Import the module and register it.
    // 4) Clear the module state at the correct time. Guaranteed to run even
    //    if there is an error in the module (#3 will not run if there is an
    //    error in the module).
    var beforeKey = goog.Dependency.registerCallback_(function() {
      goog.Dependency.unregisterCallback_(beforeKey);
      controller.setModuleState(goog.ModuleType.ES6);
    });
    create(undefined, 'goog.Dependency.callback_("' + beforeKey + '")');

    // TODO(johnplaisted): Does this really speed up anything?
    create(this.path, undefined);

    var registerKey = goog.Dependency.registerCallback_(function(exports) {
      goog.Dependency.unregisterCallback_(registerKey);
      controller.registerEs6ModuleExports(
          dep.path, exports, goog.moduleLoaderState_.moduleName);
    });
    create(
        undefined,
        'import * as m from "' + this.path + '"; goog.Dependency.callback_("' +
            registerKey + '", m)');

    var afterKey = goog.Dependency.registerCallback_(function() {
      goog.Dependency.unregisterCallback_(afterKey);
      controller.clearModuleState();
      controller.loaded();
    });
    create(undefined, 'goog.Dependency.callback_("' + afterKey + '")');
  };


  /**
   * Superclass of any dependency that needs to be loaded into memory,
   * transformed, and then eval'd (goog.modules and transpiled files).
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @struct @constructor @abstract
   * @extends {goog.Dependency}
   */
  goog.TransformedDependency = function(
      path, relativePath, provides, requires, loadFlags) {
    goog.TransformedDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
    /** @private {?string} */
    this.contents_ = null;

    /**
     * Whether to lazily make the synchronous XHR (when goog.require'd) or make
     * the synchronous XHR when initially loading. On FireFox 61 there is a bug
     * where an ES6 module cannot make a synchronous XHR (rather, it can, but if
     * it does then no other ES6 modules will load after).
     *
     * tl;dr we lazy load due to bugs on older browsers and eager load due to
     * bugs on newer ones.
     *
     * https://bugzilla.mozilla.org/show_bug.cgi?id=1477090
     *
     * @private @const {boolean}
     */
    this.lazyFetch_ = !goog.inHtmlDocument_() ||
        !('noModule' in goog.global.document.createElement('script'));
  };
  goog.inherits(goog.TransformedDependency, goog.Dependency);


  /** @override */
  goog.TransformedDependency.prototype.load = function(controller) {
    var dep = this;

    function fetch() {
      dep.contents_ = goog.loadFileSync_(dep.path);

      if (dep.contents_) {
        dep.contents_ = dep.transform(dep.contents_);
        if (dep.contents_) {
          dep.contents_ += '\n//# sourceURL=' + dep.path;
        }
      }
    }

    if (goog.global.CLOSURE_IMPORT_SCRIPT) {
      fetch();
      if (this.contents_ &&
          goog.global.CLOSURE_IMPORT_SCRIPT('', this.contents_)) {
        this.contents_ = null;
        controller.loaded();
      } else {
        controller.pause();
      }
      return;
    }


    var isEs6 = this.loadFlags['module'] == goog.ModuleType.ES6;

    if (!this.lazyFetch_) {
      fetch();
    }

    function load() {
      if (dep.lazyFetch_) {
        fetch();
      }

      if (!dep.contents_) {
        // loadFileSync_ or transform are responsible. Assume they logged an
        // error.
        return;
      }

      if (isEs6) {
        controller.setModuleState(goog.ModuleType.ES6);
      }

      var namespace;

      try {
        var contents = dep.contents_;
        dep.contents_ = null;
        goog.globalEval(contents);
        if (isEs6) {
          namespace = goog.moduleLoaderState_.moduleName;
        }
      } finally {
        if (isEs6) {
          controller.clearModuleState();
        }
      }

      if (isEs6) {
        // Due to circular dependencies this may not be available for require
        // right now.
        goog.global['$jscomp']['require']['ensure'](
            [dep.getPathName()], function() {
              controller.registerEs6ModuleExports(
                  dep.path,
                  goog.global['$jscomp']['require'](dep.getPathName()),
                  namespace);
            });
      }

      controller.loaded();
    }

    // Do not fetch now; in FireFox 47 the synchronous XHR doesn't block all
    // events. If we fetched now and then document.write'd the contents the
    // document.write would be an eval and would execute too soon! Instead write
    // a script tag to fetch and eval synchronously at the correct time.
    function fetchInOwnScriptThenLoad() {
      /** @type {!HTMLDocument} */
      var doc = goog.global.document;

      var key = goog.Dependency.registerCallback_(function() {
        goog.Dependency.unregisterCallback_(key);
        load();
      });

      var script = '<script type="text/javascript">' +
          goog.protectScriptTag_('goog.Dependency.callback_("' + key + '");') +
          '</' +
          'script>';
      doc.write(
          goog.TRUSTED_TYPES_POLICY_ ?
              goog.TRUSTED_TYPES_POLICY_.createHTML(script) :
              script);
    }

    // If one thing is pending it is this.
    var anythingElsePending = controller.pending().length > 1;

    // If anything else is loading we need to lazy load due to bugs in old IE.
    // Specifically script tags with src and script tags with contents could
    // execute out of order if document.write is used, so we cannot use
    // document.write. Do not pause here; it breaks old IE as well.
    var useOldIeWorkAround =
        anythingElsePending && goog.DebugLoader_.IS_OLD_IE_;

    // Additionally if we are meant to defer scripts but the page is still
    // loading (e.g. an ES6 module is loading) then also defer. Or if we are
    // meant to defer and anything else is pending then defer (those may be
    // scripts that did not need transformation and are just script tags with
    // defer set to true, and we need to evaluate after that deferred script).
    var needsAsyncLoading = goog.Dependency.defer_ &&
        (anythingElsePending || goog.isDocumentLoading_());

    if (useOldIeWorkAround || needsAsyncLoading) {
      // Note that we only defer when we have to rather than 100% of the time.
      // Always defering would work, but then in theory the order of
      // goog.require calls would then matter. We want to enforce that most of
      // the time the order of the require calls does not matter.
      controller.defer(function() {
        load();
      });
      return;
    }
    // TODO(johnplaisted): Externs are missing onreadystatechange for
    // HTMLDocument.
    /** @type {?} */
    var doc = goog.global.document;

    var isInternetExplorer =
        goog.inHtmlDocument_() && 'ActiveXObject' in goog.global;

    // Don't delay in any version of IE. There's bug around this that will
    // cause out of order script execution. This means that on older IE ES6
    // modules will load too early (while the document is still loading + the
    // dom is not available). The other option is to load too late (when the
    // document is complete and the onload even will never fire). This seems
    // to be the lesser of two evils as scripts already act like the former.
    if (isEs6 && goog.inHtmlDocument_() && goog.isDocumentLoading_() &&
        !isInternetExplorer) {
      goog.Dependency.defer_ = true;
      // Transpiled ES6 modules still need to load like regular ES6 modules,
      // aka only after the document is interactive.
      controller.pause();
      var oldCallback = doc.onreadystatechange;
      doc.onreadystatechange = function() {
        if (doc.readyState == 'interactive') {
          doc.onreadystatechange = oldCallback;
          load();
          controller.resume();
        }
        if (goog.isFunction(oldCallback)) {
          oldCallback.apply(undefined, arguments);
        }
      };
    } else {
      // Always eval on old IE.
      if (goog.DebugLoader_.IS_OLD_IE_ || !goog.inHtmlDocument_() ||
          !goog.isDocumentLoading_()) {
        load();
      } else {
        fetchInOwnScriptThenLoad();
      }
    }
  };


  /**
   * @param {string} contents
   * @return {string}
   * @abstract
   */
  goog.TransformedDependency.prototype.transform = function(contents) {};


  /**
   * Any non-goog.module dependency which needs to be transpiled before eval.
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @param {!goog.Transpiler} transpiler
   * @struct @constructor
   * @extends {goog.TransformedDependency}
   */
  goog.TranspiledDependency = function(
      path, relativePath, provides, requires, loadFlags, transpiler) {
    goog.TranspiledDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
    /** @protected @const*/
    this.transpiler = transpiler;
  };
  goog.inherits(goog.TranspiledDependency, goog.TransformedDependency);


  /** @override */
  goog.TranspiledDependency.prototype.transform = function(contents) {
    // Transpile with the pathname so that ES6 modules are domain agnostic.
    return this.transpiler.transpile(contents, this.getPathName());
  };


  /**
   * An ES6 module dependency that was transpiled to a jscomp module outside
   * of the debug loader, e.g. server side.
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @struct @constructor
   * @extends {goog.TransformedDependency}
   */
  goog.PreTranspiledEs6ModuleDependency = function(
      path, relativePath, provides, requires, loadFlags) {
    goog.PreTranspiledEs6ModuleDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
  };
  goog.inherits(
      goog.PreTranspiledEs6ModuleDependency, goog.TransformedDependency);


  /** @override */
  goog.PreTranspiledEs6ModuleDependency.prototype.transform = function(
      contents) {
    return contents;
  };


  /**
   * A goog.module, transpiled or not. Will always perform some minimal
   * transformation even when not transpiled to wrap in a goog.loadModule
   * statement.
   *
   * @param {string} path Absolute path of this script.
   * @param {string} relativePath Path of this script relative to goog.basePath.
   * @param {!Array<string>} provides goog.provided or goog.module symbols
   *     in this file.
   * @param {!Array<string>} requires goog symbols or relative paths to Closure
   *     this depends on.
   * @param {!Object<string, string>} loadFlags
   * @param {boolean} needsTranspile
   * @param {!goog.Transpiler} transpiler
   * @struct @constructor
   * @extends {goog.TransformedDependency}
   */
  goog.GoogModuleDependency = function(
      path, relativePath, provides, requires, loadFlags, needsTranspile,
      transpiler) {
    goog.GoogModuleDependency.base(
        this, 'constructor', path, relativePath, provides, requires, loadFlags);
    /** @private @const */
    this.needsTranspile_ = needsTranspile;
    /** @private @const */
    this.transpiler_ = transpiler;
  };
  goog.inherits(goog.GoogModuleDependency, goog.TransformedDependency);


  /** @override */
  goog.GoogModuleDependency.prototype.transform = function(contents) {
    if (this.needsTranspile_) {
      contents = this.transpiler_.transpile(contents, this.getPathName());
    }

    if (!goog.LOAD_MODULE_USING_EVAL || goog.global.JSON === undefined) {
      return '' +
          'goog.loadModule(function(exports) {' +
          '"use strict";' + contents +
          '\n' +  // terminate any trailing single line comment.
          ';return exports' +
          '});' +
          '\n//# sourceURL=' + this.path + '\n';
    } else {
      return '' +
          'goog.loadModule(' +
          goog.global.JSON.stringify(
              contents + '\n//# sourceURL=' + this.path + '\n') +
          ');';
    }
  };


  /**
   * Whether the browser is IE9 or earlier, which needs special handling
   * for deferred modules.
   * @const @private {boolean}
   */
  goog.DebugLoader_.IS_OLD_IE_ = !!(
      !goog.global.atob && goog.global.document && goog.global.document['all']);


  /**
   * @param {string} relPath
   * @param {!Array<string>|undefined} provides
   * @param {!Array<string>} requires
   * @param {boolean|!Object<string>=} opt_loadFlags
   * @see goog.addDependency
   */
  goog.DebugLoader_.prototype.addDependency = function(
      relPath, provides, requires, opt_loadFlags) {
    provides = provides || [];
    relPath = relPath.replace(/\\/g, '/');
    var path = goog.normalizePath_(goog.basePath + relPath);
    if (!opt_loadFlags || typeof opt_loadFlags === 'boolean') {
      opt_loadFlags = opt_loadFlags ? {'module': goog.ModuleType.GOOG} : {};
    }
    var dep = this.factory_.createDependency(
        path, relPath, provides, requires, opt_loadFlags,
        goog.transpiler_.needsTranspile(
            opt_loadFlags['lang'] || 'es3', opt_loadFlags['module']));
    this.dependencies_[path] = dep;
    for (var i = 0; i < provides.length; i++) {
      this.idToPath_[provides[i]] = path;
    }
    this.idToPath_[relPath] = path;
  };


  /**
   * Creates goog.Dependency instances for the debug loader to load.
   *
   * Should be overridden to have the debug loader use custom subclasses of
   * goog.Dependency.
   *
   * @param {!goog.Transpiler} transpiler
   * @struct @constructor
   */
  goog.DependencyFactory = function(transpiler) {
    /** @protected @const */
    this.transpiler = transpiler;
  };


  /**
   * @param {string} path Absolute path of the file.
   * @param {string} relativePath Path relative to closure’s base.js.
   * @param {!Array<string>} provides Array of provided goog.provide/module ids.
   * @param {!Array<string>} requires Array of required goog.provide/module /
   *     relative ES6 module paths.
   * @param {!Object<string, string>} loadFlags
   * @param {boolean} needsTranspile True if the file needs to be transpiled
   *     per the goog.Transpiler.
   * @return {!goog.Dependency}
   */
  goog.DependencyFactory.prototype.createDependency = function(
      path, relativePath, provides, requires, loadFlags, needsTranspile) {

    if (loadFlags['module'] == goog.ModuleType.GOOG) {
      return new goog.GoogModuleDependency(
          path, relativePath, provides, requires, loadFlags, needsTranspile,
          this.transpiler);
    } else if (needsTranspile) {
      return new goog.TranspiledDependency(
          path, relativePath, provides, requires, loadFlags, this.transpiler);
    } else {
      if (loadFlags['module'] == goog.ModuleType.ES6) {
        if (goog.TRANSPILE == 'never' && goog.ASSUME_ES_MODULES_TRANSPILED) {
          return new goog.PreTranspiledEs6ModuleDependency(
              path, relativePath, provides, requires, loadFlags);
        } else {
          return new goog.Es6ModuleDependency(
              path, relativePath, provides, requires, loadFlags);
        }
      } else {
        return new goog.Dependency(
            path, relativePath, provides, requires, loadFlags);
      }
    }
  };


  /** @private @const */
  goog.debugLoader_ = new goog.DebugLoader_();


  /**
   * Loads the Closure Dependency file.
   *
   * Exposed a public function so CLOSURE_NO_DEPS can be set to false, base
   * loaded, setDependencyFactory called, and then this called. i.e. allows
   * custom loading of the deps file.
   */
  goog.loadClosureDeps = function() {
    goog.debugLoader_.loadClosureDeps();
  };


  /**
   * Sets the dependency factory, which can be used to create custom
   * goog.Dependency implementations to control how dependencies are loaded.
   *
   * Note: if you wish to call this function and provide your own implemnetation
   * it is a wise idea to set CLOSURE_NO_DEPS to true, otherwise the dependency
   * file and all of its goog.addDependency calls will use the default factory.
   * You can call goog.loadClosureDeps to load the Closure dependency file
   * later, after your factory is injected.
   *
   * @param {!goog.DependencyFactory} factory
   */
  goog.setDependencyFactory = function(factory) {
    goog.debugLoader_.setDependencyFactory(factory);
  };


  if (!goog.global.CLOSURE_NO_DEPS) {
    goog.debugLoader_.loadClosureDeps();
  }


  /**
   * Bootstraps the given namespaces and calls the callback once they are
   * available either via goog.require. This is a replacement for using
   * `goog.require` to bootstrap Closure JavaScript. Previously a `goog.require`
   * in an HTML file would guarantee that the require'd namespace was available
   * in the next immediate script tag. With ES6 modules this no longer a
   * guarantee.
   *
   * @param {!Array<string>} namespaces
   * @param {function(): ?} callback Function to call once all the namespaces
   *     have loaded. Always called asynchronously.
   */
  goog.bootstrap = function(namespaces, callback) {
    goog.debugLoader_.bootstrap(namespaces, callback);
  };
}


/**
 * @define {string} Trusted Types policy name. If non-empty then Closure will
 * use Trusted Types.
 */
goog.TRUSTED_TYPES_POLICY_NAME =
    goog.define('goog.TRUSTED_TYPES_POLICY_NAME', '');


/**
 * Returns the parameter.
 * @param {string} s
 * @return {string}
 * @private
 */
goog.identity_ = function(s) {
  return s;
};


/**
 * Creates Trusted Types policy if Trusted Types are supported by the browser.
 * The policy just blesses any string as a Trusted Type. It is not visibility
 * restricted because anyone can also call TrustedTypes.createPolicy directly.
 * However, the allowed names should be restricted by a HTTP header and the
 * reference to the created policy should be visibility restricted.
 * @param {string} name
 * @return {?TrustedTypePolicy}
 */
goog.createTrustedTypesPolicy = function(name) {
  var policy = null;
  // TODO(koto): Remove window.TrustedTypes variant when the newer API ships.
  var policyFactory = goog.global.trustedTypes || goog.global.TrustedTypes;
  if (!policyFactory || !policyFactory.createPolicy) {
    return policy;
  }
  // TrustedTypes.createPolicy throws if called with a name that is already
  // registered, even in report-only mode. Until the API changes, catch the
  // error not to break the applications functionally. In such case, the code
  // will fall back to using regular Safe Types.
  // TODO(koto): Remove catching once createPolicy API stops throwing.
  try {
    policy = policyFactory.createPolicy(name, {
      createHTML: goog.identity_,
      createScript: goog.identity_,
      createScriptURL: goog.identity_,
      createURL: goog.identity_
    });
  } catch (e) {
    goog.logToConsole_(e.message);
  }
  return policy;
};


/** @private @const {?TrustedTypePolicy} */
goog.TRUSTED_TYPES_POLICY_ = goog.TRUSTED_TYPES_POLICY_NAME ?
    goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME + '#base') :
    null;

// Copyright 2019 The Closure Library 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.
//
// This file has been auto-generated by GenJsDeps, please do not edit.

// Disable Clang formatter for this file.
// See http://goo.gl/SdiwZH
// clang-format off

goog.addDependency('collections/sets.js', ['goog.collections.sets'], ['goog.labs.collections.iterables'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('collections/sets_test.js', ['goog.collections.setsTest'], ['goog.collections.sets', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferred.js', ['goog.async.Deferred', 'goog.async.Deferred.AlreadyCalledError', 'goog.async.Deferred.CanceledError'], ['goog.Promise', 'goog.Thenable', 'goog.array', 'goog.asserts', 'goog.debug.Error'], {});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferred_async_test.js', ['goog.async.deferredAsyncTest'], ['goog.async.Deferred', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferred_test.js', ['goog.async.deferredTest'], ['goog.Promise', 'goog.Thenable', 'goog.async.Deferred', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferredlist.js', ['goog.async.DeferredList'], ['goog.async.Deferred'], {});
goog.addDependency('../../third_party/closure/goog/mochikit/async/deferredlist_test.js', ['goog.async.deferredListTest'], ['goog.array', 'goog.async.Deferred', 'goog.async.DeferredList', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto/proto.js', ['goog.proto'], ['goog.proto.Serializer'], {});
goog.addDependency('proto/serializer.js', ['goog.proto.Serializer'], ['goog.json.Serializer', 'goog.string'], {});
goog.addDependency('proto/serializer_test.js', ['goog.protoTest'], ['goog.proto', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('a11y/aria/announcer.js', ['goog.a11y.aria.Announcer'], ['goog.Disposable', 'goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.LivePriority', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.object'], {});
goog.addDependency('a11y/aria/announcer_test.js', ['goog.a11y.aria.AnnouncerTest'], ['goog.a11y.aria', 'goog.a11y.aria.Announcer', 'goog.a11y.aria.LivePriority', 'goog.a11y.aria.State', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.iframe', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('a11y/aria/aria.js', ['goog.a11y.aria'], ['goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.a11y.aria.datatables', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.object', 'goog.string'], {});
goog.addDependency('a11y/aria/aria_test.js', ['goog.a11y.ariaTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('a11y/aria/attributes.js', ['goog.a11y.aria.AutoCompleteValues', 'goog.a11y.aria.CheckedValues', 'goog.a11y.aria.DropEffectValues', 'goog.a11y.aria.ExpandedValues', 'goog.a11y.aria.GrabbedValues', 'goog.a11y.aria.InvalidValues', 'goog.a11y.aria.LivePriority', 'goog.a11y.aria.OrientationValues', 'goog.a11y.aria.PressedValues', 'goog.a11y.aria.RelevantValues', 'goog.a11y.aria.SelectedValues', 'goog.a11y.aria.SortValues', 'goog.a11y.aria.State'], [], {});
goog.addDependency('a11y/aria/datatables.js', ['goog.a11y.aria.datatables'], ['goog.a11y.aria.State', 'goog.object'], {});
goog.addDependency('a11y/aria/roles.js', ['goog.a11y.aria.Role'], [], {});
goog.addDependency('array/array.js', ['goog.array'], ['goog.asserts'], {});
goog.addDependency('array/array_test.js', ['goog.arrayTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es7', 'module': 'goog'});
goog.addDependency('asserts/asserts.js', ['goog.asserts', 'goog.asserts.AssertionError'], ['goog.debug.Error', 'goog.dom.NodeType'], {});
goog.addDependency('asserts/asserts_test.js', ['goog.assertsTest'], ['goog.asserts', 'goog.asserts.AssertionError', 'goog.dom', 'goog.dom.TagName', 'goog.reflect', 'goog.string', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/animationdelay.js', ['goog.async.AnimationDelay'], ['goog.Disposable', 'goog.events', 'goog.functions'], {});
goog.addDependency('async/animationdelay_test.js', ['goog.async.AnimationDelayTest'], ['goog.Promise', 'goog.Timer', 'goog.async.AnimationDelay', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/conditionaldelay.js', ['goog.async.ConditionalDelay'], ['goog.Disposable', 'goog.async.Delay'], {});
goog.addDependency('async/conditionaldelay_test.js', ['goog.async.ConditionalDelayTest'], ['goog.async.ConditionalDelay', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/debouncer.js', ['goog.async.Debouncer'], ['goog.Disposable', 'goog.Timer'], {});
goog.addDependency('async/debouncer_test.js', ['goog.async.DebouncerTest'], ['goog.array', 'goog.async.Debouncer', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/delay.js', ['goog.Delay', 'goog.async.Delay'], ['goog.Disposable', 'goog.Timer'], {});
goog.addDependency('async/delay_test.js', ['goog.async.DelayTest'], ['goog.async.Delay', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/freelist.js', ['goog.async.FreeList'], [], {'lang': 'es6'});
goog.addDependency('async/freelist_test.js', ['goog.async.FreeListTest'], ['goog.async.FreeList', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/nexttick.js', ['goog.async.nextTick', 'goog.async.throwException'], ['goog.debug.entryPointRegistry', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.labs.userAgent.browser', 'goog.labs.userAgent.engine', 'goog.string.Const'], {});
goog.addDependency('async/nexttick_test.js', ['goog.async.nextTickTest'], ['goog.Promise', 'goog.async.nextTick', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.dom', 'goog.dom.TagName', 'goog.labs.userAgent.browser', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/run.js', ['goog.async.run'], ['goog.async.WorkQueue', 'goog.async.nextTick', 'goog.async.throwException'], {});
goog.addDependency('async/run_next_tick_test.js', ['goog.async.runNextTickTest'], ['goog.async.run', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/run_test.js', ['goog.async.runTest'], ['goog.async.run', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/throttle.js', ['goog.Throttle', 'goog.async.Throttle'], ['goog.Disposable', 'goog.Timer'], {});
goog.addDependency('async/throttle_test.js', ['goog.async.ThrottleTest'], ['goog.async.Throttle', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('async/workqueue.js', ['goog.async.WorkItem', 'goog.async.WorkQueue'], ['goog.asserts', 'goog.async.FreeList'], {});
goog.addDependency('async/workqueue_test.js', ['goog.async.WorkQueueTest'], ['goog.async.WorkQueue', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('base.js', ['goog'], [], {});
goog.addDependency('base_module_test.js', ['goog.baseModuleTest'], ['goog.Timer', 'goog.test_module', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('base_test.js', ['goog.baseTest'], ['goog.Promise', 'goog.Timer', 'goog.Uri', 'goog.dom', 'goog.dom.TagName', 'goog.object', 'goog.test_module', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit', 'goog.testing.recordFunction', 'goog.userAgent'], {'lang': 'es6'});
goog.addDependency('color/alpha.js', ['goog.color.alpha'], ['goog.color'], {});
goog.addDependency('color/alpha_test.js', ['goog.color.alphaTest'], ['goog.array', 'goog.color.alpha', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('color/color.js', ['goog.color', 'goog.color.Hsl', 'goog.color.Hsv', 'goog.color.Rgb'], ['goog.color.names', 'goog.math'], {});
goog.addDependency('color/color_test.js', ['goog.colorTest'], ['goog.array', 'goog.color', 'goog.color.names', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('color/names.js', ['goog.color.names'], [], {});
goog.addDependency('crypt/aes.js', ['goog.crypt.Aes'], ['goog.asserts', 'goog.crypt.BlockCipher'], {});
goog.addDependency('crypt/aes_test.js', ['goog.crypt.AesTest'], ['goog.crypt', 'goog.crypt.Aes', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/arc4.js', ['goog.crypt.Arc4'], ['goog.asserts'], {});
goog.addDependency('crypt/arc4_test.js', ['goog.crypt.Arc4Test'], ['goog.array', 'goog.crypt.Arc4', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/base64.js', ['goog.crypt.base64'], ['goog.asserts', 'goog.crypt', 'goog.string', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es5'});
goog.addDependency('crypt/base64_test.js', ['goog.crypt.base64Test'], ['goog.crypt', 'goog.crypt.base64', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/basen.js', ['goog.crypt.baseN'], [], {'lang': 'es6'});
goog.addDependency('crypt/basen_test.js', ['goog.crypt.baseNTest'], ['goog.crypt.baseN', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/blobhasher.js', ['goog.crypt.BlobHasher', 'goog.crypt.BlobHasher.EventType'], ['goog.asserts', 'goog.events.EventTarget', 'goog.fs', 'goog.log'], {});
goog.addDependency('crypt/blobhasher_test.js', ['goog.crypt.BlobHasherTest'], ['goog.crypt', 'goog.crypt.BlobHasher', 'goog.crypt.Md5', 'goog.events', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/blockcipher.js', ['goog.crypt.BlockCipher'], [], {});
goog.addDependency('crypt/bytestring_perf.js', ['goog.crypt.byteArrayToStringPerf'], ['goog.array', 'goog.dom', 'goog.testing.PerformanceTable'], {});
goog.addDependency('crypt/cbc.js', ['goog.crypt.Cbc'], ['goog.array', 'goog.asserts', 'goog.crypt', 'goog.crypt.BlockCipher'], {});
goog.addDependency('crypt/cbc_test.js', ['goog.crypt.CbcTest'], ['goog.crypt', 'goog.crypt.Aes', 'goog.crypt.Cbc', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/crypt.js', ['goog.crypt'], ['goog.array', 'goog.asserts'], {});
goog.addDependency('crypt/crypt_test.js', ['goog.cryptTest'], ['goog.crypt', 'goog.string', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/ctr.js', ['goog.crypt.Ctr'], ['goog.array', 'goog.asserts', 'goog.crypt'], {});
goog.addDependency('crypt/ctr_test.js', ['goog.crypt.CtrTest'], ['goog.crypt', 'goog.crypt.Aes', 'goog.crypt.Ctr', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('crypt/hash.js', ['goog.crypt.Hash'], [], {});
goog.addDependency('crypt/hash32.js', ['goog.crypt.hash32'], ['goog.crypt'], {});
goog.addDependency('crypt/hash32_test.js', ['goog.crypt.hash32Test'], ['goog.crypt.hash32', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/hashtester.js', ['goog.crypt.hashTester'], ['goog.array', 'goog.crypt', 'goog.dom', 'goog.dom.TagName', 'goog.reflect', 'goog.testing.PerformanceTable', 'goog.testing.PseudoRandom', 'goog.testing.asserts'], {});
goog.addDependency('crypt/hmac.js', ['goog.crypt.Hmac'], ['goog.crypt.Hash'], {});
goog.addDependency('crypt/hmac_test.js', ['goog.crypt.HmacTest'], ['goog.crypt.Hmac', 'goog.crypt.Sha1', 'goog.crypt.hashTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/md5.js', ['goog.crypt.Md5'], ['goog.crypt.Hash'], {});
goog.addDependency('crypt/md5_test.js', ['goog.crypt.Md5Test'], ['goog.crypt', 'goog.crypt.Md5', 'goog.crypt.hashTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/pbkdf2.js', ['goog.crypt.pbkdf2'], ['goog.array', 'goog.asserts', 'goog.crypt', 'goog.crypt.Hmac', 'goog.crypt.Sha1'], {});
goog.addDependency('crypt/pbkdf2_test.js', ['goog.crypt.pbkdf2Test'], ['goog.crypt', 'goog.crypt.pbkdf2', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha1.js', ['goog.crypt.Sha1'], ['goog.crypt.Hash'], {});
goog.addDependency('crypt/sha1_test.js', ['goog.crypt.Sha1Test'], ['goog.crypt', 'goog.crypt.Sha1', 'goog.crypt.hashTester', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha2.js', ['goog.crypt.Sha2'], ['goog.array', 'goog.asserts', 'goog.crypt.Hash'], {});
goog.addDependency('crypt/sha224.js', ['goog.crypt.Sha224'], ['goog.crypt.Sha2'], {});
goog.addDependency('crypt/sha224_test.js', ['goog.crypt.Sha224Test'], ['goog.crypt', 'goog.crypt.Sha224', 'goog.crypt.hashTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha256.js', ['goog.crypt.Sha256'], ['goog.crypt.Sha2'], {});
goog.addDependency('crypt/sha256_test.js', ['goog.crypt.Sha256Test'], ['goog.crypt', 'goog.crypt.Sha256', 'goog.crypt.hashTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha2_64bit.js', ['goog.crypt.Sha2_64bit'], ['goog.array', 'goog.asserts', 'goog.crypt.Hash', 'goog.math.Long'], {});
goog.addDependency('crypt/sha2_64bit_test.js', ['goog.crypt.Sha2_64bit_test'], ['goog.array', 'goog.crypt', 'goog.crypt.Sha384', 'goog.crypt.Sha512', 'goog.crypt.Sha512_256', 'goog.crypt.hashTester', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('crypt/sha384.js', ['goog.crypt.Sha384'], ['goog.crypt.Sha2_64bit'], {});
goog.addDependency('crypt/sha512.js', ['goog.crypt.Sha512'], ['goog.crypt.Sha2_64bit'], {});
goog.addDependency('crypt/sha512_256.js', ['goog.crypt.Sha512_256'], ['goog.crypt.Sha2_64bit'], {});
goog.addDependency('cssom/cssom.js', ['goog.cssom', 'goog.cssom.CssRuleType'], ['goog.array', 'goog.dom', 'goog.dom.TagName'], {});
goog.addDependency('cssom/cssom_test.js', ['goog.cssomTest'], ['goog.array', 'goog.cssom', 'goog.cssom.CssRuleType', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('cssom/iframe/style.js', ['goog.cssom.iframe.style'], ['goog.asserts', 'goog.cssom', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.string', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('cssom/iframe/style_test.js', ['goog.cssom.iframe.styleTest'], ['goog.cssom', 'goog.cssom.iframe.style', 'goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/datamanager.js', ['goog.ds.DataManager'], ['goog.ds.BasicNodeList', 'goog.ds.DataNode', 'goog.ds.Expr', 'goog.object', 'goog.string', 'goog.structs', 'goog.structs.Map'], {});
goog.addDependency('datasource/datasource.js', ['goog.ds.BaseDataNode', 'goog.ds.BasicNodeList', 'goog.ds.DataNode', 'goog.ds.DataNodeList', 'goog.ds.EmptyNodeList', 'goog.ds.LoadState', 'goog.ds.SortedNodeList', 'goog.ds.Util', 'goog.ds.logger'], ['goog.array', 'goog.log'], {});
goog.addDependency('datasource/datasource_test.js', ['goog.ds.JsDataSourceTest'], ['goog.dom.xml', 'goog.ds.DataManager', 'goog.ds.JsDataSource', 'goog.ds.SortedNodeList', 'goog.ds.XmlDataSource', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/expr.js', ['goog.ds.Expr'], ['goog.ds.BasicNodeList', 'goog.ds.EmptyNodeList', 'goog.string'], {});
goog.addDependency('datasource/expr_test.js', ['goog.ds.ExprTest'], ['goog.ds.DataManager', 'goog.ds.Expr', 'goog.ds.JsDataSource', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/fastdatanode.js', ['goog.ds.AbstractFastDataNode', 'goog.ds.FastDataNode', 'goog.ds.FastListNode', 'goog.ds.PrimitiveFastDataNode'], ['goog.ds.DataManager', 'goog.ds.DataNodeList', 'goog.ds.EmptyNodeList', 'goog.string'], {});
goog.addDependency('datasource/fastdatanode_test.js', ['goog.ds.FastDataNodeTest'], ['goog.array', 'goog.ds.DataManager', 'goog.ds.Expr', 'goog.ds.FastDataNode', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/jsdatasource.js', ['goog.ds.JsDataSource', 'goog.ds.JsPropertyDataSource'], ['goog.ds.BaseDataNode', 'goog.ds.BasicNodeList', 'goog.ds.DataManager', 'goog.ds.DataNode', 'goog.ds.EmptyNodeList', 'goog.ds.LoadState'], {});
goog.addDependency('datasource/jsondatasource.js', ['goog.ds.JsonDataSource'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.ds.DataManager', 'goog.ds.JsDataSource', 'goog.ds.LoadState', 'goog.ds.logger', 'goog.log'], {});
goog.addDependency('datasource/jsxmlhttpdatasource.js', ['goog.ds.JsXmlHttpDataSource'], ['goog.Uri', 'goog.ds.DataManager', 'goog.ds.FastDataNode', 'goog.ds.LoadState', 'goog.ds.logger', 'goog.events', 'goog.log', 'goog.net.EventType', 'goog.net.XhrIo'], {});
goog.addDependency('datasource/jsxmlhttpdatasource_test.js', ['goog.ds.JsXmlHttpDataSourceTest'], ['goog.ds.JsXmlHttpDataSource', 'goog.testing.TestQueue', 'goog.testing.net.XhrIo', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('datasource/xmldatasource.js', ['goog.ds.XmlDataSource', 'goog.ds.XmlHttpDataSource'], ['goog.Uri', 'goog.dom.NodeType', 'goog.dom.xml', 'goog.ds.BasicNodeList', 'goog.ds.DataManager', 'goog.ds.DataNode', 'goog.ds.LoadState', 'goog.ds.logger', 'goog.log', 'goog.net.XhrIo', 'goog.string'], {});
goog.addDependency('date/date.js', ['goog.date', 'goog.date.Date', 'goog.date.DateTime', 'goog.date.Interval', 'goog.date.month', 'goog.date.weekDay'], ['goog.asserts', 'goog.date.DateLike', 'goog.i18n.DateTimeSymbols', 'goog.string'], {});
goog.addDependency('date/date_test.js', ['goog.dateTest'], ['goog.array', 'goog.date', 'goog.date.Date', 'goog.date.DateTime', 'goog.date.Interval', 'goog.date.month', 'goog.date.weekDay', 'goog.i18n.DateTimeSymbols', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.platform', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('date/datelike.js', ['goog.date.DateLike'], [], {});
goog.addDependency('date/daterange.js', ['goog.date.DateRange', 'goog.date.DateRange.Iterator', 'goog.date.DateRange.StandardDateRangeKeys'], ['goog.date.Date', 'goog.date.Interval', 'goog.iter.Iterator', 'goog.iter.StopIteration'], {});
goog.addDependency('date/daterange_test.js', ['goog.date.DateRangeTest'], ['goog.date.Date', 'goog.date.DateRange', 'goog.date.Interval', 'goog.i18n.DateTimeSymbols', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('date/duration.js', ['goog.date.duration'], ['goog.i18n.DateTimeFormat', 'goog.i18n.MessageFormat'], {});
goog.addDependency('date/duration_test.js', ['goog.date.durationTest'], ['goog.date.duration', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbols_bn', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_fa', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('date/relative.js', ['goog.date.relative', 'goog.date.relative.TimeDeltaFormatter', 'goog.date.relative.Unit'], ['goog.i18n.DateTimeFormat', 'goog.i18n.DateTimePatterns', 'goog.i18n.RelativeDateTimeFormat'], {});
goog.addDependency('date/relative_test.js', ['goog.date.relativeTest'], ['goog.date.relativeCommonTests'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('date/relativecommontests.js', ['goog.date.relativeCommonTests'], ['goog.date.DateTime', 'goog.date.relative', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimePatterns_ar', 'goog.i18n.DateTimePatterns_bn', 'goog.i18n.DateTimePatterns_es', 'goog.i18n.DateTimePatterns_fa', 'goog.i18n.DateTimePatterns_fr', 'goog.i18n.DateTimePatterns_no', 'goog.i18n.DateTimeSymbols_ar', 'goog.i18n.DateTimeSymbols_bn', 'goog.i18n.DateTimeSymbols_es', 'goog.i18n.DateTimeSymbols_fa', 'goog.i18n.DateTimeSymbols_fr', 'goog.i18n.DateTimeSymbols_no', 'goog.i18n.NumberFormatSymbols_bn', 'goog.i18n.NumberFormatSymbols_en', 'goog.i18n.NumberFormatSymbols_fa', 'goog.i18n.NumberFormatSymbols_no', 'goog.i18n.relativeDateTimeSymbols', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('date/utcdatetime.js', ['goog.date.UtcDateTime'], ['goog.date', 'goog.date.Date', 'goog.date.DateTime', 'goog.date.Interval'], {});
goog.addDependency('date/utcdatetime_test.js', ['goog.date.UtcDateTimeTest'], ['goog.date.Interval', 'goog.date.UtcDateTime', 'goog.date.month', 'goog.date.weekDay', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('db/cursor.js', ['goog.db.Cursor'], ['goog.async.Deferred', 'goog.db.Error', 'goog.db.KeyRange', 'goog.debug', 'goog.events.EventTarget'], {});
goog.addDependency('db/db.js', ['goog.db', 'goog.db.BlockedCallback', 'goog.db.UpgradeNeededCallback'], ['goog.asserts', 'goog.async.Deferred', 'goog.db.Error', 'goog.db.IndexedDb', 'goog.db.Transaction'], {});
goog.addDependency('db/db_test.js', ['goog.dbTest'], ['goog.Promise', 'goog.array', 'goog.db', 'goog.db.Cursor', 'goog.db.Error', 'goog.db.IndexedDb', 'goog.db.KeyRange', 'goog.db.Transaction', 'goog.events', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('db/error.js', ['goog.db.DomErrorLike', 'goog.db.Error', 'goog.db.Error.ErrorCode', 'goog.db.Error.ErrorName', 'goog.db.Error.VersionChangeBlockedError'], ['goog.asserts', 'goog.debug.Error'], {});
goog.addDependency('db/index.js', ['goog.db.Index'], ['goog.async.Deferred', 'goog.db.Cursor', 'goog.db.Error', 'goog.db.KeyRange', 'goog.debug'], {});
goog.addDependency('db/indexeddb.js', ['goog.db.IndexedDb'], ['goog.db.Error', 'goog.db.ObjectStore', 'goog.db.Transaction', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget'], {'lang': 'es6'});
goog.addDependency('db/keyrange.js', ['goog.db.KeyRange'], [], {});
goog.addDependency('db/objectstore.js', ['goog.db.ObjectStore'], ['goog.async.Deferred', 'goog.db.Cursor', 'goog.db.Error', 'goog.db.Index', 'goog.db.KeyRange', 'goog.debug'], {});
goog.addDependency('db/transaction.js', ['goog.db.Transaction', 'goog.db.Transaction.TransactionMode'], ['goog.async.Deferred', 'goog.db.Error', 'goog.db.ObjectStore', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventTarget'], {});
goog.addDependency('debug/console.js', ['goog.debug.Console'], ['goog.debug.LogManager', 'goog.debug.Logger', 'goog.debug.TextFormatter'], {});
goog.addDependency('debug/console_test.js', ['goog.debug.ConsoleTest'], ['goog.debug.Console', 'goog.debug.LogRecord', 'goog.debug.Logger', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/debug.js', ['goog.debug'], ['goog.array', 'goog.debug.errorcontext', 'goog.userAgent'], {});
goog.addDependency('debug/debug_test.js', ['goog.debugTest'], ['goog.debug', 'goog.debug.errorcontext', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/debugwindow.js', ['goog.debug.DebugWindow'], ['goog.debug.HtmlFormatter', 'goog.debug.LogManager', 'goog.debug.Logger', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.string.Const', 'goog.structs.CircularBuffer', 'goog.userAgent'], {});
goog.addDependency('debug/debugwindow_test.js', ['goog.debug.DebugWindowTest'], ['goog.debug.DebugWindow', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/devcss/devcss.js', ['goog.debug.DevCss', 'goog.debug.DevCss.UserAgent'], ['goog.asserts', 'goog.cssom', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('debug/devcss/devcss_test.js', ['goog.debug.DevCssTest'], ['goog.debug.DevCss', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/devcss/devcssrunner.js', ['goog.debug.devCssRunner'], ['goog.debug.DevCss'], {});
goog.addDependency('debug/divconsole.js', ['goog.debug.DivConsole'], ['goog.debug.HtmlFormatter', 'goog.debug.LogManager', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.string.Const', 'goog.style'], {});
goog.addDependency('debug/enhanceerror_test.js', ['goog.debugEnhanceErrorTest'], ['goog.debug', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/entrypointregistry.js', ['goog.debug.EntryPointMonitor', 'goog.debug.entryPointRegistry'], ['goog.asserts'], {});
goog.addDependency('debug/entrypointregistry_test.js', ['goog.debug.entryPointRegistryTest'], ['goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/error.js', ['goog.debug.Error'], [], {'lang': 'es6'});
goog.addDependency('debug/error_test.js', ['goog.debug.ErrorTest'], ['goog.debug.Error', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/errorcontext.js', ['goog.debug.errorcontext'], [], {});
goog.addDependency('debug/errorcontext_test.js', ['goog.debug.errorcontextTest'], ['goog.debug.errorcontext', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/errorhandler.js', ['goog.debug.ErrorHandler', 'goog.debug.ErrorHandler.ProtectedFunctionError'], ['goog.Disposable', 'goog.asserts', 'goog.debug', 'goog.debug.EntryPointMonitor', 'goog.debug.Error', 'goog.debug.Trace'], {'lang': 'es6'});
goog.addDependency('debug/errorhandler_async_test.js', ['goog.debug.ErrorHandlerAsyncTest'], ['goog.Promise', 'goog.debug.ErrorHandler', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('debug/errorhandler_test.js', ['goog.debug.ErrorHandlerTest'], ['goog.debug.ErrorHandler', 'goog.testing.MockControl', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/errorhandlerweakdep.js', ['goog.debug.errorHandlerWeakDep'], [], {});
goog.addDependency('debug/errorreporter.js', ['goog.debug.ErrorReporter', 'goog.debug.ErrorReporter.ExceptionEvent'], ['goog.asserts', 'goog.debug', 'goog.debug.Error', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.debug.errorcontext', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.log', 'goog.net.XhrIo', 'goog.object', 'goog.string', 'goog.uri.utils', 'goog.userAgent'], {});
goog.addDependency('debug/errorreporter_test.js', ['goog.debug.ErrorReporterTest'], ['goog.debug.Error', 'goog.debug.ErrorReporter', 'goog.debug.errorcontext', 'goog.events', 'goog.functions', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/fancywindow.js', ['goog.debug.FancyWindow'], ['goog.array', 'goog.asserts', 'goog.debug.DebugWindow', 'goog.debug.LogManager', 'goog.debug.Logger', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.object', 'goog.string', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('debug/formatter.js', ['goog.debug.Formatter', 'goog.debug.HtmlFormatter', 'goog.debug.TextFormatter'], ['goog.debug', 'goog.debug.Logger', 'goog.debug.RelativeTimeProvider', 'goog.html.SafeHtml', 'goog.html.SafeUrl', 'goog.html.uncheckedconversions', 'goog.string.Const'], {});
goog.addDependency('debug/formatter_test.js', ['goog.debug.FormatterTest'], ['goog.debug.HtmlFormatter', 'goog.debug.LogRecord', 'goog.debug.Logger', 'goog.html.SafeHtml', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/fpsdisplay.js', ['goog.debug.FpsDisplay'], ['goog.asserts', 'goog.async.AnimationDelay', 'goog.dom', 'goog.dom.TagName', 'goog.ui.Component'], {});
goog.addDependency('debug/fpsdisplay_test.js', ['goog.debug.FpsDisplayTest'], ['goog.Timer', 'goog.debug.FpsDisplay', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/logbuffer.js', ['goog.debug.LogBuffer'], ['goog.asserts', 'goog.debug.LogRecord'], {});
goog.addDependency('debug/logbuffer_test.js', ['goog.debug.LogBufferTest'], ['goog.debug.LogBuffer', 'goog.debug.Logger', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/logger.js', ['goog.debug.LogManager', 'goog.debug.Loggable', 'goog.debug.Logger', 'goog.debug.Logger.Level'], ['goog.array', 'goog.asserts', 'goog.debug', 'goog.debug.LogBuffer', 'goog.debug.LogRecord'], {});
goog.addDependency('debug/logger_test.js', ['goog.debug.LoggerTest'], ['goog.debug.LogManager', 'goog.debug.Logger', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/logrecord.js', ['goog.debug.LogRecord'], [], {});
goog.addDependency('debug/logrecordserializer.js', ['goog.debug.logRecordSerializer'], ['goog.debug.LogRecord', 'goog.debug.Logger', 'goog.json', 'goog.object'], {});
goog.addDependency('debug/logrecordserializer_test.js', ['goog.debug.logRecordSerializerTest'], ['goog.debug.LogRecord', 'goog.debug.Logger', 'goog.debug.logRecordSerializer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('debug/relativetimeprovider.js', ['goog.debug.RelativeTimeProvider'], [], {});
goog.addDependency('debug/tracer.js', ['goog.debug.StopTraceDetail', 'goog.debug.Trace'], ['goog.array', 'goog.asserts', 'goog.debug.Logger', 'goog.iter', 'goog.log', 'goog.structs.Map', 'goog.structs.SimplePool'], {});
goog.addDependency('debug/tracer_test.js', ['goog.debug.TraceTest'], ['goog.array', 'goog.debug.Trace', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('defineclass_test.js', ['goog.defineClassTest'], ['goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('delegate/delegateregistry.js', ['goog.delegate.DelegateRegistry'], ['goog.array', 'goog.asserts', 'goog.debug'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('delegate/delegateregistry_test.js', ['goog.delegate.DelegateRegistryTest'], ['goog.array', 'goog.delegate.DelegateRegistry', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('delegate/delegates.js', ['goog.delegate.delegates'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('delegate/delegates_test.js', ['goog.delegate.delegatesTest'], ['goog.delegate.delegates', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('disposable/disposable.js', ['goog.Disposable', 'goog.dispose', 'goog.disposeAll'], ['goog.disposable.IDisposable'], {});
goog.addDependency('disposable/disposable_test.js', ['goog.DisposableTest'], ['goog.Disposable', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('disposable/idisposable.js', ['goog.disposable.IDisposable'], [], {});
goog.addDependency('dom/abstractmultirange.js', ['goog.dom.AbstractMultiRange'], ['goog.array', 'goog.dom', 'goog.dom.AbstractRange', 'goog.dom.TextRange'], {});
goog.addDependency('dom/abstractrange.js', ['goog.dom.AbstractRange', 'goog.dom.RangeIterator', 'goog.dom.RangeType'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.SavedCaretRange', 'goog.dom.TagIterator', 'goog.userAgent'], {});
goog.addDependency('dom/abstractrange_test.js', ['goog.dom.AbstractRangeTest'], ['goog.dom', 'goog.dom.AbstractRange', 'goog.dom.Range', 'goog.dom.TagName', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/animationframe/animationframe.js', ['goog.dom.animationFrame', 'goog.dom.animationFrame.Spec', 'goog.dom.animationFrame.State'], ['goog.dom.animationFrame.polyfill'], {});
goog.addDependency('dom/animationframe/animationframe_test.js', ['goog.dom.AnimationFrameTest'], ['goog.dom.animationFrame', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/animationframe/polyfill.js', ['goog.dom.animationFrame.polyfill'], [], {'lang': 'es6'});
goog.addDependency('dom/annotate.js', ['goog.dom.annotate', 'goog.dom.annotate.AnnotateFn'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.object'], {});
goog.addDependency('dom/annotate_test.js', ['goog.dom.annotateTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.annotate', 'goog.html.SafeHtml', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/asserts.js', ['goog.dom.asserts'], ['goog.asserts'], {});
goog.addDependency('dom/asserts_test.js', ['goog.dom.assertsTest'], ['goog.dom.asserts', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/attr.js', ['goog.dom.Attr'], [], {});
goog.addDependency('dom/browserfeature.js', ['goog.dom.BrowserFeature'], ['goog.userAgent'], {});
goog.addDependency('dom/browserfeature_test.js', ['goog.dom.BrowserFeatureTest'], ['goog.dom', 'goog.dom.BrowserFeature', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/browserrange/abstractrange.js', ['goog.dom.browserrange.AbstractRange'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.RangeEndpoint', 'goog.dom.TagName', 'goog.dom.TextRangeIterator', 'goog.iter', 'goog.math.Coordinate', 'goog.string', 'goog.string.StringBuffer', 'goog.userAgent'], {});
goog.addDependency('dom/browserrange/browserrange.js', ['goog.dom.browserrange', 'goog.dom.browserrange.Error'], ['goog.dom', 'goog.dom.BrowserFeature', 'goog.dom.NodeType', 'goog.dom.browserrange.GeckoRange', 'goog.dom.browserrange.IeRange', 'goog.dom.browserrange.OperaRange', 'goog.dom.browserrange.W3cRange', 'goog.dom.browserrange.WebKitRange', 'goog.userAgent'], {});
goog.addDependency('dom/browserrange/browserrange_test.js', ['goog.dom.browserrangeTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.RangeEndpoint', 'goog.dom.TagName', 'goog.dom.browserrange', 'goog.html.testing', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/browserrange/geckorange.js', ['goog.dom.browserrange.GeckoRange'], ['goog.dom.browserrange.W3cRange'], {});
goog.addDependency('dom/browserrange/ierange.js', ['goog.dom.browserrange.IeRange'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.RangeEndpoint', 'goog.dom.TagName', 'goog.dom.browserrange.AbstractRange', 'goog.dom.safe', 'goog.html.uncheckedconversions', 'goog.log', 'goog.string'], {});
goog.addDependency('dom/browserrange/operarange.js', ['goog.dom.browserrange.OperaRange'], ['goog.dom.browserrange.W3cRange'], {});
goog.addDependency('dom/browserrange/w3crange.js', ['goog.dom.browserrange.W3cRange'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.RangeEndpoint', 'goog.dom.TagName', 'goog.dom.browserrange.AbstractRange', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('dom/browserrange/webkitrange.js', ['goog.dom.browserrange.WebKitRange'], ['goog.dom.RangeEndpoint', 'goog.dom.browserrange.W3cRange', 'goog.userAgent'], {});
goog.addDependency('dom/bufferedviewportsizemonitor.js', ['goog.dom.BufferedViewportSizeMonitor'], ['goog.asserts', 'goog.async.Delay', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType'], {});
goog.addDependency('dom/bufferedviewportsizemonitor_test.js', ['goog.dom.BufferedViewportSizeMonitorTest'], ['goog.dom.BufferedViewportSizeMonitor', 'goog.dom.ViewportSizeMonitor', 'goog.events', 'goog.events.EventType', 'goog.math.Size', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/classes.js', ['goog.dom.classes'], ['goog.array'], {});
goog.addDependency('dom/classes_test.js', ['goog.dom.classes_test'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classes', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/classlist.js', ['goog.dom.classlist'], ['goog.array'], {});
goog.addDependency('dom/classlist_test.js', ['goog.dom.classlist_test'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/controlrange.js', ['goog.dom.ControlRange', 'goog.dom.ControlRangeIterator'], ['goog.array', 'goog.dom', 'goog.dom.AbstractMultiRange', 'goog.dom.AbstractRange', 'goog.dom.RangeIterator', 'goog.dom.RangeType', 'goog.dom.SavedRange', 'goog.dom.TagWalkType', 'goog.dom.TextRange', 'goog.iter.StopIteration', 'goog.userAgent'], {});
goog.addDependency('dom/controlrange_test.js', ['goog.dom.ControlRangeTest'], ['goog.dom', 'goog.dom.ControlRange', 'goog.dom.RangeType', 'goog.dom.TagName', 'goog.dom.TextRange', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/dataset.js', ['goog.dom.dataset'], ['goog.labs.userAgent.browser', 'goog.string', 'goog.userAgent.product'], {});
goog.addDependency('dom/dataset_test.js', ['goog.dom.datasetTest'], ['goog.dom', 'goog.dom.dataset', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/dom.js', ['goog.dom', 'goog.dom.Appendable', 'goog.dom.DomHelper'], ['goog.array', 'goog.asserts', 'goog.dom.BrowserFeature', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.uncheckedconversions', 'goog.math.Coordinate', 'goog.math.Size', 'goog.object', 'goog.string', 'goog.string.Unicode', 'goog.userAgent'], {});
goog.addDependency('dom/dom_compile_test.js', ['goog.dom.DomCompileTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/dom_test.js', ['goog.dom.dom_test'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.BrowserFeature', 'goog.dom.DomHelper', 'goog.dom.InputType', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.functions', 'goog.html.SafeUrl', 'goog.html.testing', 'goog.object', 'goog.string.Const', 'goog.string.Unicode', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/fontsizemonitor.js', ['goog.dom.FontSizeMonitor', 'goog.dom.FontSizeMonitor.EventType'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.userAgent'], {});
goog.addDependency('dom/fontsizemonitor_test.js', ['goog.dom.FontSizeMonitorTest'], ['goog.dom', 'goog.dom.FontSizeMonitor', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/forms.js', ['goog.dom.forms'], ['goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.structs.Map', 'goog.window'], {});
goog.addDependency('dom/forms_test.js', ['goog.dom.formsTest'], ['goog.dom', 'goog.dom.forms', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/fullscreen.js', ['goog.dom.fullscreen', 'goog.dom.fullscreen.EventType'], ['goog.dom'], {});
goog.addDependency('dom/fullscreen_test.js', ['goog.dom.fullscreen_test'], ['goog.dom.DomHelper', 'goog.dom.fullscreen', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/htmlelement.js', ['goog.dom.HtmlElement'], [], {});
goog.addDependency('dom/iframe.js', ['goog.dom.iframe'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyle', 'goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('dom/iframe_test.js', ['goog.dom.iframeTest'], ['goog.dom', 'goog.dom.iframe', 'goog.html.SafeHtml', 'goog.html.SafeStyle', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/inputtype.js', ['goog.dom.InputType'], [], {});
goog.addDependency('dom/inputtype_test.js', ['goog.dom.InputTypeTest'], ['goog.dom.InputType', 'goog.object', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/iter.js', ['goog.dom.iter.AncestorIterator', 'goog.dom.iter.ChildIterator', 'goog.dom.iter.SiblingIterator'], ['goog.iter.Iterator', 'goog.iter.StopIteration'], {});
goog.addDependency('dom/iter_test.js', ['goog.dom.iterTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.iter.AncestorIterator', 'goog.dom.iter.ChildIterator', 'goog.dom.iter.SiblingIterator', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/multirange.js', ['goog.dom.MultiRange', 'goog.dom.MultiRangeIterator'], ['goog.array', 'goog.dom', 'goog.dom.AbstractMultiRange', 'goog.dom.AbstractRange', 'goog.dom.RangeIterator', 'goog.dom.RangeType', 'goog.dom.SavedRange', 'goog.dom.TextRange', 'goog.iter', 'goog.iter.StopIteration', 'goog.log'], {});
goog.addDependency('dom/multirange_test.js', ['goog.dom.MultiRangeTest'], ['goog.dom', 'goog.dom.MultiRange', 'goog.dom.Range', 'goog.iter', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/nodeiterator.js', ['goog.dom.NodeIterator'], ['goog.dom.TagIterator'], {});
goog.addDependency('dom/nodeiterator_test.js', ['goog.dom.NodeIteratorTest'], ['goog.dom', 'goog.dom.NodeIterator', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/nodeoffset.js', ['goog.dom.NodeOffset'], ['goog.Disposable', 'goog.dom.TagName'], {});
goog.addDependency('dom/nodeoffset_test.js', ['goog.dom.NodeOffsetTest'], ['goog.dom', 'goog.dom.NodeOffset', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/nodetype.js', ['goog.dom.NodeType'], [], {});
goog.addDependency('dom/pattern/abstractpattern.js', ['goog.dom.pattern.AbstractPattern'], ['goog.dom.TagWalkType', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/allchildren.js', ['goog.dom.pattern.AllChildren'], ['goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/callback/callback.js', ['goog.dom.pattern.callback'], ['goog.dom', 'goog.dom.TagWalkType', 'goog.iter'], {});
goog.addDependency('dom/pattern/callback/counter.js', ['goog.dom.pattern.callback.Counter'], [], {});
goog.addDependency('dom/pattern/callback/test.js', ['goog.dom.pattern.callback.Test'], ['goog.iter.StopIteration'], {});
goog.addDependency('dom/pattern/childmatches.js', ['goog.dom.pattern.ChildMatches'], ['goog.dom.pattern.AllChildren', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/endtag.js', ['goog.dom.pattern.EndTag'], ['goog.dom.TagWalkType', 'goog.dom.pattern.Tag'], {});
goog.addDependency('dom/pattern/fulltag.js', ['goog.dom.pattern.FullTag'], ['goog.dom.pattern.MatchType', 'goog.dom.pattern.StartTag', 'goog.dom.pattern.Tag'], {});
goog.addDependency('dom/pattern/matcher.js', ['goog.dom.pattern.Matcher'], ['goog.dom.TagIterator', 'goog.dom.pattern.MatchType', 'goog.iter'], {});
goog.addDependency('dom/pattern/matcher_test.js', ['goog.dom.pattern.matcherTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.pattern.EndTag', 'goog.dom.pattern.FullTag', 'goog.dom.pattern.Matcher', 'goog.dom.pattern.Repeat', 'goog.dom.pattern.Sequence', 'goog.dom.pattern.StartTag', 'goog.dom.pattern.callback.Counter', 'goog.dom.pattern.callback.Test', 'goog.iter.StopIteration', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/pattern/nodetype.js', ['goog.dom.pattern.NodeType'], ['goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/pattern.js', ['goog.dom.pattern', 'goog.dom.pattern.MatchType'], [], {});
goog.addDependency('dom/pattern/pattern_test.js', ['goog.dom.patternTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagWalkType', 'goog.dom.pattern.AllChildren', 'goog.dom.pattern.ChildMatches', 'goog.dom.pattern.EndTag', 'goog.dom.pattern.FullTag', 'goog.dom.pattern.MatchType', 'goog.dom.pattern.NodeType', 'goog.dom.pattern.Repeat', 'goog.dom.pattern.Sequence', 'goog.dom.pattern.StartTag', 'goog.dom.pattern.Text', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/pattern/repeat.js', ['goog.dom.pattern.Repeat'], ['goog.dom.NodeType', 'goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/sequence.js', ['goog.dom.pattern.Sequence'], ['goog.dom.NodeType', 'goog.dom.pattern', 'goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/pattern/starttag.js', ['goog.dom.pattern.StartTag'], ['goog.dom.TagWalkType', 'goog.dom.pattern.Tag'], {});
goog.addDependency('dom/pattern/tag.js', ['goog.dom.pattern.Tag'], ['goog.dom.pattern', 'goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType', 'goog.object'], {});
goog.addDependency('dom/pattern/text.js', ['goog.dom.pattern.Text'], ['goog.dom.NodeType', 'goog.dom.pattern', 'goog.dom.pattern.AbstractPattern', 'goog.dom.pattern.MatchType'], {});
goog.addDependency('dom/range.js', ['goog.dom.Range'], ['goog.dom', 'goog.dom.AbstractRange', 'goog.dom.BrowserFeature', 'goog.dom.ControlRange', 'goog.dom.MultiRange', 'goog.dom.NodeType', 'goog.dom.TextRange'], {});
goog.addDependency('dom/range_test.js', ['goog.dom.RangeTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.RangeType', 'goog.dom.TagName', 'goog.dom.TextRange', 'goog.dom.browserrange', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/rangeendpoint.js', ['goog.dom.RangeEndpoint'], [], {});
goog.addDependency('dom/safe.js', ['goog.dom.safe', 'goog.dom.safe.InsertAdjacentHtmlPosition'], ['goog.asserts', 'goog.dom.asserts', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.uncheckedconversions', 'goog.string.Const', 'goog.string.internal'], {});
goog.addDependency('dom/safe_test.js', ['goog.dom.safeTest'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.dom.safe.InsertAdjacentHtmlPosition', 'goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.testing', 'goog.string', 'goog.string.Const', 'goog.testing', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/savedcaretrange.js', ['goog.dom.SavedCaretRange'], ['goog.array', 'goog.dom', 'goog.dom.SavedRange', 'goog.dom.TagName', 'goog.string'], {});
goog.addDependency('dom/savedcaretrange_test.js', ['goog.dom.SavedCaretRangeTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.SavedCaretRange', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/savedrange.js', ['goog.dom.SavedRange'], ['goog.Disposable', 'goog.log'], {});
goog.addDependency('dom/savedrange_test.js', ['goog.dom.SavedRangeTest'], ['goog.dom', 'goog.dom.Range', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/selection.js', ['goog.dom.selection'], ['goog.dom.InputType', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('dom/selection_test.js', ['goog.dom.selectionTest'], ['goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.selection', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/tagiterator.js', ['goog.dom.TagIterator', 'goog.dom.TagWalkType'], ['goog.dom', 'goog.dom.NodeType', 'goog.iter.Iterator', 'goog.iter.StopIteration'], {});
goog.addDependency('dom/tagiterator_test.js', ['goog.dom.TagIteratorTest'], ['goog.dom', 'goog.dom.TagIterator', 'goog.dom.TagName', 'goog.dom.TagWalkType', 'goog.iter', 'goog.iter.StopIteration', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/tagname.js', ['goog.dom.TagName'], ['goog.dom.HtmlElement'], {});
goog.addDependency('dom/tagname_test.js', ['goog.dom.TagNameTest'], ['goog.dom.TagName', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/tags.js', ['goog.dom.tags'], ['goog.object'], {});
goog.addDependency('dom/tags_test.js', ['goog.dom.tagsTest'], ['goog.dom.tags', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/textassert.js', ['goog.dom.textAssert'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName'], {});
goog.addDependency('dom/textassert_test.js', ['goog.dom.textassert_test'], ['goog.dom.textAssert', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/textrange.js', ['goog.dom.TextRange'], ['goog.array', 'goog.dom', 'goog.dom.AbstractRange', 'goog.dom.RangeType', 'goog.dom.SavedRange', 'goog.dom.TagName', 'goog.dom.TextRangeIterator', 'goog.dom.browserrange', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('dom/textrange_test.js', ['goog.dom.TextRangeTest'], ['goog.dom', 'goog.dom.ControlRange', 'goog.dom.Range', 'goog.dom.TextRange', 'goog.math.Coordinate', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/textrangeiterator.js', ['goog.dom.TextRangeIterator'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.RangeIterator', 'goog.dom.TagName', 'goog.iter.StopIteration'], {});
goog.addDependency('dom/textrangeiterator_test.js', ['goog.dom.TextRangeIteratorTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.TextRangeIterator', 'goog.iter.StopIteration', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/uri.js', ['goog.dom.uri'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.uncheckedconversions', 'goog.string.Const'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/uri_test.js', ['goog.dom.uriTest'], ['goog.dom.uri', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/vendor.js', ['goog.dom.vendor'], ['goog.string', 'goog.userAgent'], {});
goog.addDependency('dom/vendor_test.js', ['goog.dom.vendorTest'], ['goog.array', 'goog.dom.vendor', 'goog.labs.userAgent.util', 'goog.testing.MockUserAgent', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/viewportsizemonitor.js', ['goog.dom.ViewportSizeMonitor'], ['goog.dom', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.math.Size'], {});
goog.addDependency('dom/viewportsizemonitor_test.js', ['goog.dom.ViewportSizeMonitorTest'], ['goog.dom.ViewportSizeMonitor', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.math.Size', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('dom/xml.js', ['goog.dom.xml'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.safe', 'goog.html.legacyconversions', 'goog.userAgent'], {});
goog.addDependency('dom/xml_test.js', ['goog.dom.xmlTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.xml', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/browserfeature.js', ['goog.editor.BrowserFeature'], ['goog.editor.defines', 'goog.labs.userAgent.browser', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('editor/browserfeature_test.js', ['goog.editor.BrowserFeatureTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/clicktoeditwrapper.js', ['goog.editor.ClickToEditWrapper'], ['goog.Disposable', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.range', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventType'], {});
goog.addDependency('editor/clicktoeditwrapper_test.js', ['goog.editor.ClickToEditWrapperTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.ClickToEditWrapper', 'goog.editor.SeamlessField', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/command.js', ['goog.editor.Command'], [], {});
goog.addDependency('editor/contenteditablefield.js', ['goog.editor.ContentEditableField'], ['goog.asserts', 'goog.editor.Field', 'goog.log'], {});
goog.addDependency('editor/contenteditablefield_test.js', ['goog.editor.ContentEditableFieldTest'], ['goog.dom', 'goog.editor.ContentEditableField', 'goog.html.SafeHtml', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/defines.js', ['goog.editor.defines'], [], {});
goog.addDependency('editor/field.js', ['goog.editor.Field', 'goog.editor.Field.EventType'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.array', 'goog.asserts', 'goog.async.Delay', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.safe', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.PluginImpl', 'goog.editor.icontent', 'goog.editor.icontent.FieldFormatInfo', 'goog.editor.icontent.FieldStyleInfo', 'goog.editor.node', 'goog.editor.range', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.log', 'goog.log.Level', 'goog.string', 'goog.string.Unicode', 'goog.style', 'goog.userAgent', 'goog.userAgent.product'], {});
goog.addDependency('editor/field_test.js', ['goog.editor.field_test'], ['goog.array', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.range', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.functions', 'goog.html.SafeHtml', 'goog.testing.LooseMock', 'goog.testing.MockClock', 'goog.testing.dom', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/focus.js', ['goog.editor.focus'], ['goog.dom.selection'], {});
goog.addDependency('editor/focus_test.js', ['goog.editor.focusTest'], ['goog.dom.selection', 'goog.editor.BrowserFeature', 'goog.editor.focus', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/icontent.js', ['goog.editor.icontent', 'goog.editor.icontent.FieldFormatInfo', 'goog.editor.icontent.FieldStyleInfo'], ['goog.dom', 'goog.editor.BrowserFeature', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('editor/icontent_test.js', ['goog.editor.icontentTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.icontent', 'goog.editor.icontent.FieldFormatInfo', 'goog.editor.icontent.FieldStyleInfo', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/link.js', ['goog.editor.Link'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.node', 'goog.editor.range', 'goog.string', 'goog.string.Unicode', 'goog.uri.utils', 'goog.uri.utils.ComponentIndex'], {});
goog.addDependency('editor/link_test.js', ['goog.editor.LinkTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Link', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/node.js', ['goog.editor.node'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.iter.ChildIterator', 'goog.dom.iter.SiblingIterator', 'goog.iter', 'goog.object', 'goog.string', 'goog.string.Unicode', 'goog.userAgent'], {});
goog.addDependency('editor/node_test.js', ['goog.editor.nodeTest'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.editor.node', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugin.js', ['goog.editor.Plugin'], ['goog.editor.Field', 'goog.editor.PluginImpl'], {});
goog.addDependency('editor/plugin_impl.js', ['goog.editor.PluginImpl'], ['goog.events.EventTarget', 'goog.functions', 'goog.log', 'goog.object', 'goog.reflect', 'goog.userAgent'], {});
goog.addDependency('editor/plugin_test.js', ['goog.editor.PluginTest'], ['goog.editor.Field', 'goog.editor.Plugin', 'goog.functions', 'goog.testing.StrictMock', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/abstractbubbleplugin.js', ['goog.editor.plugins.AbstractBubblePlugin'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.editor.Plugin', 'goog.editor.style', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.actionEventWrapper', 'goog.functions', 'goog.string.Unicode', 'goog.ui.Component', 'goog.ui.editor.Bubble', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/abstractbubbleplugin_test.js', ['goog.editor.plugins.AbstractBubblePluginTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.plugins.AbstractBubblePlugin', 'goog.events.BrowserEvent', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.functions', 'goog.style', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.editor.Bubble', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/abstractdialogplugin.js', ['goog.editor.plugins.AbstractDialogPlugin', 'goog.editor.plugins.AbstractDialogPlugin.EventType'], ['goog.dom', 'goog.dom.Range', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.range', 'goog.events', 'goog.ui.editor.AbstractDialog'], {});
goog.addDependency('editor/plugins/abstractdialogplugin_test.js', ['goog.editor.plugins.AbstractDialogPluginTest'], ['goog.dom', 'goog.dom.SavedRange', 'goog.dom.TagName', 'goog.editor.Field', 'goog.editor.plugins.AbstractDialogPlugin', 'goog.events.Event', 'goog.events.EventHandler', 'goog.functions', 'goog.html.SafeHtml', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.testSuite', 'goog.ui.editor.AbstractDialog', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/abstracttabhandler.js', ['goog.editor.plugins.AbstractTabHandler'], ['goog.editor.Plugin', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/abstracttabhandler_test.js', ['goog.editor.plugins.AbstractTabHandlerTest'], ['goog.editor.Field', 'goog.editor.plugins.AbstractTabHandler', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.testing.StrictMock', 'goog.testing.editor.FieldMock', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/basictextformatter.js', ['goog.editor.plugins.BasicTextFormatter', 'goog.editor.plugins.BasicTextFormatter.COMMAND'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Link', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.range', 'goog.editor.style', 'goog.iter', 'goog.iter.StopIteration', 'goog.log', 'goog.object', 'goog.string', 'goog.string.Unicode', 'goog.style', 'goog.ui.editor.messages', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/basictextformatter_test.js', ['goog.editor.plugins.BasicTextFormatterTest'], ['goog.array', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.plugins.BasicTextFormatter', 'goog.html.SafeHtml', 'goog.object', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.LooseMock', 'goog.testing.PropertyReplacer', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/blockquote.js', ['goog.editor.plugins.Blockquote'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Plugin', 'goog.editor.node', 'goog.functions', 'goog.log'], {});
goog.addDependency('editor/plugins/blockquote_test.js', ['goog.editor.plugins.BlockquoteTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.plugins.Blockquote', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/emoticons.js', ['goog.editor.plugins.Emoticons'], ['goog.dom.TagName', 'goog.editor.Plugin', 'goog.editor.range', 'goog.functions', 'goog.ui.emoji.Emoji', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/emoticons_test.js', ['goog.editor.plugins.EmoticonsTest'], ['goog.Uri', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.editor.Field', 'goog.editor.plugins.Emoticons', 'goog.testing.testSuite', 'goog.ui.emoji.Emoji', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/enterhandler.js', ['goog.editor.plugins.EnterHandler'], ['goog.dom', 'goog.dom.NodeOffset', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.plugins.Blockquote', 'goog.editor.range', 'goog.editor.style', 'goog.events.KeyCodes', 'goog.functions', 'goog.object', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/enterhandler_test.js', ['goog.editor.plugins.EnterHandlerTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.plugins.Blockquote', 'goog.editor.plugins.EnterHandler', 'goog.editor.range', 'goog.events', 'goog.events.KeyCodes', 'goog.html.testing', 'goog.testing.ExpectedFailures', 'goog.testing.MockClock', 'goog.testing.dom', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/firststrong.js', ['goog.editor.plugins.FirstStrong'], ['goog.dom.NodeType', 'goog.dom.TagIterator', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.range', 'goog.i18n.bidi', 'goog.i18n.uChar', 'goog.iter', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/firststrong_test.js', ['goog.editor.plugins.FirstStrongTest'], ['goog.dom.Range', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.plugins.FirstStrong', 'goog.editor.range', 'goog.events.KeyCodes', 'goog.html.testing', 'goog.testing.MockClock', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/headerformatter.js', ['goog.editor.plugins.HeaderFormatter'], ['goog.editor.Command', 'goog.editor.Plugin', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/headerformatter_test.js', ['goog.editor.plugins.HeaderFormatterTest'], ['goog.dom', 'goog.editor.Command', 'goog.editor.plugins.BasicTextFormatter', 'goog.editor.plugins.HeaderFormatter', 'goog.events.BrowserEvent', 'goog.testing.LooseMock', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/linkbubble.js', ['goog.editor.plugins.LinkBubble', 'goog.editor.plugins.LinkBubble.Action'], ['goog.array', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.Link', 'goog.editor.plugins.AbstractBubblePlugin', 'goog.functions', 'goog.string', 'goog.style', 'goog.ui.editor.messages', 'goog.uri.utils', 'goog.window'], {});
goog.addDependency('editor/plugins/linkbubble_test.js', ['goog.editor.plugins.LinkBubbleTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.Link', 'goog.editor.plugins.LinkBubble', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.string', 'goog.style', 'goog.testing.FunctionMock', 'goog.testing.PropertyReplacer', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/linkdialogplugin.js', ['goog.editor.plugins.LinkDialogPlugin'], ['goog.array', 'goog.dom', 'goog.editor.Command', 'goog.editor.plugins.AbstractDialogPlugin', 'goog.events.EventHandler', 'goog.functions', 'goog.ui.editor.AbstractDialog', 'goog.ui.editor.LinkDialog', 'goog.uri.utils'], {});
goog.addDependency('editor/plugins/linkdialogplugin_test.js', ['goog.ui.editor.plugins.LinkDialogTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Link', 'goog.editor.plugins.LinkDialogPlugin', 'goog.html.SafeHtml', 'goog.string', 'goog.string.Unicode', 'goog.testing.MockControl', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.editor.dom', 'goog.testing.events', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.ui.editor.AbstractDialog', 'goog.ui.editor.LinkDialog', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/linkshortcutplugin.js', ['goog.editor.plugins.LinkShortcutPlugin'], ['goog.editor.Command', 'goog.editor.Plugin'], {});
goog.addDependency('editor/plugins/linkshortcutplugin_test.js', ['goog.editor.plugins.LinkShortcutPluginTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.Field', 'goog.editor.plugins.BasicTextFormatter', 'goog.editor.plugins.LinkBubble', 'goog.editor.plugins.LinkShortcutPlugin', 'goog.events.KeyCodes', 'goog.testing.PropertyReplacer', 'goog.testing.dom', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/listtabhandler.js', ['goog.editor.plugins.ListTabHandler'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.plugins.AbstractTabHandler', 'goog.iter'], {});
goog.addDependency('editor/plugins/listtabhandler_test.js', ['goog.editor.plugins.ListTabHandlerTest'], ['goog.dom', 'goog.editor.Command', 'goog.editor.plugins.ListTabHandler', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.functions', 'goog.testing.StrictMock', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/loremipsum.js', ['goog.editor.plugins.LoremIpsum'], ['goog.asserts', 'goog.dom', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.node', 'goog.functions', 'goog.html.SafeHtml', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/loremipsum_test.js', ['goog.editor.plugins.LoremIpsumTest'], ['goog.dom', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.plugins.LoremIpsum', 'goog.html.SafeHtml', 'goog.string.Unicode', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/removeformatting.js', ['goog.editor.plugins.RemoveFormatting'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.range', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/removeformatting_test.js', ['goog.editor.plugins.RemoveFormattingTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.plugins.RemoveFormatting', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.dom', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/spacestabhandler.js', ['goog.editor.plugins.SpacesTabHandler'], ['goog.dom.TagName', 'goog.editor.plugins.AbstractTabHandler', 'goog.editor.range'], {});
goog.addDependency('editor/plugins/spacestabhandler_test.js', ['goog.editor.plugins.SpacesTabHandlerTest'], ['goog.dom', 'goog.dom.Range', 'goog.editor.plugins.SpacesTabHandler', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.functions', 'goog.testing.StrictMock', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/tableeditor.js', ['goog.editor.plugins.TableEditor'], ['goog.array', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Plugin', 'goog.editor.Table', 'goog.editor.node', 'goog.editor.range', 'goog.object', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/tableeditor_test.js', ['goog.editor.plugins.TableEditorTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.plugins.TableEditor', 'goog.object', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.TestCase', 'goog.testing.editor.FieldMock', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/tagonenterhandler.js', ['goog.editor.plugins.TagOnEnterHandler'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.Command', 'goog.editor.node', 'goog.editor.plugins.EnterHandler', 'goog.editor.range', 'goog.editor.style', 'goog.events.KeyCodes', 'goog.functions', 'goog.string.Unicode', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('editor/plugins/tagonenterhandler_test.js', ['goog.editor.plugins.TagOnEnterHandlerTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.plugins.TagOnEnterHandler', 'goog.events.KeyCodes', 'goog.html.SafeHtml', 'goog.string.Unicode', 'goog.testing.dom', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/undoredo.js', ['goog.editor.plugins.UndoRedo'], ['goog.dom', 'goog.dom.NodeOffset', 'goog.dom.Range', 'goog.editor.BrowserFeature', 'goog.editor.Command', 'goog.editor.Field', 'goog.editor.Plugin', 'goog.editor.node', 'goog.editor.plugins.UndoRedoManager', 'goog.editor.plugins.UndoRedoState', 'goog.events', 'goog.events.EventHandler', 'goog.log', 'goog.object'], {});
goog.addDependency('editor/plugins/undoredo_test.js', ['goog.editor.plugins.UndoRedoTest'], ['goog.array', 'goog.dom', 'goog.dom.browserrange', 'goog.editor.Field', 'goog.editor.plugins.LoremIpsum', 'goog.editor.plugins.UndoRedo', 'goog.events', 'goog.functions', 'goog.html.SafeHtml', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/undoredomanager.js', ['goog.editor.plugins.UndoRedoManager', 'goog.editor.plugins.UndoRedoManager.EventType'], ['goog.editor.plugins.UndoRedoState', 'goog.events', 'goog.events.EventTarget'], {});
goog.addDependency('editor/plugins/undoredomanager_test.js', ['goog.editor.plugins.UndoRedoManagerTest'], ['goog.editor.plugins.UndoRedoManager', 'goog.editor.plugins.UndoRedoState', 'goog.events', 'goog.testing.StrictMock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/plugins/undoredostate.js', ['goog.editor.plugins.UndoRedoState'], ['goog.events.EventTarget'], {});
goog.addDependency('editor/plugins/undoredostate_test.js', ['goog.editor.plugins.UndoRedoStateTest'], ['goog.editor.plugins.UndoRedoState', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/range.js', ['goog.editor.range', 'goog.editor.range.Point'], ['goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.dom.RangeEndpoint', 'goog.dom.SavedCaretRange', 'goog.editor.node', 'goog.editor.style', 'goog.iter', 'goog.userAgent'], {});
goog.addDependency('editor/range_test.js', ['goog.editor.rangeTest'], ['goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.range', 'goog.editor.range.Point', 'goog.string', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/seamlessfield.js', ['goog.editor.SeamlessField'], ['goog.cssom.iframe.style', 'goog.dom', 'goog.dom.Range', 'goog.dom.TagName', 'goog.dom.safe', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.icontent', 'goog.editor.icontent.FieldFormatInfo', 'goog.editor.icontent.FieldStyleInfo', 'goog.editor.node', 'goog.events', 'goog.events.EventType', 'goog.html.SafeHtml', 'goog.log', 'goog.style'], {});
goog.addDependency('editor/seamlessfield_test.js', ['goog.editor.seamlessfield_test'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.Range', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Field', 'goog.editor.SeamlessField', 'goog.events', 'goog.functions', 'goog.html.SafeHtml', 'goog.style', 'goog.testing.MockClock', 'goog.testing.MockRange', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/style.js', ['goog.editor.style'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.object', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('editor/style_test.js', ['goog.editor.styleTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.style', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.style', 'goog.testing.LooseMock', 'goog.testing.mockmatchers', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('editor/table.js', ['goog.editor.Table', 'goog.editor.TableCell', 'goog.editor.TableRow'], ['goog.asserts', 'goog.dom', 'goog.dom.DomHelper', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.log', 'goog.string.Unicode', 'goog.style'], {});
goog.addDependency('editor/table_test.js', ['goog.editor.TableTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.Table', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/actioneventwrapper.js', ['goog.events.actionEventWrapper'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.dom', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.EventWrapper', 'goog.events.KeyCodes'], {});
goog.addDependency('events/actioneventwrapper_test.js', ['goog.events.actionEventWrapperTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.events', 'goog.events.EventHandler', 'goog.events.KeyCodes', 'goog.events.actionEventWrapper', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/actionhandler.js', ['goog.events.ActionEvent', 'goog.events.ActionHandler', 'goog.events.ActionHandler.EventType', 'goog.events.BeforeActionEvent'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('events/actionhandler_test.js', ['goog.events.ActionHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.ActionHandler', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/browserevent.js', ['goog.events.BrowserEvent', 'goog.events.BrowserEvent.MouseButton', 'goog.events.BrowserEvent.PointerType'], ['goog.debug', 'goog.events.BrowserFeature', 'goog.events.Event', 'goog.events.EventType', 'goog.reflect', 'goog.userAgent'], {});
goog.addDependency('events/browserevent_test.js', ['goog.events.BrowserEventTest'], ['goog.events.BrowserEvent', 'goog.events.BrowserFeature', 'goog.math.Coordinate', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/browserfeature.js', ['goog.events.BrowserFeature'], ['goog.userAgent'], {});
goog.addDependency('events/event.js', ['goog.events.Event', 'goog.events.EventLike'], ['goog.Disposable', 'goog.events.EventId'], {});
goog.addDependency('events/event_test.js', ['goog.events.EventTest'], ['goog.events.Event', 'goog.events.EventId', 'goog.events.EventTarget', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventhandler.js', ['goog.events.EventHandler'], ['goog.Disposable', 'goog.events', 'goog.object'], {});
goog.addDependency('events/eventhandler_test.js', ['goog.events.EventHandlerTest'], ['goog.events', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventid.js', ['goog.events.EventId'], [], {});
goog.addDependency('events/events.js', ['goog.events', 'goog.events.CaptureSimulationMode', 'goog.events.Key', 'goog.events.ListenableType'], ['goog.asserts', 'goog.debug.entryPointRegistry', 'goog.events.BrowserEvent', 'goog.events.BrowserFeature', 'goog.events.Listenable', 'goog.events.ListenerMap'], {});
goog.addDependency('events/events_test.js', ['goog.eventsTest'], ['goog.asserts.AssertionError', 'goog.debug.EntryPointMonitor', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.BrowserFeature', 'goog.events.CaptureSimulationMode', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.Listener', 'goog.functions', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtarget.js', ['goog.events.EventTarget'], ['goog.Disposable', 'goog.asserts', 'goog.events', 'goog.events.Event', 'goog.events.Listenable', 'goog.events.ListenerMap', 'goog.object'], {});
goog.addDependency('events/eventtarget_test.js', ['goog.events.EventTargetTest'], ['goog.events.EventTarget', 'goog.events.Listenable', 'goog.events.eventTargetTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtarget_via_googevents_test.js', ['goog.events.EventTargetGoogEventsTest'], ['goog.events', 'goog.events.EventTarget', 'goog.events.eventTargetTester', 'goog.testing', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtarget_via_w3cinterface_test.js', ['goog.events.EventTargetW3CTest'], ['goog.events.EventTarget', 'goog.events.eventTargetTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtargettester.js', ['goog.events.eventTargetTester'], ['goog.array', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.Listenable', 'goog.testing.asserts', 'goog.testing.recordFunction'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventtype.js', ['goog.events.EventType', 'goog.events.MouseAsMouseEventType', 'goog.events.MouseEvents', 'goog.events.PointerAsMouseEventType', 'goog.events.PointerAsTouchEventType', 'goog.events.PointerFallbackEventType', 'goog.events.PointerTouchFallbackEventType'], ['goog.events.BrowserFeature', 'goog.userAgent'], {});
goog.addDependency('events/eventtype_test.js', ['goog.events.EventTypeTest'], ['goog.events.BrowserFeature', 'goog.events.EventType', 'goog.events.PointerFallbackEventType', 'goog.events.PointerTouchFallbackEventType', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/eventwrapper.js', ['goog.events.EventWrapper'], [], {});
goog.addDependency('events/filedrophandler.js', ['goog.events.FileDropHandler', 'goog.events.FileDropHandler.EventType'], ['goog.array', 'goog.dom', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.log', 'goog.log.Level'], {});
goog.addDependency('events/filedrophandler_test.js', ['goog.events.FileDropHandlerTest'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.FileDropHandler', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/focushandler.js', ['goog.events.FocusHandler', 'goog.events.FocusHandler.EventType'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.userAgent'], {});
goog.addDependency('events/imehandler.js', ['goog.events.ImeHandler', 'goog.events.ImeHandler.Event', 'goog.events.ImeHandler.EventType'], ['goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('events/imehandler_test.js', ['goog.events.ImeHandlerTest'], ['goog.array', 'goog.dom', 'goog.events', 'goog.events.ImeHandler', 'goog.events.KeyCodes', 'goog.object', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/inputhandler.js', ['goog.events.InputHandler', 'goog.events.InputHandler.EventType'], ['goog.Timer', 'goog.dom.TagName', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('events/inputhandler_test.js', ['goog.events.InputHandlerTest'], ['goog.dom', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/keycodes.js', ['goog.events.KeyCodes'], ['goog.userAgent'], {});
goog.addDependency('events/keycodes_test.js', ['goog.events.KeyCodesTest'], ['goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.object', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/keyhandler.js', ['goog.events.KeyEvent', 'goog.events.KeyHandler', 'goog.events.KeyHandler.EventType'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.userAgent'], {});
goog.addDependency('events/keyhandler_test.js', ['goog.events.KeyEventTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/keynames.js', ['goog.events.KeyNames'], [], {});
goog.addDependency('events/keys.js', ['goog.events.Keys'], [], {'lang': 'es5'});
goog.addDependency('events/listenable.js', ['goog.events.Listenable', 'goog.events.ListenableKey'], ['goog.events.EventId'], {});
goog.addDependency('events/listenable_test.js', ['goog.events.ListenableTest'], ['goog.events.Listenable', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/listener.js', ['goog.events.Listener'], ['goog.events.ListenableKey'], {});
goog.addDependency('events/listenermap.js', ['goog.events.ListenerMap'], ['goog.array', 'goog.events.Listener', 'goog.object'], {});
goog.addDependency('events/listenermap_test.js', ['goog.events.ListenerMapTest'], ['goog.dispose', 'goog.events', 'goog.events.EventId', 'goog.events.EventTarget', 'goog.events.ListenerMap', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/mousewheelhandler.js', ['goog.events.MouseWheelEvent', 'goog.events.MouseWheelHandler', 'goog.events.MouseWheelHandler.EventType'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.math', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('events/mousewheelhandler_test.js', ['goog.events.MouseWheelHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.MouseWheelEvent', 'goog.events.MouseWheelHandler', 'goog.functions', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/onlinehandler.js', ['goog.events.OnlineHandler', 'goog.events.OnlineHandler.EventType'], ['goog.Timer', 'goog.events.BrowserFeature', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.net.NetworkStatusMonitor'], {});
goog.addDependency('events/onlinelistener_test.js', ['goog.events.OnlineHandlerTest'], ['goog.events', 'goog.events.BrowserFeature', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.OnlineHandler', 'goog.net.NetworkStatusMonitor', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/pastehandler.js', ['goog.events.PasteHandler', 'goog.events.PasteHandler.EventType', 'goog.events.PasteHandler.State'], ['goog.Timer', 'goog.async.ConditionalDelay', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.log', 'goog.userAgent'], {});
goog.addDependency('events/pastehandler_test.js', ['goog.events.PasteHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.PasteHandler', 'goog.testing.MockClock', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('events/wheelevent.js', ['goog.events.WheelEvent'], ['goog.asserts', 'goog.events.BrowserEvent'], {});
goog.addDependency('events/wheelhandler.js', ['goog.events.WheelHandler'], ['goog.dom', 'goog.events', 'goog.events.EventTarget', 'goog.events.WheelEvent', 'goog.style', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('events/wheelhandler_test.js', ['goog.events.WheelHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.WheelEvent', 'goog.events.WheelHandler', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/emailaddress.js', ['goog.format.EmailAddress'], ['goog.string'], {});
goog.addDependency('format/emailaddress_test.js', ['goog.format.EmailAddressTest'], ['goog.array', 'goog.format.EmailAddress', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/format.js', ['goog.format'], ['goog.i18n.GraphemeBreak', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('format/format_test.js', ['goog.formatTest'], ['goog.dom', 'goog.dom.TagName', 'goog.format', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/htmlprettyprinter.js', ['goog.format.HtmlPrettyPrinter', 'goog.format.HtmlPrettyPrinter.Buffer'], ['goog.dom.TagName', 'goog.object', 'goog.string.StringBuffer'], {});
goog.addDependency('format/htmlprettyprinter_test.js', ['goog.format.HtmlPrettyPrinterTest'], ['goog.format.HtmlPrettyPrinter', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/internationalizedemailaddress.js', ['goog.format.InternationalizedEmailAddress'], ['goog.format.EmailAddress', 'goog.string'], {});
goog.addDependency('format/internationalizedemailaddress_test.js', ['goog.format.InternationalizedEmailAddressTest'], ['goog.array', 'goog.format.InternationalizedEmailAddress', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('format/jsonprettyprinter.js', ['goog.format.JsonPrettyPrinter', 'goog.format.JsonPrettyPrinter.SafeHtmlDelimiters', 'goog.format.JsonPrettyPrinter.TextDelimiters'], ['goog.html.SafeHtml', 'goog.json', 'goog.json.Serializer', 'goog.string', 'goog.string.format'], {});
goog.addDependency('format/jsonprettyprinter_test.js', ['goog.format.JsonPrettyPrinterTest'], ['goog.format.JsonPrettyPrinter', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fs/entry.js', ['goog.fs.DirectoryEntry', 'goog.fs.DirectoryEntry.Behavior', 'goog.fs.Entry', 'goog.fs.FileEntry'], [], {});
goog.addDependency('fs/entryimpl.js', ['goog.fs.DirectoryEntryImpl', 'goog.fs.EntryImpl', 'goog.fs.FileEntryImpl'], ['goog.array', 'goog.async.Deferred', 'goog.fs.DirectoryEntry', 'goog.fs.Entry', 'goog.fs.Error', 'goog.fs.FileEntry', 'goog.fs.FileWriter', 'goog.functions', 'goog.string'], {});
goog.addDependency('fs/error.js', ['goog.fs.DOMErrorLike', 'goog.fs.Error', 'goog.fs.Error.ErrorCode'], ['goog.asserts', 'goog.debug.Error', 'goog.object', 'goog.string'], {});
goog.addDependency('fs/filereader.js', ['goog.fs.FileReader', 'goog.fs.FileReader.EventType', 'goog.fs.FileReader.ReadyState'], ['goog.async.Deferred', 'goog.events.EventTarget', 'goog.fs.Error', 'goog.fs.ProgressEvent'], {});
goog.addDependency('fs/filesaver.js', ['goog.fs.FileSaver', 'goog.fs.FileSaver.EventType', 'goog.fs.FileSaver.ReadyState'], ['goog.events.EventTarget', 'goog.fs.Error', 'goog.fs.ProgressEvent'], {});
goog.addDependency('fs/filesystem.js', ['goog.fs.FileSystem'], [], {});
goog.addDependency('fs/filesystemimpl.js', ['goog.fs.FileSystemImpl'], ['goog.fs.DirectoryEntryImpl', 'goog.fs.FileSystem'], {});
goog.addDependency('fs/filewriter.js', ['goog.fs.FileWriter'], ['goog.fs.Error', 'goog.fs.FileSaver'], {});
goog.addDependency('fs/fs.js', ['goog.fs'], ['goog.array', 'goog.async.Deferred', 'goog.fs.Error', 'goog.fs.FileReader', 'goog.fs.FileSystemImpl', 'goog.fs.url', 'goog.userAgent'], {});
goog.addDependency('fs/fs_test.js', ['goog.fsTest'], ['goog.Promise', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.fs', 'goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.fs.FileReader', 'goog.fs.FileSaver', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fs/progressevent.js', ['goog.fs.ProgressEvent'], ['goog.events.Event'], {});
goog.addDependency('fs/url.js', ['goog.fs.url'], [], {'lang': 'es6'});
goog.addDependency('fs/url_test.js', ['goog.urlTest'], ['goog.fs.url', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('functions/functions.js', ['goog.functions'], [], {'lang': 'es6'});
goog.addDependency('functions/functions_test.js', ['goog.functionsTest'], ['goog.array', 'goog.functions', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/abstractdragdrop.js', ['goog.fx.AbstractDragDrop', 'goog.fx.AbstractDragDrop.EventType', 'goog.fx.DragDropEvent', 'goog.fx.DragDropItem'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.fx.Dragger', 'goog.math.Box', 'goog.math.Coordinate', 'goog.style'], {});
goog.addDependency('fx/abstractdragdrop_test.js', ['goog.fx.AbstractDragDropTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.functions', 'goog.fx.AbstractDragDrop', 'goog.fx.DragDropItem', 'goog.math.Box', 'goog.math.Coordinate', 'goog.style', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('fx/anim/anim.js', ['goog.fx.anim', 'goog.fx.anim.Animated'], ['goog.async.AnimationDelay', 'goog.async.Delay', 'goog.object'], {});
goog.addDependency('fx/anim/anim_test.js', ['goog.fx.animTest'], ['goog.async.AnimationDelay', 'goog.async.Delay', 'goog.events', 'goog.functions', 'goog.fx.Animation', 'goog.fx.anim', 'goog.object', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/animation.js', ['goog.fx.Animation', 'goog.fx.Animation.EventType', 'goog.fx.Animation.State', 'goog.fx.AnimationEvent'], ['goog.array', 'goog.asserts', 'goog.events.Event', 'goog.fx.Transition', 'goog.fx.TransitionBase', 'goog.fx.anim', 'goog.fx.anim.Animated'], {});
goog.addDependency('fx/animation_test.js', ['goog.fx.AnimationTest'], ['goog.events', 'goog.fx.Animation', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/animationqueue.js', ['goog.fx.AnimationParallelQueue', 'goog.fx.AnimationQueue', 'goog.fx.AnimationSerialQueue'], ['goog.array', 'goog.asserts', 'goog.events', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.fx.TransitionBase'], {});
goog.addDependency('fx/animationqueue_test.js', ['goog.fx.AnimationQueueTest'], ['goog.events', 'goog.fx.Animation', 'goog.fx.AnimationParallelQueue', 'goog.fx.AnimationSerialQueue', 'goog.fx.Transition', 'goog.fx.anim', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/css3/fx.js', ['goog.fx.css3'], ['goog.fx.css3.Transition'], {});
goog.addDependency('fx/css3/transition.js', ['goog.fx.css3.Transition'], ['goog.Timer', 'goog.asserts', 'goog.fx.TransitionBase', 'goog.style', 'goog.style.transition'], {});
goog.addDependency('fx/css3/transition_test.js', ['goog.fx.css3.TransitionTest'], ['goog.dispose', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.fx.Transition', 'goog.fx.css3.Transition', 'goog.style.transition', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/cssspriteanimation.js', ['goog.fx.CssSpriteAnimation'], ['goog.fx.Animation'], {});
goog.addDependency('fx/cssspriteanimation_test.js', ['goog.fx.CssSpriteAnimationTest'], ['goog.fx.CssSpriteAnimation', 'goog.math.Box', 'goog.math.Size', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/dom.js', ['goog.fx.dom', 'goog.fx.dom.BgColorTransform', 'goog.fx.dom.ColorTransform', 'goog.fx.dom.Fade', 'goog.fx.dom.FadeIn', 'goog.fx.dom.FadeInAndShow', 'goog.fx.dom.FadeOut', 'goog.fx.dom.FadeOutAndHide', 'goog.fx.dom.PredefinedEffect', 'goog.fx.dom.Resize', 'goog.fx.dom.ResizeHeight', 'goog.fx.dom.ResizeWidth', 'goog.fx.dom.Scroll', 'goog.fx.dom.Slide', 'goog.fx.dom.SlideFrom', 'goog.fx.dom.Swipe'], ['goog.color', 'goog.events', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.style', 'goog.style.bidi'], {});
goog.addDependency('fx/dragdrop.js', ['goog.fx.DragDrop'], ['goog.fx.AbstractDragDrop', 'goog.fx.DragDropItem'], {});
goog.addDependency('fx/dragdropgroup.js', ['goog.fx.DragDropGroup'], ['goog.dom', 'goog.fx.AbstractDragDrop', 'goog.fx.DragDropItem'], {});
goog.addDependency('fx/dragdropgroup_test.js', ['goog.fx.DragDropGroupTest'], ['goog.events', 'goog.fx.DragDropGroup', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/dragger.js', ['goog.fx.DragEvent', 'goog.fx.Dragger', 'goog.fx.Dragger.EventType'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.style', 'goog.style.bidi', 'goog.userAgent'], {});
goog.addDependency('fx/dragger_test.js', ['goog.fx.DraggerTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventType', 'goog.fx.Dragger', 'goog.math.Rect', 'goog.style.bidi', 'goog.testing.StrictMock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/draglistgroup.js', ['goog.fx.DragListDirection', 'goog.fx.DragListGroup', 'goog.fx.DragListGroup.EventType', 'goog.fx.DragListGroupEvent', 'goog.fx.DragListPermission'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventId', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.fx.Dragger', 'goog.math.Coordinate', 'goog.string', 'goog.style'], {});
goog.addDependency('fx/draglistgroup_test.js', ['goog.fx.DragListGroupTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.BrowserFeature', 'goog.events.Event', 'goog.events.EventType', 'goog.fx.DragEvent', 'goog.fx.DragListDirection', 'goog.fx.DragListGroup', 'goog.fx.DragListPermission', 'goog.fx.Dragger', 'goog.math.Coordinate', 'goog.object', 'goog.style', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/dragscrollsupport.js', ['goog.fx.DragScrollSupport'], ['goog.Disposable', 'goog.Timer', 'goog.dom', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.math.Coordinate', 'goog.style'], {});
goog.addDependency('fx/dragscrollsupport_test.js', ['goog.fx.DragScrollSupportTest'], ['goog.fx.DragScrollSupport', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/easing.js', ['goog.fx.easing'], [], {});
goog.addDependency('fx/easing_test.js', ['goog.fx.easingTest'], ['goog.fx.easing', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/fx.js', ['goog.fx'], ['goog.asserts', 'goog.fx.Animation', 'goog.fx.Animation.EventType', 'goog.fx.Animation.State', 'goog.fx.AnimationEvent', 'goog.fx.Transition.EventType', 'goog.fx.easing'], {});
goog.addDependency('fx/fx_test.js', ['goog.fxTest'], ['goog.fx.Animation', 'goog.object', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('fx/transition.js', ['goog.fx.Transition', 'goog.fx.Transition.EventType'], [], {});
goog.addDependency('fx/transitionbase.js', ['goog.fx.TransitionBase', 'goog.fx.TransitionBase.State'], ['goog.events.EventTarget', 'goog.fx.Transition'], {});
goog.addDependency('goog.js', [], [], {'lang': 'es6', 'module': 'es6'});
goog.addDependency('graphics/abstractgraphics.js', ['goog.graphics.AbstractGraphics'], ['goog.dom', 'goog.graphics.AffineTransform', 'goog.graphics.Element', 'goog.graphics.EllipseElement', 'goog.graphics.Fill', 'goog.graphics.Font', 'goog.graphics.GroupElement', 'goog.graphics.Path', 'goog.graphics.PathElement', 'goog.graphics.RectElement', 'goog.graphics.Stroke', 'goog.graphics.StrokeAndFillElement', 'goog.graphics.TextElement', 'goog.math.Coordinate', 'goog.math.Size', 'goog.style', 'goog.ui.Component'], {});
goog.addDependency('graphics/affinetransform.js', ['goog.graphics.AffineTransform'], [], {'lang': 'es6'});
goog.addDependency('graphics/affinetransform_test.js', ['goog.graphics.AffineTransformTest'], ['goog.array', 'goog.graphics', 'goog.graphics.AffineTransform', 'goog.math', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/canvaselement.js', ['goog.graphics.CanvasEllipseElement', 'goog.graphics.CanvasGroupElement', 'goog.graphics.CanvasImageElement', 'goog.graphics.CanvasPathElement', 'goog.graphics.CanvasRectElement', 'goog.graphics.CanvasTextElement'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.graphics.EllipseElement', 'goog.graphics.Font', 'goog.graphics.GroupElement', 'goog.graphics.ImageElement', 'goog.graphics.Path', 'goog.graphics.PathElement', 'goog.graphics.RectElement', 'goog.graphics.TextElement', 'goog.html.SafeHtml', 'goog.html.uncheckedconversions', 'goog.math', 'goog.string', 'goog.string.Const'], {});
goog.addDependency('graphics/canvasgraphics.js', ['goog.graphics.CanvasGraphics'], ['goog.dom.TagName', 'goog.events.EventType', 'goog.graphics.AbstractGraphics', 'goog.graphics.CanvasEllipseElement', 'goog.graphics.CanvasGroupElement', 'goog.graphics.CanvasImageElement', 'goog.graphics.CanvasPathElement', 'goog.graphics.CanvasRectElement', 'goog.graphics.CanvasTextElement', 'goog.graphics.Font', 'goog.graphics.SolidFill', 'goog.math.Size', 'goog.style'], {});
goog.addDependency('graphics/canvasgraphics_test.js', ['goog.graphics.CanvasGraphicsTest'], ['goog.dom', 'goog.graphics.CanvasGraphics', 'goog.graphics.SolidFill', 'goog.graphics.Stroke', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/element.js', ['goog.graphics.Element'], ['goog.asserts', 'goog.events', 'goog.events.EventTarget', 'goog.events.Listenable', 'goog.graphics.AffineTransform', 'goog.math'], {});
goog.addDependency('graphics/ellipseelement.js', ['goog.graphics.EllipseElement'], ['goog.graphics.StrokeAndFillElement'], {});
goog.addDependency('graphics/ext/coordinates.js', ['goog.graphics.ext.coordinates'], ['goog.string'], {});
goog.addDependency('graphics/ext/coordinates_test.js', ['goog.graphics.ext.coordinatesTest'], ['goog.graphics', 'goog.graphics.ext.coordinates', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/ext/element.js', ['goog.graphics.ext.Element'], ['goog.events.EventTarget', 'goog.functions', 'goog.graphics.ext.coordinates'], {});
goog.addDependency('graphics/ext/element_test.js', ['goog.graphics.ext.ElementTest'], ['goog.graphics', 'goog.graphics.ext', 'goog.testing.StrictMock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/ext/ellipse.js', ['goog.graphics.ext.Ellipse'], ['goog.graphics.ext.StrokeAndFillElement'], {});
goog.addDependency('graphics/ext/ext.js', ['goog.graphics.ext'], ['goog.graphics.ext.Ellipse', 'goog.graphics.ext.Graphics', 'goog.graphics.ext.Group', 'goog.graphics.ext.Image', 'goog.graphics.ext.Rectangle', 'goog.graphics.ext.Shape', 'goog.graphics.ext.coordinates'], {});
goog.addDependency('graphics/ext/graphics.js', ['goog.graphics.ext.Graphics'], ['goog.events', 'goog.events.EventType', 'goog.graphics', 'goog.graphics.ext.Group'], {});
goog.addDependency('graphics/ext/group.js', ['goog.graphics.ext.Group'], ['goog.array', 'goog.graphics.ext.Element'], {});
goog.addDependency('graphics/ext/image.js', ['goog.graphics.ext.Image'], ['goog.graphics.ext.Element'], {});
goog.addDependency('graphics/ext/path.js', ['goog.graphics.ext.Path'], ['goog.graphics.AffineTransform', 'goog.graphics.Path', 'goog.math.Rect'], {});
goog.addDependency('graphics/ext/path_test.js', ['goog.graphics.ext.PathTest'], ['goog.graphics', 'goog.graphics.ext.Path', 'goog.math.Rect', 'goog.testing.graphics', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/ext/rectangle.js', ['goog.graphics.ext.Rectangle'], ['goog.graphics.ext.StrokeAndFillElement'], {});
goog.addDependency('graphics/ext/shape.js', ['goog.graphics.ext.Shape'], ['goog.graphics.ext.StrokeAndFillElement'], {});
goog.addDependency('graphics/ext/strokeandfillelement.js', ['goog.graphics.ext.StrokeAndFillElement'], ['goog.graphics.ext.Element'], {});
goog.addDependency('graphics/fill.js', ['goog.graphics.Fill'], [], {});
goog.addDependency('graphics/font.js', ['goog.graphics.Font'], [], {});
goog.addDependency('graphics/graphics.js', ['goog.graphics'], ['goog.dom', 'goog.graphics.CanvasGraphics', 'goog.graphics.SvgGraphics', 'goog.graphics.VmlGraphics', 'goog.userAgent'], {});
goog.addDependency('graphics/groupelement.js', ['goog.graphics.GroupElement'], ['goog.graphics.Element'], {});
goog.addDependency('graphics/imageelement.js', ['goog.graphics.ImageElement'], ['goog.graphics.Element'], {});
goog.addDependency('graphics/lineargradient.js', ['goog.graphics.LinearGradient'], ['goog.asserts', 'goog.graphics.Fill'], {});
goog.addDependency('graphics/path.js', ['goog.graphics.Path', 'goog.graphics.Path.Segment'], ['goog.array', 'goog.graphics.AffineTransform', 'goog.math'], {});
goog.addDependency('graphics/path_test.js', ['goog.graphics.PathTest'], ['goog.array', 'goog.graphics.AffineTransform', 'goog.graphics.Path', 'goog.testing.graphics', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/pathelement.js', ['goog.graphics.PathElement'], ['goog.graphics.StrokeAndFillElement'], {});
goog.addDependency('graphics/paths.js', ['goog.graphics.paths'], ['goog.graphics.Path', 'goog.math.Coordinate'], {});
goog.addDependency('graphics/paths_test.js', ['goog.graphics.pathsTest'], ['goog.dom', 'goog.graphics', 'goog.graphics.paths', 'goog.math.Coordinate', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/rectelement.js', ['goog.graphics.RectElement'], ['goog.graphics.StrokeAndFillElement'], {});
goog.addDependency('graphics/solidfill.js', ['goog.graphics.SolidFill'], ['goog.graphics.Fill'], {});
goog.addDependency('graphics/solidfill_test.js', ['goog.graphics.SolidFillTest'], ['goog.graphics.SolidFill', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/stroke.js', ['goog.graphics.Stroke'], [], {});
goog.addDependency('graphics/strokeandfillelement.js', ['goog.graphics.StrokeAndFillElement'], ['goog.graphics.Element'], {});
goog.addDependency('graphics/svgelement.js', ['goog.graphics.SvgEllipseElement', 'goog.graphics.SvgGroupElement', 'goog.graphics.SvgImageElement', 'goog.graphics.SvgPathElement', 'goog.graphics.SvgRectElement', 'goog.graphics.SvgTextElement'], ['goog.dom', 'goog.graphics.EllipseElement', 'goog.graphics.GroupElement', 'goog.graphics.ImageElement', 'goog.graphics.PathElement', 'goog.graphics.RectElement', 'goog.graphics.TextElement'], {});
goog.addDependency('graphics/svggraphics.js', ['goog.graphics.SvgGraphics'], ['goog.Timer', 'goog.dom', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.graphics.AbstractGraphics', 'goog.graphics.Font', 'goog.graphics.LinearGradient', 'goog.graphics.Path', 'goog.graphics.SolidFill', 'goog.graphics.Stroke', 'goog.graphics.SvgEllipseElement', 'goog.graphics.SvgGroupElement', 'goog.graphics.SvgImageElement', 'goog.graphics.SvgPathElement', 'goog.graphics.SvgRectElement', 'goog.graphics.SvgTextElement', 'goog.math', 'goog.math.Size', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('graphics/svggraphics_test.js', ['goog.graphics.SvgGraphicsTest'], ['goog.dom', 'goog.graphics.AffineTransform', 'goog.graphics.SolidFill', 'goog.graphics.SvgGraphics', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('graphics/textelement.js', ['goog.graphics.TextElement'], ['goog.graphics.StrokeAndFillElement'], {});
goog.addDependency('graphics/vmlelement.js', ['goog.graphics.VmlEllipseElement', 'goog.graphics.VmlGroupElement', 'goog.graphics.VmlImageElement', 'goog.graphics.VmlPathElement', 'goog.graphics.VmlRectElement', 'goog.graphics.VmlTextElement'], ['goog.dom', 'goog.graphics.EllipseElement', 'goog.graphics.GroupElement', 'goog.graphics.ImageElement', 'goog.graphics.PathElement', 'goog.graphics.RectElement', 'goog.graphics.TextElement'], {});
goog.addDependency('graphics/vmlgraphics.js', ['goog.graphics.VmlGraphics'], ['goog.array', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.graphics.AbstractGraphics', 'goog.graphics.Font', 'goog.graphics.LinearGradient', 'goog.graphics.Path', 'goog.graphics.SolidFill', 'goog.graphics.VmlEllipseElement', 'goog.graphics.VmlGroupElement', 'goog.graphics.VmlImageElement', 'goog.graphics.VmlPathElement', 'goog.graphics.VmlRectElement', 'goog.graphics.VmlTextElement', 'goog.html.uncheckedconversions', 'goog.math', 'goog.math.Size', 'goog.reflect', 'goog.string', 'goog.string.Const', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('history/event.js', ['goog.history.Event'], ['goog.events.Event', 'goog.history.EventType'], {});
goog.addDependency('history/eventtype.js', ['goog.history.EventType'], [], {});
goog.addDependency('history/history.js', ['goog.History', 'goog.History.Event', 'goog.History.EventType'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.safe', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.history.Event', 'goog.history.EventType', 'goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.uncheckedconversions', 'goog.labs.userAgent.device', 'goog.memoize', 'goog.string', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('history/history_test.js', ['goog.HistoryTest'], ['goog.History', 'goog.dispose', 'goog.dom', 'goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('history/html5history.js', ['goog.history.Html5History', 'goog.history.Html5History.TokenTransformer'], ['goog.asserts', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.history.Event'], {});
goog.addDependency('history/html5history_test.js', ['goog.history.Html5HistoryTest'], ['goog.Timer', 'goog.events', 'goog.events.EventType', 'goog.history.EventType', 'goog.history.Html5History', 'goog.testing.MockControl', 'goog.testing.mockmatchers', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/cssspecificity.js', ['goog.html.CssSpecificity'], ['goog.userAgent', 'goog.userAgent.product'], {'module': 'goog'});
goog.addDependency('html/cssspecificity_test.js', ['goog.html.CssSpecificityTest'], ['goog.html.CssSpecificity', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/flash.js', ['goog.html.flash'], ['goog.asserts', 'goog.html.SafeHtml'], {});
goog.addDependency('html/flash_test.js', ['goog.html.flashTest'], ['goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.flash', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/legacyconversions.js', ['goog.html.legacyconversions'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl'], {});
goog.addDependency('html/legacyconversions_test.js', ['goog.html.legacyconversionsTest'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.legacyconversions', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safehtml.js', ['goog.html.SafeHtml'], ['goog.array', 'goog.asserts', 'goog.dom.TagName', 'goog.dom.tags', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.trustedtypes', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.labs.userAgent.browser', 'goog.object', 'goog.string.Const', 'goog.string.TypedString', 'goog.string.internal'], {});
goog.addDependency('html/safehtml_test.js', ['goog.html.safeHtmlTest'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.testing', 'goog.html.trustedtypes', 'goog.i18n.bidi.Dir', 'goog.labs.userAgent.browser', 'goog.object', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safehtmlformatter.js', ['goog.html.SafeHtmlFormatter'], ['goog.asserts', 'goog.dom.tags', 'goog.html.SafeHtml', 'goog.string'], {});
goog.addDependency('html/safehtmlformatter_test.js', ['goog.html.safeHtmlFormatterTest'], ['goog.html.SafeHtml', 'goog.html.SafeHtmlFormatter', 'goog.html.SafeUrl', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safescript.js', ['goog.html.SafeScript'], ['goog.asserts', 'goog.html.trustedtypes', 'goog.string.Const', 'goog.string.TypedString'], {});
goog.addDependency('html/safescript_test.js', ['goog.html.safeScriptTest'], ['goog.html.SafeScript', 'goog.html.trustedtypes', 'goog.object', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safestyle.js', ['goog.html.SafeStyle'], ['goog.array', 'goog.asserts', 'goog.html.SafeUrl', 'goog.string.Const', 'goog.string.TypedString', 'goog.string.internal'], {'lang': 'es5'});
goog.addDependency('html/safestyle_test.js', ['goog.html.safeStyleTest'], ['goog.html.SafeStyle', 'goog.html.SafeUrl', 'goog.object', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safestylesheet.js', ['goog.html.SafeStyleSheet'], ['goog.array', 'goog.asserts', 'goog.html.SafeStyle', 'goog.object', 'goog.string.Const', 'goog.string.TypedString', 'goog.string.internal'], {});
goog.addDependency('html/safestylesheet_test.js', ['goog.html.safeStyleSheetTest'], ['goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.object', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safeurl.js', ['goog.html.SafeUrl'], ['goog.asserts', 'goog.fs.url', 'goog.html.TrustedResourceUrl', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.string.Const', 'goog.string.TypedString', 'goog.string.internal'], {});
goog.addDependency('html/safeurl_test.js', ['goog.html.safeUrlTest'], ['goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.safeUrlTestVectors', 'goog.i18n.bidi.Dir', 'goog.object', 'goog.string.Const', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/safeurl_test_vectors.js', ['goog.html.safeUrlTestVectors'], [], {});
goog.addDependency('html/sanitizer/attributewhitelist.js', ['goog.html.sanitizer.AttributeSanitizedWhitelist', 'goog.html.sanitizer.AttributeWhitelist'], [], {});
goog.addDependency('html/sanitizer/csspropertysanitizer.js', ['goog.html.sanitizer.CssPropertySanitizer'], ['goog.asserts', 'goog.html.SafeUrl', 'goog.object', 'goog.string'], {'module': 'goog'});
goog.addDependency('html/sanitizer/csspropertysanitizer_test.js', ['goog.html.sanitizer.CssPropertySanitizerTest'], ['goog.functions', 'goog.html.SafeUrl', 'goog.html.sanitizer.CssPropertySanitizer', 'goog.html.sanitizer.noclobber', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/csssanitizer.js', ['goog.html.sanitizer.CssSanitizer'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.CssSpecificity', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.sanitizer.CssPropertySanitizer', 'goog.html.sanitizer.noclobber', 'goog.html.uncheckedconversions', 'goog.object', 'goog.string', 'goog.string.Const', 'goog.userAgent', 'goog.userAgent.product'], {});
goog.addDependency('html/sanitizer/csssanitizer_test.js', ['goog.html.CssSanitizerTest'], ['goog.array', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.sanitizer.CssSanitizer', 'goog.html.testing', 'goog.string', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/elementweakmap.js', ['goog.html.sanitizer.ElementWeakMap'], ['goog.html.sanitizer.noclobber'], {'module': 'goog'});
goog.addDependency('html/sanitizer/elementweakmap_test.js', ['goog.html.sanitizer.ElementWeakMapTest'], ['goog.html.sanitizer.ElementWeakMap', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/html_test_vectors.js', ['goog.html.htmlTestVectors'], [], {'lang': 'es5'});
goog.addDependency('html/sanitizer/htmlsanitizer.js', ['goog.html.sanitizer.HtmlSanitizer', 'goog.html.sanitizer.HtmlSanitizer.Builder', 'goog.html.sanitizer.HtmlSanitizerAttributePolicy', 'goog.html.sanitizer.HtmlSanitizerPolicy', 'goog.html.sanitizer.HtmlSanitizerPolicyContext', 'goog.html.sanitizer.HtmlSanitizerPolicyHints', 'goog.html.sanitizer.HtmlSanitizerUrlPolicy'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.sanitizer.AttributeSanitizedWhitelist', 'goog.html.sanitizer.AttributeWhitelist', 'goog.html.sanitizer.CssSanitizer', 'goog.html.sanitizer.SafeDomTreeProcessor', 'goog.html.sanitizer.TagBlacklist', 'goog.html.sanitizer.TagWhitelist', 'goog.html.sanitizer.noclobber', 'goog.html.uncheckedconversions', 'goog.object', 'goog.string', 'goog.string.Const'], {'lang': 'es5'});
goog.addDependency('html/sanitizer/htmlsanitizer_test.js', ['goog.html.HtmlSanitizerTest'], ['goog.array', 'goog.dom', 'goog.functions', 'goog.html.SafeHtml', 'goog.html.SafeUrl', 'goog.html.sanitizer.HtmlSanitizer', 'goog.html.sanitizer.HtmlSanitizer.Builder', 'goog.html.sanitizer.TagWhitelist', 'goog.html.testing', 'goog.object', 'goog.string.Const', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/htmlsanitizer_unified_test.js', ['goog.html.HtmlSanitizerUnifiedTest'], ['goog.html.SafeHtml', 'goog.html.htmlTestVectors', 'goog.html.sanitizer.HtmlSanitizer.Builder', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/noclobber.js', ['goog.html.sanitizer.noclobber'], ['goog.asserts', 'goog.dom.NodeType', 'goog.userAgent.product'], {'lang': 'es5', 'module': 'goog'});
goog.addDependency('html/sanitizer/noclobber_test.js', ['goog.html.sanitizer.noclobberTest'], ['goog.dom.NodeType', 'goog.html.sanitizer.noclobber', 'goog.testing.PropertyReplacer', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/safedomtreeprocessor.js', ['goog.html.sanitizer.SafeDomTreeProcessor'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.sanitizer.ElementWeakMap', 'goog.html.sanitizer.noclobber', 'goog.html.uncheckedconversions', 'goog.log', 'goog.string.Const', 'goog.userAgent'], {'module': 'goog'});
goog.addDependency('html/sanitizer/safedomtreeprocessor_test.js', ['goog.html.sanitizer.SafeDomTreeProcessorTest'], ['goog.html.sanitizer.SafeDomTreeProcessor', 'goog.html.sanitizer.noclobber', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/sanitizer/tagblacklist.js', ['goog.html.sanitizer.TagBlacklist'], [], {});
goog.addDependency('html/sanitizer/tagwhitelist.js', ['goog.html.sanitizer.TagWhitelist'], [], {});
goog.addDependency('html/sanitizer/unsafe.js', ['goog.html.sanitizer.unsafe'], ['goog.asserts', 'goog.html.sanitizer.HtmlSanitizer.Builder', 'goog.string', 'goog.string.Const'], {});
goog.addDependency('html/sanitizer/unsafe_test.js', ['goog.html.UnsafeTest'], ['goog.html.SafeHtml', 'goog.html.sanitizer.AttributeWhitelist', 'goog.html.sanitizer.HtmlSanitizer', 'goog.html.sanitizer.TagWhitelist', 'goog.html.sanitizer.unsafe', 'goog.string.Const', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/silverlight.js', ['goog.html.silverlight'], ['goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.flash', 'goog.string.Const'], {});
goog.addDependency('html/silverlight_test.js', ['goog.html.silverlightTest'], ['goog.html.SafeHtml', 'goog.html.TrustedResourceUrl', 'goog.html.silverlight', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/testing.js', ['goog.html.testing'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.testing.mockmatchers.ArgumentMatcher'], {});
goog.addDependency('html/textextractor.js', ['goog.html.textExtractor'], ['goog.array', 'goog.dom.TagName', 'goog.html.sanitizer.HtmlSanitizer', 'goog.object', 'goog.userAgent'], {});
goog.addDependency('html/textextractor_test.js', ['goog.html.textExtractorTest'], ['goog.html.textExtractor', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/trustedresourceurl.js', ['goog.html.TrustedResourceUrl'], ['goog.asserts', 'goog.html.trustedtypes', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.string.Const', 'goog.string.TypedString'], {});
goog.addDependency('html/trustedresourceurl_test.js', ['goog.html.trustedResourceUrlTest'], ['goog.html.TrustedResourceUrl', 'goog.html.trustedtypes', 'goog.i18n.bidi.Dir', 'goog.object', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/trustedtypes.js', ['goog.html.trustedtypes'], [], {});
goog.addDependency('html/uncheckedconversions.js', ['goog.html.uncheckedconversions'], ['goog.asserts', 'goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.string.internal'], {});
goog.addDependency('html/uncheckedconversions_test.js', ['goog.html.uncheckedconversionsTest'], ['goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.uncheckedconversions', 'goog.i18n.bidi.Dir', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('html/utils.js', ['goog.html.utils'], ['goog.string'], {});
goog.addDependency('html/utils_test.js', ['goog.html.UtilsTest'], ['goog.array', 'goog.dom.TagName', 'goog.html.utils', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/bidi.js', ['goog.i18n.bidi', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.DirectionalString', 'goog.i18n.bidi.Format'], [], {'lang': 'es6'});
goog.addDependency('i18n/bidi_test.js', ['goog.i18n.bidiTest'], ['goog.i18n.bidi', 'goog.i18n.bidi.Dir', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/bidiformatter.js', ['goog.i18n.BidiFormatter'], ['goog.html.SafeHtml', 'goog.i18n.bidi', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.Format'], {});
goog.addDependency('i18n/bidiformatter_test.js', ['goog.i18n.BidiFormatterTest'], ['goog.html.SafeHtml', 'goog.html.testing', 'goog.i18n.BidiFormatter', 'goog.i18n.bidi.Dir', 'goog.i18n.bidi.Format', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/charlistdecompressor.js', ['goog.i18n.CharListDecompressor'], ['goog.array', 'goog.i18n.uChar'], {});
goog.addDependency('i18n/charlistdecompressor_test.js', ['goog.i18n.CharListDecompressorTest'], ['goog.i18n.CharListDecompressor', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/charpickerdata.js', ['goog.i18n.CharPickerData'], [], {});
goog.addDependency('i18n/collation.js', ['goog.i18n.collation'], [], {'lang': 'es6'});
goog.addDependency('i18n/collation_test.js', ['goog.i18n.collationTest'], ['goog.i18n.collation', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/compactnumberformatsymbols.js', ['goog.i18n.CompactNumberFormatSymbols', 'goog.i18n.CompactNumberFormatSymbols_af', 'goog.i18n.CompactNumberFormatSymbols_am', 'goog.i18n.CompactNumberFormatSymbols_ar', 'goog.i18n.CompactNumberFormatSymbols_ar_DZ', 'goog.i18n.CompactNumberFormatSymbols_ar_EG', 'goog.i18n.CompactNumberFormatSymbols_az', 'goog.i18n.CompactNumberFormatSymbols_be', 'goog.i18n.CompactNumberFormatSymbols_bg', 'goog.i18n.CompactNumberFormatSymbols_bn', 'goog.i18n.CompactNumberFormatSymbols_br', 'goog.i18n.CompactNumberFormatSymbols_bs', 'goog.i18n.CompactNumberFormatSymbols_ca', 'goog.i18n.CompactNumberFormatSymbols_chr', 'goog.i18n.CompactNumberFormatSymbols_cs', 'goog.i18n.CompactNumberFormatSymbols_cy', 'goog.i18n.CompactNumberFormatSymbols_da', 'goog.i18n.CompactNumberFormatSymbols_de', 'goog.i18n.CompactNumberFormatSymbols_de_AT', 'goog.i18n.CompactNumberFormatSymbols_de_CH', 'goog.i18n.CompactNumberFormatSymbols_el', 'goog.i18n.CompactNumberFormatSymbols_en', 'goog.i18n.CompactNumberFormatSymbols_en_AU', 'goog.i18n.CompactNumberFormatSymbols_en_CA', 'goog.i18n.CompactNumberFormatSymbols_en_GB', 'goog.i18n.CompactNumberFormatSymbols_en_IE', 'goog.i18n.CompactNumberFormatSymbols_en_IN', 'goog.i18n.CompactNumberFormatSymbols_en_SG', 'goog.i18n.CompactNumberFormatSymbols_en_US', 'goog.i18n.CompactNumberFormatSymbols_en_ZA', 'goog.i18n.CompactNumberFormatSymbols_es', 'goog.i18n.CompactNumberFormatSymbols_es_419', 'goog.i18n.CompactNumberFormatSymbols_es_ES', 'goog.i18n.CompactNumberFormatSymbols_es_MX', 'goog.i18n.CompactNumberFormatSymbols_es_US', 'goog.i18n.CompactNumberFormatSymbols_et', 'goog.i18n.CompactNumberFormatSymbols_eu', 'goog.i18n.CompactNumberFormatSymbols_fa', 'goog.i18n.CompactNumberFormatSymbols_fi', 'goog.i18n.CompactNumberFormatSymbols_fil', 'goog.i18n.CompactNumberFormatSymbols_fr', 'goog.i18n.CompactNumberFormatSymbols_fr_CA', 'goog.i18n.CompactNumberFormatSymbols_ga', 'goog.i18n.CompactNumberFormatSymbols_gl', 'goog.i18n.CompactNumberFormatSymbols_gsw', 'goog.i18n.CompactNumberFormatSymbols_gu', 'goog.i18n.CompactNumberFormatSymbols_haw', 'goog.i18n.CompactNumberFormatSymbols_he', 'goog.i18n.CompactNumberFormatSymbols_hi', 'goog.i18n.CompactNumberFormatSymbols_hr', 'goog.i18n.CompactNumberFormatSymbols_hu', 'goog.i18n.CompactNumberFormatSymbols_hy', 'goog.i18n.CompactNumberFormatSymbols_id', 'goog.i18n.CompactNumberFormatSymbols_in', 'goog.i18n.CompactNumberFormatSymbols_is', 'goog.i18n.CompactNumberFormatSymbols_it', 'goog.i18n.CompactNumberFormatSymbols_iw', 'goog.i18n.CompactNumberFormatSymbols_ja', 'goog.i18n.CompactNumberFormatSymbols_ka', 'goog.i18n.CompactNumberFormatSymbols_kk', 'goog.i18n.CompactNumberFormatSymbols_km', 'goog.i18n.CompactNumberFormatSymbols_kn', 'goog.i18n.CompactNumberFormatSymbols_ko', 'goog.i18n.CompactNumberFormatSymbols_ky', 'goog.i18n.CompactNumberFormatSymbols_ln', 'goog.i18n.CompactNumberFormatSymbols_lo', 'goog.i18n.CompactNumberFormatSymbols_lt', 'goog.i18n.CompactNumberFormatSymbols_lv', 'goog.i18n.CompactNumberFormatSymbols_mk', 'goog.i18n.CompactNumberFormatSymbols_ml', 'goog.i18n.CompactNumberFormatSymbols_mn', 'goog.i18n.CompactNumberFormatSymbols_mo', 'goog.i18n.CompactNumberFormatSymbols_mr', 'goog.i18n.CompactNumberFormatSymbols_ms', 'goog.i18n.CompactNumberFormatSymbols_mt', 'goog.i18n.CompactNumberFormatSymbols_my', 'goog.i18n.CompactNumberFormatSymbols_nb', 'goog.i18n.CompactNumberFormatSymbols_ne', 'goog.i18n.CompactNumberFormatSymbols_nl', 'goog.i18n.CompactNumberFormatSymbols_no', 'goog.i18n.CompactNumberFormatSymbols_no_NO', 'goog.i18n.CompactNumberFormatSymbols_or', 'goog.i18n.CompactNumberFormatSymbols_pa', 'goog.i18n.CompactNumberFormatSymbols_pl', 'goog.i18n.CompactNumberFormatSymbols_pt', 'goog.i18n.CompactNumberFormatSymbols_pt_BR', 'goog.i18n.CompactNumberFormatSymbols_pt_PT', 'goog.i18n.CompactNumberFormatSymbols_ro', 'goog.i18n.CompactNumberFormatSymbols_ru', 'goog.i18n.CompactNumberFormatSymbols_sh', 'goog.i18n.CompactNumberFormatSymbols_si', 'goog.i18n.CompactNumberFormatSymbols_sk', 'goog.i18n.CompactNumberFormatSymbols_sl', 'goog.i18n.CompactNumberFormatSymbols_sq', 'goog.i18n.CompactNumberFormatSymbols_sr', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn', 'goog.i18n.CompactNumberFormatSymbols_sv', 'goog.i18n.CompactNumberFormatSymbols_sw', 'goog.i18n.CompactNumberFormatSymbols_ta', 'goog.i18n.CompactNumberFormatSymbols_te', 'goog.i18n.CompactNumberFormatSymbols_th', 'goog.i18n.CompactNumberFormatSymbols_tl', 'goog.i18n.CompactNumberFormatSymbols_tr', 'goog.i18n.CompactNumberFormatSymbols_uk', 'goog.i18n.CompactNumberFormatSymbols_ur', 'goog.i18n.CompactNumberFormatSymbols_uz', 'goog.i18n.CompactNumberFormatSymbols_vi', 'goog.i18n.CompactNumberFormatSymbols_zh', 'goog.i18n.CompactNumberFormatSymbols_zh_CN', 'goog.i18n.CompactNumberFormatSymbols_zh_HK', 'goog.i18n.CompactNumberFormatSymbols_zh_TW', 'goog.i18n.CompactNumberFormatSymbols_zu'], [], {});
goog.addDependency('i18n/compactnumberformatsymbolsext.js', ['goog.i18n.CompactNumberFormatSymbolsExt', 'goog.i18n.CompactNumberFormatSymbols_af_NA', 'goog.i18n.CompactNumberFormatSymbols_af_ZA', 'goog.i18n.CompactNumberFormatSymbols_agq', 'goog.i18n.CompactNumberFormatSymbols_agq_CM', 'goog.i18n.CompactNumberFormatSymbols_ak', 'goog.i18n.CompactNumberFormatSymbols_ak_GH', 'goog.i18n.CompactNumberFormatSymbols_am_ET', 'goog.i18n.CompactNumberFormatSymbols_ar_001', 'goog.i18n.CompactNumberFormatSymbols_ar_AE', 'goog.i18n.CompactNumberFormatSymbols_ar_BH', 'goog.i18n.CompactNumberFormatSymbols_ar_DJ', 'goog.i18n.CompactNumberFormatSymbols_ar_EH', 'goog.i18n.CompactNumberFormatSymbols_ar_ER', 'goog.i18n.CompactNumberFormatSymbols_ar_IL', 'goog.i18n.CompactNumberFormatSymbols_ar_IQ', 'goog.i18n.CompactNumberFormatSymbols_ar_JO', 'goog.i18n.CompactNumberFormatSymbols_ar_KM', 'goog.i18n.CompactNumberFormatSymbols_ar_KW', 'goog.i18n.CompactNumberFormatSymbols_ar_LB', 'goog.i18n.CompactNumberFormatSymbols_ar_LY', 'goog.i18n.CompactNumberFormatSymbols_ar_MA', 'goog.i18n.CompactNumberFormatSymbols_ar_MR', 'goog.i18n.CompactNumberFormatSymbols_ar_OM', 'goog.i18n.CompactNumberFormatSymbols_ar_PS', 'goog.i18n.CompactNumberFormatSymbols_ar_QA', 'goog.i18n.CompactNumberFormatSymbols_ar_SA', 'goog.i18n.CompactNumberFormatSymbols_ar_SD', 'goog.i18n.CompactNumberFormatSymbols_ar_SO', 'goog.i18n.CompactNumberFormatSymbols_ar_SS', 'goog.i18n.CompactNumberFormatSymbols_ar_SY', 'goog.i18n.CompactNumberFormatSymbols_ar_TD', 'goog.i18n.CompactNumberFormatSymbols_ar_TN', 'goog.i18n.CompactNumberFormatSymbols_ar_XB', 'goog.i18n.CompactNumberFormatSymbols_ar_YE', 'goog.i18n.CompactNumberFormatSymbols_as', 'goog.i18n.CompactNumberFormatSymbols_as_IN', 'goog.i18n.CompactNumberFormatSymbols_asa', 'goog.i18n.CompactNumberFormatSymbols_asa_TZ', 'goog.i18n.CompactNumberFormatSymbols_ast', 'goog.i18n.CompactNumberFormatSymbols_ast_ES', 'goog.i18n.CompactNumberFormatSymbols_az_Cyrl', 'goog.i18n.CompactNumberFormatSymbols_az_Cyrl_AZ', 'goog.i18n.CompactNumberFormatSymbols_az_Latn', 'goog.i18n.CompactNumberFormatSymbols_az_Latn_AZ', 'goog.i18n.CompactNumberFormatSymbols_bas', 'goog.i18n.CompactNumberFormatSymbols_bas_CM', 'goog.i18n.CompactNumberFormatSymbols_be_BY', 'goog.i18n.CompactNumberFormatSymbols_bem', 'goog.i18n.CompactNumberFormatSymbols_bem_ZM', 'goog.i18n.CompactNumberFormatSymbols_bez', 'goog.i18n.CompactNumberFormatSymbols_bez_TZ', 'goog.i18n.CompactNumberFormatSymbols_bg_BG', 'goog.i18n.CompactNumberFormatSymbols_bm', 'goog.i18n.CompactNumberFormatSymbols_bm_ML', 'goog.i18n.CompactNumberFormatSymbols_bn_BD', 'goog.i18n.CompactNumberFormatSymbols_bn_IN', 'goog.i18n.CompactNumberFormatSymbols_bo', 'goog.i18n.CompactNumberFormatSymbols_bo_CN', 'goog.i18n.CompactNumberFormatSymbols_bo_IN', 'goog.i18n.CompactNumberFormatSymbols_br_FR', 'goog.i18n.CompactNumberFormatSymbols_brx', 'goog.i18n.CompactNumberFormatSymbols_brx_IN', 'goog.i18n.CompactNumberFormatSymbols_bs_Cyrl', 'goog.i18n.CompactNumberFormatSymbols_bs_Cyrl_BA', 'goog.i18n.CompactNumberFormatSymbols_bs_Latn', 'goog.i18n.CompactNumberFormatSymbols_bs_Latn_BA', 'goog.i18n.CompactNumberFormatSymbols_ca_AD', 'goog.i18n.CompactNumberFormatSymbols_ca_ES', 'goog.i18n.CompactNumberFormatSymbols_ca_FR', 'goog.i18n.CompactNumberFormatSymbols_ca_IT', 'goog.i18n.CompactNumberFormatSymbols_ccp', 'goog.i18n.CompactNumberFormatSymbols_ccp_BD', 'goog.i18n.CompactNumberFormatSymbols_ccp_IN', 'goog.i18n.CompactNumberFormatSymbols_ce', 'goog.i18n.CompactNumberFormatSymbols_ce_RU', 'goog.i18n.CompactNumberFormatSymbols_ceb', 'goog.i18n.CompactNumberFormatSymbols_ceb_PH', 'goog.i18n.CompactNumberFormatSymbols_cgg', 'goog.i18n.CompactNumberFormatSymbols_cgg_UG', 'goog.i18n.CompactNumberFormatSymbols_chr_US', 'goog.i18n.CompactNumberFormatSymbols_ckb', 'goog.i18n.CompactNumberFormatSymbols_ckb_IQ', 'goog.i18n.CompactNumberFormatSymbols_ckb_IR', 'goog.i18n.CompactNumberFormatSymbols_cs_CZ', 'goog.i18n.CompactNumberFormatSymbols_cy_GB', 'goog.i18n.CompactNumberFormatSymbols_da_DK', 'goog.i18n.CompactNumberFormatSymbols_da_GL', 'goog.i18n.CompactNumberFormatSymbols_dav', 'goog.i18n.CompactNumberFormatSymbols_dav_KE', 'goog.i18n.CompactNumberFormatSymbols_de_BE', 'goog.i18n.CompactNumberFormatSymbols_de_DE', 'goog.i18n.CompactNumberFormatSymbols_de_IT', 'goog.i18n.CompactNumberFormatSymbols_de_LI', 'goog.i18n.CompactNumberFormatSymbols_de_LU', 'goog.i18n.CompactNumberFormatSymbols_dje', 'goog.i18n.CompactNumberFormatSymbols_dje_NE', 'goog.i18n.CompactNumberFormatSymbols_dsb', 'goog.i18n.CompactNumberFormatSymbols_dsb_DE', 'goog.i18n.CompactNumberFormatSymbols_dua', 'goog.i18n.CompactNumberFormatSymbols_dua_CM', 'goog.i18n.CompactNumberFormatSymbols_dyo', 'goog.i18n.CompactNumberFormatSymbols_dyo_SN', 'goog.i18n.CompactNumberFormatSymbols_dz', 'goog.i18n.CompactNumberFormatSymbols_dz_BT', 'goog.i18n.CompactNumberFormatSymbols_ebu', 'goog.i18n.CompactNumberFormatSymbols_ebu_KE', 'goog.i18n.CompactNumberFormatSymbols_ee', 'goog.i18n.CompactNumberFormatSymbols_ee_GH', 'goog.i18n.CompactNumberFormatSymbols_ee_TG', 'goog.i18n.CompactNumberFormatSymbols_el_CY', 'goog.i18n.CompactNumberFormatSymbols_el_GR', 'goog.i18n.CompactNumberFormatSymbols_en_001', 'goog.i18n.CompactNumberFormatSymbols_en_150', 'goog.i18n.CompactNumberFormatSymbols_en_AE', 'goog.i18n.CompactNumberFormatSymbols_en_AG', 'goog.i18n.CompactNumberFormatSymbols_en_AI', 'goog.i18n.CompactNumberFormatSymbols_en_AS', 'goog.i18n.CompactNumberFormatSymbols_en_AT', 'goog.i18n.CompactNumberFormatSymbols_en_BB', 'goog.i18n.CompactNumberFormatSymbols_en_BE', 'goog.i18n.CompactNumberFormatSymbols_en_BI', 'goog.i18n.CompactNumberFormatSymbols_en_BM', 'goog.i18n.CompactNumberFormatSymbols_en_BS', 'goog.i18n.CompactNumberFormatSymbols_en_BW', 'goog.i18n.CompactNumberFormatSymbols_en_BZ', 'goog.i18n.CompactNumberFormatSymbols_en_CC', 'goog.i18n.CompactNumberFormatSymbols_en_CH', 'goog.i18n.CompactNumberFormatSymbols_en_CK', 'goog.i18n.CompactNumberFormatSymbols_en_CM', 'goog.i18n.CompactNumberFormatSymbols_en_CX', 'goog.i18n.CompactNumberFormatSymbols_en_CY', 'goog.i18n.CompactNumberFormatSymbols_en_DE', 'goog.i18n.CompactNumberFormatSymbols_en_DG', 'goog.i18n.CompactNumberFormatSymbols_en_DK', 'goog.i18n.CompactNumberFormatSymbols_en_DM', 'goog.i18n.CompactNumberFormatSymbols_en_ER', 'goog.i18n.CompactNumberFormatSymbols_en_FI', 'goog.i18n.CompactNumberFormatSymbols_en_FJ', 'goog.i18n.CompactNumberFormatSymbols_en_FK', 'goog.i18n.CompactNumberFormatSymbols_en_FM', 'goog.i18n.CompactNumberFormatSymbols_en_GD', 'goog.i18n.CompactNumberFormatSymbols_en_GG', 'goog.i18n.CompactNumberFormatSymbols_en_GH', 'goog.i18n.CompactNumberFormatSymbols_en_GI', 'goog.i18n.CompactNumberFormatSymbols_en_GM', 'goog.i18n.CompactNumberFormatSymbols_en_GU', 'goog.i18n.CompactNumberFormatSymbols_en_GY', 'goog.i18n.CompactNumberFormatSymbols_en_HK', 'goog.i18n.CompactNumberFormatSymbols_en_IL', 'goog.i18n.CompactNumberFormatSymbols_en_IM', 'goog.i18n.CompactNumberFormatSymbols_en_IO', 'goog.i18n.CompactNumberFormatSymbols_en_JE', 'goog.i18n.CompactNumberFormatSymbols_en_JM', 'goog.i18n.CompactNumberFormatSymbols_en_KE', 'goog.i18n.CompactNumberFormatSymbols_en_KI', 'goog.i18n.CompactNumberFormatSymbols_en_KN', 'goog.i18n.CompactNumberFormatSymbols_en_KY', 'goog.i18n.CompactNumberFormatSymbols_en_LC', 'goog.i18n.CompactNumberFormatSymbols_en_LR', 'goog.i18n.CompactNumberFormatSymbols_en_LS', 'goog.i18n.CompactNumberFormatSymbols_en_MG', 'goog.i18n.CompactNumberFormatSymbols_en_MH', 'goog.i18n.CompactNumberFormatSymbols_en_MO', 'goog.i18n.CompactNumberFormatSymbols_en_MP', 'goog.i18n.CompactNumberFormatSymbols_en_MS', 'goog.i18n.CompactNumberFormatSymbols_en_MT', 'goog.i18n.CompactNumberFormatSymbols_en_MU', 'goog.i18n.CompactNumberFormatSymbols_en_MW', 'goog.i18n.CompactNumberFormatSymbols_en_MY', 'goog.i18n.CompactNumberFormatSymbols_en_NA', 'goog.i18n.CompactNumberFormatSymbols_en_NF', 'goog.i18n.CompactNumberFormatSymbols_en_NG', 'goog.i18n.CompactNumberFormatSymbols_en_NL', 'goog.i18n.CompactNumberFormatSymbols_en_NR', 'goog.i18n.CompactNumberFormatSymbols_en_NU', 'goog.i18n.CompactNumberFormatSymbols_en_NZ', 'goog.i18n.CompactNumberFormatSymbols_en_PG', 'goog.i18n.CompactNumberFormatSymbols_en_PH', 'goog.i18n.CompactNumberFormatSymbols_en_PK', 'goog.i18n.CompactNumberFormatSymbols_en_PN', 'goog.i18n.CompactNumberFormatSymbols_en_PR', 'goog.i18n.CompactNumberFormatSymbols_en_PW', 'goog.i18n.CompactNumberFormatSymbols_en_RW', 'goog.i18n.CompactNumberFormatSymbols_en_SB', 'goog.i18n.CompactNumberFormatSymbols_en_SC', 'goog.i18n.CompactNumberFormatSymbols_en_SD', 'goog.i18n.CompactNumberFormatSymbols_en_SE', 'goog.i18n.CompactNumberFormatSymbols_en_SH', 'goog.i18n.CompactNumberFormatSymbols_en_SI', 'goog.i18n.CompactNumberFormatSymbols_en_SL', 'goog.i18n.CompactNumberFormatSymbols_en_SS', 'goog.i18n.CompactNumberFormatSymbols_en_SX', 'goog.i18n.CompactNumberFormatSymbols_en_SZ', 'goog.i18n.CompactNumberFormatSymbols_en_TC', 'goog.i18n.CompactNumberFormatSymbols_en_TK', 'goog.i18n.CompactNumberFormatSymbols_en_TO', 'goog.i18n.CompactNumberFormatSymbols_en_TT', 'goog.i18n.CompactNumberFormatSymbols_en_TV', 'goog.i18n.CompactNumberFormatSymbols_en_TZ', 'goog.i18n.CompactNumberFormatSymbols_en_UG', 'goog.i18n.CompactNumberFormatSymbols_en_UM', 'goog.i18n.CompactNumberFormatSymbols_en_US_POSIX', 'goog.i18n.CompactNumberFormatSymbols_en_VC', 'goog.i18n.CompactNumberFormatSymbols_en_VG', 'goog.i18n.CompactNumberFormatSymbols_en_VI', 'goog.i18n.CompactNumberFormatSymbols_en_VU', 'goog.i18n.CompactNumberFormatSymbols_en_WS', 'goog.i18n.CompactNumberFormatSymbols_en_XA', 'goog.i18n.CompactNumberFormatSymbols_en_ZM', 'goog.i18n.CompactNumberFormatSymbols_en_ZW', 'goog.i18n.CompactNumberFormatSymbols_eo', 'goog.i18n.CompactNumberFormatSymbols_eo_001', 'goog.i18n.CompactNumberFormatSymbols_es_AR', 'goog.i18n.CompactNumberFormatSymbols_es_BO', 'goog.i18n.CompactNumberFormatSymbols_es_BR', 'goog.i18n.CompactNumberFormatSymbols_es_BZ', 'goog.i18n.CompactNumberFormatSymbols_es_CL', 'goog.i18n.CompactNumberFormatSymbols_es_CO', 'goog.i18n.CompactNumberFormatSymbols_es_CR', 'goog.i18n.CompactNumberFormatSymbols_es_CU', 'goog.i18n.CompactNumberFormatSymbols_es_DO', 'goog.i18n.CompactNumberFormatSymbols_es_EA', 'goog.i18n.CompactNumberFormatSymbols_es_EC', 'goog.i18n.CompactNumberFormatSymbols_es_GQ', 'goog.i18n.CompactNumberFormatSymbols_es_GT', 'goog.i18n.CompactNumberFormatSymbols_es_HN', 'goog.i18n.CompactNumberFormatSymbols_es_IC', 'goog.i18n.CompactNumberFormatSymbols_es_NI', 'goog.i18n.CompactNumberFormatSymbols_es_PA', 'goog.i18n.CompactNumberFormatSymbols_es_PE', 'goog.i18n.CompactNumberFormatSymbols_es_PH', 'goog.i18n.CompactNumberFormatSymbols_es_PR', 'goog.i18n.CompactNumberFormatSymbols_es_PY', 'goog.i18n.CompactNumberFormatSymbols_es_SV', 'goog.i18n.CompactNumberFormatSymbols_es_UY', 'goog.i18n.CompactNumberFormatSymbols_es_VE', 'goog.i18n.CompactNumberFormatSymbols_et_EE', 'goog.i18n.CompactNumberFormatSymbols_eu_ES', 'goog.i18n.CompactNumberFormatSymbols_ewo', 'goog.i18n.CompactNumberFormatSymbols_ewo_CM', 'goog.i18n.CompactNumberFormatSymbols_fa_AF', 'goog.i18n.CompactNumberFormatSymbols_fa_IR', 'goog.i18n.CompactNumberFormatSymbols_ff', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_BF', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_CM', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_GH', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_GM', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_GN', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_GW', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_LR', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_MR', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_NE', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_NG', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_SL', 'goog.i18n.CompactNumberFormatSymbols_ff_Latn_SN', 'goog.i18n.CompactNumberFormatSymbols_fi_FI', 'goog.i18n.CompactNumberFormatSymbols_fil_PH', 'goog.i18n.CompactNumberFormatSymbols_fo', 'goog.i18n.CompactNumberFormatSymbols_fo_DK', 'goog.i18n.CompactNumberFormatSymbols_fo_FO', 'goog.i18n.CompactNumberFormatSymbols_fr_BE', 'goog.i18n.CompactNumberFormatSymbols_fr_BF', 'goog.i18n.CompactNumberFormatSymbols_fr_BI', 'goog.i18n.CompactNumberFormatSymbols_fr_BJ', 'goog.i18n.CompactNumberFormatSymbols_fr_BL', 'goog.i18n.CompactNumberFormatSymbols_fr_CD', 'goog.i18n.CompactNumberFormatSymbols_fr_CF', 'goog.i18n.CompactNumberFormatSymbols_fr_CG', 'goog.i18n.CompactNumberFormatSymbols_fr_CH', 'goog.i18n.CompactNumberFormatSymbols_fr_CI', 'goog.i18n.CompactNumberFormatSymbols_fr_CM', 'goog.i18n.CompactNumberFormatSymbols_fr_DJ', 'goog.i18n.CompactNumberFormatSymbols_fr_DZ', 'goog.i18n.CompactNumberFormatSymbols_fr_FR', 'goog.i18n.CompactNumberFormatSymbols_fr_GA', 'goog.i18n.CompactNumberFormatSymbols_fr_GF', 'goog.i18n.CompactNumberFormatSymbols_fr_GN', 'goog.i18n.CompactNumberFormatSymbols_fr_GP', 'goog.i18n.CompactNumberFormatSymbols_fr_GQ', 'goog.i18n.CompactNumberFormatSymbols_fr_HT', 'goog.i18n.CompactNumberFormatSymbols_fr_KM', 'goog.i18n.CompactNumberFormatSymbols_fr_LU', 'goog.i18n.CompactNumberFormatSymbols_fr_MA', 'goog.i18n.CompactNumberFormatSymbols_fr_MC', 'goog.i18n.CompactNumberFormatSymbols_fr_MF', 'goog.i18n.CompactNumberFormatSymbols_fr_MG', 'goog.i18n.CompactNumberFormatSymbols_fr_ML', 'goog.i18n.CompactNumberFormatSymbols_fr_MQ', 'goog.i18n.CompactNumberFormatSymbols_fr_MR', 'goog.i18n.CompactNumberFormatSymbols_fr_MU', 'goog.i18n.CompactNumberFormatSymbols_fr_NC', 'goog.i18n.CompactNumberFormatSymbols_fr_NE', 'goog.i18n.CompactNumberFormatSymbols_fr_PF', 'goog.i18n.CompactNumberFormatSymbols_fr_PM', 'goog.i18n.CompactNumberFormatSymbols_fr_RE', 'goog.i18n.CompactNumberFormatSymbols_fr_RW', 'goog.i18n.CompactNumberFormatSymbols_fr_SC', 'goog.i18n.CompactNumberFormatSymbols_fr_SN', 'goog.i18n.CompactNumberFormatSymbols_fr_SY', 'goog.i18n.CompactNumberFormatSymbols_fr_TD', 'goog.i18n.CompactNumberFormatSymbols_fr_TG', 'goog.i18n.CompactNumberFormatSymbols_fr_TN', 'goog.i18n.CompactNumberFormatSymbols_fr_VU', 'goog.i18n.CompactNumberFormatSymbols_fr_WF', 'goog.i18n.CompactNumberFormatSymbols_fr_YT', 'goog.i18n.CompactNumberFormatSymbols_fur', 'goog.i18n.CompactNumberFormatSymbols_fur_IT', 'goog.i18n.CompactNumberFormatSymbols_fy', 'goog.i18n.CompactNumberFormatSymbols_fy_NL', 'goog.i18n.CompactNumberFormatSymbols_ga_IE', 'goog.i18n.CompactNumberFormatSymbols_gd', 'goog.i18n.CompactNumberFormatSymbols_gd_GB', 'goog.i18n.CompactNumberFormatSymbols_gl_ES', 'goog.i18n.CompactNumberFormatSymbols_gsw_CH', 'goog.i18n.CompactNumberFormatSymbols_gsw_FR', 'goog.i18n.CompactNumberFormatSymbols_gsw_LI', 'goog.i18n.CompactNumberFormatSymbols_gu_IN', 'goog.i18n.CompactNumberFormatSymbols_guz', 'goog.i18n.CompactNumberFormatSymbols_guz_KE', 'goog.i18n.CompactNumberFormatSymbols_gv', 'goog.i18n.CompactNumberFormatSymbols_gv_IM', 'goog.i18n.CompactNumberFormatSymbols_ha', 'goog.i18n.CompactNumberFormatSymbols_ha_GH', 'goog.i18n.CompactNumberFormatSymbols_ha_NE', 'goog.i18n.CompactNumberFormatSymbols_ha_NG', 'goog.i18n.CompactNumberFormatSymbols_haw_US', 'goog.i18n.CompactNumberFormatSymbols_he_IL', 'goog.i18n.CompactNumberFormatSymbols_hi_IN', 'goog.i18n.CompactNumberFormatSymbols_hr_BA', 'goog.i18n.CompactNumberFormatSymbols_hr_HR', 'goog.i18n.CompactNumberFormatSymbols_hsb', 'goog.i18n.CompactNumberFormatSymbols_hsb_DE', 'goog.i18n.CompactNumberFormatSymbols_hu_HU', 'goog.i18n.CompactNumberFormatSymbols_hy_AM', 'goog.i18n.CompactNumberFormatSymbols_ia', 'goog.i18n.CompactNumberFormatSymbols_ia_001', 'goog.i18n.CompactNumberFormatSymbols_id_ID', 'goog.i18n.CompactNumberFormatSymbols_ig', 'goog.i18n.CompactNumberFormatSymbols_ig_NG', 'goog.i18n.CompactNumberFormatSymbols_ii', 'goog.i18n.CompactNumberFormatSymbols_ii_CN', 'goog.i18n.CompactNumberFormatSymbols_is_IS', 'goog.i18n.CompactNumberFormatSymbols_it_CH', 'goog.i18n.CompactNumberFormatSymbols_it_IT', 'goog.i18n.CompactNumberFormatSymbols_it_SM', 'goog.i18n.CompactNumberFormatSymbols_it_VA', 'goog.i18n.CompactNumberFormatSymbols_ja_JP', 'goog.i18n.CompactNumberFormatSymbols_jgo', 'goog.i18n.CompactNumberFormatSymbols_jgo_CM', 'goog.i18n.CompactNumberFormatSymbols_jmc', 'goog.i18n.CompactNumberFormatSymbols_jmc_TZ', 'goog.i18n.CompactNumberFormatSymbols_jv', 'goog.i18n.CompactNumberFormatSymbols_jv_ID', 'goog.i18n.CompactNumberFormatSymbols_ka_GE', 'goog.i18n.CompactNumberFormatSymbols_kab', 'goog.i18n.CompactNumberFormatSymbols_kab_DZ', 'goog.i18n.CompactNumberFormatSymbols_kam', 'goog.i18n.CompactNumberFormatSymbols_kam_KE', 'goog.i18n.CompactNumberFormatSymbols_kde', 'goog.i18n.CompactNumberFormatSymbols_kde_TZ', 'goog.i18n.CompactNumberFormatSymbols_kea', 'goog.i18n.CompactNumberFormatSymbols_kea_CV', 'goog.i18n.CompactNumberFormatSymbols_khq', 'goog.i18n.CompactNumberFormatSymbols_khq_ML', 'goog.i18n.CompactNumberFormatSymbols_ki', 'goog.i18n.CompactNumberFormatSymbols_ki_KE', 'goog.i18n.CompactNumberFormatSymbols_kk_KZ', 'goog.i18n.CompactNumberFormatSymbols_kkj', 'goog.i18n.CompactNumberFormatSymbols_kkj_CM', 'goog.i18n.CompactNumberFormatSymbols_kl', 'goog.i18n.CompactNumberFormatSymbols_kl_GL', 'goog.i18n.CompactNumberFormatSymbols_kln', 'goog.i18n.CompactNumberFormatSymbols_kln_KE', 'goog.i18n.CompactNumberFormatSymbols_km_KH', 'goog.i18n.CompactNumberFormatSymbols_kn_IN', 'goog.i18n.CompactNumberFormatSymbols_ko_KP', 'goog.i18n.CompactNumberFormatSymbols_ko_KR', 'goog.i18n.CompactNumberFormatSymbols_kok', 'goog.i18n.CompactNumberFormatSymbols_kok_IN', 'goog.i18n.CompactNumberFormatSymbols_ks', 'goog.i18n.CompactNumberFormatSymbols_ks_IN', 'goog.i18n.CompactNumberFormatSymbols_ksb', 'goog.i18n.CompactNumberFormatSymbols_ksb_TZ', 'goog.i18n.CompactNumberFormatSymbols_ksf', 'goog.i18n.CompactNumberFormatSymbols_ksf_CM', 'goog.i18n.CompactNumberFormatSymbols_ksh', 'goog.i18n.CompactNumberFormatSymbols_ksh_DE', 'goog.i18n.CompactNumberFormatSymbols_ku', 'goog.i18n.CompactNumberFormatSymbols_ku_TR', 'goog.i18n.CompactNumberFormatSymbols_kw', 'goog.i18n.CompactNumberFormatSymbols_kw_GB', 'goog.i18n.CompactNumberFormatSymbols_ky_KG', 'goog.i18n.CompactNumberFormatSymbols_lag', 'goog.i18n.CompactNumberFormatSymbols_lag_TZ', 'goog.i18n.CompactNumberFormatSymbols_lb', 'goog.i18n.CompactNumberFormatSymbols_lb_LU', 'goog.i18n.CompactNumberFormatSymbols_lg', 'goog.i18n.CompactNumberFormatSymbols_lg_UG', 'goog.i18n.CompactNumberFormatSymbols_lkt', 'goog.i18n.CompactNumberFormatSymbols_lkt_US', 'goog.i18n.CompactNumberFormatSymbols_ln_AO', 'goog.i18n.CompactNumberFormatSymbols_ln_CD', 'goog.i18n.CompactNumberFormatSymbols_ln_CF', 'goog.i18n.CompactNumberFormatSymbols_ln_CG', 'goog.i18n.CompactNumberFormatSymbols_lo_LA', 'goog.i18n.CompactNumberFormatSymbols_lrc', 'goog.i18n.CompactNumberFormatSymbols_lrc_IQ', 'goog.i18n.CompactNumberFormatSymbols_lrc_IR', 'goog.i18n.CompactNumberFormatSymbols_lt_LT', 'goog.i18n.CompactNumberFormatSymbols_lu', 'goog.i18n.CompactNumberFormatSymbols_lu_CD', 'goog.i18n.CompactNumberFormatSymbols_luo', 'goog.i18n.CompactNumberFormatSymbols_luo_KE', 'goog.i18n.CompactNumberFormatSymbols_luy', 'goog.i18n.CompactNumberFormatSymbols_luy_KE', 'goog.i18n.CompactNumberFormatSymbols_lv_LV', 'goog.i18n.CompactNumberFormatSymbols_mas', 'goog.i18n.CompactNumberFormatSymbols_mas_KE', 'goog.i18n.CompactNumberFormatSymbols_mas_TZ', 'goog.i18n.CompactNumberFormatSymbols_mer', 'goog.i18n.CompactNumberFormatSymbols_mer_KE', 'goog.i18n.CompactNumberFormatSymbols_mfe', 'goog.i18n.CompactNumberFormatSymbols_mfe_MU', 'goog.i18n.CompactNumberFormatSymbols_mg', 'goog.i18n.CompactNumberFormatSymbols_mg_MG', 'goog.i18n.CompactNumberFormatSymbols_mgh', 'goog.i18n.CompactNumberFormatSymbols_mgh_MZ', 'goog.i18n.CompactNumberFormatSymbols_mgo', 'goog.i18n.CompactNumberFormatSymbols_mgo_CM', 'goog.i18n.CompactNumberFormatSymbols_mi', 'goog.i18n.CompactNumberFormatSymbols_mi_NZ', 'goog.i18n.CompactNumberFormatSymbols_mk_MK', 'goog.i18n.CompactNumberFormatSymbols_ml_IN', 'goog.i18n.CompactNumberFormatSymbols_mn_MN', 'goog.i18n.CompactNumberFormatSymbols_mr_IN', 'goog.i18n.CompactNumberFormatSymbols_ms_BN', 'goog.i18n.CompactNumberFormatSymbols_ms_MY', 'goog.i18n.CompactNumberFormatSymbols_ms_SG', 'goog.i18n.CompactNumberFormatSymbols_mt_MT', 'goog.i18n.CompactNumberFormatSymbols_mua', 'goog.i18n.CompactNumberFormatSymbols_mua_CM', 'goog.i18n.CompactNumberFormatSymbols_my_MM', 'goog.i18n.CompactNumberFormatSymbols_mzn', 'goog.i18n.CompactNumberFormatSymbols_mzn_IR', 'goog.i18n.CompactNumberFormatSymbols_naq', 'goog.i18n.CompactNumberFormatSymbols_naq_NA', 'goog.i18n.CompactNumberFormatSymbols_nb_NO', 'goog.i18n.CompactNumberFormatSymbols_nb_SJ', 'goog.i18n.CompactNumberFormatSymbols_nd', 'goog.i18n.CompactNumberFormatSymbols_nd_ZW', 'goog.i18n.CompactNumberFormatSymbols_nds', 'goog.i18n.CompactNumberFormatSymbols_nds_DE', 'goog.i18n.CompactNumberFormatSymbols_nds_NL', 'goog.i18n.CompactNumberFormatSymbols_ne_IN', 'goog.i18n.CompactNumberFormatSymbols_ne_NP', 'goog.i18n.CompactNumberFormatSymbols_nl_AW', 'goog.i18n.CompactNumberFormatSymbols_nl_BE', 'goog.i18n.CompactNumberFormatSymbols_nl_BQ', 'goog.i18n.CompactNumberFormatSymbols_nl_CW', 'goog.i18n.CompactNumberFormatSymbols_nl_NL', 'goog.i18n.CompactNumberFormatSymbols_nl_SR', 'goog.i18n.CompactNumberFormatSymbols_nl_SX', 'goog.i18n.CompactNumberFormatSymbols_nmg', 'goog.i18n.CompactNumberFormatSymbols_nmg_CM', 'goog.i18n.CompactNumberFormatSymbols_nn', 'goog.i18n.CompactNumberFormatSymbols_nn_NO', 'goog.i18n.CompactNumberFormatSymbols_nnh', 'goog.i18n.CompactNumberFormatSymbols_nnh_CM', 'goog.i18n.CompactNumberFormatSymbols_nus', 'goog.i18n.CompactNumberFormatSymbols_nus_SS', 'goog.i18n.CompactNumberFormatSymbols_nyn', 'goog.i18n.CompactNumberFormatSymbols_nyn_UG', 'goog.i18n.CompactNumberFormatSymbols_om', 'goog.i18n.CompactNumberFormatSymbols_om_ET', 'goog.i18n.CompactNumberFormatSymbols_om_KE', 'goog.i18n.CompactNumberFormatSymbols_or_IN', 'goog.i18n.CompactNumberFormatSymbols_os', 'goog.i18n.CompactNumberFormatSymbols_os_GE', 'goog.i18n.CompactNumberFormatSymbols_os_RU', 'goog.i18n.CompactNumberFormatSymbols_pa_Arab', 'goog.i18n.CompactNumberFormatSymbols_pa_Arab_PK', 'goog.i18n.CompactNumberFormatSymbols_pa_Guru', 'goog.i18n.CompactNumberFormatSymbols_pa_Guru_IN', 'goog.i18n.CompactNumberFormatSymbols_pl_PL', 'goog.i18n.CompactNumberFormatSymbols_ps', 'goog.i18n.CompactNumberFormatSymbols_ps_AF', 'goog.i18n.CompactNumberFormatSymbols_ps_PK', 'goog.i18n.CompactNumberFormatSymbols_pt_AO', 'goog.i18n.CompactNumberFormatSymbols_pt_CH', 'goog.i18n.CompactNumberFormatSymbols_pt_CV', 'goog.i18n.CompactNumberFormatSymbols_pt_GQ', 'goog.i18n.CompactNumberFormatSymbols_pt_GW', 'goog.i18n.CompactNumberFormatSymbols_pt_LU', 'goog.i18n.CompactNumberFormatSymbols_pt_MO', 'goog.i18n.CompactNumberFormatSymbols_pt_MZ', 'goog.i18n.CompactNumberFormatSymbols_pt_ST', 'goog.i18n.CompactNumberFormatSymbols_pt_TL', 'goog.i18n.CompactNumberFormatSymbols_qu', 'goog.i18n.CompactNumberFormatSymbols_qu_BO', 'goog.i18n.CompactNumberFormatSymbols_qu_EC', 'goog.i18n.CompactNumberFormatSymbols_qu_PE', 'goog.i18n.CompactNumberFormatSymbols_rm', 'goog.i18n.CompactNumberFormatSymbols_rm_CH', 'goog.i18n.CompactNumberFormatSymbols_rn', 'goog.i18n.CompactNumberFormatSymbols_rn_BI', 'goog.i18n.CompactNumberFormatSymbols_ro_MD', 'goog.i18n.CompactNumberFormatSymbols_ro_RO', 'goog.i18n.CompactNumberFormatSymbols_rof', 'goog.i18n.CompactNumberFormatSymbols_rof_TZ', 'goog.i18n.CompactNumberFormatSymbols_ru_BY', 'goog.i18n.CompactNumberFormatSymbols_ru_KG', 'goog.i18n.CompactNumberFormatSymbols_ru_KZ', 'goog.i18n.CompactNumberFormatSymbols_ru_MD', 'goog.i18n.CompactNumberFormatSymbols_ru_RU', 'goog.i18n.CompactNumberFormatSymbols_ru_UA', 'goog.i18n.CompactNumberFormatSymbols_rw', 'goog.i18n.CompactNumberFormatSymbols_rw_RW', 'goog.i18n.CompactNumberFormatSymbols_rwk', 'goog.i18n.CompactNumberFormatSymbols_rwk_TZ', 'goog.i18n.CompactNumberFormatSymbols_sah', 'goog.i18n.CompactNumberFormatSymbols_sah_RU', 'goog.i18n.CompactNumberFormatSymbols_saq', 'goog.i18n.CompactNumberFormatSymbols_saq_KE', 'goog.i18n.CompactNumberFormatSymbols_sbp', 'goog.i18n.CompactNumberFormatSymbols_sbp_TZ', 'goog.i18n.CompactNumberFormatSymbols_sd', 'goog.i18n.CompactNumberFormatSymbols_sd_PK', 'goog.i18n.CompactNumberFormatSymbols_se', 'goog.i18n.CompactNumberFormatSymbols_se_FI', 'goog.i18n.CompactNumberFormatSymbols_se_NO', 'goog.i18n.CompactNumberFormatSymbols_se_SE', 'goog.i18n.CompactNumberFormatSymbols_seh', 'goog.i18n.CompactNumberFormatSymbols_seh_MZ', 'goog.i18n.CompactNumberFormatSymbols_ses', 'goog.i18n.CompactNumberFormatSymbols_ses_ML', 'goog.i18n.CompactNumberFormatSymbols_sg', 'goog.i18n.CompactNumberFormatSymbols_sg_CF', 'goog.i18n.CompactNumberFormatSymbols_shi', 'goog.i18n.CompactNumberFormatSymbols_shi_Latn', 'goog.i18n.CompactNumberFormatSymbols_shi_Latn_MA', 'goog.i18n.CompactNumberFormatSymbols_shi_Tfng', 'goog.i18n.CompactNumberFormatSymbols_shi_Tfng_MA', 'goog.i18n.CompactNumberFormatSymbols_si_LK', 'goog.i18n.CompactNumberFormatSymbols_sk_SK', 'goog.i18n.CompactNumberFormatSymbols_sl_SI', 'goog.i18n.CompactNumberFormatSymbols_smn', 'goog.i18n.CompactNumberFormatSymbols_smn_FI', 'goog.i18n.CompactNumberFormatSymbols_sn', 'goog.i18n.CompactNumberFormatSymbols_sn_ZW', 'goog.i18n.CompactNumberFormatSymbols_so', 'goog.i18n.CompactNumberFormatSymbols_so_DJ', 'goog.i18n.CompactNumberFormatSymbols_so_ET', 'goog.i18n.CompactNumberFormatSymbols_so_KE', 'goog.i18n.CompactNumberFormatSymbols_so_SO', 'goog.i18n.CompactNumberFormatSymbols_sq_AL', 'goog.i18n.CompactNumberFormatSymbols_sq_MK', 'goog.i18n.CompactNumberFormatSymbols_sq_XK', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl_BA', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl_ME', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl_RS', 'goog.i18n.CompactNumberFormatSymbols_sr_Cyrl_XK', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn_BA', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn_ME', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn_RS', 'goog.i18n.CompactNumberFormatSymbols_sr_Latn_XK', 'goog.i18n.CompactNumberFormatSymbols_sv_AX', 'goog.i18n.CompactNumberFormatSymbols_sv_FI', 'goog.i18n.CompactNumberFormatSymbols_sv_SE', 'goog.i18n.CompactNumberFormatSymbols_sw_CD', 'goog.i18n.CompactNumberFormatSymbols_sw_KE', 'goog.i18n.CompactNumberFormatSymbols_sw_TZ', 'goog.i18n.CompactNumberFormatSymbols_sw_UG', 'goog.i18n.CompactNumberFormatSymbols_ta_IN', 'goog.i18n.CompactNumberFormatSymbols_ta_LK', 'goog.i18n.CompactNumberFormatSymbols_ta_MY', 'goog.i18n.CompactNumberFormatSymbols_ta_SG', 'goog.i18n.CompactNumberFormatSymbols_te_IN', 'goog.i18n.CompactNumberFormatSymbols_teo', 'goog.i18n.CompactNumberFormatSymbols_teo_KE', 'goog.i18n.CompactNumberFormatSymbols_teo_UG', 'goog.i18n.CompactNumberFormatSymbols_tg', 'goog.i18n.CompactNumberFormatSymbols_tg_TJ', 'goog.i18n.CompactNumberFormatSymbols_th_TH', 'goog.i18n.CompactNumberFormatSymbols_ti', 'goog.i18n.CompactNumberFormatSymbols_ti_ER', 'goog.i18n.CompactNumberFormatSymbols_ti_ET', 'goog.i18n.CompactNumberFormatSymbols_tk', 'goog.i18n.CompactNumberFormatSymbols_tk_TM', 'goog.i18n.CompactNumberFormatSymbols_to', 'goog.i18n.CompactNumberFormatSymbols_to_TO', 'goog.i18n.CompactNumberFormatSymbols_tr_CY', 'goog.i18n.CompactNumberFormatSymbols_tr_TR', 'goog.i18n.CompactNumberFormatSymbols_tt', 'goog.i18n.CompactNumberFormatSymbols_tt_RU', 'goog.i18n.CompactNumberFormatSymbols_twq', 'goog.i18n.CompactNumberFormatSymbols_twq_NE', 'goog.i18n.CompactNumberFormatSymbols_tzm', 'goog.i18n.CompactNumberFormatSymbols_tzm_MA', 'goog.i18n.CompactNumberFormatSymbols_ug', 'goog.i18n.CompactNumberFormatSymbols_ug_CN', 'goog.i18n.CompactNumberFormatSymbols_uk_UA', 'goog.i18n.CompactNumberFormatSymbols_ur_IN', 'goog.i18n.CompactNumberFormatSymbols_ur_PK', 'goog.i18n.CompactNumberFormatSymbols_uz_Arab', 'goog.i18n.CompactNumberFormatSymbols_uz_Arab_AF', 'goog.i18n.CompactNumberFormatSymbols_uz_Cyrl', 'goog.i18n.CompactNumberFormatSymbols_uz_Cyrl_UZ', 'goog.i18n.CompactNumberFormatSymbols_uz_Latn', 'goog.i18n.CompactNumberFormatSymbols_uz_Latn_UZ', 'goog.i18n.CompactNumberFormatSymbols_vai', 'goog.i18n.CompactNumberFormatSymbols_vai_Latn', 'goog.i18n.CompactNumberFormatSymbols_vai_Latn_LR', 'goog.i18n.CompactNumberFormatSymbols_vai_Vaii', 'goog.i18n.CompactNumberFormatSymbols_vai_Vaii_LR', 'goog.i18n.CompactNumberFormatSymbols_vi_VN', 'goog.i18n.CompactNumberFormatSymbols_vun', 'goog.i18n.CompactNumberFormatSymbols_vun_TZ', 'goog.i18n.CompactNumberFormatSymbols_wae', 'goog.i18n.CompactNumberFormatSymbols_wae_CH', 'goog.i18n.CompactNumberFormatSymbols_wo', 'goog.i18n.CompactNumberFormatSymbols_wo_SN', 'goog.i18n.CompactNumberFormatSymbols_xh', 'goog.i18n.CompactNumberFormatSymbols_xh_ZA', 'goog.i18n.CompactNumberFormatSymbols_xog', 'goog.i18n.CompactNumberFormatSymbols_xog_UG', 'goog.i18n.CompactNumberFormatSymbols_yav', 'goog.i18n.CompactNumberFormatSymbols_yav_CM', 'goog.i18n.CompactNumberFormatSymbols_yi', 'goog.i18n.CompactNumberFormatSymbols_yi_001', 'goog.i18n.CompactNumberFormatSymbols_yo', 'goog.i18n.CompactNumberFormatSymbols_yo_BJ', 'goog.i18n.CompactNumberFormatSymbols_yo_NG', 'goog.i18n.CompactNumberFormatSymbols_yue', 'goog.i18n.CompactNumberFormatSymbols_yue_Hans', 'goog.i18n.CompactNumberFormatSymbols_yue_Hans_CN', 'goog.i18n.CompactNumberFormatSymbols_yue_Hant', 'goog.i18n.CompactNumberFormatSymbols_yue_Hant_HK', 'goog.i18n.CompactNumberFormatSymbols_zgh', 'goog.i18n.CompactNumberFormatSymbols_zgh_MA', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans_CN', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans_HK', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans_MO', 'goog.i18n.CompactNumberFormatSymbols_zh_Hans_SG', 'goog.i18n.CompactNumberFormatSymbols_zh_Hant', 'goog.i18n.CompactNumberFormatSymbols_zh_Hant_HK', 'goog.i18n.CompactNumberFormatSymbols_zh_Hant_MO', 'goog.i18n.CompactNumberFormatSymbols_zh_Hant_TW', 'goog.i18n.CompactNumberFormatSymbols_zu_ZA'], ['goog.i18n.CompactNumberFormatSymbols'], {});
goog.addDependency('i18n/currency.js', ['goog.i18n.currency', 'goog.i18n.currency.CurrencyInfo', 'goog.i18n.currency.CurrencyInfoTier2'], [], {'lang': 'es6'});
goog.addDependency('i18n/currency_test.js', ['goog.i18n.currencyTest'], ['goog.i18n.NumberFormat', 'goog.i18n.currency', 'goog.i18n.currency.CurrencyInfo', 'goog.object', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/currencycodemap.js', ['goog.i18n.currencyCodeMap', 'goog.i18n.currencyCodeMapTier2'], [], {});
goog.addDependency('i18n/dateintervalformat.js', ['goog.i18n.DateIntervalFormat'], ['goog.array', 'goog.asserts', 'goog.date.DateLike', 'goog.date.DateRange', 'goog.date.DateTime', 'goog.date.Interval', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbolsType', 'goog.i18n.TimeZone', 'goog.i18n.dateIntervalSymbols', 'goog.object'], {'lang': 'es5', 'module': 'goog'});
goog.addDependency('i18n/dateintervalformat_test.js', ['goog.i18n.DateIntervalFormatTest'], ['goog.date.Date', 'goog.date.DateRange', 'goog.date.DateTime', 'goog.date.Interval', 'goog.i18n.DateIntervalFormat', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeSymbols_ar_EG', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_fr_CA', 'goog.i18n.DateTimeSymbols_gl', 'goog.i18n.DateTimeSymbols_hi', 'goog.i18n.DateTimeSymbols_zh', 'goog.i18n.TimeZone', 'goog.i18n.dateIntervalPatterns', 'goog.i18n.dateIntervalSymbols', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/dateintervalpatterns.js', ['goog.i18n.dateIntervalPatterns'], ['goog.i18n.dateIntervalSymbols'], {'module': 'goog'});
goog.addDependency('i18n/dateintervalpatternsext.js', ['goog.i18n.dateIntervalPatternsExt'], ['goog.i18n.dateIntervalPatterns'], {'module': 'goog'});
goog.addDependency('i18n/dateintervalsymbols.js', ['goog.i18n.dateIntervalSymbols'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/dateintervalsymbolsext.js', ['goog.i18n.dateIntervalSymbolsExt'], ['goog.i18n.dateIntervalSymbols'], {'module': 'goog'});
goog.addDependency('i18n/datetimeformat.js', ['goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeFormat.Format'], ['goog.asserts', 'goog.date', 'goog.i18n.DateTimeSymbols', 'goog.i18n.TimeZone', 'goog.string'], {});
goog.addDependency('i18n/datetimeformat_test.js', ['goog.i18n.DateTimeFormatTest'], ['goog.date.Date', 'goog.date.DateTime', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimePatterns', 'goog.i18n.DateTimePatterns_ar_EG', 'goog.i18n.DateTimePatterns_bg', 'goog.i18n.DateTimePatterns_de', 'goog.i18n.DateTimePatterns_en', 'goog.i18n.DateTimePatterns_en_XA', 'goog.i18n.DateTimePatterns_fa', 'goog.i18n.DateTimePatterns_fr', 'goog.i18n.DateTimePatterns_ja', 'goog.i18n.DateTimePatterns_sv', 'goog.i18n.DateTimePatterns_zh_HK', 'goog.i18n.DateTimePatterns_zh_Hant_TW', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbols_ar_AE', 'goog.i18n.DateTimeSymbols_ar_EG', 'goog.i18n.DateTimeSymbols_ar_SA', 'goog.i18n.DateTimeSymbols_bn_BD', 'goog.i18n.DateTimeSymbols_de', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_en_GB', 'goog.i18n.DateTimeSymbols_en_IE', 'goog.i18n.DateTimeSymbols_en_IN', 'goog.i18n.DateTimeSymbols_en_US', 'goog.i18n.DateTimeSymbols_fa', 'goog.i18n.DateTimeSymbols_fr', 'goog.i18n.DateTimeSymbols_fr_DJ', 'goog.i18n.DateTimeSymbols_he_IL', 'goog.i18n.DateTimeSymbols_ja', 'goog.i18n.DateTimeSymbols_ro_RO', 'goog.i18n.DateTimeSymbols_sv', 'goog.i18n.TimeZone', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/datetimeparse.js', ['goog.i18n.DateTimeParse'], ['goog.asserts', 'goog.date', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeSymbols'], {});
goog.addDependency('i18n/datetimeparse_test.js', ['goog.i18n.DateTimeParseTest'], ['goog.date.Date', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeParse', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_fa', 'goog.i18n.DateTimeSymbols_fr', 'goog.i18n.DateTimeSymbols_pl', 'goog.i18n.DateTimeSymbols_zh', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/datetimepatterns.js', ['goog.i18n.DateTimePatterns', 'goog.i18n.DateTimePatterns_af', 'goog.i18n.DateTimePatterns_am', 'goog.i18n.DateTimePatterns_ar', 'goog.i18n.DateTimePatterns_ar_DZ', 'goog.i18n.DateTimePatterns_ar_EG', 'goog.i18n.DateTimePatterns_az', 'goog.i18n.DateTimePatterns_be', 'goog.i18n.DateTimePatterns_bg', 'goog.i18n.DateTimePatterns_bn', 'goog.i18n.DateTimePatterns_br', 'goog.i18n.DateTimePatterns_bs', 'goog.i18n.DateTimePatterns_ca', 'goog.i18n.DateTimePatterns_chr', 'goog.i18n.DateTimePatterns_cs', 'goog.i18n.DateTimePatterns_cy', 'goog.i18n.DateTimePatterns_da', 'goog.i18n.DateTimePatterns_de', 'goog.i18n.DateTimePatterns_de_AT', 'goog.i18n.DateTimePatterns_de_CH', 'goog.i18n.DateTimePatterns_el', 'goog.i18n.DateTimePatterns_en', 'goog.i18n.DateTimePatterns_en_AU', 'goog.i18n.DateTimePatterns_en_CA', 'goog.i18n.DateTimePatterns_en_GB', 'goog.i18n.DateTimePatterns_en_IE', 'goog.i18n.DateTimePatterns_en_IN', 'goog.i18n.DateTimePatterns_en_SG', 'goog.i18n.DateTimePatterns_en_US', 'goog.i18n.DateTimePatterns_en_ZA', 'goog.i18n.DateTimePatterns_es', 'goog.i18n.DateTimePatterns_es_419', 'goog.i18n.DateTimePatterns_es_ES', 'goog.i18n.DateTimePatterns_es_MX', 'goog.i18n.DateTimePatterns_es_US', 'goog.i18n.DateTimePatterns_et', 'goog.i18n.DateTimePatterns_eu', 'goog.i18n.DateTimePatterns_fa', 'goog.i18n.DateTimePatterns_fi', 'goog.i18n.DateTimePatterns_fil', 'goog.i18n.DateTimePatterns_fr', 'goog.i18n.DateTimePatterns_fr_CA', 'goog.i18n.DateTimePatterns_ga', 'goog.i18n.DateTimePatterns_gl', 'goog.i18n.DateTimePatterns_gsw', 'goog.i18n.DateTimePatterns_gu', 'goog.i18n.DateTimePatterns_haw', 'goog.i18n.DateTimePatterns_he', 'goog.i18n.DateTimePatterns_hi', 'goog.i18n.DateTimePatterns_hr', 'goog.i18n.DateTimePatterns_hu', 'goog.i18n.DateTimePatterns_hy', 'goog.i18n.DateTimePatterns_id', 'goog.i18n.DateTimePatterns_in', 'goog.i18n.DateTimePatterns_is', 'goog.i18n.DateTimePatterns_it', 'goog.i18n.DateTimePatterns_iw', 'goog.i18n.DateTimePatterns_ja', 'goog.i18n.DateTimePatterns_ka', 'goog.i18n.DateTimePatterns_kk', 'goog.i18n.DateTimePatterns_km', 'goog.i18n.DateTimePatterns_kn', 'goog.i18n.DateTimePatterns_ko', 'goog.i18n.DateTimePatterns_ky', 'goog.i18n.DateTimePatterns_ln', 'goog.i18n.DateTimePatterns_lo', 'goog.i18n.DateTimePatterns_lt', 'goog.i18n.DateTimePatterns_lv', 'goog.i18n.DateTimePatterns_mk', 'goog.i18n.DateTimePatterns_ml', 'goog.i18n.DateTimePatterns_mn', 'goog.i18n.DateTimePatterns_mo', 'goog.i18n.DateTimePatterns_mr', 'goog.i18n.DateTimePatterns_ms', 'goog.i18n.DateTimePatterns_mt', 'goog.i18n.DateTimePatterns_my', 'goog.i18n.DateTimePatterns_nb', 'goog.i18n.DateTimePatterns_ne', 'goog.i18n.DateTimePatterns_nl', 'goog.i18n.DateTimePatterns_no', 'goog.i18n.DateTimePatterns_no_NO', 'goog.i18n.DateTimePatterns_or', 'goog.i18n.DateTimePatterns_pa', 'goog.i18n.DateTimePatterns_pl', 'goog.i18n.DateTimePatterns_pt', 'goog.i18n.DateTimePatterns_pt_BR', 'goog.i18n.DateTimePatterns_pt_PT', 'goog.i18n.DateTimePatterns_ro', 'goog.i18n.DateTimePatterns_ru', 'goog.i18n.DateTimePatterns_sh', 'goog.i18n.DateTimePatterns_si', 'goog.i18n.DateTimePatterns_sk', 'goog.i18n.DateTimePatterns_sl', 'goog.i18n.DateTimePatterns_sq', 'goog.i18n.DateTimePatterns_sr', 'goog.i18n.DateTimePatterns_sr_Latn', 'goog.i18n.DateTimePatterns_sv', 'goog.i18n.DateTimePatterns_sw', 'goog.i18n.DateTimePatterns_ta', 'goog.i18n.DateTimePatterns_te', 'goog.i18n.DateTimePatterns_th', 'goog.i18n.DateTimePatterns_tl', 'goog.i18n.DateTimePatterns_tr', 'goog.i18n.DateTimePatterns_uk', 'goog.i18n.DateTimePatterns_ur', 'goog.i18n.DateTimePatterns_uz', 'goog.i18n.DateTimePatterns_vi', 'goog.i18n.DateTimePatterns_zh', 'goog.i18n.DateTimePatterns_zh_CN', 'goog.i18n.DateTimePatterns_zh_HK', 'goog.i18n.DateTimePatterns_zh_TW', 'goog.i18n.DateTimePatterns_zu'], [], {});
goog.addDependency('i18n/datetimepatternsext.js', ['goog.i18n.DateTimePatternsExt', 'goog.i18n.DateTimePatterns_af_NA', 'goog.i18n.DateTimePatterns_af_ZA', 'goog.i18n.DateTimePatterns_agq', 'goog.i18n.DateTimePatterns_agq_CM', 'goog.i18n.DateTimePatterns_ak', 'goog.i18n.DateTimePatterns_ak_GH', 'goog.i18n.DateTimePatterns_am_ET', 'goog.i18n.DateTimePatterns_ar_001', 'goog.i18n.DateTimePatterns_ar_AE', 'goog.i18n.DateTimePatterns_ar_BH', 'goog.i18n.DateTimePatterns_ar_DJ', 'goog.i18n.DateTimePatterns_ar_EH', 'goog.i18n.DateTimePatterns_ar_ER', 'goog.i18n.DateTimePatterns_ar_IL', 'goog.i18n.DateTimePatterns_ar_IQ', 'goog.i18n.DateTimePatterns_ar_JO', 'goog.i18n.DateTimePatterns_ar_KM', 'goog.i18n.DateTimePatterns_ar_KW', 'goog.i18n.DateTimePatterns_ar_LB', 'goog.i18n.DateTimePatterns_ar_LY', 'goog.i18n.DateTimePatterns_ar_MA', 'goog.i18n.DateTimePatterns_ar_MR', 'goog.i18n.DateTimePatterns_ar_OM', 'goog.i18n.DateTimePatterns_ar_PS', 'goog.i18n.DateTimePatterns_ar_QA', 'goog.i18n.DateTimePatterns_ar_SA', 'goog.i18n.DateTimePatterns_ar_SD', 'goog.i18n.DateTimePatterns_ar_SO', 'goog.i18n.DateTimePatterns_ar_SS', 'goog.i18n.DateTimePatterns_ar_SY', 'goog.i18n.DateTimePatterns_ar_TD', 'goog.i18n.DateTimePatterns_ar_TN', 'goog.i18n.DateTimePatterns_ar_XB', 'goog.i18n.DateTimePatterns_ar_YE', 'goog.i18n.DateTimePatterns_as', 'goog.i18n.DateTimePatterns_as_IN', 'goog.i18n.DateTimePatterns_asa', 'goog.i18n.DateTimePatterns_asa_TZ', 'goog.i18n.DateTimePatterns_ast', 'goog.i18n.DateTimePatterns_ast_ES', 'goog.i18n.DateTimePatterns_az_Cyrl', 'goog.i18n.DateTimePatterns_az_Cyrl_AZ', 'goog.i18n.DateTimePatterns_az_Latn', 'goog.i18n.DateTimePatterns_az_Latn_AZ', 'goog.i18n.DateTimePatterns_bas', 'goog.i18n.DateTimePatterns_bas_CM', 'goog.i18n.DateTimePatterns_be_BY', 'goog.i18n.DateTimePatterns_bem', 'goog.i18n.DateTimePatterns_bem_ZM', 'goog.i18n.DateTimePatterns_bez', 'goog.i18n.DateTimePatterns_bez_TZ', 'goog.i18n.DateTimePatterns_bg_BG', 'goog.i18n.DateTimePatterns_bm', 'goog.i18n.DateTimePatterns_bm_ML', 'goog.i18n.DateTimePatterns_bn_BD', 'goog.i18n.DateTimePatterns_bn_IN', 'goog.i18n.DateTimePatterns_bo', 'goog.i18n.DateTimePatterns_bo_CN', 'goog.i18n.DateTimePatterns_bo_IN', 'goog.i18n.DateTimePatterns_br_FR', 'goog.i18n.DateTimePatterns_brx', 'goog.i18n.DateTimePatterns_brx_IN', 'goog.i18n.DateTimePatterns_bs_Cyrl', 'goog.i18n.DateTimePatterns_bs_Cyrl_BA', 'goog.i18n.DateTimePatterns_bs_Latn', 'goog.i18n.DateTimePatterns_bs_Latn_BA', 'goog.i18n.DateTimePatterns_ca_AD', 'goog.i18n.DateTimePatterns_ca_ES', 'goog.i18n.DateTimePatterns_ca_FR', 'goog.i18n.DateTimePatterns_ca_IT', 'goog.i18n.DateTimePatterns_ccp', 'goog.i18n.DateTimePatterns_ccp_BD', 'goog.i18n.DateTimePatterns_ccp_IN', 'goog.i18n.DateTimePatterns_ce', 'goog.i18n.DateTimePatterns_ce_RU', 'goog.i18n.DateTimePatterns_ceb', 'goog.i18n.DateTimePatterns_ceb_PH', 'goog.i18n.DateTimePatterns_cgg', 'goog.i18n.DateTimePatterns_cgg_UG', 'goog.i18n.DateTimePatterns_chr_US', 'goog.i18n.DateTimePatterns_ckb', 'goog.i18n.DateTimePatterns_ckb_IQ', 'goog.i18n.DateTimePatterns_ckb_IR', 'goog.i18n.DateTimePatterns_cs_CZ', 'goog.i18n.DateTimePatterns_cy_GB', 'goog.i18n.DateTimePatterns_da_DK', 'goog.i18n.DateTimePatterns_da_GL', 'goog.i18n.DateTimePatterns_dav', 'goog.i18n.DateTimePatterns_dav_KE', 'goog.i18n.DateTimePatterns_de_BE', 'goog.i18n.DateTimePatterns_de_DE', 'goog.i18n.DateTimePatterns_de_IT', 'goog.i18n.DateTimePatterns_de_LI', 'goog.i18n.DateTimePatterns_de_LU', 'goog.i18n.DateTimePatterns_dje', 'goog.i18n.DateTimePatterns_dje_NE', 'goog.i18n.DateTimePatterns_dsb', 'goog.i18n.DateTimePatterns_dsb_DE', 'goog.i18n.DateTimePatterns_dua', 'goog.i18n.DateTimePatterns_dua_CM', 'goog.i18n.DateTimePatterns_dyo', 'goog.i18n.DateTimePatterns_dyo_SN', 'goog.i18n.DateTimePatterns_dz', 'goog.i18n.DateTimePatterns_dz_BT', 'goog.i18n.DateTimePatterns_ebu', 'goog.i18n.DateTimePatterns_ebu_KE', 'goog.i18n.DateTimePatterns_ee', 'goog.i18n.DateTimePatterns_ee_GH', 'goog.i18n.DateTimePatterns_ee_TG', 'goog.i18n.DateTimePatterns_el_CY', 'goog.i18n.DateTimePatterns_el_GR', 'goog.i18n.DateTimePatterns_en_001', 'goog.i18n.DateTimePatterns_en_150', 'goog.i18n.DateTimePatterns_en_AE', 'goog.i18n.DateTimePatterns_en_AG', 'goog.i18n.DateTimePatterns_en_AI', 'goog.i18n.DateTimePatterns_en_AS', 'goog.i18n.DateTimePatterns_en_AT', 'goog.i18n.DateTimePatterns_en_BB', 'goog.i18n.DateTimePatterns_en_BE', 'goog.i18n.DateTimePatterns_en_BI', 'goog.i18n.DateTimePatterns_en_BM', 'goog.i18n.DateTimePatterns_en_BS', 'goog.i18n.DateTimePatterns_en_BW', 'goog.i18n.DateTimePatterns_en_BZ', 'goog.i18n.DateTimePatterns_en_CC', 'goog.i18n.DateTimePatterns_en_CH', 'goog.i18n.DateTimePatterns_en_CK', 'goog.i18n.DateTimePatterns_en_CM', 'goog.i18n.DateTimePatterns_en_CX', 'goog.i18n.DateTimePatterns_en_CY', 'goog.i18n.DateTimePatterns_en_DE', 'goog.i18n.DateTimePatterns_en_DG', 'goog.i18n.DateTimePatterns_en_DK', 'goog.i18n.DateTimePatterns_en_DM', 'goog.i18n.DateTimePatterns_en_ER', 'goog.i18n.DateTimePatterns_en_FI', 'goog.i18n.DateTimePatterns_en_FJ', 'goog.i18n.DateTimePatterns_en_FK', 'goog.i18n.DateTimePatterns_en_FM', 'goog.i18n.DateTimePatterns_en_GD', 'goog.i18n.DateTimePatterns_en_GG', 'goog.i18n.DateTimePatterns_en_GH', 'goog.i18n.DateTimePatterns_en_GI', 'goog.i18n.DateTimePatterns_en_GM', 'goog.i18n.DateTimePatterns_en_GU', 'goog.i18n.DateTimePatterns_en_GY', 'goog.i18n.DateTimePatterns_en_HK', 'goog.i18n.DateTimePatterns_en_IL', 'goog.i18n.DateTimePatterns_en_IM', 'goog.i18n.DateTimePatterns_en_IO', 'goog.i18n.DateTimePatterns_en_JE', 'goog.i18n.DateTimePatterns_en_JM', 'goog.i18n.DateTimePatterns_en_KE', 'goog.i18n.DateTimePatterns_en_KI', 'goog.i18n.DateTimePatterns_en_KN', 'goog.i18n.DateTimePatterns_en_KY', 'goog.i18n.DateTimePatterns_en_LC', 'goog.i18n.DateTimePatterns_en_LR', 'goog.i18n.DateTimePatterns_en_LS', 'goog.i18n.DateTimePatterns_en_MG', 'goog.i18n.DateTimePatterns_en_MH', 'goog.i18n.DateTimePatterns_en_MO', 'goog.i18n.DateTimePatterns_en_MP', 'goog.i18n.DateTimePatterns_en_MS', 'goog.i18n.DateTimePatterns_en_MT', 'goog.i18n.DateTimePatterns_en_MU', 'goog.i18n.DateTimePatterns_en_MW', 'goog.i18n.DateTimePatterns_en_MY', 'goog.i18n.DateTimePatterns_en_NA', 'goog.i18n.DateTimePatterns_en_NF', 'goog.i18n.DateTimePatterns_en_NG', 'goog.i18n.DateTimePatterns_en_NL', 'goog.i18n.DateTimePatterns_en_NR', 'goog.i18n.DateTimePatterns_en_NU', 'goog.i18n.DateTimePatterns_en_NZ', 'goog.i18n.DateTimePatterns_en_PG', 'goog.i18n.DateTimePatterns_en_PH', 'goog.i18n.DateTimePatterns_en_PK', 'goog.i18n.DateTimePatterns_en_PN', 'goog.i18n.DateTimePatterns_en_PR', 'goog.i18n.DateTimePatterns_en_PW', 'goog.i18n.DateTimePatterns_en_RW', 'goog.i18n.DateTimePatterns_en_SB', 'goog.i18n.DateTimePatterns_en_SC', 'goog.i18n.DateTimePatterns_en_SD', 'goog.i18n.DateTimePatterns_en_SE', 'goog.i18n.DateTimePatterns_en_SH', 'goog.i18n.DateTimePatterns_en_SI', 'goog.i18n.DateTimePatterns_en_SL', 'goog.i18n.DateTimePatterns_en_SS', 'goog.i18n.DateTimePatterns_en_SX', 'goog.i18n.DateTimePatterns_en_SZ', 'goog.i18n.DateTimePatterns_en_TC', 'goog.i18n.DateTimePatterns_en_TK', 'goog.i18n.DateTimePatterns_en_TO', 'goog.i18n.DateTimePatterns_en_TT', 'goog.i18n.DateTimePatterns_en_TV', 'goog.i18n.DateTimePatterns_en_TZ', 'goog.i18n.DateTimePatterns_en_UG', 'goog.i18n.DateTimePatterns_en_UM', 'goog.i18n.DateTimePatterns_en_US_POSIX', 'goog.i18n.DateTimePatterns_en_VC', 'goog.i18n.DateTimePatterns_en_VG', 'goog.i18n.DateTimePatterns_en_VI', 'goog.i18n.DateTimePatterns_en_VU', 'goog.i18n.DateTimePatterns_en_WS', 'goog.i18n.DateTimePatterns_en_XA', 'goog.i18n.DateTimePatterns_en_ZM', 'goog.i18n.DateTimePatterns_en_ZW', 'goog.i18n.DateTimePatterns_eo', 'goog.i18n.DateTimePatterns_eo_001', 'goog.i18n.DateTimePatterns_es_AR', 'goog.i18n.DateTimePatterns_es_BO', 'goog.i18n.DateTimePatterns_es_BR', 'goog.i18n.DateTimePatterns_es_BZ', 'goog.i18n.DateTimePatterns_es_CL', 'goog.i18n.DateTimePatterns_es_CO', 'goog.i18n.DateTimePatterns_es_CR', 'goog.i18n.DateTimePatterns_es_CU', 'goog.i18n.DateTimePatterns_es_DO', 'goog.i18n.DateTimePatterns_es_EA', 'goog.i18n.DateTimePatterns_es_EC', 'goog.i18n.DateTimePatterns_es_GQ', 'goog.i18n.DateTimePatterns_es_GT', 'goog.i18n.DateTimePatterns_es_HN', 'goog.i18n.DateTimePatterns_es_IC', 'goog.i18n.DateTimePatterns_es_NI', 'goog.i18n.DateTimePatterns_es_PA', 'goog.i18n.DateTimePatterns_es_PE', 'goog.i18n.DateTimePatterns_es_PH', 'goog.i18n.DateTimePatterns_es_PR', 'goog.i18n.DateTimePatterns_es_PY', 'goog.i18n.DateTimePatterns_es_SV', 'goog.i18n.DateTimePatterns_es_UY', 'goog.i18n.DateTimePatterns_es_VE', 'goog.i18n.DateTimePatterns_et_EE', 'goog.i18n.DateTimePatterns_eu_ES', 'goog.i18n.DateTimePatterns_ewo', 'goog.i18n.DateTimePatterns_ewo_CM', 'goog.i18n.DateTimePatterns_fa_AF', 'goog.i18n.DateTimePatterns_fa_IR', 'goog.i18n.DateTimePatterns_ff', 'goog.i18n.DateTimePatterns_ff_Latn', 'goog.i18n.DateTimePatterns_ff_Latn_BF', 'goog.i18n.DateTimePatterns_ff_Latn_CM', 'goog.i18n.DateTimePatterns_ff_Latn_GH', 'goog.i18n.DateTimePatterns_ff_Latn_GM', 'goog.i18n.DateTimePatterns_ff_Latn_GN', 'goog.i18n.DateTimePatterns_ff_Latn_GW', 'goog.i18n.DateTimePatterns_ff_Latn_LR', 'goog.i18n.DateTimePatterns_ff_Latn_MR', 'goog.i18n.DateTimePatterns_ff_Latn_NE', 'goog.i18n.DateTimePatterns_ff_Latn_NG', 'goog.i18n.DateTimePatterns_ff_Latn_SL', 'goog.i18n.DateTimePatterns_ff_Latn_SN', 'goog.i18n.DateTimePatterns_fi_FI', 'goog.i18n.DateTimePatterns_fil_PH', 'goog.i18n.DateTimePatterns_fo', 'goog.i18n.DateTimePatterns_fo_DK', 'goog.i18n.DateTimePatterns_fo_FO', 'goog.i18n.DateTimePatterns_fr_BE', 'goog.i18n.DateTimePatterns_fr_BF', 'goog.i18n.DateTimePatterns_fr_BI', 'goog.i18n.DateTimePatterns_fr_BJ', 'goog.i18n.DateTimePatterns_fr_BL', 'goog.i18n.DateTimePatterns_fr_CD', 'goog.i18n.DateTimePatterns_fr_CF', 'goog.i18n.DateTimePatterns_fr_CG', 'goog.i18n.DateTimePatterns_fr_CH', 'goog.i18n.DateTimePatterns_fr_CI', 'goog.i18n.DateTimePatterns_fr_CM', 'goog.i18n.DateTimePatterns_fr_DJ', 'goog.i18n.DateTimePatterns_fr_DZ', 'goog.i18n.DateTimePatterns_fr_FR', 'goog.i18n.DateTimePatterns_fr_GA', 'goog.i18n.DateTimePatterns_fr_GF', 'goog.i18n.DateTimePatterns_fr_GN', 'goog.i18n.DateTimePatterns_fr_GP', 'goog.i18n.DateTimePatterns_fr_GQ', 'goog.i18n.DateTimePatterns_fr_HT', 'goog.i18n.DateTimePatterns_fr_KM', 'goog.i18n.DateTimePatterns_fr_LU', 'goog.i18n.DateTimePatterns_fr_MA', 'goog.i18n.DateTimePatterns_fr_MC', 'goog.i18n.DateTimePatterns_fr_MF', 'goog.i18n.DateTimePatterns_fr_MG', 'goog.i18n.DateTimePatterns_fr_ML', 'goog.i18n.DateTimePatterns_fr_MQ', 'goog.i18n.DateTimePatterns_fr_MR', 'goog.i18n.DateTimePatterns_fr_MU', 'goog.i18n.DateTimePatterns_fr_NC', 'goog.i18n.DateTimePatterns_fr_NE', 'goog.i18n.DateTimePatterns_fr_PF', 'goog.i18n.DateTimePatterns_fr_PM', 'goog.i18n.DateTimePatterns_fr_RE', 'goog.i18n.DateTimePatterns_fr_RW', 'goog.i18n.DateTimePatterns_fr_SC', 'goog.i18n.DateTimePatterns_fr_SN', 'goog.i18n.DateTimePatterns_fr_SY', 'goog.i18n.DateTimePatterns_fr_TD', 'goog.i18n.DateTimePatterns_fr_TG', 'goog.i18n.DateTimePatterns_fr_TN', 'goog.i18n.DateTimePatterns_fr_VU', 'goog.i18n.DateTimePatterns_fr_WF', 'goog.i18n.DateTimePatterns_fr_YT', 'goog.i18n.DateTimePatterns_fur', 'goog.i18n.DateTimePatterns_fur_IT', 'goog.i18n.DateTimePatterns_fy', 'goog.i18n.DateTimePatterns_fy_NL', 'goog.i18n.DateTimePatterns_ga_IE', 'goog.i18n.DateTimePatterns_gd', 'goog.i18n.DateTimePatterns_gd_GB', 'goog.i18n.DateTimePatterns_gl_ES', 'goog.i18n.DateTimePatterns_gsw_CH', 'goog.i18n.DateTimePatterns_gsw_FR', 'goog.i18n.DateTimePatterns_gsw_LI', 'goog.i18n.DateTimePatterns_gu_IN', 'goog.i18n.DateTimePatterns_guz', 'goog.i18n.DateTimePatterns_guz_KE', 'goog.i18n.DateTimePatterns_gv', 'goog.i18n.DateTimePatterns_gv_IM', 'goog.i18n.DateTimePatterns_ha', 'goog.i18n.DateTimePatterns_ha_GH', 'goog.i18n.DateTimePatterns_ha_NE', 'goog.i18n.DateTimePatterns_ha_NG', 'goog.i18n.DateTimePatterns_haw_US', 'goog.i18n.DateTimePatterns_he_IL', 'goog.i18n.DateTimePatterns_hi_IN', 'goog.i18n.DateTimePatterns_hr_BA', 'goog.i18n.DateTimePatterns_hr_HR', 'goog.i18n.DateTimePatterns_hsb', 'goog.i18n.DateTimePatterns_hsb_DE', 'goog.i18n.DateTimePatterns_hu_HU', 'goog.i18n.DateTimePatterns_hy_AM', 'goog.i18n.DateTimePatterns_ia', 'goog.i18n.DateTimePatterns_ia_001', 'goog.i18n.DateTimePatterns_id_ID', 'goog.i18n.DateTimePatterns_ig', 'goog.i18n.DateTimePatterns_ig_NG', 'goog.i18n.DateTimePatterns_ii', 'goog.i18n.DateTimePatterns_ii_CN', 'goog.i18n.DateTimePatterns_is_IS', 'goog.i18n.DateTimePatterns_it_CH', 'goog.i18n.DateTimePatterns_it_IT', 'goog.i18n.DateTimePatterns_it_SM', 'goog.i18n.DateTimePatterns_it_VA', 'goog.i18n.DateTimePatterns_ja_JP', 'goog.i18n.DateTimePatterns_jgo', 'goog.i18n.DateTimePatterns_jgo_CM', 'goog.i18n.DateTimePatterns_jmc', 'goog.i18n.DateTimePatterns_jmc_TZ', 'goog.i18n.DateTimePatterns_jv', 'goog.i18n.DateTimePatterns_jv_ID', 'goog.i18n.DateTimePatterns_ka_GE', 'goog.i18n.DateTimePatterns_kab', 'goog.i18n.DateTimePatterns_kab_DZ', 'goog.i18n.DateTimePatterns_kam', 'goog.i18n.DateTimePatterns_kam_KE', 'goog.i18n.DateTimePatterns_kde', 'goog.i18n.DateTimePatterns_kde_TZ', 'goog.i18n.DateTimePatterns_kea', 'goog.i18n.DateTimePatterns_kea_CV', 'goog.i18n.DateTimePatterns_khq', 'goog.i18n.DateTimePatterns_khq_ML', 'goog.i18n.DateTimePatterns_ki', 'goog.i18n.DateTimePatterns_ki_KE', 'goog.i18n.DateTimePatterns_kk_KZ', 'goog.i18n.DateTimePatterns_kkj', 'goog.i18n.DateTimePatterns_kkj_CM', 'goog.i18n.DateTimePatterns_kl', 'goog.i18n.DateTimePatterns_kl_GL', 'goog.i18n.DateTimePatterns_kln', 'goog.i18n.DateTimePatterns_kln_KE', 'goog.i18n.DateTimePatterns_km_KH', 'goog.i18n.DateTimePatterns_kn_IN', 'goog.i18n.DateTimePatterns_ko_KP', 'goog.i18n.DateTimePatterns_ko_KR', 'goog.i18n.DateTimePatterns_kok', 'goog.i18n.DateTimePatterns_kok_IN', 'goog.i18n.DateTimePatterns_ks', 'goog.i18n.DateTimePatterns_ks_IN', 'goog.i18n.DateTimePatterns_ksb', 'goog.i18n.DateTimePatterns_ksb_TZ', 'goog.i18n.DateTimePatterns_ksf', 'goog.i18n.DateTimePatterns_ksf_CM', 'goog.i18n.DateTimePatterns_ksh', 'goog.i18n.DateTimePatterns_ksh_DE', 'goog.i18n.DateTimePatterns_ku', 'goog.i18n.DateTimePatterns_ku_TR', 'goog.i18n.DateTimePatterns_kw', 'goog.i18n.DateTimePatterns_kw_GB', 'goog.i18n.DateTimePatterns_ky_KG', 'goog.i18n.DateTimePatterns_lag', 'goog.i18n.DateTimePatterns_lag_TZ', 'goog.i18n.DateTimePatterns_lb', 'goog.i18n.DateTimePatterns_lb_LU', 'goog.i18n.DateTimePatterns_lg', 'goog.i18n.DateTimePatterns_lg_UG', 'goog.i18n.DateTimePatterns_lkt', 'goog.i18n.DateTimePatterns_lkt_US', 'goog.i18n.DateTimePatterns_ln_AO', 'goog.i18n.DateTimePatterns_ln_CD', 'goog.i18n.DateTimePatterns_ln_CF', 'goog.i18n.DateTimePatterns_ln_CG', 'goog.i18n.DateTimePatterns_lo_LA', 'goog.i18n.DateTimePatterns_lrc', 'goog.i18n.DateTimePatterns_lrc_IQ', 'goog.i18n.DateTimePatterns_lrc_IR', 'goog.i18n.DateTimePatterns_lt_LT', 'goog.i18n.DateTimePatterns_lu', 'goog.i18n.DateTimePatterns_lu_CD', 'goog.i18n.DateTimePatterns_luo', 'goog.i18n.DateTimePatterns_luo_KE', 'goog.i18n.DateTimePatterns_luy', 'goog.i18n.DateTimePatterns_luy_KE', 'goog.i18n.DateTimePatterns_lv_LV', 'goog.i18n.DateTimePatterns_mas', 'goog.i18n.DateTimePatterns_mas_KE', 'goog.i18n.DateTimePatterns_mas_TZ', 'goog.i18n.DateTimePatterns_mer', 'goog.i18n.DateTimePatterns_mer_KE', 'goog.i18n.DateTimePatterns_mfe', 'goog.i18n.DateTimePatterns_mfe_MU', 'goog.i18n.DateTimePatterns_mg', 'goog.i18n.DateTimePatterns_mg_MG', 'goog.i18n.DateTimePatterns_mgh', 'goog.i18n.DateTimePatterns_mgh_MZ', 'goog.i18n.DateTimePatterns_mgo', 'goog.i18n.DateTimePatterns_mgo_CM', 'goog.i18n.DateTimePatterns_mi', 'goog.i18n.DateTimePatterns_mi_NZ', 'goog.i18n.DateTimePatterns_mk_MK', 'goog.i18n.DateTimePatterns_ml_IN', 'goog.i18n.DateTimePatterns_mn_MN', 'goog.i18n.DateTimePatterns_mr_IN', 'goog.i18n.DateTimePatterns_ms_BN', 'goog.i18n.DateTimePatterns_ms_MY', 'goog.i18n.DateTimePatterns_ms_SG', 'goog.i18n.DateTimePatterns_mt_MT', 'goog.i18n.DateTimePatterns_mua', 'goog.i18n.DateTimePatterns_mua_CM', 'goog.i18n.DateTimePatterns_my_MM', 'goog.i18n.DateTimePatterns_mzn', 'goog.i18n.DateTimePatterns_mzn_IR', 'goog.i18n.DateTimePatterns_naq', 'goog.i18n.DateTimePatterns_naq_NA', 'goog.i18n.DateTimePatterns_nb_NO', 'goog.i18n.DateTimePatterns_nb_SJ', 'goog.i18n.DateTimePatterns_nd', 'goog.i18n.DateTimePatterns_nd_ZW', 'goog.i18n.DateTimePatterns_nds', 'goog.i18n.DateTimePatterns_nds_DE', 'goog.i18n.DateTimePatterns_nds_NL', 'goog.i18n.DateTimePatterns_ne_IN', 'goog.i18n.DateTimePatterns_ne_NP', 'goog.i18n.DateTimePatterns_nl_AW', 'goog.i18n.DateTimePatterns_nl_BE', 'goog.i18n.DateTimePatterns_nl_BQ', 'goog.i18n.DateTimePatterns_nl_CW', 'goog.i18n.DateTimePatterns_nl_NL', 'goog.i18n.DateTimePatterns_nl_SR', 'goog.i18n.DateTimePatterns_nl_SX', 'goog.i18n.DateTimePatterns_nmg', 'goog.i18n.DateTimePatterns_nmg_CM', 'goog.i18n.DateTimePatterns_nn', 'goog.i18n.DateTimePatterns_nn_NO', 'goog.i18n.DateTimePatterns_nnh', 'goog.i18n.DateTimePatterns_nnh_CM', 'goog.i18n.DateTimePatterns_nus', 'goog.i18n.DateTimePatterns_nus_SS', 'goog.i18n.DateTimePatterns_nyn', 'goog.i18n.DateTimePatterns_nyn_UG', 'goog.i18n.DateTimePatterns_om', 'goog.i18n.DateTimePatterns_om_ET', 'goog.i18n.DateTimePatterns_om_KE', 'goog.i18n.DateTimePatterns_or_IN', 'goog.i18n.DateTimePatterns_os', 'goog.i18n.DateTimePatterns_os_GE', 'goog.i18n.DateTimePatterns_os_RU', 'goog.i18n.DateTimePatterns_pa_Arab', 'goog.i18n.DateTimePatterns_pa_Arab_PK', 'goog.i18n.DateTimePatterns_pa_Guru', 'goog.i18n.DateTimePatterns_pa_Guru_IN', 'goog.i18n.DateTimePatterns_pl_PL', 'goog.i18n.DateTimePatterns_ps', 'goog.i18n.DateTimePatterns_ps_AF', 'goog.i18n.DateTimePatterns_ps_PK', 'goog.i18n.DateTimePatterns_pt_AO', 'goog.i18n.DateTimePatterns_pt_CH', 'goog.i18n.DateTimePatterns_pt_CV', 'goog.i18n.DateTimePatterns_pt_GQ', 'goog.i18n.DateTimePatterns_pt_GW', 'goog.i18n.DateTimePatterns_pt_LU', 'goog.i18n.DateTimePatterns_pt_MO', 'goog.i18n.DateTimePatterns_pt_MZ', 'goog.i18n.DateTimePatterns_pt_ST', 'goog.i18n.DateTimePatterns_pt_TL', 'goog.i18n.DateTimePatterns_qu', 'goog.i18n.DateTimePatterns_qu_BO', 'goog.i18n.DateTimePatterns_qu_EC', 'goog.i18n.DateTimePatterns_qu_PE', 'goog.i18n.DateTimePatterns_rm', 'goog.i18n.DateTimePatterns_rm_CH', 'goog.i18n.DateTimePatterns_rn', 'goog.i18n.DateTimePatterns_rn_BI', 'goog.i18n.DateTimePatterns_ro_MD', 'goog.i18n.DateTimePatterns_ro_RO', 'goog.i18n.DateTimePatterns_rof', 'goog.i18n.DateTimePatterns_rof_TZ', 'goog.i18n.DateTimePatterns_ru_BY', 'goog.i18n.DateTimePatterns_ru_KG', 'goog.i18n.DateTimePatterns_ru_KZ', 'goog.i18n.DateTimePatterns_ru_MD', 'goog.i18n.DateTimePatterns_ru_RU', 'goog.i18n.DateTimePatterns_ru_UA', 'goog.i18n.DateTimePatterns_rw', 'goog.i18n.DateTimePatterns_rw_RW', 'goog.i18n.DateTimePatterns_rwk', 'goog.i18n.DateTimePatterns_rwk_TZ', 'goog.i18n.DateTimePatterns_sah', 'goog.i18n.DateTimePatterns_sah_RU', 'goog.i18n.DateTimePatterns_saq', 'goog.i18n.DateTimePatterns_saq_KE', 'goog.i18n.DateTimePatterns_sbp', 'goog.i18n.DateTimePatterns_sbp_TZ', 'goog.i18n.DateTimePatterns_sd', 'goog.i18n.DateTimePatterns_sd_PK', 'goog.i18n.DateTimePatterns_se', 'goog.i18n.DateTimePatterns_se_FI', 'goog.i18n.DateTimePatterns_se_NO', 'goog.i18n.DateTimePatterns_se_SE', 'goog.i18n.DateTimePatterns_seh', 'goog.i18n.DateTimePatterns_seh_MZ', 'goog.i18n.DateTimePatterns_ses', 'goog.i18n.DateTimePatterns_ses_ML', 'goog.i18n.DateTimePatterns_sg', 'goog.i18n.DateTimePatterns_sg_CF', 'goog.i18n.DateTimePatterns_shi', 'goog.i18n.DateTimePatterns_shi_Latn', 'goog.i18n.DateTimePatterns_shi_Latn_MA', 'goog.i18n.DateTimePatterns_shi_Tfng', 'goog.i18n.DateTimePatterns_shi_Tfng_MA', 'goog.i18n.DateTimePatterns_si_LK', 'goog.i18n.DateTimePatterns_sk_SK', 'goog.i18n.DateTimePatterns_sl_SI', 'goog.i18n.DateTimePatterns_smn', 'goog.i18n.DateTimePatterns_smn_FI', 'goog.i18n.DateTimePatterns_sn', 'goog.i18n.DateTimePatterns_sn_ZW', 'goog.i18n.DateTimePatterns_so', 'goog.i18n.DateTimePatterns_so_DJ', 'goog.i18n.DateTimePatterns_so_ET', 'goog.i18n.DateTimePatterns_so_KE', 'goog.i18n.DateTimePatterns_so_SO', 'goog.i18n.DateTimePatterns_sq_AL', 'goog.i18n.DateTimePatterns_sq_MK', 'goog.i18n.DateTimePatterns_sq_XK', 'goog.i18n.DateTimePatterns_sr_Cyrl', 'goog.i18n.DateTimePatterns_sr_Cyrl_BA', 'goog.i18n.DateTimePatterns_sr_Cyrl_ME', 'goog.i18n.DateTimePatterns_sr_Cyrl_RS', 'goog.i18n.DateTimePatterns_sr_Cyrl_XK', 'goog.i18n.DateTimePatterns_sr_Latn_BA', 'goog.i18n.DateTimePatterns_sr_Latn_ME', 'goog.i18n.DateTimePatterns_sr_Latn_RS', 'goog.i18n.DateTimePatterns_sr_Latn_XK', 'goog.i18n.DateTimePatterns_sv_AX', 'goog.i18n.DateTimePatterns_sv_FI', 'goog.i18n.DateTimePatterns_sv_SE', 'goog.i18n.DateTimePatterns_sw_CD', 'goog.i18n.DateTimePatterns_sw_KE', 'goog.i18n.DateTimePatterns_sw_TZ', 'goog.i18n.DateTimePatterns_sw_UG', 'goog.i18n.DateTimePatterns_ta_IN', 'goog.i18n.DateTimePatterns_ta_LK', 'goog.i18n.DateTimePatterns_ta_MY', 'goog.i18n.DateTimePatterns_ta_SG', 'goog.i18n.DateTimePatterns_te_IN', 'goog.i18n.DateTimePatterns_teo', 'goog.i18n.DateTimePatterns_teo_KE', 'goog.i18n.DateTimePatterns_teo_UG', 'goog.i18n.DateTimePatterns_tg', 'goog.i18n.DateTimePatterns_tg_TJ', 'goog.i18n.DateTimePatterns_th_TH', 'goog.i18n.DateTimePatterns_ti', 'goog.i18n.DateTimePatterns_ti_ER', 'goog.i18n.DateTimePatterns_ti_ET', 'goog.i18n.DateTimePatterns_tk', 'goog.i18n.DateTimePatterns_tk_TM', 'goog.i18n.DateTimePatterns_to', 'goog.i18n.DateTimePatterns_to_TO', 'goog.i18n.DateTimePatterns_tr_CY', 'goog.i18n.DateTimePatterns_tr_TR', 'goog.i18n.DateTimePatterns_tt', 'goog.i18n.DateTimePatterns_tt_RU', 'goog.i18n.DateTimePatterns_twq', 'goog.i18n.DateTimePatterns_twq_NE', 'goog.i18n.DateTimePatterns_tzm', 'goog.i18n.DateTimePatterns_tzm_MA', 'goog.i18n.DateTimePatterns_ug', 'goog.i18n.DateTimePatterns_ug_CN', 'goog.i18n.DateTimePatterns_uk_UA', 'goog.i18n.DateTimePatterns_ur_IN', 'goog.i18n.DateTimePatterns_ur_PK', 'goog.i18n.DateTimePatterns_uz_Arab', 'goog.i18n.DateTimePatterns_uz_Arab_AF', 'goog.i18n.DateTimePatterns_uz_Cyrl', 'goog.i18n.DateTimePatterns_uz_Cyrl_UZ', 'goog.i18n.DateTimePatterns_uz_Latn', 'goog.i18n.DateTimePatterns_uz_Latn_UZ', 'goog.i18n.DateTimePatterns_vai', 'goog.i18n.DateTimePatterns_vai_Latn', 'goog.i18n.DateTimePatterns_vai_Latn_LR', 'goog.i18n.DateTimePatterns_vai_Vaii', 'goog.i18n.DateTimePatterns_vai_Vaii_LR', 'goog.i18n.DateTimePatterns_vi_VN', 'goog.i18n.DateTimePatterns_vun', 'goog.i18n.DateTimePatterns_vun_TZ', 'goog.i18n.DateTimePatterns_wae', 'goog.i18n.DateTimePatterns_wae_CH', 'goog.i18n.DateTimePatterns_wo', 'goog.i18n.DateTimePatterns_wo_SN', 'goog.i18n.DateTimePatterns_xh', 'goog.i18n.DateTimePatterns_xh_ZA', 'goog.i18n.DateTimePatterns_xog', 'goog.i18n.DateTimePatterns_xog_UG', 'goog.i18n.DateTimePatterns_yav', 'goog.i18n.DateTimePatterns_yav_CM', 'goog.i18n.DateTimePatterns_yi', 'goog.i18n.DateTimePatterns_yi_001', 'goog.i18n.DateTimePatterns_yo', 'goog.i18n.DateTimePatterns_yo_BJ', 'goog.i18n.DateTimePatterns_yo_NG', 'goog.i18n.DateTimePatterns_yue', 'goog.i18n.DateTimePatterns_yue_Hans', 'goog.i18n.DateTimePatterns_yue_Hans_CN', 'goog.i18n.DateTimePatterns_yue_Hant', 'goog.i18n.DateTimePatterns_yue_Hant_HK', 'goog.i18n.DateTimePatterns_zgh', 'goog.i18n.DateTimePatterns_zgh_MA', 'goog.i18n.DateTimePatterns_zh_Hans', 'goog.i18n.DateTimePatterns_zh_Hans_CN', 'goog.i18n.DateTimePatterns_zh_Hans_HK', 'goog.i18n.DateTimePatterns_zh_Hans_MO', 'goog.i18n.DateTimePatterns_zh_Hans_SG', 'goog.i18n.DateTimePatterns_zh_Hant', 'goog.i18n.DateTimePatterns_zh_Hant_HK', 'goog.i18n.DateTimePatterns_zh_Hant_MO', 'goog.i18n.DateTimePatterns_zh_Hant_TW', 'goog.i18n.DateTimePatterns_zu_ZA'], ['goog.i18n.DateTimePatterns'], {});
goog.addDependency('i18n/datetimesymbols.js', ['goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbolsType', 'goog.i18n.DateTimeSymbols_af', 'goog.i18n.DateTimeSymbols_am', 'goog.i18n.DateTimeSymbols_ar', 'goog.i18n.DateTimeSymbols_ar_DZ', 'goog.i18n.DateTimeSymbols_ar_EG', 'goog.i18n.DateTimeSymbols_az', 'goog.i18n.DateTimeSymbols_be', 'goog.i18n.DateTimeSymbols_bg', 'goog.i18n.DateTimeSymbols_bn', 'goog.i18n.DateTimeSymbols_br', 'goog.i18n.DateTimeSymbols_bs', 'goog.i18n.DateTimeSymbols_ca', 'goog.i18n.DateTimeSymbols_chr', 'goog.i18n.DateTimeSymbols_cs', 'goog.i18n.DateTimeSymbols_cy', 'goog.i18n.DateTimeSymbols_da', 'goog.i18n.DateTimeSymbols_de', 'goog.i18n.DateTimeSymbols_de_AT', 'goog.i18n.DateTimeSymbols_de_CH', 'goog.i18n.DateTimeSymbols_el', 'goog.i18n.DateTimeSymbols_en', 'goog.i18n.DateTimeSymbols_en_AU', 'goog.i18n.DateTimeSymbols_en_CA', 'goog.i18n.DateTimeSymbols_en_GB', 'goog.i18n.DateTimeSymbols_en_IE', 'goog.i18n.DateTimeSymbols_en_IN', 'goog.i18n.DateTimeSymbols_en_ISO', 'goog.i18n.DateTimeSymbols_en_SG', 'goog.i18n.DateTimeSymbols_en_US', 'goog.i18n.DateTimeSymbols_en_ZA', 'goog.i18n.DateTimeSymbols_es', 'goog.i18n.DateTimeSymbols_es_419', 'goog.i18n.DateTimeSymbols_es_ES', 'goog.i18n.DateTimeSymbols_es_MX', 'goog.i18n.DateTimeSymbols_es_US', 'goog.i18n.DateTimeSymbols_et', 'goog.i18n.DateTimeSymbols_eu', 'goog.i18n.DateTimeSymbols_fa', 'goog.i18n.DateTimeSymbols_fi', 'goog.i18n.DateTimeSymbols_fil', 'goog.i18n.DateTimeSymbols_fr', 'goog.i18n.DateTimeSymbols_fr_CA', 'goog.i18n.DateTimeSymbols_ga', 'goog.i18n.DateTimeSymbols_gl', 'goog.i18n.DateTimeSymbols_gsw', 'goog.i18n.DateTimeSymbols_gu', 'goog.i18n.DateTimeSymbols_haw', 'goog.i18n.DateTimeSymbols_he', 'goog.i18n.DateTimeSymbols_hi', 'goog.i18n.DateTimeSymbols_hr', 'goog.i18n.DateTimeSymbols_hu', 'goog.i18n.DateTimeSymbols_hy', 'goog.i18n.DateTimeSymbols_id', 'goog.i18n.DateTimeSymbols_in', 'goog.i18n.DateTimeSymbols_is', 'goog.i18n.DateTimeSymbols_it', 'goog.i18n.DateTimeSymbols_iw', 'goog.i18n.DateTimeSymbols_ja', 'goog.i18n.DateTimeSymbols_ka', 'goog.i18n.DateTimeSymbols_kk', 'goog.i18n.DateTimeSymbols_km', 'goog.i18n.DateTimeSymbols_kn', 'goog.i18n.DateTimeSymbols_ko', 'goog.i18n.DateTimeSymbols_ky', 'goog.i18n.DateTimeSymbols_ln', 'goog.i18n.DateTimeSymbols_lo', 'goog.i18n.DateTimeSymbols_lt', 'goog.i18n.DateTimeSymbols_lv', 'goog.i18n.DateTimeSymbols_mk', 'goog.i18n.DateTimeSymbols_ml', 'goog.i18n.DateTimeSymbols_mn', 'goog.i18n.DateTimeSymbols_mo', 'goog.i18n.DateTimeSymbols_mr', 'goog.i18n.DateTimeSymbols_ms', 'goog.i18n.DateTimeSymbols_mt', 'goog.i18n.DateTimeSymbols_my', 'goog.i18n.DateTimeSymbols_nb', 'goog.i18n.DateTimeSymbols_ne', 'goog.i18n.DateTimeSymbols_nl', 'goog.i18n.DateTimeSymbols_no', 'goog.i18n.DateTimeSymbols_no_NO', 'goog.i18n.DateTimeSymbols_or', 'goog.i18n.DateTimeSymbols_pa', 'goog.i18n.DateTimeSymbols_pl', 'goog.i18n.DateTimeSymbols_pt', 'goog.i18n.DateTimeSymbols_pt_BR', 'goog.i18n.DateTimeSymbols_pt_PT', 'goog.i18n.DateTimeSymbols_ro', 'goog.i18n.DateTimeSymbols_ru', 'goog.i18n.DateTimeSymbols_sh', 'goog.i18n.DateTimeSymbols_si', 'goog.i18n.DateTimeSymbols_sk', 'goog.i18n.DateTimeSymbols_sl', 'goog.i18n.DateTimeSymbols_sq', 'goog.i18n.DateTimeSymbols_sr', 'goog.i18n.DateTimeSymbols_sr_Latn', 'goog.i18n.DateTimeSymbols_sv', 'goog.i18n.DateTimeSymbols_sw', 'goog.i18n.DateTimeSymbols_ta', 'goog.i18n.DateTimeSymbols_te', 'goog.i18n.DateTimeSymbols_th', 'goog.i18n.DateTimeSymbols_tl', 'goog.i18n.DateTimeSymbols_tr', 'goog.i18n.DateTimeSymbols_uk', 'goog.i18n.DateTimeSymbols_ur', 'goog.i18n.DateTimeSymbols_uz', 'goog.i18n.DateTimeSymbols_vi', 'goog.i18n.DateTimeSymbols_zh', 'goog.i18n.DateTimeSymbols_zh_CN', 'goog.i18n.DateTimeSymbols_zh_HK', 'goog.i18n.DateTimeSymbols_zh_TW', 'goog.i18n.DateTimeSymbols_zu'], [], {});
goog.addDependency('i18n/datetimesymbolsext.js', ['goog.i18n.DateTimeSymbolsExt', 'goog.i18n.DateTimeSymbols_af_NA', 'goog.i18n.DateTimeSymbols_af_ZA', 'goog.i18n.DateTimeSymbols_agq', 'goog.i18n.DateTimeSymbols_agq_CM', 'goog.i18n.DateTimeSymbols_ak', 'goog.i18n.DateTimeSymbols_ak_GH', 'goog.i18n.DateTimeSymbols_am_ET', 'goog.i18n.DateTimeSymbols_ar_001', 'goog.i18n.DateTimeSymbols_ar_AE', 'goog.i18n.DateTimeSymbols_ar_BH', 'goog.i18n.DateTimeSymbols_ar_DJ', 'goog.i18n.DateTimeSymbols_ar_EH', 'goog.i18n.DateTimeSymbols_ar_ER', 'goog.i18n.DateTimeSymbols_ar_IL', 'goog.i18n.DateTimeSymbols_ar_IQ', 'goog.i18n.DateTimeSymbols_ar_JO', 'goog.i18n.DateTimeSymbols_ar_KM', 'goog.i18n.DateTimeSymbols_ar_KW', 'goog.i18n.DateTimeSymbols_ar_LB', 'goog.i18n.DateTimeSymbols_ar_LY', 'goog.i18n.DateTimeSymbols_ar_MA', 'goog.i18n.DateTimeSymbols_ar_MR', 'goog.i18n.DateTimeSymbols_ar_OM', 'goog.i18n.DateTimeSymbols_ar_PS', 'goog.i18n.DateTimeSymbols_ar_QA', 'goog.i18n.DateTimeSymbols_ar_SA', 'goog.i18n.DateTimeSymbols_ar_SD', 'goog.i18n.DateTimeSymbols_ar_SO', 'goog.i18n.DateTimeSymbols_ar_SS', 'goog.i18n.DateTimeSymbols_ar_SY', 'goog.i18n.DateTimeSymbols_ar_TD', 'goog.i18n.DateTimeSymbols_ar_TN', 'goog.i18n.DateTimeSymbols_ar_XB', 'goog.i18n.DateTimeSymbols_ar_YE', 'goog.i18n.DateTimeSymbols_as', 'goog.i18n.DateTimeSymbols_as_IN', 'goog.i18n.DateTimeSymbols_asa', 'goog.i18n.DateTimeSymbols_asa_TZ', 'goog.i18n.DateTimeSymbols_ast', 'goog.i18n.DateTimeSymbols_ast_ES', 'goog.i18n.DateTimeSymbols_az_Cyrl', 'goog.i18n.DateTimeSymbols_az_Cyrl_AZ', 'goog.i18n.DateTimeSymbols_az_Latn', 'goog.i18n.DateTimeSymbols_az_Latn_AZ', 'goog.i18n.DateTimeSymbols_bas', 'goog.i18n.DateTimeSymbols_bas_CM', 'goog.i18n.DateTimeSymbols_be_BY', 'goog.i18n.DateTimeSymbols_bem', 'goog.i18n.DateTimeSymbols_bem_ZM', 'goog.i18n.DateTimeSymbols_bez', 'goog.i18n.DateTimeSymbols_bez_TZ', 'goog.i18n.DateTimeSymbols_bg_BG', 'goog.i18n.DateTimeSymbols_bm', 'goog.i18n.DateTimeSymbols_bm_ML', 'goog.i18n.DateTimeSymbols_bn_BD', 'goog.i18n.DateTimeSymbols_bn_IN', 'goog.i18n.DateTimeSymbols_bo', 'goog.i18n.DateTimeSymbols_bo_CN', 'goog.i18n.DateTimeSymbols_bo_IN', 'goog.i18n.DateTimeSymbols_br_FR', 'goog.i18n.DateTimeSymbols_brx', 'goog.i18n.DateTimeSymbols_brx_IN', 'goog.i18n.DateTimeSymbols_bs_Cyrl', 'goog.i18n.DateTimeSymbols_bs_Cyrl_BA', 'goog.i18n.DateTimeSymbols_bs_Latn', 'goog.i18n.DateTimeSymbols_bs_Latn_BA', 'goog.i18n.DateTimeSymbols_ca_AD', 'goog.i18n.DateTimeSymbols_ca_ES', 'goog.i18n.DateTimeSymbols_ca_FR', 'goog.i18n.DateTimeSymbols_ca_IT', 'goog.i18n.DateTimeSymbols_ccp', 'goog.i18n.DateTimeSymbols_ccp_BD', 'goog.i18n.DateTimeSymbols_ccp_IN', 'goog.i18n.DateTimeSymbols_ce', 'goog.i18n.DateTimeSymbols_ce_RU', 'goog.i18n.DateTimeSymbols_ceb', 'goog.i18n.DateTimeSymbols_ceb_PH', 'goog.i18n.DateTimeSymbols_cgg', 'goog.i18n.DateTimeSymbols_cgg_UG', 'goog.i18n.DateTimeSymbols_chr_US', 'goog.i18n.DateTimeSymbols_ckb', 'goog.i18n.DateTimeSymbols_ckb_IQ', 'goog.i18n.DateTimeSymbols_ckb_IR', 'goog.i18n.DateTimeSymbols_cs_CZ', 'goog.i18n.DateTimeSymbols_cy_GB', 'goog.i18n.DateTimeSymbols_da_DK', 'goog.i18n.DateTimeSymbols_da_GL', 'goog.i18n.DateTimeSymbols_dav', 'goog.i18n.DateTimeSymbols_dav_KE', 'goog.i18n.DateTimeSymbols_de_BE', 'goog.i18n.DateTimeSymbols_de_DE', 'goog.i18n.DateTimeSymbols_de_IT', 'goog.i18n.DateTimeSymbols_de_LI', 'goog.i18n.DateTimeSymbols_de_LU', 'goog.i18n.DateTimeSymbols_dje', 'goog.i18n.DateTimeSymbols_dje_NE', 'goog.i18n.DateTimeSymbols_dsb', 'goog.i18n.DateTimeSymbols_dsb_DE', 'goog.i18n.DateTimeSymbols_dua', 'goog.i18n.DateTimeSymbols_dua_CM', 'goog.i18n.DateTimeSymbols_dyo', 'goog.i18n.DateTimeSymbols_dyo_SN', 'goog.i18n.DateTimeSymbols_dz', 'goog.i18n.DateTimeSymbols_dz_BT', 'goog.i18n.DateTimeSymbols_ebu', 'goog.i18n.DateTimeSymbols_ebu_KE', 'goog.i18n.DateTimeSymbols_ee', 'goog.i18n.DateTimeSymbols_ee_GH', 'goog.i18n.DateTimeSymbols_ee_TG', 'goog.i18n.DateTimeSymbols_el_CY', 'goog.i18n.DateTimeSymbols_el_GR', 'goog.i18n.DateTimeSymbols_en_001', 'goog.i18n.DateTimeSymbols_en_150', 'goog.i18n.DateTimeSymbols_en_AE', 'goog.i18n.DateTimeSymbols_en_AG', 'goog.i18n.DateTimeSymbols_en_AI', 'goog.i18n.DateTimeSymbols_en_AS', 'goog.i18n.DateTimeSymbols_en_AT', 'goog.i18n.DateTimeSymbols_en_BB', 'goog.i18n.DateTimeSymbols_en_BE', 'goog.i18n.DateTimeSymbols_en_BI', 'goog.i18n.DateTimeSymbols_en_BM', 'goog.i18n.DateTimeSymbols_en_BS', 'goog.i18n.DateTimeSymbols_en_BW', 'goog.i18n.DateTimeSymbols_en_BZ', 'goog.i18n.DateTimeSymbols_en_CC', 'goog.i18n.DateTimeSymbols_en_CH', 'goog.i18n.DateTimeSymbols_en_CK', 'goog.i18n.DateTimeSymbols_en_CM', 'goog.i18n.DateTimeSymbols_en_CX', 'goog.i18n.DateTimeSymbols_en_CY', 'goog.i18n.DateTimeSymbols_en_DE', 'goog.i18n.DateTimeSymbols_en_DG', 'goog.i18n.DateTimeSymbols_en_DK', 'goog.i18n.DateTimeSymbols_en_DM', 'goog.i18n.DateTimeSymbols_en_ER', 'goog.i18n.DateTimeSymbols_en_FI', 'goog.i18n.DateTimeSymbols_en_FJ', 'goog.i18n.DateTimeSymbols_en_FK', 'goog.i18n.DateTimeSymbols_en_FM', 'goog.i18n.DateTimeSymbols_en_GD', 'goog.i18n.DateTimeSymbols_en_GG', 'goog.i18n.DateTimeSymbols_en_GH', 'goog.i18n.DateTimeSymbols_en_GI', 'goog.i18n.DateTimeSymbols_en_GM', 'goog.i18n.DateTimeSymbols_en_GU', 'goog.i18n.DateTimeSymbols_en_GY', 'goog.i18n.DateTimeSymbols_en_HK', 'goog.i18n.DateTimeSymbols_en_IL', 'goog.i18n.DateTimeSymbols_en_IM', 'goog.i18n.DateTimeSymbols_en_IO', 'goog.i18n.DateTimeSymbols_en_JE', 'goog.i18n.DateTimeSymbols_en_JM', 'goog.i18n.DateTimeSymbols_en_KE', 'goog.i18n.DateTimeSymbols_en_KI', 'goog.i18n.DateTimeSymbols_en_KN', 'goog.i18n.DateTimeSymbols_en_KY', 'goog.i18n.DateTimeSymbols_en_LC', 'goog.i18n.DateTimeSymbols_en_LR', 'goog.i18n.DateTimeSymbols_en_LS', 'goog.i18n.DateTimeSymbols_en_MG', 'goog.i18n.DateTimeSymbols_en_MH', 'goog.i18n.DateTimeSymbols_en_MO', 'goog.i18n.DateTimeSymbols_en_MP', 'goog.i18n.DateTimeSymbols_en_MS', 'goog.i18n.DateTimeSymbols_en_MT', 'goog.i18n.DateTimeSymbols_en_MU', 'goog.i18n.DateTimeSymbols_en_MW', 'goog.i18n.DateTimeSymbols_en_MY', 'goog.i18n.DateTimeSymbols_en_NA', 'goog.i18n.DateTimeSymbols_en_NF', 'goog.i18n.DateTimeSymbols_en_NG', 'goog.i18n.DateTimeSymbols_en_NL', 'goog.i18n.DateTimeSymbols_en_NR', 'goog.i18n.DateTimeSymbols_en_NU', 'goog.i18n.DateTimeSymbols_en_NZ', 'goog.i18n.DateTimeSymbols_en_PG', 'goog.i18n.DateTimeSymbols_en_PH', 'goog.i18n.DateTimeSymbols_en_PK', 'goog.i18n.DateTimeSymbols_en_PN', 'goog.i18n.DateTimeSymbols_en_PR', 'goog.i18n.DateTimeSymbols_en_PW', 'goog.i18n.DateTimeSymbols_en_RW', 'goog.i18n.DateTimeSymbols_en_SB', 'goog.i18n.DateTimeSymbols_en_SC', 'goog.i18n.DateTimeSymbols_en_SD', 'goog.i18n.DateTimeSymbols_en_SE', 'goog.i18n.DateTimeSymbols_en_SH', 'goog.i18n.DateTimeSymbols_en_SI', 'goog.i18n.DateTimeSymbols_en_SL', 'goog.i18n.DateTimeSymbols_en_SS', 'goog.i18n.DateTimeSymbols_en_SX', 'goog.i18n.DateTimeSymbols_en_SZ', 'goog.i18n.DateTimeSymbols_en_TC', 'goog.i18n.DateTimeSymbols_en_TK', 'goog.i18n.DateTimeSymbols_en_TO', 'goog.i18n.DateTimeSymbols_en_TT', 'goog.i18n.DateTimeSymbols_en_TV', 'goog.i18n.DateTimeSymbols_en_TZ', 'goog.i18n.DateTimeSymbols_en_UG', 'goog.i18n.DateTimeSymbols_en_UM', 'goog.i18n.DateTimeSymbols_en_US_POSIX', 'goog.i18n.DateTimeSymbols_en_VC', 'goog.i18n.DateTimeSymbols_en_VG', 'goog.i18n.DateTimeSymbols_en_VI', 'goog.i18n.DateTimeSymbols_en_VU', 'goog.i18n.DateTimeSymbols_en_WS', 'goog.i18n.DateTimeSymbols_en_XA', 'goog.i18n.DateTimeSymbols_en_ZM', 'goog.i18n.DateTimeSymbols_en_ZW', 'goog.i18n.DateTimeSymbols_eo', 'goog.i18n.DateTimeSymbols_eo_001', 'goog.i18n.DateTimeSymbols_es_AR', 'goog.i18n.DateTimeSymbols_es_BO', 'goog.i18n.DateTimeSymbols_es_BR', 'goog.i18n.DateTimeSymbols_es_BZ', 'goog.i18n.DateTimeSymbols_es_CL', 'goog.i18n.DateTimeSymbols_es_CO', 'goog.i18n.DateTimeSymbols_es_CR', 'goog.i18n.DateTimeSymbols_es_CU', 'goog.i18n.DateTimeSymbols_es_DO', 'goog.i18n.DateTimeSymbols_es_EA', 'goog.i18n.DateTimeSymbols_es_EC', 'goog.i18n.DateTimeSymbols_es_GQ', 'goog.i18n.DateTimeSymbols_es_GT', 'goog.i18n.DateTimeSymbols_es_HN', 'goog.i18n.DateTimeSymbols_es_IC', 'goog.i18n.DateTimeSymbols_es_NI', 'goog.i18n.DateTimeSymbols_es_PA', 'goog.i18n.DateTimeSymbols_es_PE', 'goog.i18n.DateTimeSymbols_es_PH', 'goog.i18n.DateTimeSymbols_es_PR', 'goog.i18n.DateTimeSymbols_es_PY', 'goog.i18n.DateTimeSymbols_es_SV', 'goog.i18n.DateTimeSymbols_es_UY', 'goog.i18n.DateTimeSymbols_es_VE', 'goog.i18n.DateTimeSymbols_et_EE', 'goog.i18n.DateTimeSymbols_eu_ES', 'goog.i18n.DateTimeSymbols_ewo', 'goog.i18n.DateTimeSymbols_ewo_CM', 'goog.i18n.DateTimeSymbols_fa_AF', 'goog.i18n.DateTimeSymbols_fa_IR', 'goog.i18n.DateTimeSymbols_ff', 'goog.i18n.DateTimeSymbols_ff_Latn', 'goog.i18n.DateTimeSymbols_ff_Latn_BF', 'goog.i18n.DateTimeSymbols_ff_Latn_CM', 'goog.i18n.DateTimeSymbols_ff_Latn_GH', 'goog.i18n.DateTimeSymbols_ff_Latn_GM', 'goog.i18n.DateTimeSymbols_ff_Latn_GN', 'goog.i18n.DateTimeSymbols_ff_Latn_GW', 'goog.i18n.DateTimeSymbols_ff_Latn_LR', 'goog.i18n.DateTimeSymbols_ff_Latn_MR', 'goog.i18n.DateTimeSymbols_ff_Latn_NE', 'goog.i18n.DateTimeSymbols_ff_Latn_NG', 'goog.i18n.DateTimeSymbols_ff_Latn_SL', 'goog.i18n.DateTimeSymbols_ff_Latn_SN', 'goog.i18n.DateTimeSymbols_fi_FI', 'goog.i18n.DateTimeSymbols_fil_PH', 'goog.i18n.DateTimeSymbols_fo', 'goog.i18n.DateTimeSymbols_fo_DK', 'goog.i18n.DateTimeSymbols_fo_FO', 'goog.i18n.DateTimeSymbols_fr_BE', 'goog.i18n.DateTimeSymbols_fr_BF', 'goog.i18n.DateTimeSymbols_fr_BI', 'goog.i18n.DateTimeSymbols_fr_BJ', 'goog.i18n.DateTimeSymbols_fr_BL', 'goog.i18n.DateTimeSymbols_fr_CD', 'goog.i18n.DateTimeSymbols_fr_CF', 'goog.i18n.DateTimeSymbols_fr_CG', 'goog.i18n.DateTimeSymbols_fr_CH', 'goog.i18n.DateTimeSymbols_fr_CI', 'goog.i18n.DateTimeSymbols_fr_CM', 'goog.i18n.DateTimeSymbols_fr_DJ', 'goog.i18n.DateTimeSymbols_fr_DZ', 'goog.i18n.DateTimeSymbols_fr_FR', 'goog.i18n.DateTimeSymbols_fr_GA', 'goog.i18n.DateTimeSymbols_fr_GF', 'goog.i18n.DateTimeSymbols_fr_GN', 'goog.i18n.DateTimeSymbols_fr_GP', 'goog.i18n.DateTimeSymbols_fr_GQ', 'goog.i18n.DateTimeSymbols_fr_HT', 'goog.i18n.DateTimeSymbols_fr_KM', 'goog.i18n.DateTimeSymbols_fr_LU', 'goog.i18n.DateTimeSymbols_fr_MA', 'goog.i18n.DateTimeSymbols_fr_MC', 'goog.i18n.DateTimeSymbols_fr_MF', 'goog.i18n.DateTimeSymbols_fr_MG', 'goog.i18n.DateTimeSymbols_fr_ML', 'goog.i18n.DateTimeSymbols_fr_MQ', 'goog.i18n.DateTimeSymbols_fr_MR', 'goog.i18n.DateTimeSymbols_fr_MU', 'goog.i18n.DateTimeSymbols_fr_NC', 'goog.i18n.DateTimeSymbols_fr_NE', 'goog.i18n.DateTimeSymbols_fr_PF', 'goog.i18n.DateTimeSymbols_fr_PM', 'goog.i18n.DateTimeSymbols_fr_RE', 'goog.i18n.DateTimeSymbols_fr_RW', 'goog.i18n.DateTimeSymbols_fr_SC', 'goog.i18n.DateTimeSymbols_fr_SN', 'goog.i18n.DateTimeSymbols_fr_SY', 'goog.i18n.DateTimeSymbols_fr_TD', 'goog.i18n.DateTimeSymbols_fr_TG', 'goog.i18n.DateTimeSymbols_fr_TN', 'goog.i18n.DateTimeSymbols_fr_VU', 'goog.i18n.DateTimeSymbols_fr_WF', 'goog.i18n.DateTimeSymbols_fr_YT', 'goog.i18n.DateTimeSymbols_fur', 'goog.i18n.DateTimeSymbols_fur_IT', 'goog.i18n.DateTimeSymbols_fy', 'goog.i18n.DateTimeSymbols_fy_NL', 'goog.i18n.DateTimeSymbols_ga_IE', 'goog.i18n.DateTimeSymbols_gd', 'goog.i18n.DateTimeSymbols_gd_GB', 'goog.i18n.DateTimeSymbols_gl_ES', 'goog.i18n.DateTimeSymbols_gsw_CH', 'goog.i18n.DateTimeSymbols_gsw_FR', 'goog.i18n.DateTimeSymbols_gsw_LI', 'goog.i18n.DateTimeSymbols_gu_IN', 'goog.i18n.DateTimeSymbols_guz', 'goog.i18n.DateTimeSymbols_guz_KE', 'goog.i18n.DateTimeSymbols_gv', 'goog.i18n.DateTimeSymbols_gv_IM', 'goog.i18n.DateTimeSymbols_ha', 'goog.i18n.DateTimeSymbols_ha_GH', 'goog.i18n.DateTimeSymbols_ha_NE', 'goog.i18n.DateTimeSymbols_ha_NG', 'goog.i18n.DateTimeSymbols_haw_US', 'goog.i18n.DateTimeSymbols_he_IL', 'goog.i18n.DateTimeSymbols_hi_IN', 'goog.i18n.DateTimeSymbols_hr_BA', 'goog.i18n.DateTimeSymbols_hr_HR', 'goog.i18n.DateTimeSymbols_hsb', 'goog.i18n.DateTimeSymbols_hsb_DE', 'goog.i18n.DateTimeSymbols_hu_HU', 'goog.i18n.DateTimeSymbols_hy_AM', 'goog.i18n.DateTimeSymbols_ia', 'goog.i18n.DateTimeSymbols_ia_001', 'goog.i18n.DateTimeSymbols_id_ID', 'goog.i18n.DateTimeSymbols_ig', 'goog.i18n.DateTimeSymbols_ig_NG', 'goog.i18n.DateTimeSymbols_ii', 'goog.i18n.DateTimeSymbols_ii_CN', 'goog.i18n.DateTimeSymbols_is_IS', 'goog.i18n.DateTimeSymbols_it_CH', 'goog.i18n.DateTimeSymbols_it_IT', 'goog.i18n.DateTimeSymbols_it_SM', 'goog.i18n.DateTimeSymbols_it_VA', 'goog.i18n.DateTimeSymbols_ja_JP', 'goog.i18n.DateTimeSymbols_jgo', 'goog.i18n.DateTimeSymbols_jgo_CM', 'goog.i18n.DateTimeSymbols_jmc', 'goog.i18n.DateTimeSymbols_jmc_TZ', 'goog.i18n.DateTimeSymbols_jv', 'goog.i18n.DateTimeSymbols_jv_ID', 'goog.i18n.DateTimeSymbols_ka_GE', 'goog.i18n.DateTimeSymbols_kab', 'goog.i18n.DateTimeSymbols_kab_DZ', 'goog.i18n.DateTimeSymbols_kam', 'goog.i18n.DateTimeSymbols_kam_KE', 'goog.i18n.DateTimeSymbols_kde', 'goog.i18n.DateTimeSymbols_kde_TZ', 'goog.i18n.DateTimeSymbols_kea', 'goog.i18n.DateTimeSymbols_kea_CV', 'goog.i18n.DateTimeSymbols_khq', 'goog.i18n.DateTimeSymbols_khq_ML', 'goog.i18n.DateTimeSymbols_ki', 'goog.i18n.DateTimeSymbols_ki_KE', 'goog.i18n.DateTimeSymbols_kk_KZ', 'goog.i18n.DateTimeSymbols_kkj', 'goog.i18n.DateTimeSymbols_kkj_CM', 'goog.i18n.DateTimeSymbols_kl', 'goog.i18n.DateTimeSymbols_kl_GL', 'goog.i18n.DateTimeSymbols_kln', 'goog.i18n.DateTimeSymbols_kln_KE', 'goog.i18n.DateTimeSymbols_km_KH', 'goog.i18n.DateTimeSymbols_kn_IN', 'goog.i18n.DateTimeSymbols_ko_KP', 'goog.i18n.DateTimeSymbols_ko_KR', 'goog.i18n.DateTimeSymbols_kok', 'goog.i18n.DateTimeSymbols_kok_IN', 'goog.i18n.DateTimeSymbols_ks', 'goog.i18n.DateTimeSymbols_ks_IN', 'goog.i18n.DateTimeSymbols_ksb', 'goog.i18n.DateTimeSymbols_ksb_TZ', 'goog.i18n.DateTimeSymbols_ksf', 'goog.i18n.DateTimeSymbols_ksf_CM', 'goog.i18n.DateTimeSymbols_ksh', 'goog.i18n.DateTimeSymbols_ksh_DE', 'goog.i18n.DateTimeSymbols_ku', 'goog.i18n.DateTimeSymbols_ku_TR', 'goog.i18n.DateTimeSymbols_kw', 'goog.i18n.DateTimeSymbols_kw_GB', 'goog.i18n.DateTimeSymbols_ky_KG', 'goog.i18n.DateTimeSymbols_lag', 'goog.i18n.DateTimeSymbols_lag_TZ', 'goog.i18n.DateTimeSymbols_lb', 'goog.i18n.DateTimeSymbols_lb_LU', 'goog.i18n.DateTimeSymbols_lg', 'goog.i18n.DateTimeSymbols_lg_UG', 'goog.i18n.DateTimeSymbols_lkt', 'goog.i18n.DateTimeSymbols_lkt_US', 'goog.i18n.DateTimeSymbols_ln_AO', 'goog.i18n.DateTimeSymbols_ln_CD', 'goog.i18n.DateTimeSymbols_ln_CF', 'goog.i18n.DateTimeSymbols_ln_CG', 'goog.i18n.DateTimeSymbols_lo_LA', 'goog.i18n.DateTimeSymbols_lrc', 'goog.i18n.DateTimeSymbols_lrc_IQ', 'goog.i18n.DateTimeSymbols_lrc_IR', 'goog.i18n.DateTimeSymbols_lt_LT', 'goog.i18n.DateTimeSymbols_lu', 'goog.i18n.DateTimeSymbols_lu_CD', 'goog.i18n.DateTimeSymbols_luo', 'goog.i18n.DateTimeSymbols_luo_KE', 'goog.i18n.DateTimeSymbols_luy', 'goog.i18n.DateTimeSymbols_luy_KE', 'goog.i18n.DateTimeSymbols_lv_LV', 'goog.i18n.DateTimeSymbols_mas', 'goog.i18n.DateTimeSymbols_mas_KE', 'goog.i18n.DateTimeSymbols_mas_TZ', 'goog.i18n.DateTimeSymbols_mer', 'goog.i18n.DateTimeSymbols_mer_KE', 'goog.i18n.DateTimeSymbols_mfe', 'goog.i18n.DateTimeSymbols_mfe_MU', 'goog.i18n.DateTimeSymbols_mg', 'goog.i18n.DateTimeSymbols_mg_MG', 'goog.i18n.DateTimeSymbols_mgh', 'goog.i18n.DateTimeSymbols_mgh_MZ', 'goog.i18n.DateTimeSymbols_mgo', 'goog.i18n.DateTimeSymbols_mgo_CM', 'goog.i18n.DateTimeSymbols_mi', 'goog.i18n.DateTimeSymbols_mi_NZ', 'goog.i18n.DateTimeSymbols_mk_MK', 'goog.i18n.DateTimeSymbols_ml_IN', 'goog.i18n.DateTimeSymbols_mn_MN', 'goog.i18n.DateTimeSymbols_mr_IN', 'goog.i18n.DateTimeSymbols_ms_BN', 'goog.i18n.DateTimeSymbols_ms_MY', 'goog.i18n.DateTimeSymbols_ms_SG', 'goog.i18n.DateTimeSymbols_mt_MT', 'goog.i18n.DateTimeSymbols_mua', 'goog.i18n.DateTimeSymbols_mua_CM', 'goog.i18n.DateTimeSymbols_my_MM', 'goog.i18n.DateTimeSymbols_mzn', 'goog.i18n.DateTimeSymbols_mzn_IR', 'goog.i18n.DateTimeSymbols_naq', 'goog.i18n.DateTimeSymbols_naq_NA', 'goog.i18n.DateTimeSymbols_nb_NO', 'goog.i18n.DateTimeSymbols_nb_SJ', 'goog.i18n.DateTimeSymbols_nd', 'goog.i18n.DateTimeSymbols_nd_ZW', 'goog.i18n.DateTimeSymbols_nds', 'goog.i18n.DateTimeSymbols_nds_DE', 'goog.i18n.DateTimeSymbols_nds_NL', 'goog.i18n.DateTimeSymbols_ne_IN', 'goog.i18n.DateTimeSymbols_ne_NP', 'goog.i18n.DateTimeSymbols_nl_AW', 'goog.i18n.DateTimeSymbols_nl_BE', 'goog.i18n.DateTimeSymbols_nl_BQ', 'goog.i18n.DateTimeSymbols_nl_CW', 'goog.i18n.DateTimeSymbols_nl_NL', 'goog.i18n.DateTimeSymbols_nl_SR', 'goog.i18n.DateTimeSymbols_nl_SX', 'goog.i18n.DateTimeSymbols_nmg', 'goog.i18n.DateTimeSymbols_nmg_CM', 'goog.i18n.DateTimeSymbols_nn', 'goog.i18n.DateTimeSymbols_nn_NO', 'goog.i18n.DateTimeSymbols_nnh', 'goog.i18n.DateTimeSymbols_nnh_CM', 'goog.i18n.DateTimeSymbols_nus', 'goog.i18n.DateTimeSymbols_nus_SS', 'goog.i18n.DateTimeSymbols_nyn', 'goog.i18n.DateTimeSymbols_nyn_UG', 'goog.i18n.DateTimeSymbols_om', 'goog.i18n.DateTimeSymbols_om_ET', 'goog.i18n.DateTimeSymbols_om_KE', 'goog.i18n.DateTimeSymbols_or_IN', 'goog.i18n.DateTimeSymbols_os', 'goog.i18n.DateTimeSymbols_os_GE', 'goog.i18n.DateTimeSymbols_os_RU', 'goog.i18n.DateTimeSymbols_pa_Arab', 'goog.i18n.DateTimeSymbols_pa_Arab_PK', 'goog.i18n.DateTimeSymbols_pa_Guru', 'goog.i18n.DateTimeSymbols_pa_Guru_IN', 'goog.i18n.DateTimeSymbols_pl_PL', 'goog.i18n.DateTimeSymbols_ps', 'goog.i18n.DateTimeSymbols_ps_AF', 'goog.i18n.DateTimeSymbols_ps_PK', 'goog.i18n.DateTimeSymbols_pt_AO', 'goog.i18n.DateTimeSymbols_pt_CH', 'goog.i18n.DateTimeSymbols_pt_CV', 'goog.i18n.DateTimeSymbols_pt_GQ', 'goog.i18n.DateTimeSymbols_pt_GW', 'goog.i18n.DateTimeSymbols_pt_LU', 'goog.i18n.DateTimeSymbols_pt_MO', 'goog.i18n.DateTimeSymbols_pt_MZ', 'goog.i18n.DateTimeSymbols_pt_ST', 'goog.i18n.DateTimeSymbols_pt_TL', 'goog.i18n.DateTimeSymbols_qu', 'goog.i18n.DateTimeSymbols_qu_BO', 'goog.i18n.DateTimeSymbols_qu_EC', 'goog.i18n.DateTimeSymbols_qu_PE', 'goog.i18n.DateTimeSymbols_rm', 'goog.i18n.DateTimeSymbols_rm_CH', 'goog.i18n.DateTimeSymbols_rn', 'goog.i18n.DateTimeSymbols_rn_BI', 'goog.i18n.DateTimeSymbols_ro_MD', 'goog.i18n.DateTimeSymbols_ro_RO', 'goog.i18n.DateTimeSymbols_rof', 'goog.i18n.DateTimeSymbols_rof_TZ', 'goog.i18n.DateTimeSymbols_ru_BY', 'goog.i18n.DateTimeSymbols_ru_KG', 'goog.i18n.DateTimeSymbols_ru_KZ', 'goog.i18n.DateTimeSymbols_ru_MD', 'goog.i18n.DateTimeSymbols_ru_RU', 'goog.i18n.DateTimeSymbols_ru_UA', 'goog.i18n.DateTimeSymbols_rw', 'goog.i18n.DateTimeSymbols_rw_RW', 'goog.i18n.DateTimeSymbols_rwk', 'goog.i18n.DateTimeSymbols_rwk_TZ', 'goog.i18n.DateTimeSymbols_sah', 'goog.i18n.DateTimeSymbols_sah_RU', 'goog.i18n.DateTimeSymbols_saq', 'goog.i18n.DateTimeSymbols_saq_KE', 'goog.i18n.DateTimeSymbols_sbp', 'goog.i18n.DateTimeSymbols_sbp_TZ', 'goog.i18n.DateTimeSymbols_sd', 'goog.i18n.DateTimeSymbols_sd_PK', 'goog.i18n.DateTimeSymbols_se', 'goog.i18n.DateTimeSymbols_se_FI', 'goog.i18n.DateTimeSymbols_se_NO', 'goog.i18n.DateTimeSymbols_se_SE', 'goog.i18n.DateTimeSymbols_seh', 'goog.i18n.DateTimeSymbols_seh_MZ', 'goog.i18n.DateTimeSymbols_ses', 'goog.i18n.DateTimeSymbols_ses_ML', 'goog.i18n.DateTimeSymbols_sg', 'goog.i18n.DateTimeSymbols_sg_CF', 'goog.i18n.DateTimeSymbols_shi', 'goog.i18n.DateTimeSymbols_shi_Latn', 'goog.i18n.DateTimeSymbols_shi_Latn_MA', 'goog.i18n.DateTimeSymbols_shi_Tfng', 'goog.i18n.DateTimeSymbols_shi_Tfng_MA', 'goog.i18n.DateTimeSymbols_si_LK', 'goog.i18n.DateTimeSymbols_sk_SK', 'goog.i18n.DateTimeSymbols_sl_SI', 'goog.i18n.DateTimeSymbols_smn', 'goog.i18n.DateTimeSymbols_smn_FI', 'goog.i18n.DateTimeSymbols_sn', 'goog.i18n.DateTimeSymbols_sn_ZW', 'goog.i18n.DateTimeSymbols_so', 'goog.i18n.DateTimeSymbols_so_DJ', 'goog.i18n.DateTimeSymbols_so_ET', 'goog.i18n.DateTimeSymbols_so_KE', 'goog.i18n.DateTimeSymbols_so_SO', 'goog.i18n.DateTimeSymbols_sq_AL', 'goog.i18n.DateTimeSymbols_sq_MK', 'goog.i18n.DateTimeSymbols_sq_XK', 'goog.i18n.DateTimeSymbols_sr_Cyrl', 'goog.i18n.DateTimeSymbols_sr_Cyrl_BA', 'goog.i18n.DateTimeSymbols_sr_Cyrl_ME', 'goog.i18n.DateTimeSymbols_sr_Cyrl_RS', 'goog.i18n.DateTimeSymbols_sr_Cyrl_XK', 'goog.i18n.DateTimeSymbols_sr_Latn_BA', 'goog.i18n.DateTimeSymbols_sr_Latn_ME', 'goog.i18n.DateTimeSymbols_sr_Latn_RS', 'goog.i18n.DateTimeSymbols_sr_Latn_XK', 'goog.i18n.DateTimeSymbols_sv_AX', 'goog.i18n.DateTimeSymbols_sv_FI', 'goog.i18n.DateTimeSymbols_sv_SE', 'goog.i18n.DateTimeSymbols_sw_CD', 'goog.i18n.DateTimeSymbols_sw_KE', 'goog.i18n.DateTimeSymbols_sw_TZ', 'goog.i18n.DateTimeSymbols_sw_UG', 'goog.i18n.DateTimeSymbols_ta_IN', 'goog.i18n.DateTimeSymbols_ta_LK', 'goog.i18n.DateTimeSymbols_ta_MY', 'goog.i18n.DateTimeSymbols_ta_SG', 'goog.i18n.DateTimeSymbols_te_IN', 'goog.i18n.DateTimeSymbols_teo', 'goog.i18n.DateTimeSymbols_teo_KE', 'goog.i18n.DateTimeSymbols_teo_UG', 'goog.i18n.DateTimeSymbols_tg', 'goog.i18n.DateTimeSymbols_tg_TJ', 'goog.i18n.DateTimeSymbols_th_TH', 'goog.i18n.DateTimeSymbols_ti', 'goog.i18n.DateTimeSymbols_ti_ER', 'goog.i18n.DateTimeSymbols_ti_ET', 'goog.i18n.DateTimeSymbols_tk', 'goog.i18n.DateTimeSymbols_tk_TM', 'goog.i18n.DateTimeSymbols_to', 'goog.i18n.DateTimeSymbols_to_TO', 'goog.i18n.DateTimeSymbols_tr_CY', 'goog.i18n.DateTimeSymbols_tr_TR', 'goog.i18n.DateTimeSymbols_tt', 'goog.i18n.DateTimeSymbols_tt_RU', 'goog.i18n.DateTimeSymbols_twq', 'goog.i18n.DateTimeSymbols_twq_NE', 'goog.i18n.DateTimeSymbols_tzm', 'goog.i18n.DateTimeSymbols_tzm_MA', 'goog.i18n.DateTimeSymbols_ug', 'goog.i18n.DateTimeSymbols_ug_CN', 'goog.i18n.DateTimeSymbols_uk_UA', 'goog.i18n.DateTimeSymbols_ur_IN', 'goog.i18n.DateTimeSymbols_ur_PK', 'goog.i18n.DateTimeSymbols_uz_Arab', 'goog.i18n.DateTimeSymbols_uz_Arab_AF', 'goog.i18n.DateTimeSymbols_uz_Cyrl', 'goog.i18n.DateTimeSymbols_uz_Cyrl_UZ', 'goog.i18n.DateTimeSymbols_uz_Latn', 'goog.i18n.DateTimeSymbols_uz_Latn_UZ', 'goog.i18n.DateTimeSymbols_vai', 'goog.i18n.DateTimeSymbols_vai_Latn', 'goog.i18n.DateTimeSymbols_vai_Latn_LR', 'goog.i18n.DateTimeSymbols_vai_Vaii', 'goog.i18n.DateTimeSymbols_vai_Vaii_LR', 'goog.i18n.DateTimeSymbols_vi_VN', 'goog.i18n.DateTimeSymbols_vun', 'goog.i18n.DateTimeSymbols_vun_TZ', 'goog.i18n.DateTimeSymbols_wae', 'goog.i18n.DateTimeSymbols_wae_CH', 'goog.i18n.DateTimeSymbols_wo', 'goog.i18n.DateTimeSymbols_wo_SN', 'goog.i18n.DateTimeSymbols_xh', 'goog.i18n.DateTimeSymbols_xh_ZA', 'goog.i18n.DateTimeSymbols_xog', 'goog.i18n.DateTimeSymbols_xog_UG', 'goog.i18n.DateTimeSymbols_yav', 'goog.i18n.DateTimeSymbols_yav_CM', 'goog.i18n.DateTimeSymbols_yi', 'goog.i18n.DateTimeSymbols_yi_001', 'goog.i18n.DateTimeSymbols_yo', 'goog.i18n.DateTimeSymbols_yo_BJ', 'goog.i18n.DateTimeSymbols_yo_NG', 'goog.i18n.DateTimeSymbols_yue', 'goog.i18n.DateTimeSymbols_yue_Hans', 'goog.i18n.DateTimeSymbols_yue_Hans_CN', 'goog.i18n.DateTimeSymbols_yue_Hant', 'goog.i18n.DateTimeSymbols_yue_Hant_HK', 'goog.i18n.DateTimeSymbols_zgh', 'goog.i18n.DateTimeSymbols_zgh_MA', 'goog.i18n.DateTimeSymbols_zh_Hans', 'goog.i18n.DateTimeSymbols_zh_Hans_CN', 'goog.i18n.DateTimeSymbols_zh_Hans_HK', 'goog.i18n.DateTimeSymbols_zh_Hans_MO', 'goog.i18n.DateTimeSymbols_zh_Hans_SG', 'goog.i18n.DateTimeSymbols_zh_Hant', 'goog.i18n.DateTimeSymbols_zh_Hant_HK', 'goog.i18n.DateTimeSymbols_zh_Hant_MO', 'goog.i18n.DateTimeSymbols_zh_Hant_TW', 'goog.i18n.DateTimeSymbols_zu_ZA'], ['goog.i18n.DateTimeSymbols'], {});
goog.addDependency('i18n/graphemebreak.js', ['goog.i18n.GraphemeBreak'], ['goog.asserts', 'goog.i18n.uChar', 'goog.structs.InversionMap'], {});
goog.addDependency('i18n/graphemebreak_test.js', ['goog.i18n.GraphemeBreakTest'], ['goog.i18n.GraphemeBreak', 'goog.i18n.uChar', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/localefeature.js', ['goog.i18n.LocaleFeature'], [], {'module': 'goog'});
goog.addDependency('i18n/localefeature_test.js', ['goog.i18n.LocaleFeatureTest'], ['goog.i18n.LocaleFeature', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/messageformat.js', ['goog.i18n.MessageFormat'], ['goog.array', 'goog.asserts', 'goog.i18n.CompactNumberFormatSymbols', 'goog.i18n.NumberFormat', 'goog.i18n.NumberFormatSymbols', 'goog.i18n.ordinalRules', 'goog.i18n.pluralRules'], {});
goog.addDependency('i18n/messageformat_test.js', ['goog.i18n.MessageFormatTest'], ['goog.i18n.MessageFormat', 'goog.i18n.NumberFormatSymbols_hr', 'goog.i18n.pluralRules', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/mime.js', ['goog.i18n.mime', 'goog.i18n.mime.encode'], ['goog.array', 'goog.i18n.uChar'], {});
goog.addDependency('i18n/mime_test.js', ['goog.i18n.mime.encodeTest'], ['goog.i18n.mime.encode', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/numberformat.js', ['goog.i18n.NumberFormat', 'goog.i18n.NumberFormat.CurrencyStyle', 'goog.i18n.NumberFormat.Format'], ['goog.asserts', 'goog.i18n.CompactNumberFormatSymbols', 'goog.i18n.NumberFormatSymbols', 'goog.i18n.NumberFormatSymbols_u_nu_latn', 'goog.i18n.currency', 'goog.math', 'goog.string'], {});
goog.addDependency('i18n/numberformat_test.js', ['goog.i18n.NumberFormatTest'], ['goog.i18n.CompactNumberFormatSymbols', 'goog.i18n.CompactNumberFormatSymbols_de', 'goog.i18n.CompactNumberFormatSymbols_en', 'goog.i18n.CompactNumberFormatSymbols_fr', 'goog.i18n.NumberFormat', 'goog.i18n.NumberFormatSymbols', 'goog.i18n.NumberFormatSymbols_ar_EG', 'goog.i18n.NumberFormatSymbols_ar_EG_u_nu_latn', 'goog.i18n.NumberFormatSymbols_de', 'goog.i18n.NumberFormatSymbols_en', 'goog.i18n.NumberFormatSymbols_en_AU', 'goog.i18n.NumberFormatSymbols_en_US', 'goog.i18n.NumberFormatSymbols_fi', 'goog.i18n.NumberFormatSymbols_fr', 'goog.i18n.NumberFormatSymbols_pl', 'goog.i18n.NumberFormatSymbols_ro', 'goog.i18n.NumberFormatSymbols_u_nu_latn', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/numberformatsymbols.js', ['goog.i18n.NumberFormatSymbols', 'goog.i18n.NumberFormatSymbols_af', 'goog.i18n.NumberFormatSymbols_am', 'goog.i18n.NumberFormatSymbols_ar', 'goog.i18n.NumberFormatSymbols_ar_DZ', 'goog.i18n.NumberFormatSymbols_ar_EG', 'goog.i18n.NumberFormatSymbols_ar_EG_u_nu_latn', 'goog.i18n.NumberFormatSymbols_az', 'goog.i18n.NumberFormatSymbols_be', 'goog.i18n.NumberFormatSymbols_bg', 'goog.i18n.NumberFormatSymbols_bn', 'goog.i18n.NumberFormatSymbols_bn_u_nu_latn', 'goog.i18n.NumberFormatSymbols_br', 'goog.i18n.NumberFormatSymbols_bs', 'goog.i18n.NumberFormatSymbols_ca', 'goog.i18n.NumberFormatSymbols_chr', 'goog.i18n.NumberFormatSymbols_cs', 'goog.i18n.NumberFormatSymbols_cy', 'goog.i18n.NumberFormatSymbols_da', 'goog.i18n.NumberFormatSymbols_de', 'goog.i18n.NumberFormatSymbols_de_AT', 'goog.i18n.NumberFormatSymbols_de_CH', 'goog.i18n.NumberFormatSymbols_el', 'goog.i18n.NumberFormatSymbols_en', 'goog.i18n.NumberFormatSymbols_en_AU', 'goog.i18n.NumberFormatSymbols_en_CA', 'goog.i18n.NumberFormatSymbols_en_GB', 'goog.i18n.NumberFormatSymbols_en_IE', 'goog.i18n.NumberFormatSymbols_en_IN', 'goog.i18n.NumberFormatSymbols_en_SG', 'goog.i18n.NumberFormatSymbols_en_US', 'goog.i18n.NumberFormatSymbols_en_ZA', 'goog.i18n.NumberFormatSymbols_es', 'goog.i18n.NumberFormatSymbols_es_419', 'goog.i18n.NumberFormatSymbols_es_ES', 'goog.i18n.NumberFormatSymbols_es_MX', 'goog.i18n.NumberFormatSymbols_es_US', 'goog.i18n.NumberFormatSymbols_et', 'goog.i18n.NumberFormatSymbols_eu', 'goog.i18n.NumberFormatSymbols_fa', 'goog.i18n.NumberFormatSymbols_fa_u_nu_latn', 'goog.i18n.NumberFormatSymbols_fi', 'goog.i18n.NumberFormatSymbols_fil', 'goog.i18n.NumberFormatSymbols_fr', 'goog.i18n.NumberFormatSymbols_fr_CA', 'goog.i18n.NumberFormatSymbols_ga', 'goog.i18n.NumberFormatSymbols_gl', 'goog.i18n.NumberFormatSymbols_gsw', 'goog.i18n.NumberFormatSymbols_gu', 'goog.i18n.NumberFormatSymbols_haw', 'goog.i18n.NumberFormatSymbols_he', 'goog.i18n.NumberFormatSymbols_hi', 'goog.i18n.NumberFormatSymbols_hr', 'goog.i18n.NumberFormatSymbols_hu', 'goog.i18n.NumberFormatSymbols_hy', 'goog.i18n.NumberFormatSymbols_id', 'goog.i18n.NumberFormatSymbols_in', 'goog.i18n.NumberFormatSymbols_is', 'goog.i18n.NumberFormatSymbols_it', 'goog.i18n.NumberFormatSymbols_iw', 'goog.i18n.NumberFormatSymbols_ja', 'goog.i18n.NumberFormatSymbols_ka', 'goog.i18n.NumberFormatSymbols_kk', 'goog.i18n.NumberFormatSymbols_km', 'goog.i18n.NumberFormatSymbols_kn', 'goog.i18n.NumberFormatSymbols_ko', 'goog.i18n.NumberFormatSymbols_ky', 'goog.i18n.NumberFormatSymbols_ln', 'goog.i18n.NumberFormatSymbols_lo', 'goog.i18n.NumberFormatSymbols_lt', 'goog.i18n.NumberFormatSymbols_lv', 'goog.i18n.NumberFormatSymbols_mk', 'goog.i18n.NumberFormatSymbols_ml', 'goog.i18n.NumberFormatSymbols_mn', 'goog.i18n.NumberFormatSymbols_mo', 'goog.i18n.NumberFormatSymbols_mr', 'goog.i18n.NumberFormatSymbols_mr_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ms', 'goog.i18n.NumberFormatSymbols_mt', 'goog.i18n.NumberFormatSymbols_my', 'goog.i18n.NumberFormatSymbols_my_u_nu_latn', 'goog.i18n.NumberFormatSymbols_nb', 'goog.i18n.NumberFormatSymbols_ne', 'goog.i18n.NumberFormatSymbols_ne_u_nu_latn', 'goog.i18n.NumberFormatSymbols_nl', 'goog.i18n.NumberFormatSymbols_no', 'goog.i18n.NumberFormatSymbols_no_NO', 'goog.i18n.NumberFormatSymbols_or', 'goog.i18n.NumberFormatSymbols_pa', 'goog.i18n.NumberFormatSymbols_pl', 'goog.i18n.NumberFormatSymbols_pt', 'goog.i18n.NumberFormatSymbols_pt_BR', 'goog.i18n.NumberFormatSymbols_pt_PT', 'goog.i18n.NumberFormatSymbols_ro', 'goog.i18n.NumberFormatSymbols_ru', 'goog.i18n.NumberFormatSymbols_sh', 'goog.i18n.NumberFormatSymbols_si', 'goog.i18n.NumberFormatSymbols_sk', 'goog.i18n.NumberFormatSymbols_sl', 'goog.i18n.NumberFormatSymbols_sq', 'goog.i18n.NumberFormatSymbols_sr', 'goog.i18n.NumberFormatSymbols_sr_Latn', 'goog.i18n.NumberFormatSymbols_sv', 'goog.i18n.NumberFormatSymbols_sw', 'goog.i18n.NumberFormatSymbols_ta', 'goog.i18n.NumberFormatSymbols_te', 'goog.i18n.NumberFormatSymbols_th', 'goog.i18n.NumberFormatSymbols_tl', 'goog.i18n.NumberFormatSymbols_tr', 'goog.i18n.NumberFormatSymbols_u_nu_latn', 'goog.i18n.NumberFormatSymbols_uk', 'goog.i18n.NumberFormatSymbols_ur', 'goog.i18n.NumberFormatSymbols_uz', 'goog.i18n.NumberFormatSymbols_vi', 'goog.i18n.NumberFormatSymbols_zh', 'goog.i18n.NumberFormatSymbols_zh_CN', 'goog.i18n.NumberFormatSymbols_zh_HK', 'goog.i18n.NumberFormatSymbols_zh_TW', 'goog.i18n.NumberFormatSymbols_zu'], [], {});
goog.addDependency('i18n/numberformatsymbolsext.js', ['goog.i18n.NumberFormatSymbolsExt', 'goog.i18n.NumberFormatSymbols_af_NA', 'goog.i18n.NumberFormatSymbols_af_ZA', 'goog.i18n.NumberFormatSymbols_agq', 'goog.i18n.NumberFormatSymbols_agq_CM', 'goog.i18n.NumberFormatSymbols_ak', 'goog.i18n.NumberFormatSymbols_ak_GH', 'goog.i18n.NumberFormatSymbols_am_ET', 'goog.i18n.NumberFormatSymbols_ar_001', 'goog.i18n.NumberFormatSymbols_ar_AE', 'goog.i18n.NumberFormatSymbols_ar_AE_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_BH', 'goog.i18n.NumberFormatSymbols_ar_BH_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_DJ', 'goog.i18n.NumberFormatSymbols_ar_DJ_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_EH', 'goog.i18n.NumberFormatSymbols_ar_ER', 'goog.i18n.NumberFormatSymbols_ar_ER_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_IL', 'goog.i18n.NumberFormatSymbols_ar_IL_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_IQ', 'goog.i18n.NumberFormatSymbols_ar_IQ_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_JO', 'goog.i18n.NumberFormatSymbols_ar_JO_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_KM', 'goog.i18n.NumberFormatSymbols_ar_KM_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_KW', 'goog.i18n.NumberFormatSymbols_ar_KW_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_LB', 'goog.i18n.NumberFormatSymbols_ar_LB_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_LY', 'goog.i18n.NumberFormatSymbols_ar_MA', 'goog.i18n.NumberFormatSymbols_ar_MR', 'goog.i18n.NumberFormatSymbols_ar_MR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_OM', 'goog.i18n.NumberFormatSymbols_ar_OM_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_PS', 'goog.i18n.NumberFormatSymbols_ar_PS_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_QA', 'goog.i18n.NumberFormatSymbols_ar_QA_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SA', 'goog.i18n.NumberFormatSymbols_ar_SA_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SD', 'goog.i18n.NumberFormatSymbols_ar_SD_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SO', 'goog.i18n.NumberFormatSymbols_ar_SO_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SS', 'goog.i18n.NumberFormatSymbols_ar_SS_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_SY', 'goog.i18n.NumberFormatSymbols_ar_SY_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_TD', 'goog.i18n.NumberFormatSymbols_ar_TD_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ar_TN', 'goog.i18n.NumberFormatSymbols_ar_XB', 'goog.i18n.NumberFormatSymbols_ar_YE', 'goog.i18n.NumberFormatSymbols_ar_YE_u_nu_latn', 'goog.i18n.NumberFormatSymbols_as', 'goog.i18n.NumberFormatSymbols_as_IN', 'goog.i18n.NumberFormatSymbols_as_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_as_u_nu_latn', 'goog.i18n.NumberFormatSymbols_asa', 'goog.i18n.NumberFormatSymbols_asa_TZ', 'goog.i18n.NumberFormatSymbols_ast', 'goog.i18n.NumberFormatSymbols_ast_ES', 'goog.i18n.NumberFormatSymbols_az_Cyrl', 'goog.i18n.NumberFormatSymbols_az_Cyrl_AZ', 'goog.i18n.NumberFormatSymbols_az_Latn', 'goog.i18n.NumberFormatSymbols_az_Latn_AZ', 'goog.i18n.NumberFormatSymbols_bas', 'goog.i18n.NumberFormatSymbols_bas_CM', 'goog.i18n.NumberFormatSymbols_be_BY', 'goog.i18n.NumberFormatSymbols_bem', 'goog.i18n.NumberFormatSymbols_bem_ZM', 'goog.i18n.NumberFormatSymbols_bez', 'goog.i18n.NumberFormatSymbols_bez_TZ', 'goog.i18n.NumberFormatSymbols_bg_BG', 'goog.i18n.NumberFormatSymbols_bm', 'goog.i18n.NumberFormatSymbols_bm_ML', 'goog.i18n.NumberFormatSymbols_bn_BD', 'goog.i18n.NumberFormatSymbols_bn_BD_u_nu_latn', 'goog.i18n.NumberFormatSymbols_bn_IN', 'goog.i18n.NumberFormatSymbols_bn_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_bo', 'goog.i18n.NumberFormatSymbols_bo_CN', 'goog.i18n.NumberFormatSymbols_bo_IN', 'goog.i18n.NumberFormatSymbols_br_FR', 'goog.i18n.NumberFormatSymbols_brx', 'goog.i18n.NumberFormatSymbols_brx_IN', 'goog.i18n.NumberFormatSymbols_bs_Cyrl', 'goog.i18n.NumberFormatSymbols_bs_Cyrl_BA', 'goog.i18n.NumberFormatSymbols_bs_Latn', 'goog.i18n.NumberFormatSymbols_bs_Latn_BA', 'goog.i18n.NumberFormatSymbols_ca_AD', 'goog.i18n.NumberFormatSymbols_ca_ES', 'goog.i18n.NumberFormatSymbols_ca_FR', 'goog.i18n.NumberFormatSymbols_ca_IT', 'goog.i18n.NumberFormatSymbols_ccp', 'goog.i18n.NumberFormatSymbols_ccp_BD', 'goog.i18n.NumberFormatSymbols_ccp_BD_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ccp_IN', 'goog.i18n.NumberFormatSymbols_ccp_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ccp_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ce', 'goog.i18n.NumberFormatSymbols_ce_RU', 'goog.i18n.NumberFormatSymbols_ceb', 'goog.i18n.NumberFormatSymbols_ceb_PH', 'goog.i18n.NumberFormatSymbols_cgg', 'goog.i18n.NumberFormatSymbols_cgg_UG', 'goog.i18n.NumberFormatSymbols_chr_US', 'goog.i18n.NumberFormatSymbols_ckb', 'goog.i18n.NumberFormatSymbols_ckb_IQ', 'goog.i18n.NumberFormatSymbols_ckb_IQ_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ckb_IR', 'goog.i18n.NumberFormatSymbols_ckb_IR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ckb_u_nu_latn', 'goog.i18n.NumberFormatSymbols_cs_CZ', 'goog.i18n.NumberFormatSymbols_cy_GB', 'goog.i18n.NumberFormatSymbols_da_DK', 'goog.i18n.NumberFormatSymbols_da_GL', 'goog.i18n.NumberFormatSymbols_dav', 'goog.i18n.NumberFormatSymbols_dav_KE', 'goog.i18n.NumberFormatSymbols_de_BE', 'goog.i18n.NumberFormatSymbols_de_DE', 'goog.i18n.NumberFormatSymbols_de_IT', 'goog.i18n.NumberFormatSymbols_de_LI', 'goog.i18n.NumberFormatSymbols_de_LU', 'goog.i18n.NumberFormatSymbols_dje', 'goog.i18n.NumberFormatSymbols_dje_NE', 'goog.i18n.NumberFormatSymbols_dsb', 'goog.i18n.NumberFormatSymbols_dsb_DE', 'goog.i18n.NumberFormatSymbols_dua', 'goog.i18n.NumberFormatSymbols_dua_CM', 'goog.i18n.NumberFormatSymbols_dyo', 'goog.i18n.NumberFormatSymbols_dyo_SN', 'goog.i18n.NumberFormatSymbols_dz', 'goog.i18n.NumberFormatSymbols_dz_BT', 'goog.i18n.NumberFormatSymbols_dz_BT_u_nu_latn', 'goog.i18n.NumberFormatSymbols_dz_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ebu', 'goog.i18n.NumberFormatSymbols_ebu_KE', 'goog.i18n.NumberFormatSymbols_ee', 'goog.i18n.NumberFormatSymbols_ee_GH', 'goog.i18n.NumberFormatSymbols_ee_TG', 'goog.i18n.NumberFormatSymbols_el_CY', 'goog.i18n.NumberFormatSymbols_el_GR', 'goog.i18n.NumberFormatSymbols_en_001', 'goog.i18n.NumberFormatSymbols_en_150', 'goog.i18n.NumberFormatSymbols_en_AE', 'goog.i18n.NumberFormatSymbols_en_AG', 'goog.i18n.NumberFormatSymbols_en_AI', 'goog.i18n.NumberFormatSymbols_en_AS', 'goog.i18n.NumberFormatSymbols_en_AT', 'goog.i18n.NumberFormatSymbols_en_BB', 'goog.i18n.NumberFormatSymbols_en_BE', 'goog.i18n.NumberFormatSymbols_en_BI', 'goog.i18n.NumberFormatSymbols_en_BM', 'goog.i18n.NumberFormatSymbols_en_BS', 'goog.i18n.NumberFormatSymbols_en_BW', 'goog.i18n.NumberFormatSymbols_en_BZ', 'goog.i18n.NumberFormatSymbols_en_CC', 'goog.i18n.NumberFormatSymbols_en_CH', 'goog.i18n.NumberFormatSymbols_en_CK', 'goog.i18n.NumberFormatSymbols_en_CM', 'goog.i18n.NumberFormatSymbols_en_CX', 'goog.i18n.NumberFormatSymbols_en_CY', 'goog.i18n.NumberFormatSymbols_en_DE', 'goog.i18n.NumberFormatSymbols_en_DG', 'goog.i18n.NumberFormatSymbols_en_DK', 'goog.i18n.NumberFormatSymbols_en_DM', 'goog.i18n.NumberFormatSymbols_en_ER', 'goog.i18n.NumberFormatSymbols_en_FI', 'goog.i18n.NumberFormatSymbols_en_FJ', 'goog.i18n.NumberFormatSymbols_en_FK', 'goog.i18n.NumberFormatSymbols_en_FM', 'goog.i18n.NumberFormatSymbols_en_GD', 'goog.i18n.NumberFormatSymbols_en_GG', 'goog.i18n.NumberFormatSymbols_en_GH', 'goog.i18n.NumberFormatSymbols_en_GI', 'goog.i18n.NumberFormatSymbols_en_GM', 'goog.i18n.NumberFormatSymbols_en_GU', 'goog.i18n.NumberFormatSymbols_en_GY', 'goog.i18n.NumberFormatSymbols_en_HK', 'goog.i18n.NumberFormatSymbols_en_IL', 'goog.i18n.NumberFormatSymbols_en_IM', 'goog.i18n.NumberFormatSymbols_en_IO', 'goog.i18n.NumberFormatSymbols_en_JE', 'goog.i18n.NumberFormatSymbols_en_JM', 'goog.i18n.NumberFormatSymbols_en_KE', 'goog.i18n.NumberFormatSymbols_en_KI', 'goog.i18n.NumberFormatSymbols_en_KN', 'goog.i18n.NumberFormatSymbols_en_KY', 'goog.i18n.NumberFormatSymbols_en_LC', 'goog.i18n.NumberFormatSymbols_en_LR', 'goog.i18n.NumberFormatSymbols_en_LS', 'goog.i18n.NumberFormatSymbols_en_MG', 'goog.i18n.NumberFormatSymbols_en_MH', 'goog.i18n.NumberFormatSymbols_en_MO', 'goog.i18n.NumberFormatSymbols_en_MP', 'goog.i18n.NumberFormatSymbols_en_MS', 'goog.i18n.NumberFormatSymbols_en_MT', 'goog.i18n.NumberFormatSymbols_en_MU', 'goog.i18n.NumberFormatSymbols_en_MW', 'goog.i18n.NumberFormatSymbols_en_MY', 'goog.i18n.NumberFormatSymbols_en_NA', 'goog.i18n.NumberFormatSymbols_en_NF', 'goog.i18n.NumberFormatSymbols_en_NG', 'goog.i18n.NumberFormatSymbols_en_NL', 'goog.i18n.NumberFormatSymbols_en_NR', 'goog.i18n.NumberFormatSymbols_en_NU', 'goog.i18n.NumberFormatSymbols_en_NZ', 'goog.i18n.NumberFormatSymbols_en_PG', 'goog.i18n.NumberFormatSymbols_en_PH', 'goog.i18n.NumberFormatSymbols_en_PK', 'goog.i18n.NumberFormatSymbols_en_PN', 'goog.i18n.NumberFormatSymbols_en_PR', 'goog.i18n.NumberFormatSymbols_en_PW', 'goog.i18n.NumberFormatSymbols_en_RW', 'goog.i18n.NumberFormatSymbols_en_SB', 'goog.i18n.NumberFormatSymbols_en_SC', 'goog.i18n.NumberFormatSymbols_en_SD', 'goog.i18n.NumberFormatSymbols_en_SE', 'goog.i18n.NumberFormatSymbols_en_SH', 'goog.i18n.NumberFormatSymbols_en_SI', 'goog.i18n.NumberFormatSymbols_en_SL', 'goog.i18n.NumberFormatSymbols_en_SS', 'goog.i18n.NumberFormatSymbols_en_SX', 'goog.i18n.NumberFormatSymbols_en_SZ', 'goog.i18n.NumberFormatSymbols_en_TC', 'goog.i18n.NumberFormatSymbols_en_TK', 'goog.i18n.NumberFormatSymbols_en_TO', 'goog.i18n.NumberFormatSymbols_en_TT', 'goog.i18n.NumberFormatSymbols_en_TV', 'goog.i18n.NumberFormatSymbols_en_TZ', 'goog.i18n.NumberFormatSymbols_en_UG', 'goog.i18n.NumberFormatSymbols_en_UM', 'goog.i18n.NumberFormatSymbols_en_US_POSIX', 'goog.i18n.NumberFormatSymbols_en_VC', 'goog.i18n.NumberFormatSymbols_en_VG', 'goog.i18n.NumberFormatSymbols_en_VI', 'goog.i18n.NumberFormatSymbols_en_VU', 'goog.i18n.NumberFormatSymbols_en_WS', 'goog.i18n.NumberFormatSymbols_en_XA', 'goog.i18n.NumberFormatSymbols_en_ZM', 'goog.i18n.NumberFormatSymbols_en_ZW', 'goog.i18n.NumberFormatSymbols_eo', 'goog.i18n.NumberFormatSymbols_eo_001', 'goog.i18n.NumberFormatSymbols_es_AR', 'goog.i18n.NumberFormatSymbols_es_BO', 'goog.i18n.NumberFormatSymbols_es_BR', 'goog.i18n.NumberFormatSymbols_es_BZ', 'goog.i18n.NumberFormatSymbols_es_CL', 'goog.i18n.NumberFormatSymbols_es_CO', 'goog.i18n.NumberFormatSymbols_es_CR', 'goog.i18n.NumberFormatSymbols_es_CU', 'goog.i18n.NumberFormatSymbols_es_DO', 'goog.i18n.NumberFormatSymbols_es_EA', 'goog.i18n.NumberFormatSymbols_es_EC', 'goog.i18n.NumberFormatSymbols_es_GQ', 'goog.i18n.NumberFormatSymbols_es_GT', 'goog.i18n.NumberFormatSymbols_es_HN', 'goog.i18n.NumberFormatSymbols_es_IC', 'goog.i18n.NumberFormatSymbols_es_NI', 'goog.i18n.NumberFormatSymbols_es_PA', 'goog.i18n.NumberFormatSymbols_es_PE', 'goog.i18n.NumberFormatSymbols_es_PH', 'goog.i18n.NumberFormatSymbols_es_PR', 'goog.i18n.NumberFormatSymbols_es_PY', 'goog.i18n.NumberFormatSymbols_es_SV', 'goog.i18n.NumberFormatSymbols_es_UY', 'goog.i18n.NumberFormatSymbols_es_VE', 'goog.i18n.NumberFormatSymbols_et_EE', 'goog.i18n.NumberFormatSymbols_eu_ES', 'goog.i18n.NumberFormatSymbols_ewo', 'goog.i18n.NumberFormatSymbols_ewo_CM', 'goog.i18n.NumberFormatSymbols_fa_AF', 'goog.i18n.NumberFormatSymbols_fa_AF_u_nu_latn', 'goog.i18n.NumberFormatSymbols_fa_IR', 'goog.i18n.NumberFormatSymbols_fa_IR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ff', 'goog.i18n.NumberFormatSymbols_ff_Latn', 'goog.i18n.NumberFormatSymbols_ff_Latn_BF', 'goog.i18n.NumberFormatSymbols_ff_Latn_CM', 'goog.i18n.NumberFormatSymbols_ff_Latn_GH', 'goog.i18n.NumberFormatSymbols_ff_Latn_GM', 'goog.i18n.NumberFormatSymbols_ff_Latn_GN', 'goog.i18n.NumberFormatSymbols_ff_Latn_GW', 'goog.i18n.NumberFormatSymbols_ff_Latn_LR', 'goog.i18n.NumberFormatSymbols_ff_Latn_MR', 'goog.i18n.NumberFormatSymbols_ff_Latn_NE', 'goog.i18n.NumberFormatSymbols_ff_Latn_NG', 'goog.i18n.NumberFormatSymbols_ff_Latn_SL', 'goog.i18n.NumberFormatSymbols_ff_Latn_SN', 'goog.i18n.NumberFormatSymbols_fi_FI', 'goog.i18n.NumberFormatSymbols_fil_PH', 'goog.i18n.NumberFormatSymbols_fo', 'goog.i18n.NumberFormatSymbols_fo_DK', 'goog.i18n.NumberFormatSymbols_fo_FO', 'goog.i18n.NumberFormatSymbols_fr_BE', 'goog.i18n.NumberFormatSymbols_fr_BF', 'goog.i18n.NumberFormatSymbols_fr_BI', 'goog.i18n.NumberFormatSymbols_fr_BJ', 'goog.i18n.NumberFormatSymbols_fr_BL', 'goog.i18n.NumberFormatSymbols_fr_CD', 'goog.i18n.NumberFormatSymbols_fr_CF', 'goog.i18n.NumberFormatSymbols_fr_CG', 'goog.i18n.NumberFormatSymbols_fr_CH', 'goog.i18n.NumberFormatSymbols_fr_CI', 'goog.i18n.NumberFormatSymbols_fr_CM', 'goog.i18n.NumberFormatSymbols_fr_DJ', 'goog.i18n.NumberFormatSymbols_fr_DZ', 'goog.i18n.NumberFormatSymbols_fr_FR', 'goog.i18n.NumberFormatSymbols_fr_GA', 'goog.i18n.NumberFormatSymbols_fr_GF', 'goog.i18n.NumberFormatSymbols_fr_GN', 'goog.i18n.NumberFormatSymbols_fr_GP', 'goog.i18n.NumberFormatSymbols_fr_GQ', 'goog.i18n.NumberFormatSymbols_fr_HT', 'goog.i18n.NumberFormatSymbols_fr_KM', 'goog.i18n.NumberFormatSymbols_fr_LU', 'goog.i18n.NumberFormatSymbols_fr_MA', 'goog.i18n.NumberFormatSymbols_fr_MC', 'goog.i18n.NumberFormatSymbols_fr_MF', 'goog.i18n.NumberFormatSymbols_fr_MG', 'goog.i18n.NumberFormatSymbols_fr_ML', 'goog.i18n.NumberFormatSymbols_fr_MQ', 'goog.i18n.NumberFormatSymbols_fr_MR', 'goog.i18n.NumberFormatSymbols_fr_MU', 'goog.i18n.NumberFormatSymbols_fr_NC', 'goog.i18n.NumberFormatSymbols_fr_NE', 'goog.i18n.NumberFormatSymbols_fr_PF', 'goog.i18n.NumberFormatSymbols_fr_PM', 'goog.i18n.NumberFormatSymbols_fr_RE', 'goog.i18n.NumberFormatSymbols_fr_RW', 'goog.i18n.NumberFormatSymbols_fr_SC', 'goog.i18n.NumberFormatSymbols_fr_SN', 'goog.i18n.NumberFormatSymbols_fr_SY', 'goog.i18n.NumberFormatSymbols_fr_TD', 'goog.i18n.NumberFormatSymbols_fr_TG', 'goog.i18n.NumberFormatSymbols_fr_TN', 'goog.i18n.NumberFormatSymbols_fr_VU', 'goog.i18n.NumberFormatSymbols_fr_WF', 'goog.i18n.NumberFormatSymbols_fr_YT', 'goog.i18n.NumberFormatSymbols_fur', 'goog.i18n.NumberFormatSymbols_fur_IT', 'goog.i18n.NumberFormatSymbols_fy', 'goog.i18n.NumberFormatSymbols_fy_NL', 'goog.i18n.NumberFormatSymbols_ga_IE', 'goog.i18n.NumberFormatSymbols_gd', 'goog.i18n.NumberFormatSymbols_gd_GB', 'goog.i18n.NumberFormatSymbols_gl_ES', 'goog.i18n.NumberFormatSymbols_gsw_CH', 'goog.i18n.NumberFormatSymbols_gsw_FR', 'goog.i18n.NumberFormatSymbols_gsw_LI', 'goog.i18n.NumberFormatSymbols_gu_IN', 'goog.i18n.NumberFormatSymbols_guz', 'goog.i18n.NumberFormatSymbols_guz_KE', 'goog.i18n.NumberFormatSymbols_gv', 'goog.i18n.NumberFormatSymbols_gv_IM', 'goog.i18n.NumberFormatSymbols_ha', 'goog.i18n.NumberFormatSymbols_ha_GH', 'goog.i18n.NumberFormatSymbols_ha_NE', 'goog.i18n.NumberFormatSymbols_ha_NG', 'goog.i18n.NumberFormatSymbols_haw_US', 'goog.i18n.NumberFormatSymbols_he_IL', 'goog.i18n.NumberFormatSymbols_hi_IN', 'goog.i18n.NumberFormatSymbols_hr_BA', 'goog.i18n.NumberFormatSymbols_hr_HR', 'goog.i18n.NumberFormatSymbols_hsb', 'goog.i18n.NumberFormatSymbols_hsb_DE', 'goog.i18n.NumberFormatSymbols_hu_HU', 'goog.i18n.NumberFormatSymbols_hy_AM', 'goog.i18n.NumberFormatSymbols_ia', 'goog.i18n.NumberFormatSymbols_ia_001', 'goog.i18n.NumberFormatSymbols_id_ID', 'goog.i18n.NumberFormatSymbols_ig', 'goog.i18n.NumberFormatSymbols_ig_NG', 'goog.i18n.NumberFormatSymbols_ii', 'goog.i18n.NumberFormatSymbols_ii_CN', 'goog.i18n.NumberFormatSymbols_is_IS', 'goog.i18n.NumberFormatSymbols_it_CH', 'goog.i18n.NumberFormatSymbols_it_IT', 'goog.i18n.NumberFormatSymbols_it_SM', 'goog.i18n.NumberFormatSymbols_it_VA', 'goog.i18n.NumberFormatSymbols_ja_JP', 'goog.i18n.NumberFormatSymbols_jgo', 'goog.i18n.NumberFormatSymbols_jgo_CM', 'goog.i18n.NumberFormatSymbols_jmc', 'goog.i18n.NumberFormatSymbols_jmc_TZ', 'goog.i18n.NumberFormatSymbols_jv', 'goog.i18n.NumberFormatSymbols_jv_ID', 'goog.i18n.NumberFormatSymbols_ka_GE', 'goog.i18n.NumberFormatSymbols_kab', 'goog.i18n.NumberFormatSymbols_kab_DZ', 'goog.i18n.NumberFormatSymbols_kam', 'goog.i18n.NumberFormatSymbols_kam_KE', 'goog.i18n.NumberFormatSymbols_kde', 'goog.i18n.NumberFormatSymbols_kde_TZ', 'goog.i18n.NumberFormatSymbols_kea', 'goog.i18n.NumberFormatSymbols_kea_CV', 'goog.i18n.NumberFormatSymbols_khq', 'goog.i18n.NumberFormatSymbols_khq_ML', 'goog.i18n.NumberFormatSymbols_ki', 'goog.i18n.NumberFormatSymbols_ki_KE', 'goog.i18n.NumberFormatSymbols_kk_KZ', 'goog.i18n.NumberFormatSymbols_kkj', 'goog.i18n.NumberFormatSymbols_kkj_CM', 'goog.i18n.NumberFormatSymbols_kl', 'goog.i18n.NumberFormatSymbols_kl_GL', 'goog.i18n.NumberFormatSymbols_kln', 'goog.i18n.NumberFormatSymbols_kln_KE', 'goog.i18n.NumberFormatSymbols_km_KH', 'goog.i18n.NumberFormatSymbols_kn_IN', 'goog.i18n.NumberFormatSymbols_ko_KP', 'goog.i18n.NumberFormatSymbols_ko_KR', 'goog.i18n.NumberFormatSymbols_kok', 'goog.i18n.NumberFormatSymbols_kok_IN', 'goog.i18n.NumberFormatSymbols_ks', 'goog.i18n.NumberFormatSymbols_ks_IN', 'goog.i18n.NumberFormatSymbols_ks_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ks_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ksb', 'goog.i18n.NumberFormatSymbols_ksb_TZ', 'goog.i18n.NumberFormatSymbols_ksf', 'goog.i18n.NumberFormatSymbols_ksf_CM', 'goog.i18n.NumberFormatSymbols_ksh', 'goog.i18n.NumberFormatSymbols_ksh_DE', 'goog.i18n.NumberFormatSymbols_ku', 'goog.i18n.NumberFormatSymbols_ku_TR', 'goog.i18n.NumberFormatSymbols_kw', 'goog.i18n.NumberFormatSymbols_kw_GB', 'goog.i18n.NumberFormatSymbols_ky_KG', 'goog.i18n.NumberFormatSymbols_lag', 'goog.i18n.NumberFormatSymbols_lag_TZ', 'goog.i18n.NumberFormatSymbols_lb', 'goog.i18n.NumberFormatSymbols_lb_LU', 'goog.i18n.NumberFormatSymbols_lg', 'goog.i18n.NumberFormatSymbols_lg_UG', 'goog.i18n.NumberFormatSymbols_lkt', 'goog.i18n.NumberFormatSymbols_lkt_US', 'goog.i18n.NumberFormatSymbols_ln_AO', 'goog.i18n.NumberFormatSymbols_ln_CD', 'goog.i18n.NumberFormatSymbols_ln_CF', 'goog.i18n.NumberFormatSymbols_ln_CG', 'goog.i18n.NumberFormatSymbols_lo_LA', 'goog.i18n.NumberFormatSymbols_lrc', 'goog.i18n.NumberFormatSymbols_lrc_IQ', 'goog.i18n.NumberFormatSymbols_lrc_IQ_u_nu_latn', 'goog.i18n.NumberFormatSymbols_lrc_IR', 'goog.i18n.NumberFormatSymbols_lrc_IR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_lrc_u_nu_latn', 'goog.i18n.NumberFormatSymbols_lt_LT', 'goog.i18n.NumberFormatSymbols_lu', 'goog.i18n.NumberFormatSymbols_lu_CD', 'goog.i18n.NumberFormatSymbols_luo', 'goog.i18n.NumberFormatSymbols_luo_KE', 'goog.i18n.NumberFormatSymbols_luy', 'goog.i18n.NumberFormatSymbols_luy_KE', 'goog.i18n.NumberFormatSymbols_lv_LV', 'goog.i18n.NumberFormatSymbols_mas', 'goog.i18n.NumberFormatSymbols_mas_KE', 'goog.i18n.NumberFormatSymbols_mas_TZ', 'goog.i18n.NumberFormatSymbols_mer', 'goog.i18n.NumberFormatSymbols_mer_KE', 'goog.i18n.NumberFormatSymbols_mfe', 'goog.i18n.NumberFormatSymbols_mfe_MU', 'goog.i18n.NumberFormatSymbols_mg', 'goog.i18n.NumberFormatSymbols_mg_MG', 'goog.i18n.NumberFormatSymbols_mgh', 'goog.i18n.NumberFormatSymbols_mgh_MZ', 'goog.i18n.NumberFormatSymbols_mgo', 'goog.i18n.NumberFormatSymbols_mgo_CM', 'goog.i18n.NumberFormatSymbols_mi', 'goog.i18n.NumberFormatSymbols_mi_NZ', 'goog.i18n.NumberFormatSymbols_mk_MK', 'goog.i18n.NumberFormatSymbols_ml_IN', 'goog.i18n.NumberFormatSymbols_mn_MN', 'goog.i18n.NumberFormatSymbols_mr_IN', 'goog.i18n.NumberFormatSymbols_mr_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ms_BN', 'goog.i18n.NumberFormatSymbols_ms_MY', 'goog.i18n.NumberFormatSymbols_ms_SG', 'goog.i18n.NumberFormatSymbols_mt_MT', 'goog.i18n.NumberFormatSymbols_mua', 'goog.i18n.NumberFormatSymbols_mua_CM', 'goog.i18n.NumberFormatSymbols_my_MM', 'goog.i18n.NumberFormatSymbols_my_MM_u_nu_latn', 'goog.i18n.NumberFormatSymbols_mzn', 'goog.i18n.NumberFormatSymbols_mzn_IR', 'goog.i18n.NumberFormatSymbols_mzn_IR_u_nu_latn', 'goog.i18n.NumberFormatSymbols_mzn_u_nu_latn', 'goog.i18n.NumberFormatSymbols_naq', 'goog.i18n.NumberFormatSymbols_naq_NA', 'goog.i18n.NumberFormatSymbols_nb_NO', 'goog.i18n.NumberFormatSymbols_nb_SJ', 'goog.i18n.NumberFormatSymbols_nd', 'goog.i18n.NumberFormatSymbols_nd_ZW', 'goog.i18n.NumberFormatSymbols_nds', 'goog.i18n.NumberFormatSymbols_nds_DE', 'goog.i18n.NumberFormatSymbols_nds_NL', 'goog.i18n.NumberFormatSymbols_ne_IN', 'goog.i18n.NumberFormatSymbols_ne_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ne_NP', 'goog.i18n.NumberFormatSymbols_ne_NP_u_nu_latn', 'goog.i18n.NumberFormatSymbols_nl_AW', 'goog.i18n.NumberFormatSymbols_nl_BE', 'goog.i18n.NumberFormatSymbols_nl_BQ', 'goog.i18n.NumberFormatSymbols_nl_CW', 'goog.i18n.NumberFormatSymbols_nl_NL', 'goog.i18n.NumberFormatSymbols_nl_SR', 'goog.i18n.NumberFormatSymbols_nl_SX', 'goog.i18n.NumberFormatSymbols_nmg', 'goog.i18n.NumberFormatSymbols_nmg_CM', 'goog.i18n.NumberFormatSymbols_nn', 'goog.i18n.NumberFormatSymbols_nn_NO', 'goog.i18n.NumberFormatSymbols_nnh', 'goog.i18n.NumberFormatSymbols_nnh_CM', 'goog.i18n.NumberFormatSymbols_nus', 'goog.i18n.NumberFormatSymbols_nus_SS', 'goog.i18n.NumberFormatSymbols_nyn', 'goog.i18n.NumberFormatSymbols_nyn_UG', 'goog.i18n.NumberFormatSymbols_om', 'goog.i18n.NumberFormatSymbols_om_ET', 'goog.i18n.NumberFormatSymbols_om_KE', 'goog.i18n.NumberFormatSymbols_or_IN', 'goog.i18n.NumberFormatSymbols_os', 'goog.i18n.NumberFormatSymbols_os_GE', 'goog.i18n.NumberFormatSymbols_os_RU', 'goog.i18n.NumberFormatSymbols_pa_Arab', 'goog.i18n.NumberFormatSymbols_pa_Arab_PK', 'goog.i18n.NumberFormatSymbols_pa_Arab_PK_u_nu_latn', 'goog.i18n.NumberFormatSymbols_pa_Arab_u_nu_latn', 'goog.i18n.NumberFormatSymbols_pa_Guru', 'goog.i18n.NumberFormatSymbols_pa_Guru_IN', 'goog.i18n.NumberFormatSymbols_pl_PL', 'goog.i18n.NumberFormatSymbols_ps', 'goog.i18n.NumberFormatSymbols_ps_AF', 'goog.i18n.NumberFormatSymbols_ps_AF_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ps_PK', 'goog.i18n.NumberFormatSymbols_ps_PK_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ps_u_nu_latn', 'goog.i18n.NumberFormatSymbols_pt_AO', 'goog.i18n.NumberFormatSymbols_pt_CH', 'goog.i18n.NumberFormatSymbols_pt_CV', 'goog.i18n.NumberFormatSymbols_pt_GQ', 'goog.i18n.NumberFormatSymbols_pt_GW', 'goog.i18n.NumberFormatSymbols_pt_LU', 'goog.i18n.NumberFormatSymbols_pt_MO', 'goog.i18n.NumberFormatSymbols_pt_MZ', 'goog.i18n.NumberFormatSymbols_pt_ST', 'goog.i18n.NumberFormatSymbols_pt_TL', 'goog.i18n.NumberFormatSymbols_qu', 'goog.i18n.NumberFormatSymbols_qu_BO', 'goog.i18n.NumberFormatSymbols_qu_EC', 'goog.i18n.NumberFormatSymbols_qu_PE', 'goog.i18n.NumberFormatSymbols_rm', 'goog.i18n.NumberFormatSymbols_rm_CH', 'goog.i18n.NumberFormatSymbols_rn', 'goog.i18n.NumberFormatSymbols_rn_BI', 'goog.i18n.NumberFormatSymbols_ro_MD', 'goog.i18n.NumberFormatSymbols_ro_RO', 'goog.i18n.NumberFormatSymbols_rof', 'goog.i18n.NumberFormatSymbols_rof_TZ', 'goog.i18n.NumberFormatSymbols_ru_BY', 'goog.i18n.NumberFormatSymbols_ru_KG', 'goog.i18n.NumberFormatSymbols_ru_KZ', 'goog.i18n.NumberFormatSymbols_ru_MD', 'goog.i18n.NumberFormatSymbols_ru_RU', 'goog.i18n.NumberFormatSymbols_ru_UA', 'goog.i18n.NumberFormatSymbols_rw', 'goog.i18n.NumberFormatSymbols_rw_RW', 'goog.i18n.NumberFormatSymbols_rwk', 'goog.i18n.NumberFormatSymbols_rwk_TZ', 'goog.i18n.NumberFormatSymbols_sah', 'goog.i18n.NumberFormatSymbols_sah_RU', 'goog.i18n.NumberFormatSymbols_saq', 'goog.i18n.NumberFormatSymbols_saq_KE', 'goog.i18n.NumberFormatSymbols_sbp', 'goog.i18n.NumberFormatSymbols_sbp_TZ', 'goog.i18n.NumberFormatSymbols_sd', 'goog.i18n.NumberFormatSymbols_sd_PK', 'goog.i18n.NumberFormatSymbols_sd_PK_u_nu_latn', 'goog.i18n.NumberFormatSymbols_sd_u_nu_latn', 'goog.i18n.NumberFormatSymbols_se', 'goog.i18n.NumberFormatSymbols_se_FI', 'goog.i18n.NumberFormatSymbols_se_NO', 'goog.i18n.NumberFormatSymbols_se_SE', 'goog.i18n.NumberFormatSymbols_seh', 'goog.i18n.NumberFormatSymbols_seh_MZ', 'goog.i18n.NumberFormatSymbols_ses', 'goog.i18n.NumberFormatSymbols_ses_ML', 'goog.i18n.NumberFormatSymbols_sg', 'goog.i18n.NumberFormatSymbols_sg_CF', 'goog.i18n.NumberFormatSymbols_shi', 'goog.i18n.NumberFormatSymbols_shi_Latn', 'goog.i18n.NumberFormatSymbols_shi_Latn_MA', 'goog.i18n.NumberFormatSymbols_shi_Tfng', 'goog.i18n.NumberFormatSymbols_shi_Tfng_MA', 'goog.i18n.NumberFormatSymbols_si_LK', 'goog.i18n.NumberFormatSymbols_sk_SK', 'goog.i18n.NumberFormatSymbols_sl_SI', 'goog.i18n.NumberFormatSymbols_smn', 'goog.i18n.NumberFormatSymbols_smn_FI', 'goog.i18n.NumberFormatSymbols_sn', 'goog.i18n.NumberFormatSymbols_sn_ZW', 'goog.i18n.NumberFormatSymbols_so', 'goog.i18n.NumberFormatSymbols_so_DJ', 'goog.i18n.NumberFormatSymbols_so_ET', 'goog.i18n.NumberFormatSymbols_so_KE', 'goog.i18n.NumberFormatSymbols_so_SO', 'goog.i18n.NumberFormatSymbols_sq_AL', 'goog.i18n.NumberFormatSymbols_sq_MK', 'goog.i18n.NumberFormatSymbols_sq_XK', 'goog.i18n.NumberFormatSymbols_sr_Cyrl', 'goog.i18n.NumberFormatSymbols_sr_Cyrl_BA', 'goog.i18n.NumberFormatSymbols_sr_Cyrl_ME', 'goog.i18n.NumberFormatSymbols_sr_Cyrl_RS', 'goog.i18n.NumberFormatSymbols_sr_Cyrl_XK', 'goog.i18n.NumberFormatSymbols_sr_Latn_BA', 'goog.i18n.NumberFormatSymbols_sr_Latn_ME', 'goog.i18n.NumberFormatSymbols_sr_Latn_RS', 'goog.i18n.NumberFormatSymbols_sr_Latn_XK', 'goog.i18n.NumberFormatSymbols_sv_AX', 'goog.i18n.NumberFormatSymbols_sv_FI', 'goog.i18n.NumberFormatSymbols_sv_SE', 'goog.i18n.NumberFormatSymbols_sw_CD', 'goog.i18n.NumberFormatSymbols_sw_KE', 'goog.i18n.NumberFormatSymbols_sw_TZ', 'goog.i18n.NumberFormatSymbols_sw_UG', 'goog.i18n.NumberFormatSymbols_ta_IN', 'goog.i18n.NumberFormatSymbols_ta_LK', 'goog.i18n.NumberFormatSymbols_ta_MY', 'goog.i18n.NumberFormatSymbols_ta_SG', 'goog.i18n.NumberFormatSymbols_te_IN', 'goog.i18n.NumberFormatSymbols_teo', 'goog.i18n.NumberFormatSymbols_teo_KE', 'goog.i18n.NumberFormatSymbols_teo_UG', 'goog.i18n.NumberFormatSymbols_tg', 'goog.i18n.NumberFormatSymbols_tg_TJ', 'goog.i18n.NumberFormatSymbols_th_TH', 'goog.i18n.NumberFormatSymbols_ti', 'goog.i18n.NumberFormatSymbols_ti_ER', 'goog.i18n.NumberFormatSymbols_ti_ET', 'goog.i18n.NumberFormatSymbols_tk', 'goog.i18n.NumberFormatSymbols_tk_TM', 'goog.i18n.NumberFormatSymbols_to', 'goog.i18n.NumberFormatSymbols_to_TO', 'goog.i18n.NumberFormatSymbols_tr_CY', 'goog.i18n.NumberFormatSymbols_tr_TR', 'goog.i18n.NumberFormatSymbols_tt', 'goog.i18n.NumberFormatSymbols_tt_RU', 'goog.i18n.NumberFormatSymbols_twq', 'goog.i18n.NumberFormatSymbols_twq_NE', 'goog.i18n.NumberFormatSymbols_tzm', 'goog.i18n.NumberFormatSymbols_tzm_MA', 'goog.i18n.NumberFormatSymbols_ug', 'goog.i18n.NumberFormatSymbols_ug_CN', 'goog.i18n.NumberFormatSymbols_uk_UA', 'goog.i18n.NumberFormatSymbols_ur_IN', 'goog.i18n.NumberFormatSymbols_ur_IN_u_nu_latn', 'goog.i18n.NumberFormatSymbols_ur_PK', 'goog.i18n.NumberFormatSymbols_uz_Arab', 'goog.i18n.NumberFormatSymbols_uz_Arab_AF', 'goog.i18n.NumberFormatSymbols_uz_Arab_AF_u_nu_latn', 'goog.i18n.NumberFormatSymbols_uz_Arab_u_nu_latn', 'goog.i18n.NumberFormatSymbols_uz_Cyrl', 'goog.i18n.NumberFormatSymbols_uz_Cyrl_UZ', 'goog.i18n.NumberFormatSymbols_uz_Latn', 'goog.i18n.NumberFormatSymbols_uz_Latn_UZ', 'goog.i18n.NumberFormatSymbols_vai', 'goog.i18n.NumberFormatSymbols_vai_Latn', 'goog.i18n.NumberFormatSymbols_vai_Latn_LR', 'goog.i18n.NumberFormatSymbols_vai_Vaii', 'goog.i18n.NumberFormatSymbols_vai_Vaii_LR', 'goog.i18n.NumberFormatSymbols_vi_VN', 'goog.i18n.NumberFormatSymbols_vun', 'goog.i18n.NumberFormatSymbols_vun_TZ', 'goog.i18n.NumberFormatSymbols_wae', 'goog.i18n.NumberFormatSymbols_wae_CH', 'goog.i18n.NumberFormatSymbols_wo', 'goog.i18n.NumberFormatSymbols_wo_SN', 'goog.i18n.NumberFormatSymbols_xh', 'goog.i18n.NumberFormatSymbols_xh_ZA', 'goog.i18n.NumberFormatSymbols_xog', 'goog.i18n.NumberFormatSymbols_xog_UG', 'goog.i18n.NumberFormatSymbols_yav', 'goog.i18n.NumberFormatSymbols_yav_CM', 'goog.i18n.NumberFormatSymbols_yi', 'goog.i18n.NumberFormatSymbols_yi_001', 'goog.i18n.NumberFormatSymbols_yo', 'goog.i18n.NumberFormatSymbols_yo_BJ', 'goog.i18n.NumberFormatSymbols_yo_NG', 'goog.i18n.NumberFormatSymbols_yue', 'goog.i18n.NumberFormatSymbols_yue_Hans', 'goog.i18n.NumberFormatSymbols_yue_Hans_CN', 'goog.i18n.NumberFormatSymbols_yue_Hant', 'goog.i18n.NumberFormatSymbols_yue_Hant_HK', 'goog.i18n.NumberFormatSymbols_zgh', 'goog.i18n.NumberFormatSymbols_zgh_MA', 'goog.i18n.NumberFormatSymbols_zh_Hans', 'goog.i18n.NumberFormatSymbols_zh_Hans_CN', 'goog.i18n.NumberFormatSymbols_zh_Hans_HK', 'goog.i18n.NumberFormatSymbols_zh_Hans_MO', 'goog.i18n.NumberFormatSymbols_zh_Hans_SG', 'goog.i18n.NumberFormatSymbols_zh_Hant', 'goog.i18n.NumberFormatSymbols_zh_Hant_HK', 'goog.i18n.NumberFormatSymbols_zh_Hant_MO', 'goog.i18n.NumberFormatSymbols_zh_Hant_TW', 'goog.i18n.NumberFormatSymbols_zu_ZA'], ['goog.i18n.NumberFormatSymbols', 'goog.i18n.NumberFormatSymbols_u_nu_latn'], {});
goog.addDependency('i18n/ordinalrules.js', ['goog.i18n.ordinalRules'], [], {'lang': 'es6'});
goog.addDependency('i18n/pluralrules.js', ['goog.i18n.pluralRules'], [], {'lang': 'es6'});
goog.addDependency('i18n/pluralrules_test.js', ['goog.i18n.pluralRulesTest'], ['goog.i18n.pluralRules', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/relativedatetimeformat.js', ['goog.i18n.RelativeDateTimeFormat'], ['goog.asserts', 'goog.i18n.LocaleFeature', 'goog.i18n.MessageFormat', 'goog.i18n.relativeDateTimeSymbols'], {'lang': 'es5', 'module': 'goog'});
goog.addDependency('i18n/relativedatetimeformat_test.js', ['goog.i18n.RelativeDateTimeFormatTest'], ['goog.i18n.LocaleFeature', 'goog.i18n.NumberFormatSymbols_ar_EG', 'goog.i18n.NumberFormatSymbols_en', 'goog.i18n.NumberFormatSymbols_es', 'goog.i18n.NumberFormatSymbols_fa', 'goog.i18n.RelativeDateTimeFormat', 'goog.i18n.relativeDateTimeSymbols', 'goog.i18n.relativeDateTimeSymbolsExt', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/relativedatetimesymbols.js', ['goog.i18n.relativeDateTimeSymbols'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/relativedatetimesymbolsext.js', ['goog.i18n.relativeDateTimeSymbolsExt'], ['goog.i18n.relativeDateTimeSymbols'], {'lang': 'es5', 'module': 'goog'});
goog.addDependency('i18n/timezone.js', ['goog.i18n.TimeZone'], ['goog.array', 'goog.date.DateLike', 'goog.object', 'goog.string'], {});
goog.addDependency('i18n/timezone_test.js', ['goog.i18n.TimeZoneTest'], ['goog.i18n.TimeZone', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/uchar.js', ['goog.i18n.uChar'], [], {'lang': 'es6'});
goog.addDependency('i18n/uchar/localnamefetcher.js', ['goog.i18n.uChar.LocalNameFetcher'], ['goog.i18n.uChar.NameFetcher', 'goog.i18n.uCharNames', 'goog.log'], {});
goog.addDependency('i18n/uchar/localnamefetcher_test.js', ['goog.i18n.uChar.LocalNameFetcherTest'], ['goog.i18n.uChar.LocalNameFetcher', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/uchar/namefetcher.js', ['goog.i18n.uChar.NameFetcher'], [], {});
goog.addDependency('i18n/uchar/remotenamefetcher.js', ['goog.i18n.uChar.RemoteNameFetcher'], ['goog.Disposable', 'goog.Uri', 'goog.events', 'goog.i18n.uChar', 'goog.i18n.uChar.NameFetcher', 'goog.log', 'goog.net.EventType', 'goog.net.XhrIo'], {});
goog.addDependency('i18n/uchar/remotenamefetcher_test.js', ['goog.i18n.uChar.RemoteNameFetcherTest'], ['goog.i18n.uChar.RemoteNameFetcher', 'goog.net.XhrIo', 'goog.testing.net.XhrIo', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/uchar_test.js', ['goog.i18n.uCharTest'], ['goog.i18n.uChar', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('i18n/ucharnames.js', ['goog.i18n.uCharNames'], ['goog.i18n.uChar'], {});
goog.addDependency('i18n/ucharnames_test.js', ['goog.i18n.uCharNamesTest'], ['goog.i18n.uCharNames', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('iter/es6.js', ['goog.iter.es6'], ['goog.iter.Iterable', 'goog.iter.Iterator', 'goog.iter.StopIteration'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('iter/es6_test.js', ['goog.iter.es6Test'], ['goog.iter', 'goog.iter.es6', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('iter/iter.js', ['goog.iter', 'goog.iter.Iterable', 'goog.iter.Iterator', 'goog.iter.StopIteration'], ['goog.array', 'goog.asserts', 'goog.functions', 'goog.math'], {});
goog.addDependency('iter/iter_test.js', ['goog.iterTest'], ['goog.iter', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('json/hybrid.js', ['goog.json.hybrid'], ['goog.asserts', 'goog.json'], {});
goog.addDependency('json/hybrid_test.js', ['goog.json.hybridTest'], ['goog.json', 'goog.json.hybrid', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('json/json.js', ['goog.json', 'goog.json.Replacer', 'goog.json.Reviver', 'goog.json.Serializer'], [], {'lang': 'es6'});
goog.addDependency('json/json_perf.js', ['goog.jsonPerf'], ['goog.dom', 'goog.json', 'goog.math', 'goog.string', 'goog.testing.PerformanceTable', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit'], {});
goog.addDependency('json/json_test.js', ['goog.jsonTest'], ['goog.functions', 'goog.json', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('json/jsonable.js', ['goog.json.Jsonable'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('json/nativejsonprocessor.js', ['goog.json.NativeJsonProcessor'], ['goog.asserts', 'goog.json.Processor'], {});
goog.addDependency('json/processor.js', ['goog.json.Processor'], ['goog.string.Parser', 'goog.string.Stringifier'], {});
goog.addDependency('json/processor_test.js', ['goog.json.processorTest'], ['goog.json.NativeJsonProcessor', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/collections/iterables.js', ['goog.labs.collections.iterables'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/collections/iterables_test.js', ['goog.labs.iterableTest'], ['goog.labs.collections.iterables', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/dom/pagevisibilitymonitor.js', ['goog.labs.dom.PageVisibilityEvent', 'goog.labs.dom.PageVisibilityMonitor', 'goog.labs.dom.PageVisibilityState'], ['goog.dom', 'goog.dom.vendor', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.memoize'], {});
goog.addDependency('labs/dom/pagevisibilitymonitor_test.js', ['goog.labs.dom.PageVisibilityMonitorTest'], ['goog.events', 'goog.functions', 'goog.labs.dom.PageVisibilityMonitor', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/events/nondisposableeventtarget.js', ['goog.labs.events.NonDisposableEventTarget'], ['goog.array', 'goog.asserts', 'goog.events.Event', 'goog.events.Listenable', 'goog.events.ListenerMap', 'goog.object'], {});
goog.addDependency('labs/events/nondisposableeventtarget_test.js', ['goog.labs.events.NonDisposableEventTargetTest'], ['goog.events.Listenable', 'goog.events.eventTargetTester', 'goog.labs.events.NonDisposableEventTarget', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/events/nondisposableeventtarget_via_googevents_test.js', ['goog.labs.events.NonDisposableEventTargetGoogEventsTest'], ['goog.events', 'goog.events.eventTargetTester', 'goog.labs.events.NonDisposableEventTarget', 'goog.testing', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/events/touch.js', ['goog.labs.events.touch', 'goog.labs.events.touch.TouchData'], ['goog.array', 'goog.asserts', 'goog.events.EventType', 'goog.string'], {});
goog.addDependency('labs/events/touch_test.js', ['goog.labs.events.touchTest'], ['goog.labs.events.touch', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/format/csv.js', ['goog.labs.format.csv', 'goog.labs.format.csv.ParseError', 'goog.labs.format.csv.Token'], ['goog.array', 'goog.asserts', 'goog.debug.Error', 'goog.object', 'goog.string', 'goog.string.newlines'], {});
goog.addDependency('labs/format/csv_test.js', ['goog.labs.format.csvTest'], ['goog.labs.format.csv', 'goog.labs.format.csv.ParseError', 'goog.object', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/i18n/listformat.js', ['goog.labs.i18n.GenderInfo', 'goog.labs.i18n.GenderInfo.Gender', 'goog.labs.i18n.ListFormat'], ['goog.asserts', 'goog.labs.i18n.ListFormatSymbols'], {});
goog.addDependency('labs/i18n/listformat_test.js', ['goog.labs.i18n.ListFormatTest'], ['goog.labs.i18n.GenderInfo', 'goog.labs.i18n.ListFormat', 'goog.labs.i18n.ListFormatSymbols', 'goog.labs.i18n.ListFormatSymbols_el', 'goog.labs.i18n.ListFormatSymbols_en', 'goog.labs.i18n.ListFormatSymbols_fr', 'goog.labs.i18n.ListFormatSymbols_ml', 'goog.labs.i18n.ListFormatSymbols_zu', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/i18n/listsymbols.js', ['goog.labs.i18n.ListFormatSymbols', 'goog.labs.i18n.ListFormatSymbols_af', 'goog.labs.i18n.ListFormatSymbols_am', 'goog.labs.i18n.ListFormatSymbols_ar', 'goog.labs.i18n.ListFormatSymbols_ar_DZ', 'goog.labs.i18n.ListFormatSymbols_ar_EG', 'goog.labs.i18n.ListFormatSymbols_az', 'goog.labs.i18n.ListFormatSymbols_be', 'goog.labs.i18n.ListFormatSymbols_bg', 'goog.labs.i18n.ListFormatSymbols_bn', 'goog.labs.i18n.ListFormatSymbols_br', 'goog.labs.i18n.ListFormatSymbols_bs', 'goog.labs.i18n.ListFormatSymbols_ca', 'goog.labs.i18n.ListFormatSymbols_chr', 'goog.labs.i18n.ListFormatSymbols_cs', 'goog.labs.i18n.ListFormatSymbols_cy', 'goog.labs.i18n.ListFormatSymbols_da', 'goog.labs.i18n.ListFormatSymbols_de', 'goog.labs.i18n.ListFormatSymbols_de_AT', 'goog.labs.i18n.ListFormatSymbols_de_CH', 'goog.labs.i18n.ListFormatSymbols_el', 'goog.labs.i18n.ListFormatSymbols_en', 'goog.labs.i18n.ListFormatSymbols_en_AU', 'goog.labs.i18n.ListFormatSymbols_en_CA', 'goog.labs.i18n.ListFormatSymbols_en_GB', 'goog.labs.i18n.ListFormatSymbols_en_IE', 'goog.labs.i18n.ListFormatSymbols_en_IN', 'goog.labs.i18n.ListFormatSymbols_en_SG', 'goog.labs.i18n.ListFormatSymbols_en_US', 'goog.labs.i18n.ListFormatSymbols_en_ZA', 'goog.labs.i18n.ListFormatSymbols_es', 'goog.labs.i18n.ListFormatSymbols_es_419', 'goog.labs.i18n.ListFormatSymbols_es_ES', 'goog.labs.i18n.ListFormatSymbols_es_MX', 'goog.labs.i18n.ListFormatSymbols_es_US', 'goog.labs.i18n.ListFormatSymbols_et', 'goog.labs.i18n.ListFormatSymbols_eu', 'goog.labs.i18n.ListFormatSymbols_fa', 'goog.labs.i18n.ListFormatSymbols_fi', 'goog.labs.i18n.ListFormatSymbols_fil', 'goog.labs.i18n.ListFormatSymbols_fr', 'goog.labs.i18n.ListFormatSymbols_fr_CA', 'goog.labs.i18n.ListFormatSymbols_ga', 'goog.labs.i18n.ListFormatSymbols_gl', 'goog.labs.i18n.ListFormatSymbols_gsw', 'goog.labs.i18n.ListFormatSymbols_gu', 'goog.labs.i18n.ListFormatSymbols_haw', 'goog.labs.i18n.ListFormatSymbols_he', 'goog.labs.i18n.ListFormatSymbols_hi', 'goog.labs.i18n.ListFormatSymbols_hr', 'goog.labs.i18n.ListFormatSymbols_hu', 'goog.labs.i18n.ListFormatSymbols_hy', 'goog.labs.i18n.ListFormatSymbols_id', 'goog.labs.i18n.ListFormatSymbols_in', 'goog.labs.i18n.ListFormatSymbols_is', 'goog.labs.i18n.ListFormatSymbols_it', 'goog.labs.i18n.ListFormatSymbols_iw', 'goog.labs.i18n.ListFormatSymbols_ja', 'goog.labs.i18n.ListFormatSymbols_ka', 'goog.labs.i18n.ListFormatSymbols_kk', 'goog.labs.i18n.ListFormatSymbols_km', 'goog.labs.i18n.ListFormatSymbols_kn', 'goog.labs.i18n.ListFormatSymbols_ko', 'goog.labs.i18n.ListFormatSymbols_ky', 'goog.labs.i18n.ListFormatSymbols_ln', 'goog.labs.i18n.ListFormatSymbols_lo', 'goog.labs.i18n.ListFormatSymbols_lt', 'goog.labs.i18n.ListFormatSymbols_lv', 'goog.labs.i18n.ListFormatSymbols_mk', 'goog.labs.i18n.ListFormatSymbols_ml', 'goog.labs.i18n.ListFormatSymbols_mn', 'goog.labs.i18n.ListFormatSymbols_mo', 'goog.labs.i18n.ListFormatSymbols_mr', 'goog.labs.i18n.ListFormatSymbols_ms', 'goog.labs.i18n.ListFormatSymbols_mt', 'goog.labs.i18n.ListFormatSymbols_my', 'goog.labs.i18n.ListFormatSymbols_nb', 'goog.labs.i18n.ListFormatSymbols_ne', 'goog.labs.i18n.ListFormatSymbols_nl', 'goog.labs.i18n.ListFormatSymbols_no', 'goog.labs.i18n.ListFormatSymbols_no_NO', 'goog.labs.i18n.ListFormatSymbols_or', 'goog.labs.i18n.ListFormatSymbols_pa', 'goog.labs.i18n.ListFormatSymbols_pl', 'goog.labs.i18n.ListFormatSymbols_pt', 'goog.labs.i18n.ListFormatSymbols_pt_BR', 'goog.labs.i18n.ListFormatSymbols_pt_PT', 'goog.labs.i18n.ListFormatSymbols_ro', 'goog.labs.i18n.ListFormatSymbols_ru', 'goog.labs.i18n.ListFormatSymbols_sh', 'goog.labs.i18n.ListFormatSymbols_si', 'goog.labs.i18n.ListFormatSymbols_sk', 'goog.labs.i18n.ListFormatSymbols_sl', 'goog.labs.i18n.ListFormatSymbols_sq', 'goog.labs.i18n.ListFormatSymbols_sr', 'goog.labs.i18n.ListFormatSymbols_sr_Latn', 'goog.labs.i18n.ListFormatSymbols_sv', 'goog.labs.i18n.ListFormatSymbols_sw', 'goog.labs.i18n.ListFormatSymbols_ta', 'goog.labs.i18n.ListFormatSymbols_te', 'goog.labs.i18n.ListFormatSymbols_th', 'goog.labs.i18n.ListFormatSymbols_tl', 'goog.labs.i18n.ListFormatSymbols_tr', 'goog.labs.i18n.ListFormatSymbols_uk', 'goog.labs.i18n.ListFormatSymbols_ur', 'goog.labs.i18n.ListFormatSymbols_uz', 'goog.labs.i18n.ListFormatSymbols_vi', 'goog.labs.i18n.ListFormatSymbols_zh', 'goog.labs.i18n.ListFormatSymbols_zh_CN', 'goog.labs.i18n.ListFormatSymbols_zh_HK', 'goog.labs.i18n.ListFormatSymbols_zh_TW', 'goog.labs.i18n.ListFormatSymbols_zu'], [], {});
goog.addDependency('labs/i18n/listsymbolsext.js', ['goog.labs.i18n.ListFormatSymbolsExt', 'goog.labs.i18n.ListFormatSymbols_af_NA', 'goog.labs.i18n.ListFormatSymbols_af_ZA', 'goog.labs.i18n.ListFormatSymbols_agq', 'goog.labs.i18n.ListFormatSymbols_agq_CM', 'goog.labs.i18n.ListFormatSymbols_ak', 'goog.labs.i18n.ListFormatSymbols_ak_GH', 'goog.labs.i18n.ListFormatSymbols_am_ET', 'goog.labs.i18n.ListFormatSymbols_ar_001', 'goog.labs.i18n.ListFormatSymbols_ar_AE', 'goog.labs.i18n.ListFormatSymbols_ar_BH', 'goog.labs.i18n.ListFormatSymbols_ar_DJ', 'goog.labs.i18n.ListFormatSymbols_ar_EH', 'goog.labs.i18n.ListFormatSymbols_ar_ER', 'goog.labs.i18n.ListFormatSymbols_ar_IL', 'goog.labs.i18n.ListFormatSymbols_ar_IQ', 'goog.labs.i18n.ListFormatSymbols_ar_JO', 'goog.labs.i18n.ListFormatSymbols_ar_KM', 'goog.labs.i18n.ListFormatSymbols_ar_KW', 'goog.labs.i18n.ListFormatSymbols_ar_LB', 'goog.labs.i18n.ListFormatSymbols_ar_LY', 'goog.labs.i18n.ListFormatSymbols_ar_MA', 'goog.labs.i18n.ListFormatSymbols_ar_MR', 'goog.labs.i18n.ListFormatSymbols_ar_OM', 'goog.labs.i18n.ListFormatSymbols_ar_PS', 'goog.labs.i18n.ListFormatSymbols_ar_QA', 'goog.labs.i18n.ListFormatSymbols_ar_SA', 'goog.labs.i18n.ListFormatSymbols_ar_SD', 'goog.labs.i18n.ListFormatSymbols_ar_SO', 'goog.labs.i18n.ListFormatSymbols_ar_SS', 'goog.labs.i18n.ListFormatSymbols_ar_SY', 'goog.labs.i18n.ListFormatSymbols_ar_TD', 'goog.labs.i18n.ListFormatSymbols_ar_TN', 'goog.labs.i18n.ListFormatSymbols_ar_XB', 'goog.labs.i18n.ListFormatSymbols_ar_YE', 'goog.labs.i18n.ListFormatSymbols_as', 'goog.labs.i18n.ListFormatSymbols_as_IN', 'goog.labs.i18n.ListFormatSymbols_asa', 'goog.labs.i18n.ListFormatSymbols_asa_TZ', 'goog.labs.i18n.ListFormatSymbols_ast', 'goog.labs.i18n.ListFormatSymbols_ast_ES', 'goog.labs.i18n.ListFormatSymbols_az_Cyrl', 'goog.labs.i18n.ListFormatSymbols_az_Cyrl_AZ', 'goog.labs.i18n.ListFormatSymbols_az_Latn', 'goog.labs.i18n.ListFormatSymbols_az_Latn_AZ', 'goog.labs.i18n.ListFormatSymbols_bas', 'goog.labs.i18n.ListFormatSymbols_bas_CM', 'goog.labs.i18n.ListFormatSymbols_be_BY', 'goog.labs.i18n.ListFormatSymbols_bem', 'goog.labs.i18n.ListFormatSymbols_bem_ZM', 'goog.labs.i18n.ListFormatSymbols_bez', 'goog.labs.i18n.ListFormatSymbols_bez_TZ', 'goog.labs.i18n.ListFormatSymbols_bg_BG', 'goog.labs.i18n.ListFormatSymbols_bm', 'goog.labs.i18n.ListFormatSymbols_bm_ML', 'goog.labs.i18n.ListFormatSymbols_bn_BD', 'goog.labs.i18n.ListFormatSymbols_bn_IN', 'goog.labs.i18n.ListFormatSymbols_bo', 'goog.labs.i18n.ListFormatSymbols_bo_CN', 'goog.labs.i18n.ListFormatSymbols_bo_IN', 'goog.labs.i18n.ListFormatSymbols_br_FR', 'goog.labs.i18n.ListFormatSymbols_brx', 'goog.labs.i18n.ListFormatSymbols_brx_IN', 'goog.labs.i18n.ListFormatSymbols_bs_Cyrl', 'goog.labs.i18n.ListFormatSymbols_bs_Cyrl_BA', 'goog.labs.i18n.ListFormatSymbols_bs_Latn', 'goog.labs.i18n.ListFormatSymbols_bs_Latn_BA', 'goog.labs.i18n.ListFormatSymbols_ca_AD', 'goog.labs.i18n.ListFormatSymbols_ca_ES', 'goog.labs.i18n.ListFormatSymbols_ca_FR', 'goog.labs.i18n.ListFormatSymbols_ca_IT', 'goog.labs.i18n.ListFormatSymbols_ccp', 'goog.labs.i18n.ListFormatSymbols_ccp_BD', 'goog.labs.i18n.ListFormatSymbols_ccp_IN', 'goog.labs.i18n.ListFormatSymbols_ce', 'goog.labs.i18n.ListFormatSymbols_ce_RU', 'goog.labs.i18n.ListFormatSymbols_ceb', 'goog.labs.i18n.ListFormatSymbols_ceb_PH', 'goog.labs.i18n.ListFormatSymbols_cgg', 'goog.labs.i18n.ListFormatSymbols_cgg_UG', 'goog.labs.i18n.ListFormatSymbols_chr_US', 'goog.labs.i18n.ListFormatSymbols_ckb', 'goog.labs.i18n.ListFormatSymbols_ckb_IQ', 'goog.labs.i18n.ListFormatSymbols_ckb_IR', 'goog.labs.i18n.ListFormatSymbols_cs_CZ', 'goog.labs.i18n.ListFormatSymbols_cy_GB', 'goog.labs.i18n.ListFormatSymbols_da_DK', 'goog.labs.i18n.ListFormatSymbols_da_GL', 'goog.labs.i18n.ListFormatSymbols_dav', 'goog.labs.i18n.ListFormatSymbols_dav_KE', 'goog.labs.i18n.ListFormatSymbols_de_BE', 'goog.labs.i18n.ListFormatSymbols_de_DE', 'goog.labs.i18n.ListFormatSymbols_de_IT', 'goog.labs.i18n.ListFormatSymbols_de_LI', 'goog.labs.i18n.ListFormatSymbols_de_LU', 'goog.labs.i18n.ListFormatSymbols_dje', 'goog.labs.i18n.ListFormatSymbols_dje_NE', 'goog.labs.i18n.ListFormatSymbols_dsb', 'goog.labs.i18n.ListFormatSymbols_dsb_DE', 'goog.labs.i18n.ListFormatSymbols_dua', 'goog.labs.i18n.ListFormatSymbols_dua_CM', 'goog.labs.i18n.ListFormatSymbols_dyo', 'goog.labs.i18n.ListFormatSymbols_dyo_SN', 'goog.labs.i18n.ListFormatSymbols_dz', 'goog.labs.i18n.ListFormatSymbols_dz_BT', 'goog.labs.i18n.ListFormatSymbols_ebu', 'goog.labs.i18n.ListFormatSymbols_ebu_KE', 'goog.labs.i18n.ListFormatSymbols_ee', 'goog.labs.i18n.ListFormatSymbols_ee_GH', 'goog.labs.i18n.ListFormatSymbols_ee_TG', 'goog.labs.i18n.ListFormatSymbols_el_CY', 'goog.labs.i18n.ListFormatSymbols_el_GR', 'goog.labs.i18n.ListFormatSymbols_en_001', 'goog.labs.i18n.ListFormatSymbols_en_150', 'goog.labs.i18n.ListFormatSymbols_en_AE', 'goog.labs.i18n.ListFormatSymbols_en_AG', 'goog.labs.i18n.ListFormatSymbols_en_AI', 'goog.labs.i18n.ListFormatSymbols_en_AS', 'goog.labs.i18n.ListFormatSymbols_en_AT', 'goog.labs.i18n.ListFormatSymbols_en_BB', 'goog.labs.i18n.ListFormatSymbols_en_BE', 'goog.labs.i18n.ListFormatSymbols_en_BI', 'goog.labs.i18n.ListFormatSymbols_en_BM', 'goog.labs.i18n.ListFormatSymbols_en_BS', 'goog.labs.i18n.ListFormatSymbols_en_BW', 'goog.labs.i18n.ListFormatSymbols_en_BZ', 'goog.labs.i18n.ListFormatSymbols_en_CC', 'goog.labs.i18n.ListFormatSymbols_en_CH', 'goog.labs.i18n.ListFormatSymbols_en_CK', 'goog.labs.i18n.ListFormatSymbols_en_CM', 'goog.labs.i18n.ListFormatSymbols_en_CX', 'goog.labs.i18n.ListFormatSymbols_en_CY', 'goog.labs.i18n.ListFormatSymbols_en_DE', 'goog.labs.i18n.ListFormatSymbols_en_DG', 'goog.labs.i18n.ListFormatSymbols_en_DK', 'goog.labs.i18n.ListFormatSymbols_en_DM', 'goog.labs.i18n.ListFormatSymbols_en_ER', 'goog.labs.i18n.ListFormatSymbols_en_FI', 'goog.labs.i18n.ListFormatSymbols_en_FJ', 'goog.labs.i18n.ListFormatSymbols_en_FK', 'goog.labs.i18n.ListFormatSymbols_en_FM', 'goog.labs.i18n.ListFormatSymbols_en_GD', 'goog.labs.i18n.ListFormatSymbols_en_GG', 'goog.labs.i18n.ListFormatSymbols_en_GH', 'goog.labs.i18n.ListFormatSymbols_en_GI', 'goog.labs.i18n.ListFormatSymbols_en_GM', 'goog.labs.i18n.ListFormatSymbols_en_GU', 'goog.labs.i18n.ListFormatSymbols_en_GY', 'goog.labs.i18n.ListFormatSymbols_en_HK', 'goog.labs.i18n.ListFormatSymbols_en_IL', 'goog.labs.i18n.ListFormatSymbols_en_IM', 'goog.labs.i18n.ListFormatSymbols_en_IO', 'goog.labs.i18n.ListFormatSymbols_en_JE', 'goog.labs.i18n.ListFormatSymbols_en_JM', 'goog.labs.i18n.ListFormatSymbols_en_KE', 'goog.labs.i18n.ListFormatSymbols_en_KI', 'goog.labs.i18n.ListFormatSymbols_en_KN', 'goog.labs.i18n.ListFormatSymbols_en_KY', 'goog.labs.i18n.ListFormatSymbols_en_LC', 'goog.labs.i18n.ListFormatSymbols_en_LR', 'goog.labs.i18n.ListFormatSymbols_en_LS', 'goog.labs.i18n.ListFormatSymbols_en_MG', 'goog.labs.i18n.ListFormatSymbols_en_MH', 'goog.labs.i18n.ListFormatSymbols_en_MO', 'goog.labs.i18n.ListFormatSymbols_en_MP', 'goog.labs.i18n.ListFormatSymbols_en_MS', 'goog.labs.i18n.ListFormatSymbols_en_MT', 'goog.labs.i18n.ListFormatSymbols_en_MU', 'goog.labs.i18n.ListFormatSymbols_en_MW', 'goog.labs.i18n.ListFormatSymbols_en_MY', 'goog.labs.i18n.ListFormatSymbols_en_NA', 'goog.labs.i18n.ListFormatSymbols_en_NF', 'goog.labs.i18n.ListFormatSymbols_en_NG', 'goog.labs.i18n.ListFormatSymbols_en_NL', 'goog.labs.i18n.ListFormatSymbols_en_NR', 'goog.labs.i18n.ListFormatSymbols_en_NU', 'goog.labs.i18n.ListFormatSymbols_en_NZ', 'goog.labs.i18n.ListFormatSymbols_en_PG', 'goog.labs.i18n.ListFormatSymbols_en_PH', 'goog.labs.i18n.ListFormatSymbols_en_PK', 'goog.labs.i18n.ListFormatSymbols_en_PN', 'goog.labs.i18n.ListFormatSymbols_en_PR', 'goog.labs.i18n.ListFormatSymbols_en_PW', 'goog.labs.i18n.ListFormatSymbols_en_RW', 'goog.labs.i18n.ListFormatSymbols_en_SB', 'goog.labs.i18n.ListFormatSymbols_en_SC', 'goog.labs.i18n.ListFormatSymbols_en_SD', 'goog.labs.i18n.ListFormatSymbols_en_SE', 'goog.labs.i18n.ListFormatSymbols_en_SH', 'goog.labs.i18n.ListFormatSymbols_en_SI', 'goog.labs.i18n.ListFormatSymbols_en_SL', 'goog.labs.i18n.ListFormatSymbols_en_SS', 'goog.labs.i18n.ListFormatSymbols_en_SX', 'goog.labs.i18n.ListFormatSymbols_en_SZ', 'goog.labs.i18n.ListFormatSymbols_en_TC', 'goog.labs.i18n.ListFormatSymbols_en_TK', 'goog.labs.i18n.ListFormatSymbols_en_TO', 'goog.labs.i18n.ListFormatSymbols_en_TT', 'goog.labs.i18n.ListFormatSymbols_en_TV', 'goog.labs.i18n.ListFormatSymbols_en_TZ', 'goog.labs.i18n.ListFormatSymbols_en_UG', 'goog.labs.i18n.ListFormatSymbols_en_UM', 'goog.labs.i18n.ListFormatSymbols_en_US_POSIX', 'goog.labs.i18n.ListFormatSymbols_en_VC', 'goog.labs.i18n.ListFormatSymbols_en_VG', 'goog.labs.i18n.ListFormatSymbols_en_VI', 'goog.labs.i18n.ListFormatSymbols_en_VU', 'goog.labs.i18n.ListFormatSymbols_en_WS', 'goog.labs.i18n.ListFormatSymbols_en_XA', 'goog.labs.i18n.ListFormatSymbols_en_ZM', 'goog.labs.i18n.ListFormatSymbols_en_ZW', 'goog.labs.i18n.ListFormatSymbols_eo', 'goog.labs.i18n.ListFormatSymbols_eo_001', 'goog.labs.i18n.ListFormatSymbols_es_AR', 'goog.labs.i18n.ListFormatSymbols_es_BO', 'goog.labs.i18n.ListFormatSymbols_es_BR', 'goog.labs.i18n.ListFormatSymbols_es_BZ', 'goog.labs.i18n.ListFormatSymbols_es_CL', 'goog.labs.i18n.ListFormatSymbols_es_CO', 'goog.labs.i18n.ListFormatSymbols_es_CR', 'goog.labs.i18n.ListFormatSymbols_es_CU', 'goog.labs.i18n.ListFormatSymbols_es_DO', 'goog.labs.i18n.ListFormatSymbols_es_EA', 'goog.labs.i18n.ListFormatSymbols_es_EC', 'goog.labs.i18n.ListFormatSymbols_es_GQ', 'goog.labs.i18n.ListFormatSymbols_es_GT', 'goog.labs.i18n.ListFormatSymbols_es_HN', 'goog.labs.i18n.ListFormatSymbols_es_IC', 'goog.labs.i18n.ListFormatSymbols_es_NI', 'goog.labs.i18n.ListFormatSymbols_es_PA', 'goog.labs.i18n.ListFormatSymbols_es_PE', 'goog.labs.i18n.ListFormatSymbols_es_PH', 'goog.labs.i18n.ListFormatSymbols_es_PR', 'goog.labs.i18n.ListFormatSymbols_es_PY', 'goog.labs.i18n.ListFormatSymbols_es_SV', 'goog.labs.i18n.ListFormatSymbols_es_UY', 'goog.labs.i18n.ListFormatSymbols_es_VE', 'goog.labs.i18n.ListFormatSymbols_et_EE', 'goog.labs.i18n.ListFormatSymbols_eu_ES', 'goog.labs.i18n.ListFormatSymbols_ewo', 'goog.labs.i18n.ListFormatSymbols_ewo_CM', 'goog.labs.i18n.ListFormatSymbols_fa_AF', 'goog.labs.i18n.ListFormatSymbols_fa_IR', 'goog.labs.i18n.ListFormatSymbols_ff', 'goog.labs.i18n.ListFormatSymbols_ff_Latn', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_BF', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_CM', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_GH', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_GM', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_GN', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_GW', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_LR', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_MR', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_NE', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_NG', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_SL', 'goog.labs.i18n.ListFormatSymbols_ff_Latn_SN', 'goog.labs.i18n.ListFormatSymbols_fi_FI', 'goog.labs.i18n.ListFormatSymbols_fil_PH', 'goog.labs.i18n.ListFormatSymbols_fo', 'goog.labs.i18n.ListFormatSymbols_fo_DK', 'goog.labs.i18n.ListFormatSymbols_fo_FO', 'goog.labs.i18n.ListFormatSymbols_fr_BE', 'goog.labs.i18n.ListFormatSymbols_fr_BF', 'goog.labs.i18n.ListFormatSymbols_fr_BI', 'goog.labs.i18n.ListFormatSymbols_fr_BJ', 'goog.labs.i18n.ListFormatSymbols_fr_BL', 'goog.labs.i18n.ListFormatSymbols_fr_CD', 'goog.labs.i18n.ListFormatSymbols_fr_CF', 'goog.labs.i18n.ListFormatSymbols_fr_CG', 'goog.labs.i18n.ListFormatSymbols_fr_CH', 'goog.labs.i18n.ListFormatSymbols_fr_CI', 'goog.labs.i18n.ListFormatSymbols_fr_CM', 'goog.labs.i18n.ListFormatSymbols_fr_DJ', 'goog.labs.i18n.ListFormatSymbols_fr_DZ', 'goog.labs.i18n.ListFormatSymbols_fr_FR', 'goog.labs.i18n.ListFormatSymbols_fr_GA', 'goog.labs.i18n.ListFormatSymbols_fr_GF', 'goog.labs.i18n.ListFormatSymbols_fr_GN', 'goog.labs.i18n.ListFormatSymbols_fr_GP', 'goog.labs.i18n.ListFormatSymbols_fr_GQ', 'goog.labs.i18n.ListFormatSymbols_fr_HT', 'goog.labs.i18n.ListFormatSymbols_fr_KM', 'goog.labs.i18n.ListFormatSymbols_fr_LU', 'goog.labs.i18n.ListFormatSymbols_fr_MA', 'goog.labs.i18n.ListFormatSymbols_fr_MC', 'goog.labs.i18n.ListFormatSymbols_fr_MF', 'goog.labs.i18n.ListFormatSymbols_fr_MG', 'goog.labs.i18n.ListFormatSymbols_fr_ML', 'goog.labs.i18n.ListFormatSymbols_fr_MQ', 'goog.labs.i18n.ListFormatSymbols_fr_MR', 'goog.labs.i18n.ListFormatSymbols_fr_MU', 'goog.labs.i18n.ListFormatSymbols_fr_NC', 'goog.labs.i18n.ListFormatSymbols_fr_NE', 'goog.labs.i18n.ListFormatSymbols_fr_PF', 'goog.labs.i18n.ListFormatSymbols_fr_PM', 'goog.labs.i18n.ListFormatSymbols_fr_RE', 'goog.labs.i18n.ListFormatSymbols_fr_RW', 'goog.labs.i18n.ListFormatSymbols_fr_SC', 'goog.labs.i18n.ListFormatSymbols_fr_SN', 'goog.labs.i18n.ListFormatSymbols_fr_SY', 'goog.labs.i18n.ListFormatSymbols_fr_TD', 'goog.labs.i18n.ListFormatSymbols_fr_TG', 'goog.labs.i18n.ListFormatSymbols_fr_TN', 'goog.labs.i18n.ListFormatSymbols_fr_VU', 'goog.labs.i18n.ListFormatSymbols_fr_WF', 'goog.labs.i18n.ListFormatSymbols_fr_YT', 'goog.labs.i18n.ListFormatSymbols_fur', 'goog.labs.i18n.ListFormatSymbols_fur_IT', 'goog.labs.i18n.ListFormatSymbols_fy', 'goog.labs.i18n.ListFormatSymbols_fy_NL', 'goog.labs.i18n.ListFormatSymbols_ga_IE', 'goog.labs.i18n.ListFormatSymbols_gd', 'goog.labs.i18n.ListFormatSymbols_gd_GB', 'goog.labs.i18n.ListFormatSymbols_gl_ES', 'goog.labs.i18n.ListFormatSymbols_gsw_CH', 'goog.labs.i18n.ListFormatSymbols_gsw_FR', 'goog.labs.i18n.ListFormatSymbols_gsw_LI', 'goog.labs.i18n.ListFormatSymbols_gu_IN', 'goog.labs.i18n.ListFormatSymbols_guz', 'goog.labs.i18n.ListFormatSymbols_guz_KE', 'goog.labs.i18n.ListFormatSymbols_gv', 'goog.labs.i18n.ListFormatSymbols_gv_IM', 'goog.labs.i18n.ListFormatSymbols_ha', 'goog.labs.i18n.ListFormatSymbols_ha_GH', 'goog.labs.i18n.ListFormatSymbols_ha_NE', 'goog.labs.i18n.ListFormatSymbols_ha_NG', 'goog.labs.i18n.ListFormatSymbols_haw_US', 'goog.labs.i18n.ListFormatSymbols_he_IL', 'goog.labs.i18n.ListFormatSymbols_hi_IN', 'goog.labs.i18n.ListFormatSymbols_hr_BA', 'goog.labs.i18n.ListFormatSymbols_hr_HR', 'goog.labs.i18n.ListFormatSymbols_hsb', 'goog.labs.i18n.ListFormatSymbols_hsb_DE', 'goog.labs.i18n.ListFormatSymbols_hu_HU', 'goog.labs.i18n.ListFormatSymbols_hy_AM', 'goog.labs.i18n.ListFormatSymbols_ia', 'goog.labs.i18n.ListFormatSymbols_ia_001', 'goog.labs.i18n.ListFormatSymbols_id_ID', 'goog.labs.i18n.ListFormatSymbols_ig', 'goog.labs.i18n.ListFormatSymbols_ig_NG', 'goog.labs.i18n.ListFormatSymbols_ii', 'goog.labs.i18n.ListFormatSymbols_ii_CN', 'goog.labs.i18n.ListFormatSymbols_is_IS', 'goog.labs.i18n.ListFormatSymbols_it_CH', 'goog.labs.i18n.ListFormatSymbols_it_IT', 'goog.labs.i18n.ListFormatSymbols_it_SM', 'goog.labs.i18n.ListFormatSymbols_it_VA', 'goog.labs.i18n.ListFormatSymbols_ja_JP', 'goog.labs.i18n.ListFormatSymbols_jgo', 'goog.labs.i18n.ListFormatSymbols_jgo_CM', 'goog.labs.i18n.ListFormatSymbols_jmc', 'goog.labs.i18n.ListFormatSymbols_jmc_TZ', 'goog.labs.i18n.ListFormatSymbols_jv', 'goog.labs.i18n.ListFormatSymbols_jv_ID', 'goog.labs.i18n.ListFormatSymbols_ka_GE', 'goog.labs.i18n.ListFormatSymbols_kab', 'goog.labs.i18n.ListFormatSymbols_kab_DZ', 'goog.labs.i18n.ListFormatSymbols_kam', 'goog.labs.i18n.ListFormatSymbols_kam_KE', 'goog.labs.i18n.ListFormatSymbols_kde', 'goog.labs.i18n.ListFormatSymbols_kde_TZ', 'goog.labs.i18n.ListFormatSymbols_kea', 'goog.labs.i18n.ListFormatSymbols_kea_CV', 'goog.labs.i18n.ListFormatSymbols_khq', 'goog.labs.i18n.ListFormatSymbols_khq_ML', 'goog.labs.i18n.ListFormatSymbols_ki', 'goog.labs.i18n.ListFormatSymbols_ki_KE', 'goog.labs.i18n.ListFormatSymbols_kk_KZ', 'goog.labs.i18n.ListFormatSymbols_kkj', 'goog.labs.i18n.ListFormatSymbols_kkj_CM', 'goog.labs.i18n.ListFormatSymbols_kl', 'goog.labs.i18n.ListFormatSymbols_kl_GL', 'goog.labs.i18n.ListFormatSymbols_kln', 'goog.labs.i18n.ListFormatSymbols_kln_KE', 'goog.labs.i18n.ListFormatSymbols_km_KH', 'goog.labs.i18n.ListFormatSymbols_kn_IN', 'goog.labs.i18n.ListFormatSymbols_ko_KP', 'goog.labs.i18n.ListFormatSymbols_ko_KR', 'goog.labs.i18n.ListFormatSymbols_kok', 'goog.labs.i18n.ListFormatSymbols_kok_IN', 'goog.labs.i18n.ListFormatSymbols_ks', 'goog.labs.i18n.ListFormatSymbols_ks_IN', 'goog.labs.i18n.ListFormatSymbols_ksb', 'goog.labs.i18n.ListFormatSymbols_ksb_TZ', 'goog.labs.i18n.ListFormatSymbols_ksf', 'goog.labs.i18n.ListFormatSymbols_ksf_CM', 'goog.labs.i18n.ListFormatSymbols_ksh', 'goog.labs.i18n.ListFormatSymbols_ksh_DE', 'goog.labs.i18n.ListFormatSymbols_ku', 'goog.labs.i18n.ListFormatSymbols_ku_TR', 'goog.labs.i18n.ListFormatSymbols_kw', 'goog.labs.i18n.ListFormatSymbols_kw_GB', 'goog.labs.i18n.ListFormatSymbols_ky_KG', 'goog.labs.i18n.ListFormatSymbols_lag', 'goog.labs.i18n.ListFormatSymbols_lag_TZ', 'goog.labs.i18n.ListFormatSymbols_lb', 'goog.labs.i18n.ListFormatSymbols_lb_LU', 'goog.labs.i18n.ListFormatSymbols_lg', 'goog.labs.i18n.ListFormatSymbols_lg_UG', 'goog.labs.i18n.ListFormatSymbols_lkt', 'goog.labs.i18n.ListFormatSymbols_lkt_US', 'goog.labs.i18n.ListFormatSymbols_ln_AO', 'goog.labs.i18n.ListFormatSymbols_ln_CD', 'goog.labs.i18n.ListFormatSymbols_ln_CF', 'goog.labs.i18n.ListFormatSymbols_ln_CG', 'goog.labs.i18n.ListFormatSymbols_lo_LA', 'goog.labs.i18n.ListFormatSymbols_lrc', 'goog.labs.i18n.ListFormatSymbols_lrc_IQ', 'goog.labs.i18n.ListFormatSymbols_lrc_IR', 'goog.labs.i18n.ListFormatSymbols_lt_LT', 'goog.labs.i18n.ListFormatSymbols_lu', 'goog.labs.i18n.ListFormatSymbols_lu_CD', 'goog.labs.i18n.ListFormatSymbols_luo', 'goog.labs.i18n.ListFormatSymbols_luo_KE', 'goog.labs.i18n.ListFormatSymbols_luy', 'goog.labs.i18n.ListFormatSymbols_luy_KE', 'goog.labs.i18n.ListFormatSymbols_lv_LV', 'goog.labs.i18n.ListFormatSymbols_mas', 'goog.labs.i18n.ListFormatSymbols_mas_KE', 'goog.labs.i18n.ListFormatSymbols_mas_TZ', 'goog.labs.i18n.ListFormatSymbols_mer', 'goog.labs.i18n.ListFormatSymbols_mer_KE', 'goog.labs.i18n.ListFormatSymbols_mfe', 'goog.labs.i18n.ListFormatSymbols_mfe_MU', 'goog.labs.i18n.ListFormatSymbols_mg', 'goog.labs.i18n.ListFormatSymbols_mg_MG', 'goog.labs.i18n.ListFormatSymbols_mgh', 'goog.labs.i18n.ListFormatSymbols_mgh_MZ', 'goog.labs.i18n.ListFormatSymbols_mgo', 'goog.labs.i18n.ListFormatSymbols_mgo_CM', 'goog.labs.i18n.ListFormatSymbols_mi', 'goog.labs.i18n.ListFormatSymbols_mi_NZ', 'goog.labs.i18n.ListFormatSymbols_mk_MK', 'goog.labs.i18n.ListFormatSymbols_ml_IN', 'goog.labs.i18n.ListFormatSymbols_mn_MN', 'goog.labs.i18n.ListFormatSymbols_mr_IN', 'goog.labs.i18n.ListFormatSymbols_ms_BN', 'goog.labs.i18n.ListFormatSymbols_ms_MY', 'goog.labs.i18n.ListFormatSymbols_ms_SG', 'goog.labs.i18n.ListFormatSymbols_mt_MT', 'goog.labs.i18n.ListFormatSymbols_mua', 'goog.labs.i18n.ListFormatSymbols_mua_CM', 'goog.labs.i18n.ListFormatSymbols_my_MM', 'goog.labs.i18n.ListFormatSymbols_mzn', 'goog.labs.i18n.ListFormatSymbols_mzn_IR', 'goog.labs.i18n.ListFormatSymbols_naq', 'goog.labs.i18n.ListFormatSymbols_naq_NA', 'goog.labs.i18n.ListFormatSymbols_nb_NO', 'goog.labs.i18n.ListFormatSymbols_nb_SJ', 'goog.labs.i18n.ListFormatSymbols_nd', 'goog.labs.i18n.ListFormatSymbols_nd_ZW', 'goog.labs.i18n.ListFormatSymbols_nds', 'goog.labs.i18n.ListFormatSymbols_nds_DE', 'goog.labs.i18n.ListFormatSymbols_nds_NL', 'goog.labs.i18n.ListFormatSymbols_ne_IN', 'goog.labs.i18n.ListFormatSymbols_ne_NP', 'goog.labs.i18n.ListFormatSymbols_nl_AW', 'goog.labs.i18n.ListFormatSymbols_nl_BE', 'goog.labs.i18n.ListFormatSymbols_nl_BQ', 'goog.labs.i18n.ListFormatSymbols_nl_CW', 'goog.labs.i18n.ListFormatSymbols_nl_NL', 'goog.labs.i18n.ListFormatSymbols_nl_SR', 'goog.labs.i18n.ListFormatSymbols_nl_SX', 'goog.labs.i18n.ListFormatSymbols_nmg', 'goog.labs.i18n.ListFormatSymbols_nmg_CM', 'goog.labs.i18n.ListFormatSymbols_nn', 'goog.labs.i18n.ListFormatSymbols_nn_NO', 'goog.labs.i18n.ListFormatSymbols_nnh', 'goog.labs.i18n.ListFormatSymbols_nnh_CM', 'goog.labs.i18n.ListFormatSymbols_nus', 'goog.labs.i18n.ListFormatSymbols_nus_SS', 'goog.labs.i18n.ListFormatSymbols_nyn', 'goog.labs.i18n.ListFormatSymbols_nyn_UG', 'goog.labs.i18n.ListFormatSymbols_om', 'goog.labs.i18n.ListFormatSymbols_om_ET', 'goog.labs.i18n.ListFormatSymbols_om_KE', 'goog.labs.i18n.ListFormatSymbols_or_IN', 'goog.labs.i18n.ListFormatSymbols_os', 'goog.labs.i18n.ListFormatSymbols_os_GE', 'goog.labs.i18n.ListFormatSymbols_os_RU', 'goog.labs.i18n.ListFormatSymbols_pa_Arab', 'goog.labs.i18n.ListFormatSymbols_pa_Arab_PK', 'goog.labs.i18n.ListFormatSymbols_pa_Guru', 'goog.labs.i18n.ListFormatSymbols_pa_Guru_IN', 'goog.labs.i18n.ListFormatSymbols_pl_PL', 'goog.labs.i18n.ListFormatSymbols_ps', 'goog.labs.i18n.ListFormatSymbols_ps_AF', 'goog.labs.i18n.ListFormatSymbols_ps_PK', 'goog.labs.i18n.ListFormatSymbols_pt_AO', 'goog.labs.i18n.ListFormatSymbols_pt_CH', 'goog.labs.i18n.ListFormatSymbols_pt_CV', 'goog.labs.i18n.ListFormatSymbols_pt_GQ', 'goog.labs.i18n.ListFormatSymbols_pt_GW', 'goog.labs.i18n.ListFormatSymbols_pt_LU', 'goog.labs.i18n.ListFormatSymbols_pt_MO', 'goog.labs.i18n.ListFormatSymbols_pt_MZ', 'goog.labs.i18n.ListFormatSymbols_pt_ST', 'goog.labs.i18n.ListFormatSymbols_pt_TL', 'goog.labs.i18n.ListFormatSymbols_qu', 'goog.labs.i18n.ListFormatSymbols_qu_BO', 'goog.labs.i18n.ListFormatSymbols_qu_EC', 'goog.labs.i18n.ListFormatSymbols_qu_PE', 'goog.labs.i18n.ListFormatSymbols_rm', 'goog.labs.i18n.ListFormatSymbols_rm_CH', 'goog.labs.i18n.ListFormatSymbols_rn', 'goog.labs.i18n.ListFormatSymbols_rn_BI', 'goog.labs.i18n.ListFormatSymbols_ro_MD', 'goog.labs.i18n.ListFormatSymbols_ro_RO', 'goog.labs.i18n.ListFormatSymbols_rof', 'goog.labs.i18n.ListFormatSymbols_rof_TZ', 'goog.labs.i18n.ListFormatSymbols_ru_BY', 'goog.labs.i18n.ListFormatSymbols_ru_KG', 'goog.labs.i18n.ListFormatSymbols_ru_KZ', 'goog.labs.i18n.ListFormatSymbols_ru_MD', 'goog.labs.i18n.ListFormatSymbols_ru_RU', 'goog.labs.i18n.ListFormatSymbols_ru_UA', 'goog.labs.i18n.ListFormatSymbols_rw', 'goog.labs.i18n.ListFormatSymbols_rw_RW', 'goog.labs.i18n.ListFormatSymbols_rwk', 'goog.labs.i18n.ListFormatSymbols_rwk_TZ', 'goog.labs.i18n.ListFormatSymbols_sah', 'goog.labs.i18n.ListFormatSymbols_sah_RU', 'goog.labs.i18n.ListFormatSymbols_saq', 'goog.labs.i18n.ListFormatSymbols_saq_KE', 'goog.labs.i18n.ListFormatSymbols_sbp', 'goog.labs.i18n.ListFormatSymbols_sbp_TZ', 'goog.labs.i18n.ListFormatSymbols_sd', 'goog.labs.i18n.ListFormatSymbols_sd_PK', 'goog.labs.i18n.ListFormatSymbols_se', 'goog.labs.i18n.ListFormatSymbols_se_FI', 'goog.labs.i18n.ListFormatSymbols_se_NO', 'goog.labs.i18n.ListFormatSymbols_se_SE', 'goog.labs.i18n.ListFormatSymbols_seh', 'goog.labs.i18n.ListFormatSymbols_seh_MZ', 'goog.labs.i18n.ListFormatSymbols_ses', 'goog.labs.i18n.ListFormatSymbols_ses_ML', 'goog.labs.i18n.ListFormatSymbols_sg', 'goog.labs.i18n.ListFormatSymbols_sg_CF', 'goog.labs.i18n.ListFormatSymbols_shi', 'goog.labs.i18n.ListFormatSymbols_shi_Latn', 'goog.labs.i18n.ListFormatSymbols_shi_Latn_MA', 'goog.labs.i18n.ListFormatSymbols_shi_Tfng', 'goog.labs.i18n.ListFormatSymbols_shi_Tfng_MA', 'goog.labs.i18n.ListFormatSymbols_si_LK', 'goog.labs.i18n.ListFormatSymbols_sk_SK', 'goog.labs.i18n.ListFormatSymbols_sl_SI', 'goog.labs.i18n.ListFormatSymbols_smn', 'goog.labs.i18n.ListFormatSymbols_smn_FI', 'goog.labs.i18n.ListFormatSymbols_sn', 'goog.labs.i18n.ListFormatSymbols_sn_ZW', 'goog.labs.i18n.ListFormatSymbols_so', 'goog.labs.i18n.ListFormatSymbols_so_DJ', 'goog.labs.i18n.ListFormatSymbols_so_ET', 'goog.labs.i18n.ListFormatSymbols_so_KE', 'goog.labs.i18n.ListFormatSymbols_so_SO', 'goog.labs.i18n.ListFormatSymbols_sq_AL', 'goog.labs.i18n.ListFormatSymbols_sq_MK', 'goog.labs.i18n.ListFormatSymbols_sq_XK', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl_BA', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl_ME', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl_RS', 'goog.labs.i18n.ListFormatSymbols_sr_Cyrl_XK', 'goog.labs.i18n.ListFormatSymbols_sr_Latn_BA', 'goog.labs.i18n.ListFormatSymbols_sr_Latn_ME', 'goog.labs.i18n.ListFormatSymbols_sr_Latn_RS', 'goog.labs.i18n.ListFormatSymbols_sr_Latn_XK', 'goog.labs.i18n.ListFormatSymbols_sv_AX', 'goog.labs.i18n.ListFormatSymbols_sv_FI', 'goog.labs.i18n.ListFormatSymbols_sv_SE', 'goog.labs.i18n.ListFormatSymbols_sw_CD', 'goog.labs.i18n.ListFormatSymbols_sw_KE', 'goog.labs.i18n.ListFormatSymbols_sw_TZ', 'goog.labs.i18n.ListFormatSymbols_sw_UG', 'goog.labs.i18n.ListFormatSymbols_ta_IN', 'goog.labs.i18n.ListFormatSymbols_ta_LK', 'goog.labs.i18n.ListFormatSymbols_ta_MY', 'goog.labs.i18n.ListFormatSymbols_ta_SG', 'goog.labs.i18n.ListFormatSymbols_te_IN', 'goog.labs.i18n.ListFormatSymbols_teo', 'goog.labs.i18n.ListFormatSymbols_teo_KE', 'goog.labs.i18n.ListFormatSymbols_teo_UG', 'goog.labs.i18n.ListFormatSymbols_tg', 'goog.labs.i18n.ListFormatSymbols_tg_TJ', 'goog.labs.i18n.ListFormatSymbols_th_TH', 'goog.labs.i18n.ListFormatSymbols_ti', 'goog.labs.i18n.ListFormatSymbols_ti_ER', 'goog.labs.i18n.ListFormatSymbols_ti_ET', 'goog.labs.i18n.ListFormatSymbols_tk', 'goog.labs.i18n.ListFormatSymbols_tk_TM', 'goog.labs.i18n.ListFormatSymbols_to', 'goog.labs.i18n.ListFormatSymbols_to_TO', 'goog.labs.i18n.ListFormatSymbols_tr_CY', 'goog.labs.i18n.ListFormatSymbols_tr_TR', 'goog.labs.i18n.ListFormatSymbols_tt', 'goog.labs.i18n.ListFormatSymbols_tt_RU', 'goog.labs.i18n.ListFormatSymbols_twq', 'goog.labs.i18n.ListFormatSymbols_twq_NE', 'goog.labs.i18n.ListFormatSymbols_tzm', 'goog.labs.i18n.ListFormatSymbols_tzm_MA', 'goog.labs.i18n.ListFormatSymbols_ug', 'goog.labs.i18n.ListFormatSymbols_ug_CN', 'goog.labs.i18n.ListFormatSymbols_uk_UA', 'goog.labs.i18n.ListFormatSymbols_ur_IN', 'goog.labs.i18n.ListFormatSymbols_ur_PK', 'goog.labs.i18n.ListFormatSymbols_uz_Arab', 'goog.labs.i18n.ListFormatSymbols_uz_Arab_AF', 'goog.labs.i18n.ListFormatSymbols_uz_Cyrl', 'goog.labs.i18n.ListFormatSymbols_uz_Cyrl_UZ', 'goog.labs.i18n.ListFormatSymbols_uz_Latn', 'goog.labs.i18n.ListFormatSymbols_uz_Latn_UZ', 'goog.labs.i18n.ListFormatSymbols_vai', 'goog.labs.i18n.ListFormatSymbols_vai_Latn', 'goog.labs.i18n.ListFormatSymbols_vai_Latn_LR', 'goog.labs.i18n.ListFormatSymbols_vai_Vaii', 'goog.labs.i18n.ListFormatSymbols_vai_Vaii_LR', 'goog.labs.i18n.ListFormatSymbols_vi_VN', 'goog.labs.i18n.ListFormatSymbols_vun', 'goog.labs.i18n.ListFormatSymbols_vun_TZ', 'goog.labs.i18n.ListFormatSymbols_wae', 'goog.labs.i18n.ListFormatSymbols_wae_CH', 'goog.labs.i18n.ListFormatSymbols_wo', 'goog.labs.i18n.ListFormatSymbols_wo_SN', 'goog.labs.i18n.ListFormatSymbols_xh', 'goog.labs.i18n.ListFormatSymbols_xh_ZA', 'goog.labs.i18n.ListFormatSymbols_xog', 'goog.labs.i18n.ListFormatSymbols_xog_UG', 'goog.labs.i18n.ListFormatSymbols_yav', 'goog.labs.i18n.ListFormatSymbols_yav_CM', 'goog.labs.i18n.ListFormatSymbols_yi', 'goog.labs.i18n.ListFormatSymbols_yi_001', 'goog.labs.i18n.ListFormatSymbols_yo', 'goog.labs.i18n.ListFormatSymbols_yo_BJ', 'goog.labs.i18n.ListFormatSymbols_yo_NG', 'goog.labs.i18n.ListFormatSymbols_yue', 'goog.labs.i18n.ListFormatSymbols_yue_Hans', 'goog.labs.i18n.ListFormatSymbols_yue_Hans_CN', 'goog.labs.i18n.ListFormatSymbols_yue_Hant', 'goog.labs.i18n.ListFormatSymbols_yue_Hant_HK', 'goog.labs.i18n.ListFormatSymbols_zgh', 'goog.labs.i18n.ListFormatSymbols_zgh_MA', 'goog.labs.i18n.ListFormatSymbols_zh_Hans', 'goog.labs.i18n.ListFormatSymbols_zh_Hans_CN', 'goog.labs.i18n.ListFormatSymbols_zh_Hans_HK', 'goog.labs.i18n.ListFormatSymbols_zh_Hans_MO', 'goog.labs.i18n.ListFormatSymbols_zh_Hans_SG', 'goog.labs.i18n.ListFormatSymbols_zh_Hant', 'goog.labs.i18n.ListFormatSymbols_zh_Hant_HK', 'goog.labs.i18n.ListFormatSymbols_zh_Hant_MO', 'goog.labs.i18n.ListFormatSymbols_zh_Hant_TW', 'goog.labs.i18n.ListFormatSymbols_zu_ZA'], ['goog.labs.i18n.ListFormatSymbols'], {});
goog.addDependency('labs/mock/mock.js', ['goog.labs.mock', 'goog.labs.mock.TimeoutError', 'goog.labs.mock.VerificationError'], ['goog.array', 'goog.asserts', 'goog.debug', 'goog.debug.Error', 'goog.functions', 'goog.labs.mock.timeout', 'goog.labs.mock.timeout.TimeoutMode', 'goog.labs.mock.verification', 'goog.labs.mock.verification.BaseVerificationMode', 'goog.labs.mock.verification.VerificationMode', 'goog.object'], {'lang': 'es6'});
goog.addDependency('labs/mock/mock_test.js', ['goog.labs.mockTest'], ['goog.array', 'goog.labs.mock', 'goog.labs.mock.TimeoutError', 'goog.labs.mock.VerificationError', 'goog.labs.mock.timeout', 'goog.labs.mock.verification', 'goog.labs.testing.AnythingMatcher', 'goog.labs.testing.GreaterThanMatcher', 'goog.string', 'goog.testing.jsunit'], {'lang': 'es8'});
goog.addDependency('labs/mock/timeoutmode.js', ['goog.labs.mock.timeout', 'goog.labs.mock.timeout.TimeoutMode'], [], {'lang': 'es6'});
goog.addDependency('labs/mock/verificationmode.js', ['goog.labs.mock.verification', 'goog.labs.mock.verification.BaseVerificationMode', 'goog.labs.mock.verification.VerificationMode'], [], {'lang': 'es6'});
goog.addDependency('labs/mock/verificationmode_test.js', ['goog.labs.mock.VerificationModeTest'], ['goog.labs.mock.verification', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/image.js', ['goog.labs.net.image'], ['goog.Promise', 'goog.dom.safe', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.html.SafeUrl', 'goog.net.EventType', 'goog.userAgent'], {});
goog.addDependency('labs/net/image_test.js', ['goog.labs.net.imageTest'], ['goog.labs.net.image', 'goog.string', 'goog.testing.TestCase', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel.js', ['goog.net.WebChannel'], ['goog.events', 'goog.events.Event', 'goog.events.Listenable', 'goog.net.XmlHttpFactory'], {});
goog.addDependency('labs/net/webchannel/basetestchannel.js', ['goog.labs.net.webChannel.BaseTestChannel'], ['goog.labs.net.webChannel.Channel', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.requestStats', 'goog.net.WebChannel'], {});
goog.addDependency('labs/net/webchannel/channel.js', ['goog.labs.net.webChannel.Channel'], [], {'lang': 'es6'});
goog.addDependency('labs/net/webchannel/channelrequest.js', ['goog.labs.net.webChannel.ChannelRequest'], ['goog.Timer', 'goog.async.Throttle', 'goog.events.EventHandler', 'goog.labs.net.webChannel.Channel', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.environment', 'goog.labs.net.webChannel.requestStats', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.WebChannel', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('labs/net/webchannel/channelrequest_test.js', ['goog.labs.net.webChannel.channelRequestTest'], ['goog.Uri', 'goog.functions', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.requestStats', 'goog.labs.net.webChannel.requestStats.ServerReachability', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.net.XhrIo', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/connectionstate.js', ['goog.labs.net.webChannel.ConnectionState'], [], {});
goog.addDependency('labs/net/webchannel/environment.js', ['goog.labs.net.webChannel.environment'], ['goog.userAgent'], {'module': 'goog'});
goog.addDependency('labs/net/webchannel/environment_test.js', ['goog.labs.net.webChannel.EnvironmentTest'], ['goog.labs.net.webChannel.environment', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/forwardchannelrequestpool.js', ['goog.labs.net.webChannel.ForwardChannelRequestPool'], ['goog.array', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.Wire', 'goog.string', 'goog.structs.Set'], {'module': 'goog'});
goog.addDependency('labs/net/webchannel/forwardchannelrequestpool_test.js', ['goog.labs.net.webChannel.ForwardChannelRequestPoolTest'], ['goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.ForwardChannelRequestPool', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/netutils.js', ['goog.labs.net.webChannel.netUtils'], ['goog.Uri', 'goog.labs.net.webChannel.WebChannelDebug'], {});
goog.addDependency('labs/net/webchannel/requeststats.js', ['goog.labs.net.webChannel.requestStats', 'goog.labs.net.webChannel.requestStats.Event', 'goog.labs.net.webChannel.requestStats.ServerReachability', 'goog.labs.net.webChannel.requestStats.ServerReachabilityEvent', 'goog.labs.net.webChannel.requestStats.Stat', 'goog.labs.net.webChannel.requestStats.StatEvent', 'goog.labs.net.webChannel.requestStats.TimingEvent'], ['goog.events.Event', 'goog.events.EventTarget'], {});
goog.addDependency('labs/net/webchannel/webchannelbase.js', ['goog.labs.net.webChannel.WebChannelBase'], ['goog.Uri', 'goog.array', 'goog.asserts', 'goog.async.run', 'goog.json', 'goog.labs.net.webChannel.BaseTestChannel', 'goog.labs.net.webChannel.Channel', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.ConnectionState', 'goog.labs.net.webChannel.ForwardChannelRequestPool', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.Wire', 'goog.labs.net.webChannel.WireV8', 'goog.labs.net.webChannel.netUtils', 'goog.labs.net.webChannel.requestStats', 'goog.net.WebChannel', 'goog.net.XhrIo', 'goog.net.XmlHttpFactory', 'goog.net.rpc.HttpCors', 'goog.object', 'goog.string', 'goog.structs'], {});
goog.addDependency('labs/net/webchannel/webchannelbase_test.js', ['goog.labs.net.webChannel.webChannelBaseTest'], ['goog.Timer', 'goog.array', 'goog.dom', 'goog.functions', 'goog.json', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.ForwardChannelRequestPool', 'goog.labs.net.webChannel.WebChannelBase', 'goog.labs.net.webChannel.WebChannelBaseTransport', 'goog.labs.net.webChannel.WebChannelDebug', 'goog.labs.net.webChannel.Wire', 'goog.labs.net.webChannel.netUtils', 'goog.labs.net.webChannel.requestStats', 'goog.labs.net.webChannel.requestStats.Stat', 'goog.structs.Map', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/webchannelbasetransport.js', ['goog.labs.net.webChannel.WebChannelBaseTransport'], ['goog.asserts', 'goog.events.EventTarget', 'goog.json', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.WebChannelBase', 'goog.labs.net.webChannel.Wire', 'goog.log', 'goog.net.WebChannel', 'goog.net.WebChannelTransport', 'goog.object', 'goog.string', 'goog.string.path'], {});
goog.addDependency('labs/net/webchannel/webchannelbasetransport_test.js', ['goog.labs.net.webChannel.webChannelBaseTransportTest'], ['goog.events', 'goog.functions', 'goog.json', 'goog.labs.net.webChannel.ChannelRequest', 'goog.labs.net.webChannel.WebChannelBase', 'goog.labs.net.webChannel.WebChannelBaseTransport', 'goog.labs.net.webChannel.Wire', 'goog.net.WebChannel', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchannel/webchanneldebug.js', ['goog.labs.net.webChannel.WebChannelDebug'], ['goog.json', 'goog.log'], {});
goog.addDependency('labs/net/webchannel/wire.js', ['goog.labs.net.webChannel.Wire'], [], {'lang': 'es6'});
goog.addDependency('labs/net/webchannel/wirev8.js', ['goog.labs.net.webChannel.WireV8'], ['goog.asserts', 'goog.json', 'goog.json.NativeJsonProcessor', 'goog.labs.net.webChannel.Wire', 'goog.structs'], {});
goog.addDependency('labs/net/webchannel/wirev8_test.js', ['goog.labs.net.webChannel.WireV8Test'], ['goog.labs.net.webChannel.WireV8', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/net/webchanneltransport.js', ['goog.net.WebChannelTransport'], [], {});
goog.addDependency('labs/net/webchanneltransportfactory.js', ['goog.net.createWebChannelTransport'], ['goog.functions', 'goog.labs.net.webChannel.WebChannelBaseTransport'], {});
goog.addDependency('labs/net/xhr.js', ['goog.labs.net.xhr', 'goog.labs.net.xhr.Error', 'goog.labs.net.xhr.HttpError', 'goog.labs.net.xhr.Options', 'goog.labs.net.xhr.PostData', 'goog.labs.net.xhr.ResponseType', 'goog.labs.net.xhr.TimeoutError'], ['goog.Promise', 'goog.asserts', 'goog.debug.Error', 'goog.net.HttpStatus', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.uri.utils', 'goog.userAgent'], {});
goog.addDependency('labs/net/xhr_test.js', ['goog.labs.net.xhrTest'], ['goog.Promise', 'goog.events', 'goog.events.EventType', 'goog.labs.net.xhr', 'goog.net.WrapperXmlHttpFactory', 'goog.net.XhrLike', 'goog.net.XmlHttp', 'goog.testing.MockClock', 'goog.testing.TestCase', 'goog.testing.jsunit', 'goog.userAgent'], {'lang': 'es6'});
goog.addDependency('labs/pubsub/broadcastpubsub.js', ['goog.labs.pubsub.BroadcastPubSub'], ['goog.Disposable', 'goog.Timer', 'goog.array', 'goog.async.run', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.log', 'goog.math', 'goog.pubsub.PubSub', 'goog.storage.Storage', 'goog.storage.mechanism.HTML5LocalStorage', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('labs/pubsub/broadcastpubsub_test.js', ['goog.labs.pubsub.BroadcastPubSubTest'], ['goog.array', 'goog.debug.Logger', 'goog.json', 'goog.labs.pubsub.BroadcastPubSub', 'goog.storage.Storage', 'goog.structs.Map', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/storage/boundedcollectablestorage.js', ['goog.labs.storage.BoundedCollectableStorage'], ['goog.array', 'goog.asserts', 'goog.iter', 'goog.storage.CollectableStorage', 'goog.storage.ErrorCode', 'goog.storage.ExpiringStorage'], {});
goog.addDependency('labs/storage/boundedcollectablestorage_test.js', ['goog.labs.storage.BoundedCollectableStorageTest'], ['goog.labs.storage.BoundedCollectableStorage', 'goog.storage.collectableStorageTester', 'goog.storage.storageTester', 'goog.testing.MockClock', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/structs/multimap.js', ['goog.labs.structs.Multimap'], ['goog.array', 'goog.object'], {'lang': 'es6'});
goog.addDependency('labs/structs/multimap_test.js', ['goog.labs.structs.MultimapTest'], ['goog.labs.structs.Multimap', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/style/pixeldensitymonitor.js', ['goog.labs.style.PixelDensityMonitor', 'goog.labs.style.PixelDensityMonitor.Density', 'goog.labs.style.PixelDensityMonitor.EventType'], ['goog.events', 'goog.events.EventTarget'], {});
goog.addDependency('labs/style/pixeldensitymonitor_test.js', ['goog.labs.style.PixelDensityMonitorTest'], ['goog.array', 'goog.dom.DomHelper', 'goog.events', 'goog.labs.style.PixelDensityMonitor', 'goog.testing.MockControl', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/assertthat.js', ['goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat'], ['goog.debug.Error'], {});
goog.addDependency('labs/testing/assertthat_test.js', ['goog.labs.testing.assertThatTest'], ['goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/decoratormatcher.js', ['goog.labs.testing.AnythingMatcher'], ['goog.labs.testing.Matcher'], {});
goog.addDependency('labs/testing/decoratormatcher_test.js', ['goog.labs.testing.decoratorMatcherTest'], ['goog.labs.testing.AnythingMatcher', 'goog.labs.testing.GreaterThanMatcher', 'goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/dictionarymatcher.js', ['goog.labs.testing.HasEntriesMatcher', 'goog.labs.testing.HasEntryMatcher', 'goog.labs.testing.HasKeyMatcher', 'goog.labs.testing.HasValueMatcher'], ['goog.asserts', 'goog.labs.testing.Matcher', 'goog.object'], {});
goog.addDependency('labs/testing/dictionarymatcher_test.js', ['goog.labs.testing.dictionaryMatcherTest'], ['goog.labs.testing.HasEntryMatcher', 'goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/environment.js', ['goog.labs.testing.Environment'], ['goog.Thenable', 'goog.array', 'goog.asserts', 'goog.debug.Console', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('labs/testing/environment_test.js', ['goog.labs.testing.environmentTest'], ['goog.asserts', 'goog.labs.testing.Environment', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('labs/testing/environment_usage_test.js', ['goog.labs.testing.environmentUsageTest'], ['goog.labs.testing.Environment', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/json_fuzzing.js', ['goog.labs.testing.JsonFuzzing'], ['goog.string', 'goog.testing.PseudoRandom'], {});
goog.addDependency('labs/testing/json_fuzzing_test.js', ['goog.labs.testing.JsonFuzzingTest'], ['goog.json', 'goog.labs.testing.JsonFuzzing', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/logicmatcher.js', ['goog.labs.testing.AllOfMatcher', 'goog.labs.testing.AnyOfMatcher', 'goog.labs.testing.IsNotMatcher', 'goog.labs.testing.logicMatchers'], ['goog.array', 'goog.labs.testing.Matcher'], {});
goog.addDependency('labs/testing/logicmatcher_test.js', ['goog.labs.testing.logicMatcherTest'], ['goog.labs.testing.AllOfMatcher', 'goog.labs.testing.GreaterThanMatcher', 'goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/matcher.js', ['goog.labs.testing.Matcher'], [], {'lang': 'es6'});
goog.addDependency('labs/testing/numbermatcher.js', ['goog.labs.testing.AnyNumberMatcher', 'goog.labs.testing.CloseToMatcher', 'goog.labs.testing.EqualToMatcher', 'goog.labs.testing.GreaterThanEqualToMatcher', 'goog.labs.testing.GreaterThanMatcher', 'goog.labs.testing.LessThanEqualToMatcher', 'goog.labs.testing.LessThanMatcher'], ['goog.asserts', 'goog.labs.testing.Matcher'], {});
goog.addDependency('labs/testing/numbermatcher_test.js', ['goog.labs.testing.numberMatcherTest'], ['goog.labs.testing.LessThanMatcher', 'goog.labs.testing.MatcherError', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/objectmatcher.js', ['goog.labs.testing.AnyObjectMatcher', 'goog.labs.testing.HasPropertyMatcher', 'goog.labs.testing.InstanceOfMatcher', 'goog.labs.testing.IsNullMatcher', 'goog.labs.testing.IsNullOrUndefinedMatcher', 'goog.labs.testing.IsUndefinedMatcher', 'goog.labs.testing.ObjectEqualsMatcher'], ['goog.labs.testing.Matcher'], {});
goog.addDependency('labs/testing/objectmatcher_test.js', ['goog.labs.testing.objectMatcherTest'], ['goog.labs.testing.MatcherError', 'goog.labs.testing.ObjectEqualsMatcher', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/testing/stringmatcher.js', ['goog.labs.testing.AnyStringMatcher', 'goog.labs.testing.ContainsStringMatcher', 'goog.labs.testing.EndsWithMatcher', 'goog.labs.testing.EqualToIgnoringWhitespaceMatcher', 'goog.labs.testing.EqualsMatcher', 'goog.labs.testing.RegexMatcher', 'goog.labs.testing.StartsWithMatcher', 'goog.labs.testing.StringContainsInOrderMatcher'], ['goog.asserts', 'goog.labs.testing.Matcher', 'goog.string'], {});
goog.addDependency('labs/testing/stringmatcher_test.js', ['goog.labs.testing.stringMatcherTest'], ['goog.labs.testing.MatcherError', 'goog.labs.testing.StringContainsInOrderMatcher', 'goog.labs.testing.assertThat', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/browser.js', ['goog.labs.userAgent.browser'], ['goog.array', 'goog.labs.userAgent.util', 'goog.object', 'goog.string.internal'], {});
goog.addDependency('labs/useragent/browser_test.js', ['goog.labs.userAgent.browserTest'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/device.js', ['goog.labs.userAgent.device'], ['goog.labs.userAgent.util'], {});
goog.addDependency('labs/useragent/device_test.js', ['goog.labs.userAgent.deviceTest'], ['goog.labs.userAgent.device', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/engine.js', ['goog.labs.userAgent.engine'], ['goog.array', 'goog.labs.userAgent.util', 'goog.string'], {});
goog.addDependency('labs/useragent/engine_test.js', ['goog.labs.userAgent.engineTest'], ['goog.labs.userAgent.engine', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/extra.js', ['goog.labs.userAgent.extra'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.platform'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/extra_test.js', ['goog.labs.userAgent.extraTest'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.extra', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/platform.js', ['goog.labs.userAgent.platform'], ['goog.labs.userAgent.util', 'goog.string'], {});
goog.addDependency('labs/useragent/platform_test.js', ['goog.labs.userAgent.platformTest'], ['goog.labs.userAgent.platform', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/test_agents.js', ['goog.labs.userAgent.testAgents'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/util.js', ['goog.labs.userAgent.util'], ['goog.string.internal'], {});
goog.addDependency('labs/useragent/util_test.js', ['goog.labs.userAgent.utilTest'], ['goog.functions', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('labs/useragent/verifier.js', ['goog.labs.useragent.verifier'], [], {'lang': 'es6'});
goog.addDependency('labs/useragent/verifier_test.js', ['goog.labs.useragent.verifierTest'], ['goog.labs.userAgent.browser', 'goog.labs.useragent.verifier', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('loader/abstractmodulemanager.js', ['goog.loader.AbstractModuleManager', 'goog.loader.AbstractModuleManager.CallbackType', 'goog.loader.AbstractModuleManager.FailureType'], ['goog.module.AbstractModuleLoader', 'goog.module.ModuleInfo', 'goog.module.ModuleLoadCallback'], {});
goog.addDependency('loader/activemodulemanager.js', ['goog.loader.activeModuleManager'], ['goog.asserts', 'goog.loader.AbstractModuleManager'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('locale/countries.js', ['goog.locale.countries'], [], {});
goog.addDependency('locale/countrylanguagenames_test.js', ['goog.locale.countryLanguageNamesTest'], ['goog.locale', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('locale/defaultlocalenameconstants.js', ['goog.locale.defaultLocaleNameConstants'], [], {});
goog.addDependency('locale/genericfontnames.js', ['goog.locale.genericFontNames'], [], {});
goog.addDependency('locale/genericfontnames_test.js', ['goog.locale.genericFontNamesTest'], ['goog.locale.genericFontNames', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('locale/genericfontnamesdata.js', ['goog.locale.genericFontNamesData'], [], {});
goog.addDependency('locale/locale.js', ['goog.locale'], ['goog.locale.nativeNameConstants'], {});
goog.addDependency('locale/nativenameconstants.js', ['goog.locale.nativeNameConstants'], [], {});
goog.addDependency('locale/scriptToLanguages.js', ['goog.locale.scriptToLanguages'], ['goog.locale'], {});
goog.addDependency('locale/timezonedetection.js', ['goog.locale.timeZoneDetection'], ['goog.locale.TimeZoneFingerprint'], {});
goog.addDependency('locale/timezonedetection_test.js', ['goog.locale.timeZoneDetectionTest'], ['goog.locale.timeZoneDetection', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('locale/timezonefingerprint.js', ['goog.locale.TimeZoneFingerprint'], [], {});
goog.addDependency('locale/timezonelist.js', ['goog.locale.TimeZoneList', 'goog.locale.getTimeZoneAllLongNames', 'goog.locale.getTimeZoneSelectedLongNames', 'goog.locale.getTimeZoneSelectedShortNames'], ['goog.locale'], {});
goog.addDependency('locale/timezonelist_test.js', ['goog.locale.TimeZoneListTest'], ['goog.locale', 'goog.locale.TimeZoneList', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('log/log.js', ['goog.log', 'goog.log.Level', 'goog.log.LogRecord', 'goog.log.Logger'], ['goog.debug', 'goog.debug.LogManager', 'goog.debug.LogRecord', 'goog.debug.Logger'], {});
goog.addDependency('log/log_test.js', ['goog.logTest'], ['goog.debug.LogManager', 'goog.log', 'goog.log.Level', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/affinetransform.js', ['goog.math.AffineTransform'], [], {'lang': 'es6'});
goog.addDependency('math/affinetransform_test.js', ['goog.math.AffineTransformTest'], ['goog.array', 'goog.math', 'goog.math.AffineTransform', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/bezier.js', ['goog.math.Bezier'], ['goog.math', 'goog.math.Coordinate'], {});
goog.addDependency('math/bezier_test.js', ['goog.math.BezierTest'], ['goog.math', 'goog.math.Bezier', 'goog.math.Coordinate', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/box.js', ['goog.math.Box'], ['goog.asserts', 'goog.math.Coordinate'], {});
goog.addDependency('math/box_test.js', ['goog.math.BoxTest'], ['goog.math.Box', 'goog.math.Coordinate', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/coordinate.js', ['goog.math.Coordinate'], ['goog.math'], {});
goog.addDependency('math/coordinate3.js', ['goog.math.Coordinate3'], [], {'lang': 'es6'});
goog.addDependency('math/coordinate3_test.js', ['goog.math.Coordinate3Test'], ['goog.math.Coordinate3', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/coordinate_test.js', ['goog.math.CoordinateTest'], ['goog.math.Coordinate', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/exponentialbackoff.js', ['goog.math.ExponentialBackoff'], ['goog.asserts'], {});
goog.addDependency('math/exponentialbackoff_test.js', ['goog.math.ExponentialBackoffTest'], ['goog.math.ExponentialBackoff', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/integer.js', ['goog.math.Integer'], ['goog.reflect'], {});
goog.addDependency('math/integer_test.js', ['goog.math.IntegerTest'], ['goog.math.Integer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/interpolator/interpolator1.js', ['goog.math.interpolator.Interpolator1'], [], {});
goog.addDependency('math/interpolator/linear1.js', ['goog.math.interpolator.Linear1'], ['goog.array', 'goog.asserts', 'goog.math', 'goog.math.interpolator.Interpolator1'], {});
goog.addDependency('math/interpolator/linear1_test.js', ['goog.math.interpolator.Linear1Test'], ['goog.math.interpolator.Linear1', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/interpolator/pchip1.js', ['goog.math.interpolator.Pchip1'], ['goog.math', 'goog.math.interpolator.Spline1'], {});
goog.addDependency('math/interpolator/pchip1_test.js', ['goog.math.interpolator.Pchip1Test'], ['goog.math.interpolator.Pchip1', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/interpolator/spline1.js', ['goog.math.interpolator.Spline1'], ['goog.array', 'goog.asserts', 'goog.math', 'goog.math.interpolator.Interpolator1', 'goog.math.tdma'], {});
goog.addDependency('math/interpolator/spline1_test.js', ['goog.math.interpolator.Spline1Test'], ['goog.math.interpolator.Spline1', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/irect.js', ['goog.math.IRect'], [], {});
goog.addDependency('math/line.js', ['goog.math.Line'], ['goog.math', 'goog.math.Coordinate'], {});
goog.addDependency('math/line_test.js', ['goog.math.LineTest'], ['goog.math.Coordinate', 'goog.math.Line', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/long.js', ['goog.math.Long'], ['goog.asserts', 'goog.reflect'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/long_test.js', ['goog.math.LongTest'], ['goog.asserts', 'goog.math.Long', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/math.js', ['goog.math'], ['goog.array', 'goog.asserts'], {});
goog.addDependency('math/math_test.js', ['goog.mathTest'], ['goog.math', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/matrix.js', ['goog.math.Matrix'], ['goog.array', 'goog.asserts', 'goog.math', 'goog.math.Size', 'goog.string'], {});
goog.addDependency('math/matrix_test.js', ['goog.math.MatrixTest'], ['goog.math.Matrix', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/path.js', ['goog.math.Path', 'goog.math.Path.Segment'], ['goog.array', 'goog.math', 'goog.math.AffineTransform'], {});
goog.addDependency('math/path_test.js', ['goog.math.PathTest'], ['goog.array', 'goog.math.AffineTransform', 'goog.math.Path', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/paths.js', ['goog.math.paths'], ['goog.math.Coordinate', 'goog.math.Path'], {});
goog.addDependency('math/paths_test.js', ['goog.math.pathsTest'], ['goog.math.Coordinate', 'goog.math.paths', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/range.js', ['goog.math.Range'], ['goog.asserts'], {});
goog.addDependency('math/range_test.js', ['goog.math.RangeTest'], ['goog.math.Range', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/rangeset.js', ['goog.math.RangeSet'], ['goog.array', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.math.Range'], {});
goog.addDependency('math/rangeset_test.js', ['goog.math.RangeSetTest'], ['goog.iter', 'goog.math.Range', 'goog.math.RangeSet', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/rect.js', ['goog.math.Rect'], ['goog.asserts', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.IRect', 'goog.math.Size'], {});
goog.addDependency('math/rect_test.js', ['goog.math.RectTest'], ['goog.math.Box', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.math.Size', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/size.js', ['goog.math.Size'], [], {'lang': 'es6'});
goog.addDependency('math/size_test.js', ['goog.math.SizeTest'], ['goog.math.Size', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/tdma.js', ['goog.math.tdma'], [], {'lang': 'es6'});
goog.addDependency('math/tdma_test.js', ['goog.math.tdmaTest'], ['goog.math.tdma', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/vec2.js', ['goog.math.Vec2'], ['goog.math', 'goog.math.Coordinate'], {'lang': 'es6'});
goog.addDependency('math/vec2_test.js', ['goog.math.Vec2Test'], ['goog.math.Vec2', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('math/vec3.js', ['goog.math.Vec3'], ['goog.math', 'goog.math.Coordinate3'], {});
goog.addDependency('math/vec3_test.js', ['goog.math.Vec3Test'], ['goog.math.Coordinate3', 'goog.math.Vec3', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('memoize/memoize.js', ['goog.memoize'], [], {'lang': 'es6'});
goog.addDependency('memoize/memoize_test.js', ['goog.memoizeTest'], ['goog.memoize', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/abstractchannel.js', ['goog.messaging.AbstractChannel'], ['goog.Disposable', 'goog.json', 'goog.log', 'goog.messaging.MessageChannel'], {});
goog.addDependency('messaging/abstractchannel_test.js', ['goog.messaging.AbstractChannelTest'], ['goog.messaging.AbstractChannel', 'goog.testing.MockControl', 'goog.testing.async.MockControl', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/bufferedchannel.js', ['goog.messaging.BufferedChannel'], ['goog.Disposable', 'goog.Timer', 'goog.events', 'goog.log', 'goog.messaging.MessageChannel', 'goog.messaging.MultiChannel'], {});
goog.addDependency('messaging/bufferedchannel_test.js', ['goog.messaging.BufferedChannelTest'], ['goog.debug.Console', 'goog.dom', 'goog.dom.TagName', 'goog.log', 'goog.log.Level', 'goog.messaging.BufferedChannel', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.async.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/deferredchannel.js', ['goog.messaging.DeferredChannel'], ['goog.Disposable', 'goog.messaging.MessageChannel'], {});
goog.addDependency('messaging/deferredchannel_test.js', ['goog.messaging.DeferredChannelTest'], ['goog.async.Deferred', 'goog.messaging.DeferredChannel', 'goog.testing.MockControl', 'goog.testing.async.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/loggerclient.js', ['goog.messaging.LoggerClient'], ['goog.Disposable', 'goog.debug', 'goog.debug.LogManager', 'goog.debug.Logger'], {});
goog.addDependency('messaging/loggerclient_test.js', ['goog.messaging.LoggerClientTest'], ['goog.debug', 'goog.debug.Logger', 'goog.messaging.LoggerClient', 'goog.testing.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/loggerserver.js', ['goog.messaging.LoggerServer'], ['goog.Disposable', 'goog.log', 'goog.log.Level'], {});
goog.addDependency('messaging/loggerserver_test.js', ['goog.messaging.LoggerServerTest'], ['goog.debug.LogManager', 'goog.debug.Logger', 'goog.log', 'goog.log.Level', 'goog.messaging.LoggerServer', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/messagechannel.js', ['goog.messaging.MessageChannel'], [], {});
goog.addDependency('messaging/messaging.js', ['goog.messaging'], [], {});
goog.addDependency('messaging/messaging_test.js', ['goog.testing.messaging.MockMessageChannelTest'], ['goog.messaging', 'goog.testing.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/multichannel.js', ['goog.messaging.MultiChannel', 'goog.messaging.MultiChannel.VirtualChannel'], ['goog.Disposable', 'goog.log', 'goog.messaging.MessageChannel', 'goog.object'], {});
goog.addDependency('messaging/multichannel_test.js', ['goog.messaging.MultiChannelTest'], ['goog.messaging.MultiChannel', 'goog.testing.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.mockmatchers.IgnoreArgument', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/portcaller.js', ['goog.messaging.PortCaller'], ['goog.Disposable', 'goog.async.Deferred', 'goog.messaging.DeferredChannel', 'goog.messaging.PortChannel', 'goog.messaging.PortNetwork', 'goog.object'], {});
goog.addDependency('messaging/portcaller_test.js', ['goog.messaging.PortCallerTest'], ['goog.events.EventTarget', 'goog.messaging.PortCaller', 'goog.messaging.PortNetwork', 'goog.testing.MockControl', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/portchannel.js', ['goog.messaging.PortChannel'], ['goog.Timer', 'goog.array', 'goog.async.Deferred', 'goog.debug', 'goog.events', 'goog.events.EventType', 'goog.json', 'goog.log', 'goog.messaging.AbstractChannel', 'goog.messaging.DeferredChannel', 'goog.object', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('messaging/portchannel_test.js', ['goog.messaging.PortChannelTest'], ['goog.Promise', 'goog.Timer', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.json', 'goog.messaging.PortChannel', 'goog.testing.MockControl', 'goog.testing.TestCase', 'goog.testing.messaging.MockMessageEvent', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/portnetwork.js', ['goog.messaging.PortNetwork'], [], {});
goog.addDependency('messaging/portnetwork_test.js', ['goog.messaging.PortNetworkTest'], ['goog.Promise', 'goog.Timer', 'goog.labs.userAgent.browser', 'goog.messaging.PortChannel', 'goog.messaging.PortOperator', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/portoperator.js', ['goog.messaging.PortOperator'], ['goog.Disposable', 'goog.asserts', 'goog.log', 'goog.messaging.PortChannel', 'goog.messaging.PortNetwork', 'goog.object'], {});
goog.addDependency('messaging/portoperator_test.js', ['goog.messaging.PortOperatorTest'], ['goog.messaging.PortNetwork', 'goog.messaging.PortOperator', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.messaging.MockMessagePort', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/respondingchannel.js', ['goog.messaging.RespondingChannel'], ['goog.Disposable', 'goog.Promise', 'goog.log', 'goog.messaging.MultiChannel'], {});
goog.addDependency('messaging/respondingchannel_test.js', ['goog.messaging.RespondingChannelTest'], ['goog.Promise', 'goog.messaging.RespondingChannel', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.messaging.MockMessageChannel', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('messaging/testdata/portchannel_worker.js', ['goog.messaging.testdata.portchannel_worker'], ['goog.messaging.PortChannel'], {});
goog.addDependency('messaging/testdata/portnetwork_worker1.js', ['goog.messaging.testdata.portnetwork_worker1'], ['goog.messaging.PortCaller', 'goog.messaging.PortChannel'], {});
goog.addDependency('messaging/testdata/portnetwork_worker2.js', ['goog.messaging.testdata.portnetwork_worker2'], ['goog.messaging.PortCaller', 'goog.messaging.PortChannel'], {});
goog.addDependency('module/abstractmoduleloader.js', ['goog.module.AbstractModuleLoader'], ['goog.module', 'goog.module.ModuleInfo'], {});
goog.addDependency('module/basemodule.js', ['goog.module.BaseModule'], ['goog.Disposable', 'goog.module'], {});
goog.addDependency('module/loader.js', ['goog.module.Loader'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.legacyconversions', 'goog.module', 'goog.object'], {});
goog.addDependency('module/module.js', ['goog.module'], [], {});
goog.addDependency('module/moduleinfo.js', ['goog.module.ModuleInfo'], ['goog.Disposable', 'goog.async.throwException', 'goog.functions', 'goog.html.TrustedResourceUrl', 'goog.module', 'goog.module.BaseModule', 'goog.module.ModuleLoadCallback'], {});
goog.addDependency('module/moduleinfo_test.js', ['goog.module.ModuleInfoTest'], ['goog.module.BaseModule', 'goog.module.ModuleInfo', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('module/moduleloadcallback.js', ['goog.module.ModuleLoadCallback'], ['goog.debug.entryPointRegistry', 'goog.module'], {});
goog.addDependency('module/moduleloadcallback_test.js', ['goog.module.ModuleLoadCallbackTest'], ['goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.functions', 'goog.module.ModuleLoadCallback', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('module/moduleloader.js', ['goog.module.ModuleLoader'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.safe', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventId', 'goog.events.EventTarget', 'goog.functions', 'goog.html.TrustedResourceUrl', 'goog.labs.userAgent.browser', 'goog.log', 'goog.module.AbstractModuleLoader', 'goog.net.BulkLoader', 'goog.net.EventType', 'goog.net.jsloader', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6'});
goog.addDependency('module/moduleloader_test.js', ['goog.module.ModuleLoaderTest'], ['goog.Promise', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.functions', 'goog.html.TrustedResourceUrl', 'goog.loader.activeModuleManager', 'goog.module.ModuleLoader', 'goog.module.ModuleManager', 'goog.net.BulkLoader', 'goog.net.XmlHttp', 'goog.object', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.events.EventObserver', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('module/modulemanager.js', ['goog.module.ModuleManager', 'goog.module.ModuleManager.CallbackType', 'goog.module.ModuleManager.FailureType'], ['goog.array', 'goog.asserts', 'goog.async.Deferred', 'goog.debug.Trace', 'goog.disposable.IDisposable', 'goog.disposeAll', 'goog.loader.AbstractModuleManager', 'goog.loader.activeModuleManager', 'goog.log', 'goog.module', 'goog.module.ModuleInfo', 'goog.module.ModuleLoadCallback', 'goog.object'], {'lang': 'es6'});
goog.addDependency('module/modulemanager_test.js', ['goog.module.ModuleManagerTest'], ['goog.array', 'goog.functions', 'goog.module.BaseModule', 'goog.module.ModuleManager', 'goog.testing', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('module/testdata/modA_1.js', ['goog.module.testdata.modA_1'], [], {});
goog.addDependency('module/testdata/modA_2.js', ['goog.module.testdata.modA_2'], ['goog.module.ModuleManager'], {});
goog.addDependency('module/testdata/modB_1.js', ['goog.module.testdata.modB_1'], ['goog.module.ModuleManager'], {});
goog.addDependency('net/browserchannel.js', ['goog.net.BrowserChannel', 'goog.net.BrowserChannel.Error', 'goog.net.BrowserChannel.Event', 'goog.net.BrowserChannel.Handler', 'goog.net.BrowserChannel.LogSaver', 'goog.net.BrowserChannel.QueuedMap', 'goog.net.BrowserChannel.ServerReachability', 'goog.net.BrowserChannel.ServerReachabilityEvent', 'goog.net.BrowserChannel.Stat', 'goog.net.BrowserChannel.StatEvent', 'goog.net.BrowserChannel.State', 'goog.net.BrowserChannel.TimingEvent'], ['goog.Uri', 'goog.array', 'goog.asserts', 'goog.debug.TextFormatter', 'goog.events.Event', 'goog.events.EventTarget', 'goog.json', 'goog.json.NativeJsonProcessor', 'goog.log', 'goog.net.BrowserTestChannel', 'goog.net.ChannelDebug', 'goog.net.ChannelRequest', 'goog.net.XhrIo', 'goog.net.tmpnetwork', 'goog.object', 'goog.string', 'goog.structs', 'goog.structs.CircularBuffer'], {});
goog.addDependency('net/browserchannel_test.js', ['goog.net.BrowserChannelTest'], ['goog.Timer', 'goog.array', 'goog.dom', 'goog.functions', 'goog.json', 'goog.net.BrowserChannel', 'goog.net.ChannelDebug', 'goog.net.ChannelRequest', 'goog.net.tmpnetwork', 'goog.structs.Map', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/browsertestchannel.js', ['goog.net.BrowserTestChannel'], ['goog.json.NativeJsonProcessor', 'goog.net.ChannelRequest', 'goog.net.ChannelRequest.Error', 'goog.net.tmpnetwork', 'goog.string.Parser'], {});
goog.addDependency('net/bulkloader.js', ['goog.net.BulkLoader'], ['goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.log', 'goog.net.BulkLoaderHelper', 'goog.net.EventType', 'goog.net.XhrIo'], {});
goog.addDependency('net/bulkloader_test.js', ['goog.net.BulkLoaderTest'], ['goog.events.Event', 'goog.events.EventHandler', 'goog.net.BulkLoader', 'goog.net.EventType', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/bulkloaderhelper.js', ['goog.net.BulkLoaderHelper'], ['goog.Disposable'], {});
goog.addDependency('net/channeldebug.js', ['goog.net.ChannelDebug'], ['goog.json', 'goog.log'], {'lang': 'es6'});
goog.addDependency('net/channelrequest.js', ['goog.net.ChannelRequest', 'goog.net.ChannelRequest.Error'], ['goog.Timer', 'goog.async.Throttle', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events.EventHandler', 'goog.html.SafeUrl', 'goog.html.uncheckedconversions', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('net/channelrequest_test.js', ['goog.net.ChannelRequestTest'], ['goog.Uri', 'goog.functions', 'goog.net.BrowserChannel', 'goog.net.ChannelDebug', 'goog.net.ChannelRequest', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.net.XhrIo', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/cookies.js', ['goog.net.Cookies', 'goog.net.cookies'], ['goog.asserts', 'goog.string'], {'lang': 'es5'});
goog.addDependency('net/cookies_test.js', ['goog.net.cookiesTest'], ['goog.array', 'goog.net.Cookies', 'goog.net.cookies', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/corsxmlhttpfactory.js', ['goog.net.CorsXmlHttpFactory', 'goog.net.IeCorsXhrAdapter'], ['goog.net.HttpStatus', 'goog.net.XhrLike', 'goog.net.XmlHttp', 'goog.net.XmlHttpFactory'], {});
goog.addDependency('net/corsxmlhttpfactory_test.js', ['goog.net.CorsXmlHttpFactoryTest'], ['goog.net.CorsXmlHttpFactory', 'goog.net.IeCorsXhrAdapter', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/crossdomainrpc.js', ['goog.net.CrossDomainRpc'], ['goog.Uri', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.html.SafeHtml', 'goog.log', 'goog.net.EventType', 'goog.net.HttpStatus', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('net/crossdomainrpc_test.js', ['goog.net.CrossDomainRpcTest'], ['goog.Promise', 'goog.log', 'goog.net.CrossDomainRpc', 'goog.testing.TestCase', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/errorcode.js', ['goog.net.ErrorCode'], [], {});
goog.addDependency('net/eventtype.js', ['goog.net.EventType'], [], {});
goog.addDependency('net/fetchxmlhttpfactory.js', ['goog.net.FetchXmlHttp', 'goog.net.FetchXmlHttpFactory'], ['goog.asserts', 'goog.events.EventTarget', 'goog.functions', 'goog.log', 'goog.net.XhrLike', 'goog.net.XmlHttpFactory'], {'lang': 'es5'});
goog.addDependency('net/fetchxmlhttpfactory_test.js', ['goog.net.FetchXmlHttpFactoryTest'], ['goog.net.FetchXmlHttp', 'goog.net.FetchXmlHttpFactory', 'goog.testing.MockControl', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/filedownloader.js', ['goog.net.FileDownloader', 'goog.net.FileDownloader.Error'], ['goog.Disposable', 'goog.asserts', 'goog.async.Deferred', 'goog.crypt.hash32', 'goog.debug.Error', 'goog.events', 'goog.events.EventHandler', 'goog.fs', 'goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.fs.FileSaver', 'goog.net.EventType', 'goog.net.XhrIo', 'goog.net.XhrIoPool', 'goog.object'], {});
goog.addDependency('net/filedownloader_test.js', ['goog.net.FileDownloaderTest'], ['goog.fs.Error', 'goog.net.ErrorCode', 'goog.net.FileDownloader', 'goog.net.XhrIo', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.fs', 'goog.testing.fs.FileSystem', 'goog.testing.net.XhrIoPool', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/httpstatus.js', ['goog.net.HttpStatus'], [], {});
goog.addDependency('net/httpstatusname.js', ['goog.net.HttpStatusName'], [], {});
goog.addDependency('net/iframeio.js', ['goog.net.IframeIo', 'goog.net.IframeIo.IncrementalDataEvent'], ['goog.Timer', 'goog.Uri', 'goog.array', 'goog.asserts', 'goog.debug.HtmlFormatter', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.html.SafeUrl', 'goog.html.legacyconversions', 'goog.html.uncheckedconversions', 'goog.json', 'goog.log', 'goog.log.Level', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.reflect', 'goog.string', 'goog.string.Const', 'goog.structs', 'goog.userAgent'], {});
goog.addDependency('net/iframeio_test.js', ['goog.net.IframeIoTest'], ['goog.debug', 'goog.debug.DivConsole', 'goog.debug.LogManager', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.log', 'goog.log.Level', 'goog.net.IframeIo', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.jsunit', 'goog.userAgent'], {'lang': 'es6'});
goog.addDependency('net/iframeloadmonitor.js', ['goog.net.IframeLoadMonitor'], ['goog.dom', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.userAgent'], {});
goog.addDependency('net/iframeloadmonitor_test.js', ['goog.net.IframeLoadMonitorTest'], ['goog.Promise', 'goog.Timer', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.net.IframeLoadMonitor', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/imageloader.js', ['goog.net.ImageLoader'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.net.EventType', 'goog.object', 'goog.userAgent'], {});
goog.addDependency('net/imageloader_test.js', ['goog.net.ImageLoaderTest'], ['goog.Promise', 'goog.Timer', 'goog.array', 'goog.dispose', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.net.EventType', 'goog.net.ImageLoader', 'goog.object', 'goog.string', 'goog.testing.TestCase', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/ipaddress.js', ['goog.net.IpAddress', 'goog.net.Ipv4Address', 'goog.net.Ipv6Address'], ['goog.array', 'goog.math.Integer', 'goog.object', 'goog.string'], {});
goog.addDependency('net/ipaddress_test.js', ['goog.net.IpAddressTest'], ['goog.array', 'goog.math.Integer', 'goog.net.IpAddress', 'goog.net.Ipv4Address', 'goog.net.Ipv6Address', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/jsloader.js', ['goog.net.jsloader', 'goog.net.jsloader.Error', 'goog.net.jsloader.ErrorCode', 'goog.net.jsloader.Options'], ['goog.array', 'goog.async.Deferred', 'goog.debug.Error', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.TrustedResourceUrl', 'goog.object'], {});
goog.addDependency('net/jsloader_test.js', ['goog.net.jsloaderTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.html.TrustedResourceUrl', 'goog.net.jsloader', 'goog.net.jsloader.ErrorCode', 'goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/jsonp.js', ['goog.net.Jsonp'], ['goog.html.TrustedResourceUrl', 'goog.net.jsloader', 'goog.object'], {});
goog.addDependency('net/jsonp_test.js', ['goog.net.JsonpTest'], ['goog.html.TrustedResourceUrl', 'goog.net.Jsonp', 'goog.string.Const', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/mockiframeio.js', ['goog.net.MockIFrameIo'], ['goog.events.EventTarget', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.IframeIo'], {});
goog.addDependency('net/multiiframeloadmonitor.js', ['goog.net.MultiIframeLoadMonitor'], ['goog.events', 'goog.net.IframeLoadMonitor'], {});
goog.addDependency('net/multiiframeloadmonitor_test.js', ['goog.net.MultiIframeLoadMonitorTest'], ['goog.Promise', 'goog.Timer', 'goog.dom', 'goog.dom.TagName', 'goog.net.MultiIframeLoadMonitor', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/networkstatusmonitor.js', ['goog.net.NetworkStatusMonitor'], ['goog.events.Listenable'], {});
goog.addDependency('net/networktester.js', ['goog.net.NetworkTester'], ['goog.Timer', 'goog.Uri', 'goog.dom.safe', 'goog.log'], {});
goog.addDependency('net/networktester_test.js', ['goog.net.NetworkTesterTest'], ['goog.Uri', 'goog.net.NetworkTester', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/rpc/httpcors.js', ['goog.net.rpc.HttpCors'], ['goog.Uri', 'goog.object', 'goog.string', 'goog.uri.utils'], {'module': 'goog'});
goog.addDependency('net/rpc/httpcors_test.js', ['goog.net.rpc.HttpCorsTest'], ['goog.Uri', 'goog.net.rpc.HttpCors', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/base64pbstreamparser.js', ['goog.net.streams.Base64PbStreamParser'], ['goog.asserts', 'goog.net.streams.Base64StreamDecoder', 'goog.net.streams.PbStreamParser', 'goog.net.streams.StreamParser'], {'module': 'goog'});
goog.addDependency('net/streams/base64pbstreamparser_test.js', ['goog.net.streams.Base64PbStreamParserTest'], ['goog.crypt.base64', 'goog.net.streams.Base64PbStreamParser', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/base64streamdecoder.js', ['goog.net.streams.Base64StreamDecoder'], ['goog.asserts', 'goog.crypt.base64'], {});
goog.addDependency('net/streams/base64streamdecoder_test.js', ['goog.net.streams.Base64StreamDecoderTest'], ['goog.net.streams.Base64StreamDecoder', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/jsonstreamparser.js', ['goog.net.streams.JsonStreamParser', 'goog.net.streams.JsonStreamParser.Options'], ['goog.asserts', 'goog.net.streams.StreamParser', 'goog.net.streams.utils'], {});
goog.addDependency('net/streams/jsonstreamparser_test.js', ['goog.net.streams.JsonStreamParserTest'], ['goog.array', 'goog.json', 'goog.labs.testing.JsonFuzzing', 'goog.net.streams.JsonStreamParser', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.uri.utils'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/nodereadablestream.js', ['goog.net.streams.NodeReadableStream'], [], {});
goog.addDependency('net/streams/pbjsonstreamparser.js', ['goog.net.streams.PbJsonStreamParser'], ['goog.asserts', 'goog.net.streams.JsonStreamParser', 'goog.net.streams.StreamParser', 'goog.net.streams.utils'], {'module': 'goog'});
goog.addDependency('net/streams/pbjsonstreamparser_test.js', ['goog.net.streams.PbJsonStreamParserTest'], ['goog.net.streams.PbJsonStreamParser', 'goog.object', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/pbstreamparser.js', ['goog.net.streams.PbStreamParser'], ['goog.asserts', 'goog.net.streams.StreamParser'], {});
goog.addDependency('net/streams/pbstreamparser_test.js', ['goog.net.streams.PbStreamParserTest'], ['goog.net.streams.PbStreamParser', 'goog.object', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/streamfactory.js', ['goog.net.streams.createXhrNodeReadableStream'], ['goog.asserts', 'goog.net.streams.XhrNodeReadableStream', 'goog.net.streams.XhrStreamReader'], {});
goog.addDependency('net/streams/streamparser.js', ['goog.net.streams.StreamParser'], [], {});
goog.addDependency('net/streams/utils.js', ['goog.net.streams.utils'], [], {'module': 'goog'});
goog.addDependency('net/streams/xhrnodereadablestream.js', ['goog.net.streams.XhrNodeReadableStream'], ['goog.array', 'goog.log', 'goog.net.streams.NodeReadableStream', 'goog.net.streams.XhrStreamReader'], {});
goog.addDependency('net/streams/xhrnodereadablestream_test.js', ['goog.net.streams.XhrNodeReadableStreamTest'], ['goog.net.streams.NodeReadableStream', 'goog.net.streams.XhrNodeReadableStream', 'goog.net.streams.XhrStreamReader', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/streams/xhrstreamreader.js', ['goog.net.streams.XhrStreamReader'], ['goog.events.EventHandler', 'goog.log', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.HttpStatus', 'goog.net.XhrIo', 'goog.net.XmlHttp', 'goog.net.streams.Base64PbStreamParser', 'goog.net.streams.JsonStreamParser', 'goog.net.streams.PbJsonStreamParser', 'goog.net.streams.PbStreamParser', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('net/streams/xhrstreamreader_test.js', ['goog.net.streams.XhrStreamReaderTest'], ['goog.net.ErrorCode', 'goog.net.HttpStatus', 'goog.net.XhrIo', 'goog.net.XmlHttp', 'goog.net.streams.Base64PbStreamParser', 'goog.net.streams.JsonStreamParser', 'goog.net.streams.PbJsonStreamParser', 'goog.net.streams.PbStreamParser', 'goog.net.streams.XhrStreamReader', 'goog.object', 'goog.testing.net.XhrIo', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/testdata/jsloader_test1.js', ['goog.net.testdata.jsloader_test1'], [], {});
goog.addDependency('net/testdata/jsloader_test2.js', ['goog.net.testdata.jsloader_test2'], [], {});
goog.addDependency('net/testdata/jsloader_test3.js', ['goog.net.testdata.jsloader_test3'], [], {});
goog.addDependency('net/testdata/jsloader_test4.js', ['goog.net.testdata.jsloader_test4'], [], {});
goog.addDependency('net/tmpnetwork.js', ['goog.net.tmpnetwork'], ['goog.Uri', 'goog.dom.safe', 'goog.net.ChannelDebug'], {});
goog.addDependency('net/websocket.js', ['goog.net.WebSocket', 'goog.net.WebSocket.ErrorEvent', 'goog.net.WebSocket.EventType', 'goog.net.WebSocket.MessageEvent'], ['goog.Timer', 'goog.asserts', 'goog.debug.entryPointRegistry', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.log'], {'lang': 'es5'});
goog.addDependency('net/websocket_test.js', ['goog.net.WebSocketTest'], ['goog.debug.EntryPointMonitor', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.events', 'goog.functions', 'goog.net.WebSocket', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/wrapperxmlhttpfactory.js', ['goog.net.WrapperXmlHttpFactory'], ['goog.net.XhrLike', 'goog.net.XmlHttpFactory'], {});
goog.addDependency('net/xhrio.js', ['goog.net.XhrIo', 'goog.net.XhrIo.ResponseType'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.debug.entryPointRegistry', 'goog.events.EventTarget', 'goog.json.hybrid', 'goog.log', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.HttpStatus', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.structs', 'goog.structs.Map', 'goog.uri.utils', 'goog.userAgent'], {});
goog.addDependency('net/xhrio_test.js', ['goog.net.XhrIoTest'], ['goog.Uri', 'goog.debug.EntryPointMonitor', 'goog.debug.ErrorHandler', 'goog.debug.entryPointRegistry', 'goog.events', 'goog.functions', 'goog.net.EventType', 'goog.net.WrapperXmlHttpFactory', 'goog.net.XhrIo', 'goog.net.XmlHttp', 'goog.object', 'goog.string', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.jsunit', 'goog.testing.net.XhrIo', 'goog.testing.recordFunction', 'goog.userAgent.product'], {'lang': 'es6'});
goog.addDependency('net/xhriopool.js', ['goog.net.XhrIoPool'], ['goog.net.XhrIo', 'goog.structs.PriorityPool'], {});
goog.addDependency('net/xhriopool_test.js', ['goog.net.XhrIoPoolTest'], ['goog.net.XhrIoPool', 'goog.structs.Map', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xhrlike.js', ['goog.net.XhrLike'], [], {});
goog.addDependency('net/xhrmanager.js', ['goog.net.XhrManager', 'goog.net.XhrManager.Event', 'goog.net.XhrManager.Request'], ['goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.XhrIo', 'goog.net.XhrIoPool', 'goog.structs.Map'], {});
goog.addDependency('net/xhrmanager_test.js', ['goog.net.XhrManagerTest'], ['goog.events', 'goog.net.EventType', 'goog.net.XhrIo', 'goog.net.XhrManager', 'goog.testing.net.XhrIoPool', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xmlhttp.js', ['goog.net.DefaultXmlHttpFactory', 'goog.net.XmlHttp', 'goog.net.XmlHttp.OptionType', 'goog.net.XmlHttp.ReadyState', 'goog.net.XmlHttpDefines'], ['goog.asserts', 'goog.net.WrapperXmlHttpFactory', 'goog.net.XmlHttpFactory'], {});
goog.addDependency('net/xmlhttpfactory.js', ['goog.net.XmlHttpFactory'], ['goog.net.XhrLike'], {});
goog.addDependency('net/xpc/crosspagechannel.js', ['goog.net.xpc.CrossPageChannel'], ['goog.Uri', 'goog.async.Deferred', 'goog.async.Delay', 'goog.dispose', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.html.legacyconversions', 'goog.json', 'goog.log', 'goog.messaging.AbstractChannel', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.ChannelStates', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.DirectTransport', 'goog.net.xpc.NativeMessagingTransport', 'goog.net.xpc.TransportTypes', 'goog.net.xpc.UriCfgFields', 'goog.string', 'goog.uri.utils', 'goog.userAgent'], {});
goog.addDependency('net/xpc/crosspagechannel_test.js', ['goog.net.xpc.CrossPageChannelTest'], ['goog.Disposable', 'goog.Promise', 'goog.Timer', 'goog.Uri', 'goog.dom', 'goog.dom.TagName', 'goog.labs.userAgent.browser', 'goog.log', 'goog.log.Level', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannel', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.TransportTypes', 'goog.object', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.jsunit'], {'lang': 'es8'});
goog.addDependency('net/xpc/crosspagechannelrole.js', ['goog.net.xpc.CrossPageChannelRole'], [], {});
goog.addDependency('net/xpc/directtransport.js', ['goog.net.xpc.DirectTransport'], ['goog.Timer', 'goog.async.Deferred', 'goog.events.EventHandler', 'goog.log', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.Transport', 'goog.net.xpc.TransportTypes', 'goog.object'], {});
goog.addDependency('net/xpc/directtransport_test.js', ['goog.net.xpc.DirectTransportTest'], ['goog.Promise', 'goog.dom', 'goog.dom.TagName', 'goog.labs.userAgent.browser', 'goog.log', 'goog.log.Level', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannel', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.TransportTypes', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xpc/iframepollingtransport.js', ['goog.net.xpc.IframePollingTransport', 'goog.net.xpc.IframePollingTransport.Receiver', 'goog.net.xpc.IframePollingTransport.Sender'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.log', 'goog.log.Level', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.Transport', 'goog.net.xpc.TransportTypes', 'goog.userAgent'], {});
goog.addDependency('net/xpc/iframepollingtransport_test.js', ['goog.net.xpc.IframePollingTransportTest'], ['goog.Timer', 'goog.dom', 'goog.dom.TagName', 'goog.functions', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannel', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.IframePollingTransport', 'goog.object', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xpc/nativemessagingtransport.js', ['goog.net.xpc.NativeMessagingTransport'], ['goog.Timer', 'goog.asserts', 'goog.async.Deferred', 'goog.events', 'goog.events.EventHandler', 'goog.log', 'goog.net.xpc', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.Transport', 'goog.net.xpc.TransportTypes'], {});
goog.addDependency('net/xpc/nativemessagingtransport_test.js', ['goog.net.xpc.NativeMessagingTransportTest'], ['goog.dom', 'goog.events', 'goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.CrossPageChannel', 'goog.net.xpc.CrossPageChannelRole', 'goog.net.xpc.NativeMessagingTransport', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('net/xpc/relay.js', ['goog.net.xpc.relay'], [], {'lang': 'es6'});
goog.addDependency('net/xpc/transport.js', ['goog.net.xpc.Transport'], ['goog.Disposable', 'goog.dom', 'goog.net.xpc.TransportNames'], {});
goog.addDependency('net/xpc/xpc.js', ['goog.net.xpc', 'goog.net.xpc.CfgFields', 'goog.net.xpc.ChannelStates', 'goog.net.xpc.TransportNames', 'goog.net.xpc.TransportTypes', 'goog.net.xpc.UriCfgFields'], ['goog.log'], {});
goog.addDependency('object/object.js', ['goog.object'], [], {'lang': 'es6'});
goog.addDependency('object/object_test.js', ['goog.objectTest'], ['goog.array', 'goog.functions', 'goog.object', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/absoluteposition.js', ['goog.positioning.AbsolutePosition'], ['goog.math.Coordinate', 'goog.positioning', 'goog.positioning.AbstractPosition'], {});
goog.addDependency('positioning/abstractposition.js', ['goog.positioning.AbstractPosition'], [], {});
goog.addDependency('positioning/anchoredposition.js', ['goog.positioning.AnchoredPosition'], ['goog.positioning', 'goog.positioning.AbstractPosition'], {});
goog.addDependency('positioning/anchoredposition_test.js', ['goog.positioning.AnchoredPositionTest'], ['goog.dom', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/anchoredviewportposition.js', ['goog.positioning.AnchoredViewportPosition'], ['goog.positioning', 'goog.positioning.AnchoredPosition', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus'], {});
goog.addDependency('positioning/anchoredviewportposition_test.js', ['goog.positioning.AnchoredViewportPositionTest'], ['goog.dom', 'goog.math.Box', 'goog.positioning.AnchoredViewportPosition', 'goog.positioning.Corner', 'goog.positioning.OverflowStatus', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/clientposition.js', ['goog.positioning.ClientPosition'], ['goog.asserts', 'goog.dom', 'goog.math.Coordinate', 'goog.positioning', 'goog.positioning.AbstractPosition', 'goog.style'], {});
goog.addDependency('positioning/clientposition_test.js', ['goog.positioning.clientPositionTest'], ['goog.dom', 'goog.dom.TagName', 'goog.positioning.ClientPosition', 'goog.positioning.Corner', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/menuanchoredposition.js', ['goog.positioning.MenuAnchoredPosition'], ['goog.positioning.AnchoredViewportPosition', 'goog.positioning.Overflow'], {});
goog.addDependency('positioning/menuanchoredposition_test.js', ['goog.positioning.MenuAnchoredPositionTest'], ['goog.dom', 'goog.dom.TagName', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/positioning.js', ['goog.positioning', 'goog.positioning.Corner', 'goog.positioning.CornerBit', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.math.Size', 'goog.style', 'goog.style.bidi'], {});
goog.addDependency('positioning/positioning_test.js', ['goog.positioningTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.labs.userAgent.browser', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.Size', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/viewportclientposition.js', ['goog.positioning.ViewportClientPosition'], ['goog.dom', 'goog.math.Coordinate', 'goog.positioning', 'goog.positioning.ClientPosition', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus', 'goog.style'], {});
goog.addDependency('positioning/viewportclientposition_test.js', ['goog.positioning.ViewportClientPositionTest'], ['goog.dom', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.positioning.ViewportClientPosition', 'goog.style', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('positioning/viewportposition.js', ['goog.positioning.ViewportPosition'], ['goog.math.Coordinate', 'goog.positioning', 'goog.positioning.AbstractPosition', 'goog.positioning.Corner', 'goog.style'], {});
goog.addDependency('promise/nativeresolver.js', ['goog.promise.NativeResolver'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('promise/nativeresolver_test.js', ['goog.promise.nativeResolverTest'], ['goog.promise.NativeResolver', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('promise/promise.js', ['goog.Promise'], ['goog.Thenable', 'goog.asserts', 'goog.async.FreeList', 'goog.async.run', 'goog.async.throwException', 'goog.debug.Error', 'goog.promise.Resolver'], {});
goog.addDependency('promise/promise_test.js', ['goog.PromiseTest'], ['goog.Promise', 'goog.Thenable', 'goog.Timer', 'goog.functions', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('promise/resolver.js', ['goog.promise.Resolver'], [], {});
goog.addDependency('promise/testsuiteadapter.js', ['goog.promise.testSuiteAdapter'], ['goog.Promise'], {});
goog.addDependency('promise/thenable.js', ['goog.Thenable'], [], {});
goog.addDependency('proto2/descriptor.js', ['goog.proto2.Descriptor', 'goog.proto2.Metadata'], ['goog.array', 'goog.asserts', 'goog.object', 'goog.string'], {});
goog.addDependency('proto2/descriptor_test.js', ['goog.proto2.DescriptorTest'], ['goog.proto2.Descriptor', 'goog.proto2.Message', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/fielddescriptor.js', ['goog.proto2.FieldDescriptor'], ['goog.asserts', 'goog.string'], {});
goog.addDependency('proto2/fielddescriptor_test.js', ['goog.proto2.FieldDescriptorTest'], ['goog.proto2.FieldDescriptor', 'goog.proto2.Message', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/lazydeserializer.js', ['goog.proto2.LazyDeserializer'], ['goog.asserts', 'goog.proto2.Message', 'goog.proto2.Serializer'], {});
goog.addDependency('proto2/message.js', ['goog.proto2.Message'], ['goog.asserts', 'goog.proto2.Descriptor', 'goog.proto2.FieldDescriptor'], {});
goog.addDependency('proto2/message_test.js', ['goog.proto2.MessageTest'], ['goog.testing.testSuite', 'proto2.TestAllTypes', 'proto2.TestAllTypes.NestedEnum', 'proto2.TestAllTypes.NestedMessage', 'proto2.TestAllTypes.OptionalGroup', 'proto2.TestAllTypes.RepeatedGroup'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/objectserializer.js', ['goog.proto2.ObjectSerializer'], ['goog.asserts', 'goog.proto2.FieldDescriptor', 'goog.proto2.Serializer', 'goog.string'], {});
goog.addDependency('proto2/objectserializer_test.js', ['goog.proto2.ObjectSerializerTest'], ['goog.proto2.ObjectSerializer', 'goog.proto2.Serializer', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'proto2.TestAllTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/package_test.pb.js', ['someprotopackage.TestPackageTypes'], ['goog.proto2.Message', 'proto2.TestAllTypes'], {'lang': 'es6'});
goog.addDependency('proto2/pbliteserializer.js', ['goog.proto2.PbLiteSerializer'], ['goog.asserts', 'goog.proto2.FieldDescriptor', 'goog.proto2.LazyDeserializer', 'goog.proto2.Serializer'], {});
goog.addDependency('proto2/pbliteserializer_test.js', ['goog.proto2.PbLiteSerializerTest'], ['goog.proto2.PbLiteSerializer', 'goog.testing.testSuite', 'proto2.TestAllTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/proto_test.js', ['goog.proto2.messageTest'], ['goog.proto2.FieldDescriptor', 'goog.testing.testSuite', 'proto2.TestAllTypes', 'proto2.TestDefaultParent', 'someprotopackage.TestPackageTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/serializer.js', ['goog.proto2.Serializer'], ['goog.asserts', 'goog.proto2.FieldDescriptor', 'goog.proto2.Message'], {});
goog.addDependency('proto2/test.pb.js', ['proto2.TestAllTypes', 'proto2.TestAllTypes.NestedEnum', 'proto2.TestAllTypes.NestedMessage', 'proto2.TestAllTypes.OptionalGroup', 'proto2.TestAllTypes.RepeatedGroup', 'proto2.TestDefaultChild', 'proto2.TestDefaultParent'], ['goog.proto2.Message'], {});
goog.addDependency('proto2/textformatserializer.js', ['goog.proto2.TextFormatSerializer'], ['goog.array', 'goog.asserts', 'goog.math', 'goog.object', 'goog.proto2.FieldDescriptor', 'goog.proto2.Message', 'goog.proto2.Serializer', 'goog.string'], {});
goog.addDependency('proto2/textformatserializer_test.js', ['goog.proto2.TextFormatSerializerTest'], ['goog.proto2.ObjectSerializer', 'goog.proto2.TextFormatSerializer', 'goog.testing.testSuite', 'proto2.TestAllTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('proto2/util.js', ['goog.proto2.Util'], ['goog.asserts'], {});
goog.addDependency('pubsub/pubsub.js', ['goog.pubsub.PubSub'], ['goog.Disposable', 'goog.array', 'goog.async.run'], {});
goog.addDependency('pubsub/pubsub_test.js', ['goog.pubsub.PubSubTest'], ['goog.array', 'goog.pubsub.PubSub', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('pubsub/topicid.js', ['goog.pubsub.TopicId'], [], {});
goog.addDependency('pubsub/typedpubsub.js', ['goog.pubsub.TypedPubSub'], ['goog.Disposable', 'goog.pubsub.PubSub'], {});
goog.addDependency('pubsub/typedpubsub_test.js', ['goog.pubsub.TypedPubSubTest'], ['goog.array', 'goog.pubsub.TopicId', 'goog.pubsub.TypedPubSub', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('reflect/reflect.js', ['goog.reflect'], [], {'lang': 'es6'});
goog.addDependency('reflect/reflect_test.js', ['goog.reflectTest'], ['goog.object', 'goog.reflect', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/chain_test.js', ['goog.result.chainTest'], ['goog.Timer', 'goog.result', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/combine_test.js', ['goog.result.combineTest'], ['goog.Timer', 'goog.array', 'goog.result', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/deferredadaptor.js', ['goog.result.DeferredAdaptor'], ['goog.async.Deferred', 'goog.result', 'goog.result.Result'], {});
goog.addDependency('result/deferredadaptor_test.js', ['goog.result.DeferredAdaptorTest'], ['goog.async.Deferred', 'goog.result', 'goog.result.DeferredAdaptor', 'goog.result.SimpleResult', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/dependentresult.js', ['goog.result.DependentResult'], ['goog.result.Result'], {});
goog.addDependency('result/result_interface.js', ['goog.result.Result'], ['goog.Thenable'], {});
goog.addDependency('result/resultutil.js', ['goog.result'], ['goog.array', 'goog.result.DependentResult', 'goog.result.Result', 'goog.result.SimpleResult'], {});
goog.addDependency('result/resultutil_test.js', ['goog.resultTest'], ['goog.result', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/simpleresult.js', ['goog.result.SimpleResult', 'goog.result.SimpleResult.StateError'], ['goog.Promise', 'goog.Thenable', 'goog.debug.Error', 'goog.result.Result'], {});
goog.addDependency('result/simpleresult_test.js', ['goog.result.SimpleResultTest'], ['goog.Promise', 'goog.Thenable', 'goog.Timer', 'goog.result', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/transform_test.js', ['goog.result.transformTest'], ['goog.Timer', 'goog.result', 'goog.result.SimpleResult', 'goog.testing.MockClock', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('result/wait_test.js', ['goog.result.waitTest'], ['goog.Timer', 'goog.result', 'goog.result.SimpleResult', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('soy/data.js', ['goog.soy.data.SanitizedContent', 'goog.soy.data.SanitizedContentKind', 'goog.soy.data.SanitizedCss', 'goog.soy.data.SanitizedHtml', 'goog.soy.data.SanitizedHtmlAttribute', 'goog.soy.data.SanitizedJs', 'goog.soy.data.SanitizedTrustedResourceUri', 'goog.soy.data.SanitizedUri'], ['goog.Uri', 'goog.asserts', 'goog.html.SafeHtml', 'goog.html.SafeScript', 'goog.html.SafeStyle', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.html.uncheckedconversions', 'goog.i18n.bidi.Dir', 'goog.string.Const'], {});
goog.addDependency('soy/data_test.js', ['goog.soy.dataTest'], ['goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.html.SafeUrl', 'goog.html.TrustedResourceUrl', 'goog.soy.testHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('soy/renderer.js', ['goog.soy.InjectedDataSupplier', 'goog.soy.Renderer'], ['goog.asserts', 'goog.dom', 'goog.soy', 'goog.soy.data.SanitizedContent', 'goog.soy.data.SanitizedContentKind'], {});
goog.addDependency('soy/renderer_test.js', ['goog.soy.RendererTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.html.SafeHtml', 'goog.i18n.bidi.Dir', 'goog.soy.Renderer', 'goog.soy.data.SanitizedContentKind', 'goog.soy.testHelper', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('soy/soy.js', ['goog.soy'], ['goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.soy.data.SanitizedContent'], {});
goog.addDependency('soy/soy_test.js', ['goog.soyTest'], ['goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.functions', 'goog.soy', 'goog.soy.testHelper', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('soy/soy_testhelper.js', ['goog.soy.testHelper'], ['goog.dom', 'goog.dom.TagName', 'goog.i18n.bidi.Dir', 'goog.soy.data.SanitizedContent', 'goog.soy.data.SanitizedContentKind', 'goog.soy.data.SanitizedCss', 'goog.soy.data.SanitizedTrustedResourceUri', 'goog.string', 'goog.userAgent'], {'lang': 'es6'});
goog.addDependency('spell/spellcheck.js', ['goog.spell.SpellCheck', 'goog.spell.SpellCheck.WordChangedEvent'], ['goog.Timer', 'goog.events.Event', 'goog.events.EventTarget', 'goog.structs.Set'], {});
goog.addDependency('spell/spellcheck_test.js', ['goog.spell.SpellCheckTest'], ['goog.spell.SpellCheck', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('stats/basicstat.js', ['goog.stats.BasicStat'], ['goog.asserts', 'goog.log', 'goog.string.format', 'goog.structs.CircularBuffer'], {});
goog.addDependency('stats/basicstat_test.js', ['goog.stats.BasicStatTest'], ['goog.array', 'goog.stats.BasicStat', 'goog.string.format', 'goog.testing.PseudoRandom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/collectablestorage.js', ['goog.storage.CollectableStorage'], ['goog.array', 'goog.iter', 'goog.storage.ErrorCode', 'goog.storage.ExpiringStorage', 'goog.storage.RichStorage'], {});
goog.addDependency('storage/collectablestorage_test.js', ['goog.storage.CollectableStorageTest'], ['goog.storage.CollectableStorage', 'goog.storage.collectableStorageTester', 'goog.storage.storageTester', 'goog.testing.MockClock', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/collectablestoragetester.js', ['goog.storage.collectableStorageTester'], ['goog.testing.asserts'], {});
goog.addDependency('storage/encryptedstorage.js', ['goog.storage.EncryptedStorage'], ['goog.crypt', 'goog.crypt.Arc4', 'goog.crypt.Sha1', 'goog.crypt.base64', 'goog.json', 'goog.json.Serializer', 'goog.storage.CollectableStorage', 'goog.storage.ErrorCode', 'goog.storage.RichStorage'], {});
goog.addDependency('storage/encryptedstorage_test.js', ['goog.storage.EncryptedStorageTest'], ['goog.json', 'goog.storage.EncryptedStorage', 'goog.storage.ErrorCode', 'goog.storage.RichStorage', 'goog.storage.collectableStorageTester', 'goog.storage.storageTester', 'goog.testing.MockClock', 'goog.testing.PseudoRandom', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/errorcode.js', ['goog.storage.ErrorCode'], [], {});
goog.addDependency('storage/expiringstorage.js', ['goog.storage.ExpiringStorage'], ['goog.storage.RichStorage'], {});
goog.addDependency('storage/expiringstorage_test.js', ['goog.storage.ExpiringStorageTest'], ['goog.storage.ExpiringStorage', 'goog.storage.storageTester', 'goog.testing.MockClock', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/errorcode.js', ['goog.storage.mechanism.ErrorCode'], [], {});
goog.addDependency('storage/mechanism/errorhandlingmechanism.js', ['goog.storage.mechanism.ErrorHandlingMechanism'], ['goog.storage.mechanism.Mechanism'], {});
goog.addDependency('storage/mechanism/errorhandlingmechanism_test.js', ['goog.storage.mechanism.ErrorHandlingMechanismTest'], ['goog.storage.mechanism.ErrorHandlingMechanism', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/html5localstorage.js', ['goog.storage.mechanism.HTML5LocalStorage'], ['goog.storage.mechanism.HTML5WebStorage'], {});
goog.addDependency('storage/mechanism/html5localstorage_test.js', ['goog.storage.mechanism.HTML5LocalStorageTest'], ['goog.storage.mechanism.HTML5LocalStorage', 'goog.storage.mechanism.mechanismSeparationTester', 'goog.storage.mechanism.mechanismSharingTester', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/html5sessionstorage.js', ['goog.storage.mechanism.HTML5SessionStorage'], ['goog.storage.mechanism.HTML5WebStorage'], {});
goog.addDependency('storage/mechanism/html5sessionstorage_test.js', ['goog.storage.mechanism.HTML5SessionStorageTest'], ['goog.storage.mechanism.HTML5SessionStorage', 'goog.storage.mechanism.mechanismSeparationTester', 'goog.storage.mechanism.mechanismSharingTester', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/html5webstorage.js', ['goog.storage.mechanism.HTML5WebStorage'], ['goog.asserts', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.storage.mechanism.ErrorCode', 'goog.storage.mechanism.IterableMechanism'], {});
goog.addDependency('storage/mechanism/html5webstorage_test.js', ['goog.storage.mechanism.HTML5WebStorageTest'], ['goog.storage.mechanism.ErrorCode', 'goog.storage.mechanism.HTML5WebStorage', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/ieuserdata.js', ['goog.storage.mechanism.IEUserData'], ['goog.asserts', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.storage.mechanism.ErrorCode', 'goog.storage.mechanism.IterableMechanism', 'goog.structs.Map', 'goog.userAgent'], {});
goog.addDependency('storage/mechanism/ieuserdata_test.js', ['goog.storage.mechanism.IEUserDataTest'], ['goog.storage.mechanism.IEUserData', 'goog.storage.mechanism.mechanismSeparationTester', 'goog.storage.mechanism.mechanismSharingTester', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/iterablemechanism.js', ['goog.storage.mechanism.IterableMechanism'], ['goog.array', 'goog.asserts', 'goog.iter', 'goog.storage.mechanism.Mechanism'], {});
goog.addDependency('storage/mechanism/iterablemechanismtester.js', ['goog.storage.mechanism.iterableMechanismTester'], ['goog.iter', 'goog.iter.StopIteration', 'goog.testing.asserts'], {});
goog.addDependency('storage/mechanism/mechanism.js', ['goog.storage.mechanism.Mechanism'], [], {});
goog.addDependency('storage/mechanism/mechanismfactory.js', ['goog.storage.mechanism.mechanismfactory'], ['goog.storage.mechanism.HTML5LocalStorage', 'goog.storage.mechanism.HTML5SessionStorage', 'goog.storage.mechanism.IEUserData', 'goog.storage.mechanism.PrefixedMechanism'], {});
goog.addDependency('storage/mechanism/mechanismfactory_test.js', ['goog.storage.mechanism.mechanismfactoryTest'], ['goog.storage.mechanism.mechanismfactory', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/mechanism/mechanismseparationtester.js', ['goog.storage.mechanism.mechanismSeparationTester'], ['goog.iter.StopIteration', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.asserts'], {});
goog.addDependency('storage/mechanism/mechanismsharingtester.js', ['goog.storage.mechanism.mechanismSharingTester'], ['goog.iter.StopIteration', 'goog.storage.mechanism.mechanismTestDefinition', 'goog.testing.asserts'], {});
goog.addDependency('storage/mechanism/mechanismtestdefinition.js', ['goog.storage.mechanism.mechanismTestDefinition'], [], {});
goog.addDependency('storage/mechanism/mechanismtester.js', ['goog.storage.mechanism.mechanismTester'], ['goog.storage.mechanism.ErrorCode', 'goog.testing.asserts', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('storage/mechanism/prefixedmechanism.js', ['goog.storage.mechanism.PrefixedMechanism'], ['goog.iter.Iterator', 'goog.storage.mechanism.IterableMechanism'], {});
goog.addDependency('storage/mechanism/prefixedmechanism_test.js', ['goog.storage.mechanism.PrefixedMechanismTest'], ['goog.storage.mechanism.HTML5LocalStorage', 'goog.storage.mechanism.PrefixedMechanism', 'goog.storage.mechanism.mechanismSeparationTester', 'goog.storage.mechanism.mechanismSharingTester', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/richstorage.js', ['goog.storage.RichStorage', 'goog.storage.RichStorage.Wrapper'], ['goog.storage.ErrorCode', 'goog.storage.Storage'], {});
goog.addDependency('storage/richstorage_test.js', ['goog.storage.RichStorageTest'], ['goog.storage.ErrorCode', 'goog.storage.RichStorage', 'goog.storage.storageTester', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/storage.js', ['goog.storage.Storage'], ['goog.json', 'goog.storage.ErrorCode'], {});
goog.addDependency('storage/storage_test.js', ['goog.storage.storage_test'], ['goog.functions', 'goog.storage.ErrorCode', 'goog.storage.Storage', 'goog.storage.storageTester', 'goog.testing.asserts', 'goog.testing.storage.FakeMechanism', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('storage/storagetester.js', ['goog.storage.storageTester'], ['goog.storage.Storage', 'goog.structs.Map', 'goog.testing.asserts'], {});
goog.addDependency('streams/defines.js', ['goog.streams.defines'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full.js', ['goog.streams.full'], ['goog.streams.defines', 'goog.streams.fullImpl', 'goog.streams.fullNativeImpl', 'goog.streams.fullTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_impl.js', ['goog.streams.fullImpl'], ['goog.asserts', 'goog.promise.NativeResolver', 'goog.streams.fullTypes', 'goog.streams.liteImpl'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_impl_test.js', ['goog.streams.fullImplTest'], ['goog.streams.fullImpl', 'goog.streams.fullTestCases', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_native_impl.js', ['goog.streams.fullNativeImpl'], ['goog.streams.fullTypes', 'goog.streams.liteNativeImpl'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_native_impl_test.js', ['goog.streams.fullNativeImplTest'], ['goog.streams.fullNativeImpl', 'goog.streams.fullTestCases', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/full_test_cases.js', ['goog.streams.fullTestCases'], ['goog.streams.fullTypes', 'goog.streams.liteTestCases', 'goog.testing.recordFunction'], {'lang': 'es9', 'module': 'goog'});
goog.addDependency('streams/full_types.js', ['goog.streams.fullTypes'], ['goog.streams.liteTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite.js', ['goog.streams.lite'], ['goog.streams.defines', 'goog.streams.liteImpl', 'goog.streams.liteNativeImpl', 'goog.streams.liteTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_impl.js', ['goog.streams.liteImpl'], ['goog.asserts', 'goog.promise.NativeResolver', 'goog.streams.liteTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_impl_test.js', ['goog.streams.liteImplTest'], ['goog.streams.liteImpl', 'goog.streams.liteTestCases', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_native_impl.js', ['goog.streams.liteNativeImpl'], ['goog.streams.liteTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_native_impl_test.js', ['goog.streams.liteNativeImplTest'], ['goog.streams.liteNativeImpl', 'goog.streams.liteTestCases', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('streams/lite_test_cases.js', ['goog.streams.liteTestCases'], ['goog.streams.liteTypes', 'goog.testing.jsunit'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('streams/lite_types.js', ['goog.streams.liteTypes'], [], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/const.js', ['goog.string.Const'], ['goog.asserts', 'goog.string.TypedString'], {});
goog.addDependency('string/const_test.js', ['goog.string.constTest'], ['goog.string.Const', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/internal.js', ['goog.string.internal'], [], {'lang': 'es6'});
goog.addDependency('string/linkify.js', ['goog.string.linkify'], ['goog.html.SafeHtml', 'goog.string'], {});
goog.addDependency('string/linkify_test.js', ['goog.string.linkifyTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.string', 'goog.string.linkify', 'goog.testing.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/newlines.js', ['goog.string.newlines', 'goog.string.newlines.Line'], ['goog.array'], {});
goog.addDependency('string/newlines_test.js', ['goog.string.newlinesTest'], ['goog.string.newlines', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/parser.js', ['goog.string.Parser'], [], {});
goog.addDependency('string/path.js', ['goog.string.path'], ['goog.array', 'goog.string'], {});
goog.addDependency('string/path_test.js', ['goog.string.pathTest'], ['goog.string.path', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/string.js', ['goog.string', 'goog.string.Unicode'], ['goog.dom.safe', 'goog.html.uncheckedconversions', 'goog.string.Const', 'goog.string.internal'], {});
goog.addDependency('string/string_test.js', ['goog.stringTest'], ['goog.dom', 'goog.dom.TagName', 'goog.functions', 'goog.object', 'goog.string', 'goog.string.Unicode', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/stringbuffer.js', ['goog.string.StringBuffer'], [], {'lang': 'es6'});
goog.addDependency('string/stringbuffer_test.js', ['goog.string.StringBufferTest'], ['goog.string.StringBuffer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/stringformat.js', ['goog.string.format'], ['goog.string'], {});
goog.addDependency('string/stringformat_test.js', ['goog.string.formatTest'], ['goog.string.format', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('string/stringifier.js', ['goog.string.Stringifier'], [], {});
goog.addDependency('string/typedstring.js', ['goog.string.TypedString'], [], {});
goog.addDependency('structs/avltree.js', ['goog.structs.AvlTree'], ['goog.asserts', 'goog.structs.Collection'], {'module': 'goog'});
goog.addDependency('structs/avltree_test.js', ['goog.structs.AvlTreeTest'], ['goog.array', 'goog.structs.AvlTree', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/circularbuffer.js', ['goog.structs.CircularBuffer'], [], {'lang': 'es6'});
goog.addDependency('structs/circularbuffer_test.js', ['goog.structs.CircularBufferTest'], ['goog.structs.CircularBuffer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/collection.js', ['goog.structs.Collection'], [], {});
goog.addDependency('structs/collection_test.js', ['goog.structs.CollectionTest'], ['goog.structs.AvlTree', 'goog.structs.Set', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/heap.js', ['goog.structs.Heap'], ['goog.array', 'goog.object', 'goog.structs.Node'], {});
goog.addDependency('structs/heap_test.js', ['goog.structs.HeapTest'], ['goog.structs', 'goog.structs.Heap', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/inversionmap.js', ['goog.structs.InversionMap'], ['goog.array', 'goog.asserts'], {});
goog.addDependency('structs/inversionmap_test.js', ['goog.structs.InversionMapTest'], ['goog.structs.InversionMap', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/linkedmap.js', ['goog.structs.LinkedMap'], ['goog.structs.Map'], {});
goog.addDependency('structs/linkedmap_test.js', ['goog.structs.LinkedMapTest'], ['goog.structs.LinkedMap', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/map.js', ['goog.structs.Map'], ['goog.iter.Iterator', 'goog.iter.StopIteration'], {});
goog.addDependency('structs/map_test.js', ['goog.structs.MapTest'], ['goog.iter', 'goog.structs', 'goog.structs.Map', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/node.js', ['goog.structs.Node'], [], {});
goog.addDependency('structs/pool.js', ['goog.structs.Pool'], ['goog.Disposable', 'goog.structs.Queue', 'goog.structs.Set'], {});
goog.addDependency('structs/pool_test.js', ['goog.structs.PoolTest'], ['goog.structs.Pool', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/prioritypool.js', ['goog.structs.PriorityPool'], ['goog.structs.Pool', 'goog.structs.PriorityQueue'], {});
goog.addDependency('structs/prioritypool_test.js', ['goog.structs.PriorityPoolTest'], ['goog.structs.PriorityPool', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/priorityqueue.js', ['goog.structs.PriorityQueue'], ['goog.structs.Heap'], {});
goog.addDependency('structs/priorityqueue_test.js', ['goog.structs.PriorityQueueTest'], ['goog.structs', 'goog.structs.PriorityQueue', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/quadtree.js', ['goog.structs.QuadTree', 'goog.structs.QuadTree.Node', 'goog.structs.QuadTree.Point'], ['goog.math.Coordinate'], {});
goog.addDependency('structs/quadtree_test.js', ['goog.structs.QuadTreeTest'], ['goog.structs', 'goog.structs.QuadTree', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/queue.js', ['goog.structs.Queue'], ['goog.array'], {});
goog.addDependency('structs/queue_test.js', ['goog.structs.QueueTest'], ['goog.structs.Queue', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/set.js', ['goog.structs.Set'], ['goog.structs', 'goog.structs.Collection', 'goog.structs.Map'], {});
goog.addDependency('structs/set_test.js', ['goog.structs.SetTest'], ['goog.iter', 'goog.structs', 'goog.structs.Set', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/simplepool.js', ['goog.structs.SimplePool'], ['goog.Disposable'], {});
goog.addDependency('structs/stringset.js', ['goog.structs.StringSet'], ['goog.asserts', 'goog.iter'], {});
goog.addDependency('structs/stringset_test.js', ['goog.structs.StringSetTest'], ['goog.array', 'goog.iter', 'goog.structs.StringSet', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/structs.js', ['goog.structs'], ['goog.array', 'goog.object'], {});
goog.addDependency('structs/structs_test.js', ['goog.structsTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.structs', 'goog.structs.Map', 'goog.structs.Set', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/treenode.js', ['goog.structs.TreeNode'], ['goog.array', 'goog.asserts', 'goog.structs.Node'], {});
goog.addDependency('structs/treenode_test.js', ['goog.structs.TreeNodeTest'], ['goog.structs.TreeNode', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('structs/trie.js', ['goog.structs.Trie'], ['goog.object', 'goog.structs'], {});
goog.addDependency('structs/trie_test.js', ['goog.structs.TrieTest'], ['goog.object', 'goog.structs', 'goog.structs.Trie', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/bidi.js', ['goog.style.bidi'], ['goog.dom', 'goog.style', 'goog.userAgent', 'goog.userAgent.platform', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('style/bidi_test.js', ['goog.style.bidiTest'], ['goog.dom', 'goog.style', 'goog.style.bidi', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/cursor.js', ['goog.style.cursor'], ['goog.userAgent'], {});
goog.addDependency('style/cursor_test.js', ['goog.style.cursorTest'], ['goog.style.cursor', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/style.js', ['goog.style'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.vendor', 'goog.html.SafeStyleSheet', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.math.Size', 'goog.object', 'goog.reflect', 'goog.string', 'goog.userAgent'], {});
goog.addDependency('style/style_document_scroll_test.js', ['goog.style.style_document_scroll_test'], ['goog.dom', 'goog.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/style_test.js', ['goog.style_test'], ['goog.array', 'goog.color', 'goog.dom', 'goog.dom.TagName', 'goog.events.BrowserEvent', 'goog.html.testing', 'goog.labs.userAgent.util', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.math.Size', 'goog.object', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.MockUserAgent', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgentTestUtil', 'goog.userAgentTestUtil.UserAgents'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/style_webkit_scrollbars_test.js', ['goog.style.webkitScrollbarsTest'], ['goog.asserts', 'goog.style', 'goog.styleScrollbarTester', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/stylescrollbartester.js', ['goog.styleScrollbarTester'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.testing.asserts'], {});
goog.addDependency('style/transform.js', ['goog.style.transform'], ['goog.functions', 'goog.math.Coordinate', 'goog.math.Coordinate3', 'goog.style', 'goog.userAgent', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('style/transform_test.js', ['goog.style.transformTest'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.style.transform', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('style/transition.js', ['goog.style.transition', 'goog.style.transition.Css3Property'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.dom.vendor', 'goog.functions', 'goog.html.SafeHtml', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('style/transition_test.js', ['goog.style.transitionTest'], ['goog.style', 'goog.style.transition', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('test_module.js', ['goog.test_module'], ['goog.test_module_dep'], {'module': 'goog'});
goog.addDependency('test_module_dep.js', ['goog.test_module_dep'], [], {'module': 'goog'});
goog.addDependency('testing/assertionfailure.js', ['goog.testing.safe.assertionFailure'], ['goog.asserts', 'goog.testing.asserts'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/asserts.js', ['goog.testing.asserts'], ['goog.testing.JsUnitException'], {});
goog.addDependency('testing/asserts_test.js', ['goog.testing.assertsTest'], ['goog.Promise', 'goog.array', 'goog.async.Deferred', 'goog.dom', 'goog.iter.Iterator', 'goog.iter.StopIteration', 'goog.structs.Map', 'goog.structs.Set', 'goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/async/mockcontrol.js', ['goog.testing.async.MockControl'], ['goog.asserts', 'goog.async.Deferred', 'goog.debug', 'goog.testing.MockControl', 'goog.testing.asserts', 'goog.testing.mockmatchers.IgnoreArgument'], {});
goog.addDependency('testing/async/mockcontrol_test.js', ['goog.testing.async.MockControlTest'], ['goog.async.Deferred', 'goog.testing.MockControl', 'goog.testing.asserts', 'goog.testing.async.MockControl', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/asynctestcase.js', ['goog.testing.AsyncTestCase', 'goog.testing.AsyncTestCase.ControlBreakingException'], ['goog.asserts', 'goog.testing.TestCase', 'goog.testing.asserts'], {});
goog.addDependency('testing/asynctestcase_async_test.js', ['goog.testing.AsyncTestCaseAsyncTest'], ['goog.testing.AsyncTestCase', 'goog.testing.TestCase', 'goog.testing.jsunit'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/asynctestcase_noasync_test.js', ['goog.testing.AsyncTestCaseSyncTest'], ['goog.testing.AsyncTestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/asynctestcase_test.js', ['goog.testing.AsyncTestCaseTest'], ['goog.debug.Error', 'goog.testing.AsyncTestCase', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/benchmark.js', ['goog.testing.benchmark'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.PerformanceTable', 'goog.testing.PerformanceTimer', 'goog.testing.TestCase'], {});
goog.addDependency('testing/continuationtestcase.js', ['goog.testing.ContinuationTestCase', 'goog.testing.ContinuationTestCase.ContinuationTest', 'goog.testing.ContinuationTestCase.Step'], ['goog.array', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.testing.TestCase', 'goog.testing.asserts'], {});
goog.addDependency('testing/continuationtestcase_test.js', ['goog.testing.ContinuationTestCaseTest'], ['goog.events', 'goog.events.EventTarget', 'goog.testing.ContinuationTestCase', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.jsunit'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/deferredtestcase.js', ['goog.testing.DeferredTestCase'], ['goog.async.Deferred', 'goog.testing.AsyncTestCase', 'goog.testing.TestCase'], {});
goog.addDependency('testing/deferredtestcase_test.js', ['goog.testing.DeferredTestCaseTest'], ['goog.async.Deferred', 'goog.testing.DeferredTestCase', 'goog.testing.TestCase', 'goog.testing.TestRunner', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/dom.js', ['goog.testing.dom'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.AbstractRange', 'goog.dom.InputType', 'goog.dom.NodeIterator', 'goog.dom.NodeType', 'goog.dom.TagIterator', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.iter', 'goog.object', 'goog.string', 'goog.style', 'goog.testing.asserts', 'goog.userAgent'], {});
goog.addDependency('testing/dom_test.js', ['goog.testing.domTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/editor/dom.js', ['goog.testing.editor.dom'], ['goog.dom.AbstractRange', 'goog.dom.NodeType', 'goog.dom.TagIterator', 'goog.dom.TagWalkType', 'goog.iter', 'goog.string', 'goog.testing.asserts'], {});
goog.addDependency('testing/editor/dom_test.js', ['goog.testing.editor.domTest'], ['goog.dom', 'goog.dom.TagName', 'goog.functions', 'goog.testing.editor.dom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/editor/fieldmock.js', ['goog.testing.editor.FieldMock'], ['goog.dom', 'goog.dom.Range', 'goog.editor.Field', 'goog.testing.LooseMock', 'goog.testing.mockmatchers'], {});
goog.addDependency('testing/editor/testhelper.js', ['goog.testing.editor.TestHelper'], ['goog.Disposable', 'goog.dom', 'goog.dom.Range', 'goog.editor.BrowserFeature', 'goog.editor.node', 'goog.editor.plugins.AbstractBubblePlugin', 'goog.testing.dom'], {});
goog.addDependency('testing/editor/testhelper_test.js', ['goog.testing.editor.TestHelperTest'], ['goog.dom', 'goog.dom.TagName', 'goog.editor.node', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/events/eventobserver.js', ['goog.testing.events.EventObserver'], ['goog.array', 'goog.events.Event'], {});
goog.addDependency('testing/events/eventobserver_test.js', ['goog.testing.events.EventObserverTest'], ['goog.array', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.testing.events.EventObserver', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/events/events.js', ['goog.testing.events', 'goog.testing.events.Event'], ['goog.Disposable', 'goog.asserts', 'goog.dom.NodeType', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.BrowserFeature', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.object', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('testing/events/events_test.js', ['goog.testing.eventsTest'], ['goog.array', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Coordinate', 'goog.string', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/events/matchers.js', ['goog.testing.events.EventMatcher'], ['goog.events.Event', 'goog.testing.mockmatchers.ArgumentMatcher'], {});
goog.addDependency('testing/events/matchers_test.js', ['goog.testing.events.EventMatcherTest'], ['goog.events.Event', 'goog.testing.events.EventMatcher', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/events/onlinehandler.js', ['goog.testing.events.OnlineHandler'], ['goog.events.EventTarget', 'goog.net.NetworkStatusMonitor'], {});
goog.addDependency('testing/events/onlinehandler_test.js', ['goog.testing.events.OnlineHandlerTest'], ['goog.events', 'goog.net.NetworkStatusMonitor', 'goog.testing.events.EventObserver', 'goog.testing.events.OnlineHandler', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/expectedfailures.js', ['goog.testing.ExpectedFailures'], ['goog.asserts', 'goog.debug.DivConsole', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.log', 'goog.style', 'goog.testing.JsUnitException', 'goog.testing.TestCase', 'goog.testing.asserts'], {});
goog.addDependency('testing/expectedfailures_test.js', ['goog.testing.ExpectedFailuresTest'], ['goog.debug.Logger', 'goog.testing.ExpectedFailures', 'goog.testing.JsUnitException', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/blob.js', ['goog.testing.fs.Blob'], ['goog.crypt', 'goog.crypt.base64'], {});
goog.addDependency('testing/fs/blob_test.js', ['goog.testing.fs.BlobTest'], ['goog.dom', 'goog.testing.fs.Blob', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/directoryentry_test.js', ['goog.testing.fs.DirectoryEntryTest'], ['goog.array', 'goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.testing.MockClock', 'goog.testing.TestCase', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/entry.js', ['goog.testing.fs.DirectoryEntry', 'goog.testing.fs.Entry', 'goog.testing.fs.FileEntry'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.async.Deferred', 'goog.fs.DirectoryEntry', 'goog.fs.DirectoryEntryImpl', 'goog.fs.Entry', 'goog.fs.Error', 'goog.fs.FileEntry', 'goog.functions', 'goog.object', 'goog.string', 'goog.testing.fs.File', 'goog.testing.fs.FileWriter'], {});
goog.addDependency('testing/fs/entry_test.js', ['goog.testing.fs.EntryTest'], ['goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.testing.MockClock', 'goog.testing.TestCase', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/file.js', ['goog.testing.fs.File'], ['goog.testing.fs.Blob'], {});
goog.addDependency('testing/fs/fileentry_test.js', ['goog.testing.fs.FileEntryTest'], ['goog.testing.MockClock', 'goog.testing.fs.FileEntry', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/filereader.js', ['goog.testing.fs.FileReader'], ['goog.Timer', 'goog.events.EventTarget', 'goog.fs.Error', 'goog.fs.FileReader', 'goog.testing.fs.Blob', 'goog.testing.fs.ProgressEvent'], {});
goog.addDependency('testing/fs/filereader_test.js', ['goog.testing.fs.FileReaderTest'], ['goog.Promise', 'goog.array', 'goog.events', 'goog.fs.Error', 'goog.fs.FileReader', 'goog.object', 'goog.testing.events.EventObserver', 'goog.testing.fs.FileReader', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/filesystem.js', ['goog.testing.fs.FileSystem'], ['goog.fs.FileSystem', 'goog.testing.fs.DirectoryEntry'], {});
goog.addDependency('testing/fs/filewriter.js', ['goog.testing.fs.FileWriter'], ['goog.Timer', 'goog.events.EventTarget', 'goog.fs.Error', 'goog.fs.FileSaver', 'goog.string', 'goog.testing.fs.Blob', 'goog.testing.fs.File', 'goog.testing.fs.ProgressEvent'], {});
goog.addDependency('testing/fs/filewriter_test.js', ['goog.testing.fs.FileWriterTest'], ['goog.Promise', 'goog.array', 'goog.events', 'goog.fs.Error', 'goog.fs.FileSaver', 'goog.object', 'goog.testing.MockClock', 'goog.testing.events.EventObserver', 'goog.testing.fs.Blob', 'goog.testing.fs.FileSystem', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/fs.js', ['goog.testing.fs'], ['goog.Timer', 'goog.array', 'goog.async.Deferred', 'goog.fs', 'goog.testing.PropertyReplacer', 'goog.testing.fs.Blob', 'goog.testing.fs.FileSystem'], {});
goog.addDependency('testing/fs/fs_test.js', ['goog.testing.fsTest'], ['goog.testing.fs', 'goog.testing.fs.Blob', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/integration_test.js', ['goog.testing.fs.integrationTest'], ['goog.Promise', 'goog.events', 'goog.fs', 'goog.fs.DirectoryEntry', 'goog.fs.Error', 'goog.fs.FileSaver', 'goog.testing.PropertyReplacer', 'goog.testing.fs', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/fs/progressevent.js', ['goog.testing.fs.ProgressEvent'], ['goog.events.Event'], {});
goog.addDependency('testing/functionmock.js', ['goog.testing', 'goog.testing.FunctionMock', 'goog.testing.GlobalFunctionMock', 'goog.testing.MethodMock'], ['goog.object', 'goog.testing.LooseMock', 'goog.testing.Mock', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock'], {});
goog.addDependency('testing/functionmock_test.js', ['goog.testing.FunctionMockTest'], ['goog.array', 'goog.string', 'goog.testing', 'goog.testing.FunctionMock', 'goog.testing.Mock', 'goog.testing.StrictMock', 'goog.testing.asserts', 'goog.testing.mockmatchers', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/graphics.js', ['goog.testing.graphics'], ['goog.graphics.Path', 'goog.testing.asserts'], {});
goog.addDependency('testing/i18n/asserts.js', ['goog.testing.i18n.asserts'], ['goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('testing/i18n/asserts_test.js', ['goog.testing.i18n.assertsTest'], ['goog.testing.ExpectedFailures', 'goog.testing.i18n.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/jstdasyncwrapper.js', ['goog.testing.JsTdAsyncWrapper'], ['goog.Promise'], {});
goog.addDependency('testing/jstdtestcaseadapter.js', ['goog.testing.JsTdTestCaseAdapter'], ['goog.async.run', 'goog.functions', 'goog.testing.JsTdAsyncWrapper', 'goog.testing.TestCase', 'goog.testing.jsunit'], {});
goog.addDependency('testing/jsunit.js', ['goog.testing.jsunit'], ['goog.dom.TagName', 'goog.testing.TestCase', 'goog.testing.TestRunner', 'goog.userAgent'], {});
goog.addDependency('testing/jsunitexception.js', ['goog.testing.JsUnitException'], ['goog.testing.stacktrace'], {});
goog.addDependency('testing/loosemock.js', ['goog.testing.LooseExpectationCollection', 'goog.testing.LooseMock'], ['goog.array', 'goog.asserts', 'goog.structs.Map', 'goog.structs.Set', 'goog.testing.Mock'], {});
goog.addDependency('testing/loosemock_test.js', ['goog.testing.LooseMockTest'], ['goog.testing.LooseMock', 'goog.testing.mockmatchers', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/messaging/mockmessagechannel.js', ['goog.testing.messaging.MockMessageChannel'], ['goog.messaging.AbstractChannel', 'goog.testing.MockControl', 'goog.testing.asserts'], {});
goog.addDependency('testing/messaging/mockmessageevent.js', ['goog.testing.messaging.MockMessageEvent'], ['goog.events.BrowserEvent', 'goog.events.EventType', 'goog.testing.events.Event'], {});
goog.addDependency('testing/messaging/mockmessageport.js', ['goog.testing.messaging.MockMessagePort'], ['goog.events.EventTarget', 'goog.testing.MockControl'], {});
goog.addDependency('testing/messaging/mockportnetwork.js', ['goog.testing.messaging.MockPortNetwork'], ['goog.messaging.PortNetwork', 'goog.testing.messaging.MockMessageChannel'], {});
goog.addDependency('testing/mock.js', ['goog.testing.Mock', 'goog.testing.MockExpectation'], ['goog.Promise', 'goog.array', 'goog.asserts', 'goog.object', 'goog.promise.Resolver', 'goog.testing.JsUnitException', 'goog.testing.MockInterface', 'goog.testing.mockmatchers'], {});
goog.addDependency('testing/mock_test.js', ['goog.testing.MockTest'], ['goog.array', 'goog.testing', 'goog.testing.Mock', 'goog.testing.MockControl', 'goog.testing.MockExpectation', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/mockclassfactory.js', ['goog.testing.MockClassFactory', 'goog.testing.MockClassRecord'], ['goog.array', 'goog.object', 'goog.testing.LooseMock', 'goog.testing.StrictMock', 'goog.testing.TestCase', 'goog.testing.mockmatchers'], {});
goog.addDependency('testing/mockclassfactory_test.js', ['fake.BaseClass', 'fake.ChildClass', 'goog.testing.MockClassFactoryTest'], ['goog.testing', 'goog.testing.MockClassFactory', 'goog.testing.jsunit'], {'lang': 'es6'});
goog.addDependency('testing/mockclock.js', ['goog.testing.MockClock'], ['goog.Disposable', 'goog.Promise', 'goog.Thenable', 'goog.async.run', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.events.Event'], {});
goog.addDependency('testing/mockclock_test.js', ['goog.testing.MockClockTest'], ['goog.Promise', 'goog.Timer', 'goog.events', 'goog.functions', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockcontrol.js', ['goog.testing.MockControl'], ['goog.Promise', 'goog.array', 'goog.testing', 'goog.testing.LooseMock', 'goog.testing.StrictMock'], {});
goog.addDependency('testing/mockcontrol_test.js', ['goog.testing.MockControlTest'], ['goog.testing.Mock', 'goog.testing.MockControl', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockinterface.js', ['goog.testing.MockInterface'], ['goog.Promise'], {});
goog.addDependency('testing/mockmatchers.js', ['goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.mockmatchers.IgnoreArgument', 'goog.testing.mockmatchers.InstanceOf', 'goog.testing.mockmatchers.ObjectEquals', 'goog.testing.mockmatchers.RegexpMatch', 'goog.testing.mockmatchers.SaveArgument', 'goog.testing.mockmatchers.TypeOf'], ['goog.array', 'goog.dom', 'goog.testing.asserts'], {});
goog.addDependency('testing/mockmatchers_test.js', ['goog.testing.mockmatchersTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.jsunit', 'goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher'], {'lang': 'es6'});
goog.addDependency('testing/mockrandom.js', ['goog.testing.MockRandom'], ['goog.Disposable'], {});
goog.addDependency('testing/mockrandom_test.js', ['goog.testing.MockRandomTest'], ['goog.testing.MockRandom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockrange.js', ['goog.testing.MockRange'], ['goog.dom.AbstractRange', 'goog.testing.LooseMock'], {});
goog.addDependency('testing/mockrange_test.js', ['goog.testing.MockRangeTest'], ['goog.testing.MockRange', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockstorage.js', ['goog.testing.MockStorage'], ['goog.structs.Map'], {});
goog.addDependency('testing/mockstorage_test.js', ['goog.testing.MockStorageTest'], ['goog.testing.MockStorage', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/mockuseragent.js', ['goog.testing.MockUserAgent'], ['goog.Disposable', 'goog.labs.userAgent.util', 'goog.testing.PropertyReplacer', 'goog.userAgent'], {});
goog.addDependency('testing/mockuseragent_test.js', ['goog.testing.MockUserAgentTest'], ['goog.dispose', 'goog.testing.MockUserAgent', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/multitestrunner.js', ['goog.testing.MultiTestRunner', 'goog.testing.MultiTestRunner.TestFrame'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventHandler', 'goog.functions', 'goog.object', 'goog.string', 'goog.testing.TestCase', 'goog.ui.Component', 'goog.ui.ServerChart', 'goog.ui.TableSorter'], {});
goog.addDependency('testing/multitestrunner_test.js', ['goog.testing.MultiTestRunnerTest'], ['goog.Promise', 'goog.array', 'goog.events', 'goog.testing.MockControl', 'goog.testing.MultiTestRunner', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.events', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/net/mockiframeio.js', ['goog.testing.net.MockIFrameIo'], ['goog.events.EventTarget', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.IframeIo', 'goog.testing.TestQueue'], {});
goog.addDependency('testing/net/xhrio.js', ['goog.testing.net.XhrIo'], ['goog.Uri', 'goog.array', 'goog.dom.xml', 'goog.events', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.HttpStatus', 'goog.net.XhrIo', 'goog.net.XmlHttp', 'goog.object', 'goog.structs', 'goog.structs.Map', 'goog.testing.TestQueue', 'goog.uri.utils'], {});
goog.addDependency('testing/net/xhrio_test.js', ['goog.testing.net.XhrIoTest'], ['goog.dom.xml', 'goog.events', 'goog.events.Event', 'goog.net.ErrorCode', 'goog.net.EventType', 'goog.net.XmlHttp', 'goog.object', 'goog.testing.MockControl', 'goog.testing.asserts', 'goog.testing.mockmatchers.InstanceOf', 'goog.testing.net.XhrIo', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/net/xhriopool.js', ['goog.testing.net.XhrIoPool'], ['goog.net.XhrIoPool', 'goog.testing.net.XhrIo'], {});
goog.addDependency('testing/objectpropertystring.js', ['goog.testing.ObjectPropertyString'], [], {});
goog.addDependency('testing/parallel_closure_test_suite.js', ['goog.testing.parallelClosureTestSuite'], ['goog.Promise', 'goog.asserts', 'goog.events', 'goog.json', 'goog.testing.MultiTestRunner', 'goog.testing.TestCase', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/parallel_closure_test_suite_test.js', ['goog.testing.parallelClosureTestSuiteTest'], ['goog.dom', 'goog.testing.MockControl', 'goog.testing.MultiTestRunner', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.parallelClosureTestSuite', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/performancetable.js', ['goog.testing.PerformanceTable'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.testing.PerformanceTimer'], {});
goog.addDependency('testing/performancetimer.js', ['goog.testing.PerformanceTimer', 'goog.testing.PerformanceTimer.Task'], ['goog.array', 'goog.async.Deferred', 'goog.math'], {'lang': 'es6'});
goog.addDependency('testing/performancetimer_test.js', ['goog.testing.PerformanceTimerTest'], ['goog.async.Deferred', 'goog.dom', 'goog.math', 'goog.testing.MockClock', 'goog.testing.PerformanceTimer', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/propertyreplacer.js', ['goog.testing.PropertyReplacer'], ['goog.asserts', 'goog.userAgent'], {});
goog.addDependency('testing/propertyreplacer_test.js', ['goog.testing.PropertyReplacerTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/proto2/proto2.js', ['goog.testing.proto2'], ['goog.proto2.Message', 'goog.proto2.ObjectSerializer', 'goog.testing.asserts'], {});
goog.addDependency('testing/proto2/proto2_test.js', ['goog.testing.proto2Test'], ['goog.testing.proto2', 'goog.testing.testSuite', 'proto2.TestAllTypes'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/pseudorandom.js', ['goog.testing.PseudoRandom'], ['goog.Disposable'], {});
goog.addDependency('testing/pseudorandom_test.js', ['goog.testing.PseudoRandomTest'], ['goog.testing.PseudoRandom', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/recordfunction.js', ['goog.testing.FunctionCall', 'goog.testing.recordConstructor', 'goog.testing.recordFunction'], ['goog.Promise', 'goog.promise.Resolver', 'goog.testing.asserts'], {});
goog.addDependency('testing/recordfunction_test.js', ['goog.testing.recordFunctionTest'], ['goog.functions', 'goog.testing.PropertyReplacer', 'goog.testing.recordConstructor', 'goog.testing.recordFunction', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/shardingtestcase.js', ['goog.testing.ShardingTestCase'], ['goog.asserts', 'goog.testing.TestCase'], {});
goog.addDependency('testing/shardingtestcase_test.js', ['goog.testing.ShardingTestCaseTest'], ['goog.testing.ShardingTestCase', 'goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.jsunit'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/singleton.js', ['goog.testing.singleton'], [], {'lang': 'es6'});
goog.addDependency('testing/singleton_test.js', ['goog.testing.singletonTest'], ['goog.testing.asserts', 'goog.testing.singleton', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/stacktrace.js', ['goog.testing.stacktrace', 'goog.testing.stacktrace.Frame'], [], {'lang': 'es6'});
goog.addDependency('testing/stacktrace_test.js', ['goog.testing.stacktraceTest'], ['goog.functions', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock', 'goog.testing.asserts', 'goog.testing.stacktrace', 'goog.testing.stacktrace.Frame', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/storage/fakemechanism.js', ['goog.testing.storage.FakeMechanism'], ['goog.storage.mechanism.IterableMechanism', 'goog.structs.Map'], {});
goog.addDependency('testing/strictmock.js', ['goog.testing.StrictMock'], ['goog.array', 'goog.asserts', 'goog.structs.Set', 'goog.testing.Mock'], {});
goog.addDependency('testing/strictmock_test.js', ['goog.testing.StrictMockTest'], ['goog.testing.StrictMock', 'goog.testing.testSuite'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/style/layoutasserts.js', ['goog.testing.style.layoutasserts'], ['goog.style', 'goog.testing.asserts', 'goog.testing.style'], {});
goog.addDependency('testing/style/layoutasserts_test.js', ['goog.testing.style.layoutassertsTest'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.testing.style.layoutasserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/style/style.js', ['goog.testing.style'], ['goog.dom', 'goog.math.Rect', 'goog.style'], {});
goog.addDependency('testing/style/style_test.js', ['goog.testing.styleTest'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.testing.style', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/testcase.js', ['goog.testing.TestCase', 'goog.testing.TestCase.Error', 'goog.testing.TestCase.Order', 'goog.testing.TestCase.Result', 'goog.testing.TestCase.Test'], ['goog.Promise', 'goog.Thenable', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.object', 'goog.testing.JsUnitException', 'goog.testing.asserts'], {});
goog.addDependency('testing/testcase_test.js', ['goog.testing.TestCaseTest'], ['goog.Promise', 'goog.Timer', 'goog.functions', 'goog.string', 'goog.testing.ExpectedFailures', 'goog.testing.FunctionMock', 'goog.testing.JsUnitException', 'goog.testing.MethodMock', 'goog.testing.MockRandom', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es8', 'module': 'goog'});
goog.addDependency('testing/testqueue.js', ['goog.testing.TestQueue'], [], {});
goog.addDependency('testing/testrunner.js', ['goog.testing.TestRunner'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.json', 'goog.testing.TestCase', 'goog.userAgent'], {});
goog.addDependency('testing/testrunner_test.js', ['goog.testing.TestRunnerTest'], ['goog.testing.TestCase', 'goog.testing.TestRunner', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/testsuite.js', ['goog.testing.testSuite'], ['goog.labs.testing.Environment', 'goog.testing.TestCase'], {});
goog.addDependency('testing/testsuite_test.js', ['goog.testing.testSuiteTest'], ['goog.testing.TestCase', 'goog.testing.asserts', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/ui/rendererasserts.js', ['goog.testing.ui.rendererasserts'], ['goog.testing.asserts', 'goog.ui.ControlRenderer'], {});
goog.addDependency('testing/ui/rendererasserts_test.js', ['goog.testing.ui.rendererassertsTest'], ['goog.testing.asserts', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.ControlRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('testing/ui/rendererharness.js', ['goog.testing.ui.RendererHarness'], ['goog.Disposable', 'goog.dom.NodeType', 'goog.testing.asserts', 'goog.testing.dom', 'goog.ui.Control', 'goog.ui.ControlRenderer'], {});
goog.addDependency('testing/ui/style.js', ['goog.testing.ui.style'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.testing.asserts'], {});
goog.addDependency('testing/ui/style_test.js', ['goog.testing.ui.styleTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.style'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('timer/timer.js', ['goog.Timer'], ['goog.Promise', 'goog.events.EventTarget'], {});
goog.addDependency('timer/timer_test.js', ['goog.TimerTest'], ['goog.Promise', 'goog.Timer', 'goog.events', 'goog.testing.MockClock', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('tweak/entries.js', ['goog.tweak.BaseEntry', 'goog.tweak.BasePrimitiveSetting', 'goog.tweak.BaseSetting', 'goog.tweak.BooleanGroup', 'goog.tweak.BooleanInGroupSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.ButtonAction', 'goog.tweak.NumericSetting', 'goog.tweak.StringSetting'], ['goog.array', 'goog.asserts', 'goog.log', 'goog.object'], {});
goog.addDependency('tweak/entries_test.js', ['goog.tweak.BaseEntryTest'], ['goog.testing.MockControl', 'goog.testing.testSuite', 'goog.tweak.testhelpers'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('tweak/registry.js', ['goog.tweak.Registry'], ['goog.array', 'goog.asserts', 'goog.log', 'goog.string', 'goog.tweak.BasePrimitiveSetting', 'goog.tweak.BaseSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.NumericSetting', 'goog.tweak.StringSetting', 'goog.uri.utils'], {});
goog.addDependency('tweak/registry_test.js', ['goog.tweak.RegistryTest'], ['goog.asserts.AssertionError', 'goog.testing.testSuite', 'goog.tweak', 'goog.tweak.testhelpers'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('tweak/testhelpers.js', ['goog.tweak.testhelpers'], ['goog.tweak', 'goog.tweak.BooleanGroup', 'goog.tweak.BooleanInGroupSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.ButtonAction', 'goog.tweak.NumericSetting', 'goog.tweak.Registry', 'goog.tweak.StringSetting'], {});
goog.addDependency('tweak/tweak.js', ['goog.tweak', 'goog.tweak.ConfigParams'], ['goog.asserts', 'goog.tweak.BaseSetting', 'goog.tweak.BooleanGroup', 'goog.tweak.BooleanInGroupSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.ButtonAction', 'goog.tweak.NumericSetting', 'goog.tweak.Registry', 'goog.tweak.StringSetting'], {});
goog.addDependency('tweak/tweakui.js', ['goog.tweak.EntriesPanel', 'goog.tweak.TweakUi'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.html.SafeStyleSheet', 'goog.object', 'goog.string.Const', 'goog.style', 'goog.tweak', 'goog.tweak.BaseEntry', 'goog.tweak.BooleanGroup', 'goog.tweak.BooleanInGroupSetting', 'goog.tweak.BooleanSetting', 'goog.tweak.ButtonAction', 'goog.tweak.NumericSetting', 'goog.tweak.StringSetting', 'goog.ui.Zippy', 'goog.userAgent'], {});
goog.addDependency('tweak/tweakui_test.js', ['goog.tweak.TweakUiTest'], ['goog.dom', 'goog.dom.TagName', 'goog.string', 'goog.testing.testSuite', 'goog.tweak', 'goog.tweak.TweakUi', 'goog.tweak.testhelpers'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/abstractspellchecker.js', ['goog.ui.AbstractSpellChecker', 'goog.ui.AbstractSpellChecker.AsyncResult'], ['goog.a11y.aria', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.selection', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.math.Coordinate', 'goog.spell.SpellCheck', 'goog.structs.Set', 'goog.style', 'goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.MenuSeparator', 'goog.ui.PopupMenu'], {});
goog.addDependency('ui/ac/ac.js', ['goog.ui.ac'], ['goog.ui.ac.ArrayMatcher', 'goog.ui.ac.AutoComplete', 'goog.ui.ac.InputHandler', 'goog.ui.ac.Renderer'], {});
goog.addDependency('ui/ac/ac_test.js', ['goog.ui.acTest'], ['goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.classlist', 'goog.dom.selection', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.ac', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/arraymatcher.js', ['goog.ui.ac.ArrayMatcher'], ['goog.string'], {});
goog.addDependency('ui/ac/arraymatcher_test.js', ['goog.ui.ac.ArrayMatcherTest'], ['goog.testing.testSuite', 'goog.ui.ac.ArrayMatcher'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/autocomplete.js', ['goog.ui.ac.AutoComplete', 'goog.ui.ac.AutoComplete.EventType'], ['goog.array', 'goog.asserts', 'goog.events', 'goog.events.EventTarget', 'goog.object', 'goog.ui.ac.RenderOptions'], {});
goog.addDependency('ui/ac/autocomplete_test.js', ['goog.ui.ac.AutoCompleteTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.string', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.ui.ac.AutoComplete', 'goog.ui.ac.InputHandler', 'goog.ui.ac.RenderOptions', 'goog.ui.ac.Renderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/cachingmatcher.js', ['goog.ui.ac.CachingMatcher'], ['goog.array', 'goog.async.Throttle', 'goog.ui.ac.ArrayMatcher', 'goog.ui.ac.RenderOptions'], {});
goog.addDependency('ui/ac/cachingmatcher_test.js', ['goog.ui.ac.CachingMatcherTest'], ['goog.testing.MockControl', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.ui.ac.CachingMatcher'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/inputhandler.js', ['goog.ui.ac.InputHandler'], ['goog.Disposable', 'goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.selection', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.string', 'goog.userAgent', 'goog.userAgent.product'], {});
goog.addDependency('ui/ac/inputhandler_test.js', ['goog.ui.ac.InputHandlerTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.selection', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.functions', 'goog.object', 'goog.testing.MockClock', 'goog.testing.testSuite', 'goog.ui.ac.InputHandler', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/remote.js', ['goog.ui.ac.Remote'], ['goog.ui.ac.AutoComplete', 'goog.ui.ac.InputHandler', 'goog.ui.ac.RemoteArrayMatcher', 'goog.ui.ac.Renderer'], {});
goog.addDependency('ui/ac/remotearraymatcher.js', ['goog.ui.ac.RemoteArrayMatcher'], ['goog.Disposable', 'goog.Uri', 'goog.events', 'goog.net.EventType', 'goog.net.XhrIo'], {});
goog.addDependency('ui/ac/remotearraymatcher_test.js', ['goog.ui.ac.RemoteArrayMatcherTest'], ['goog.net.XhrIo', 'goog.testing.MockControl', 'goog.testing.net.XhrIo', 'goog.testing.testSuite', 'goog.ui.ac.RemoteArrayMatcher'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/renderer.js', ['goog.ui.ac.Renderer', 'goog.ui.ac.Renderer.CustomRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dispose', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.fx.dom.FadeInAndShow', 'goog.fx.dom.FadeOutAndHide', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.string', 'goog.style', 'goog.ui.IdGenerator', 'goog.ui.ac.AutoComplete'], {'lang': 'es6'});
goog.addDependency('ui/ac/renderer_test.js', ['goog.ui.ac.RendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.fx.dom.FadeInAndShow', 'goog.fx.dom.FadeOutAndHide', 'goog.string', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.ac.AutoComplete', 'goog.ui.ac.Renderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ac/renderoptions.js', ['goog.ui.ac.RenderOptions'], [], {});
goog.addDependency('ui/ac/richinputhandler.js', ['goog.ui.ac.RichInputHandler'], ['goog.ui.ac.InputHandler'], {});
goog.addDependency('ui/ac/richremote.js', ['goog.ui.ac.RichRemote'], ['goog.ui.ac.AutoComplete', 'goog.ui.ac.Remote', 'goog.ui.ac.Renderer', 'goog.ui.ac.RichInputHandler', 'goog.ui.ac.RichRemoteArrayMatcher'], {});
goog.addDependency('ui/ac/richremotearraymatcher.js', ['goog.ui.ac.RichRemoteArrayMatcher'], ['goog.dom', 'goog.ui.ac.RemoteArrayMatcher'], {});
goog.addDependency('ui/ac/richremotearraymatcher_test.js', ['goog.ui.ac.RichRemoteArrayMatcherTest'], ['goog.net.XhrIo', 'goog.testing.MockControl', 'goog.testing.net.XhrIo', 'goog.testing.testSuite', 'goog.ui.ac.RichRemoteArrayMatcher'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/activitymonitor.js', ['goog.ui.ActivityMonitor'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType'], {});
goog.addDependency('ui/activitymonitor_test.js', ['goog.ui.ActivityMonitorTest'], ['goog.dom', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.ActivityMonitor'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/advancedtooltip.js', ['goog.ui.AdvancedTooltip'], ['goog.events', 'goog.events.EventType', 'goog.math.Box', 'goog.math.Coordinate', 'goog.style', 'goog.ui.Tooltip', 'goog.userAgent'], {});
goog.addDependency('ui/advancedtooltip_test.js', ['goog.ui.AdvancedTooltipTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events.Event', 'goog.events.EventType', 'goog.math.Box', 'goog.math.Coordinate', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.AdvancedTooltip', 'goog.ui.Tooltip', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/animatedzippy.js', ['goog.ui.AnimatedZippy'], ['goog.a11y.aria.Role', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.fx.easing', 'goog.ui.Zippy', 'goog.ui.ZippyEvent'], {});
goog.addDependency('ui/animatedzippy_test.js', ['goog.ui.AnimatedZippyTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.events', 'goog.functions', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.testing.PropertyReplacer', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.ui.AnimatedZippy', 'goog.ui.Zippy'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/attachablemenu.js', ['goog.ui.AttachableMenu'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events.Event', 'goog.events.KeyCodes', 'goog.string', 'goog.style', 'goog.ui.ItemEvent', 'goog.ui.MenuBase', 'goog.ui.PopupBase', 'goog.userAgent'], {});
goog.addDependency('ui/bidiinput.js', ['goog.ui.BidiInput'], ['goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.InputHandler', 'goog.i18n.bidi', 'goog.ui.Component'], {});
goog.addDependency('ui/bidiinput_test.js', ['goog.ui.BidiInputTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.BidiInput'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/bubble.js', ['goog.ui.Bubble'], ['goog.Timer', 'goog.dom.safe', 'goog.events', 'goog.events.EventType', 'goog.html.SafeHtml', 'goog.math.Box', 'goog.positioning', 'goog.positioning.AbsolutePosition', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.positioning.CornerBit', 'goog.string.Const', 'goog.style', 'goog.ui.Component', 'goog.ui.Popup'], {});
goog.addDependency('ui/button.js', ['goog.ui.Button', 'goog.ui.Button.Side'], ['goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.ui.ButtonRenderer', 'goog.ui.ButtonSide', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.NativeButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/button_test.js', ['goog.ui.ButtonTest'], ['goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Button', 'goog.ui.ButtonRenderer', 'goog.ui.ButtonSide', 'goog.ui.Component', 'goog.ui.NativeButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/buttonrenderer.js', ['goog.ui.ButtonRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.ui.ButtonSide', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/buttonrenderer_test.js', ['goog.ui.ButtonRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.ExpectedFailures', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Button', 'goog.ui.ButtonRenderer', 'goog.ui.ButtonSide', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/buttonside.js', ['goog.ui.ButtonSide'], [], {});
goog.addDependency('ui/charcounter.js', ['goog.ui.CharCounter', 'goog.ui.CharCounter.Display'], ['goog.dom', 'goog.events', 'goog.events.EventTarget', 'goog.events.InputHandler'], {});
goog.addDependency('ui/charcounter_test.js', ['goog.ui.CharCounterTest'], ['goog.dom', 'goog.testing.asserts', 'goog.testing.testSuite', 'goog.ui.CharCounter', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/charpicker.js', ['goog.ui.CharPicker'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.i18n.CharListDecompressor', 'goog.i18n.CharPickerData', 'goog.i18n.uChar', 'goog.i18n.uChar.NameFetcher', 'goog.structs.Set', 'goog.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.ContainerScroller', 'goog.ui.FlatButtonRenderer', 'goog.ui.HoverCard', 'goog.ui.LabelInput', 'goog.ui.Menu', 'goog.ui.MenuButton', 'goog.ui.MenuItem', 'goog.ui.Tooltip'], {});
goog.addDependency('ui/charpicker_test.js', ['goog.ui.CharPickerTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dispose', 'goog.dom', 'goog.events.Event', 'goog.events.EventType', 'goog.i18n.CharPickerData', 'goog.i18n.uChar.NameFetcher', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.mockmatchers', 'goog.testing.testSuite', 'goog.ui.CharPicker', 'goog.ui.FlatButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/checkbox.js', ['goog.ui.Checkbox', 'goog.ui.Checkbox.State'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.string', 'goog.ui.CheckboxRenderer', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.registry'], {});
goog.addDependency('ui/checkbox_test.js', ['goog.ui.CheckboxTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.KeyCodes', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Checkbox', 'goog.ui.CheckboxRenderer', 'goog.ui.Component', 'goog.ui.ControlRenderer', 'goog.ui.decorate'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/checkboxmenuitem.js', ['goog.ui.CheckBoxMenuItem'], ['goog.ui.MenuItem', 'goog.ui.registry'], {});
goog.addDependency('ui/checkboxrenderer.js', ['goog.ui.CheckboxRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.object', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/colormenubutton.js', ['goog.ui.ColorMenuButton'], ['goog.array', 'goog.object', 'goog.ui.ColorMenuButtonRenderer', 'goog.ui.ColorPalette', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.MenuButton', 'goog.ui.registry'], {});
goog.addDependency('ui/colormenubuttonrenderer.js', ['goog.ui.ColorMenuButtonRenderer'], ['goog.asserts', 'goog.color', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.MenuButtonRenderer', 'goog.userAgent'], {});
goog.addDependency('ui/colormenubuttonrenderer_test.js', ['goog.ui.ColorMenuButtonTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.testing.ui.RendererHarness', 'goog.testing.ui.rendererasserts', 'goog.ui.ColorMenuButton', 'goog.ui.ColorMenuButtonRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/colorpalette.js', ['goog.ui.ColorPalette'], ['goog.array', 'goog.color', 'goog.dom.TagName', 'goog.style', 'goog.ui.Palette', 'goog.ui.PaletteRenderer'], {});
goog.addDependency('ui/colorpalette_test.js', ['goog.ui.ColorPaletteTest'], ['goog.color', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.ColorPalette'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/colorpicker.js', ['goog.ui.ColorPicker', 'goog.ui.ColorPicker.EventType'], ['goog.ui.ColorPalette', 'goog.ui.Component'], {});
goog.addDependency('ui/combobox.js', ['goog.ui.ComboBox', 'goog.ui.ComboBoxItem'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.log', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.ItemEvent', 'goog.ui.LabelInput', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.MenuSeparator', 'goog.ui.registry', 'goog.userAgent'], {});
goog.addDependency('ui/combobox_test.js', ['goog.ui.ComboBoxTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.KeyCodes', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.ComboBox', 'goog.ui.ComboBoxItem', 'goog.ui.Component', 'goog.ui.ControlRenderer', 'goog.ui.LabelInput', 'goog.ui.Menu', 'goog.ui.MenuItem'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/component.js', ['goog.ui.Component', 'goog.ui.Component.Error', 'goog.ui.Component.EventType', 'goog.ui.Component.State'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.object', 'goog.style', 'goog.ui.IdGenerator'], {});
goog.addDependency('ui/component_test.js', ['goog.ui.ComponentTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.events.EventTarget', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.Component'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/componentutil.js', ['goog.ui.ComponentUtil'], ['goog.events.MouseAsMouseEventType', 'goog.events.MouseEvents', 'goog.events.PointerAsMouseEventType'], {});
goog.addDependency('ui/componentutil_test.js', ['goog.ui.ComponentUtilTest'], ['goog.events.MouseAsMouseEventType', 'goog.events.PointerAsMouseEventType', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.ComponentUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/container.js', ['goog.ui.Container', 'goog.ui.Container.EventType', 'goog.ui.Container.Orientation'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.object', 'goog.style', 'goog.ui.Component', 'goog.ui.ComponentUtil', 'goog.ui.ContainerRenderer', 'goog.ui.Control'], {});
goog.addDependency('ui/container_test.js', ['goog.ui.ContainerTest'], ['goog.a11y.aria', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.KeyCodes', 'goog.events.KeyEvent', 'goog.events.PointerFallbackEventType', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Container', 'goog.ui.Control'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/containerrenderer.js', ['goog.ui.ContainerRenderer'], ['goog.a11y.aria', 'goog.array', 'goog.asserts', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.string', 'goog.style', 'goog.ui.registry', 'goog.userAgent'], {});
goog.addDependency('ui/containerrenderer_test.js', ['goog.ui.ContainerRendererTest'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Container', 'goog.ui.ContainerRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/containerscroller.js', ['goog.ui.ContainerScroller'], ['goog.Disposable', 'goog.Timer', 'goog.events.EventHandler', 'goog.style', 'goog.ui.Component', 'goog.ui.Container'], {});
goog.addDependency('ui/containerscroller_test.js', ['goog.ui.ContainerScrollerTest'], ['goog.dom', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Container', 'goog.ui.ContainerScroller'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/control.js', ['goog.ui.Control'], ['goog.Disposable', 'goog.array', 'goog.dom', 'goog.events.BrowserEvent', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.string', 'goog.ui.Component', 'goog.ui.ComponentUtil', 'goog.ui.ControlContent', 'goog.ui.ControlRenderer', 'goog.ui.registry', 'goog.userAgent'], {});
goog.addDependency('ui/control_test.js', ['goog.ui.ControlTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.events.PointerFallbackEventType', 'goog.html.testing', 'goog.object', 'goog.string', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.ControlRenderer', 'goog.ui.registry', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/controlcontent.js', ['goog.ui.ControlContent'], [], {});
goog.addDependency('ui/controlrenderer.js', ['goog.ui.ControlRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.object', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.ControlContent', 'goog.userAgent'], {});
goog.addDependency('ui/controlrenderer_test.js', ['goog.ui.ControlRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.object', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.ControlRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/cookieeditor.js', ['goog.ui.CookieEditor'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.events.EventType', 'goog.net.cookies', 'goog.string', 'goog.style', 'goog.ui.Component'], {});
goog.addDependency('ui/cookieeditor_test.js', ['goog.ui.CookieEditorTest'], ['goog.dom', 'goog.events.Event', 'goog.events.EventType', 'goog.net.cookies', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.CookieEditor'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/css3buttonrenderer.js', ['goog.ui.Css3ButtonRenderer'], ['goog.asserts', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Button', 'goog.ui.ButtonRenderer', 'goog.ui.Component', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.registry'], {});
goog.addDependency('ui/css3menubuttonrenderer.js', ['goog.ui.Css3MenuButtonRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.MenuButton', 'goog.ui.MenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/cssnames.js', ['goog.ui.INLINE_BLOCK_CLASSNAME'], [], {});
goog.addDependency('ui/custombutton.js', ['goog.ui.CustomButton'], ['goog.ui.Button', 'goog.ui.CustomButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/custombuttonrenderer.js', ['goog.ui.CustomButtonRenderer'], ['goog.a11y.aria.Role', 'goog.asserts', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.string', 'goog.ui.ButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME'], {});
goog.addDependency('ui/customcolorpalette.js', ['goog.ui.CustomColorPalette'], ['goog.color', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.ColorPalette', 'goog.ui.Component'], {});
goog.addDependency('ui/customcolorpalette_test.js', ['goog.ui.CustomColorPaletteTest'], ['goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.ui.CustomColorPalette'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/datepicker.js', ['goog.ui.DatePicker', 'goog.ui.DatePicker.Events', 'goog.ui.DatePickerEvent'], ['goog.a11y.aria', 'goog.asserts', 'goog.date.Date', 'goog.date.DateRange', 'goog.date.Interval', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyHandler', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimePatterns', 'goog.i18n.DateTimeSymbols', 'goog.style', 'goog.ui.Component', 'goog.ui.DefaultDatePickerRenderer', 'goog.ui.IdGenerator'], {});
goog.addDependency('ui/datepicker_test.js', ['goog.ui.DatePickerTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.date.Date', 'goog.date.DateRange', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.KeyCodes', 'goog.i18n.DateTimeSymbols', 'goog.i18n.DateTimeSymbols_en_US', 'goog.i18n.DateTimeSymbols_zh_HK', 'goog.style', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.DatePicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/datepickerrenderer.js', ['goog.ui.DatePickerRenderer'], [], {});
goog.addDependency('ui/decorate.js', ['goog.ui.decorate'], ['goog.ui.registry'], {});
goog.addDependency('ui/decorate_test.js', ['goog.ui.decorateTest'], ['goog.testing.testSuite', 'goog.ui.decorate', 'goog.ui.registry'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/defaultdatepickerrenderer.js', ['goog.ui.DefaultDatePickerRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.ui.DatePickerRenderer'], {});
goog.addDependency('ui/dialog.js', ['goog.ui.Dialog', 'goog.ui.Dialog.ButtonSet', 'goog.ui.Dialog.ButtonSet.DefaultButtons', 'goog.ui.Dialog.DefaultButtonCaptions', 'goog.ui.Dialog.DefaultButtonKeys', 'goog.ui.Dialog.Event', 'goog.ui.Dialog.EventType'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.safe', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.Keys', 'goog.fx.Dragger', 'goog.html.SafeHtml', 'goog.math.Rect', 'goog.string', 'goog.structs.Map', 'goog.style', 'goog.ui.ModalPopup'], {});
goog.addDependency('ui/dialog_test.js', ['goog.ui.DialogTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.fx.css3', 'goog.html.SafeHtml', 'goog.html.testing', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Dialog', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/dimensionpicker.js', ['goog.ui.DimensionPicker'], ['goog.events.BrowserEvent.PointerType', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Size', 'goog.ui.Component', 'goog.ui.ComponentUtil', 'goog.ui.Control', 'goog.ui.DimensionPickerRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/dimensionpicker_test.js', ['goog.ui.DimensionPickerTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.math.Size', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.DimensionPicker', 'goog.ui.DimensionPickerRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/dimensionpickerrenderer.js', ['goog.ui.DimensionPickerRenderer'], ['goog.a11y.aria.Announcer', 'goog.a11y.aria.LivePriority', 'goog.dom', 'goog.dom.TagName', 'goog.i18n.bidi', 'goog.style', 'goog.ui.ControlRenderer', 'goog.userAgent'], {});
goog.addDependency('ui/dimensionpickerrenderer_test.js', ['goog.ui.DimensionPickerRendererTest'], ['goog.a11y.aria.LivePriority', 'goog.array', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.DimensionPicker', 'goog.ui.DimensionPickerRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/dragdropdetector.js', ['goog.ui.DragDropDetector', 'goog.ui.DragDropDetector.EventType', 'goog.ui.DragDropDetector.ImageDropEvent', 'goog.ui.DragDropDetector.LinkDropEvent'], ['goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.math.Coordinate', 'goog.string', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('ui/drilldownrow.js', ['goog.ui.DrilldownRow'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.string.Unicode', 'goog.ui.Component'], {});
goog.addDependency('ui/drilldownrow_test.js', ['goog.ui.DrilldownRowTest'], ['goog.dom', 'goog.dom.TagName', 'goog.html.SafeHtml', 'goog.testing.testSuite', 'goog.ui.DrilldownRow'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/editor/abstractdialog.js', ['goog.ui.editor.AbstractDialog', 'goog.ui.editor.AbstractDialog.Builder', 'goog.ui.editor.AbstractDialog.EventType'], ['goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events.EventTarget', 'goog.string', 'goog.ui.Dialog', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/editor/abstractdialog_test.js', ['goog.ui.editor.AbstractDialogTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.KeyCodes', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.testSuite', 'goog.ui.editor.AbstractDialog', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/editor/bubble.js', ['goog.ui.editor.Bubble'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.ViewportSizeMonitor', 'goog.dom.classlist', 'goog.editor.style', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.functions', 'goog.log', 'goog.math.Box', 'goog.object', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.PopupBase', 'goog.userAgent'], {});
goog.addDependency('ui/editor/bubble_test.js', ['goog.ui.editor.BubbleTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.positioning.Corner', 'goog.positioning.OverflowStatus', 'goog.string', 'goog.style', 'goog.testing.editor.TestHelper', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.editor.Bubble', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/editor/defaulttoolbar.js', ['goog.ui.editor.ButtonDescriptor', 'goog.ui.editor.DefaultToolbar'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.editor.Command', 'goog.style', 'goog.ui.editor.ToolbarFactory', 'goog.ui.editor.messages', 'goog.userAgent'], {});
goog.addDependency('ui/editor/linkdialog.js', ['goog.ui.editor.LinkDialog', 'goog.ui.editor.LinkDialog.BeforeTestLinkEvent', 'goog.ui.editor.LinkDialog.EventType', 'goog.ui.editor.LinkDialog.OkEvent'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.editor.BrowserFeature', 'goog.editor.Link', 'goog.editor.focus', 'goog.editor.node', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.InputHandler', 'goog.html.SafeHtml', 'goog.html.SafeHtmlFormatter', 'goog.string', 'goog.string.Unicode', 'goog.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.LinkButtonRenderer', 'goog.ui.editor.AbstractDialog', 'goog.ui.editor.TabPane', 'goog.ui.editor.messages', 'goog.userAgent', 'goog.window'], {});
goog.addDependency('ui/editor/linkdialog_test.js', ['goog.ui.editor.LinkDialogTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.editor.BrowserFeature', 'goog.editor.Link', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.style', 'goog.testing.MockControl', 'goog.testing.PropertyReplacer', 'goog.testing.dom', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.mockmatchers', 'goog.testing.mockmatchers.ArgumentMatcher', 'goog.testing.testSuite', 'goog.ui.editor.AbstractDialog', 'goog.ui.editor.LinkDialog', 'goog.ui.editor.messages', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/editor/messages.js', ['goog.ui.editor.messages'], ['goog.html.SafeHtmlFormatter'], {});
goog.addDependency('ui/editor/tabpane.js', ['goog.ui.editor.TabPane'], ['goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.style', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.Tab', 'goog.ui.TabBar'], {});
goog.addDependency('ui/editor/toolbarcontroller.js', ['goog.ui.editor.ToolbarController'], ['goog.editor.Field', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.ui.Component'], {});
goog.addDependency('ui/editor/toolbarfactory.js', ['goog.ui.editor.ToolbarFactory'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.string', 'goog.string.Unicode', 'goog.style', 'goog.ui.Component', 'goog.ui.Container', 'goog.ui.Option', 'goog.ui.Toolbar', 'goog.ui.ToolbarButton', 'goog.ui.ToolbarColorMenuButton', 'goog.ui.ToolbarMenuButton', 'goog.ui.ToolbarRenderer', 'goog.ui.ToolbarSelect', 'goog.userAgent'], {});
goog.addDependency('ui/editor/toolbarfactory_test.js', ['goog.ui.editor.ToolbarFactoryTest'], ['goog.dom', 'goog.testing.ExpectedFailures', 'goog.testing.editor.TestHelper', 'goog.testing.testSuite', 'goog.ui.editor.ToolbarFactory', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/emoji.js', ['goog.ui.emoji.Emoji'], [], {});
goog.addDependency('ui/emoji/emojipalette.js', ['goog.ui.emoji.EmojiPalette'], ['goog.events.EventType', 'goog.net.ImageLoader', 'goog.ui.Palette', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPaletteRenderer'], {});
goog.addDependency('ui/emoji/emojipaletterenderer.js', ['goog.ui.emoji.EmojiPaletteRenderer'], ['goog.a11y.aria', 'goog.asserts', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.style', 'goog.ui.PaletteRenderer', 'goog.ui.emoji.Emoji'], {});
goog.addDependency('ui/emoji/emojipicker.js', ['goog.ui.emoji.EmojiPicker'], ['goog.dom.TagName', 'goog.style', 'goog.ui.Component', 'goog.ui.TabPane', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPalette', 'goog.ui.emoji.EmojiPaletteRenderer', 'goog.ui.emoji.ProgressiveEmojiPaletteRenderer'], {});
goog.addDependency('ui/emoji/emojipicker_test.js', ['goog.ui.emoji.EmojiPickerTest'], ['goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventHandler', 'goog.style', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPicker', 'goog.ui.emoji.SpriteInfo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/fast_nonprogressive_emojipicker_test.js', ['goog.ui.emoji.FastNonProgressiveEmojiPickerTest'], ['goog.Promise', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.net.EventType', 'goog.style', 'goog.testing.TestCase', 'goog.testing.testSuite', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPicker', 'goog.ui.emoji.SpriteInfo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/fast_progressive_emojipicker_test.js', ['goog.ui.emoji.FastProgressiveEmojiPickerTest'], ['goog.Promise', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.net.EventType', 'goog.style', 'goog.testing.testSuite', 'goog.ui.emoji.Emoji', 'goog.ui.emoji.EmojiPicker', 'goog.ui.emoji.SpriteInfo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/popupemojipicker.js', ['goog.ui.emoji.PopupEmojiPicker'], ['goog.events.EventType', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.ui.Component', 'goog.ui.Popup', 'goog.ui.emoji.EmojiPicker'], {});
goog.addDependency('ui/emoji/popupemojipicker_test.js', ['goog.ui.emoji.PopupEmojiPickerTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.emoji.PopupEmojiPicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/emoji/progressiveemojipaletterenderer.js', ['goog.ui.emoji.ProgressiveEmojiPaletteRenderer'], ['goog.dom.TagName', 'goog.style', 'goog.ui.emoji.EmojiPaletteRenderer'], {});
goog.addDependency('ui/emoji/spriteinfo.js', ['goog.ui.emoji.SpriteInfo'], [], {'lang': 'es6'});
goog.addDependency('ui/emoji/spriteinfo_test.js', ['goog.ui.emoji.SpriteInfoTest'], ['goog.testing.testSuite', 'goog.ui.emoji.SpriteInfo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/filteredmenu.js', ['goog.ui.FilteredMenu'], ['goog.a11y.aria', 'goog.a11y.aria.AutoCompleteValues', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.FilterObservingMenuItem', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.userAgent'], {});
goog.addDependency('ui/filteredmenu_test.js', ['goog.ui.FilteredMenuTest'], ['goog.a11y.aria', 'goog.a11y.aria.AutoCompleteValues', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Rect', 'goog.style', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.FilteredMenu', 'goog.ui.MenuItem'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/filterobservingmenuitem.js', ['goog.ui.FilterObservingMenuItem'], ['goog.ui.FilterObservingMenuItemRenderer', 'goog.ui.MenuItem', 'goog.ui.registry'], {});
goog.addDependency('ui/filterobservingmenuitemrenderer.js', ['goog.ui.FilterObservingMenuItemRenderer'], ['goog.ui.MenuItemRenderer'], {});
goog.addDependency('ui/flatbuttonrenderer.js', ['goog.ui.FlatButtonRenderer'], ['goog.a11y.aria.Role', 'goog.asserts', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Button', 'goog.ui.ButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.registry'], {});
goog.addDependency('ui/flatmenubuttonrenderer.js', ['goog.ui.FlatMenuButtonRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.ui.FlatButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.Menu', 'goog.ui.MenuButton', 'goog.ui.MenuRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/formpost.js', ['goog.ui.FormPost'], ['goog.array', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeHtml', 'goog.ui.Component'], {});
goog.addDependency('ui/formpost_test.js', ['goog.ui.FormPostTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.object', 'goog.testing.testSuite', 'goog.ui.FormPost', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/gauge.js', ['goog.ui.Gauge', 'goog.ui.GaugeColoredRange'], ['goog.a11y.aria', 'goog.asserts', 'goog.dom.TagName', 'goog.events', 'goog.fx.Animation', 'goog.fx.Transition', 'goog.fx.easing', 'goog.graphics', 'goog.graphics.Font', 'goog.graphics.Path', 'goog.graphics.SolidFill', 'goog.math', 'goog.ui.Component', 'goog.ui.GaugeTheme'], {});
goog.addDependency('ui/gaugetheme.js', ['goog.ui.GaugeTheme'], ['goog.graphics.LinearGradient', 'goog.graphics.SolidFill', 'goog.graphics.Stroke'], {});
goog.addDependency('ui/hovercard.js', ['goog.ui.HoverCard', 'goog.ui.HoverCard.EventType', 'goog.ui.HoverCard.TriggerEvent'], ['goog.array', 'goog.dom', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.ui.AdvancedTooltip', 'goog.ui.PopupBase', 'goog.ui.Tooltip'], {});
goog.addDependency('ui/hovercard_test.js', ['goog.ui.HoverCardTest'], ['goog.dom', 'goog.events', 'goog.math.Coordinate', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.HoverCard'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/hsvapalette.js', ['goog.ui.HsvaPalette'], ['goog.array', 'goog.color.alpha', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.style', 'goog.ui.Component', 'goog.ui.HsvPalette'], {});
goog.addDependency('ui/hsvapalette_test.js', ['goog.ui.HsvaPaletteTest'], ['goog.color.alpha', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.Event', 'goog.math.Coordinate', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.HsvaPalette', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/hsvpalette.js', ['goog.ui.HsvPalette'], ['goog.color', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.events.InputHandler', 'goog.style', 'goog.style.bidi', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/hsvpalette_test.js', ['goog.ui.HsvPaletteTest'], ['goog.color', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.math.Coordinate', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.HsvPalette', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/idgenerator.js', ['goog.ui.IdGenerator'], [], {});
goog.addDependency('ui/idletimer.js', ['goog.ui.IdleTimer'], ['goog.Timer', 'goog.events', 'goog.events.EventTarget', 'goog.structs.Set', 'goog.ui.ActivityMonitor'], {});
goog.addDependency('ui/idletimer_test.js', ['goog.ui.IdleTimerTest'], ['goog.events', 'goog.testing.MockClock', 'goog.testing.testSuite', 'goog.ui.IdleTimer', 'goog.ui.MockActivityMonitor'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/iframemask.js', ['goog.ui.IframeMask'], ['goog.Disposable', 'goog.Timer', 'goog.dom', 'goog.dom.iframe', 'goog.events.EventHandler', 'goog.structs.Pool', 'goog.style'], {});
goog.addDependency('ui/iframemask_test.js', ['goog.ui.IframeMaskTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.iframe', 'goog.structs.Pool', 'goog.style', 'goog.testing.MockClock', 'goog.testing.StrictMock', 'goog.testing.testSuite', 'goog.ui.IframeMask', 'goog.ui.Popup', 'goog.ui.PopupBase', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/imagelessbuttonrenderer.js', ['goog.ui.ImagelessButtonRenderer'], ['goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.CustomButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.registry'], {});
goog.addDependency('ui/imagelessmenubuttonrenderer.js', ['goog.ui.ImagelessMenuButtonRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.MenuButton', 'goog.ui.MenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/inputdatepicker.js', ['goog.ui.InputDatePicker'], ['goog.date.DateTime', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.i18n.DateTimeParse', 'goog.string', 'goog.ui.Component', 'goog.ui.DatePicker', 'goog.ui.LabelInput', 'goog.ui.PopupBase', 'goog.ui.PopupDatePicker'], {});
goog.addDependency('ui/inputdatepicker_test.js', ['goog.ui.InputDatePickerTest'], ['goog.dom', 'goog.i18n.DateTimeFormat', 'goog.i18n.DateTimeParse', 'goog.testing.testSuite', 'goog.ui.InputDatePicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/itemevent.js', ['goog.ui.ItemEvent'], ['goog.events.Event'], {});
goog.addDependency('ui/keyboardeventdata.js', ['goog.ui.KeyboardEventData'], ['goog.asserts', 'goog.events.BrowserEvent'], {'lang': 'es6'});
goog.addDependency('ui/keyboardshortcuthandler.js', ['goog.ui.KeyboardShortcutEvent', 'goog.ui.KeyboardShortcutHandler', 'goog.ui.KeyboardShortcutHandler.EventType', 'goog.ui.KeyboardShortcutHandler.Modifiers'], ['goog.array', 'goog.asserts', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyNames', 'goog.events.Keys', 'goog.object', 'goog.ui.KeyboardEventData', 'goog.ui.SyntheticKeyboardEvent', 'goog.userAgent'], {});
goog.addDependency('ui/keyboardshortcuthandler_test.js', ['goog.ui.KeyboardShortcutHandlerTest'], ['goog.dom', 'goog.events', 'goog.events.BrowserEvent', 'goog.events.KeyCodes', 'goog.testing.MockClock', 'goog.testing.PropertyReplacer', 'goog.testing.StrictMock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.KeyboardShortcutHandler', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/labelinput.js', ['goog.ui.LabelInput'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/labelinput_test.js', ['goog.ui.LabelInputTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.classlist', 'goog.events.EventType', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.LabelInput', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/linkbuttonrenderer.js', ['goog.ui.LinkButtonRenderer'], ['goog.ui.Button', 'goog.ui.FlatButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/media/flashobject.js', ['goog.ui.media.FlashObject', 'goog.ui.media.FlashObject.ScriptAccessLevel', 'goog.ui.media.FlashObject.Wmodes'], ['goog.asserts', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.html.TrustedResourceUrl', 'goog.html.flash', 'goog.log', 'goog.object', 'goog.string', 'goog.structs.Map', 'goog.style', 'goog.ui.Component', 'goog.userAgent', 'goog.userAgent.flash'], {});
goog.addDependency('ui/media/flashobject_test.js', ['goog.ui.media.FlashObjectTest'], ['goog.dom', 'goog.dom.DomHelper', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.html.testing', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/flickr.js', ['goog.ui.media.FlickrSet', 'goog.ui.media.FlickrSetModel'], ['goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/flickr_test.js', ['goog.ui.media.FlickrSetTest'], ['goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.FlickrSet', 'goog.ui.media.FlickrSetModel', 'goog.ui.media.Media'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/googlevideo.js', ['goog.ui.media.GoogleVideo', 'goog.ui.media.GoogleVideoModel'], ['goog.html.TrustedResourceUrl', 'goog.string', 'goog.string.Const', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/googlevideo_test.js', ['goog.ui.media.GoogleVideoTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.GoogleVideo', 'goog.ui.media.GoogleVideoModel', 'goog.ui.media.Media'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/media.js', ['goog.ui.media.Media', 'goog.ui.media.MediaRenderer'], ['goog.asserts', 'goog.dom.TagName', 'goog.style', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/media/media_test.js', ['goog.ui.media.MediaTest'], ['goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.math.Size', 'goog.testing.testSuite', 'goog.ui.ControlRenderer', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/mediamodel.js', ['goog.ui.media.MediaModel', 'goog.ui.media.MediaModel.Category', 'goog.ui.media.MediaModel.Credit', 'goog.ui.media.MediaModel.Credit.Role', 'goog.ui.media.MediaModel.Credit.Scheme', 'goog.ui.media.MediaModel.Medium', 'goog.ui.media.MediaModel.MimeType', 'goog.ui.media.MediaModel.Player', 'goog.ui.media.MediaModel.SubTitle', 'goog.ui.media.MediaModel.Thumbnail'], ['goog.array', 'goog.html.TrustedResourceUrl'], {});
goog.addDependency('ui/media/mediamodel_test.js', ['goog.ui.media.MediaModelTest'], ['goog.testing.testSuite', 'goog.ui.media.MediaModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/mp3.js', ['goog.ui.media.Mp3'], ['goog.string', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/mp3_test.js', ['goog.ui.media.Mp3Test'], ['goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.Mp3'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/photo.js', ['goog.ui.media.Photo'], ['goog.dom.TagName', 'goog.ui.media.Media', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/photo_test.js', ['goog.ui.media.PhotoTest'], ['goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.media.MediaModel', 'goog.ui.media.Photo'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/picasa.js', ['goog.ui.media.PicasaAlbum', 'goog.ui.media.PicasaAlbumModel'], ['goog.html.TrustedResourceUrl', 'goog.string.Const', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/picasa_test.js', ['goog.ui.media.PicasaTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.PicasaAlbum', 'goog.ui.media.PicasaAlbumModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/vimeo.js', ['goog.ui.media.Vimeo', 'goog.ui.media.VimeoModel'], ['goog.html.TrustedResourceUrl', 'goog.string', 'goog.string.Const', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/vimeo_test.js', ['goog.ui.media.VimeoTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.Vimeo', 'goog.ui.media.VimeoModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/media/youtube.js', ['goog.ui.media.Youtube', 'goog.ui.media.YoutubeModel'], ['goog.dom.TagName', 'goog.html.TrustedResourceUrl', 'goog.string', 'goog.string.Const', 'goog.ui.Component', 'goog.ui.media.FlashObject', 'goog.ui.media.Media', 'goog.ui.media.MediaModel', 'goog.ui.media.MediaRenderer'], {});
goog.addDependency('ui/media/youtube_test.js', ['goog.ui.media.YoutubeTest'], ['goog.dom', 'goog.dom.TagName', 'goog.testing.testSuite', 'goog.ui.media.FlashObject', 'goog.ui.media.Youtube', 'goog.ui.media.YoutubeModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menu.js', ['goog.ui.Menu', 'goog.ui.Menu.EventType'], ['goog.dom.TagName', 'goog.math.Coordinate', 'goog.string', 'goog.style', 'goog.ui.Component.EventType', 'goog.ui.Component.State', 'goog.ui.Container', 'goog.ui.Container.Orientation', 'goog.ui.MenuHeader', 'goog.ui.MenuItem', 'goog.ui.MenuRenderer', 'goog.ui.MenuSeparator'], {});
goog.addDependency('ui/menu_test.js', ['goog.ui.MenuTest'], ['goog.dom', 'goog.events', 'goog.math.Coordinate', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Menu'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menubar.js', ['goog.ui.menuBar'], ['goog.ui.Container', 'goog.ui.MenuBarRenderer'], {});
goog.addDependency('ui/menubardecorator.js', ['goog.ui.menuBarDecorator'], ['goog.ui.MenuBarRenderer', 'goog.ui.menuBar', 'goog.ui.registry'], {});
goog.addDependency('ui/menubarrenderer.js', ['goog.ui.MenuBarRenderer'], ['goog.a11y.aria.Role', 'goog.ui.Container', 'goog.ui.ContainerRenderer'], {});
goog.addDependency('ui/menubase.js', ['goog.ui.MenuBase'], ['goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyHandler', 'goog.ui.Popup'], {});
goog.addDependency('ui/menubutton.js', ['goog.ui.MenuButton'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.math.Box', 'goog.math.Coordinate', 'goog.math.Rect', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.positioning.Overflow', 'goog.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.IdGenerator', 'goog.ui.Menu', 'goog.ui.MenuButtonRenderer', 'goog.ui.MenuItem', 'goog.ui.MenuRenderer', 'goog.ui.SubMenu', 'goog.ui.registry', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6'});
goog.addDependency('ui/menubutton_test.js', ['goog.ui.MenuButtonTest'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.positioning', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.positioning.Overflow', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.PropertyReplacer', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.MenuButton', 'goog.ui.MenuItem', 'goog.ui.SubMenu', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menubuttonrenderer.js', ['goog.ui.MenuButtonRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.ui.CustomButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.Menu', 'goog.ui.MenuRenderer'], {});
goog.addDependency('ui/menubuttonrenderer_test.js', ['goog.ui.MenuButtonRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.MenuButton', 'goog.ui.MenuButtonRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menuheader.js', ['goog.ui.MenuHeader'], ['goog.ui.Component', 'goog.ui.Control', 'goog.ui.MenuHeaderRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/menuheaderrenderer.js', ['goog.ui.MenuHeaderRenderer'], ['goog.ui.ControlRenderer'], {});
goog.addDependency('ui/menuitem.js', ['goog.ui.MenuItem'], ['goog.a11y.aria.Role', 'goog.array', 'goog.dom', 'goog.dom.classlist', 'goog.math.Coordinate', 'goog.string', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.MenuItemRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/menuitem_test.js', ['goog.ui.MenuItemTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.array', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.KeyCodes', 'goog.html.testing', 'goog.math.Coordinate', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.MenuItemRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menuitemrenderer.js', ['goog.ui.MenuItemRenderer'], ['goog.a11y.aria.Role', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/menuitemrenderer_test.js', ['goog.ui.MenuItemRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.MenuItemRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/menurenderer.js', ['goog.ui.MenuRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.ui.ContainerRenderer', 'goog.ui.Separator'], {});
goog.addDependency('ui/menuseparator.js', ['goog.ui.MenuSeparator'], ['goog.ui.MenuSeparatorRenderer', 'goog.ui.Separator', 'goog.ui.registry'], {});
goog.addDependency('ui/menuseparatorrenderer.js', ['goog.ui.MenuSeparatorRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/menuseparatorrenderer_test.js', ['goog.ui.MenuSeparatorRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.MenuSeparator', 'goog.ui.MenuSeparatorRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/mockactivitymonitor.js', ['goog.ui.MockActivityMonitor'], ['goog.events.EventType', 'goog.ui.ActivityMonitor'], {});
goog.addDependency('ui/mockactivitymonitor_test.js', ['goog.ui.MockActivityMonitorTest'], ['goog.events', 'goog.functions', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.ActivityMonitor', 'goog.ui.MockActivityMonitor'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/modalariavisibilityhelper.js', ['goog.ui.ModalAriaVisibilityHelper'], ['goog.a11y.aria', 'goog.a11y.aria.State'], {});
goog.addDependency('ui/modalariavisibilityhelper_test.js', ['goog.ui.ModalAriaVisibilityHelperTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.string', 'goog.testing.testSuite', 'goog.ui.ModalAriaVisibilityHelper'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/modalpopup.js', ['goog.ui.ModalPopup'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.animationFrame', 'goog.dom.classlist', 'goog.dom.iframe', 'goog.events', 'goog.events.EventType', 'goog.events.FocusHandler', 'goog.fx.Transition', 'goog.string', 'goog.style', 'goog.ui.Component', 'goog.ui.ModalAriaVisibilityHelper', 'goog.ui.PopupBase', 'goog.userAgent'], {});
goog.addDependency('ui/modalpopup_test.js', ['goog.ui.ModalPopupTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dispose', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.fx.Transition', 'goog.fx.css3', 'goog.string', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.ModalPopup', 'goog.ui.PopupBase'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/nativebuttonrenderer.js', ['goog.ui.NativeButtonRenderer'], ['goog.asserts', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.ui.ButtonRenderer', 'goog.ui.Component'], {});
goog.addDependency('ui/nativebuttonrenderer_test.js', ['goog.ui.NativeButtonRendererTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.testing.ExpectedFailures', 'goog.testing.events', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.NativeButtonRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/option.js', ['goog.ui.Option'], ['goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.registry'], {});
goog.addDependency('ui/palette.js', ['goog.ui.Palette'], ['goog.array', 'goog.dom', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Size', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.PaletteRenderer', 'goog.ui.SelectionModel'], {});
goog.addDependency('ui/palette_test.js', ['goog.ui.PaletteTest'], ['goog.a11y.aria', 'goog.dom', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyEvent', 'goog.testing.events.Event', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Container', 'goog.ui.Palette'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/paletterenderer.js', ['goog.ui.PaletteRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.NodeIterator', 'goog.dom.NodeType', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.dom.dataset', 'goog.iter', 'goog.style', 'goog.ui.ControlRenderer', 'goog.userAgent'], {});
goog.addDependency('ui/paletterenderer_test.js', ['goog.ui.PaletteRendererTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.Palette', 'goog.ui.PaletteRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/plaintextspellchecker.js', ['goog.ui.PlainTextSpellChecker'], ['goog.Timer', 'goog.a11y.aria', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.spell.SpellCheck', 'goog.style', 'goog.ui.AbstractSpellChecker', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/plaintextspellchecker_test.js', ['goog.ui.PlainTextSpellCheckerTest'], ['goog.Timer', 'goog.dom', 'goog.events.KeyCodes', 'goog.spell.SpellCheck', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.AbstractSpellChecker', 'goog.ui.PlainTextSpellChecker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popup.js', ['goog.ui.Popup'], ['goog.math.Box', 'goog.positioning.AbstractPosition', 'goog.positioning.Corner', 'goog.style', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/popup_test.js', ['goog.ui.PopupTest'], ['goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.style', 'goog.testing.testSuite', 'goog.ui.Popup', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popupbase.js', ['goog.ui.PopupBase', 'goog.ui.PopupBase.EventType', 'goog.ui.PopupBase.Type'], ['goog.Timer', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.fx.Transition', 'goog.style', 'goog.userAgent'], {});
goog.addDependency('ui/popupbase_test.js', ['goog.ui.PopupBaseTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.fx.Transition', 'goog.fx.css3', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.PopupBase'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popupcolorpicker.js', ['goog.ui.PopupColorPicker'], ['goog.asserts', 'goog.dom.classlist', 'goog.events.EventType', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.ui.ColorPicker', 'goog.ui.Component', 'goog.ui.Popup'], {});
goog.addDependency('ui/popupcolorpicker_test.js', ['goog.ui.PopupColorPickerTest'], ['goog.dom', 'goog.events', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.ColorPicker', 'goog.ui.PopupColorPicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popupdatepicker.js', ['goog.ui.PopupDatePicker'], ['goog.events.EventType', 'goog.positioning.AnchoredViewportPosition', 'goog.positioning.Corner', 'goog.style', 'goog.ui.Component', 'goog.ui.DatePicker', 'goog.ui.Popup', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/popupdatepicker_test.js', ['goog.ui.PopupDatePickerTest'], ['goog.date.Date', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.style', 'goog.testing.MockControl', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.DatePicker', 'goog.ui.PopupBase', 'goog.ui.PopupDatePicker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/popupmenu.js', ['goog.ui.PopupMenu'], ['goog.events', 'goog.events.BrowserEvent', 'goog.events.BrowserEvent.MouseButton', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.positioning.AnchoredViewportPosition', 'goog.positioning.Corner', 'goog.positioning.MenuAnchoredPosition', 'goog.positioning.Overflow', 'goog.positioning.ViewportClientPosition', 'goog.structs.Map', 'goog.style', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/popupmenu_test.js', ['goog.ui.PopupMenuTest'], ['goog.dom', 'goog.events.BrowserEvent', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.math.Box', 'goog.math.Coordinate', 'goog.positioning.Corner', 'goog.style', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.PopupMenu'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/progressbar.js', ['goog.ui.ProgressBar', 'goog.ui.ProgressBar.Orientation'], ['goog.a11y.aria', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.ui.Component', 'goog.ui.RangeModel', 'goog.userAgent'], {});
goog.addDependency('ui/prompt.js', ['goog.ui.Prompt'], ['goog.Timer', 'goog.dom', 'goog.dom.InputType', 'goog.dom.TagName', 'goog.events', 'goog.events.EventType', 'goog.functions', 'goog.html.SafeHtml', 'goog.ui.Component', 'goog.ui.Dialog', 'goog.userAgent'], {});
goog.addDependency('ui/prompt_test.js', ['goog.ui.PromptTest'], ['goog.dom.selection', 'goog.events.InputHandler', 'goog.events.KeyCodes', 'goog.functions', 'goog.string', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.BidiInput', 'goog.ui.Dialog', 'goog.ui.Prompt', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/rangemodel.js', ['goog.ui.RangeModel'], ['goog.events.EventTarget', 'goog.ui.Component'], {});
goog.addDependency('ui/rangemodel_test.js', ['goog.ui.RangeModelTest'], ['goog.testing.testSuite', 'goog.ui.RangeModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/ratings.js', ['goog.ui.Ratings', 'goog.ui.Ratings.EventType'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.ui.Component'], {});
goog.addDependency('ui/registry.js', ['goog.ui.registry'], ['goog.asserts', 'goog.dom.classlist'], {});
goog.addDependency('ui/registry_test.js', ['goog.ui.registryTest'], ['goog.object', 'goog.testing.testSuite', 'goog.ui.registry'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/richtextspellchecker.js', ['goog.ui.RichTextSpellChecker'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.NodeType', 'goog.dom.Range', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.math.Coordinate', 'goog.spell.SpellCheck', 'goog.string.StringBuffer', 'goog.style', 'goog.ui.AbstractSpellChecker', 'goog.ui.Component', 'goog.ui.PopupMenu'], {});
goog.addDependency('ui/richtextspellchecker_test.js', ['goog.ui.RichTextSpellCheckerTest'], ['goog.dom.Range', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.KeyCodes', 'goog.object', 'goog.spell.SpellCheck', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.RichTextSpellChecker'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/roundedpanel.js', ['goog.ui.BaseRoundedPanel', 'goog.ui.CssRoundedPanel', 'goog.ui.GraphicsRoundedPanel', 'goog.ui.RoundedPanel', 'goog.ui.RoundedPanel.Corner'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.graphics', 'goog.graphics.Path', 'goog.graphics.SolidFill', 'goog.graphics.Stroke', 'goog.math', 'goog.math.Coordinate', 'goog.style', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/roundedpanel_test.js', ['goog.ui.RoundedPanelTest'], ['goog.testing.testSuite', 'goog.ui.CssRoundedPanel', 'goog.ui.GraphicsRoundedPanel', 'goog.ui.RoundedPanel', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/roundedtabrenderer.js', ['goog.ui.RoundedTabRenderer'], ['goog.dom', 'goog.dom.TagName', 'goog.ui.Tab', 'goog.ui.TabBar', 'goog.ui.TabRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/scrollfloater.js', ['goog.ui.ScrollFloater', 'goog.ui.ScrollFloater.EventType'], ['goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.style', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/scrollfloater_test.js', ['goog.ui.ScrollFloaterTest'], ['goog.dom', 'goog.events', 'goog.style', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.ui.ScrollFloater'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/select.js', ['goog.ui.Select'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.events.EventType', 'goog.ui.Component', 'goog.ui.IdGenerator', 'goog.ui.MenuButton', 'goog.ui.MenuItem', 'goog.ui.MenuRenderer', 'goog.ui.SelectionModel', 'goog.ui.registry'], {});
goog.addDependency('ui/select_test.js', ['goog.ui.SelectTest'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.CustomButtonRenderer', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.Select', 'goog.ui.Separator'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/selectionmenubutton.js', ['goog.ui.SelectionMenuButton', 'goog.ui.SelectionMenuButton.SelectionState'], ['goog.dom.InputType', 'goog.dom.TagName', 'goog.events.EventType', 'goog.style', 'goog.ui.Component', 'goog.ui.MenuButton', 'goog.ui.MenuItem', 'goog.ui.registry'], {});
goog.addDependency('ui/selectionmenubutton_test.js', ['goog.ui.SelectionMenuButtonTest'], ['goog.dom', 'goog.events', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.SelectionMenuButton'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/selectionmodel.js', ['goog.ui.SelectionModel'], ['goog.array', 'goog.events.EventTarget', 'goog.events.EventType'], {});
goog.addDependency('ui/selectionmodel_test.js', ['goog.ui.SelectionModelTest'], ['goog.array', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.SelectionModel'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/separator.js', ['goog.ui.Separator'], ['goog.a11y.aria', 'goog.asserts', 'goog.ui.Component', 'goog.ui.Control', 'goog.ui.MenuSeparatorRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/serverchart.js', ['goog.ui.ServerChart', 'goog.ui.ServerChart.AxisDisplayType', 'goog.ui.ServerChart.ChartType', 'goog.ui.ServerChart.EncodingType', 'goog.ui.ServerChart.Event', 'goog.ui.ServerChart.LegendPosition', 'goog.ui.ServerChart.MaximumValue', 'goog.ui.ServerChart.MultiAxisAlignment', 'goog.ui.ServerChart.MultiAxisType', 'goog.ui.ServerChart.UriParam', 'goog.ui.ServerChart.UriTooLongEvent'], ['goog.Uri', 'goog.array', 'goog.asserts', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events.Event', 'goog.string', 'goog.ui.Component'], {});
goog.addDependency('ui/serverchart_test.js', ['goog.ui.ServerChartTest'], ['goog.Uri', 'goog.events', 'goog.testing.testSuite', 'goog.ui.ServerChart'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/slider.js', ['goog.ui.Slider', 'goog.ui.Slider.Orientation'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.dom', 'goog.dom.TagName', 'goog.ui.SliderBase'], {});
goog.addDependency('ui/sliderbase.js', ['goog.ui.SliderBase', 'goog.ui.SliderBase.AnimationFactory', 'goog.ui.SliderBase.Orientation'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.events.MouseWheelHandler', 'goog.functions', 'goog.fx.AnimationParallelQueue', 'goog.fx.Dragger', 'goog.fx.Transition', 'goog.fx.dom.ResizeHeight', 'goog.fx.dom.ResizeWidth', 'goog.fx.dom.Slide', 'goog.math', 'goog.math.Coordinate', 'goog.style', 'goog.style.bidi', 'goog.ui.Component', 'goog.ui.RangeModel'], {});
goog.addDependency('ui/sliderbase_test.js', ['goog.ui.SliderBaseTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.fx.Animation', 'goog.math.Coordinate', 'goog.style', 'goog.style.bidi', 'goog.testing.MockClock', 'goog.testing.MockControl', 'goog.testing.events', 'goog.testing.mockmatchers', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.SliderBase', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/splitpane.js', ['goog.ui.SplitPane', 'goog.ui.SplitPane.Orientation'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.fx.Dragger', 'goog.math.Rect', 'goog.math.Size', 'goog.style', 'goog.ui.Component', 'goog.userAgent'], {});
goog.addDependency('ui/splitpane_test.js', ['goog.ui.SplitPaneTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.math.Size', 'goog.style', 'goog.testing.events', 'goog.testing.recordFunction', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.SplitPane'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/style/app/buttonrenderer.js', ['goog.ui.style.app.ButtonRenderer'], ['goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.Button', 'goog.ui.CustomButtonRenderer', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.registry'], {});
goog.addDependency('ui/style/app/buttonrenderer_test.js', ['goog.ui.style.app.ButtonRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.style.app.ButtonRenderer', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/style/app/menubuttonrenderer.js', ['goog.ui.style.app.MenuButtonRenderer'], ['goog.a11y.aria.Role', 'goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.style', 'goog.ui.Menu', 'goog.ui.MenuRenderer', 'goog.ui.style.app.ButtonRenderer'], {});
goog.addDependency('ui/style/app/menubuttonrenderer_test.js', ['goog.ui.style.app.MenuButtonRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.style', 'goog.ui.Component', 'goog.ui.MenuButton', 'goog.ui.style.app.MenuButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/style/app/primaryactionbuttonrenderer.js', ['goog.ui.style.app.PrimaryActionButtonRenderer'], ['goog.ui.Button', 'goog.ui.registry', 'goog.ui.style.app.ButtonRenderer'], {});
goog.addDependency('ui/style/app/primaryactionbuttonrenderer_test.js', ['goog.ui.style.app.PrimaryActionButtonRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.style', 'goog.ui.Button', 'goog.ui.Component', 'goog.ui.style.app.PrimaryActionButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/submenu.js', ['goog.ui.SubMenu'], ['goog.Timer', 'goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events.KeyCodes', 'goog.positioning.AnchoredViewportPosition', 'goog.positioning.Corner', 'goog.style', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.SubMenuRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/submenu_test.js', ['goog.ui.SubMenuTest'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.functions', 'goog.positioning', 'goog.positioning.Overflow', 'goog.style', 'goog.testing.MockClock', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Menu', 'goog.ui.MenuItem', 'goog.ui.SubMenu', 'goog.ui.SubMenuRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/submenurenderer.js', ['goog.ui.SubMenuRenderer'], ['goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.style', 'goog.ui.Menu', 'goog.ui.MenuItemRenderer'], {});
goog.addDependency('ui/synthetickeyboardevent.js', ['goog.ui.SyntheticKeyboardEvent'], ['goog.events.Event', 'goog.ui.KeyboardEventData'], {});
goog.addDependency('ui/tab.js', ['goog.ui.Tab'], ['goog.ui.Component', 'goog.ui.Control', 'goog.ui.TabRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/tab_test.js', ['goog.ui.TabTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Tab', 'goog.ui.TabRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tabbar.js', ['goog.ui.TabBar', 'goog.ui.TabBar.Location'], ['goog.ui.Component.EventType', 'goog.ui.Container', 'goog.ui.Container.Orientation', 'goog.ui.Tab', 'goog.ui.TabBarRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/tabbar_test.js', ['goog.ui.TabBarTest'], ['goog.dom', 'goog.events', 'goog.events.Event', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.Container', 'goog.ui.Tab', 'goog.ui.TabBar', 'goog.ui.TabBarRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tabbarrenderer.js', ['goog.ui.TabBarRenderer'], ['goog.a11y.aria.Role', 'goog.object', 'goog.ui.ContainerRenderer'], {});
goog.addDependency('ui/tabbarrenderer_test.js', ['goog.ui.TabBarRendererTest'], ['goog.a11y.aria.Role', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Container', 'goog.ui.TabBar', 'goog.ui.TabBarRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tablesorter.js', ['goog.ui.TableSorter', 'goog.ui.TableSorter.EventType'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events.EventType', 'goog.functions', 'goog.ui.Component'], {});
goog.addDependency('ui/tablesorter_test.js', ['goog.ui.TableSorterTest'], ['goog.array', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.TableSorter'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tabpane.js', ['goog.ui.TabPane', 'goog.ui.TabPane.Events', 'goog.ui.TabPane.TabLocation', 'goog.ui.TabPane.TabPage', 'goog.ui.TabPaneEvent'], ['goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.Event', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.html.SafeStyleSheet', 'goog.style'], {});
goog.addDependency('ui/tabpane_test.js', ['goog.ui.TabPaneTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.TabPane'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tabrenderer.js', ['goog.ui.TabRenderer'], ['goog.a11y.aria.Role', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/tabrenderer_test.js', ['goog.ui.TabRendererTest'], ['goog.a11y.aria.Role', 'goog.dom', 'goog.dom.classlist', 'goog.testing.dom', 'goog.testing.testSuite', 'goog.testing.ui.rendererasserts', 'goog.ui.Tab', 'goog.ui.TabRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/textarea.js', ['goog.ui.Textarea', 'goog.ui.Textarea.EventType'], ['goog.asserts', 'goog.dom', 'goog.dom.classlist', 'goog.events.EventType', 'goog.style', 'goog.ui.Control', 'goog.ui.TextareaRenderer', 'goog.userAgent'], {});
goog.addDependency('ui/textarea_test.js', ['goog.ui.TextareaTest'], ['goog.dom', 'goog.dom.classlist', 'goog.events', 'goog.style', 'goog.testing.ExpectedFailures', 'goog.testing.events.EventObserver', 'goog.testing.testSuite', 'goog.ui.Textarea', 'goog.ui.TextareaRenderer', 'goog.userAgent', 'goog.userAgent.product'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/textarearenderer.js', ['goog.ui.TextareaRenderer'], ['goog.dom.TagName', 'goog.ui.Component', 'goog.ui.ControlRenderer'], {});
goog.addDependency('ui/togglebutton.js', ['goog.ui.ToggleButton'], ['goog.ui.Button', 'goog.ui.Component', 'goog.ui.CustomButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbar.js', ['goog.ui.Toolbar'], ['goog.ui.Container', 'goog.ui.ToolbarRenderer'], {});
goog.addDependency('ui/toolbar_test.js', ['goog.ui.ToolbarTest'], ['goog.a11y.aria', 'goog.dom', 'goog.events.EventType', 'goog.testing.events', 'goog.testing.events.Event', 'goog.testing.testSuite', 'goog.ui.Toolbar', 'goog.ui.ToolbarMenuButton'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/toolbarbutton.js', ['goog.ui.ToolbarButton'], ['goog.ui.Button', 'goog.ui.ToolbarButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarbuttonrenderer.js', ['goog.ui.ToolbarButtonRenderer'], ['goog.ui.CustomButtonRenderer'], {});
goog.addDependency('ui/toolbarcolormenubutton.js', ['goog.ui.ToolbarColorMenuButton'], ['goog.ui.ColorMenuButton', 'goog.ui.ToolbarColorMenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarcolormenubuttonrenderer.js', ['goog.ui.ToolbarColorMenuButtonRenderer'], ['goog.asserts', 'goog.dom.classlist', 'goog.ui.ColorMenuButtonRenderer', 'goog.ui.MenuButtonRenderer', 'goog.ui.ToolbarMenuButtonRenderer'], {});
goog.addDependency('ui/toolbarcolormenubuttonrenderer_test.js', ['goog.ui.ToolbarColorMenuButtonRendererTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.testing.ui.RendererHarness', 'goog.testing.ui.rendererasserts', 'goog.ui.ToolbarColorMenuButton', 'goog.ui.ToolbarColorMenuButtonRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/toolbarmenubutton.js', ['goog.ui.ToolbarMenuButton'], ['goog.ui.MenuButton', 'goog.ui.ToolbarMenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarmenubuttonrenderer.js', ['goog.ui.ToolbarMenuButtonRenderer'], ['goog.ui.MenuButtonRenderer'], {});
goog.addDependency('ui/toolbarrenderer.js', ['goog.ui.ToolbarRenderer'], ['goog.a11y.aria.Role', 'goog.dom.TagName', 'goog.ui.Container', 'goog.ui.ContainerRenderer', 'goog.ui.Separator', 'goog.ui.ToolbarSeparatorRenderer'], {});
goog.addDependency('ui/toolbarselect.js', ['goog.ui.ToolbarSelect'], ['goog.ui.Select', 'goog.ui.ToolbarMenuButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarseparator.js', ['goog.ui.ToolbarSeparator'], ['goog.ui.Separator', 'goog.ui.ToolbarSeparatorRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/toolbarseparatorrenderer.js', ['goog.ui.ToolbarSeparatorRenderer'], ['goog.asserts', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.MenuSeparatorRenderer'], {});
goog.addDependency('ui/toolbarseparatorrenderer_test.js', ['goog.ui.ToolbarSeparatorRendererTest'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.INLINE_BLOCK_CLASSNAME', 'goog.ui.ToolbarSeparator', 'goog.ui.ToolbarSeparatorRenderer'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/toolbartogglebutton.js', ['goog.ui.ToolbarToggleButton'], ['goog.ui.ToggleButton', 'goog.ui.ToolbarButtonRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/tooltip.js', ['goog.ui.Tooltip', 'goog.ui.Tooltip.CursorTooltipPosition', 'goog.ui.Tooltip.ElementTooltipPosition', 'goog.ui.Tooltip.State'], ['goog.Timer', 'goog.array', 'goog.asserts', 'goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.events', 'goog.events.EventType', 'goog.events.FocusHandler', 'goog.math.Box', 'goog.math.Coordinate', 'goog.positioning', 'goog.positioning.AnchoredPosition', 'goog.positioning.Corner', 'goog.positioning.Overflow', 'goog.positioning.OverflowStatus', 'goog.positioning.ViewportPosition', 'goog.structs.Set', 'goog.style', 'goog.ui.Popup', 'goog.ui.PopupBase'], {});
goog.addDependency('ui/tooltip_test.js', ['goog.ui.TooltipTest'], ['goog.dom', 'goog.dom.TagName', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventType', 'goog.events.FocusHandler', 'goog.html.testing', 'goog.math.Coordinate', 'goog.positioning.AbsolutePosition', 'goog.style', 'goog.testing.MockClock', 'goog.testing.TestQueue', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.PopupBase', 'goog.ui.Tooltip', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tree/basenode.js', ['goog.ui.tree.BaseNode', 'goog.ui.tree.BaseNode.EventType'], ['goog.Timer', 'goog.a11y.aria', 'goog.a11y.aria.State', 'goog.asserts', 'goog.dom.safe', 'goog.events.Event', 'goog.events.KeyCodes', 'goog.html.SafeHtml', 'goog.html.SafeStyle', 'goog.string', 'goog.string.StringBuffer', 'goog.style', 'goog.ui.Component'], {});
goog.addDependency('ui/tree/basenode_test.js', ['goog.ui.tree.BaseNodeTest'], ['goog.a11y.aria', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.html.testing', 'goog.testing.testSuite', 'goog.ui.Component', 'goog.ui.tree.BaseNode', 'goog.ui.tree.TreeControl', 'goog.ui.tree.TreeNode'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tree/treecontrol.js', ['goog.ui.tree.TreeControl'], ['goog.a11y.aria', 'goog.asserts', 'goog.dom.classlist', 'goog.events.EventType', 'goog.events.FocusHandler', 'goog.events.KeyHandler', 'goog.html.SafeHtml', 'goog.log', 'goog.ui.tree.BaseNode', 'goog.ui.tree.TreeNode', 'goog.ui.tree.TypeAhead', 'goog.userAgent'], {});
goog.addDependency('ui/tree/treecontrol_test.js', ['goog.ui.tree.TreeControlTest'], ['goog.dom', 'goog.testing.testSuite', 'goog.ui.tree.TreeControl'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tree/treenode.js', ['goog.ui.tree.TreeNode'], ['goog.ui.tree.BaseNode'], {});
goog.addDependency('ui/tree/typeahead.js', ['goog.ui.tree.TypeAhead', 'goog.ui.tree.TypeAhead.Offset'], ['goog.array', 'goog.events.KeyCodes', 'goog.string', 'goog.structs.Trie'], {});
goog.addDependency('ui/tree/typeahead_test.js', ['goog.ui.tree.TypeAheadTest'], ['goog.dom', 'goog.events.KeyCodes', 'goog.testing.testSuite', 'goog.ui.tree.TreeControl', 'goog.ui.tree.TypeAhead'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/tristatemenuitem.js', ['goog.ui.TriStateMenuItem', 'goog.ui.TriStateMenuItem.State'], ['goog.dom.classlist', 'goog.ui.Component', 'goog.ui.MenuItem', 'goog.ui.TriStateMenuItemRenderer', 'goog.ui.registry'], {});
goog.addDependency('ui/tristatemenuitemrenderer.js', ['goog.ui.TriStateMenuItemRenderer'], ['goog.asserts', 'goog.dom.classlist', 'goog.ui.MenuItemRenderer'], {});
goog.addDependency('ui/twothumbslider.js', ['goog.ui.TwoThumbSlider'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.dom', 'goog.dom.TagName', 'goog.ui.SliderBase'], {});
goog.addDependency('ui/twothumbslider_test.js', ['goog.ui.TwoThumbSliderTest'], ['goog.testing.testSuite', 'goog.ui.SliderBase', 'goog.ui.TwoThumbSlider'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('ui/zippy.js', ['goog.ui.Zippy', 'goog.ui.Zippy.Events', 'goog.ui.ZippyEvent'], ['goog.a11y.aria', 'goog.a11y.aria.Role', 'goog.a11y.aria.State', 'goog.dom', 'goog.dom.classlist', 'goog.events.Event', 'goog.events.EventHandler', 'goog.events.EventTarget', 'goog.events.EventType', 'goog.events.KeyCodes', 'goog.events.KeyHandler', 'goog.style'], {});
goog.addDependency('ui/zippy_test.js', ['goog.ui.ZippyTest'], ['goog.a11y.aria', 'goog.dom', 'goog.dom.TagName', 'goog.dom.classlist', 'goog.events', 'goog.events.KeyCodes', 'goog.object', 'goog.testing.events', 'goog.testing.testSuite', 'goog.ui.Zippy'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('uri/uri.js', ['goog.Uri', 'goog.Uri.QueryData'], ['goog.array', 'goog.asserts', 'goog.string', 'goog.structs', 'goog.structs.Map', 'goog.uri.utils', 'goog.uri.utils.ComponentIndex', 'goog.uri.utils.StandardQueryParam'], {});
goog.addDependency('uri/uri_test.js', ['goog.UriTest'], ['goog.Uri', 'goog.testing.testSuite'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('uri/utils.js', ['goog.uri.utils', 'goog.uri.utils.ComponentIndex', 'goog.uri.utils.QueryArray', 'goog.uri.utils.QueryValue', 'goog.uri.utils.StandardQueryParam'], ['goog.array', 'goog.asserts', 'goog.string'], {});
goog.addDependency('uri/utils_test.js', ['goog.uri.utilsTest'], ['goog.functions', 'goog.string', 'goog.testing.testSuite', 'goog.uri.utils'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/adobereader.js', ['goog.userAgent.adobeReader'], ['goog.string', 'goog.userAgent'], {'module': 'goog'});
goog.addDependency('useragent/adobereader_test.js', ['goog.userAgent.adobeReaderTest'], ['goog.testing.testSuite', 'goog.userAgent.adobeReader'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/flash.js', ['goog.userAgent.flash'], ['goog.string'], {});
goog.addDependency('useragent/flash_test.js', ['goog.userAgent.flashTest'], ['goog.testing.testSuite', 'goog.userAgent.flash'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/iphoto.js', ['goog.userAgent.iphoto'], ['goog.string', 'goog.userAgent'], {});
goog.addDependency('useragent/jscript.js', ['goog.userAgent.jscript'], ['goog.string'], {});
goog.addDependency('useragent/jscript_test.js', ['goog.userAgent.jscriptTest'], ['goog.testing.testSuite', 'goog.userAgent.jscript'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/keyboard.js', ['goog.userAgent.keyboard'], ['goog.labs.userAgent.platform'], {});
goog.addDependency('useragent/keyboard_test.js', ['goog.userAgent.keyboardTest'], ['goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.MockUserAgent', 'goog.testing.testSuite', 'goog.userAgent.keyboard', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/platform.js', ['goog.userAgent.platform'], ['goog.string', 'goog.userAgent'], {});
goog.addDependency('useragent/platform_test.js', ['goog.userAgent.platformTest'], ['goog.testing.MockUserAgent', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.platform', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/product.js', ['goog.userAgent.product'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.platform', 'goog.userAgent'], {});
goog.addDependency('useragent/product_isversion.js', ['goog.userAgent.product.isVersion'], ['goog.labs.userAgent.platform', 'goog.string', 'goog.userAgent', 'goog.userAgent.product'], {});
goog.addDependency('useragent/product_test.js', ['goog.userAgent.productTest'], ['goog.array', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.MockUserAgent', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgent.product', 'goog.userAgent.product.isVersion', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/useragent.js', ['goog.userAgent'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.engine', 'goog.labs.userAgent.platform', 'goog.labs.userAgent.util', 'goog.reflect', 'goog.string'], {});
goog.addDependency('useragent/useragent_quirks_test.js', ['goog.userAgentQuirksTest'], ['goog.testing.testSuite', 'goog.userAgent'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/useragent_test.js', ['goog.userAgentTest'], ['goog.array', 'goog.labs.userAgent.platform', 'goog.labs.userAgent.testAgents', 'goog.labs.userAgent.util', 'goog.testing.PropertyReplacer', 'goog.testing.testSuite', 'goog.userAgent', 'goog.userAgentTestUtil'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('useragent/useragenttestutil.js', ['goog.userAgentTestUtil', 'goog.userAgentTestUtil.UserAgents'], ['goog.labs.userAgent.browser', 'goog.labs.userAgent.engine', 'goog.labs.userAgent.platform', 'goog.object', 'goog.userAgent', 'goog.userAgent.keyboard', 'goog.userAgent.platform', 'goog.userAgent.product', 'goog.userAgent.product.isVersion'], {});
goog.addDependency('vec/float32array.js', ['goog.vec.Float32Array'], [], {'lang': 'es6'});
goog.addDependency('vec/float32array_test.js', ['goog.vec.Float32ArrayTest'], ['goog.testing.testSuite', 'goog.vec.Float32Array'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/float64array.js', ['goog.vec.Float64Array'], [], {'lang': 'es6'});
goog.addDependency('vec/float64array_test.js', ['goog.vec.Float64ArrayTest'], ['goog.testing.testSuite', 'goog.vec.Float64Array'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat3.js', ['goog.vec.Mat3'], ['goog.vec'], {});
goog.addDependency('vec/mat3_test.js', ['goog.vec.Mat3Test'], ['goog.testing.testSuite', 'goog.vec.Mat3'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat3d.js', ['goog.vec.mat3d', 'goog.vec.mat3d.Type'], ['goog.vec', 'goog.vec.vec3d.Type'], {});
goog.addDependency('vec/mat3d_test.js', ['goog.vec.mat3dTest'], ['goog.testing.testSuite', 'goog.vec.mat3d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat3f.js', ['goog.vec.mat3f', 'goog.vec.mat3f.Type'], ['goog.vec', 'goog.vec.vec3f.Type'], {});
goog.addDependency('vec/mat3f_test.js', ['goog.vec.mat3fTest'], ['goog.testing.testSuite', 'goog.vec.mat3f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat4.js', ['goog.vec.Mat4'], ['goog.vec', 'goog.vec.Vec3', 'goog.vec.Vec4'], {});
goog.addDependency('vec/mat4_test.js', ['goog.vec.Mat4Test'], ['goog.testing.testSuite', 'goog.vec.Mat4', 'goog.vec.Vec3', 'goog.vec.Vec4'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat4d.js', ['goog.vec.mat4d', 'goog.vec.mat4d.Type'], ['goog.vec', 'goog.vec.Quaternion', 'goog.vec.vec3d', 'goog.vec.vec4d'], {});
goog.addDependency('vec/mat4d_test.js', ['goog.vec.mat4dTest'], ['goog.testing.testSuite', 'goog.vec.Quaternion', 'goog.vec.mat4d', 'goog.vec.vec3d', 'goog.vec.vec4d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/mat4f.js', ['goog.vec.mat4f', 'goog.vec.mat4f.Type'], ['goog.vec', 'goog.vec.Quaternion', 'goog.vec.vec3f', 'goog.vec.vec4f'], {});
goog.addDependency('vec/mat4f_test.js', ['goog.vec.mat4fTest'], ['goog.testing.testSuite', 'goog.vec.Quaternion', 'goog.vec.mat4f', 'goog.vec.vec3f', 'goog.vec.vec4f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/quaternion.js', ['goog.vec.Quaternion', 'goog.vec.Quaternion.AnyType'], ['goog.vec', 'goog.vec.Vec3', 'goog.vec.Vec4'], {});
goog.addDependency('vec/quaternion_test.js', ['goog.vec.QuaternionTest'], ['goog.testing.testSuite', 'goog.vec.Mat3', 'goog.vec.Mat4', 'goog.vec.Quaternion', 'goog.vec.Vec3', 'goog.vec.vec3f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/ray.js', ['goog.vec.Ray'], ['goog.vec.Vec3'], {});
goog.addDependency('vec/ray_test.js', ['goog.vec.RayTest'], ['goog.testing.testSuite', 'goog.vec.Ray'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec.js', ['goog.vec', 'goog.vec.AnyType', 'goog.vec.ArrayType', 'goog.vec.Float32', 'goog.vec.Float64', 'goog.vec.Number'], ['goog.vec.Float32Array', 'goog.vec.Float64Array'], {});
goog.addDependency('vec/vec2.js', ['goog.vec.Vec2'], ['goog.vec'], {});
goog.addDependency('vec/vec2_test.js', ['goog.vec.Vec2Test'], ['goog.testing.testSuite', 'goog.vec.Vec2'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec2d.js', ['goog.vec.vec2d', 'goog.vec.vec2d.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec2d_test.js', ['goog.vec.vec2dTest'], ['goog.testing.testSuite', 'goog.vec.vec2d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec2f.js', ['goog.vec.vec2f', 'goog.vec.vec2f.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec2f_test.js', ['goog.vec.vec2fTest'], ['goog.testing.testSuite', 'goog.vec.vec2f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec3.js', ['goog.vec.Vec3'], ['goog.vec'], {});
goog.addDependency('vec/vec3_test.js', ['goog.vec.Vec3Test'], ['goog.testing.testSuite', 'goog.vec.Vec3'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec3d.js', ['goog.vec.vec3d', 'goog.vec.vec3d.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec3d_test.js', ['goog.vec.vec3dTest'], ['goog.testing.testSuite', 'goog.vec.vec3d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec3f.js', ['goog.vec.vec3f', 'goog.vec.vec3f.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec3f_test.js', ['goog.vec.vec3fTest'], ['goog.testing.testSuite', 'goog.vec.vec3f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec4.js', ['goog.vec.Vec4'], ['goog.vec'], {});
goog.addDependency('vec/vec4_test.js', ['goog.vec.Vec4Test'], ['goog.testing.testSuite', 'goog.vec.Vec4'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec4d.js', ['goog.vec.vec4d', 'goog.vec.vec4d.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec4d_test.js', ['goog.vec.vec4dTest'], ['goog.testing.testSuite', 'goog.vec.vec4d'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('vec/vec4f.js', ['goog.vec.vec4f', 'goog.vec.vec4f.Type'], ['goog.vec'], {});
goog.addDependency('vec/vec4f_test.js', ['goog.vec.vec4fTest'], ['goog.testing.testSuite', 'goog.vec.vec4f'], {'lang': 'es6', 'module': 'goog'});
goog.addDependency('webgl/webgl.js', ['goog.webgl'], [], {});
goog.addDependency('window/window.js', ['goog.window'], ['goog.dom', 'goog.dom.TagName', 'goog.dom.safe', 'goog.html.SafeUrl', 'goog.html.uncheckedconversions', 'goog.labs.userAgent.platform', 'goog.string', 'goog.string.Const', 'goog.userAgent'], {});
goog.addDependency('window/window_test.js', ['goog.windowTest'], ['goog.Promise', 'goog.dom', 'goog.dom.TagName', 'goog.events', 'goog.functions', 'goog.html.SafeUrl', 'goog.labs.userAgent.browser', 'goog.labs.userAgent.engine', 'goog.labs.userAgent.platform', 'goog.string', 'goog.testing.PropertyReplacer', 'goog.testing.TestCase', 'goog.testing.testSuite', 'goog.window'], {'lang': 'es6', 'module': 'goog'});

//# sourceURL=build:/external/com_google_javascript_closure_library/closure/goog/base.js
function wa(b){var d=0;return function(){return d<b.length?{done:!1,value:b[d++]}:{done:!0}}}function gb(b){return{next:wa(b)}}function lb(b){var d="undefined"!=typeof Symbol&&Symbol.iterator&&b[Symbol.iterator];return d?d.call(b):gb(b)}var wb=function(b){return"undefined"!=typeof window&&window===b?b:"undefined"!=typeof global&&null!=global?global:b}(this),Rb="function"==typeof Object.defineProperties?Object.defineProperty:function(b,d,f){b!=Array.prototype&&b!=Object.prototype&&(b[d]=f.value)};
function Ub(b,d){if(d){var f=wb;b=b.split(".");for(var h=0;h<b.length-1;h++){var k=b[h];k in f||(f[k]={});f=f[k]}b=b[b.length-1];h=f[b];d=d(h);d!=h&&null!=d&&Rb(f,b,{configurable:!0,writable:!0,value:d})}}
Ub("Promise",function(b){function d(p){this.state_=0;this.result_=void 0;this.onSettledCallbacks_=[];var m=this.createResolveAndReject_();try{p(m.resolve,m.reject)}catch(n){m.reject(n)}}function f(){this.batch_=null}function h(p){switch(typeof p){case "object":return null!=p;case "function":return!0;default:return!1}}function k(p){return p instanceof d?p:new d(function(m){m(p)})}if(b)return b;f.prototype.asyncExecute=function(p){if(null==this.batch_){this.batch_=[];var m=this;this.asyncExecuteFunction(function(){m.executeBatch_()})}this.batch_.push(p)};
var t=wb.setTimeout;f.prototype.asyncExecuteFunction=function(p){t(p,0)};f.prototype.executeBatch_=function(){for(;this.batch_&&this.batch_.length;){var p=this.batch_;this.batch_=[];for(var m=0;m<p.length;++m){var n=p[m];p[m]=null;try{n()}catch(q){this.asyncThrow_(q)}}}this.batch_=null};f.prototype.asyncThrow_=function(p){this.asyncExecuteFunction(function(){throw p;})};d.prototype.createResolveAndReject_=function(){function p(q){return function(u){n||(n=!0,q.call(m,u))}}var m=this,n=!1;return{resolve:p(this.resolveTo_),
reject:p(this.reject_)}};d.prototype.resolveTo_=function(p){p===this?this.reject_(new TypeError("A Promise cannot resolve to itself")):p instanceof d?this.settleSameAsPromise_(p):h(p)?this.resolveToNonPromiseObj_(p):this.fulfill_(p)};d.prototype.resolveToNonPromiseObj_=function(p){var m=void 0;try{m=p.then}catch(n){this.reject_(n);return}"function"==typeof m?this.settleSameAsThenable_(m,p):this.fulfill_(p)};d.prototype.reject_=function(p){this.settle_(2,p)};d.prototype.fulfill_=function(p){this.settle_(1,
p)};d.prototype.settle_=function(p,m){if(0!=this.state_)throw Error("Cannot settle("+p+", "+m+"): Promise already settled in state"+this.state_);this.state_=p;this.result_=m;this.executeOnSettledCallbacks_()};d.prototype.executeOnSettledCallbacks_=function(){if(null!=this.onSettledCallbacks_){for(var p=0;p<this.onSettledCallbacks_.length;++p)l.asyncExecute(this.onSettledCallbacks_[p]);this.onSettledCallbacks_=null}};var l=new f;d.prototype.settleSameAsPromise_=function(p){var m=this.createResolveAndReject_();
p.callWhenSettled_(m.resolve,m.reject)};d.prototype.settleSameAsThenable_=function(p,m){var n=this.createResolveAndReject_();try{p.call(m,n.resolve,n.reject)}catch(q){n.reject(q)}};d.prototype.then=function(p,m){function n(A,y){return"function"==typeof A?function(w){try{q(A(w))}catch(C){u(C)}}:y}var q,u,x=new d(function(A,y){q=A;u=y});this.callWhenSettled_(n(p,q),n(m,u));return x};d.prototype.catch=function(p){return this.then(void 0,p)};d.prototype.callWhenSettled_=function(p,m){function n(){switch(q.state_){case 1:p(q.result_);
break;case 2:m(q.result_);break;default:throw Error("Unexpected state: "+q.state_);}}var q=this;null==this.onSettledCallbacks_?l.asyncExecute(n):this.onSettledCallbacks_.push(n)};d.resolve=k;d.reject=function(p){return new d(function(m,n){n(p)})};d.race=function(p){return new d(function(m,n){for(var q=lb(p),u=q.next();!u.done;u=q.next())k(u.value).callWhenSettled_(m,n)})};d.all=function(p){var m=lb(p),n=m.next();return n.done?k([]):new d(function(q,u){function x(w){return function(C){A[w]=C;y--;0==
y&&q(A)}}var A=[],y=0;do A.push(void 0),y++,k(n.value).callWhenSettled_(x(A.length-1),u),n=m.next();while(!n.done)})};return d});function ac(b){function d(h){return b.next(h)}function f(h){return b.throw(h)}return new Promise(function(h,k){function t(l){l.done?h(l.value):Promise.resolve(l.value).then(d,f).then(t,k)}t(b.next())})}function hc(b){return ac(b())};
//# sourceURL=build:/external/com_google_javascript_closure_library/closure/goog/deps.js
//# sourceURL=build://analytics.html.js
window.ga=function(){};

// 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(a,b){var c={},d={},e={},f=null;!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=w}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==u.indexOf(b[c]))return;if("direction"==c&&-1==v.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 0>a||a>1||0>c||c>1?w: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(0==e||1==e)return e;for(var g=0,h=1;;){var i=(g+h)/2,j=f(a,c,i);if(Math.abs(e-j)<1e-4)return f(b,d,i);e>j?g=i:h=i}}}function j(a,b){return function(c){if(c>=1)return 1;var d=1/a;return c+=b*d,c-c%d}}function k(a){B||(B=document.createElement("div").style),B.animationTimingFunction="",B.animationTimingFunction=a;var b=B.animationTimingFunction;if(""==b&&e())throw new TypeError(a+" is not a valid value for easing");var c=D.exec(b);if(c)return i.apply(this,c.slice(1).map(Number));var d=E.exec(b);if(d)return j(Number(d[1]),{start:x,middle:y,end:z}[d[2]]);var f=A[b];return f?f:w}function l(a){return Math.abs(m(a)/a.playbackRate)}function m(a){return a.duration*a.iterations}function n(a,b,c){return null==b?F:b<c.delay?G:b>=c.delay+a?H:I}function o(a,b,c,d,e){switch(d){case G:return"backwards"==b||"both"==b?0:null;case I:return c-e;case H:return"forwards"==b||"both"==b?a:null;case F:return null}}function p(a,b,c,d){return(d.playbackRate<0?b-a:b)*d.playbackRate+c}function q(a,b,c,d,e){return c===1/0||c===-(1/0)||c-d==b&&e.iterations&&(e.iterations+e.iterationStart)%1==0?a:c%a}function r(a,b,c,d){return 0===c?0:b==a?d.iterationStart+d.iterations-1:Math.floor(c/a)}function s(a,b,c,d){var e=a%2>=1,f="normal"==d.direction||d.direction==(e?"alternate-reverse":"alternate"),g=f?c:b-c,h=g/b;return b*d._easingFunction(h)}function t(a,b,c){var d=n(a,b,c),e=o(a,c.fill,b,d,c.delay);if(null===e)return null;if(0===a)return d===G?0:1;var f=c.iterationStart*c.duration,g=p(a,e,f,c),h=q(c.duration,m(c),g,f,c),i=r(c.duration,h,g,c);return s(i,c.duration,h,c)/c.duration}var u="backwards|forwards|both|none".split("|"),v="reverse|alternate|alternate-reverse".split("|"),w=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)||0>a)&&e())throw new TypeError("iterationStart must be a non-negative number, received: "+timing.iterationStart);this._setMember("iterationStart",a)},get iterationStart(){return this._iterationStart},set duration(a){if("auto"!=a&&(isNaN(a)||0>a)&&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=k(a),this._setMember("easing",a)},get easing(){return this._easing},set iterations(a){if((isNaN(a)||0>a)&&e())throw new TypeError("iterations must be non-negative, received: "+a);this._setMember("iterations",a)},get iterations(){return this._iterations}};var x=1,y=.5,z=0,A={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,x),"step-middle":j(1,y),"step-end":j(1,z)},B=null,C="\\s*(-?\\d+\\.?\\d*|-?\\.\\d+)\\s*",D=new RegExp("cubic-bezier\\("+C+","+C+","+C+","+C+"\\)"),E=/steps\(\s*(\d+)\s*,\s*(start|middle|end)\s*\)/,F=0,G=1,H=2,I=3;a.cloneTimingInput=c,a.makeTiming=f,a.numericTimingToObject=g,a.normalizeTimingInput=h,a.calculateActiveDuration=l,a.calculateTimeFraction=t,a.calculatePhase=n,a.toTimingFunction=k}(c,f),function(a,b){function c(a,b){return a in j?j[a][b]||b:b}function d(a,b,d){var e=g[a];if(e){h.style[a]=b;for(var f in e){var i=e[f],j=h.style[i];d[i]=c(i,j)}}else d[a]=c(a,b)}function e(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;f>g;g++)e={},"offset"in a?e.offset=a.offset:1==f?e.offset=1:e.offset=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 f(a){function b(){var a=c.length;null==c[a-1].offset&&(c[a-1].offset=1),a>1&&null==c[0].offset&&(c[0].offset=0);for(var b=0,d=c[0].offset,e=1;a>e;e++){var f=c[e].offset;if(null!=f){for(var g=1;e-b>g;g++)c[b+g].offset=d+(f-d)*g/(e-b);b=e,d=f}}}if(null==a)return[];window.Symbol&&Symbol.iterator&&Array.prototype.from&&a[Symbol.iterator]&&(a=Array.from(a)),Array.isArray(a)||(a=e(a));for(var c=a.map(function(a){var b={};for(var c in a){var e=a[c];if("offset"==c){if(null!=e&&(e=Number(e),!isFinite(e)))throw new TypeError("keyframe offsets must be numbers.")}else{if("composite"==c)throw{type:DOMException.NOT_SUPPORTED_ERR,name:"NotSupportedError",message:"add compositing is not supported"};e=""+e}d(c,e,b)}return void 0==b.offset&&(b.offset=null),b}),f=!0,g=-(1/0),h=0;h<c.length;h++){var i=c[h].offset;if(null!=i){if(g>i)throw{code:DOMException.INVALID_MODIFICATION_ERR,name:"InvalidModificationError",message:"Keyframes are not loosely sorted by offset. Sort or specify offsets."};g=i}else f=!1}return c=c.filter(function(a){return a.offset>=0&&a.offset<=1}),f||b(),c}var g={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"]},h=document.createElementNS("http://www.w3.org/1999/xhtml","div"),i={thin:"1px",medium:"3px",thick:"5px"},j={borderBottomWidth:i,borderLeftWidth:i,borderRightWidth:i,borderTopWidth:i,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:i,textShadow:{none:"0px 0px 0px transparent"},boxShadow:{none:"0px 0px 0px 0px transparent"}};a.convertToArrayForm=e,a.normalizeKeyframes=f}(c,f),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),h>g?(a in b||console.warn("Web Animations: "+a+" "+f+" deprecated and will stop working on "+h.toDateString()+". "+d),b[a]=!0,!1):!0},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)}}(c),function(){if(document.documentElement.animate){var a=document.documentElement.animate([],0),b=!0;if(a&&(b=!1,"play|currentTime|pause|reverse|playbackRate|cancel|finish|startTime|playState".split("|").forEach(function(c){void 0===a[c]&&(b=!0)})),!b)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=f[g].offset,i=f[g+1].offset,j=f[g].value,k=f[g+1].value,l=f[g].easing;h==i&&(1==i?j=k:k=j),d.push({startTime:h,endTime:i,easing:a.toTimingFunction(l?l:"linear"),property:e,interpolation:b.propertyInterpolation(e,j,k)})}return d.sort(function(a,b){return a.startTime-b.startTime}),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 0>=c&&0==a.startTime||c>=1&&1==a.endTime||c>=a.startTime&&c<=a.endTime}).forEach(function(d){var e=c-d.startTime,f=d.endTime-d.startTime,g=0==f?0:d.easing(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)}}}(c,d,f),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++){var g=c[f];e(a,b,d(g))}}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",textIndent:"0px",textShadow:"0px 0px 0px transparent",top:"auto",transform:"",verticalAlign:"0px",visibility:"visible",width:"auto",wordSpacing:"normal",zIndex:"auto"};b.propertyInterpolation=g}(c,d,f),function(a,b,c){function d(b){var c=a.calculateActiveDuration(b),d=function(d){return a.calculateTimeFraction(c,d,b)};return d._totalDuration=b.delay+c+b.endDelay,d._isCurrent=function(d){var e=a.calculatePhase(c,d,b);return e===PhaseActive||e===PhaseBefore},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 h=i(a),null!==h},k._clear=function(){j(c,null)},k._hasSameTarget=function(a){return c===a},k._isCurrent=i._isCurrent,k._totalDuration=i._totalDuration,k._id=g,k},b.NullEffect=function(a){var b=function(){a&&(a(),a=null)};return b._update=function(){return null},b._totalDuration=0,b._isCurrent=function(){return!1},b._hasSameTarget=function(){return!1},b}}(c,d,f),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)]=""}}(d,f),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))}}(d),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.5>d?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))}}}(d,f),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._tickCurrentTime(a,!0),b.invalidateEffects()))},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.invalidateEffects())},get playbackRate(){return this._playbackRate},set playbackRate(a){if(a!=this._playbackRate){var b=this.currentTime;this._playbackRate=a,this._startTime=null,"paused"!=this.playState&&"idle"!=this.playState&&this.play(),null!=b&&(this.currentTime=b)}},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"},play:function(){this._paused=!1,(this._isFinished||this._idle)&&(this._currentTime=this._playbackRate>0?0:this._totalDuration,this._startTime=null),this._finishedFlag=!1,this._idle=!1,this._ensureAlive(),b.invalidateEffects()},pause:function(){this._isFinished||this._paused||this._idle||(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.invalidateEffects())},cancel:function(){this._inEffect&&(this._inEffect=!1,this._idle=!0,this._finishedFlag=!0,this.currentTime=0,this._startTime=null,this._effect._update(null),b.invalidateEffects())},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}}}(c,d,f),function(a,b,c){function d(a){var b=j;j=[],a<p.currentTime&&(a=p.currentTime),h(a,!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){n=!1;var d=b.timeline;d.currentTime=a,d._animations.sort(e),m=!1;var f=d._animations;d._animations=[];var g=[],h=[];f=f.filter(function(b){b._tick(a,c),b._inEffect?h.push(b._effect):g.push(b._effect),b._needsTick&&(m=!0);var d=b._inEffect||b._needsTick;return b._inTimeline=d,d}),o.push.apply(o,g),o.push.apply(o,h),d._animations.push.apply(d._animations,f),m&&requestAnimationFrame(function(){})}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.invalidateEffects(),d}};var l=void 0,m=!1,n=!1;b.restart=function(){return m||(m=!0,requestAnimationFrame(function(){}),n=!0),n},b.invalidateEffects=function(){h(b.timeline.currentTime,!1),g()};var o=[],p=new f;b.timeline=p}(c,d,f),function(a){function b(a,b){var c=a.exec(b);return c?(c=a.ignoreCase?c[0].toLowerCase():c[0],[c,b.substr(c.length)]):void 0}function c(a,b){b=b.replace(/^\s*/,"");var c=a(b);return c?[c[0],c[1].replace(/^\s*/,"")]:void 0}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||""==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++,0>=c))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){var d=a(c);return d?d:[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]}return""==c?d:void 0}function j(a,b,c,d,e){for(var g=[],h=[],i=[],j=f(d.length,e.length),k=0;j>k;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}(d),function(a){function b(b){function c(b){var c=a.consumeToken(/^inset/i,b);if(c)return d.inset=!0,c;var c=a.consumeLengthOrPercent(b);if(c)return d.lengths.push(c[0]),c;var c=a.consumeColor(b);return c?(d.color=c[0],c):void 0}var d={inset:!1,lengths:[],color:null},e=a.consumeRepeated(c,/^/,b);return e&&e[0].length?[d,e[1]]:void 0}function c(c){var d=a.consumeRepeated(b,/^,/,c);return d&&""==d[1]?d[0]:void 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"])}(d),function(a,b){function c(a){return a.toFixed(3).replace(".000","")}function d(a,b,c){return Math.min(b,Math.max(a,c))}function e(a){return/^\s*[-+]?(\d*\.)?\d+\s*$/.test(a)?Number(a):void 0}function f(a,b){return[a,b,c]}function g(a,b){return 0!=a?i(0,1/0)(a,b):void 0}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,b){return[a,b,Math.round]}a.clamp=d,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,j,["z-index"]),a.parseNumber=e,a.mergeNumbers=f,a.numberToString=c}(d,f),function(a,b){function c(a,b){return"visible"==a||"visible"==b?[0,1,function(c){return 0>=c?a:c>=1?b:"visible"}]:void 0}a.addPropertiesHandler(String,c,["visibility"])}(d),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;3>d;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","outline-color","text-decoration-color"]),a.consumeColor=a.consumeParenthesised.bind(null,c),a.mergeColors=d}(d,f),function(a,b){function c(a,b){if(b=b.trim().toLowerCase(),"0"==b&&"px".search(a)>=0)return{px:0};if(/^[^(]*$|^calc/.test(b)){b=b.replace(/calc\(/g,"(");var c={};b=b.replace(a,function(a){return c[a]=null,"U"+a});for(var d="U("+a.source+")",e=b.replace(/[-+]?(\d*\.)?\d+/g,"N").replace(new RegExp("N"+d,"g"),"D").replace(/\s[+-]\s/g,"O").replace(/\s/g,""),f=[/N\*(D)/g,/(N|D)[*\/]N/g,/(N|D)O\1/g,/\((N|D)\)/g],g=0;g<f.length;)f[g].test(e)?(e=e.replace(f[g],"$1"),g=0):g++;if("D"==e){for(var h in c){var i=eval(b.replace(new RegExp("U"+h,"g"),"").replace(new RegExp(d,"g"),"*0"));if(!isFinite(i))return;c[h]=i}return c}}}function d(a,b){return e(a,b,!0)}function e(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 f="px|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc",g=c.bind(null,new RegExp(f,"g")),h=c.bind(null,new RegExp(f+"|%","g")),i=c.bind(null,/deg|rad|grad|turn/g);a.parseLength=g,a.parseLengthOrPercent=h,a.consumeLengthOrPercent=a.consumeParenthesised.bind(null,h),a.parseAngle=i,a.mergeDimensions=e;var j=a.consumeParenthesised.bind(null,g),k=a.consumeRepeated.bind(void 0,j,/^/),l=a.consumeRepeated.bind(void 0,k,/^,/);a.consumeSizePairList=l;var m=function(a){var b=l(a);return b&&""==b[1]?b[0]:void 0},n=a.mergeNestedRepeated.bind(void 0,d," "),o=a.mergeNestedRepeated.bind(void 0,n,",");a.mergeNonNegativeSizePair=n,a.addPropertiesHandler(m,o,["background-size"]),a.addPropertiesHandler(h,d,["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(h,e,["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","text-indent","top","vertical-align","word-spacing"])}(d,f),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);return d&&4==d[0].length?d[0]:void 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"])}(d,f),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(b=b.toLowerCase().trim(),"none"==b)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(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],void 0===p)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]),g=a.composeMatrix(b[0],b[1],b[2],c,b[4]),h=g.map(f).join(",");return h}])}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"])}(d,f),function(a,b){function c(a,b){b.concat([a]).forEach(function(b){b in document.documentElement.style&&(d[a]=b)})}var d={};c("transform",["webkitTransform","msTransform"]),c("transformOrigin",["webkitTransformOrigin"]),c("perspective",["webkitPerspective"]),c("perspectiveOrigin",["webkitPerspectiveOrigin"]),a.propertyName=function(a){return d[a]||a}}(d,f)}(),!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(g){}finally{c&&c.cancel()}if(!d){var h=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)),h.call(this,b,c)}}}(c),!function(a,b,c){function d(a){var b=window.document.timeline;b.currentTime=a,b._discardAnimations(),0==b._animations.length?f=!1:requestAnimationFrame(d);
}var e=window.requestAnimationFrame;window.requestAnimationFrame=function(a){return e(function(b){window.document.timeline._updateAnimationsPromises(),a(b),window.document.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(h){}try{window.document.timeline=g}catch(h){}}(c,e,f),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=window.document.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){"function"==typeof a?this._animation.onfinish=function(b){b.target=this,a.call(this,b)}.bind(this):this._animation.onfinish=a},get oncancel(){return this._animation.oncancel},set oncancel(a){"function"==typeof a?this._animation.oncancel=function(b){b.target=this,a.call(this,b)}.bind(this):this._animation.oncancel=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}),"paused"!=this.playState&&"idle"!=this.playState&&this.play(),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.calculateTimeFraction(a.calculateActiveDuration(d),e,d)),(null==e||isNaN(e))&&this._removeChildAnimations()}}},window.Animation=b.Animation}(c,e,f),function(a,b,c){function d(b){this._frames=a.normalizeKeyframes(b)}function e(){for(var a=!1;i.length;){var b=i.shift();b._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(){window.document.timeline._updateAnimationsPromises();var a=j.apply(this,arguments);return e()&&(a=j.apply(this,arguments)),window.document.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))}}(c,e,f),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.calculateTimeFraction(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)}}(c,e,f),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;return c&&"pending"!=c.playState&&c.effect?null==b?void c._removeChildAnimations():0==b&&c.playbackRate<0&&(e||(e=a.normalizeTimingInput(c.effect.timing)),b=a.calculateTimeFraction(a.calculateActiveDuration(e),-1,e),isNaN(b)||null==b)?(c._forEachChild(function(a){a.currentTime=-1}),void c._removeChildAnimations()):void 0: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}(c,e,f),b["true"]=a}({},function(){return this}());

/**
@license @nocompile
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
*/
(function(){/*

 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
*/
'use strict';var n,p="undefined"!=typeof window&&window===this?this:"undefined"!=typeof global&&null!=global?global:this,aa="function"==typeof Object.defineProperties?Object.defineProperty:function(a,b,c){a!=Array.prototype&&a!=Object.prototype&&(a[b]=c.value)};function ba(){ba=function(){};p.Symbol||(p.Symbol=ca)}var ca=function(){var a=0;return function(b){return"jscomp_symbol_"+(b||"")+a++}}();
function da(){ba();var a=p.Symbol.iterator;a||(a=p.Symbol.iterator=p.Symbol("iterator"));"function"!=typeof Array.prototype[a]&&aa(Array.prototype,a,{configurable:!0,writable:!0,value:function(){return ea(this)}});da=function(){}}function ea(a){var b=0;return fa(function(){return b<a.length?{done:!1,value:a[b++]}:{done:!0}})}function fa(a){da();a={next:a};a[p.Symbol.iterator]=function(){return this};return a}function ia(a){da();var b=a[Symbol.iterator];return b?b.call(a):ea(a)}
function ja(a){for(var b,c=[];!(b=a.next()).done;)c.push(b.value);return c}
(function(){if(!function(){var a=document.createEvent("Event");a.initEvent("foo",!0,!0);a.preventDefault();return a.defaultPrevented}()){var a=Event.prototype.preventDefault;Event.prototype.preventDefault=function(){this.cancelable&&(a.call(this),Object.defineProperty(this,"defaultPrevented",{get:function(){return!0},configurable:!0}))}}var b=/Trident/.test(navigator.userAgent);if(!window.CustomEvent||b&&"function"!==typeof window.CustomEvent)window.CustomEvent=function(a,b){b=b||{};var c=document.createEvent("CustomEvent");
c.initCustomEvent(a,!!b.bubbles,!!b.cancelable,b.detail);return c},window.CustomEvent.prototype=window.Event.prototype;if(!window.Event||b&&"function"!==typeof window.Event){var c=window.Event;window.Event=function(a,b){b=b||{};var c=document.createEvent("Event");c.initEvent(a,!!b.bubbles,!!b.cancelable);return c};if(c)for(var d in c)window.Event[d]=c[d];window.Event.prototype=c.prototype}if(!window.MouseEvent||b&&"function"!==typeof window.MouseEvent){b=window.MouseEvent;window.MouseEvent=function(a,
b){b=b||{};var c=document.createEvent("MouseEvent");c.initMouseEvent(a,!!b.bubbles,!!b.cancelable,b.view||window,b.detail,b.screenX,b.screenY,b.clientX,b.clientY,b.ctrlKey,b.altKey,b.shiftKey,b.metaKey,b.button,b.relatedTarget);return c};if(b)for(d in b)window.MouseEvent[d]=b[d];window.MouseEvent.prototype=b.prototype}Array.from||(Array.from=function(a){return[].slice.call(a)});Object.assign||(Object.assign=function(a,b){for(var c=[].slice.call(arguments,1),d=0,e;d<c.length;d++)if(e=c[d])for(var f=
a,m=e,q=Object.getOwnPropertyNames(m),x=0;x<q.length;x++)e=q[x],f[e]=m[e];return a})})(window.WebComponents);(function(){function a(){}function b(a,b){if(!a.childNodes.length)return[];switch(a.nodeType){case Node.DOCUMENT_NODE:return ua.call(a,b);case Node.DOCUMENT_FRAGMENT_NODE:return lb.call(a,b);default:return U.call(a,b)}}var c="undefined"===typeof HTMLTemplateElement,d=!(document.createDocumentFragment().cloneNode()instanceof DocumentFragment),e=!1;/Trident/.test(navigator.userAgent)&&function(){function a(a,b){if(a instanceof DocumentFragment)for(var d;d=a.firstChild;)c.call(this,d,b);else c.call(this,
a,b);return a}e=!0;var b=Node.prototype.cloneNode;Node.prototype.cloneNode=function(a){a=b.call(this,a);this instanceof DocumentFragment&&(a.__proto__=DocumentFragment.prototype);return a};DocumentFragment.prototype.querySelectorAll=HTMLElement.prototype.querySelectorAll;DocumentFragment.prototype.querySelector=HTMLElement.prototype.querySelector;Object.defineProperties(DocumentFragment.prototype,{nodeType:{get:function(){return Node.DOCUMENT_FRAGMENT_NODE},configurable:!0},localName:{get:function(){},
configurable:!0},nodeName:{get:function(){return"#document-fragment"},configurable:!0}});var c=Node.prototype.insertBefore;Node.prototype.insertBefore=a;var d=Node.prototype.appendChild;Node.prototype.appendChild=function(b){b instanceof DocumentFragment?a.call(this,b,null):d.call(this,b);return b};var f=Node.prototype.removeChild,g=Node.prototype.replaceChild;Node.prototype.replaceChild=function(b,c){b instanceof DocumentFragment?(a.call(this,b,c),f.call(this,c)):g.call(this,b,c);return c};Document.prototype.createDocumentFragment=
function(){var a=this.createElement("df");a.__proto__=DocumentFragment.prototype;return a};var h=Document.prototype.importNode;Document.prototype.importNode=function(a,b){b=h.call(this,a,b||!1);a instanceof DocumentFragment&&(b.__proto__=DocumentFragment.prototype);return b}}();var f=Node.prototype.cloneNode,g=Document.prototype.createElement,h=Document.prototype.importNode,k=Node.prototype.removeChild,l=Node.prototype.appendChild,m=Node.prototype.replaceChild,q=DOMParser.prototype.parseFromString,
x=Object.getOwnPropertyDescriptor(window.HTMLElement.prototype,"innerHTML")||{get:function(){return this.innerHTML},set:function(a){this.innerHTML=a}},M=Object.getOwnPropertyDescriptor(window.Node.prototype,"childNodes")||{get:function(){return this.childNodes}},U=Element.prototype.querySelectorAll,ua=Document.prototype.querySelectorAll,lb=DocumentFragment.prototype.querySelectorAll,mb=function(){if(!c){var a=document.createElement("template"),b=document.createElement("template");b.content.appendChild(document.createElement("div"));
a.content.appendChild(b);a=a.cloneNode(!0);return 0===a.content.childNodes.length||0===a.content.firstChild.content.childNodes.length||d}}();if(c){var S=document.implementation.createHTMLDocument("template"),C=!0,V=document.createElement("style");V.textContent="template{display:none;}";var ha=document.head;ha.insertBefore(V,ha.firstElementChild);a.prototype=Object.create(HTMLElement.prototype);var va=!document.createElement("div").hasOwnProperty("innerHTML");a.G=function(b){if(!b.content&&b.namespaceURI===
document.documentElement.namespaceURI){b.content=S.createDocumentFragment();for(var c;c=b.firstChild;)l.call(b.content,c);if(va)b.__proto__=a.prototype;else if(b.cloneNode=function(b){return a.a(this,b)},C)try{P(b),W(b)}catch(Tg){C=!1}a.C(b.content)}};var X={option:["select"],thead:["table"],col:["colgroup","table"],tr:["tbody","table"],th:["tr","tbody","table"],td:["tr","tbody","table"]},P=function(b){Object.defineProperty(b,"innerHTML",{get:function(){return nb(this)},set:function(b){var c=X[(/<([a-z][^/\0>\x20\t\r\n\f]+)/i.exec(b)||
["",""])[1].toLowerCase()];if(c)for(var d=0;d<c.length;d++)b="<"+c[d]+">"+b+"</"+c[d]+">";S.body.innerHTML=b;for(a.C(S);this.content.firstChild;)k.call(this.content,this.content.firstChild);b=S.body;if(c)for(d=0;d<c.length;d++)b=b.lastChild;for(;b.firstChild;)l.call(this.content,b.firstChild)},configurable:!0})},W=function(a){Object.defineProperty(a,"outerHTML",{get:function(){return"<template>"+this.innerHTML+"</template>"},set:function(a){if(this.parentNode){S.body.innerHTML=a;for(a=this.ownerDocument.createDocumentFragment();S.body.firstChild;)l.call(a,
S.body.firstChild);m.call(this.parentNode,a,this)}else throw Error("Failed to set the 'outerHTML' property on 'Element': This element has no parent node.");},configurable:!0})};P(a.prototype);W(a.prototype);a.C=function(c){c=b(c,"template");for(var d=0,e=c.length,f;d<e&&(f=c[d]);d++)a.G(f)};document.addEventListener("DOMContentLoaded",function(){a.C(document)});Document.prototype.createElement=function(){var b=g.apply(this,arguments);"template"===b.localName&&a.G(b);return b};DOMParser.prototype.parseFromString=
function(){var b=q.apply(this,arguments);a.C(b);return b};Object.defineProperty(HTMLElement.prototype,"innerHTML",{get:function(){return nb(this)},set:function(b){x.set.call(this,b);a.C(this)},configurable:!0,enumerable:!0});var Ve=/[&\u00A0"]/g,yc=/[&\u00A0<>]/g,zc=function(a){switch(a){case "&":return"&amp;";case "<":return"&lt;";case ">":return"&gt;";case '"':return"&quot;";case "\u00a0":return"&nbsp;"}};V=function(a){for(var b={},c=0;c<a.length;c++)b[a[c]]=!0;return b};var We=V("area base br col command embed hr img input keygen link meta param source track wbr".split(" ")),
Xe=V("style script xmp iframe noembed noframes plaintext noscript".split(" ")),nb=function(a,b){"template"===a.localName&&(a=a.content);for(var c="",d=b?b(a):M.get.call(a),e=0,f=d.length,g;e<f&&(g=d[e]);e++){a:{var h=g;var k=a;var l=b;switch(h.nodeType){case Node.ELEMENT_NODE:for(var P=h.localName,m="<"+P,W=h.attributes,q=0;k=W[q];q++)m+=" "+k.name+'="'+k.value.replace(Ve,zc)+'"';m+=">";h=We[P]?m:m+nb(h,l)+"</"+P+">";break a;case Node.TEXT_NODE:h=h.data;h=k&&Xe[k.localName]?h:h.replace(yc,zc);break a;
case Node.COMMENT_NODE:h="\x3c!--"+h.data+"--\x3e";break a;default:throw window.console.error(h),Error("not implemented");}}c+=h}return c}}if(c||mb){a.a=function(a,b){var c=f.call(a,!1);this.G&&this.G(c);b&&(l.call(c.content,f.call(a.content,!0)),ob(c.content,a.content));return c};var ob=function(c,d){if(d.querySelectorAll&&(d=b(d,"template"),0!==d.length)){c=b(c,"template");for(var e=0,f=c.length,g,h;e<f;e++)h=d[e],g=c[e],a&&a.G&&a.G(h),m.call(g.parentNode,Ye.call(h,!0),g)}},Ye=Node.prototype.cloneNode=
function(b){if(!e&&d&&this instanceof DocumentFragment)if(b)var c=Ze.call(this.ownerDocument,this,!0);else return this.ownerDocument.createDocumentFragment();else this.nodeType===Node.ELEMENT_NODE&&"template"===this.localName&&this.namespaceURI==document.documentElement.namespaceURI?c=a.a(this,b):c=f.call(this,b);b&&ob(c,this);return c},Ze=Document.prototype.importNode=function(c,d){d=d||!1;if("template"===c.localName)return a.a(c,d);var e=h.call(this,c,d);if(d){ob(e,c);c=b(e,'script:not([type]),script[type="application/javascript"],script[type="text/javascript"]');
for(var f,k=0;k<c.length;k++){f=c[k];d=g.call(document,"script");d.textContent=f.textContent;for(var l=f.attributes,P=0,W;P<l.length;P++)W=l[P],d.setAttribute(W.name,W.value);m.call(f.parentNode,d,f)}}return e}}c&&(window.HTMLTemplateElement=a)})();var ka=setTimeout;function la(){}function ma(a,b){return function(){a.apply(b,arguments)}}function r(a){if(!(this instanceof r))throw new TypeError("Promises must be constructed via new");if("function"!==typeof a)throw new TypeError("not a function");this.u=0;this.ma=!1;this.h=void 0;this.I=[];na(a,this)}
function oa(a,b){for(;3===a.u;)a=a.h;0===a.u?a.I.push(b):(a.ma=!0,pa(function(){var c=1===a.u?b.Na:b.Oa;if(null===c)(1===a.u?qa:ra)(b.ga,a.h);else{try{var d=c(a.h)}catch(e){ra(b.ga,e);return}qa(b.ga,d)}}))}function qa(a,b){try{if(b===a)throw new TypeError("A promise cannot be resolved with itself.");if(b&&("object"===typeof b||"function"===typeof b)){var c=b.then;if(b instanceof r){a.u=3;a.h=b;sa(a);return}if("function"===typeof c){na(ma(c,b),a);return}}a.u=1;a.h=b;sa(a)}catch(d){ra(a,d)}}
function ra(a,b){a.u=2;a.h=b;sa(a)}function sa(a){2===a.u&&0===a.I.length&&pa(function(){a.ma||"undefined"!==typeof console&&console&&console.warn("Possible Unhandled Promise Rejection:",a.h)});for(var b=0,c=a.I.length;b<c;b++)oa(a,a.I[b]);a.I=null}function ta(a,b,c){this.Na="function"===typeof a?a:null;this.Oa="function"===typeof b?b:null;this.ga=c}function na(a,b){var c=!1;try{a(function(a){c||(c=!0,qa(b,a))},function(a){c||(c=!0,ra(b,a))})}catch(d){c||(c=!0,ra(b,d))}}
r.prototype["catch"]=function(a){return this.then(null,a)};r.prototype.then=function(a,b){var c=new this.constructor(la);oa(this,new ta(a,b,c));return c};r.prototype["finally"]=function(a){var b=this.constructor;return this.then(function(c){return b.resolve(a()).then(function(){return c})},function(c){return b.resolve(a()).then(function(){return b.reject(c)})})};
function wa(a){return new r(function(b,c){function d(a,g){try{if(g&&("object"===typeof g||"function"===typeof g)){var h=g.then;if("function"===typeof h){h.call(g,function(b){d(a,b)},c);return}}e[a]=g;0===--f&&b(e)}catch(m){c(m)}}if(!a||"undefined"===typeof a.length)throw new TypeError("Promise.all accepts an array");var e=Array.prototype.slice.call(a);if(0===e.length)return b([]);for(var f=e.length,g=0;g<e.length;g++)d(g,e[g])})}
function xa(a){return a&&"object"===typeof a&&a.constructor===r?a:new r(function(b){b(a)})}function ya(a){return new r(function(b,c){c(a)})}function za(a){return new r(function(b,c){for(var d=0,e=a.length;d<e;d++)a[d].then(b,c)})}var pa="function"===typeof setImmediate&&function(a){setImmediate(a)}||function(a){ka(a,0)};/*

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
*/
if(!window.Promise){window.Promise=r;r.prototype.then=r.prototype.then;r.all=wa;r.race=za;r.resolve=xa;r.reject=ya;var Aa=document.createTextNode(""),Ba=[];(new MutationObserver(function(){for(var a=Ba.length,b=0;b<a;b++)Ba[b]();Ba.splice(0,a)})).observe(Aa,{characterData:!0});pa=function(a){Ba.push(a);Aa.textContent=0<Aa.textContent.length?"":"a"}};(function(a){function b(a,b){if("function"===typeof window.CustomEvent)return new CustomEvent(a,b);var c=document.createEvent("CustomEvent");c.initCustomEvent(a,!!b.bubbles,!!b.cancelable,b.detail);return c}function c(a){if(M)return a.ownerDocument!==document?a.ownerDocument:null;var b=a.__importDoc;if(!b&&a.parentNode){b=a.parentNode;if("function"===typeof b.closest)b=b.closest("link[rel=import]");else for(;!h(b)&&(b=b.parentNode););a.__importDoc=b}return b}function d(a){var b=m(document,"link[rel=import]:not([import-dependency])"),
c=b.length;c?q(b,function(b){return g(b,function(){0===--c&&a()})}):a()}function e(a){function b(){"loading"!==document.readyState&&document.body&&(document.removeEventListener("readystatechange",b),a())}document.addEventListener("readystatechange",b);b()}function f(a){e(function(){return d(function(){return a&&a()})})}function g(a,b){if(a.__loaded)b&&b();else if("script"===a.localName&&!a.src||"style"===a.localName&&!a.firstChild)a.__loaded=!0,b&&b();else{var c=function(d){a.removeEventListener(d.type,
c);a.__loaded=!0;b&&b()};a.addEventListener("load",c);ha&&"style"===a.localName||a.addEventListener("error",c)}}function h(a){return a.nodeType===Node.ELEMENT_NODE&&"link"===a.localName&&"import"===a.rel}function k(){var a=this;this.a={};this.b=0;this.c=new MutationObserver(function(b){return a.Ja(b)});this.c.observe(document.head,{childList:!0,subtree:!0});this.loadImports(document)}function l(a){q(m(a,"template"),function(a){q(m(a.content,'script:not([type]),script[type="application/javascript"],script[type="text/javascript"],script[type="module"]'),
function(a){var b=document.createElement("script");q(a.attributes,function(a){return b.setAttribute(a.name,a.value)});b.textContent=a.textContent;a.parentNode.replaceChild(b,a)});l(a.content)})}function m(a,b){return a.childNodes.length?a.querySelectorAll(b):U}function q(a,b,c){var d=a?a.length:0,e=c?-1:1;for(c=c?d-1:0;c<d&&0<=c;c+=e)b(a[c],c)}var x=document.createElement("link"),M="import"in x,U=x.querySelectorAll("*"),ua=null;!1==="currentScript"in document&&Object.defineProperty(document,"currentScript",
{get:function(){return ua||("complete"!==document.readyState?document.scripts[document.scripts.length-1]:null)},configurable:!0});var lb=/(url\()([^)]*)(\))/g,mb=/(@import[\s]+(?!url\())([^;]*)(;)/g,S=/(<link[^>]*)(rel=['|"]?stylesheet['|"]?[^>]*>)/g,C={Ea:function(a,b){a.href&&a.setAttribute("href",C.X(a.getAttribute("href"),b));a.src&&a.setAttribute("src",C.X(a.getAttribute("src"),b));if("style"===a.localName){var c=C.qa(a.textContent,b,lb);a.textContent=C.qa(c,b,mb)}},qa:function(a,b,c){return a.replace(c,
function(a,c,d,e){a=d.replace(/["']/g,"");b&&(a=C.X(a,b));return c+"'"+a+"'"+e})},X:function(a,b){if(void 0===C.aa){C.aa=!1;try{var c=new URL("b","http://a");c.pathname="c%20d";C.aa="http://a/c%20d"===c.href}catch(yc){}}if(C.aa)return(new URL(a,b)).href;c=C.xa;c||(c=document.implementation.createHTMLDocument("temp"),C.xa=c,c.ja=c.createElement("base"),c.head.appendChild(c.ja),c.ia=c.createElement("a"));c.ja.href=b;c.ia.href=a;return c.ia.href||a}},V={async:!0,load:function(a,b,c){if(a)if(a.match(/^data:/)){a=
a.split(",");var d=a[1];d=-1<a[0].indexOf(";base64")?atob(d):decodeURIComponent(d);b(d)}else{var e=new XMLHttpRequest;e.open("GET",a,V.async);e.onload=function(){var a=e.responseURL||e.getResponseHeader("Location");a&&0===a.indexOf("/")&&(a=(location.origin||location.protocol+"//"+location.host)+a);var d=e.response||e.responseText;304===e.status||0===e.status||200<=e.status&&300>e.status?b(d,a):c(d)};e.send()}else c("error: href must be specified")}},ha=/Trident/.test(navigator.userAgent)||/Edge\/\d./i.test(navigator.userAgent);
k.prototype.loadImports=function(a){var b=this;a=m(a,"link[rel=import]");q(a,function(a){return b.g(a)})};k.prototype.g=function(a){var b=this,c=a.href;if(void 0!==this.a[c]){var d=this.a[c];d&&d.__loaded&&(a.__import=d,this.f(a))}else this.b++,this.a[c]="pending",V.load(c,function(a,d){a=b.Ka(a,d||c);b.a[c]=a;b.b--;b.loadImports(a);b.l()},function(){b.a[c]=null;b.b--;b.l()})};k.prototype.Ka=function(a,b){if(!a)return document.createDocumentFragment();ha&&(a=a.replace(S,function(a,b,c){return-1===
a.indexOf("type=")?b+" type=import-disable "+c:a}));var c=document.createElement("template");c.innerHTML=a;if(c.content)a=c.content,l(a);else for(a=document.createDocumentFragment();c.firstChild;)a.appendChild(c.firstChild);if(c=a.querySelector("base"))b=C.X(c.getAttribute("href"),b),c.removeAttribute("href");c=m(a,'link[rel=import],link[rel=stylesheet][href][type=import-disable],style:not([type]),link[rel=stylesheet][href]:not([type]),script:not([type]),script[type="application/javascript"],script[type="text/javascript"],script[type="module"]');
var d=0;q(c,function(a){g(a);C.Ea(a,b);a.setAttribute("import-dependency","");if("script"===a.localName&&!a.src&&a.textContent){if("module"===a.type)throw Error("Inline module scripts are not supported in HTML Imports.");a.setAttribute("src","data:text/javascript;charset=utf-8,"+encodeURIComponent(a.textContent+("\n//# sourceURL="+b+(d?"-"+d:"")+".js\n")));a.textContent="";d++}});return a};k.prototype.l=function(){var a=this;if(!this.b){this.c.disconnect();this.flatten(document);var b=!1,c=!1,d=function(){c&&
b&&(a.loadImports(document),a.b||(a.c.observe(document.head,{childList:!0,subtree:!0}),a.da()))};this.Ma(function(){c=!0;d()});this.La(function(){b=!0;d()})}};k.prototype.flatten=function(a){var b=this;a=m(a,"link[rel=import]");q(a,function(a){var c=b.a[a.href];(a.__import=c)&&c.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&(b.a[a.href]=a,a.readyState="loading",a.__import=a,b.flatten(c),a.appendChild(c))})};k.prototype.La=function(a){function b(e){if(e<d){var f=c[e],h=document.createElement("script");f.removeAttribute("import-dependency");
q(f.attributes,function(a){return h.setAttribute(a.name,a.value)});ua=h;f.parentNode.replaceChild(h,f);g(h,function(){ua=null;b(e+1)})}else a()}var c=m(document,"script[import-dependency]"),d=c.length;b(0)};k.prototype.Ma=function(a){var b=m(document,"style[import-dependency],link[rel=stylesheet][import-dependency]"),d=b.length;if(d){var e=ha&&!!document.querySelector("link[rel=stylesheet][href][type=import-disable]");q(b,function(b){g(b,function(){b.removeAttribute("import-dependency");0===--d&&
a()});if(e&&b.parentNode!==document.head){var f=document.createElement(b.localName);f.__appliedElement=b;f.setAttribute("type","import-placeholder");b.parentNode.insertBefore(f,b.nextSibling);for(f=c(b);f&&c(f);)f=c(f);f.parentNode!==document.head&&(f=null);document.head.insertBefore(b,f);b.removeAttribute("type")}})}else a()};k.prototype.da=function(){var a=this,b=m(document,"link[rel=import]");q(b,function(b){return a.f(b)},!0)};k.prototype.f=function(a){a.__loaded||(a.__loaded=!0,a.import&&(a.import.readyState=
"complete"),a.dispatchEvent(b(a.import?"load":"error",{bubbles:!1,cancelable:!1,detail:void 0})))};k.prototype.Ja=function(a){var b=this;q(a,function(a){return q(a.addedNodes,function(a){a&&a.nodeType===Node.ELEMENT_NODE&&(h(a)?b.g(a):b.loadImports(a))})})};var va=null;if(M)x=m(document,"link[rel=import]"),q(x,function(a){a.import&&"loading"===a.import.readyState||(a.__loaded=!0)}),x=function(a){a=a.target;h(a)&&(a.__loaded=!0)},document.addEventListener("load",x,!0),document.addEventListener("error",
x,!0);else{var X=Object.getOwnPropertyDescriptor(Node.prototype,"baseURI");Object.defineProperty((!X||X.configurable?Node:Element).prototype,"baseURI",{get:function(){var a=h(this)?this:c(this);return a?a.href:X&&X.get?X.get.call(this):(document.querySelector("base")||window.location).href},configurable:!0,enumerable:!0});Object.defineProperty(HTMLLinkElement.prototype,"import",{get:function(){return this.__import||null},configurable:!0,enumerable:!0});e(function(){va=new k})}f(function(){return document.dispatchEvent(b("HTMLImportsLoaded",
{cancelable:!0,bubbles:!0,detail:void 0}))});a.useNative=M;a.whenReady=f;a.importForElement=c;a.loadImports=function(a){va&&va.loadImports(a)}})(window.HTMLImports=window.HTMLImports||{});/*

 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
*/
window.WebComponents=window.WebComponents||{flags:{}};var Ca=document.querySelector('script[src*="webcomponents-lite.js"]'),Da=/wc-(.+)/,t={};if(!t.noOpts){location.search.slice(1).split("&").forEach(function(a){a=a.split("=");var b;a[0]&&(b=a[0].match(Da))&&(t[b[1]]=a[1]||!0)});if(Ca)for(var Ea=0,Fa=void 0;Fa=Ca.attributes[Ea];Ea++)"src"!==Fa.name&&(t[Fa.name]=Fa.value||!0);if(t.log&&t.log.split){var Ga=t.log.split(",");t.log={};Ga.forEach(function(a){t.log[a]=!0})}else t.log={}}
window.WebComponents.flags=t;var Ha=t.shadydom;Ha&&(window.ShadyDOM=window.ShadyDOM||{},window.ShadyDOM.force=Ha);var Ia=t.register||t.ce;Ia&&window.customElements&&(window.customElements.forcePolyfill=Ia);/*

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
*/
function Ja(){this.pa=this.root=null;this.T=!1;this.D=this.P=this.ca=this.assignedSlot=this.assignedNodes=this.H=null;this.childNodes=this.nextSibling=this.previousSibling=this.lastChild=this.firstChild=this.parentNode=this.K=void 0;this.ka=this.la=!1;this.O={}}Ja.prototype.toJSON=function(){return{}};function u(a){a.__shady||(a.__shady=new Ja);return a.__shady}function v(a){return a&&a.__shady};var w=window.ShadyDOM||{};w.Ga=!(!Element.prototype.attachShadow||!Node.prototype.getRootNode);var Ka=Object.getOwnPropertyDescriptor(Node.prototype,"firstChild");w.m=!!(Ka&&Ka.configurable&&Ka.get);w.ea=w.force||!w.Ga;w.J=w.noPatch||!1;w.oa=w.preferPerformance;function y(a){return(a=v(a))&&void 0!==a.firstChild}function z(a){return"ShadyRoot"===a.za}function La(a){return(a=(a=v(a))&&a.root)&&Ma(a)}
var Na=Element.prototype,Oa=Na.matches||Na.matchesSelector||Na.mozMatchesSelector||Na.msMatchesSelector||Na.oMatchesSelector||Na.webkitMatchesSelector,Pa=document.createTextNode(""),Qa=0,Ra=[];(new MutationObserver(function(){for(;Ra.length;)try{Ra.shift()()}catch(a){throw Pa.textContent=Qa++,a;}})).observe(Pa,{characterData:!0});function Sa(a){Ra.push(a);Pa.textContent=Qa++}var Ta=!!document.contains;function Ua(a,b){for(;b;){if(b==a)return!0;b=b.__shady_parentNode}return!1}
function Va(a){for(var b=a.length-1;0<=b;b--){var c=a[b],d=c.getAttribute("id")||c.getAttribute("name");d&&"length"!==d&&isNaN(d)&&(a[d]=c)}a.item=function(b){return a[b]};a.namedItem=function(b){if("length"!==b&&isNaN(b)&&a[b])return a[b];for(var c=ia(a),d=c.next();!d.done;d=c.next())if(d=d.value,(d.getAttribute("id")||d.getAttribute("name"))==b)return d;return null};return a}
function A(a,b,c,d){c=void 0===c?"":c;for(var e in b){var f=b[e];if(!(d&&0<=d.indexOf(e))){f.configurable=!0;var g=c+e;if(f.value)a[g]=f.value;else try{Object.defineProperty(a,g,f)}catch(h){}}}}function B(a){var b={};Object.getOwnPropertyNames(a).forEach(function(c){b[c]=Object.getOwnPropertyDescriptor(a,c)});return b};var Wa=[],Xa;function Ya(a){Xa||(Xa=!0,Sa(Za));Wa.push(a)}function Za(){Xa=!1;for(var a=!!Wa.length;Wa.length;)Wa.shift()();return a}Za.list=Wa;function $a(){this.a=!1;this.addedNodes=[];this.removedNodes=[];this.S=new Set}function ab(a){a.a||(a.a=!0,Sa(function(){a.flush()}))}$a.prototype.flush=function(){if(this.a){this.a=!1;var a=this.takeRecords();a.length&&this.S.forEach(function(b){b(a)})}};$a.prototype.takeRecords=function(){if(this.addedNodes.length||this.removedNodes.length){var a=[{addedNodes:this.addedNodes,removedNodes:this.removedNodes}];this.addedNodes=[];this.removedNodes=[];return a}return[]};
function bb(a,b){var c=u(a);c.H||(c.H=new $a);c.H.S.add(b);var d=c.H;return{ya:b,F:d,Aa:a,takeRecords:function(){return d.takeRecords()}}}function cb(a){var b=a&&a.F;b&&(b.S.delete(a.ya),b.S.size||(u(a.Aa).H=null))}
function db(a,b){var c=b.getRootNode();return a.map(function(a){var b=c===a.target.getRootNode();if(b&&a.addedNodes){if(b=Array.from(a.addedNodes).filter(function(a){return c===a.getRootNode()}),b.length)return a=Object.create(a),Object.defineProperty(a,"addedNodes",{value:b,configurable:!0}),a}else if(b)return a}).filter(function(a){return a})};var eb=/[&\u00A0"]/g,fb=/[&\u00A0<>]/g;function gb(a){switch(a){case "&":return"&amp;";case "<":return"&lt;";case ">":return"&gt;";case '"':return"&quot;";case "\u00a0":return"&nbsp;"}}function hb(a){for(var b={},c=0;c<a.length;c++)b[a[c]]=!0;return b}var ib=hb("area base br col command embed hr img input keygen link meta param source track wbr".split(" ")),jb=hb("style script xmp iframe noembed noframes plaintext noscript".split(" "));
function kb(a,b){"template"===a.localName&&(a=a.content);for(var c="",d=b?b(a):a.childNodes,e=0,f=d.length,g=void 0;e<f&&(g=d[e]);e++){a:{var h=g;var k=a,l=b;switch(h.nodeType){case Node.ELEMENT_NODE:k=h.localName;for(var m="<"+k,q=h.attributes,x=0,M;M=q[x];x++)m+=" "+M.name+'="'+M.value.replace(eb,gb)+'"';m+=">";h=ib[k]?m:m+kb(h,l)+"</"+k+">";break a;case Node.TEXT_NODE:h=h.data;h=k&&jb[k.localName]?h:h.replace(fb,gb);break a;case Node.COMMENT_NODE:h="\x3c!--"+h.data+"--\x3e";break a;default:throw window.console.error(h),
Error("not implemented");}}c+=h}return c};var pb=w.m,qb={querySelector:function(a){return this.__shady_native_querySelector(a)},querySelectorAll:function(a){return this.__shady_native_querySelectorAll(a)}},rb={};function sb(a){rb[a]=function(b){return b["__shady_native_"+a]}}function tb(a,b){A(a,b,"__shady_native_");for(var c in b)sb(c)}function D(a,b){b=void 0===b?[]:b;for(var c=0;c<b.length;c++){var d=b[c],e=Object.getOwnPropertyDescriptor(a,d);e&&(Object.defineProperty(a,"__shady_native_"+d,e),e.value?qb[d]||(qb[d]=e.value):sb(d))}}
var E=document.createTreeWalker(document,NodeFilter.SHOW_ALL,null,!1),F=document.createTreeWalker(document,NodeFilter.SHOW_ELEMENT,null,!1),ub=document.implementation.createHTMLDocument("inert");function vb(a){for(var b;b=a.__shady_native_firstChild;)a.__shady_native_removeChild(b)}var wb=["firstElementChild","lastElementChild","children","childElementCount"],xb=["querySelector","querySelectorAll"];
function yb(){var a=["dispatchEvent","addEventListener","removeEventListener"];window.EventTarget?D(window.EventTarget.prototype,a):(D(Node.prototype,a),D(Window.prototype,a));pb?D(Node.prototype,"parentNode firstChild lastChild previousSibling nextSibling childNodes parentElement textContent".split(" ")):tb(Node.prototype,{parentNode:{get:function(){E.currentNode=this;return E.parentNode()}},firstChild:{get:function(){E.currentNode=this;return E.firstChild()}},lastChild:{get:function(){E.currentNode=
this;return E.lastChild()}},previousSibling:{get:function(){E.currentNode=this;return E.previousSibling()}},nextSibling:{get:function(){E.currentNode=this;return E.nextSibling()}},childNodes:{get:function(){var a=[];E.currentNode=this;for(var c=E.firstChild();c;)a.push(c),c=E.nextSibling();return a}},parentElement:{get:function(){F.currentNode=this;return F.parentNode()}},textContent:{get:function(){switch(this.nodeType){case Node.ELEMENT_NODE:case Node.DOCUMENT_FRAGMENT_NODE:for(var a=document.createTreeWalker(this,
NodeFilter.SHOW_TEXT,null,!1),c="",d;d=a.nextNode();)c+=d.nodeValue;return c;default:return this.nodeValue}},set:function(a){if("undefined"===typeof a||null===a)a="";switch(this.nodeType){case Node.ELEMENT_NODE:case Node.DOCUMENT_FRAGMENT_NODE:vb(this);(0<a.length||this.nodeType===Node.ELEMENT_NODE)&&this.__shady_native_insertBefore(document.createTextNode(a),void 0);break;default:this.nodeValue=a}}}});D(Node.prototype,"appendChild insertBefore removeChild replaceChild cloneNode contains".split(" "));
a={firstElementChild:{get:function(){F.currentNode=this;return F.firstChild()}},lastElementChild:{get:function(){F.currentNode=this;return F.lastChild()}},children:{get:function(){var a=[];F.currentNode=this;for(var c=F.firstChild();c;)a.push(c),c=F.nextSibling();return Va(a)}},childElementCount:{get:function(){return this.children?this.children.length:0}}};pb?(D(Element.prototype,wb),D(Element.prototype,["previousElementSibling","nextElementSibling","innerHTML"]),Object.getOwnPropertyDescriptor(HTMLElement.prototype,
"children")&&D(HTMLElement.prototype,["children"]),Object.getOwnPropertyDescriptor(HTMLElement.prototype,"innerHTML")&&D(HTMLElement.prototype,["innerHTML"])):(tb(Element.prototype,a),tb(Element.prototype,{previousElementSibling:{get:function(){F.currentNode=this;return F.previousSibling()}},nextElementSibling:{get:function(){F.currentNode=this;return F.nextSibling()}},innerHTML:{get:function(){return kb(this,function(a){return a.__shady_native_childNodes})},set:function(a){var b="template"===this.localName?
this.content:this;vb(b);var d=this.localName||"div";d=this.namespaceURI&&this.namespaceURI!==ub.namespaceURI?ub.createElementNS(this.namespaceURI,d):ub.createElement(d);d.innerHTML=a;for(a="template"===this.localName?d.content:d;d=a.__shady_native_firstChild;)b.__shady_native_insertBefore(d,void 0)}}}));D(Element.prototype,"setAttribute getAttribute hasAttribute removeAttribute focus blur".split(" "));D(Element.prototype,xb);D(HTMLElement.prototype,["focus","blur","contains"]);pb&&D(HTMLElement.prototype,
["parentElement","children","innerHTML"]);window.HTMLTemplateElement&&D(window.HTMLTemplateElement.prototype,["innerHTML"]);pb?D(DocumentFragment.prototype,wb):tb(DocumentFragment.prototype,a);D(DocumentFragment.prototype,xb);pb?(D(Document.prototype,wb),D(Document.prototype,["activeElement"])):tb(Document.prototype,a);D(Document.prototype,["importNode","getElementById"]);D(Document.prototype,xb)};var zb=B({get childNodes(){return this.__shady_childNodes},get firstChild(){return this.__shady_firstChild},get lastChild(){return this.__shady_lastChild},get textContent(){return this.__shady_textContent},set textContent(a){this.__shady_textContent=a},get childElementCount(){return this.__shady_childElementCount},get children(){return this.__shady_children},get firstElementChild(){return this.__shady_firstElementChild},get lastElementChild(){return this.__shady_lastElementChild},get innerHTML(){return this.__shady_innerHTML},
set innerHTML(a){return this.__shady_innerHTML=a},get shadowRoot(){return this.__shady_shadowRoot}}),Ab=B({get parentElement(){return this.__shady_parentElement},get parentNode(){return this.__shady_parentNode},get nextSibling(){return this.__shady_nextSibling},get previousSibling(){return this.__shady_previousSibling},get nextElementSibling(){return this.__shady_nextElementSibling},get previousElementSibling(){return this.__shady_previousElementSibling},get className(){return this.__shady_className},
set className(a){return this.__shady_className=a}}),Bb;for(Bb in zb)zb[Bb].enumerable=!1;for(var Cb in Ab)Ab[Cb].enumerable=!1;var Db=w.m||w.J,Eb=Db?function(){}:function(a){var b=u(a);b.la||(b.la=!0,A(a,Ab))},Fb=Db?function(){}:function(a){var b=u(a);b.ka||(b.ka=!0,A(a,zb))};var Gb="__eventWrappers"+Date.now(),Hb=function(){var a=Object.getOwnPropertyDescriptor(Event.prototype,"composed");return a?function(b){return a.get.call(b)}:null}(),Ib={blur:!0,focus:!0,focusin:!0,focusout:!0,click:!0,dblclick:!0,mousedown:!0,mouseenter:!0,mouseleave:!0,mousemove:!0,mouseout:!0,mouseover:!0,mouseup:!0,wheel:!0,beforeinput:!0,input:!0,keydown:!0,keyup:!0,compositionstart:!0,compositionupdate:!0,compositionend:!0,touchstart:!0,touchend:!0,touchmove:!0,touchcancel:!0,pointerover:!0,
pointerenter:!0,pointerdown:!0,pointermove:!0,pointerup:!0,pointercancel:!0,pointerout:!0,pointerleave:!0,gotpointercapture:!0,lostpointercapture:!0,dragstart:!0,drag:!0,dragenter:!0,dragleave:!0,dragover:!0,drop:!0,dragend:!0,DOMActivate:!0,DOMFocusIn:!0,DOMFocusOut:!0,keypress:!0},Jb={DOMAttrModified:!0,DOMAttributeNameChanged:!0,DOMCharacterDataModified:!0,DOMElementNameChanged:!0,DOMNodeInserted:!0,DOMNodeInsertedIntoDocument:!0,DOMNodeRemoved:!0,DOMNodeRemovedFromDocument:!0,DOMSubtreeModified:!0};
function Kb(a){return a instanceof Node?a.__shady_getRootNode():a}function Lb(a,b){var c=[],d=a;for(a=Kb(a);d;)c.push(d),d.__shady_assignedSlot?d=d.__shady_assignedSlot:d.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&d.host&&(b||d!==a)?d=d.host:d=d.__shady_parentNode;c[c.length-1]===document&&c.push(window);return c}function Mb(a){a.__composedPath||(a.__composedPath=Lb(a.target,!0));return a.__composedPath}
function Nb(a,b){if(!z)return a;a=Lb(a,!0);for(var c=0,d,e=void 0,f,g=void 0;c<b.length;c++)if(d=b[c],f=Kb(d),f!==e&&(g=a.indexOf(f),e=f),!z(f)||-1<g)return d}function Ob(a){function b(b,d){b=new a(b,d);b.__composed=d&&!!d.composed;return b}b.__proto__=a;b.prototype=a.prototype;return b}var Pb={focus:!0,blur:!0};function Qb(a){return a.__target!==a.target||a.__relatedTarget!==a.relatedTarget}
function Rb(a,b,c){if(c=b.__handlers&&b.__handlers[a.type]&&b.__handlers[a.type][c])for(var d=0,e;(e=c[d])&&(!Qb(a)||a.target!==a.relatedTarget)&&(e.call(b,a),!a.__immediatePropagationStopped);d++);}
function Sb(a){var b=a.composedPath();Object.defineProperty(a,"currentTarget",{get:function(){return d},configurable:!0});for(var c=b.length-1;0<=c;c--){var d=b[c];Rb(a,d,"capture");if(a.Z)return}Object.defineProperty(a,"eventPhase",{get:function(){return Event.AT_TARGET}});var e;for(c=0;c<b.length;c++){d=b[c];var f=v(d);f=f&&f.root;if(0===c||f&&f===e)if(Rb(a,d,"bubble"),d!==window&&(e=d.__shady_getRootNode()),a.Z)break}}
function Tb(a,b,c,d,e,f){for(var g=0;g<a.length;g++){var h=a[g],k=h.type,l=h.capture,m=h.once,q=h.passive;if(b===h.node&&c===k&&d===l&&e===m&&f===q)return g}return-1}
function Ub(a,b,c){if(b){var d=typeof b;if("function"===d||"object"===d)if("object"!==d||b.handleEvent&&"function"===typeof b.handleEvent){if(Jb[a])return this.__shady_native_addEventListener(a,b,c);if(c&&"object"===typeof c){var e=!!c.capture;var f=!!c.once;var g=!!c.passive}else e=!!c,g=f=!1;var h=c&&c.$||this,k=b[Gb];if(k){if(-1<Tb(k,h,a,e,f,g))return}else b[Gb]=[];k=function(e){f&&this.__shady_removeEventListener(a,b,c);e.__target||Vb(e);if(h!==this){var g=Object.getOwnPropertyDescriptor(e,"currentTarget");
Object.defineProperty(e,"currentTarget",{get:function(){return h},configurable:!0})}e.__previousCurrentTarget=e.currentTarget;if(!z(h)||-1!=e.composedPath().indexOf(h))if(e.composed||-1<e.composedPath().indexOf(h))if(Qb(e)&&e.target===e.relatedTarget)e.eventPhase===Event.BUBBLING_PHASE&&e.stopImmediatePropagation();else if(e.eventPhase===Event.CAPTURING_PHASE||e.bubbles||e.target===h||h instanceof Window){var k="function"===d?b.call(h,e):b.handleEvent&&b.handleEvent(e);h!==this&&(g?(Object.defineProperty(e,
"currentTarget",g),g=null):delete e.currentTarget);return k}};b[Gb].push({node:h,type:a,capture:e,once:f,passive:g,Ya:k});Pb[a]?(this.__handlers=this.__handlers||{},this.__handlers[a]=this.__handlers[a]||{capture:[],bubble:[]},this.__handlers[a][e?"capture":"bubble"].push(k)):this.__shady_native_addEventListener(a,k,c)}}}
function Wb(a,b,c){if(b){if(Jb[a])return this.__shady_native_removeEventListener(a,b,c);if(c&&"object"===typeof c){var d=!!c.capture;var e=!!c.once;var f=!!c.passive}else d=!!c,f=e=!1;var g=c&&c.$||this,h=void 0;var k=null;try{k=b[Gb]}catch(l){}k&&(e=Tb(k,g,a,d,e,f),-1<e&&(h=k.splice(e,1)[0].Ya,k.length||(b[Gb]=void 0)));this.__shady_native_removeEventListener(a,h||b,c);h&&Pb[a]&&this.__handlers&&this.__handlers[a]&&(a=this.__handlers[a][d?"capture":"bubble"],h=a.indexOf(h),-1<h&&a.splice(h,1))}}
function Xb(){for(var a in Pb)window.__shady_native_addEventListener(a,function(a){a.__target||(Vb(a),Sb(a))},!0)}
var Yb=B({get composed(){void 0===this.__composed&&(Hb?this.__composed="focusin"===this.type||"focusout"===this.type||Hb(this):!1!==this.isTrusted&&(this.__composed=Ib[this.type]));return this.__composed||!1},composedPath:function(){this.__composedPath||(this.__composedPath=Lb(this.__target,this.composed));return this.__composedPath},get target(){return Nb(this.currentTarget||this.__previousCurrentTarget,this.composedPath())},get relatedTarget(){if(!this.__relatedTarget)return null;this.__relatedTargetComposedPath||
(this.__relatedTargetComposedPath=Lb(this.__relatedTarget,!0));return Nb(this.currentTarget||this.__previousCurrentTarget,this.__relatedTargetComposedPath)},stopPropagation:function(){Event.prototype.stopPropagation.call(this);this.Z=!0},stopImmediatePropagation:function(){Event.prototype.stopImmediatePropagation.call(this);this.Z=this.__immediatePropagationStopped=!0}});
function Vb(a){a.__target=a.target;a.__relatedTarget=a.relatedTarget;if(w.m){var b=Object.getPrototypeOf(a);if(!Object.hasOwnProperty(b,"__shady_patchedProto")){var c=Object.create(b);c.__shady_sourceProto=b;A(c,Yb);b.__shady_patchedProto=c}a.__proto__=b.__shady_patchedProto}else A(a,Yb)}var Zb=Ob(Event),$b=Ob(CustomEvent),ac=Ob(MouseEvent);
function bc(){if(!Hb&&Object.getOwnPropertyDescriptor(Event.prototype,"isTrusted")){var a=function(){var a=new MouseEvent("click",{bubbles:!0,cancelable:!0,composed:!0});this.__shady_dispatchEvent(a)};Element.prototype.click?Element.prototype.click=a:HTMLElement.prototype.click&&(HTMLElement.prototype.click=a)}}var cc=Object.getOwnPropertyNames(Document.prototype).filter(function(a){return"on"===a.substring(0,2)});function dc(a,b){return{index:a,L:[],R:b}}
function ec(a,b,c,d){var e=0,f=0,g=0,h=0,k=Math.min(b-e,d-f);if(0==e&&0==f)a:{for(g=0;g<k;g++)if(a[g]!==c[g])break a;g=k}if(b==a.length&&d==c.length){h=a.length;for(var l=c.length,m=0;m<k-g&&fc(a[--h],c[--l]);)m++;h=m}e+=g;f+=g;b-=h;d-=h;if(0==b-e&&0==d-f)return[];if(e==b){for(b=dc(e,0);f<d;)b.L.push(c[f++]);return[b]}if(f==d)return[dc(e,b-e)];k=e;g=f;d=d-g+1;h=b-k+1;b=Array(d);for(l=0;l<d;l++)b[l]=Array(h),b[l][0]=l;for(l=0;l<h;l++)b[0][l]=l;for(l=1;l<d;l++)for(m=1;m<h;m++)if(a[k+m-1]===c[g+l-1])b[l][m]=
b[l-1][m-1];else{var q=b[l-1][m]+1,x=b[l][m-1]+1;b[l][m]=q<x?q:x}k=b.length-1;g=b[0].length-1;d=b[k][g];for(a=[];0<k||0<g;)0==k?(a.push(2),g--):0==g?(a.push(3),k--):(h=b[k-1][g-1],l=b[k-1][g],m=b[k][g-1],q=l<m?l<h?l:h:m<h?m:h,q==h?(h==d?a.push(0):(a.push(1),d=h),k--,g--):q==l?(a.push(3),k--,d=l):(a.push(2),g--,d=m));a.reverse();b=void 0;k=[];for(g=0;g<a.length;g++)switch(a[g]){case 0:b&&(k.push(b),b=void 0);e++;f++;break;case 1:b||(b=dc(e,0));b.R++;e++;b.L.push(c[f]);f++;break;case 2:b||(b=dc(e,0));
b.R++;e++;break;case 3:b||(b=dc(e,0)),b.L.push(c[f]),f++}b&&k.push(b);return k}function fc(a,b){return a===b};function gc(a,b,c){Eb(a);c=c||null;var d=u(a),e=u(b),f=c?u(c):null;d.previousSibling=c?f.previousSibling:b.__shady_lastChild;if(f=v(d.previousSibling))f.nextSibling=a;if(f=v(d.nextSibling=c))f.previousSibling=a;d.parentNode=b;c?c===e.firstChild&&(e.firstChild=a):(e.lastChild=a,e.firstChild||(e.firstChild=a));e.childNodes=null}
function hc(a,b,c){Fb(b);var d=u(b);void 0!==d.firstChild&&(d.childNodes=null);if(a.nodeType===Node.DOCUMENT_FRAGMENT_NODE){d=a.__shady_childNodes;for(var e=0;e<d.length;e++)gc(d[e],b,c);a=u(a);b=void 0!==a.firstChild?null:void 0;a.firstChild=a.lastChild=b;a.childNodes=b}else gc(a,b,c)}
function ic(a,b){var c=u(a);b=u(b);a===b.firstChild&&(b.firstChild=c.nextSibling);a===b.lastChild&&(b.lastChild=c.previousSibling);a=c.previousSibling;var d=c.nextSibling;a&&(u(a).nextSibling=d);d&&(u(d).previousSibling=a);c.parentNode=c.previousSibling=c.nextSibling=void 0;void 0!==b.childNodes&&(b.childNodes=null)}
function jc(a){var b=u(a);if(void 0===b.firstChild){b.childNodes=null;var c=b.firstChild=a.__shady_native_firstChild||null;b.lastChild=a.__shady_native_lastChild||null;Fb(a);b=c;for(c=void 0;b;b=b.__shady_native_nextSibling){var d=u(b);d.parentNode=a;d.nextSibling=b.__shady_native_nextSibling||null;d.previousSibling=c||null;c=b;Eb(b)}}};var kc=null;function G(){kc||(kc=window.ShadyCSS&&window.ShadyCSS.ScopingShim);return kc||null}function lc(a,b){var c=G();c&&c.unscopeNode(a,b)}function mc(a,b){var c=G();if(!c)return!0;if(a.nodeType===Node.DOCUMENT_FRAGMENT_NODE){c=!0;a=a.__shady_childNodes;for(var d=0;c&&d<a.length;d++)c=c&&mc(a[d],b);return c}return a.nodeType!==Node.ELEMENT_NODE?!0:c.currentScopeForNode(a)===b}function nc(a){if(a.nodeType!==Node.ELEMENT_NODE)return"";var b=G();return b?b.currentScopeForNode(a):""}
function oc(a,b){if(a){a.nodeType===Node.ELEMENT_NODE&&b(a);a=a.__shady_childNodes;for(var c=0,d;c<a.length;c++)d=a[c],d.nodeType===Node.ELEMENT_NODE&&oc(d,b)}};var pc=window.document,qc=w.oa,rc=Object.getOwnPropertyDescriptor(Node.prototype,"isConnected"),sc=rc&&rc.get;function tc(a){for(var b;b=a.__shady_firstChild;)a.__shady_removeChild(b)}function uc(a){var b=v(a);if(b&&void 0!==b.K){b=a.__shady_childNodes;for(var c=0,d=b.length,e=void 0;c<d&&(e=b[c]);c++)uc(e)}if(a=v(a))a.K=void 0}function vc(a){var b=a;a&&"slot"===a.localName&&(b=(b=(b=v(a))&&b.D)&&b.length?b[0]:vc(a.__shady_nextSibling));return b}
function wc(a,b,c){if(a=(a=v(a))&&a.H)b&&a.addedNodes.push(b),c&&a.removedNodes.push(c),ab(a)}
var Cc=B({get parentNode(){var a=v(this);a=a&&a.parentNode;return void 0!==a?a:this.__shady_native_parentNode},get firstChild(){var a=v(this);a=a&&a.firstChild;return void 0!==a?a:this.__shady_native_firstChild},get lastChild(){var a=v(this);a=a&&a.lastChild;return void 0!==a?a:this.__shady_native_lastChild},get nextSibling(){var a=v(this);a=a&&a.nextSibling;return void 0!==a?a:this.__shady_native_nextSibling},get previousSibling(){var a=v(this);a=a&&a.previousSibling;return void 0!==a?a:this.__shady_native_previousSibling},
get childNodes(){if(y(this)){var a=v(this);if(!a.childNodes){a.childNodes=[];for(var b=this.__shady_firstChild;b;b=b.__shady_nextSibling)a.childNodes.push(b)}var c=a.childNodes}else c=this.__shady_native_childNodes;c.item=function(a){return c[a]};return c},get parentElement(){var a=v(this);(a=a&&a.parentNode)&&a.nodeType!==Node.ELEMENT_NODE&&(a=null);return void 0!==a?a:this.__shady_native_parentElement},get isConnected(){if(sc&&sc.call(this))return!0;if(this.nodeType==Node.DOCUMENT_FRAGMENT_NODE)return!1;
var a=this.ownerDocument;if(Ta){if(a.__shady_native_contains(this))return!0}else if(a.documentElement&&a.documentElement.__shady_native_contains(this))return!0;for(a=this;a&&!(a instanceof Document);)a=a.__shady_parentNode||(z(a)?a.host:void 0);return!!(a&&a instanceof Document)},get textContent(){if(y(this)){for(var a=[],b=0,c=this.__shady_childNodes,d;d=c[b];b++)d.nodeType!==Node.COMMENT_NODE&&a.push(d.__shady_textContent);return a.join("")}return this.__shady_native_textContent},set textContent(a){if("undefined"===
typeof a||null===a)a="";switch(this.nodeType){case Node.ELEMENT_NODE:case Node.DOCUMENT_FRAGMENT_NODE:if(!y(this)&&w.m){var b=this.__shady_firstChild;(b!=this.__shady_lastChild||b&&b.nodeType!=Node.TEXT_NODE)&&tc(this);this.__shady_native_textContent=a}else tc(this),(0<a.length||this.nodeType===Node.ELEMENT_NODE)&&this.__shady_insertBefore(document.createTextNode(a));break;default:this.nodeValue=a}},insertBefore:function(a,b){if(this.ownerDocument!==pc&&a.ownerDocument!==pc)return this.__shady_native_insertBefore(a,
b),a;if(a===this)throw Error("Failed to execute 'appendChild' on 'Node': The new child element contains the parent.");if(b){var c=v(b);c=c&&c.parentNode;if(void 0!==c&&c!==this||void 0===c&&b.__shady_native_parentNode!==this)throw Error("Failed to execute 'insertBefore' on 'Node': The node before which the new node is to be inserted is not a child of this node.");}if(b===a)return a;var d=[],e=(c=xc(this))?c.host.localName:nc(this),f=a.__shady_parentNode;if(f){var g=nc(a);f.__shady_removeChild(a,!!c||
!xc(a))}f=!0;var h=(!qc||void 0===a.__noInsertionPoint)&&!mc(a,e),k=c&&!a.__noInsertionPoint&&(!qc||a.nodeType===Node.DOCUMENT_FRAGMENT_NODE);if(k||h)h&&(g=g||nc(a)),oc(a,function(a){k&&"slot"===a.localName&&d.push(a);if(h){var b=g;G()&&(b&&lc(a,b),(b=G())&&b.scopeNode(a,e))}});if("slot"===this.localName||d.length)d.length&&(c.c=c.c||[],c.a=c.a||[],c.b=c.b||{},c.c.push.apply(c.c,d instanceof Array?d:ja(ia(d)))),c&&Ac(c);y(this)&&(hc(a,this,b),c=v(this),La(this)?(Ac(c.root),f=!1):c.root&&(f=!1));f?
(c=z(this)?this.host:this,b?(b=vc(b),c.__shady_native_insertBefore(a,b)):c.__shady_native_appendChild(a)):a.ownerDocument!==this.ownerDocument&&this.ownerDocument.adoptNode(a);wc(this,a);return a},appendChild:function(a){return this.__shady_insertBefore(a)},removeChild:function(a,b){b=void 0===b?!1:b;if(this.ownerDocument!==pc)return this.__shady_native_removeChild(a);if(a.__shady_parentNode!==this)throw Error("The node to be removed is not a child of this node: "+a);var c=xc(a),d=c&&Bc(c,a),e=v(this);
if(y(this)&&(ic(a,this),La(this))){Ac(e.root);var f=!0}if(G()&&!b&&c){var g=nc(a);oc(a,function(a){lc(a,g)})}uc(a);c&&((b=this&&"slot"===this.localName)&&(f=!0),(d||b)&&Ac(c));f||(f=z(this)?this.host:this,(!e.root&&"slot"!==a.localName||f===a.__shady_native_parentNode)&&f.__shady_native_removeChild(a));wc(this,null,a);return a},replaceChild:function(a,b){this.__shady_insertBefore(a,b);this.__shady_removeChild(b);return a},cloneNode:function(a){if("template"==this.localName)return this.__shady_native_cloneNode(a);
var b=this.__shady_native_cloneNode(!1);if(a&&b.nodeType!==Node.ATTRIBUTE_NODE){a=this.__shady_childNodes;for(var c=0,d;c<a.length;c++)d=a[c].__shady_cloneNode(!0),b.__shady_appendChild(d)}return b},getRootNode:function(a){if(this&&this.nodeType){var b=u(this),c=b.K;void 0===c&&(z(this)?(c=this,b.K=c):(c=(c=this.__shady_parentNode)?c.__shady_getRootNode(a):this,document.documentElement.__shady_native_contains(this)&&(b.K=c)));return c}},contains:function(a){return Ua(this,a)}});function Dc(a,b,c){var d=[];Ec(a.__shady_childNodes,b,c,d);return d}function Ec(a,b,c,d){for(var e=0,f=a.length,g=void 0;e<f&&(g=a[e]);e++){var h;if(h=g.nodeType===Node.ELEMENT_NODE){h=g;var k=b,l=c,m=d,q=k(h);q&&m.push(h);l&&l(q)?h=q:(Ec(h.__shady_childNodes,k,l,m),h=void 0)}if(h)break}}
var Fc=B({get firstElementChild(){var a=v(this);if(a&&void 0!==a.firstChild){for(a=this.__shady_firstChild;a&&a.nodeType!==Node.ELEMENT_NODE;)a=a.__shady_nextSibling;return a}return this.__shady_native_firstElementChild},get lastElementChild(){var a=v(this);if(a&&void 0!==a.lastChild){for(a=this.__shady_lastChild;a&&a.nodeType!==Node.ELEMENT_NODE;)a=a.__shady_previousSibling;return a}return this.__shady_native_lastElementChild},get children(){return y(this)?Va(Array.prototype.filter.call(this.__shady_childNodes,
function(a){return a.nodeType===Node.ELEMENT_NODE})):this.__shady_native_children},get childElementCount(){var a=this.__shady_children;return a?a.length:0}}),Gc=B({querySelector:function(a){return Dc(this,function(b){return Oa.call(b,a)},function(a){return!!a})[0]||null},querySelectorAll:function(a,b){if(b){b=Array.prototype.slice.call(this.__shady_native_querySelectorAll(a));var c=this.__shady_getRootNode();return b.filter(function(a){return a.__shady_getRootNode()==c})}return Dc(this,function(b){return Oa.call(b,
a)})}}),Hc=w.oa?Object.assign({},Fc):Fc;Object.assign(Fc,Gc);var Ic=B({getElementById:function(a){return""===a?null:Dc(this,function(b){return b.id==a},function(a){return!!a})[0]||null}});var Jc=B({get activeElement(){var a=w.m?document.__shady_native_activeElement:document.activeElement;if(!a||!a.nodeType)return null;var b=!!z(this);if(!(this===document||b&&this.host!==a&&this.host.__shady_native_contains(a)))return null;for(b=xc(a);b&&b!==this;)a=b.host,b=xc(a);return this===document?b?null:a:b===this?a:null}});var Kc=document.implementation.createHTMLDocument("inert"),Lc=B({get innerHTML(){return y(this)?kb("template"===this.localName?this.content:this,function(a){return a.__shady_childNodes}):this.__shady_native_innerHTML},set innerHTML(a){if("template"===this.localName)this.__shady_native_innerHTML=a;else{tc(this);var b=this.localName||"div";b=this.namespaceURI&&this.namespaceURI!==Kc.namespaceURI?Kc.createElementNS(this.namespaceURI,b):Kc.createElement(b);for(w.m?b.__shady_native_innerHTML=a:b.innerHTML=
a;a=b.__shady_firstChild;)this.__shady_insertBefore(a)}}});var Mc=B({addEventListener:function(a,b,c){"object"!==typeof c&&(c={capture:!!c});c.$=this;this.host.__shady_addEventListener(a,b,c)},removeEventListener:function(a,b,c){"object"!==typeof c&&(c={capture:!!c});c.$=this;this.host.__shady_removeEventListener(a,b,c)}});function Nc(a,b){A(a,Mc,b);A(a,Jc,b);A(a,Lc,b);A(a,Fc,b);w.J&&!b?(A(a,Cc,b),A(a,Ic,b)):w.m||(A(a,Ab),A(a,zb))};var Oc={},Pc=w.deferConnectionCallbacks&&"loading"===document.readyState,Qc;function Rc(a){var b=[];do b.unshift(a);while(a=a.__shady_parentNode);return b}
function Sc(a,b,c){if(a!==Oc)throw new TypeError("Illegal constructor");this.za="ShadyRoot";this.host=b;this.mode=c&&c.mode;jc(b);a=u(b);a.root=this;a.pa="closed"!==this.mode?this:null;a=u(this);a.firstChild=a.lastChild=a.parentNode=a.nextSibling=a.previousSibling=null;a.childNodes=[];this.ba=this.B=!1;this.c=this.b=this.a=null;if(w.preferPerformance)for(;a=b.__shady_native_firstChild;)b.__shady_native_removeChild(a);else Ac(this)}function Ac(a){a.B||(a.B=!0,Ya(function(){return Tc(a)}))}
function Tc(a){var b;if(b=a.B){for(var c;a;)a:{a.B&&(c=a),b=a;a=b.host.__shady_getRootNode();if(z(a)&&(b=v(b.host))&&0<b.N)break a;a=void 0}b=c}(c=b)&&c._renderSelf()}
Sc.prototype._renderSelf=function(){var a=Pc;Pc=!0;this.B=!1;if(this.a){Uc(this);for(var b=0,c;b<this.a.length;b++){c=this.a[b];var d=v(c),e=d.assignedNodes;d.assignedNodes=[];d.D=[];if(d.ca=e)for(d=0;d<e.length;d++){var f=v(e[d]);f.P=f.assignedSlot;f.assignedSlot===c&&(f.assignedSlot=null)}}for(b=this.host.__shady_firstChild;b;b=b.__shady_nextSibling)Vc(this,b);for(b=0;b<this.a.length;b++){c=this.a[b];e=v(c);if(!e.assignedNodes.length)for(d=c.__shady_firstChild;d;d=d.__shady_nextSibling)Vc(this,
d,c);(d=(d=v(c.__shady_parentNode))&&d.root)&&(Ma(d)||d.B)&&d._renderSelf();Wc(this,e.D,e.assignedNodes);if(d=e.ca){for(f=0;f<d.length;f++)v(d[f]).P=null;e.ca=null;d.length>e.assignedNodes.length&&(e.T=!0)}e.T&&(e.T=!1,Xc(this,c))}c=this.a;b=[];for(e=0;e<c.length;e++)d=c[e].__shady_parentNode,(f=v(d))&&f.root||!(0>b.indexOf(d))||b.push(d);for(c=0;c<b.length;c++){f=b[c];e=f===this?this.host:f;d=[];f=f.__shady_childNodes;for(var g=0;g<f.length;g++){var h=f[g];if("slot"==h.localName){h=v(h).D;for(var k=
0;k<h.length;k++)d.push(h[k])}else d.push(h)}f=Array.prototype.slice.call(e.__shady_native_childNodes);g=ec(d,d.length,f,f.length);k=h=0;for(var l=void 0;h<g.length&&(l=g[h]);h++){for(var m=0,q=void 0;m<l.L.length&&(q=l.L[m]);m++)q.__shady_native_parentNode===e&&e.__shady_native_removeChild(q),f.splice(l.index+k,1);k-=l.R}k=0;for(l=void 0;k<g.length&&(l=g[k]);k++)for(h=f[l.index],m=l.index;m<l.index+l.R;m++)q=d[m],e.__shady_native_insertBefore(q,h),f.splice(m,0,q)}}if(!w.preferPerformance&&!this.ba)for(b=
this.host.__shady_childNodes,c=0,e=b.length;c<e;c++)d=b[c],f=v(d),d.__shady_native_parentNode!==this.host||"slot"!==d.localName&&f.assignedSlot||this.host.__shady_native_removeChild(d);this.ba=!0;Pc=a;Qc&&Qc()};function Vc(a,b,c){var d=u(b),e=d.P;d.P=null;c||(c=(a=a.b[b.__shady_slot||"__catchall"])&&a[0]);c?(u(c).assignedNodes.push(b),d.assignedSlot=c):d.assignedSlot=void 0;e!==d.assignedSlot&&d.assignedSlot&&(u(d.assignedSlot).T=!0)}
function Wc(a,b,c){for(var d=0,e=void 0;d<c.length&&(e=c[d]);d++)if("slot"==e.localName){var f=v(e).assignedNodes;f&&f.length&&Wc(a,b,f)}else b.push(c[d])}function Xc(a,b){b.__shady_native_dispatchEvent(new Event("slotchange"));b=v(b);b.assignedSlot&&Xc(a,b.assignedSlot)}
function Uc(a){if(a.c&&a.c.length){for(var b=a.c,c,d=0;d<b.length;d++){var e=b[d];jc(e);var f=e.__shady_parentNode;jc(f);f=v(f);f.N=(f.N||0)+1;f=Yc(e);a.b[f]?(c=c||{},c[f]=!0,a.b[f].push(e)):a.b[f]=[e];a.a.push(e)}if(c)for(var g in c)a.b[g]=Zc(a.b[g]);a.c=[]}}function Yc(a){var b=a.name||a.getAttribute("name")||"__catchall";return a.wa=b}
function Zc(a){return a.sort(function(a,c){a=Rc(a);for(var b=Rc(c),e=0;e<a.length;e++){c=a[e];var f=b[e];if(c!==f)return a=Array.from(c.__shady_parentNode.__shady_childNodes),a.indexOf(c)-a.indexOf(f)}})}
function Bc(a,b){if(a.a){Uc(a);var c=a.b,d;for(d in c)for(var e=c[d],f=0;f<e.length;f++){var g=e[f];if(Ua(b,g)){e.splice(f,1);var h=a.a.indexOf(g);0<=h&&(a.a.splice(h,1),(h=v(g.__shady_parentNode))&&h.N&&h.N--);f--;g=v(g);if(h=g.D)for(var k=0;k<h.length;k++){var l=h[k],m=l.__shady_native_parentNode;m&&m.__shady_native_removeChild(l)}g.D=[];g.assignedNodes=[];h=!0}}return h}}function Ma(a){Uc(a);return!(!a.a||!a.a.length)}
(function(a){a.__proto__=DocumentFragment.prototype;Nc(a,"__shady_");Nc(a);Object.defineProperties(a,{nodeType:{value:Node.DOCUMENT_FRAGMENT_NODE,configurable:!0},nodeName:{value:"#document-fragment",configurable:!0},nodeValue:{value:null,configurable:!0}});["localName","namespaceURI","prefix"].forEach(function(b){Object.defineProperty(a,b,{value:void 0,configurable:!0})});["ownerDocument","baseURI","isConnected"].forEach(function(b){Object.defineProperty(a,b,{get:function(){return this.host[b]},
configurable:!0})})})(Sc.prototype);
if(window.customElements&&w.ea&&!w.preferPerformance){var $c=new Map;Qc=function(){var a=[];$c.forEach(function(b,c){a.push([c,b])});$c.clear();for(var b=0;b<a.length;b++){var c=a[b][0];a[b][1]?c.ua():c.va()}};Pc&&document.addEventListener("readystatechange",function(){Pc=!1;Qc()},{once:!0});var ad=function(a,b,c){var d=0,e="__isConnected"+d++;if(b||c)a.prototype.connectedCallback=a.prototype.ua=function(){Pc?$c.set(this,!0):this[e]||(this[e]=!0,b&&b.call(this))},a.prototype.disconnectedCallback=
a.prototype.va=function(){Pc?this.isConnected||$c.set(this,!1):this[e]&&(this[e]=!1,c&&c.call(this))};return a},bd=window.customElements.define;Object.defineProperty(window.CustomElementRegistry.prototype,"define",{value:function(a,b){var c=b.prototype.connectedCallback,d=b.prototype.disconnectedCallback;bd.call(window.customElements,a,ad(b,c,d));b.prototype.connectedCallback=c;b.prototype.disconnectedCallback=d}})}function xc(a){a=a.__shady_getRootNode();if(z(a))return a};function cd(a){this.node=a}n=cd.prototype;n.addEventListener=function(a,b,c){return this.node.__shady_addEventListener(a,b,c)};n.removeEventListener=function(a,b,c){return this.node.__shady_removeEventListener(a,b,c)};n.appendChild=function(a){return this.node.__shady_appendChild(a)};n.insertBefore=function(a,b){return this.node.__shady_insertBefore(a,b)};n.removeChild=function(a){return this.node.__shady_removeChild(a)};n.replaceChild=function(a,b){return this.node.__shady_replaceChild(a,b)};
n.cloneNode=function(a){return this.node.__shady_cloneNode(a)};n.getRootNode=function(a){return this.node.__shady_getRootNode(a)};n.contains=function(a){return this.node.__shady_contains(a)};n.dispatchEvent=function(a){return this.node.__shady_dispatchEvent(a)};n.setAttribute=function(a,b){this.node.__shady_setAttribute(a,b)};n.getAttribute=function(a){return this.node.__shady_native_getAttribute(a)};n.hasAttribute=function(a){return this.node.__shady_native_hasAttribute(a)};n.removeAttribute=function(a){this.node.__shady_removeAttribute(a)};
n.attachShadow=function(a){return this.node.__shady_attachShadow(a)};n.focus=function(){this.node.__shady_native_focus()};n.blur=function(){this.node.__shady_blur()};n.importNode=function(a,b){if(this.node.nodeType===Node.DOCUMENT_NODE)return this.node.__shady_importNode(a,b)};n.getElementById=function(a){if(this.node.nodeType===Node.DOCUMENT_NODE)return this.node.__shady_getElementById(a)};n.querySelector=function(a){return this.node.__shady_querySelector(a)};
n.querySelectorAll=function(a,b){return this.node.__shady_querySelectorAll(a,b)};n.assignedNodes=function(a){if("slot"===this.node.localName)return this.node.__shady_assignedNodes(a)};
p.Object.defineProperties(cd.prototype,{activeElement:{configurable:!0,enumerable:!0,get:function(){if(z(this.node)||this.node.nodeType===Node.DOCUMENT_NODE)return this.node.__shady_activeElement}},_activeElement:{configurable:!0,enumerable:!0,get:function(){return this.activeElement}},host:{configurable:!0,enumerable:!0,get:function(){if(z(this.node))return this.node.host}},parentNode:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_parentNode}},firstChild:{configurable:!0,
enumerable:!0,get:function(){return this.node.__shady_firstChild}},lastChild:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_lastChild}},nextSibling:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_nextSibling}},previousSibling:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_previousSibling}},childNodes:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_childNodes}},parentElement:{configurable:!0,enumerable:!0,
get:function(){return this.node.__shady_parentElement}},firstElementChild:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_firstElementChild}},lastElementChild:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_lastElementChild}},nextElementSibling:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_nextElementSibling}},previousElementSibling:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_previousElementSibling}},
children:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_children}},childElementCount:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_childElementCount}},shadowRoot:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_shadowRoot}},assignedSlot:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_assignedSlot}},isConnected:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_isConnected}},innerHTML:{configurable:!0,
enumerable:!0,get:function(){return this.node.__shady_innerHTML},set:function(a){this.node.__shady_innerHTML=a}},textContent:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_textContent},set:function(a){this.node.__shady_textContent=a}},slot:{configurable:!0,enumerable:!0,get:function(){return this.node.__shady_slot},set:function(a){this.node.__shady_slot=a}}});
cc.forEach(function(a){Object.defineProperty(cd.prototype,a,{get:function(){return this.node["__shady_"+a]},set:function(b){this.node["__shady_"+a]=b},configurable:!0})});var dd=new WeakMap;function ed(a){if(z(a)||a instanceof cd)return a;var b=dd.get(a);b||(b=new cd(a),dd.set(a,b));return b};var fd=B({dispatchEvent:function(a){Za();return this.__shady_native_dispatchEvent(a)},addEventListener:Ub,removeEventListener:Wb});var gd=B({get assignedSlot(){var a=this.__shady_parentNode;(a=a&&a.__shady_shadowRoot)&&Tc(a);return(a=v(this))&&a.assignedSlot||null}});var hd=window.document;function id(a,b){if("slot"===b)a=a.__shady_parentNode,La(a)&&Ac(v(a).root);else if("slot"===a.localName&&"name"===b&&(b=xc(a))){if(b.a){Uc(b);var c=a.wa,d=Yc(a);if(d!==c){c=b.b[c];var e=c.indexOf(a);0<=e&&c.splice(e,1);c=b.b[d]||(b.b[d]=[]);c.push(a);1<c.length&&(b.b[d]=Zc(c))}}Ac(b)}}
var jd=B({get previousElementSibling(){var a=v(this);if(a&&void 0!==a.previousSibling){for(a=this.__shady_previousSibling;a&&a.nodeType!==Node.ELEMENT_NODE;)a=a.__shady_previousSibling;return a}return this.__shady_native_previousElementSibling},get nextElementSibling(){var a=v(this);if(a&&void 0!==a.nextSibling){for(a=this.__shady_nextSibling;a&&a.nodeType!==Node.ELEMENT_NODE;)a=a.__shady_nextSibling;return a}return this.__shady_native_nextElementSibling},get slot(){return this.getAttribute("slot")},
set slot(a){this.__shady_setAttribute("slot",a)},get shadowRoot(){var a=v(this);return a&&a.pa||null},get className(){return this.getAttribute("class")||""},set className(a){this.__shady_setAttribute("class",a)},setAttribute:function(a,b){if(this.ownerDocument!==hd)this.__shady_native_setAttribute(a,b);else{var c;(c=G())&&"class"===a?(c.setElementClass(this,b),c=!0):c=!1;c||(this.__shady_native_setAttribute(a,b),id(this,a))}},removeAttribute:function(a){this.__shady_native_removeAttribute(a);id(this,
a)},attachShadow:function(a){if(!this)throw Error("Must provide a host.");if(!a)throw Error("Not enough arguments.");return new Sc(Oc,this,a)}});var kd=B({blur:function(){var a=v(this);(a=(a=a&&a.root)&&a.activeElement)?a.__shady_blur():this.__shady_native_blur()}});cc.forEach(function(a){kd[a]={set:function(b){var c=u(this),d=a.substring(2);c.O[a]&&this.removeEventListener(d,c.O[a]);this.__shady_addEventListener(d,b);c.O[a]=b},get:function(){var b=v(this);return b&&b.O[a]},configurable:!0}});var ld=B({assignedNodes:function(a){if("slot"===this.localName){var b=this.__shady_getRootNode();b&&z(b)&&Tc(b);return(b=v(this))?(a&&a.flatten?b.D:b.assignedNodes)||[]:[]}}});var md=window.document,nd=B({importNode:function(a,b){if(a.ownerDocument!==md||"template"===a.localName)return this.__shady_native_importNode(a,b);var c=this.__shady_native_importNode(a,!1);if(b){a=a.__shady_childNodes;b=0;for(var d;b<a.length;b++)d=this.__shady_importNode(a[b],!0),c.__shady_appendChild(d)}return c}});var od=B({addEventListener:Ub.bind(window),removeEventListener:Wb.bind(window)});var pd={};Object.getOwnPropertyDescriptor(HTMLElement.prototype,"parentElement")&&(pd.parentElement=Cc.parentElement);Object.getOwnPropertyDescriptor(HTMLElement.prototype,"contains")&&(pd.contains=Cc.contains);Object.getOwnPropertyDescriptor(HTMLElement.prototype,"children")&&(pd.children=Fc.children);Object.getOwnPropertyDescriptor(HTMLElement.prototype,"innerHTML")&&(pd.innerHTML=Lc.innerHTML);Object.getOwnPropertyDescriptor(HTMLElement.prototype,"className")&&(pd.className=jd.className);
var qd={EventTarget:[fd],Node:[Cc,window.EventTarget?null:fd],Text:[gd],Element:[jd,Fc,gd,!w.m||"innerHTML"in Element.prototype?Lc:null,window.HTMLSlotElement?null:ld],HTMLElement:[kd,pd],HTMLSlotElement:[ld],DocumentFragment:[Hc,Ic],Document:[nd,Hc,Ic,Jc],Window:[od]},rd=w.m?null:["innerHTML","textContent"];function sd(a){var b=a?null:rd,c={},d;for(d in qd)c.W=window[d]&&window[d].prototype,qd[d].forEach(function(c){return function(d){return c.W&&d&&A(c.W,d,a,b)}}(c)),c={W:c.W}};if(w.ea){var ShadyDOM={inUse:w.ea,patch:function(a){Fb(a);Eb(a);return a},isShadyRoot:z,enqueue:Ya,flush:Za,flushInitial:function(a){!a.ba&&a.B&&Tc(a)},settings:w,filterMutations:db,observeChildren:bb,unobserveChildren:cb,deferConnectionCallbacks:w.deferConnectionCallbacks,preferPerformance:w.preferPerformance,handlesDynamicScoping:!0,wrap:w.J?ed:function(a){return a},Wrapper:cd,composedPath:Mb,noPatch:w.J,nativeMethods:qb,nativeTree:rb};window.ShadyDOM=ShadyDOM;yb();sd("__shady_");Object.defineProperty(document,
"_activeElement",Jc.activeElement);A(Window.prototype,od,"__shady_");w.J||(sd(),bc());Xb();window.Event=Zb;window.CustomEvent=$b;window.MouseEvent=ac;window.ShadowRoot=Sc};var td=new Set("annotation-xml color-profile font-face font-face-src font-face-uri font-face-format font-face-name missing-glyph".split(" "));function ud(a){var b=td.has(a);a=/^[a-z][.0-9_a-z]*-[\-.0-9_a-z]*$/.test(a);return!b&&a}function H(a){var b=a.isConnected;if(void 0!==b)return b;for(;a&&!(a.__CE_isImportDocument||a instanceof Document);)a=a.parentNode||(window.ShadowRoot&&a instanceof ShadowRoot?a.host:void 0);return!(!a||!(a.__CE_isImportDocument||a instanceof Document))}
function vd(a,b){for(;b&&b!==a&&!b.nextSibling;)b=b.parentNode;return b&&b!==a?b.nextSibling:null}
function wd(a,b,c){c=void 0===c?new Set:c;for(var d=a;d;){if(d.nodeType===Node.ELEMENT_NODE){var e=d;b(e);var f=e.localName;if("link"===f&&"import"===e.getAttribute("rel")){d=e.import;if(d instanceof Node&&!c.has(d))for(c.add(d),d=d.firstChild;d;d=d.nextSibling)wd(d,b,c);d=vd(a,e);continue}else if("template"===f){d=vd(a,e);continue}if(e=e.__CE_shadowRoot)for(e=e.firstChild;e;e=e.nextSibling)wd(e,b,c)}d=d.firstChild?d.firstChild:vd(a,d)}}function I(a,b,c){a[b]=c};function xd(){this.a=new Map;this.g=new Map;this.f=[];this.c=!1}function yd(a,b,c){a.a.set(b,c);a.g.set(c.constructorFunction,c)}function zd(a,b){a.c=!0;a.f.push(b)}function Ad(a,b){a.c&&wd(b,function(b){return a.b(b)})}xd.prototype.b=function(a){if(this.c&&!a.__CE_patched){a.__CE_patched=!0;for(var b=0;b<this.f.length;b++)this.f[b](a)}};function J(a,b){var c=[];wd(b,function(a){return c.push(a)});for(b=0;b<c.length;b++){var d=c[b];1===d.__CE_state?a.connectedCallback(d):Bd(a,d)}}
function K(a,b){var c=[];wd(b,function(a){return c.push(a)});for(b=0;b<c.length;b++){var d=c[b];1===d.__CE_state&&a.disconnectedCallback(d)}}
function L(a,b,c){c=void 0===c?{}:c;var d=c.Xa||new Set,e=c.Y||function(b){return Bd(a,b)},f=[];wd(b,function(b){if("link"===b.localName&&"import"===b.getAttribute("rel")){var c=b.import;c instanceof Node&&(c.__CE_isImportDocument=!0,c.__CE_hasRegistry=!0);c&&"complete"===c.readyState?c.__CE_documentLoadHandled=!0:b.addEventListener("load",function(){var c=b.import;if(!c.__CE_documentLoadHandled){c.__CE_documentLoadHandled=!0;var f=new Set(d);f.delete(c);L(a,c,{Xa:f,Y:e})}})}else f.push(b)},d);if(a.c)for(b=
0;b<f.length;b++)a.b(f[b]);for(b=0;b<f.length;b++)e(f[b])}
function Bd(a,b){if(void 0===b.__CE_state){var c=b.ownerDocument;if(c.defaultView||c.__CE_isImportDocument&&c.__CE_hasRegistry)if(c=a.a.get(b.localName)){c.constructionStack.push(b);var d=c.constructorFunction;try{try{if(new d!==b)throw Error("The custom element constructor did not produce the element being upgraded.");}finally{c.constructionStack.pop()}}catch(g){throw b.__CE_state=2,g;}b.__CE_state=1;b.__CE_definition=c;if(c.attributeChangedCallback)for(c=c.observedAttributes,d=0;d<c.length;d++){var e=
c[d],f=b.getAttribute(e);null!==f&&a.attributeChangedCallback(b,e,null,f,null)}H(b)&&a.connectedCallback(b)}}}xd.prototype.connectedCallback=function(a){var b=a.__CE_definition;b.connectedCallback&&b.connectedCallback.call(a)};xd.prototype.disconnectedCallback=function(a){var b=a.__CE_definition;b.disconnectedCallback&&b.disconnectedCallback.call(a)};
xd.prototype.attributeChangedCallback=function(a,b,c,d,e){var f=a.__CE_definition;f.attributeChangedCallback&&-1<f.observedAttributes.indexOf(b)&&f.attributeChangedCallback.call(a,b,c,d,e)};function Cd(a){var b=document;this.b=a;this.a=b;this.F=void 0;L(this.b,this.a);"loading"===this.a.readyState&&(this.F=new MutationObserver(this.c.bind(this)),this.F.observe(this.a,{childList:!0,subtree:!0}))}function Dd(a){a.F&&a.F.disconnect()}Cd.prototype.c=function(a){var b=this.a.readyState;"interactive"!==b&&"complete"!==b||Dd(this);for(b=0;b<a.length;b++)for(var c=a[b].addedNodes,d=0;d<c.length;d++)L(this.b,c[d])};function Ed(){var a=this;this.a=this.h=void 0;this.b=new Promise(function(b){a.a=b;a.h&&b(a.h)})}Ed.prototype.resolve=function(a){if(this.h)throw Error("Already resolved.");this.h=a;this.a&&this.a(a)};function N(a){this.c=!1;this.a=a;this.l=new Map;this.f=function(a){return a()};this.b=!1;this.g=[];this.da=new Cd(a)}n=N.prototype;
n.sa=function(a,b){var c=this;if(!(b instanceof Function))throw new TypeError("Custom element constructors must be functions.");if(!ud(a))throw new SyntaxError("The element name '"+a+"' is not valid.");if(this.a.a.get(a))throw Error("A custom element with name '"+a+"' has already been defined.");if(this.c)throw Error("A custom element is already being defined.");this.c=!0;try{var d=function(a){var b=e[a];if(void 0!==b&&!(b instanceof Function))throw Error("The '"+a+"' callback must be a function.");
return b},e=b.prototype;if(!(e instanceof Object))throw new TypeError("The custom element constructor's prototype is not an object.");var f=d("connectedCallback");var g=d("disconnectedCallback");var h=d("adoptedCallback");var k=d("attributeChangedCallback");var l=b.observedAttributes||[]}catch(m){return}finally{this.c=!1}b={localName:a,constructorFunction:b,connectedCallback:f,disconnectedCallback:g,adoptedCallback:h,attributeChangedCallback:k,observedAttributes:l,constructionStack:[]};yd(this.a,
a,b);this.g.push(b);this.b||(this.b=!0,this.f(function(){return Fd(c)}))};n.Y=function(a){L(this.a,a)};
function Fd(a){if(!1!==a.b){a.b=!1;for(var b=a.g,c=[],d=new Map,e=0;e<b.length;e++)d.set(b[e].localName,[]);L(a.a,document,{Y:function(b){if(void 0===b.__CE_state){var e=b.localName,f=d.get(e);f?f.push(b):a.a.a.get(e)&&c.push(b)}}});for(e=0;e<c.length;e++)Bd(a.a,c[e]);for(;0<b.length;){var f=b.shift();e=f.localName;f=d.get(f.localName);for(var g=0;g<f.length;g++)Bd(a.a,f[g]);(e=a.l.get(e))&&e.resolve(void 0)}}}n.get=function(a){if(a=this.a.a.get(a))return a.constructorFunction};
n.ta=function(a){if(!ud(a))return Promise.reject(new SyntaxError("'"+a+"' is not a valid custom element name."));var b=this.l.get(a);if(b)return b.b;b=new Ed;this.l.set(a,b);this.a.a.get(a)&&!this.g.some(function(b){return b.localName===a})&&b.resolve(void 0);return b.b};n.Pa=function(a){Dd(this.da);var b=this.f;this.f=function(c){return a(function(){return b(c)})}};window.CustomElementRegistry=N;N.prototype.define=N.prototype.sa;N.prototype.upgrade=N.prototype.Y;N.prototype.get=N.prototype.get;
N.prototype.whenDefined=N.prototype.ta;N.prototype.polyfillWrapFlushCallback=N.prototype.Pa;var Gd=window.Document.prototype.createElement,Hd=window.Document.prototype.createElementNS,Id=window.Document.prototype.importNode,Jd=window.Document.prototype.prepend,Kd=window.Document.prototype.append,Ld=window.DocumentFragment.prototype.prepend,Md=window.DocumentFragment.prototype.append,Nd=window.Node.prototype.cloneNode,Od=window.Node.prototype.appendChild,Pd=window.Node.prototype.insertBefore,Qd=window.Node.prototype.removeChild,Rd=window.Node.prototype.replaceChild,Sd=Object.getOwnPropertyDescriptor(window.Node.prototype,
"textContent"),Td=window.Element.prototype.attachShadow,Ud=Object.getOwnPropertyDescriptor(window.Element.prototype,"innerHTML"),Vd=window.Element.prototype.getAttribute,Wd=window.Element.prototype.setAttribute,Xd=window.Element.prototype.removeAttribute,Yd=window.Element.prototype.getAttributeNS,Zd=window.Element.prototype.setAttributeNS,$d=window.Element.prototype.removeAttributeNS,ae=window.Element.prototype.insertAdjacentElement,be=window.Element.prototype.insertAdjacentHTML,ce=window.Element.prototype.prepend,
de=window.Element.prototype.append,ee=window.Element.prototype.before,fe=window.Element.prototype.after,ge=window.Element.prototype.replaceWith,he=window.Element.prototype.remove,ie=window.HTMLElement,je=Object.getOwnPropertyDescriptor(window.HTMLElement.prototype,"innerHTML"),ke=window.HTMLElement.prototype.insertAdjacentElement,le=window.HTMLElement.prototype.insertAdjacentHTML;var me=new function(){};function ne(){var a=oe;window.HTMLElement=function(){function b(){var b=this.constructor,d=a.g.get(b);if(!d)throw Error("The custom element being constructed was not registered with `customElements`.");var e=d.constructionStack;if(0===e.length)return e=Gd.call(document,d.localName),Object.setPrototypeOf(e,b.prototype),e.__CE_state=1,e.__CE_definition=d,a.b(e),e;d=e.length-1;var f=e[d];if(f===me)throw Error("The HTMLElement constructor was either called reentrantly for this constructor or called multiple times.");
e[d]=me;Object.setPrototypeOf(f,b.prototype);a.b(f);return f}b.prototype=ie.prototype;Object.defineProperty(b.prototype,"constructor",{writable:!0,configurable:!0,enumerable:!1,value:b});return b}()};function pe(a,b,c){function d(b){return function(c){for(var d=[],e=0;e<arguments.length;++e)d[e]=arguments[e];e=[];for(var f=[],l=0;l<d.length;l++){var m=d[l];m instanceof Element&&H(m)&&f.push(m);if(m instanceof DocumentFragment)for(m=m.firstChild;m;m=m.nextSibling)e.push(m);else e.push(m)}b.apply(this,d);for(d=0;d<f.length;d++)K(a,f[d]);if(H(this))for(d=0;d<e.length;d++)f=e[d],f instanceof Element&&J(a,f)}}void 0!==c.V&&(b.prepend=d(c.V));void 0!==c.append&&(b.append=d(c.append))};function qe(){var a=oe;I(Document.prototype,"createElement",function(b){if(this.__CE_hasRegistry){var c=a.a.get(b);if(c)return new c.constructorFunction}b=Gd.call(this,b);a.b(b);return b});I(Document.prototype,"importNode",function(b,c){b=Id.call(this,b,!!c);this.__CE_hasRegistry?L(a,b):Ad(a,b);return b});I(Document.prototype,"createElementNS",function(b,c){if(this.__CE_hasRegistry&&(null===b||"http://www.w3.org/1999/xhtml"===b)){var d=a.a.get(c);if(d)return new d.constructorFunction}b=Hd.call(this,
b,c);a.b(b);return b});pe(a,Document.prototype,{V:Jd,append:Kd})};function re(){function a(a,d){Object.defineProperty(a,"textContent",{enumerable:d.enumerable,configurable:!0,get:d.get,set:function(a){if(this.nodeType===Node.TEXT_NODE)d.set.call(this,a);else{var c=void 0;if(this.firstChild){var e=this.childNodes,h=e.length;if(0<h&&H(this)){c=Array(h);for(var k=0;k<h;k++)c[k]=e[k]}}d.set.call(this,a);if(c)for(a=0;a<c.length;a++)K(b,c[a])}}})}var b=oe;I(Node.prototype,"insertBefore",function(a,d){if(a instanceof DocumentFragment){var c=Array.prototype.slice.apply(a.childNodes);
a=Pd.call(this,a,d);if(H(this))for(d=0;d<c.length;d++)J(b,c[d]);return a}c=H(a);d=Pd.call(this,a,d);c&&K(b,a);H(this)&&J(b,a);return d});I(Node.prototype,"appendChild",function(a){if(a instanceof DocumentFragment){var c=Array.prototype.slice.apply(a.childNodes);a=Od.call(this,a);if(H(this))for(var e=0;e<c.length;e++)J(b,c[e]);return a}c=H(a);e=Od.call(this,a);c&&K(b,a);H(this)&&J(b,a);return e});I(Node.prototype,"cloneNode",function(a){a=Nd.call(this,!!a);this.ownerDocument.__CE_hasRegistry?L(b,a):
Ad(b,a);return a});I(Node.prototype,"removeChild",function(a){var c=H(a),e=Qd.call(this,a);c&&K(b,a);return e});I(Node.prototype,"replaceChild",function(a,d){if(a instanceof DocumentFragment){var c=Array.prototype.slice.apply(a.childNodes);a=Rd.call(this,a,d);if(H(this))for(K(b,d),d=0;d<c.length;d++)J(b,c[d]);return a}c=H(a);var f=Rd.call(this,a,d),g=H(this);g&&K(b,d);c&&K(b,a);g&&J(b,a);return f});Sd&&Sd.get?a(Node.prototype,Sd):zd(b,function(b){a(b,{enumerable:!0,configurable:!0,get:function(){for(var a=
[],b=0;b<this.childNodes.length;b++)a.push(this.childNodes[b].textContent);return a.join("")},set:function(a){for(;this.firstChild;)Qd.call(this,this.firstChild);Od.call(this,document.createTextNode(a))}})})};function se(a){function b(b){return function(c){for(var d=[],e=0;e<arguments.length;++e)d[e]=arguments[e];e=[];for(var h=[],k=0;k<d.length;k++){var l=d[k];l instanceof Element&&H(l)&&h.push(l);if(l instanceof DocumentFragment)for(l=l.firstChild;l;l=l.nextSibling)e.push(l);else e.push(l)}b.apply(this,d);for(d=0;d<h.length;d++)K(a,h[d]);if(H(this))for(d=0;d<e.length;d++)h=e[d],h instanceof Element&&J(a,h)}}var c=Element.prototype;void 0!==ee&&(c.before=b(ee));void 0!==ee&&(c.after=b(fe));void 0!==ge&&
I(c,"replaceWith",function(b){for(var c=[],d=0;d<arguments.length;++d)c[d]=arguments[d];d=[];for(var g=[],h=0;h<c.length;h++){var k=c[h];k instanceof Element&&H(k)&&g.push(k);if(k instanceof DocumentFragment)for(k=k.firstChild;k;k=k.nextSibling)d.push(k);else d.push(k)}h=H(this);ge.apply(this,c);for(c=0;c<g.length;c++)K(a,g[c]);if(h)for(K(a,this),c=0;c<d.length;c++)g=d[c],g instanceof Element&&J(a,g)});void 0!==he&&I(c,"remove",function(){var b=H(this);he.call(this);b&&K(a,this)})};function te(){function a(a,b){Object.defineProperty(a,"innerHTML",{enumerable:b.enumerable,configurable:!0,get:b.get,set:function(a){var c=this,e=void 0;H(this)&&(e=[],wd(this,function(a){a!==c&&e.push(a)}));b.set.call(this,a);if(e)for(var f=0;f<e.length;f++){var g=e[f];1===g.__CE_state&&d.disconnectedCallback(g)}this.ownerDocument.__CE_hasRegistry?L(d,this):Ad(d,this);return a}})}function b(a,b){I(a,"insertAdjacentElement",function(a,c){var e=H(c);a=b.call(this,a,c);e&&K(d,c);H(a)&&J(d,c);return a})}
function c(a,b){function c(a,b){for(var c=[];a!==b;a=a.nextSibling)c.push(a);for(b=0;b<c.length;b++)L(d,c[b])}I(a,"insertAdjacentHTML",function(a,d){a=a.toLowerCase();if("beforebegin"===a){var e=this.previousSibling;b.call(this,a,d);c(e||this.parentNode.firstChild,this)}else if("afterbegin"===a)e=this.firstChild,b.call(this,a,d),c(this.firstChild,e);else if("beforeend"===a)e=this.lastChild,b.call(this,a,d),c(e||this.firstChild,null);else if("afterend"===a)e=this.nextSibling,b.call(this,a,d),c(this.nextSibling,
e);else throw new SyntaxError("The value provided ("+String(a)+") is not one of 'beforebegin', 'afterbegin', 'beforeend', or 'afterend'.");})}var d=oe;Td&&I(Element.prototype,"attachShadow",function(a){return this.__CE_shadowRoot=a=Td.call(this,a)});Ud&&Ud.get?a(Element.prototype,Ud):je&&je.get?a(HTMLElement.prototype,je):zd(d,function(b){a(b,{enumerable:!0,configurable:!0,get:function(){return Nd.call(this,!0).innerHTML},set:function(a){var b="template"===this.localName,c=b?this.content:this,d=Hd.call(document,
this.namespaceURI,this.localName);for(d.innerHTML=a;0<c.childNodes.length;)Qd.call(c,c.childNodes[0]);for(a=b?d.content:d;0<a.childNodes.length;)Od.call(c,a.childNodes[0])}})});I(Element.prototype,"setAttribute",function(a,b){if(1!==this.__CE_state)return Wd.call(this,a,b);var c=Vd.call(this,a);Wd.call(this,a,b);b=Vd.call(this,a);d.attributeChangedCallback(this,a,c,b,null)});I(Element.prototype,"setAttributeNS",function(a,b,c){if(1!==this.__CE_state)return Zd.call(this,a,b,c);var e=Yd.call(this,a,
b);Zd.call(this,a,b,c);c=Yd.call(this,a,b);d.attributeChangedCallback(this,b,e,c,a)});I(Element.prototype,"removeAttribute",function(a){if(1!==this.__CE_state)return Xd.call(this,a);var b=Vd.call(this,a);Xd.call(this,a);null!==b&&d.attributeChangedCallback(this,a,b,null,null)});I(Element.prototype,"removeAttributeNS",function(a,b){if(1!==this.__CE_state)return $d.call(this,a,b);var c=Yd.call(this,a,b);$d.call(this,a,b);var e=Yd.call(this,a,b);c!==e&&d.attributeChangedCallback(this,b,c,e,a)});ke?b(HTMLElement.prototype,
ke):ae?b(Element.prototype,ae):console.warn("Custom Elements: `Element#insertAdjacentElement` was not patched.");le?c(HTMLElement.prototype,le):be?c(Element.prototype,be):console.warn("Custom Elements: `Element#insertAdjacentHTML` was not patched.");pe(d,Element.prototype,{V:ce,append:de});se(d)};var ue=window.customElements;if(!ue||ue.forcePolyfill||"function"!=typeof ue.define||"function"!=typeof ue.get){var oe=new xd;ne();qe();pe(oe,DocumentFragment.prototype,{V:Ld,append:Md});re();te();document.__CE_hasRegistry=!0;var customElements=new N(oe);Object.defineProperty(window,"customElements",{configurable:!0,enumerable:!0,value:customElements})};function ve(){this.end=this.start=0;this.rules=this.parent=this.previous=null;this.cssText=this.parsedCssText="";this.atRule=!1;this.type=0;this.parsedSelector=this.selector=this.keyframesName=""}
function we(a){a=a.replace(xe,"").replace(ye,"");var b=ze,c=a,d=new ve;d.start=0;d.end=c.length;for(var e=d,f=0,g=c.length;f<g;f++)if("{"===c[f]){e.rules||(e.rules=[]);var h=e,k=h.rules[h.rules.length-1]||null;e=new ve;e.start=f+1;e.parent=h;e.previous=k;h.rules.push(e)}else"}"===c[f]&&(e.end=f+1,e=e.parent||d);return b(d,a)}
function ze(a,b){var c=b.substring(a.start,a.end-1);a.parsedCssText=a.cssText=c.trim();a.parent&&(c=b.substring(a.previous?a.previous.end:a.parent.start,a.start-1),c=Ae(c),c=c.replace(Be," "),c=c.substring(c.lastIndexOf(";")+1),c=a.parsedSelector=a.selector=c.trim(),a.atRule=0===c.indexOf("@"),a.atRule?0===c.indexOf("@media")?a.type=Ce:c.match(De)&&(a.type=Ee,a.keyframesName=a.selector.split(Be).pop()):a.type=0===c.indexOf("--")?Fe:Ge);if(c=a.rules)for(var d=0,e=c.length,f=void 0;d<e&&(f=c[d]);d++)ze(f,
b);return a}function Ae(a){return a.replace(/\\([0-9a-f]{1,6})\s/gi,function(a,c){a=c;for(c=6-a.length;c--;)a="0"+a;return"\\"+a})}
function He(a,b,c){c=void 0===c?"":c;var d="";if(a.cssText||a.rules){var e=a.rules,f;if(f=e)f=e[0],f=!(f&&f.selector&&0===f.selector.indexOf("--"));if(f){f=0;for(var g=e.length,h=void 0;f<g&&(h=e[f]);f++)d=He(h,b,d)}else b?b=a.cssText:(b=a.cssText,b=b.replace(Ie,"").replace(Je,""),b=b.replace(Ke,"").replace(Le,"")),(d=b.trim())&&(d="  "+d+"\n")}d&&(a.selector&&(c+=a.selector+" {\n"),c+=d,a.selector&&(c+="}\n\n"));return c}
var Ge=1,Ee=7,Ce=4,Fe=1E3,xe=/\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,ye=/@import[^;]*;/gim,Ie=/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\n]|$)/gim,Je=/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\n]|$)?/gim,Ke=/@apply\s*\(?[^);]*\)?\s*(?:[;\n]|$)?/gim,Le=/[^;:]*?:[^;]*?var\([^;]*\)(?:[;\n]|$)?/gim,De=/^@[^\s]*keyframes/,Be=/\s+/g;var O=!(window.ShadyDOM&&window.ShadyDOM.inUse),Me;function Ne(a){Me=a&&a.shimcssproperties?!1:O||!(navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/)||!window.CSS||!CSS.supports||!CSS.supports("box-shadow","0 0 0 var(--foo)"))}var Oe;window.ShadyCSS&&void 0!==window.ShadyCSS.cssBuild&&(Oe=window.ShadyCSS.cssBuild);var Pe=!(!window.ShadyCSS||!window.ShadyCSS.disableRuntime);
window.ShadyCSS&&void 0!==window.ShadyCSS.nativeCss?Me=window.ShadyCSS.nativeCss:window.ShadyCSS?(Ne(window.ShadyCSS),window.ShadyCSS=void 0):Ne(window.WebComponents&&window.WebComponents.flags);var Q=Me,Qe=Oe;var Re=/(?:^|[;\s{]\s*)(--[\w-]*?)\s*:\s*(?:((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};{])+)|\{([^}]*)\}(?:(?=[;\s}])|$))/gi,Se=/(?:^|\W+)@apply\s*\(?([^);\n]*)\)?/gi,Te=/(--[\w-]+)\s*([:,;)]|$)/gi,Ue=/(animation\s*:)|(animation-name\s*:)/,$e=/@media\s(.*)/,af=/\{[^}]*\}/g;var bf=new Set;function cf(a,b){if(!a)return"";"string"===typeof a&&(a=we(a));b&&df(a,b);return He(a,Q)}function ef(a){!a.__cssRules&&a.textContent&&(a.__cssRules=we(a.textContent));return a.__cssRules||null}function ff(a){return!!a.parent&&a.parent.type===Ee}function df(a,b,c,d){if(a){var e=!1,f=a.type;if(d&&f===Ce){var g=a.selector.match($e);g&&(window.matchMedia(g[1]).matches||(e=!0))}f===Ge?b(a):c&&f===Ee?c(a):f===Fe&&(e=!0);if((a=a.rules)&&!e)for(e=0,f=a.length,g=void 0;e<f&&(g=a[e]);e++)df(g,b,c,d)}}
function gf(a,b,c,d){var e=document.createElement("style");b&&e.setAttribute("scope",b);e.textContent=a;hf(e,c,d);return e}var jf=null;function kf(a){a=document.createComment(" Shady DOM styles for "+a+" ");var b=document.head;b.insertBefore(a,(jf?jf.nextSibling:null)||b.firstChild);return jf=a}function hf(a,b,c){b=b||document.head;b.insertBefore(a,c&&c.nextSibling||b.firstChild);jf?a.compareDocumentPosition(jf)===Node.DOCUMENT_POSITION_PRECEDING&&(jf=a):jf=a}
function lf(a,b){for(var c=0,d=a.length;b<d;b++)if("("===a[b])c++;else if(")"===a[b]&&0===--c)return b;return-1}function mf(a,b){var c=a.indexOf("var(");if(-1===c)return b(a,"","","");var d=lf(a,c+3),e=a.substring(c+4,d);c=a.substring(0,c);a=mf(a.substring(d+1),b);d=e.indexOf(",");return-1===d?b(c,e.trim(),"",a):b(c,e.substring(0,d).trim(),e.substring(d+1).trim(),a)}function nf(a,b){O?a.setAttribute("class",b):window.ShadyDOM.nativeMethods.setAttribute.call(a,"class",b)}
var of=window.ShadyDOM&&window.ShadyDOM.wrap||function(a){return a};function pf(a){var b=a.localName,c="";b?-1<b.indexOf("-")||(c=b,b=a.getAttribute&&a.getAttribute("is")||""):(b=a.is,c=a.extends);return{is:b,M:c}}function qf(a){for(var b=[],c="",d=0;0<=d&&d<a.length;d++)if("("===a[d]){var e=lf(a,d);c+=a.slice(d,e+1);d=e}else","===a[d]?(b.push(c),c=""):c+=a[d];c&&b.push(c);return b}
function rf(a){if(void 0!==Qe)return Qe;if(void 0===a.__cssBuild){var b=a.getAttribute("css-build");if(b)a.__cssBuild=b;else{a:{b="template"===a.localName?a.content.firstChild:a.firstChild;if(b instanceof Comment&&(b=b.textContent.trim().split(":"),"css-build"===b[0])){b=b[1];break a}b=""}if(""!==b){var c="template"===a.localName?a.content.firstChild:a.firstChild;c.parentNode.removeChild(c)}a.__cssBuild=b}}return a.__cssBuild||""}
function sf(a){a=void 0===a?"":a;return""!==a&&Q?O?"shadow"===a:"shady"===a:!1};function tf(){}function uf(a,b){vf(R,a,function(a){wf(a,b||"")})}function vf(a,b,c){b.nodeType===Node.ELEMENT_NODE&&c(b);var d;"template"===b.localName?d=(b.content||b._content||b).childNodes:d=b.children||b.childNodes;if(d)for(b=0;b<d.length;b++)vf(a,d[b],c)}
function wf(a,b,c){if(b)if(a.classList)c?(a.classList.remove("style-scope"),a.classList.remove(b)):(a.classList.add("style-scope"),a.classList.add(b));else if(a.getAttribute){var d=a.getAttribute("class");c?d&&(b=d.replace("style-scope","").replace(b,""),nf(a,b)):nf(a,(d?d+" ":"")+"style-scope "+b)}}function xf(a,b,c){vf(R,a,function(a){wf(a,b,!0);wf(a,c)})}function yf(a,b){vf(R,a,function(a){wf(a,b||"",!0)})}
function zf(a,b,c,d,e){var f=R;e=void 0===e?"":e;""===e&&(O||"shady"===(void 0===d?"":d)?e=cf(b,c):(a=pf(a),e=Af(f,b,a.is,a.M,c)+"\n\n"));return e.trim()}function Af(a,b,c,d,e){var f=Bf(c,d);c=c?"."+c:"";return cf(b,function(b){b.c||(b.selector=b.j=Cf(a,b,a.b,c,f),b.c=!0);e&&e(b,c,f)})}function Bf(a,b){return b?"[is="+a+"]":a}
function Cf(a,b,c,d,e){var f=qf(b.selector);if(!ff(b)){b=0;for(var g=f.length,h=void 0;b<g&&(h=f[b]);b++)f[b]=c.call(a,h,d,e)}return f.filter(function(a){return!!a}).join(",")}function Df(a){return a.replace(Ef,function(a,c,d){-1<d.indexOf("+")?d=d.replace(/\+/g,"___"):-1<d.indexOf("___")&&(d=d.replace(/___/g,"+"));return":"+c+"("+d+")"})}
function Ff(a){for(var b=[],c;c=a.match(Gf);){var d=c.index,e=lf(a,d);if(-1===e)throw Error(c.input+" selector missing ')'");c=a.slice(d,e+1);a=a.replace(c,"\ue000");b.push(c)}return{ha:a,matches:b}}function Hf(a,b){var c=a.split("\ue000");return b.reduce(function(a,b,f){return a+b+c[f+1]},c[0])}
tf.prototype.b=function(a,b,c){var d=!1;a=a.trim();var e=Ef.test(a);e&&(a=a.replace(Ef,function(a,b,c){return":"+b+"("+c.replace(/\s/g,"")+")"}),a=Df(a));var f=Gf.test(a);if(f){var g=Ff(a);a=g.ha;g=g.matches}a=a.replace(If,":host $1");a=a.replace(Jf,function(a,e,f){d||(a=Kf(f,e,b,c),d=d||a.stop,e=a.Ca,f=a.value);return e+f});f&&(a=Hf(a,g));e&&(a=Df(a));return a};
function Kf(a,b,c,d){var e=a.indexOf("::slotted");0<=a.indexOf(":host")?a=Lf(a,d):0!==e&&(a=c?Mf(a,c):a);c=!1;0<=e&&(b="",c=!0);if(c){var f=!0;c&&(a=a.replace(Nf,function(a,b){return" > "+b}))}a=a.replace(Of,function(a,b,c){return'[dir="'+c+'"] '+b+", "+b+'[dir="'+c+'"]'});return{value:a,Ca:b,stop:f}}
function Mf(a,b){a=a.split(/(\[.+?\])/);for(var c=[],d=0;d<a.length;d++)if(1===d%2)c.push(a[d]);else{var e=a[d];if(""!==e||d!==a.length-1)e=e.split(":"),e[0]+=b,c.push(e.join(":"))}return c.join("")}function Lf(a,b){var c=a.match(Pf);return(c=c&&c[2].trim()||"")?c[0].match(Qf)?a.replace(Pf,function(a,c,f){return b+f}):c.split(Qf)[0]===b?c:"should_not_match":a.replace(":host",b)}function Rf(a){":root"===a.selector&&(a.selector="html")}
tf.prototype.c=function(a){return a.match(":host")?"":a.match("::slotted")?this.b(a,":not(.style-scope)"):Mf(a.trim(),":not(.style-scope)")};p.Object.defineProperties(tf.prototype,{a:{configurable:!0,enumerable:!0,get:function(){return"style-scope"}}});
var Ef=/:(nth[-\w]+)\(([^)]+)\)/,Jf=/(^|[\s>+~]+)((?:\[.+?\]|[^\s>+~=[])+)/g,Qf=/[[.:#*]/,If=/^(::slotted)/,Pf=/(:host)(?:\(((?:\([^)(]*\)|[^)(]*)+?)\))/,Nf=/(?:::slotted)(?:\(((?:\([^)(]*\)|[^)(]*)+?)\))/,Of=/(.*):dir\((?:(ltr|rtl))\)/,Gf=/:(?:matches|any|-(?:webkit|moz)-any)/,R=new tf;function Sf(a,b,c,d,e){this.A=a||null;this.b=b||null;this.fa=c||[];this.o=null;this.cssBuild=e||"";this.M=d||"";this.a=this.s=this.w=null}function T(a){return a?a.__styleInfo:null}function Tf(a,b){return a.__styleInfo=b}Sf.prototype.c=function(){return this.A};Sf.prototype._getStyleRules=Sf.prototype.c;function Uf(a){var b=this.matches||this.matchesSelector||this.mozMatchesSelector||this.msMatchesSelector||this.oMatchesSelector||this.webkitMatchesSelector;return b&&b.call(this,a)}var Vf=navigator.userAgent.match("Trident");function Wf(){}function Xf(a){var b={},c=[],d=0;df(a,function(a){Yf(a);a.index=d++;a=a.i.cssText;for(var c;c=Te.exec(a);){var e=c[1];":"!==c[2]&&(b[e]=!0)}},function(a){c.push(a)});a.b=c;a=[];for(var e in b)a.push(e);return a}
function Yf(a){if(!a.i){var b={},c={};Zf(a,c)&&(b.v=c,a.rules=null);b.cssText=a.parsedCssText.replace(af,"").replace(Re,"");a.i=b}}function Zf(a,b){var c=a.i;if(c){if(c.v)return Object.assign(b,c.v),!0}else{c=a.parsedCssText;for(var d;a=Re.exec(c);){d=(a[2]||a[3]).trim();if("inherit"!==d||"unset"!==d)b[a[1].trim()]=d;d=!0}return d}}
function $f(a,b,c){b&&(b=0<=b.indexOf(";")?ag(a,b,c):mf(b,function(b,e,f,g){if(!e)return b+g;(e=$f(a,c[e],c))&&"initial"!==e?"apply-shim-inherit"===e&&(e="inherit"):e=$f(a,c[f]||f,c)||f;return b+(e||"")+g}));return b&&b.trim()||""}
function ag(a,b,c){b=b.split(";");for(var d=0,e,f;d<b.length;d++)if(e=b[d]){Se.lastIndex=0;if(f=Se.exec(e))e=$f(a,c[f[1]],c);else if(f=e.indexOf(":"),-1!==f){var g=e.substring(f);g=g.trim();g=$f(a,g,c)||g;e=e.substring(0,f)+g}b[d]=e&&e.lastIndexOf(";")===e.length-1?e.slice(0,-1):e||""}return b.join(";")}
function bg(a,b){var c={},d=[];df(a,function(a){a.i||Yf(a);var e=a.j||a.parsedSelector;b&&a.i.v&&e&&Uf.call(b,e)&&(Zf(a,c),a=a.index,e=parseInt(a/32,10),d[e]=(d[e]||0)|1<<a%32)},null,!0);return{v:c,key:d}}
function cg(a,b,c,d){b.i||Yf(b);if(b.i.v){var e=pf(a);a=e.is;e=e.M;e=a?Bf(a,e):"html";var f=b.parsedSelector,g=":host > *"===f||"html"===f,h=0===f.indexOf(":host")&&!g;"shady"===c&&(g=f===e+" > *."+e||-1!==f.indexOf("html"),h=!g&&0===f.indexOf(e));if(g||h)c=e,h&&(b.j||(b.j=Cf(R,b,R.b,a?"."+a:"",e)),c=b.j||e),d({ha:c,Ia:h,Za:g})}}function dg(a,b,c){var d={},e={};df(b,function(b){cg(a,b,c,function(c){Uf.call(a._element||a,c.ha)&&(c.Ia?Zf(b,d):Zf(b,e))})},null,!0);return{Ra:e,Ha:d}}
function eg(a,b,c,d){var e=pf(b),f=Bf(e.is,e.M),g=new RegExp("(?:^|[^.#[:])"+(b.extends?"\\"+f.slice(0,-1)+"\\]":f)+"($|[.:[\\s>+~])"),h=T(b);e=h.A;h=h.cssBuild;var k=fg(e,d);return zf(b,e,function(b){var e="";b.i||Yf(b);b.i.cssText&&(e=ag(a,b.i.cssText,c));b.cssText=e;if(!O&&!ff(b)&&b.cssText){var h=e=b.cssText;null==b.na&&(b.na=Ue.test(e));if(b.na)if(null==b.U){b.U=[];for(var l in k)h=k[l],h=h(e),e!==h&&(e=h,b.U.push(l))}else{for(l=0;l<b.U.length;++l)h=k[b.U[l]],e=h(e);h=e}b.cssText=h;b.j=b.j||
b.selector;e="."+d;l=qf(b.j);h=0;for(var M=l.length,U=void 0;h<M&&(U=l[h]);h++)l[h]=U.match(g)?U.replace(f,e):e+" "+U;b.selector=l.join(",")}},h)}function fg(a,b){a=a.b;var c={};if(!O&&a)for(var d=0,e=a[d];d<a.length;e=a[++d]){var f=e,g=b;f.f=new RegExp("\\b"+f.keyframesName+"(?!\\B|-)","g");f.a=f.keyframesName+"-"+g;f.j=f.j||f.selector;f.selector=f.j.replace(f.keyframesName,f.a);c[e.keyframesName]=gg(e)}return c}function gg(a){return function(b){return b.replace(a.f,a.a)}}
function hg(a,b){var c=ig,d=ef(a);a.textContent=cf(d,function(a){var d=a.cssText=a.parsedCssText;a.i&&a.i.cssText&&(d=d.replace(Ie,"").replace(Je,""),a.cssText=ag(c,d,b))})}p.Object.defineProperties(Wf.prototype,{a:{configurable:!0,enumerable:!0,get:function(){return"x-scope"}}});var ig=new Wf;var jg={},kg=window.customElements;if(kg&&!O&&!Pe){var lg=kg.define;kg.define=function(a,b,c){jg[a]||(jg[a]=kf(a));lg.call(kg,a,b,c)}};function mg(){this.cache={}}mg.prototype.store=function(a,b,c,d){var e=this.cache[a]||[];e.push({v:b,styleElement:c,s:d});100<e.length&&e.shift();this.cache[a]=e};function ng(){}var og=new RegExp(R.a+"\\s*([^\\s]*)");function pg(a){return(a=(a.classList&&a.classList.value?a.classList.value:a.getAttribute("class")||"").match(og))?a[1]:""}function qg(a){var b=of(a).getRootNode();return b===a||b===a.ownerDocument?"":(a=b.host)?pf(a).is:""}
function rg(a){for(var b=0;b<a.length;b++){var c=a[b];if(c.target!==document.documentElement&&c.target!==document.head)for(var d=0;d<c.addedNodes.length;d++){var e=c.addedNodes[d];if(e.nodeType===Node.ELEMENT_NODE){var f=e.getRootNode(),g=pg(e);if(g&&f===e.ownerDocument&&("style"!==e.localName&&"template"!==e.localName||""===rf(e)))yf(e,g);else if(f instanceof ShadowRoot)for(f=qg(e),f!==g&&xf(e,g,f),e=window.ShadyDOM.nativeMethods.querySelectorAll.call(e,":not(."+R.a+")"),g=0;g<e.length;g++){f=e[g];
var h=qg(f);h&&wf(f,h)}}}}}
if(!(O||window.ShadyDOM&&window.ShadyDOM.handlesDynamicScoping)){var sg=new MutationObserver(rg),tg=function(a){sg.observe(a,{childList:!0,subtree:!0})};if(window.customElements&&!window.customElements.polyfillWrapFlushCallback)tg(document);else{var ug=function(){tg(document.body)};window.HTMLImports?window.HTMLImports.whenReady(ug):requestAnimationFrame(function(){if("loading"===document.readyState){var a=function(){ug();document.removeEventListener("readystatechange",a)};document.addEventListener("readystatechange",
a)}else ug()})}ng=function(){rg(sg.takeRecords())}}var vg=ng;var wg={};var xg=Promise.resolve();function yg(a){if(a=wg[a])a._applyShimCurrentVersion=a._applyShimCurrentVersion||0,a._applyShimValidatingVersion=a._applyShimValidatingVersion||0,a._applyShimNextVersion=(a._applyShimNextVersion||0)+1}function zg(a){return a._applyShimCurrentVersion===a._applyShimNextVersion}function Ag(a){a._applyShimValidatingVersion=a._applyShimNextVersion;a._validating||(a._validating=!0,xg.then(function(){a._applyShimCurrentVersion=a._applyShimNextVersion;a._validating=!1}))};var Bg={},Cg=new mg;function Y(){this.l={};this.c=document.documentElement;var a=new ve;a.rules=[];this.f=Tf(this.c,new Sf(a));this.g=!1;this.b=this.a=null}n=Y.prototype;n.flush=function(){vg()};n.Fa=function(a){return ef(a)};n.Va=function(a){return cf(a)};n.prepareTemplate=function(a,b,c){this.prepareTemplateDom(a,b);this.prepareTemplateStyles(a,b,c)};
n.prepareTemplateStyles=function(a,b,c){if(!a._prepared&&!Pe){O||jg[b]||(jg[b]=kf(b));a._prepared=!0;a.name=b;a.extends=c;wg[b]=a;var d=rf(a),e=sf(d);c={is:b,extends:c};for(var f=[],g=a.content.querySelectorAll("style"),h=0;h<g.length;h++){var k=g[h];if(k.hasAttribute("shady-unscoped")){if(!O){var l=k.textContent;bf.has(l)||(bf.add(l),l=k.cloneNode(!0),document.head.appendChild(l));k.parentNode.removeChild(k)}}else f.push(k.textContent),k.parentNode.removeChild(k)}f=f.join("").trim()+(Bg[b]||"");
Dg(this);if(!e){if(g=!d)g=Se.test(f)||Re.test(f),Se.lastIndex=0,Re.lastIndex=0;h=we(f);g&&Q&&this.a&&this.a.transformRules(h,b);a._styleAst=h}g=[];Q||(g=Xf(a._styleAst));if(!g.length||Q)h=O?a.content:null,b=jg[b]||null,d=zf(c,a._styleAst,null,d,e?f:""),d=d.length?gf(d,c.is,h,b):null,a._style=d;a.a=g}};n.Qa=function(a,b){Bg[b]=a.join(" ")};n.prepareTemplateDom=function(a,b){if(!Pe){var c=rf(a);O||"shady"===c||a._domPrepared||(a._domPrepared=!0,uf(a.content,b))}};
function Eg(a){var b=pf(a),c=b.is;b=b.M;var d=jg[c]||null,e=wg[c];if(e){c=e._styleAst;var f=e.a;e=rf(e);b=new Sf(c,d,f,b,e);Tf(a,b);return b}}function Fg(a){!a.b&&window.ShadyCSS&&window.ShadyCSS.CustomStyleInterface&&(a.b=window.ShadyCSS.CustomStyleInterface,a.b.transformCallback=function(b){a.ra(b)},a.b.validateCallback=function(){requestAnimationFrame(function(){(a.b.enqueued||a.g)&&a.flushCustomStyles()})})}
function Dg(a){!a.a&&window.ShadyCSS&&window.ShadyCSS.ApplyShim&&(a.a=window.ShadyCSS.ApplyShim,a.a.invalidCallback=yg);Fg(a)}
n.flushCustomStyles=function(){if(!Pe&&(Dg(this),this.b)){var a=this.b.processStyles();if(this.b.enqueued&&!sf(this.f.cssBuild)){if(Q){if(!this.f.cssBuild)for(var b=0;b<a.length;b++){var c=this.b.getStyleForCustomStyle(a[b]);if(c&&Q&&this.a){var d=ef(c);Dg(this);this.a.transformRules(d);c.textContent=cf(d)}}}else{Gg(this,this.c,this.f);for(b=0;b<a.length;b++)(c=this.b.getStyleForCustomStyle(a[b]))&&hg(c,this.f.w);this.g&&this.styleDocument()}this.b.enqueued=!1}}};
n.styleElement=function(a,b){if(Pe){if(b){T(a)||Tf(a,new Sf(null));var c=T(a);c.o=c.o||{};Object.assign(c.o,b);Hg(this,a,c)}}else if(c=T(a)||Eg(a))if(a!==this.c&&(this.g=!0),b&&(c.o=c.o||{},Object.assign(c.o,b)),Q)Hg(this,a,c);else if(this.flush(),Gg(this,a,c),c.fa&&c.fa.length){b=pf(a).is;var d;a:{if(d=Cg.cache[b])for(var e=d.length-1;0<=e;e--){var f=d[e];b:{var g=c.fa;for(var h=0;h<g.length;h++){var k=g[h];if(f.v[k]!==c.w[k]){g=!1;break b}}g=!0}if(g){d=f;break a}}d=void 0}g=d?d.styleElement:null;
e=c.s;(f=d&&d.s)||(f=this.l[b]=(this.l[b]||0)+1,f=b+"-"+f);c.s=f;f=c.s;h=ig;h=g?g.textContent||"":eg(h,a,c.w,f);k=T(a);var l=k.a;l&&!O&&l!==g&&(l._useCount--,0>=l._useCount&&l.parentNode&&l.parentNode.removeChild(l));O?k.a?(k.a.textContent=h,g=k.a):h&&(g=gf(h,f,a.shadowRoot,k.b)):g?g.parentNode||(Vf&&-1<h.indexOf("@media")&&(g.textContent=h),hf(g,null,k.b)):h&&(g=gf(h,f,null,k.b));g&&(g._useCount=g._useCount||0,k.a!=g&&g._useCount++,k.a=g);f=g;O||(g=c.s,k=h=a.getAttribute("class")||"",e&&(k=h.replace(new RegExp("\\s*x-scope\\s*"+
e+"\\s*","g")," ")),k+=(k?" ":"")+"x-scope "+g,h!==k&&nf(a,k));d||Cg.store(b,c.w,f,c.s)}};
function Hg(a,b,c){var d=pf(b).is;if(c.o){var e=c.o,f;for(f in e)null===f?b.style.removeProperty(f):b.style.setProperty(f,e[f])}e=wg[d];if(!(!e&&b!==a.c||e&&""!==rf(e))&&e&&e._style&&!zg(e)){if(zg(e)||e._applyShimValidatingVersion!==e._applyShimNextVersion)Dg(a),a.a&&a.a.transformRules(e._styleAst,d),e._style.textContent=zf(b,c.A),Ag(e);O&&(a=b.shadowRoot)&&(a=a.querySelector("style"))&&(a.textContent=zf(b,c.A));c.A=e._styleAst}}
function Ig(a,b){return(b=of(b).getRootNode().host)?T(b)||Eg(b)?b:Ig(a,b):a.c}function Gg(a,b,c){var d=Ig(a,b),e=T(d),f=e.w;d===a.c||f||(Gg(a,d,e),f=e.w);a=Object.create(f||null);d=dg(b,c.A,c.cssBuild);b=bg(e.A,b).v;Object.assign(a,d.Ha,b,d.Ra);b=c.o;for(var g in b)if((e=b[g])||0===e)a[g]=e;g=ig;b=Object.getOwnPropertyNames(a);for(e=0;e<b.length;e++)d=b[e],a[d]=$f(g,a[d],a);c.w=a}n.styleDocument=function(a){this.styleSubtree(this.c,a)};
n.styleSubtree=function(a,b){var c=of(a),d=c.shadowRoot;(d||a===this.c)&&this.styleElement(a,b);if(a=d&&(d.children||d.childNodes))for(c=0;c<a.length;c++)this.styleSubtree(a[c]);else if(c=c.children||c.childNodes)for(a=0;a<c.length;a++)this.styleSubtree(c[a])};
n.ra=function(a){var b=this,c=rf(a);c!==this.f.cssBuild&&(this.f.cssBuild=c);if(!sf(c)){var d=ef(a);df(d,function(a){if(O)Rf(a);else{var d=R;a.selector=a.parsedSelector;Rf(a);a.selector=a.j=Cf(d,a,d.c,void 0,void 0)}Q&&""===c&&(Dg(b),b.a&&b.a.transformRule(a))});Q?a.textContent=cf(d):this.f.A.rules.push(d)}};n.getComputedStyleValue=function(a,b){var c;Q||(c=(T(a)||T(Ig(this,a))).w[b]);return(c=c||window.getComputedStyle(a).getPropertyValue(b))?c.trim():""};
n.Ua=function(a,b){var c=of(a).getRootNode();b=b?b.split(/\s/):[];c=c.host&&c.host.localName;if(!c){var d=a.getAttribute("class");if(d){d=d.split(/\s/);for(var e=0;e<d.length;e++)if(d[e]===R.a){c=d[e+1];break}}}c&&b.push(R.a,c);Q||(c=T(a))&&c.s&&b.push(ig.a,c.s);nf(a,b.join(" "))};n.Ba=function(a){return T(a)};n.Ta=function(a,b){wf(a,b)};n.Wa=function(a,b){wf(a,b,!0)};n.Sa=function(a){return qg(a)};n.Da=function(a){return pg(a)};Y.prototype.flush=Y.prototype.flush;Y.prototype.prepareTemplate=Y.prototype.prepareTemplate;
Y.prototype.styleElement=Y.prototype.styleElement;Y.prototype.styleDocument=Y.prototype.styleDocument;Y.prototype.styleSubtree=Y.prototype.styleSubtree;Y.prototype.getComputedStyleValue=Y.prototype.getComputedStyleValue;Y.prototype.setElementClass=Y.prototype.Ua;Y.prototype._styleInfoForNode=Y.prototype.Ba;Y.prototype.transformCustomStyleForDocument=Y.prototype.ra;Y.prototype.getStyleAst=Y.prototype.Fa;Y.prototype.styleAstToString=Y.prototype.Va;Y.prototype.flushCustomStyles=Y.prototype.flushCustomStyles;
Y.prototype.scopeNode=Y.prototype.Ta;Y.prototype.unscopeNode=Y.prototype.Wa;Y.prototype.scopeForNode=Y.prototype.Sa;Y.prototype.currentScopeForNode=Y.prototype.Da;Y.prototype.prepareAdoptedCssText=Y.prototype.Qa;Object.defineProperties(Y.prototype,{nativeShadow:{get:function(){return O}},nativeCss:{get:function(){return Q}}});var Z=new Y,Jg,Kg;window.ShadyCSS&&(Jg=window.ShadyCSS.ApplyShim,Kg=window.ShadyCSS.CustomStyleInterface);
window.ShadyCSS={ScopingShim:Z,prepareTemplate:function(a,b,c){Z.flushCustomStyles();Z.prepareTemplate(a,b,c)},prepareTemplateDom:function(a,b){Z.prepareTemplateDom(a,b)},prepareTemplateStyles:function(a,b,c){Z.flushCustomStyles();Z.prepareTemplateStyles(a,b,c)},styleSubtree:function(a,b){Z.flushCustomStyles();Z.styleSubtree(a,b)},styleElement:function(a){Z.flushCustomStyles();Z.styleElement(a)},styleDocument:function(a){Z.flushCustomStyles();Z.styleDocument(a)},flushCustomStyles:function(){Z.flushCustomStyles()},
getComputedStyleValue:function(a,b){return Z.getComputedStyleValue(a,b)},nativeCss:Q,nativeShadow:O,cssBuild:Qe,disableRuntime:Pe};Jg&&(window.ShadyCSS.ApplyShim=Jg);Kg&&(window.ShadyCSS.CustomStyleInterface=Kg);var Lg=window.customElements,Mg=window.HTMLImports,Ng=window.HTMLTemplateElement;window.WebComponents=window.WebComponents||{};if(Lg&&Lg.polyfillWrapFlushCallback){var Og,Pg=function(){if(Og){Ng.C&&Ng.C(window.document);var a=Og;Og=null;a();return!0}},Qg=Mg.whenReady;Lg.polyfillWrapFlushCallback(function(a){Og=a;Qg(Pg)});Mg.whenReady=function(a){Qg(function(){Pg()?Mg.whenReady(a):a()})}}
Mg.whenReady(function(){requestAnimationFrame(function(){window.WebComponents.ready=!0;document.dispatchEvent(new CustomEvent("WebComponentsReady",{bubbles:!0}))})});var Rg=document.createElement("style");Rg.textContent="body {transition: opacity ease-in 0.2s; } \nbody[unresolved] {opacity: 0; display: block; overflow: hidden; position: relative; } \n";var Sg=document.querySelector("head");Sg.insertBefore(Rg,Sg.firstChild);}).call(this);



(function(){/*

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
*/
'use strict';var l=!(window.ShadyDOM&&window.ShadyDOM.inUse),p;function r(a){p=a&&a.shimcssproperties?!1:l||!(navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/)||!window.CSS||!CSS.supports||!CSS.supports("box-shadow","0 0 0 var(--foo)"))}var t;window.ShadyCSS&&void 0!==window.ShadyCSS.cssBuild&&(t=window.ShadyCSS.cssBuild);var aa=!(!window.ShadyCSS||!window.ShadyCSS.disableRuntime);
window.ShadyCSS&&void 0!==window.ShadyCSS.nativeCss?p=window.ShadyCSS.nativeCss:window.ShadyCSS?(r(window.ShadyCSS),window.ShadyCSS=void 0):r(window.WebComponents&&window.WebComponents.flags);var u=p,v=t;function w(){this.end=this.start=0;this.rules=this.parent=this.previous=null;this.cssText=this.parsedCssText="";this.atRule=!1;this.type=0;this.parsedSelector=this.selector=this.keyframesName=""}
function x(a){a=a.replace(ba,"").replace(ca,"");var b=y,c=a,e=new w;e.start=0;e.end=c.length;for(var d=e,f=0,g=c.length;f<g;f++)if("{"===c[f]){d.rules||(d.rules=[]);var h=d,k=h.rules[h.rules.length-1]||null;d=new w;d.start=f+1;d.parent=h;d.previous=k;h.rules.push(d)}else"}"===c[f]&&(d.end=f+1,d=d.parent||e);return b(e,a)}
function y(a,b){var c=b.substring(a.start,a.end-1);a.parsedCssText=a.cssText=c.trim();a.parent&&(c=b.substring(a.previous?a.previous.end:a.parent.start,a.start-1),c=da(c),c=c.replace(z," "),c=c.substring(c.lastIndexOf(";")+1),c=a.parsedSelector=a.selector=c.trim(),a.atRule=0===c.indexOf("@"),a.atRule?0===c.indexOf("@media")?a.type=A:c.match(ea)&&(a.type=B,a.keyframesName=a.selector.split(z).pop()):a.type=0===c.indexOf("--")?C:D);if(c=a.rules)for(var e=0,d=c.length,f=void 0;e<d&&(f=c[e]);e++)y(f,b);
return a}function da(a){return a.replace(/\\([0-9a-f]{1,6})\s/gi,function(a,c){a=c;for(c=6-a.length;c--;)a="0"+a;return"\\"+a})}
function E(a,b,c){c=void 0===c?"":c;var e="";if(a.cssText||a.rules){var d=a.rules,f;if(f=d)f=d[0],f=!(f&&f.selector&&0===f.selector.indexOf("--"));if(f){f=0;for(var g=d.length,h=void 0;f<g&&(h=d[f]);f++)e=E(h,b,e)}else b?b=a.cssText:(b=a.cssText,b=b.replace(fa,"").replace(ha,""),b=b.replace(ia,"").replace(ja,"")),(e=b.trim())&&(e="  "+e+"\n")}e&&(a.selector&&(c+=a.selector+" {\n"),c+=e,a.selector&&(c+="}\n\n"));return c}
var D=1,B=7,A=4,C=1E3,ba=/\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,ca=/@import[^;]*;/gim,fa=/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?(?:[;\n]|$)/gim,ha=/(?:^[^;\-\s}]+)?--[^;{}]*?:[^{};]*?{[^}]*?}(?:[;\n]|$)?/gim,ia=/@apply\s*\(?[^);]*\)?\s*(?:[;\n]|$)?/gim,ja=/[^;:]*?:[^;]*?var\([^;]*\)(?:[;\n]|$)?/gim,ea=/^@[^\s]*keyframes/,z=/\s+/g;var G=/(?:^|[;\s{]\s*)(--[\w-]*?)\s*:\s*(?:((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};{])+)|\{([^}]*)\}(?:(?=[;\s}])|$))/gi,H=/(?:^|\W+)@apply\s*\(?([^);\n]*)\)?/gi,ka=/@media\s(.*)/;var I=new Set;function J(a){if(!a)return"";"string"===typeof a&&(a=x(a));return E(a,u)}function K(a){!a.__cssRules&&a.textContent&&(a.__cssRules=x(a.textContent));return a.__cssRules||null}function L(a,b,c,e){if(a){var d=!1,f=a.type;if(e&&f===A){var g=a.selector.match(ka);g&&(window.matchMedia(g[1]).matches||(d=!0))}f===D?b(a):c&&f===B?c(a):f===C&&(d=!0);if((a=a.rules)&&!d)for(d=0,f=a.length,g=void 0;d<f&&(g=a[d]);d++)L(g,b,c,e)}}
function M(a,b){var c=a.indexOf("var(");if(-1===c)return b(a,"","","");a:{var e=0;var d=c+3;for(var f=a.length;d<f;d++)if("("===a[d])e++;else if(")"===a[d]&&0===--e)break a;d=-1}e=a.substring(c+4,d);c=a.substring(0,c);a=M(a.substring(d+1),b);d=e.indexOf(",");return-1===d?b(c,e.trim(),"",a):b(c,e.substring(0,d).trim(),e.substring(d+1).trim(),a)}
function N(a){if(void 0!==v)return v;if(void 0===a.__cssBuild){var b=a.getAttribute("css-build");if(b)a.__cssBuild=b;else{a:{b="template"===a.localName?a.content.firstChild:a.firstChild;if(b instanceof Comment&&(b=b.textContent.trim().split(":"),"css-build"===b[0])){b=b[1];break a}b=""}if(""!==b){var c="template"===a.localName?a.content.firstChild:a.firstChild;c.parentNode.removeChild(c)}a.__cssBuild=b}}return a.__cssBuild||""};var la=/;\s*/m,ma=/^\s*(initial)|(inherit)\s*$/,O=/\s*!important/;function P(){this.a={}}P.prototype.set=function(a,b){a=a.trim();this.a[a]={h:b,i:{}}};P.prototype.get=function(a){a=a.trim();return this.a[a]||null};var Q=null;function R(){this.b=this.c=null;this.a=new P}R.prototype.o=function(a){a=H.test(a)||G.test(a);H.lastIndex=0;G.lastIndex=0;return a};
R.prototype.m=function(a,b){if(void 0===a._gatheredStyle){var c=[];for(var e=a.content.querySelectorAll("style"),d=0;d<e.length;d++){var f=e[d];if(f.hasAttribute("shady-unscoped")){if(!l){var g=f.textContent;I.has(g)||(I.add(g),g=f.cloneNode(!0),document.head.appendChild(g));f.parentNode.removeChild(f)}}else c.push(f.textContent),f.parentNode.removeChild(f)}(c=c.join("").trim())?(e=document.createElement("style"),e.textContent=c,a.content.insertBefore(e,a.content.firstChild),c=e):c=null;a._gatheredStyle=
c}return(a=a._gatheredStyle)?this.j(a,b):null};R.prototype.j=function(a,b){b=void 0===b?"":b;var c=K(a);this.l(c,b);a.textContent=J(c);return c};R.prototype.f=function(a){var b=this,c=K(a);L(c,function(a){":root"===a.selector&&(a.selector="html");b.g(a)});a.textContent=J(c);return c};R.prototype.l=function(a,b){var c=this;this.c=b;L(a,function(a){c.g(a)});this.c=null};R.prototype.g=function(a){a.cssText=na(this,a.parsedCssText,a);":root"===a.selector&&(a.selector=":host > *")};
function na(a,b,c){b=b.replace(G,function(b,d,f,g){return oa(a,b,d,f,g,c)});return S(a,b,c)}function pa(a,b){for(var c=b;c.parent;)c=c.parent;var e={},d=!1;L(c,function(c){(d=d||c===b)||c.selector===b.selector&&Object.assign(e,T(a,c.parsedCssText))});return e}
function S(a,b,c){for(var e;e=H.exec(b);){var d=e[0],f=e[1];e=e.index;var g=b.slice(0,e+d.indexOf("@apply"));b=b.slice(e+d.length);var h=c?pa(a,c):{};Object.assign(h,T(a,g));d=void 0;var k=a;f=f.replace(la,"");var n=[];var m=k.a.get(f);m||(k.a.set(f,{}),m=k.a.get(f));if(m){k.c&&(m.i[k.c]=!0);var q=m.h;for(d in q)k=h&&h[d],m=[d,": var(",f,"_-_",d],k&&m.push(",",k.replace(O,"")),m.push(")"),O.test(q[d])&&m.push(" !important"),n.push(m.join(""))}d=n.join("; ");b=g+d+b;H.lastIndex=e+d.length}return b}
function T(a,b,c){c=void 0===c?!1:c;b=b.split(";");for(var e,d,f={},g=0,h;g<b.length;g++)if(e=b[g])if(h=e.split(":"),1<h.length){e=h[0].trim();d=h.slice(1).join(":");if(c){var k=a;h=e;var n=ma.exec(d);n&&(n[1]?(k.b||(k.b=document.createElement("meta"),k.b.setAttribute("apply-shim-measure",""),k.b.style.all="initial",document.head.appendChild(k.b)),h=window.getComputedStyle(k.b).getPropertyValue(h)):h="apply-shim-inherit",d=h)}f[e]=d}return f}function qa(a,b){if(Q)for(var c in b.i)c!==a.c&&Q(c)}
function oa(a,b,c,e,d,f){e&&M(e,function(b,c){c&&a.a.get(c)&&(d="@apply "+c+";")});if(!d)return b;var g=S(a,""+d,f);f=b.slice(0,b.indexOf("--"));var h=g=T(a,g,!0),k=a.a.get(c),n=k&&k.h;n?h=Object.assign(Object.create(n),g):a.a.set(c,h);var m=[],q,Z=!1;for(q in h){var F=g[q];void 0===F&&(F="initial");!n||q in n||(Z=!0);m.push(c+"_-_"+q+": "+F)}Z&&qa(a,k);k&&(k.h=h);e&&(f=b+";"+f);return f+m.join("; ")+";"}R.prototype.detectMixin=R.prototype.o;R.prototype.transformStyle=R.prototype.j;
R.prototype.transformCustomStyle=R.prototype.f;R.prototype.transformRules=R.prototype.l;R.prototype.transformRule=R.prototype.g;R.prototype.transformTemplate=R.prototype.m;R.prototype._separator="_-_";Object.defineProperty(R.prototype,"invalidCallback",{get:function(){return Q},set:function(a){Q=a}});var U={};var ra=Promise.resolve();function sa(a){if(a=U[a])a._applyShimCurrentVersion=a._applyShimCurrentVersion||0,a._applyShimValidatingVersion=a._applyShimValidatingVersion||0,a._applyShimNextVersion=(a._applyShimNextVersion||0)+1}function ta(a){return a._applyShimCurrentVersion===a._applyShimNextVersion}function ua(a){a._applyShimValidatingVersion=a._applyShimNextVersion;a._validating||(a._validating=!0,ra.then(function(){a._applyShimCurrentVersion=a._applyShimNextVersion;a._validating=!1}))};var V=new R;function W(){this.a=null;V.invalidCallback=sa}function X(a){!a.a&&window.ShadyCSS.CustomStyleInterface&&(a.a=window.ShadyCSS.CustomStyleInterface,a.a.transformCallback=function(a){V.f(a)},a.a.validateCallback=function(){requestAnimationFrame(function(){a.a.enqueued&&a.flushCustomStyles()})})}W.prototype.prepareTemplate=function(a,b){X(this);""===N(a)&&(U[b]=a,b=V.m(a,b),a._styleAst=b)};
W.prototype.flushCustomStyles=function(){X(this);if(this.a){var a=this.a.processStyles();if(this.a.enqueued){for(var b=0;b<a.length;b++){var c=this.a.getStyleForCustomStyle(a[b]);c&&V.f(c)}this.a.enqueued=!1}}};
W.prototype.styleSubtree=function(a,b){X(this);if(b)for(var c in b)null===c?a.style.removeProperty(c):a.style.setProperty(c,b[c]);if(a.shadowRoot)for(this.styleElement(a),a=a.shadowRoot.children||a.shadowRoot.childNodes,b=0;b<a.length;b++)this.styleSubtree(a[b]);else for(a=a.children||a.childNodes,b=0;b<a.length;b++)this.styleSubtree(a[b])};
W.prototype.styleElement=function(a){X(this);var b=a.localName,c;b?-1<b.indexOf("-")?c=b:c=a.getAttribute&&a.getAttribute("is")||"":c=a.is;b=U[c];if(!(b&&""!==N(b)||!b||ta(b))){if(ta(b)||b._applyShimValidatingVersion!==b._applyShimNextVersion)this.prepareTemplate(b,c),ua(b);if(a=a.shadowRoot)if(a=a.querySelector("style"))a.__cssRules=b._styleAst,a.textContent=J(b._styleAst)}};W.prototype.styleDocument=function(a){X(this);this.styleSubtree(document.body,a)};
if(!window.ShadyCSS||!window.ShadyCSS.ScopingShim){var Y=new W,va=window.ShadyCSS&&window.ShadyCSS.CustomStyleInterface;window.ShadyCSS={prepareTemplate:function(a,b){Y.flushCustomStyles();Y.prepareTemplate(a,b)},prepareTemplateStyles:function(a,b,c){window.ShadyCSS.prepareTemplate(a,b,c)},prepareTemplateDom:function(){},styleSubtree:function(a,b){Y.flushCustomStyles();Y.styleSubtree(a,b)},styleElement:function(a){Y.flushCustomStyles();Y.styleElement(a)},styleDocument:function(a){Y.flushCustomStyles();
Y.styleDocument(a)},getComputedStyleValue:function(a,b){return(a=window.getComputedStyle(a).getPropertyValue(b))?a.trim():""},flushCustomStyles:function(){Y.flushCustomStyles()},nativeCss:u,nativeShadow:l,cssBuild:v,disableRuntime:aa};va&&(window.ShadyCSS.CustomStyleInterface=va)}window.ShadyCSS.ApplyShim=V;}).call(this);




(function() {
  'use strict';

  const userPolymer = window.Polymer;

  /**
   * @namespace Polymer
   * @summary Polymer is a lightweight library built on top of the web
   *   standards-based Web Components API's, and makes it easy to build your
   *   own custom HTML elements.
   * @param {!PolymerInit} info Prototype for the custom element. It must contain
   *   an `is` property to specify the element name. Other properties populate
   *   the element prototype. The `properties`, `observers`, `hostAttributes`,
   *   and `listeners` properties are processed to create element features.
   * @return {!Object} Returns a custom element class for the given provided
   *   prototype `info` object. The name of the element if given by `info.is`.
   */
  window.Polymer = function(info) {
    return window.Polymer._polymerFn(info);
  };

  // support user settings on the Polymer object
  if (userPolymer) {
    Object.assign(Polymer, userPolymer);
  }

  // To be plugged by legacy implementation if loaded
  /* eslint-disable valid-jsdoc */
  /**
   * @param {!PolymerInit} info Prototype for the custom element. It must contain
   *   an `is` property to specify the element name. Other properties populate
   *   the element prototype. The `properties`, `observers`, `hostAttributes`,
   *   and `listeners` properties are processed to create element features.
   * @return {!Object} Returns a custom element class for the given provided
   *   prototype `info` object. The name of the element if given by `info.is`.
   */
  window.Polymer._polymerFn = function(info) { // eslint-disable-line no-unused-vars
    throw new Error('Load polymer.html to use the Polymer() function.');
  };
  /* eslint-enable */

  window.Polymer.version = '2.7.0';

  /* eslint-disable no-unused-vars */
  /*
  When using Closure Compiler, JSCompiler_renameProperty(property, object) is replaced by the munged name for object[property]
  We cannot alias this function, so we have to use a small shim that has the same behavior when not compiling.
  */
  window.JSCompiler_renameProperty = function(prop, obj) {
    return prop;
  };
  /* eslint-enable */

})();



  (function() {
    'use strict';

    let CSS_URL_RX = /(url\()([^)]*)(\))/g;
    let ABS_URL = /(^\/)|(^#)|(^[\w-\d]*:)/;
    let workingURL;
    let resolveDoc;
    /**
     * Resolves the given URL against the provided `baseUri'.
     * 
     * Note that this function performs no resolution for URLs that start
     * with `/` (absolute URLs) or `#` (hash identifiers).  For general purpose
     * URL resolution, use `window.URL`.
     *
     * @memberof Polymer.ResolveUrl
     * @param {string} url Input URL to resolve
     * @param {?string=} baseURI Base URI to resolve the URL against
     * @return {string} resolved URL
     */
    function resolveUrl(url, baseURI) {
      if (url && ABS_URL.test(url)) {
        return url;
      }
      // Lazy feature detection.
      if (workingURL === undefined) {
        workingURL = false;
        try {
          const u = new URL('b', 'http://a');
          u.pathname = 'c%20d';
          workingURL = (u.href === 'http://a/c%20d');
        } catch (e) {
          // silently fail
        }
      }
      if (!baseURI) {
        baseURI = document.baseURI || window.location.href;
      }
      if (workingURL) {
        return (new URL(url, baseURI)).href;
      }
      // Fallback to creating an anchor into a disconnected document.
      if (!resolveDoc) {
        resolveDoc = document.implementation.createHTMLDocument('temp');
        resolveDoc.base = resolveDoc.createElement('base');
        resolveDoc.head.appendChild(resolveDoc.base);
        resolveDoc.anchor = resolveDoc.createElement('a');
        resolveDoc.body.appendChild(resolveDoc.anchor);
      }
      resolveDoc.base.href = baseURI;
      resolveDoc.anchor.href = url;
      return resolveDoc.anchor.href || url;

    }

    /**
     * Resolves any relative URL's in the given CSS text against the provided
     * `ownerDocument`'s `baseURI`.
     *
     * @memberof Polymer.ResolveUrl
     * @param {string} cssText CSS text to process
     * @param {string} baseURI Base URI to resolve the URL against
     * @return {string} Processed CSS text with resolved URL's
     */
    function resolveCss(cssText, baseURI) {
      return cssText.replace(CSS_URL_RX, function(m, pre, url, post) {
        return pre + '\'' +
          resolveUrl(url.replace(/["']/g, ''), baseURI) +
          '\'' + post;
      });
    }

    /**
     * Returns a path from a given `url`. The path includes the trailing
     * `/` from the url.
     *
     * @memberof Polymer.ResolveUrl
     * @param {string} url Input URL to transform
     * @return {string} resolved path
     */
    function pathFromUrl(url) {
      return url.substring(0, url.lastIndexOf('/') + 1);
    }

    /**
     * Module with utilities for resolving relative URL's.
     *
     * @namespace
     * @memberof Polymer
     * @summary Module with utilities for resolving relative URL's.
     */
    Polymer.ResolveUrl = {
      resolveCss: resolveCss,
      resolveUrl: resolveUrl,
      pathFromUrl: pathFromUrl
    };

  })();



/** @suppress {deprecated} */
(function() {
  'use strict';

  /**
   * Sets the global, legacy settings.
   *
   * @deprecated
   * @namespace
   * @memberof Polymer
   */
  Polymer.Settings = Polymer.Settings || {};

  Polymer.Settings.useShadow = !(window.ShadyDOM);
  Polymer.Settings.useNativeCSSProperties =
    Boolean(!window.ShadyCSS || window.ShadyCSS.nativeCss);
  Polymer.Settings.useNativeCustomElements =
    !(window.customElements.polyfillWrapFlushCallback);


  /**
   * Globally settable property that is automatically assigned to
   * `Polymer.ElementMixin` instances, useful for binding in templates to
   * make URL's relative to an application's root.  Defaults to the main
   * document URL, but can be overridden by users.  It may be useful to set
   * `Polymer.rootPath` to provide a stable application mount path when
   * using client side routing.
   *
   * @memberof Polymer
   */
  Polymer.rootPath = Polymer.rootPath ||
    Polymer.ResolveUrl.pathFromUrl(document.baseURI || window.location.href);

  /**
   * Sets the global rootPath property used by `Polymer.ElementMixin` and
   * available via `Polymer.rootPath`.
   *
   * @memberof Polymer
   * @param {string} path The new root path
   * @return {void}
   */
  Polymer.setRootPath = function(path) {
    Polymer.rootPath = path;
  };

  /**
   * A global callback used to sanitize any value before inserting it into the DOM. The callback signature is:
   *
   *     Polymer = {
   *       sanitizeDOMValue: function(value, name, type, node) { ... }
   *     }
   *
   * Where:
   *
   * `value` is the value to sanitize.
   * `name` is the name of an attribute or property (for example, href).
   * `type` indicates where the value is being inserted: one of property, attribute, or text.
   * `node` is the node where the value is being inserted.
   *
   * @type {(function(*,string,string,Node):*)|undefined}
   * @memberof Polymer
   */
  Polymer.sanitizeDOMValue = Polymer.sanitizeDOMValue || null;

  /**
   * Sets the global sanitizeDOMValue available via `Polymer.sanitizeDOMValue`.
   *
   * @memberof Polymer
   * @param {(function(*,string,string,Node):*)|undefined} newSanitizeDOMValue the global sanitizeDOMValue callback
   * @return {void}
   */
  Polymer.setSanitizeDOMValue = function(newSanitizeDOMValue) {
    Polymer.sanitizeDOMValue = newSanitizeDOMValue;
  };

  /**
   * Globally settable property to make Polymer Gestures use passive TouchEvent listeners when recognizing gestures.
   * When set to `true`, gestures made from touch will not be able to prevent scrolling, allowing for smoother
   * scrolling performance.
   * Defaults to `false` for backwards compatibility.
   *
   * @memberof Polymer
   */
  Polymer.passiveTouchGestures = Polymer.passiveTouchGestures || false;

  /**
   * Sets `passiveTouchGestures` globally for all elements using Polymer Gestures.
   *
   * @memberof Polymer
   * @param {boolean} usePassive enable or disable passive touch gestures globally
   * @return {void}
   */
  Polymer.setPassiveTouchGestures = function(usePassive) {
    Polymer.passiveTouchGestures = usePassive;
  };

  Polymer.legacyOptimizations = Polymer.legacyOptimizations ||
      window.PolymerSettings && window.PolymerSettings.legacyOptimizations || false;

  /**
   * Sets `legacyOptimizations` globally for all elements. Enables
   * optimizations when only legacy Polymer() style elements are used.
   *
   * @memberof Polymer
   * @param {boolean} useLegacyOptimizations enable or disable legacy optimizations globally.
   * @return {void}
   */
  Polymer.setLegacyOptimizations = function(useLegacyOptimizations) {
    Polymer.legacyOptimizations = useLegacyOptimizations;
  };
})();



(function() {

  'use strict';

  // unique global id for deduping mixins.
  let dedupeId = 0;

  /**
   * @constructor
   * @extends {Function}
   * @private
   */
  function MixinFunction(){}
  /** @type {(WeakMap | undefined)} */
  MixinFunction.prototype.__mixinApplications;
  /** @type {(Object | undefined)} */
  MixinFunction.prototype.__mixinSet;

  /* eslint-disable valid-jsdoc */
  /**
   * Wraps an ES6 class expression mixin such that the mixin is only applied
   * if it has not already been applied its base argument. Also memoizes mixin
   * applications.
   *
   * @memberof Polymer
   * @template T
   * @param {T} mixin ES6 class expression mixin to wrap
   * @return {T}
   * @suppress {invalidCasts}
   */
  Polymer.dedupingMixin = function(mixin) {
    let mixinApplications = /** @type {!MixinFunction} */(mixin).__mixinApplications;
    if (!mixinApplications) {
      mixinApplications = new WeakMap();
      /** @type {!MixinFunction} */(mixin).__mixinApplications = mixinApplications;
    }
    // maintain a unique id for each mixin
    let mixinDedupeId = dedupeId++;
    function dedupingMixin(base) {
      let baseSet = /** @type {!MixinFunction} */(base).__mixinSet;
      if (baseSet && baseSet[mixinDedupeId]) {
        return base;
      }
      let map = mixinApplications;
      let extended = map.get(base);
      if (!extended) {
        extended = /** @type {!Function} */(mixin)(base);
        map.set(base, extended);
      }
      // copy inherited mixin set from the extended class, or the base class
      // NOTE: we avoid use of Set here because some browser (IE11)
      // cannot extend a base Set via the constructor.
      let mixinSet = Object.create(/** @type {!MixinFunction} */(extended).__mixinSet || baseSet || null);
      mixinSet[mixinDedupeId] = true;
      /** @type {!MixinFunction} */(extended).__mixinSet = mixinSet;
      return extended;
    }

    return /** @type {T} */ (dedupingMixin);
  };
  /* eslint-enable valid-jsdoc */

})();



(function() {
  'use strict';

  const MODULE_STYLE_LINK_SELECTOR = 'link[rel=import][type~=css]';
  const INCLUDE_ATTR = 'include';
  const SHADY_UNSCOPED_ATTR = 'shady-unscoped';

  function importModule(moduleId) {
    const /** Polymer.DomModule */ PolymerDomModule = customElements.get('dom-module');
    if (!PolymerDomModule) {
      return null;
    }
    return PolymerDomModule.import(moduleId);
  }

  function styleForImport(importDoc) {
    // NOTE: polyfill affordance.
    // under the HTMLImports polyfill, there will be no 'body',
    // but the import pseudo-doc can be used directly.
    let container = importDoc.body ? importDoc.body : importDoc;
    const importCss = Polymer.ResolveUrl.resolveCss(container.textContent,
      importDoc.baseURI);
    const style = document.createElement('style');
    style.textContent = importCss;
    return style;
  }

  /** @typedef {{assetpath: string}} */
  let templateWithAssetPath; // eslint-disable-line no-unused-vars

  /**
   * Module with utilities for collection CSS text from `<templates>`, external
   * stylesheets, and `dom-module`s.
   *
   * @namespace
   * @memberof Polymer
   * @summary Module with utilities for collection CSS text from various sources.
   */
  const StyleGather = {

    /**
     * Returns a list of <style> elements in a space-separated list of `dom-module`s.
     *
     * @memberof Polymer.StyleGather
     * @param {string} moduleIds List of dom-module id's within which to
     * search for css.
     * @return {!Array<!HTMLStyleElement>} Array of contained <style> elements
     * @this {StyleGather}
     */
     stylesFromModules(moduleIds) {
      const modules = moduleIds.trim().split(/\s+/);
      const styles = [];
      for (let i=0; i < modules.length; i++) {
        styles.push(...this.stylesFromModule(modules[i]));
      }
      return styles;
    },

    /**
     * Returns a list of <style> elements in a given `dom-module`.
     * Styles in a `dom-module` can come either from `<style>`s within the
     * first `<template>`, or else from one or more
     * `<link rel="import" type="css">` links outside the template.
     *
     * @memberof Polymer.StyleGather
     * @param {string} moduleId dom-module id to gather styles from
     * @return {!Array<!HTMLStyleElement>} Array of contained styles.
     * @this {StyleGather}
     */
    stylesFromModule(moduleId) {
      const m = importModule(moduleId);

      if (!m) {
        console.warn('Could not find style data in module named', moduleId);
        return [];
      }

      if (m._styles === undefined) {
        const styles = [];
        // module imports: <link rel="import" type="css">
        styles.push(...this._stylesFromModuleImports(m));
        // include css from the first template in the module
        const template = m.querySelector('template');
        if (template) {
          styles.push(...this.stylesFromTemplate(template,
            /** @type {templateWithAssetPath} */(m).assetpath));
        }

        m._styles = styles;
      }

      return m._styles;
    },

    /**
     * Returns the `<style>` elements within a given template.
     *
     * @memberof Polymer.StyleGather
     * @param {!HTMLTemplateElement} template Template to gather styles from
     * @param {string} baseURI baseURI for style content
     * @return {!Array<!HTMLStyleElement>} Array of styles
     * @this {StyleGather}
     */
    stylesFromTemplate(template, baseURI) {
      if (!template._styles) {
        const styles = [];
        // if element is a template, get content from its .content
        const e$ = template.content.querySelectorAll('style');
        for (let i=0; i < e$.length; i++) {
          let e = e$[i];
          // support style sharing by allowing styles to "include"
          // other dom-modules that contain styling
          let include = e.getAttribute(INCLUDE_ATTR);
          if (include) {
            styles.push(...this.stylesFromModules(include).filter(function(item, index, self) {
              return self.indexOf(item) === index;
            }));
          }
          if (baseURI) {
            e.textContent = Polymer.ResolveUrl.resolveCss(e.textContent, baseURI);
          }
          styles.push(e);
        }
        template._styles = styles;
      }
      return template._styles;
    },

    /**
     * Returns a list of <style> elements  from stylesheets loaded via `<link rel="import" type="css">` links within the specified `dom-module`.
     *
     * @memberof Polymer.StyleGather
     * @param {string} moduleId Id of `dom-module` to gather CSS from
     * @return {!Array<!HTMLStyleElement>} Array of contained styles.
     * @this {StyleGather}
     */
     stylesFromModuleImports(moduleId) {
      let m = importModule(moduleId);
      return m ? this._stylesFromModuleImports(m) : [];
    },

    /**
     * @memberof Polymer.StyleGather
     * @this {StyleGather}
     * @param {!HTMLElement} module dom-module element that could contain `<link rel="import" type="css">` styles
     * @return {!Array<!HTMLStyleElement>} Array of contained styles
     */
    _stylesFromModuleImports(module) {
      const styles = [];
      const p$ = module.querySelectorAll(MODULE_STYLE_LINK_SELECTOR);
      for (let i=0; i < p$.length; i++) {
        let p = p$[i];
        if (p.import) {
          const importDoc = p.import;
          const unscoped = p.hasAttribute(SHADY_UNSCOPED_ATTR);
          if (unscoped && !importDoc._unscopedStyle) {
            const style = styleForImport(importDoc);
            style.setAttribute(SHADY_UNSCOPED_ATTR, '');
            importDoc._unscopedStyle = style;
          } else if (!importDoc._style) {
            importDoc._style = styleForImport(importDoc);
          }
          styles.push(unscoped ? importDoc._unscopedStyle : importDoc._style);
        }
      }
      return styles;
    },

    /**
     *
     * Returns CSS text of styles in a space-separated list of `dom-module`s.
     * Note: This method is deprecated, use `stylesFromModules` instead.
     *
     * @deprecated
     * @memberof Polymer.StyleGather
     * @param {string} moduleIds List of dom-module id's within which to
     * search for css.
     * @return {string} Concatenated CSS content from specified `dom-module`s
     * @this {StyleGather}
     */
     cssFromModules(moduleIds) {
      let modules = moduleIds.trim().split(/\s+/);
      let cssText = '';
      for (let i=0; i < modules.length; i++) {
        cssText += this.cssFromModule(modules[i]);
      }
      return cssText;
    },

    /**
     * Returns CSS text of styles in a given `dom-module`.  CSS in a `dom-module`
     * can come either from `<style>`s within the first `<template>`, or else
     * from one or more `<link rel="import" type="css">` links outside the
     * template.
     *
     * Any `<styles>` processed are removed from their original location.
     * Note: This method is deprecated, use `styleFromModule` instead.
     *
     * @deprecated
     * @memberof Polymer.StyleGather
     * @param {string} moduleId dom-module id to gather styles from
     * @return {string} Concatenated CSS content from specified `dom-module`
     * @this {StyleGather}
     */
    cssFromModule(moduleId) {
      let m = importModule(moduleId);
      if (m && m._cssText === undefined) {
        // module imports: <link rel="import" type="css">
        let cssText = this._cssFromModuleImports(m);
        // include css from the first template in the module
        let t = m.querySelector('template');
        if (t) {
          cssText += this.cssFromTemplate(t,
            /** @type {templateWithAssetPath} */(m).assetpath);
        }
        m._cssText = cssText || null;
      }
      if (!m) {
        console.warn('Could not find style data in module named', moduleId);
      }
      return m && m._cssText || '';
    },

    /**
     * Returns CSS text of `<styles>` within a given template.
     *
     * Any `<styles>` processed are removed from their original location.
     * Note: This method is deprecated, use `styleFromTemplate` instead.
     *
     * @deprecated
     * @memberof Polymer.StyleGather
     * @param {!HTMLTemplateElement} template Template to gather styles from
     * @param {string} baseURI Base URI to resolve the URL against
     * @return {string} Concatenated CSS content from specified template
     * @this {StyleGather}
     */
    cssFromTemplate(template, baseURI) {
      let cssText = '';
      const e$ = this.stylesFromTemplate(template, baseURI);
      // if element is a template, get content from its .content
      for (let i=0; i < e$.length; i++) {
        let e = e$[i];
        if (e.parentNode) {
          e.parentNode.removeChild(e);
        }
        cssText += e.textContent;
      }
      return cssText;
    },

    /**
     * Returns CSS text from stylesheets loaded via `<link rel="import" type="css">`
     * links within the specified `dom-module`.
     *
     * Note: This method is deprecated, use `stylesFromModuleImports` instead.
     *
     * @deprecated
     *
     * @memberof Polymer.StyleGather
     * @param {string} moduleId Id of `dom-module` to gather CSS from
     * @return {string} Concatenated CSS content from links in specified `dom-module`
     * @this {StyleGather}
     */
    cssFromModuleImports(moduleId) {
      let m = importModule(moduleId);
      return m ? this._cssFromModuleImports(m) : '';
    },

    /**
     * @deprecated
     * @memberof Polymer.StyleGather
     * @this {StyleGather}
     * @param {!HTMLElement} module dom-module element that could contain `<link rel="import" type="css">` styles
     * @return {string} Concatenated CSS content from links in the dom-module
     */
     _cssFromModuleImports(module) {
      let cssText = '';
      let styles = this._stylesFromModuleImports(module);
      for (let i=0; i < styles.length; i++) {
        cssText += styles[i].textContent;
      }
      return cssText;
    }
  };

  Polymer.StyleGather = StyleGather;
})();


(function() {
  'use strict';

  let modules = {};
  let lcModules = {};
  function setModule(id, module) {
    // store id separate from lowercased id so that
    // in all cases mixedCase id will stored distinctly
    // and lowercase version is a fallback
    modules[id] = lcModules[id.toLowerCase()] = module;
  }
  function findModule(id) {
    return modules[id] || lcModules[id.toLowerCase()];
  }

  function styleOutsideTemplateCheck(inst) {
    if (inst.querySelector('style')) {
      console.warn('dom-module %s has style outside template', inst.id);
    }
  }

  /**
   * The `dom-module` element registers the dom it contains to the name given
   * by the module's id attribute. It provides a unified database of dom
   * accessible via its static `import` API.
   *
   * A key use case of `dom-module` is for providing custom element `<template>`s
   * via HTML imports that are parsed by the native HTML parser, that can be
   * relocated during a bundling pass and still looked up by `id`.
   *
   * Example:
   *
   *     <dom-module id="foo">
   *       <img src="stuff.png">
   *     </dom-module>
   *
   * Then in code in some other location that cannot access the dom-module above
   *
   *     let img = customElements.get('dom-module').import('foo', 'img');
   *
   * @customElement
   * @extends HTMLElement
   * @memberof Polymer
   * @summary Custom element that provides a registry of relocatable DOM content
   *   by `id` that is agnostic to bundling.
   * @unrestricted
   */
  class DomModule extends HTMLElement {

    static get observedAttributes() { return ['id']; }

    /**
     * Retrieves the element specified by the css `selector` in the module
     * registered by `id`. For example, this.import('foo', 'img');
     * @param {string} id The id of the dom-module in which to search.
     * @param {string=} selector The css selector by which to find the element.
     * @return {Element} Returns the element which matches `selector` in the
     * module registered at the specified `id`.
     */
    static import(id, selector) {
      if (id) {
        let m = findModule(id);
        if (m && selector) {
          return m.querySelector(selector);
        }
        return m;
      }
      return null;
    }

    /* eslint-disable no-unused-vars */
    /**
     * @param {string} name Name of attribute.
     * @param {?string} old Old value of attribute.
     * @param {?string} value Current value of attribute.
     * @param {?string} namespace Attribute namespace.
     * @return {void}
     */
    attributeChangedCallback(name, old, value, namespace) {
      if (old !== value) {
        this.register();
      }
    }
    /* eslint-enable no-unused-args */

    /**
     * The absolute URL of the original location of this `dom-module`.
     *
     * This value will differ from this element's `ownerDocument` in the
     * following ways:
     * - Takes into account any `assetpath` attribute added during bundling
     *   to indicate the original location relative to the bundled location
     * - Uses the HTMLImports polyfill's `importForElement` API to ensure
     *   the path is relative to the import document's location since
     *   `ownerDocument` is not currently polyfilled
     */
    get assetpath() {
      // Don't override existing assetpath.
      if (!this.__assetpath) {
        // note: assetpath set via an attribute must be relative to this
        // element's location; accomodate polyfilled HTMLImports
        const owner = window.HTMLImports && HTMLImports.importForElement ?
          HTMLImports.importForElement(this) || document : this.ownerDocument;
        const url = Polymer.ResolveUrl.resolveUrl(
          this.getAttribute('assetpath') || '', owner.baseURI);
        this.__assetpath = Polymer.ResolveUrl.pathFromUrl(url);
      }
      return this.__assetpath;
    }

    /**
     * Registers the dom-module at a given id. This method should only be called
     * when a dom-module is imperatively created. For
     * example, `document.createElement('dom-module').register('foo')`.
     * @param {string=} id The id at which to register the dom-module.
     * @return {void}
     */
    register(id) {
      id = id || this.id;
      if (id) {
        // Under strictTemplatePolicy, reject and null out any re-registered
        // dom-module since it is ambiguous whether first-in or last-in is trusted 
        if (Polymer.strictTemplatePolicy && findModule(id) !== undefined) {
          setModule(id, null);
          throw new Error(`strictTemplatePolicy: dom-module ${id} re-registered`);
        }
        this.id = id;
        setModule(id, this);
        styleOutsideTemplateCheck(this);
      }
    }
  }

  DomModule.prototype['modules'] = modules;

  customElements.define('dom-module', DomModule);

  /** @const */
  Polymer.DomModule = DomModule;

})();


(function() {
  'use strict';

  /**
   * Module with utilities for manipulating structured data path strings.
   *
   * @namespace
   * @memberof Polymer
   * @summary Module with utilities for manipulating structured data path strings.
   */
  const Path = {

    /**
     * Returns true if the given string is a structured data path (has dots).
     *
     * Example:
     *
     * ```
     * Polymer.Path.isPath('foo.bar.baz') // true
     * Polymer.Path.isPath('foo')         // false
     * ```
     *
     * @memberof Polymer.Path
     * @param {string} path Path string
     * @return {boolean} True if the string contained one or more dots
     */
    isPath: function(path) {
      return path.indexOf('.') >= 0;
    },

    /**
     * Returns the root property name for the given path.
     *
     * Example:
     *
     * ```
     * Polymer.Path.root('foo.bar.baz') // 'foo'
     * Polymer.Path.root('foo')         // 'foo'
     * ```
     *
     * @memberof Polymer.Path
     * @param {string} path Path string
     * @return {string} Root property name
     */
    root: function(path) {
      let dotIndex = path.indexOf('.');
      if (dotIndex === -1) {
        return path;
      }
      return path.slice(0, dotIndex);
    },

    /**
     * Given `base` is `foo.bar`, `foo` is an ancestor, `foo.bar` is not
     * Returns true if the given path is an ancestor of the base path.
     *
     * Example:
     *
     * ```
     * Polymer.Path.isAncestor('foo.bar', 'foo')         // true
     * Polymer.Path.isAncestor('foo.bar', 'foo.bar')     // false
     * Polymer.Path.isAncestor('foo.bar', 'foo.bar.baz') // false
     * ```
     *
     * @memberof Polymer.Path
     * @param {string} base Path string to test against.
     * @param {string} path Path string to test.
     * @return {boolean} True if `path` is an ancestor of `base`.
     */
    isAncestor: function(base, path) {
      //     base.startsWith(path + '.');
      return base.indexOf(path + '.') === 0;
    },

    /**
     * Given `base` is `foo.bar`, `foo.bar.baz` is an descendant
     *
     * Example:
     *
     * ```
     * Polymer.Path.isDescendant('foo.bar', 'foo.bar.baz') // true
     * Polymer.Path.isDescendant('foo.bar', 'foo.bar')     // false
     * Polymer.Path.isDescendant('foo.bar', 'foo')         // false
     * ```
     *
     * @memberof Polymer.Path
     * @param {string} base Path string to test against.
     * @param {string} path Path string to test.
     * @return {boolean} True if `path` is a descendant of `base`.
     */
    isDescendant: function(base, path) {
      //     path.startsWith(base + '.');
      return path.indexOf(base + '.') === 0;
    },

    /**
     * Replaces a previous base path with a new base path, preserving the
     * remainder of the path.
     *
     * User must ensure `path` has a prefix of `base`.
     *
     * Example:
     *
     * ```
     * Polymer.Path.translate('foo.bar', 'zot', 'foo.bar.baz') // 'zot.baz'
     * ```
     *
     * @memberof Polymer.Path
     * @param {string} base Current base string to remove
     * @param {string} newBase New base string to replace with
     * @param {string} path Path to translate
     * @return {string} Translated string
     */
    translate: function(base, newBase, path) {
      return newBase + path.slice(base.length);
    },

    /**
     * @param {string} base Path string to test against
     * @param {string} path Path string to test
     * @return {boolean} True if `path` is equal to `base`
     * @this {Path}
     */
    matches: function(base, path) {
      return (base === path) ||
             this.isAncestor(base, path) ||
             this.isDescendant(base, path);
    },

    /**
     * Converts array-based paths to flattened path.  String-based paths
     * are returned as-is.
     *
     * Example:
     *
     * ```
     * Polymer.Path.normalize(['foo.bar', 0, 'baz'])  // 'foo.bar.0.baz'
     * Polymer.Path.normalize('foo.bar.0.baz')        // 'foo.bar.0.baz'
     * ```
     *
     * @memberof Polymer.Path
     * @param {string | !Array<string|number>} path Input path
     * @return {string} Flattened path
     */
    normalize: function(path) {
      if (Array.isArray(path)) {
        let parts = [];
        for (let i=0; i<path.length; i++) {
          let args = path[i].toString().split('.');
          for (let j=0; j<args.length; j++) {
            parts.push(args[j]);
          }
        }
        return parts.join('.');
      } else {
        return path;
      }
    },

    /**
     * Splits a path into an array of property names. Accepts either arrays
     * of path parts or strings.
     *
     * Example:
     *
     * ```
     * Polymer.Path.split(['foo.bar', 0, 'baz'])  // ['foo', 'bar', '0', 'baz']
     * Polymer.Path.split('foo.bar.0.baz')        // ['foo', 'bar', '0', 'baz']
     * ```
     *
     * @memberof Polymer.Path
     * @param {string | !Array<string|number>} path Input path
     * @return {!Array<string>} Array of path parts
     * @this {Path}
     * @suppress {checkTypes}
     */
    split: function(path) {
      if (Array.isArray(path)) {
        return this.normalize(path).split('.');
      }
      return path.toString().split('.');
    },

    /**
     * Reads a value from a path.  If any sub-property in the path is `undefined`,
     * this method returns `undefined` (will never throw.
     *
     * @memberof Polymer.Path
     * @param {Object} root Object from which to dereference path from
     * @param {string | !Array<string|number>} path Path to read
     * @param {Object=} info If an object is provided to `info`, the normalized
     *  (flattened) path will be set to `info.path`.
     * @return {*} Value at path, or `undefined` if the path could not be
     *  fully dereferenced.
     * @this {Path}
     */
    get: function(root, path, info) {
      let prop = root;
      let parts = this.split(path);
      // Loop over path parts[0..n-1] and dereference
      for (let i=0; i<parts.length; i++) {
        if (!prop) {
          return;
        }
        let part = parts[i];
        prop = prop[part];
      }
      if (info) {
        info.path = parts.join('.');
      }
      return prop;
    },

    /**
     * Sets a value to a path.  If any sub-property in the path is `undefined`,
     * this method will no-op.
     *
     * @memberof Polymer.Path
     * @param {Object} root Object from which to dereference path from
     * @param {string | !Array<string|number>} path Path to set
     * @param {*} value Value to set to path
     * @return {string | undefined} The normalized version of the input path
     * @this {Path}
     */
    set: function(root, path, value) {
      let prop = root;
      let parts = this.split(path);
      let last = parts[parts.length-1];
      if (parts.length > 1) {
        // Loop over path parts[0..n-2] and dereference
        for (let i=0; i<parts.length-1; i++) {
          let part = parts[i];
          prop = prop[part];
          if (!prop) {
            return;
          }
        }
        // Set value to object at end of path
        prop[last] = value;
      } else {
        // Simple property set
        prop[path] = value;
      }
      return parts.join('.');
    }

  };

  /**
   * Returns true if the given string is a structured data path (has dots).
   *
   * This function is deprecated.  Use `Polymer.Path.isPath` instead.
   *
   * Example:
   *
   * ```
   * Polymer.Path.isDeep('foo.bar.baz') // true
   * Polymer.Path.isDeep('foo')         // false
   * ```
   *
   * @deprecated
   * @memberof Polymer.Path
   * @param {string} path Path string
   * @return {boolean} True if the string contained one or more dots
   */
  Path.isDeep = Path.isPath;

  Polymer.Path = Path;

})();


(function() {
  'use strict';

  const caseMap = {};
  const DASH_TO_CAMEL = /-[a-z]/g;
  const CAMEL_TO_DASH = /([A-Z])/g;

  /**
   * Module with utilities for converting between "dash-case" and "camelCase"
   * identifiers.
   *
   * @namespace
   * @memberof Polymer
   * @summary Module that provides utilities for converting between "dash-case"
   *   and "camelCase".
   */
  const CaseMap = {

    /**
     * Converts "dash-case" identifier (e.g. `foo-bar-baz`) to "camelCase"
     * (e.g. `fooBarBaz`).
     *
     * @memberof Polymer.CaseMap
     * @param {string} dash Dash-case identifier
     * @return {string} Camel-case representation of the identifier
     */
    dashToCamelCase(dash) {
      return caseMap[dash] || (
        caseMap[dash] = dash.indexOf('-') < 0 ? dash : dash.replace(DASH_TO_CAMEL,
          (m) => m[1].toUpperCase()
        )
      );
    },

    /**
     * Converts "camelCase" identifier (e.g. `fooBarBaz`) to "dash-case"
     * (e.g. `foo-bar-baz`).
     *
     * @memberof Polymer.CaseMap
     * @param {string} camel Camel-case identifier
     * @return {string} Dash-case representation of the identifier
     */
    camelToDashCase(camel) {
      return caseMap[camel] || (
        caseMap[camel] = camel.replace(CAMEL_TO_DASH, '-$1').toLowerCase()
      );
    }

  };

  Polymer.CaseMap = CaseMap;
})();


(function() {

  'use strict';

  // Microtask implemented using Mutation Observer
  let microtaskCurrHandle = 0;
  let microtaskLastHandle = 0;
  let microtaskCallbacks = [];
  let microtaskNodeContent = 0;
  let microtaskNode = document.createTextNode('');
  new window.MutationObserver(microtaskFlush).observe(microtaskNode, {characterData: true});

  function microtaskFlush() {
    const len = microtaskCallbacks.length;
    for (let i = 0; i < len; i++) {
      let cb = microtaskCallbacks[i];
      if (cb) {
        try {
          cb();
        } catch (e) {
          setTimeout(() => { throw e; });
        }
      }
    }
    microtaskCallbacks.splice(0, len);
    microtaskLastHandle += len;
  }

  /**
   * Module that provides a number of strategies for enqueuing asynchronous
   * tasks.  Each sub-module provides a standard `run(fn)` interface that returns a
   * handle, and a `cancel(handle)` interface for canceling async tasks before
   * they run.
   *
   * @namespace
   * @memberof Polymer
   * @summary Module that provides a number of strategies for enqueuing asynchronous
   * tasks.
   */
  Polymer.Async = {

    /**
     * Async interface wrapper around `setTimeout`.
     *
     * @namespace
     * @memberof Polymer.Async
     * @summary Async interface wrapper around `setTimeout`.
     */
    timeOut: {
      /**
       * Returns a sub-module with the async interface providing the provided
       * delay.
       *
       * @memberof Polymer.Async.timeOut
       * @param {number=} delay Time to wait before calling callbacks in ms
       * @return {!AsyncInterface} An async timeout interface
       */
      after(delay) {
        return {
          run(fn) { return window.setTimeout(fn, delay); },
          cancel(handle) {
            window.clearTimeout(handle);
          }
        };
      },
      /**
       * Enqueues a function called in the next task.
       *
       * @memberof Polymer.Async.timeOut
       * @param {!Function} fn Callback to run
       * @param {number=} delay Delay in milliseconds
       * @return {number} Handle used for canceling task
       */
      run(fn, delay) {
        return window.setTimeout(fn, delay);
      },
      /**
       * Cancels a previously enqueued `timeOut` callback.
       *
       * @memberof Polymer.Async.timeOut
       * @param {number} handle Handle returned from `run` of callback to cancel
       * @return {void}
       */
      cancel(handle) {
        window.clearTimeout(handle);
      }
    },

    /**
     * Async interface wrapper around `requestAnimationFrame`.
     *
     * @namespace
     * @memberof Polymer.Async
     * @summary Async interface wrapper around `requestAnimationFrame`.
     */
    animationFrame: {
      /**
       * Enqueues a function called at `requestAnimationFrame` timing.
       *
       * @memberof Polymer.Async.animationFrame
       * @param {function(number):void} fn Callback to run
       * @return {number} Handle used for canceling task
       */
      run(fn) {
        return window.requestAnimationFrame(fn);
      },
      /**
       * Cancels a previously enqueued `animationFrame` callback.
       *
       * @memberof Polymer.Async.animationFrame
       * @param {number} handle Handle returned from `run` of callback to cancel
       * @return {void}
       */
      cancel(handle) {
        window.cancelAnimationFrame(handle);
      }
    },

    /**
     * Async interface wrapper around `requestIdleCallback`.  Falls back to
     * `setTimeout` on browsers that do not support `requestIdleCallback`.
     *
     * @namespace
     * @memberof Polymer.Async
     * @summary Async interface wrapper around `requestIdleCallback`.
     */
    idlePeriod: {
      /**
       * Enqueues a function called at `requestIdleCallback` timing.
       *
       * @memberof Polymer.Async.idlePeriod
       * @param {function(!IdleDeadline):void} fn Callback to run
       * @return {number} Handle used for canceling task
       */
      run(fn) {
        return window.requestIdleCallback ?
          window.requestIdleCallback(fn) :
          window.setTimeout(fn, 16);
      },
      /**
       * Cancels a previously enqueued `idlePeriod` callback.
       *
       * @memberof Polymer.Async.idlePeriod
       * @param {number} handle Handle returned from `run` of callback to cancel
       * @return {void}
       */
      cancel(handle) {
        window.cancelIdleCallback ?
          window.cancelIdleCallback(handle) :
          window.clearTimeout(handle);
      }
    },

    /**
     * Async interface for enqueuing callbacks that run at microtask timing.
     *
     * Note that microtask timing is achieved via a single `MutationObserver`,
     * and thus callbacks enqueued with this API will all run in a single
     * batch, and not interleaved with other microtasks such as promises.
     * Promises are avoided as an implementation choice for the time being
     * due to Safari bugs that cause Promises to lack microtask guarantees.
     *
     * @namespace
     * @memberof Polymer.Async
     * @summary Async interface for enqueuing callbacks that run at microtask
     *   timing.
     */
    microTask: {

      /**
       * Enqueues a function called at microtask timing.
       *
       * @memberof Polymer.Async.microTask
       * @param {!Function=} callback Callback to run
       * @return {number} Handle used for canceling task
       */
      run(callback) {
        microtaskNode.textContent = microtaskNodeContent++;
        microtaskCallbacks.push(callback);
        return microtaskCurrHandle++;
      },

      /**
       * Cancels a previously enqueued `microTask` callback.
       *
       * @memberof Polymer.Async.microTask
       * @param {number} handle Handle returned from `run` of callback to cancel
       * @return {void}
       */
      cancel(handle) {
        const idx = handle - microtaskLastHandle;
        if (idx >= 0) {
          if (!microtaskCallbacks[idx]) {
            throw new Error('invalid async handle: ' + handle);
          }
          microtaskCallbacks[idx] = null;
        }
      }

    }
  };

})();


  (function () {

    'use strict';

    /** @const {!AsyncInterface} */
    const microtask = Polymer.Async.microTask;

    /**
     * Element class mixin that provides basic meta-programming for creating one
     * or more property accessors (getter/setter pair) that enqueue an async
     * (batched) `_propertiesChanged` callback.
     *
     * For basic usage of this mixin, call `MyClass.createProperties(props)`
     * once at class definition time to create property accessors for properties
     * named in props, implement `_propertiesChanged` to react as desired to
     * property changes, and implement `static get observedAttributes()` and
     * include lowercase versions of any property names that should be set from
     * attributes. Last, call `this._enableProperties()` in the element's
     * `connectedCallback` to enable the accessors.
     *
     * @mixinFunction
     * @polymer
     * @memberof Polymer
     * @summary Element class mixin for reacting to property changes from
     *   generated property accessors.
     */
    Polymer.PropertiesChanged = Polymer.dedupingMixin(superClass => {

      /**
       * @polymer
       * @mixinClass
       * @extends {superClass}
       * @implements {Polymer_PropertiesChanged}
       * @unrestricted
       */
      class PropertiesChanged extends superClass {

        /**
         * Creates property accessors for the given property names.
         * @param {!Object} props Object whose keys are names of accessors.
         * @return {void}
         * @protected
         */
        static createProperties(props) {
          const proto = this.prototype;
          for (let prop in props) {
            // don't stomp an existing accessor
            if (!(prop in proto)) {
              proto._createPropertyAccessor(prop);
            }
          }
        }

        /**
         * Returns an attribute name that corresponds to the given property.
         * The attribute name is the lowercased property name. Override to
         * customize this mapping.
         * @param {string} property Property to convert
         * @return {string} Attribute name corresponding to the given property.
         *
         * @protected
         */
        static attributeNameForProperty(property) {
          return property.toLowerCase();
        }

        /**
         * Override point to provide a type to which to deserialize a value to
         * a given property.
         * @param {string} name Name of property
         *
         * @protected
         */
        static typeForProperty(name) { } //eslint-disable-line no-unused-vars

        /**
         * Creates a setter/getter pair for the named property with its own
         * local storage.  The getter returns the value in the local storage,
         * and the setter calls `_setProperty`, which updates the local storage
         * for the property and enqueues a `_propertiesChanged` callback.
         *
         * This method may be called on a prototype or an instance.  Calling
         * this method may overwrite a property value that already exists on
         * the prototype/instance by creating the accessor.
         *
         * @param {string} property Name of the property
         * @param {boolean=} readOnly When true, no setter is created; the
         *   protected `_setProperty` function must be used to set the property
         * @return {void}
         * @protected
         */
        _createPropertyAccessor(property, readOnly) {
          this._addPropertyToAttributeMap(property);
          if (!this.hasOwnProperty('__dataHasAccessor')) {
            this.__dataHasAccessor = Object.assign({}, this.__dataHasAccessor);
          }
          if (!this.__dataHasAccessor[property]) {
            this.__dataHasAccessor[property] = true;
            this._definePropertyAccessor(property, readOnly);
          }
        }

        /**
         * Adds the given `property` to a map matching attribute names
         * to property names, using `attributeNameForProperty`. This map is
         * used when deserializing attribute values to properties.
         *
         * @param {string} property Name of the property
         */
        _addPropertyToAttributeMap(property) {
          if (!this.hasOwnProperty('__dataAttributes')) {
            this.__dataAttributes = Object.assign({}, this.__dataAttributes);
          }
          if (!this.__dataAttributes[property]) {
            const attr = this.constructor.attributeNameForProperty(property);
            this.__dataAttributes[attr] = property;
          }
        }

        /**
         * Defines a property accessor for the given property.
         * @param {string} property Name of the property
         * @param {boolean=} readOnly When true, no setter is created
         * @return {void}
         */
         _definePropertyAccessor(property, readOnly) {
          Object.defineProperty(this, property, {
            /* eslint-disable valid-jsdoc */
            /** @this {PropertiesChanged} */
            get() {
              return this._getProperty(property);
            },
            /** @this {PropertiesChanged} */
            set: readOnly ? function () {} : function (value) {
              this._setProperty(property, value);
            }
            /* eslint-enable */
          });
        }

        constructor() {
          super();
          this.__dataEnabled = false;
          this.__dataReady = false;
          this.__dataInvalid = false;
          this.__data = {};
          this.__dataPending = null;
          this.__dataOld = null;
          this.__dataInstanceProps = null;
          this.__serializing = false;
          this._initializeProperties();
        }

        /**
         * Lifecycle callback called when properties are enabled via
         * `_enableProperties`.
         *
         * Users may override this function to implement behavior that is
         * dependent on the element having its property data initialized, e.g.
         * from defaults (initialized from `constructor`, `_initializeProperties`),
         * `attributeChangedCallback`, or values propagated from host e.g. via
         * bindings.  `super.ready()` must be called to ensure the data system
         * becomes enabled.
         *
         * @return {void}
         * @public
         */
        ready() {
          this.__dataReady = true;
          this._flushProperties();
        }

        /**
         * Initializes the local storage for property accessors.
         *
         * Provided as an override point for performing any setup work prior
         * to initializing the property accessor system.
         *
         * @return {void}
         * @protected
         */
        _initializeProperties() {
          // Capture instance properties; these will be set into accessors
          // during first flush. Don't set them here, since we want
          // these to overwrite defaults/constructor assignments
          for (let p in this.__dataHasAccessor) {
            if (this.hasOwnProperty(p)) {
              this.__dataInstanceProps = this.__dataInstanceProps || {};
              this.__dataInstanceProps[p] = this[p];
              delete this[p];
            }
          }
        }

        /**
         * Called at ready time with bag of instance properties that overwrote
         * accessors when the element upgraded.
         *
         * The default implementation sets these properties back into the
         * setter at ready time.  This method is provided as an override
         * point for customizing or providing more efficient initialization.
         *
         * @param {Object} props Bag of property values that were overwritten
         *   when creating property accessors.
         * @return {void}
         * @protected
         */
        _initializeInstanceProperties(props) {
          Object.assign(this, props);
        }

        /**
         * Updates the local storage for a property (via `_setPendingProperty`)
         * and enqueues a `_proeprtiesChanged` callback.
         *
         * @param {string} property Name of the property
         * @param {*} value Value to set
         * @return {void}
         * @protected
         */
        _setProperty(property, value) {
          if (this._setPendingProperty(property, value)) {
            this._invalidateProperties();
          }
        }

        /**
         * Returns the value for the given property.
         * @param {string} property Name of property
         * @return {*} Value for the given property
         * @protected
         */
        _getProperty(property) {
          return this.__data[property];
        }

        /* eslint-disable no-unused-vars */
        /**
         * Updates the local storage for a property, records the previous value,
         * and adds it to the set of "pending changes" that will be passed to the
         * `_propertiesChanged` callback.  This method does not enqueue the
         * `_propertiesChanged` callback.
         *
         * @param {string} property Name of the property
         * @param {*} value Value to set
         * @param {boolean=} ext Not used here; affordance for closure
         * @return {boolean} Returns true if the property changed
         * @protected
         */
        _setPendingProperty(property, value, ext) {
          let old = this.__data[property];
          let changed = this._shouldPropertyChange(property, value, old);
          if (changed) {
            if (!this.__dataPending) {
              this.__dataPending = {};
              this.__dataOld = {};
            }
            // Ensure old is captured from the last turn
            if (this.__dataOld && !(property in this.__dataOld)) {
              this.__dataOld[property] = old;
            }
            this.__data[property] = value;
            this.__dataPending[property] = value;
          }
          return changed;
        }
        /* eslint-enable */

        /**
         * Marks the properties as invalid, and enqueues an async
         * `_propertiesChanged` callback.
         *
         * @return {void}
         * @protected
         */
        _invalidateProperties() {
          if (!this.__dataInvalid && this.__dataReady) {
            this.__dataInvalid = true;
            microtask.run(() => {
              if (this.__dataInvalid) {
                this.__dataInvalid = false;
                this._flushProperties();
              }
            });
          }
        }

        /**
         * Call to enable property accessor processing. Before this method is
         * called accessor values will be set but side effects are
         * queued. When called, any pending side effects occur immediately.
         * For elements, generally `connectedCallback` is a normal spot to do so.
         * It is safe to call this method multiple times as it only turns on
         * property accessors once.
         *
         * @return {void}
         * @protected
         */
        _enableProperties() {
          if (!this.__dataEnabled) {
            this.__dataEnabled = true;
            if (this.__dataInstanceProps) {
              this._initializeInstanceProperties(this.__dataInstanceProps);
              this.__dataInstanceProps = null;
            }
            this.ready();
          }
        }

        /**
         * Calls the `_propertiesChanged` callback with the current set of
         * pending changes (and old values recorded when pending changes were
         * set), and resets the pending set of changes. Generally, this method
         * should not be called in user code.
         *
         * @return {void}
         * @protected
         */
        _flushProperties() {
          const props = this.__data;
          const changedProps = this.__dataPending;
          const old = this.__dataOld;
          if (this._shouldPropertiesChange(props, changedProps, old)) {
            this.__dataPending = null;
            this.__dataOld = null;
            this._propertiesChanged(props, changedProps, old);
          }
        }

        /**
         * Called in `_flushProperties` to determine if `_propertiesChanged`
         * should be called. The default implementation returns true if
         * properties are pending. Override to customize when
         * `_propertiesChanged` is called.
         * @param {!Object} currentProps Bag of all current accessor values
         * @param {!Object} changedProps Bag of properties changed since the last
         *   call to `_propertiesChanged`
         * @param {!Object} oldProps Bag of previous values for each property
         *   in `changedProps`
         * @return {boolean} true if changedProps is truthy
         */
        _shouldPropertiesChange(currentProps, changedProps, oldProps) { // eslint-disable-line no-unused-vars
          return Boolean(changedProps);
        }

        /**
         * Callback called when any properties with accessors created via
         * `_createPropertyAccessor` have been set.
         *
         * @param {!Object} currentProps Bag of all current accessor values
         * @param {!Object} changedProps Bag of properties changed since the last
         *   call to `_propertiesChanged`
         * @param {!Object} oldProps Bag of previous values for each property
         *   in `changedProps`
         * @return {void}
         * @protected
         */
        _propertiesChanged(currentProps, changedProps, oldProps) { // eslint-disable-line no-unused-vars
        }

        /**
         * Method called to determine whether a property value should be
         * considered as a change and cause the `_propertiesChanged` callback
         * to be enqueued.
         *
         * The default implementation returns `true` if a strict equality
         * check fails. The method always returns false for `NaN`.
         *
         * Override this method to e.g. provide stricter checking for
         * Objects/Arrays when using immutable patterns.
         *
         * @param {string} property Property name
         * @param {*} value New property value
         * @param {*} old Previous property value
         * @return {boolean} Whether the property should be considered a change
         *   and enqueue a `_proeprtiesChanged` callback
         * @protected
         */
        _shouldPropertyChange(property, value, old) {
          return (
            // Strict equality check
            (old !== value &&
              // This ensures (old==NaN, value==NaN) always returns false
              (old === old || value === value))
          );
        }

        /**
         * Implements native Custom Elements `attributeChangedCallback` to
         * set an attribute value to a property via `_attributeToProperty`.
         *
         * @param {string} name Name of attribute that changed
         * @param {?string} old Old attribute value
         * @param {?string} value New attribute value
         * @param {?string} namespace Attribute namespace.
         * @return {void}
         * @suppress {missingProperties} Super may or may not implement the callback
         */
        attributeChangedCallback(name, old, value, namespace) {
          if (old !== value) {
            this._attributeToProperty(name, value);
          }
          if (super.attributeChangedCallback) {
            super.attributeChangedCallback(name, old, value, namespace);
          }
        }

        /**
         * Deserializes an attribute to its associated property.
         *
         * This method calls the `_deserializeValue` method to convert the string to
         * a typed value.
         *
         * @param {string} attribute Name of attribute to deserialize.
         * @param {?string} value of the attribute.
         * @param {*=} type type to deserialize to, defaults to the value
         * returned from `typeForProperty`
         * @return {void}
         */
        _attributeToProperty(attribute, value, type) {
          if (!this.__serializing) {
            const map = this.__dataAttributes;
            const property = map && map[attribute] || attribute;
            this[property] = this._deserializeValue(value, type ||
              this.constructor.typeForProperty(property));
          }
        }

        /**
         * Serializes a property to its associated attribute.
         *
         * @suppress {invalidCasts} Closure can't figure out `this` is an element.
         *
         * @param {string} property Property name to reflect.
         * @param {string=} attribute Attribute name to reflect to.
         * @param {*=} value Property value to refect.
         * @return {void}
         */
        _propertyToAttribute(property, attribute, value) {
          this.__serializing = true;
          value = (arguments.length < 3) ? this[property] : value;
          this._valueToNodeAttribute(/** @type {!HTMLElement} */(this), value,
            attribute || this.constructor.attributeNameForProperty(property));
          this.__serializing = false;
        }

        /**
         * Sets a typed value to an HTML attribute on a node.
         *
         * This method calls the `_serializeValue` method to convert the typed
         * value to a string.  If the `_serializeValue` method returns `undefined`,
         * the attribute will be removed (this is the default for boolean
         * type `false`).
         *
         * @param {Element} node Element to set attribute to.
         * @param {*} value Value to serialize.
         * @param {string} attribute Attribute name to serialize to.
         * @return {void}
         */
        _valueToNodeAttribute(node, value, attribute) {
          const str = this._serializeValue(value);
          if (str === undefined) {
            node.removeAttribute(attribute);
          } else {
            node.setAttribute(attribute, str);
          }
        }

        /**
         * Converts a typed JavaScript value to a string.
         *
         * This method is called when setting JS property values to
         * HTML attributes.  Users may override this method to provide
         * serialization for custom types.
         *
         * @param {*} value Property value to serialize.
         * @return {string | undefined} String serialized from the provided
         * property  value.
         */
        _serializeValue(value) {
          switch (typeof value) {
            case 'boolean':
              return value ? '' : undefined;
            default:
              return value != null ? value.toString() : undefined;
          }
        }

        /**
         * Converts a string to a typed JavaScript value.
         *
         * This method is called when reading HTML attribute values to
         * JS properties.  Users may override this method to provide
         * deserialization for custom `type`s. Types for `Boolean`, `String`,
         * and `Number` convert attributes to the expected types.
         *
         * @param {?string} value Value to deserialize.
         * @param {*=} type Type to deserialize the string to.
         * @return {*} Typed value deserialized from the provided string.
         */
        _deserializeValue(value, type) {
          switch (type) {
            case Boolean:
              return (value !== null);
            case Number:
              return Number(value);
            default:
              return value;
          }
        }

      }

      return PropertiesChanged;
    });


  })();



(function() {

  'use strict';

  let caseMap = Polymer.CaseMap;

  // Save map of native properties; this forms a blacklist or properties
  // that won't have their values "saved" by `saveAccessorValue`, since
  // reading from an HTMLElement accessor from the context of a prototype throws
  const nativeProperties = {};
  let proto = HTMLElement.prototype;
  while (proto) {
    let props = Object.getOwnPropertyNames(proto);
    for (let i=0; i<props.length; i++) {
      nativeProperties[props[i]] = true;
    }
    proto = Object.getPrototypeOf(proto);
  }

  /**
   * Used to save the value of a property that will be overridden with
   * an accessor. If the `model` is a prototype, the values will be saved
   * in `__dataProto`, and it's up to the user (or downstream mixin) to
   * decide how/when to set these values back into the accessors.
   * If `model` is already an instance (it has a `__data` property), then
   * the value will be set as a pending property, meaning the user should
   * call `_invalidateProperties` or `_flushProperties` to take effect
   *
   * @param {Object} model Prototype or instance
   * @param {string} property Name of property
   * @return {void}
   * @private
   */
  function saveAccessorValue(model, property) {
    // Don't read/store value for any native properties since they could throw
    if (!nativeProperties[property]) {
      let value = model[property];
      if (value !== undefined) {
        if (model.__data) {
          // Adding accessor to instance; update the property
          // It is the user's responsibility to call _flushProperties
          model._setPendingProperty(property, value);
        } else {
          // Adding accessor to proto; save proto's value for instance-time use
          if (!model.__dataProto) {
            model.__dataProto = {};
          } else if (!model.hasOwnProperty(JSCompiler_renameProperty('__dataProto', model))) {
            model.__dataProto = Object.create(model.__dataProto);
          }
          model.__dataProto[property] = value;
        }
      }
    }
  }

  /**
   * Element class mixin that provides basic meta-programming for creating one
   * or more property accessors (getter/setter pair) that enqueue an async
   * (batched) `_propertiesChanged` callback.
   *
   * For basic usage of this mixin:
   * 
   * -   Declare attributes to observe via the standard `static get observedAttributes()`. Use
   *     `dash-case` attribute names to represent `camelCase` property names. 
   * -   Implement the `_propertiesChanged` callback on the class.
   * -   Call `MyClass.createPropertiesForAttributes()` **once** on the class to generate 
   *     property accessors for each observed attribute. This must be called before the first 
   *     instance is created, for example, by calling it before calling `customElements.define`.
   *     It can also be called lazily from the element's `constructor`, as long as it's guarded so
   *     that the call is only made once, when the first instance is created.
   * -   Call `this._enableProperties()` in the element's `connectedCallback` to enable 
   *     the accessors.
   *
   * Any `observedAttributes` will automatically be
   * deserialized via `attributeChangedCallback` and set to the associated
   * property using `dash-case`-to-`camelCase` convention.
   *
   * @mixinFunction
   * @polymer
   * @appliesMixin Polymer.PropertiesChanged
   * @memberof Polymer
   * @summary Element class mixin for reacting to property changes from
   *   generated property accessors.
   */
  Polymer.PropertyAccessors = Polymer.dedupingMixin(superClass => {

    /**
     * @constructor
     * @extends {superClass}
     * @implements {Polymer_PropertiesChanged}
     * @unrestricted
     * @private
     */
     const base = Polymer.PropertiesChanged(superClass);

    /**
     * @polymer
     * @mixinClass
     * @implements {Polymer_PropertyAccessors}
     * @extends {base}
     * @unrestricted
     */
    class PropertyAccessors extends base {

      /**
       * Generates property accessors for all attributes in the standard
       * static `observedAttributes` array.
       *
       * Attribute names are mapped to property names using the `dash-case` to
       * `camelCase` convention
       *
       * @return {void}
       */
      static createPropertiesForAttributes() {
        let a$ = this.observedAttributes;
        for (let i=0; i < a$.length; i++) {
          this.prototype._createPropertyAccessor(caseMap.dashToCamelCase(a$[i]));
        }
      }

      /**
       * Returns an attribute name that corresponds to the given property.
       * By default, converts camel to dash case, e.g. `fooBar` to `foo-bar`.
       * @param {string} property Property to convert
       * @return {string} Attribute name corresponding to the given property.
       *
       * @protected
       */
      static attributeNameForProperty(property) {
        return caseMap.camelToDashCase(property);
      }

      /**
       * Overrides PropertiesChanged implementation to initialize values for
       * accessors created for values that already existed on the element
       * prototype.
       *
       * @return {void}
       * @protected
       */
      _initializeProperties() {
        if (this.__dataProto) {
          this._initializeProtoProperties(this.__dataProto);
          this.__dataProto = null;
        }
        super._initializeProperties();
      }

      /**
       * Called at instance time with bag of properties that were overwritten
       * by accessors on the prototype when accessors were created.
       *
       * The default implementation sets these properties back into the
       * setter at instance time.  This method is provided as an override
       * point for customizing or providing more efficient initialization.
       *
       * @param {Object} props Bag of property values that were overwritten
       *   when creating property accessors.
       * @return {void}
       * @protected
       */
      _initializeProtoProperties(props) {
        for (let p in props) {
          this._setProperty(p, props[p]);
        }
      }

      /**
       * Ensures the element has the given attribute. If it does not,
       * assigns the given value to the attribute.
       *
       * @suppress {invalidCasts} Closure can't figure out `this` is infact an element
       *
       * @param {string} attribute Name of attribute to ensure is set.
       * @param {string} value of the attribute.
       * @return {void}
       */
      _ensureAttribute(attribute, value) {
        const el = /** @type {!HTMLElement} */(this);
        if (!el.hasAttribute(attribute)) {
          this._valueToNodeAttribute(el, value, attribute);
        }
      }

      /**
       * Overrides PropertiesChanged implemention to serialize objects as JSON.
       *
       * @param {*} value Property value to serialize.
       * @return {string | undefined} String serialized from the provided property value.
       */
      _serializeValue(value) {
        /* eslint-disable no-fallthrough */
        switch (typeof value) {
          case 'object':
            if (value instanceof Date) {
              return value.toString();
            } else if (value) {
              try {
                return JSON.stringify(value);
              } catch(x) {
                return '';
              }
            }

          default:
            return super._serializeValue(value);
        }
      }

      /**
       * Converts a string to a typed JavaScript value.
       *
       * This method is called by Polymer when reading HTML attribute values to
       * JS properties.  Users may override this method on Polymer element
       * prototypes to provide deserialization for custom `type`s.  Note,
       * the `type` argument is the value of the `type` field provided in the
       * `properties` configuration object for a given property, and is
       * by convention the constructor for the type to deserialize.
       *
       *
       * @param {?string} value Attribute value to deserialize.
       * @param {*=} type Type to deserialize the string to.
       * @return {*} Typed value deserialized from the provided string.
       */
      _deserializeValue(value, type) {
        /**
         * @type {*}
         */
        let outValue;
        switch (type) {
          case Object:
            try {
              outValue = JSON.parse(/** @type {string} */(value));
            } catch(x) {
              // allow non-JSON literals like Strings and Numbers
              outValue = value;
            }
            break;
          case Array:
            try {
              outValue = JSON.parse(/** @type {string} */(value));
            } catch(x) {
              outValue = null;
              console.warn(`Polymer::Attributes: couldn't decode Array as JSON: ${value}`);
            }
            break;
          case Date:
            outValue = isNaN(value) ? String(value) : Number(value);
            outValue = new Date(outValue);
            break;
          default:
            outValue = super._deserializeValue(value, type);
            break;
        }
        return outValue;
      }
      /* eslint-enable no-fallthrough */

      /**
       * Overrides PropertiesChanged implementation to save existing prototype
       * property value so that it can be reset.
       * @param {string} property Name of the property
       * @param {boolean=} readOnly When true, no setter is created
       *
       * When calling on a prototype, any overwritten values are saved in
       * `__dataProto`, and it is up to the subclasser to decide how/when
       * to set those properties back into the accessor.  When calling on an
       * instance, the overwritten value is set via `_setPendingProperty`,
       * and the user should call `_invalidateProperties` or `_flushProperties`
       * for the values to take effect.
       * @protected
       * @return {void}
       */
      _definePropertyAccessor(property, readOnly) {
        saveAccessorValue(this, property);
        super._definePropertyAccessor(property, readOnly);
      }

      /**
       * Returns true if this library created an accessor for the given property.
       *
       * @param {string} property Property name
       * @return {boolean} True if an accessor was created
       */
      _hasAccessor(property) {
        return this.__dataHasAccessor && this.__dataHasAccessor[property];
      }

      /**
       * Returns true if the specified property has a pending change.
       *
       * @param {string} prop Property name
       * @return {boolean} True if property has a pending change
       * @protected
       */
      _isPropertyPending(prop) {
        return Boolean(this.__dataPending && (prop in this.__dataPending));
      }

    }

    return PropertyAccessors;

  });

})();


(function() {

  'use strict';

  const walker = document.createTreeWalker(document, NodeFilter.SHOW_ALL,
      null, false);

  // 1.x backwards-compatible auto-wrapper for template type extensions
  // This is a clear layering violation and gives favored-nation status to
  // dom-if and dom-repeat templates.  This is a conceit we're choosing to keep
  // a.) to ease 1.x backwards-compatibility due to loss of `is`, and
  // b.) to maintain if/repeat capability in parser-constrained elements
  //     (e.g. table, select) in lieu of native CE type extensions without
  //     massive new invention in this space (e.g. directive system)
  const templateExtensions = {
    'dom-if': true,
    'dom-repeat': true
  };
  function wrapTemplateExtension(node) {
    let is = node.getAttribute('is');
    if (is && templateExtensions[is]) {
      let t = node;
      t.removeAttribute('is');
      node = t.ownerDocument.createElement(is);
      t.parentNode.replaceChild(node, t);
      node.appendChild(t);
      while(t.attributes.length) {
        node.setAttribute(t.attributes[0].name, t.attributes[0].value);
        t.removeAttribute(t.attributes[0].name);
      }
    }
    return node;
  }

  function findTemplateNode(root, nodeInfo) {
    // recursively ascend tree until we hit root
    let parent = nodeInfo.parentInfo && findTemplateNode(root, nodeInfo.parentInfo);
    // unwind the stack, returning the indexed node at each level
    if (parent) {
      // note: marginally faster than indexing via childNodes
      // (http://jsperf.com/childnodes-lookup)
      walker.currentNode = parent;
      for (let n=walker.firstChild(), i=0; n; n=walker.nextSibling()) {
        if (nodeInfo.parentIndex === i++) {
          return n;
        }
      }
    } else {
      return root;
    }
  }

  // construct `$` map (from id annotations)
  function applyIdToMap(inst, map, node, nodeInfo) {
    if (nodeInfo.id) {
      map[nodeInfo.id] = node;
    }
  }

  // install event listeners (from event annotations)
  function applyEventListener(inst, node, nodeInfo) {
    if (nodeInfo.events && nodeInfo.events.length) {
      for (let j=0, e$=nodeInfo.events, e; (j<e$.length) && (e=e$[j]); j++) {
        inst._addMethodEventListenerToNode(node, e.name, e.value, inst);
      }
    }
  }

  // push configuration references at configure time
  function applyTemplateContent(inst, node, nodeInfo) {
    if (nodeInfo.templateInfo) {
      node._templateInfo = nodeInfo.templateInfo;
    }
  }

  function createNodeEventHandler(context, eventName, methodName) {
    // Instances can optionally have a _methodHost which allows redirecting where
    // to find methods. Currently used by `templatize`.
    context = context._methodHost || context;
    let handler = function(e) {
      if (context[methodName]) {
        context[methodName](e, e.detail);
      } else {
        console.warn('listener method `' + methodName + '` not defined');
      }
    };
    return handler;
  }

  /**
   * Element mixin that provides basic template parsing and stamping, including
   * the following template-related features for stamped templates:
   *
   * - Declarative event listeners (`on-eventname="listener"`)
   * - Map of node id's to stamped node instances (`this.$.id`)
   * - Nested template content caching/removal and re-installation (performance
   *   optimization)
   *
   * @mixinFunction
   * @polymer
   * @memberof Polymer
   * @summary Element class mixin that provides basic template parsing and stamping
   */
  Polymer.TemplateStamp = Polymer.dedupingMixin(superClass => {

    /**
     * @polymer
     * @mixinClass
     * @implements {Polymer_TemplateStamp}
     */
    class TemplateStamp extends superClass {

      /**
       * Scans a template to produce template metadata.
       *
       * Template-specific metadata are stored in the object returned, and node-
       * specific metadata are stored in objects in its flattened `nodeInfoList`
       * array.  Only nodes in the template that were parsed as nodes of
       * interest contain an object in `nodeInfoList`.  Each `nodeInfo` object
       * contains an `index` (`childNodes` index in parent) and optionally
       * `parent`, which points to node info of its parent (including its index).
       *
       * The template metadata object returned from this method has the following
       * structure (many fields optional):
       *
       * ```js
       *   {
       *     // Flattened list of node metadata (for nodes that generated metadata)
       *     nodeInfoList: [
       *       {
       *         // `id` attribute for any nodes with id's for generating `$` map
       *         id: {string},
       *         // `on-event="handler"` metadata
       *         events: [
       *           {
       *             name: {string},   // event name
       *             value: {string},  // handler method name
       *           }, ...
       *         ],
       *         // Notes when the template contained a `<slot>` for shady DOM
       *         // optimization purposes
       *         hasInsertionPoint: {boolean},
       *         // For nested `<template>`` nodes, nested template metadata
       *         templateInfo: {object}, // nested template metadata
       *         // Metadata to allow efficient retrieval of instanced node
       *         // corresponding to this metadata
       *         parentInfo: {number},   // reference to parent nodeInfo>
       *         parentIndex: {number},  // index in parent's `childNodes` collection
       *         infoIndex: {number},    // index of this `nodeInfo` in `templateInfo.nodeInfoList`
       *       },
       *       ...
       *     ],
       *     // When true, the template had the `strip-whitespace` attribute
       *     // or was nested in a template with that setting
       *     stripWhitespace: {boolean},
       *     // For nested templates, nested template content is moved into
       *     // a document fragment stored here; this is an optimization to
       *     // avoid the cost of nested template cloning
       *     content: {DocumentFragment}
       *   }
       * ```
       *
       * This method kicks off a recursive treewalk as follows:
       *
       * ```
       *    _parseTemplate <---------------------+
       *      _parseTemplateContent              |
       *        _parseTemplateNode  <------------|--+
       *          _parseTemplateNestedTemplate --+  |
       *          _parseTemplateChildNodes ---------+
       *          _parseTemplateNodeAttributes
       *            _parseTemplateNodeAttribute
       *
       * ```
       *
       * These methods may be overridden to add custom metadata about templates
       * to either `templateInfo` or `nodeInfo`.
       *
       * Note that this method may be destructive to the template, in that
       * e.g. event annotations may be removed after being noted in the
       * template metadata.
       *
       * @param {!HTMLTemplateElement} template Template to parse
       * @param {TemplateInfo=} outerTemplateInfo Template metadata from the outer
       *   template, for parsing nested templates
       * @return {!TemplateInfo} Parsed template metadata
       */
      static _parseTemplate(template, outerTemplateInfo) {
        // since a template may be re-used, memo-ize metadata
        if (!template._templateInfo) {
          let templateInfo = template._templateInfo = {};
          templateInfo.nodeInfoList = [];
          templateInfo.stripWhiteSpace = Polymer.legacyOptimizations ||
            (outerTemplateInfo && outerTemplateInfo.stripWhiteSpace) ||
            template.hasAttribute('strip-whitespace');
          this._parseTemplateContent(template, templateInfo, {parent: null});
        }
        return template._templateInfo;
      }

      static _parseTemplateContent(template, templateInfo, nodeInfo) {
        return this._parseTemplateNode(template.content, templateInfo, nodeInfo);
      }

      /**
       * Parses template node and adds template and node metadata based on
       * the current node, and its `childNodes` and `attributes`.
       *
       * This method may be overridden to add custom node or template specific
       * metadata based on this node.
       *
       * @param {Node} node Node to parse
       * @param {!TemplateInfo} templateInfo Template metadata for current template
       * @param {!NodeInfo} nodeInfo Node metadata for current template.
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       */
      static _parseTemplateNode(node, templateInfo, nodeInfo) {
        let noted;
        let element = /** @type {Element} */(node);
        if (element.localName == 'template' && !element.hasAttribute('preserve-content')) {
          noted = this._parseTemplateNestedTemplate(element, templateInfo, nodeInfo) || noted;
        } else if (element.localName === 'slot') {
          // For ShadyDom optimization, indicating there is an insertion point
          templateInfo.hasInsertionPoint = true;
        }
        walker.currentNode = element;
        if (walker.firstChild()) {
          noted = this._parseTemplateChildNodes(element, templateInfo, nodeInfo) || noted;
        }
        if (element.hasAttributes && element.hasAttributes()) {
          noted = this._parseTemplateNodeAttributes(element, templateInfo, nodeInfo) || noted;
        }
        return noted;
      }

      /**
       * Parses template child nodes for the given root node.
       *
       * This method also wraps whitelisted legacy template extensions
       * (`is="dom-if"` and `is="dom-repeat"`) with their equivalent element
       * wrappers, collapses text nodes, and strips whitespace from the template
       * if the `templateInfo.stripWhitespace` setting was provided.
       *
       * @param {Node} root Root node whose `childNodes` will be parsed
       * @param {!TemplateInfo} templateInfo Template metadata for current template
       * @param {!NodeInfo} nodeInfo Node metadata for current template.
       * @return {void}
       */
      static _parseTemplateChildNodes(root, templateInfo, nodeInfo) {
        if (root.localName === 'script' || root.localName === 'style') {
          return;
        }
        walker.currentNode = root;
        for (let node=walker.firstChild(), parentIndex=0, next; node; node=next) {
          // Wrap templates
          if (node.localName == 'template') {
            node = wrapTemplateExtension(node);
          }
          // collapse adjacent textNodes: fixes an IE issue that can cause
          // text nodes to be inexplicably split =(
          // note that root.normalize() should work but does not so we do this
          // manually.
          walker.currentNode = node;
          next = walker.nextSibling();
          if (node.nodeType === Node.TEXT_NODE) {
            let /** Node */ n = next;
            while (n && (n.nodeType === Node.TEXT_NODE)) {
              node.textContent += n.textContent;
              next = walker.nextSibling();
              root.removeChild(n);
              n = next;
            }
            // optionally strip whitespace
            if (templateInfo.stripWhiteSpace && !node.textContent.trim()) {
              root.removeChild(node);
              continue;
            }
          }
          let childInfo = { parentIndex, parentInfo: nodeInfo };
          if (this._parseTemplateNode(node, templateInfo, childInfo)) {
            childInfo.infoIndex = templateInfo.nodeInfoList.push(/** @type {!NodeInfo} */(childInfo)) - 1;
          }
          // Increment if not removed
          walker.currentNode = node;
          if (walker.parentNode()) {
            parentIndex++;
          }
        }
      }

      /**
       * Parses template content for the given nested `<template>`.
       *
       * Nested template info is stored as `templateInfo` in the current node's
       * `nodeInfo`. `template.content` is removed and stored in `templateInfo`.
       * It will then be the responsibility of the host to set it back to the
       * template and for users stamping nested templates to use the
       * `_contentForTemplate` method to retrieve the content for this template
       * (an optimization to avoid the cost of cloning nested template content).
       *
       * @param {HTMLTemplateElement} node Node to parse (a <template>)
       * @param {TemplateInfo} outerTemplateInfo Template metadata for current template
       *   that includes the template `node`
       * @param {!NodeInfo} nodeInfo Node metadata for current template.
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       */
      static _parseTemplateNestedTemplate(node, outerTemplateInfo, nodeInfo) {
        let templateInfo = this._parseTemplate(node, outerTemplateInfo);
        let content = templateInfo.content =
          node.content.ownerDocument.createDocumentFragment();
        content.appendChild(node.content);
        nodeInfo.templateInfo = templateInfo;
        return true;
      }

      /**
       * Parses template node attributes and adds node metadata to `nodeInfo`
       * for nodes of interest.
       *
       * @param {Element} node Node to parse
       * @param {TemplateInfo} templateInfo Template metadata for current template
       * @param {NodeInfo} nodeInfo Node metadata for current template.
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       */
      static _parseTemplateNodeAttributes(node, templateInfo, nodeInfo) {
        // Make copy of original attribute list, since the order may change
        // as attributes are added and removed
        let noted = false;
        let attrs = Array.from(node.attributes);
        for (let i=attrs.length-1, a; (a=attrs[i]); i--) {
          noted = this._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, a.name, a.value) || noted;
        }
        return noted;
      }

      /**
       * Parses a single template node attribute and adds node metadata to
       * `nodeInfo` for attributes of interest.
       *
       * This implementation adds metadata for `on-event="handler"` attributes
       * and `id` attributes.
       *
       * @param {Element} node Node to parse
       * @param {!TemplateInfo} templateInfo Template metadata for current template
       * @param {!NodeInfo} nodeInfo Node metadata for current template.
       * @param {string} name Attribute name
       * @param {string} value Attribute value
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       */
      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
        // events (on-*)
        if (name.slice(0, 3) === 'on-') {
          node.removeAttribute(name);
          nodeInfo.events = nodeInfo.events || [];
          nodeInfo.events.push({
            name: name.slice(3),
            value
          });
          return true;
        }
        // static id
        else if (name === 'id') {
          nodeInfo.id = value;
          return true;
        }
        return false;
      }

      /**
       * Returns the `content` document fragment for a given template.
       *
       * For nested templates, Polymer performs an optimization to cache nested
       * template content to avoid the cost of cloning deeply nested templates.
       * This method retrieves the cached content for a given template.
       *
       * @param {HTMLTemplateElement} template Template to retrieve `content` for
       * @return {DocumentFragment} Content fragment
       */
      static _contentForTemplate(template) {
        let templateInfo = /** @type {HTMLTemplateElementWithInfo} */ (template)._templateInfo;
        return (templateInfo && templateInfo.content) || template.content;
      }

      /**
       * Clones the provided template content and returns a document fragment
       * containing the cloned dom.
       *
       * The template is parsed (once and memoized) using this library's
       * template parsing features, and provides the following value-added
       * features:
       * * Adds declarative event listeners for `on-event="handler"` attributes
       * * Generates an "id map" for all nodes with id's under `$` on returned
       *   document fragment
       * * Passes template info including `content` back to templates as
       *   `_templateInfo` (a performance optimization to avoid deep template
       *   cloning)
       *
       * Note that the memoized template parsing process is destructive to the
       * template: attributes for bindings and declarative event listeners are
       * removed after being noted in notes, and any nested `<template>.content`
       * is removed and stored in notes as well.
       *
       * @param {!HTMLTemplateElement} template Template to stamp
       * @return {!StampedTemplate} Cloned template content
       */
      _stampTemplate(template) {
        // Polyfill support: bootstrap the template if it has not already been
        if (template && !template.content &&
            window.HTMLTemplateElement && HTMLTemplateElement.decorate) {
          HTMLTemplateElement.decorate(template);
        }
        let templateInfo = this.constructor._parseTemplate(template);
        let nodeInfo = templateInfo.nodeInfoList;
        let content = templateInfo.content || template.content;
        let dom = /** @type {DocumentFragment} */ (document.importNode(content, true));
        // NOTE: ShadyDom optimization indicating there is an insertion point
        dom.__noInsertionPoint = !templateInfo.hasInsertionPoint;
        let nodes = dom.nodeList = new Array(nodeInfo.length);
        dom.$ = {};
        for (let i=0, l=nodeInfo.length, info; (i<l) && (info=nodeInfo[i]); i++) {
          let node = nodes[i] = findTemplateNode(dom, info);
          applyIdToMap(this, dom.$, node, info);
          applyTemplateContent(this, node, info);
          applyEventListener(this, node, info);
        }
        dom = /** @type {!StampedTemplate} */(dom); // eslint-disable-line no-self-assign
        return dom;
      }

      /**
       * Adds an event listener by method name for the event provided.
       *
       * This method generates a handler function that looks up the method
       * name at handling time.
       *
       * @param {!Node} node Node to add listener on
       * @param {string} eventName Name of event
       * @param {string} methodName Name of method
       * @param {*=} context Context the method will be called on (defaults
       *   to `node`)
       * @return {Function} Generated handler function
       */
      _addMethodEventListenerToNode(node, eventName, methodName, context) {
        context = context || node;
        let handler = createNodeEventHandler(context, eventName, methodName);
        this._addEventListenerToNode(node, eventName, handler);
        return handler;
      }

      /**
       * Override point for adding custom or simulated event handling.
       *
       * @param {!Node} node Node to add event listener to
       * @param {string} eventName Name of event
       * @param {function(!Event):void} handler Listener function to add
       * @return {void}
       */
      _addEventListenerToNode(node, eventName, handler) {
        node.addEventListener(eventName, handler);
      }

      /**
       * Override point for adding custom or simulated event handling.
       *
       * @param {!Node} node Node to remove event listener from
       * @param {string} eventName Name of event
       * @param {function(!Event):void} handler Listener function to remove
       * @return {void}
       */
      _removeEventListenerFromNode(node, eventName, handler) {
        node.removeEventListener(eventName, handler);
      }

    }

    return TemplateStamp;

  });

})();


(function() {

  'use strict';

  /** @const {Object} */
  const CaseMap = Polymer.CaseMap;

  // Monotonically increasing unique ID used for de-duping effects triggered
  // from multiple properties in the same turn
  let dedupeId = 0;

  /**
   * Property effect types; effects are stored on the prototype using these keys
   * @enum {string}
   */
  const TYPES = {
    COMPUTE: '__computeEffects',
    REFLECT: '__reflectEffects',
    NOTIFY: '__notifyEffects',
    PROPAGATE: '__propagateEffects',
    OBSERVE: '__observeEffects',
    READ_ONLY: '__readOnly'
  };

  /** @const {RegExp} */
  const capitalAttributeRegex = /[A-Z]/;

  /**
   * @typedef {{
   * name: (string | undefined),
   * structured: (boolean | undefined),
   * wildcard: (boolean | undefined)
   * }}
   */
  let DataTrigger; //eslint-disable-line no-unused-vars

  /**
   * @typedef {{
   * info: ?,
   * trigger: (!DataTrigger | undefined),
   * fn: (!Function | undefined)
   * }}
   */
  let DataEffect; //eslint-disable-line no-unused-vars

  let PropertyEffectsType; //eslint-disable-line no-unused-vars

  /**
   * Ensures that the model has an own-property map of effects for the given type.
   * The model may be a prototype or an instance.
   *
   * Property effects are stored as arrays of effects by property in a map,
   * by named type on the model. e.g.
   *
   *   __computeEffects: {
   *     foo: [ ... ],
   *     bar: [ ... ]
   *   }
   *
   * If the model does not yet have an effect map for the type, one is created
   * and returned.  If it does, but it is not an own property (i.e. the
   * prototype had effects), the the map is deeply cloned and the copy is
   * set on the model and returned, ready for new effects to be added.
   *
   * @param {Object} model Prototype or instance
   * @param {string} type Property effect type
   * @return {Object} The own-property map of effects for the given type
   * @private
   */
  function ensureOwnEffectMap(model, type) {
    let effects = model[type];
    if (!effects) {
      effects = model[type] = {};
    } else if (!model.hasOwnProperty(type)) {
      effects = model[type] = Object.create(model[type]);
      for (let p in effects) {
        let protoFx = effects[p];
        let instFx = effects[p] = Array(protoFx.length);
        for (let i=0; i<protoFx.length; i++) {
          instFx[i] = protoFx[i];
        }
      }
    }
    return effects;
  }

  // -- effects ----------------------------------------------

  /**
   * Runs all effects of a given type for the given set of property changes
   * on an instance.
   *
   * @param {!PropertyEffectsType} inst The instance with effects to run
   * @param {Object} effects Object map of property-to-Array of effects
   * @param {Object} props Bag of current property changes
   * @param {Object=} oldProps Bag of previous values for changed properties
   * @param {boolean=} hasPaths True with `props` contains one or more paths
   * @param {*=} extraArgs Additional metadata to pass to effect function
   * @return {boolean} True if an effect ran for this property
   * @private
   */
  function runEffects(inst, effects, props, oldProps, hasPaths, extraArgs) {
    if (effects) {
      let ran = false;
      let id = dedupeId++;
      for (let prop in props) {
        if (runEffectsForProperty(inst, effects, id, prop, props, oldProps, hasPaths, extraArgs)) {
          ran = true;
        }
      }
      return ran;
    }
    return false;
  }

  /**
   * Runs a list of effects for a given property.
   *
   * @param {!PropertyEffectsType} inst The instance with effects to run
   * @param {Object} effects Object map of property-to-Array of effects
   * @param {number} dedupeId Counter used for de-duping effects
   * @param {string} prop Name of changed property
   * @param {*} props Changed properties
   * @param {*} oldProps Old properties
   * @param {boolean=} hasPaths True with `props` contains one or more paths
   * @param {*=} extraArgs Additional metadata to pass to effect function
   * @return {boolean} True if an effect ran for this property
   * @private
   */
  function runEffectsForProperty(inst, effects, dedupeId, prop, props, oldProps, hasPaths, extraArgs) {
    let ran = false;
    let rootProperty = hasPaths ? Polymer.Path.root(prop) : prop;
    let fxs = effects[rootProperty];
    if (fxs) {
      for (let i=0, l=fxs.length, fx; (i<l) && (fx=fxs[i]); i++) {
        if ((!fx.info || fx.info.lastRun !== dedupeId) &&
            (!hasPaths || pathMatchesTrigger(prop, fx.trigger))) {
          if (fx.info) {
            fx.info.lastRun = dedupeId;
          }
          fx.fn(inst, prop, props, oldProps, fx.info, hasPaths, extraArgs);
          ran = true;
        }
      }
    }
    return ran;
  }

  /**
   * Determines whether a property/path that has changed matches the trigger
   * criteria for an effect.  A trigger is a descriptor with the following
   * structure, which matches the descriptors returned from `parseArg`.
   * e.g. for `foo.bar.*`:
   * ```
   * trigger: {
   *   name: 'a.b',
   *   structured: true,
   *   wildcard: true
   * }
   * ```
   * If no trigger is given, the path is deemed to match.
   *
   * @param {string} path Path or property that changed
   * @param {DataTrigger} trigger Descriptor
   * @return {boolean} Whether the path matched the trigger
   */
  function pathMatchesTrigger(path, trigger) {
    if (trigger) {
      let triggerPath = trigger.name;
      return (triggerPath == path) ||
        (trigger.structured && Polymer.Path.isAncestor(triggerPath, path)) ||
        (trigger.wildcard && Polymer.Path.isDescendant(triggerPath, path));
    } else {
      return true;
    }
  }

  /**
   * Implements the "observer" effect.
   *
   * Calls the method with `info.methodName` on the instance, passing the
   * new and old values.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {string} property Name of property
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {?} info Effect metadata
   * @return {void}
   * @private
   */
  function runObserverEffect(inst, property, props, oldProps, info) {
    let fn = typeof info.method === "string" ? inst[info.method] : info.method;
    let changedProp = info.property;
    if (fn) {
      fn.call(inst, inst.__data[changedProp], oldProps[changedProp]);
    } else if (!info.dynamicFn) {
      console.warn('observer method `' + info.method + '` not defined');
    }
  }

  /**
   * Runs "notify" effects for a set of changed properties.
   *
   * This method differs from the generic `runEffects` method in that it
   * will dispatch path notification events in the case that the property
   * changed was a path and the root property for that path didn't have a
   * "notify" effect.  This is to maintain 1.0 behavior that did not require
   * `notify: true` to ensure object sub-property notifications were
   * sent.
   *
   * @param {!PropertyEffectsType} inst The instance with effects to run
   * @param {Object} notifyProps Bag of properties to notify
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {boolean} hasPaths True with `props` contains one or more paths
   * @return {void}
   * @private
   */
  function runNotifyEffects(inst, notifyProps, props, oldProps, hasPaths) {
    // Notify
    let fxs = inst[TYPES.NOTIFY];
    let notified;
    let id = dedupeId++;
    // Try normal notify effects; if none, fall back to try path notification
    for (let prop in notifyProps) {
      if (notifyProps[prop]) {
        if (fxs && runEffectsForProperty(inst, fxs, id, prop, props, oldProps, hasPaths)) {
          notified = true;
        } else if (hasPaths && notifyPath(inst, prop, props)) {
          notified = true;
        }
      }
    }
    // Flush host if we actually notified and host was batching
    // And the host has already initialized clients; this prevents
    // an issue with a host observing data changes before clients are ready.
    let host;
    if (notified && (host = inst.__dataHost) && host._invalidateProperties) {
      host._invalidateProperties();
    }
  }

  /**
   * Dispatches {property}-changed events with path information in the detail
   * object to indicate a sub-path of the property was changed.
   *
   * @param {!PropertyEffectsType} inst The element from which to fire the event
   * @param {string} path The path that was changed
   * @param {Object} props Bag of current property changes
   * @return {boolean} Returns true if the path was notified
   * @private
   */
  function notifyPath(inst, path, props) {
    let rootProperty = Polymer.Path.root(path);
    if (rootProperty !== path) {
      let eventName = Polymer.CaseMap.camelToDashCase(rootProperty) + '-changed';
      dispatchNotifyEvent(inst, eventName, props[path], path);
      return true;
    }
    return false;
  }

  /**
   * Dispatches {property}-changed events to indicate a property (or path)
   * changed.
   *
   * @param {!PropertyEffectsType} inst The element from which to fire the event
   * @param {string} eventName The name of the event to send ('{property}-changed')
   * @param {*} value The value of the changed property
   * @param {string | null | undefined} path If a sub-path of this property changed, the path
   *   that changed (optional).
   * @return {void}
   * @private
   * @suppress {invalidCasts}
   */
  function dispatchNotifyEvent(inst, eventName, value, path) {
    let detail = {
      value: value,
      queueProperty: true
    };
    if (path) {
      detail.path = path;
    }
    /** @type {!HTMLElement} */(inst).dispatchEvent(new CustomEvent(eventName, { detail }));
  }

  /**
   * Implements the "notify" effect.
   *
   * Dispatches a non-bubbling event named `info.eventName` on the instance
   * with a detail object containing the new `value`.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {string} property Name of property
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {?} info Effect metadata
   * @param {boolean} hasPaths True with `props` contains one or more paths
   * @return {void}
   * @private
   */
  function runNotifyEffect(inst, property, props, oldProps, info, hasPaths) {
    let rootProperty = hasPaths ? Polymer.Path.root(property) : property;
    let path = rootProperty != property ? property : null;
    let value = path ? Polymer.Path.get(inst, path) : inst.__data[property];
    if (path && value === undefined) {
      value = props[property];  // specifically for .splices
    }
    dispatchNotifyEvent(inst, info.eventName, value, path);
  }

  /**
   * Handler function for 2-way notification events. Receives context
   * information captured in the `addNotifyListener` closure from the
   * `__notifyListeners` metadata.
   *
   * Sets the value of the notified property to the host property or path.  If
   * the event contained path information, translate that path to the host
   * scope's name for that path first.
   *
   * @param {CustomEvent} event Notification event (e.g. '<property>-changed')
   * @param {!PropertyEffectsType} inst Host element instance handling the notification event
   * @param {string} fromProp Child element property that was bound
   * @param {string} toPath Host property/path that was bound
   * @param {boolean} negate Whether the binding was negated
   * @return {void}
   * @private
   */
  function handleNotification(event, inst, fromProp, toPath, negate) {
    let value;
    let detail = /** @type {Object} */(event.detail);
    let fromPath = detail && detail.path;
    if (fromPath) {
      toPath = Polymer.Path.translate(fromProp, toPath, fromPath);
      value = detail && detail.value;
    } else {
      value = event.currentTarget[fromProp];
    }
    value = negate ? !value : value;
    if (!inst[TYPES.READ_ONLY] || !inst[TYPES.READ_ONLY][toPath]) {
      if (inst._setPendingPropertyOrPath(toPath, value, true, Boolean(fromPath))
        && (!detail || !detail.queueProperty)) {
        inst._invalidateProperties();
      }
    }
  }

  /**
   * Implements the "reflect" effect.
   *
   * Sets the attribute named `info.attrName` to the given property value.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {string} property Name of property
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {?} info Effect metadata
   * @return {void}
   * @private
   */
  function runReflectEffect(inst, property, props, oldProps, info) {
    let value = inst.__data[property];
    if (Polymer.sanitizeDOMValue) {
      value = Polymer.sanitizeDOMValue(value, info.attrName, 'attribute', /** @type {Node} */(inst));
    }
    inst._propertyToAttribute(property, info.attrName, value);
  }

  /**
   * Runs "computed" effects for a set of changed properties.
   *
   * This method differs from the generic `runEffects` method in that it
   * continues to run computed effects based on the output of each pass until
   * there are no more newly computed properties.  This ensures that all
   * properties that will be computed by the initial set of changes are
   * computed before other effects (binding propagation, observers, and notify)
   * run.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {!Object} changedProps Bag of changed properties
   * @param {!Object} oldProps Bag of previous values for changed properties
   * @param {boolean} hasPaths True with `props` contains one or more paths
   * @return {void}
   * @private
   */
  function runComputedEffects(inst, changedProps, oldProps, hasPaths) {
    let computeEffects = inst[TYPES.COMPUTE];
    if (computeEffects) {
      let inputProps = changedProps;
      while (runEffects(inst, computeEffects, inputProps, oldProps, hasPaths)) {
        Object.assign(oldProps, inst.__dataOld);
        Object.assign(changedProps, inst.__dataPending);
        inputProps = inst.__dataPending;
        inst.__dataPending = null;
      }
    }
  }

  /**
   * Implements the "computed property" effect by running the method with the
   * values of the arguments specified in the `info` object and setting the
   * return value to the computed property specified.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {string} property Name of property
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {?} info Effect metadata
   * @return {void}
   * @private
   */
  function runComputedEffect(inst, property, props, oldProps, info) {
    let result = runMethodEffect(inst, property, props, oldProps, info);
    let computedProp = info.methodInfo;
    if (inst.__dataHasAccessor && inst.__dataHasAccessor[computedProp]) {
      inst._setPendingProperty(computedProp, result, true);
    } else {
      inst[computedProp] = result;
    }
  }

  /**
   * Computes path changes based on path links set up using the `linkPaths`
   * API.
   *
   * @param {!PropertyEffectsType} inst The instance whose props are changing
   * @param {string | !Array<(string|number)>} path Path that has changed
   * @param {*} value Value of changed path
   * @return {void}
   * @private
   */
  function computeLinkedPaths(inst, path, value) {
    let links = inst.__dataLinkedPaths;
    if (links) {
      let link;
      for (let a in links) {
        let b = links[a];
        if (Polymer.Path.isDescendant(a, path)) {
          link = Polymer.Path.translate(a, b, path);
          inst._setPendingPropertyOrPath(link, value, true, true);
        } else if (Polymer.Path.isDescendant(b, path)) {
          link = Polymer.Path.translate(b, a, path);
          inst._setPendingPropertyOrPath(link, value, true, true);
        }
      }
    }
  }

  // -- bindings ----------------------------------------------

  /**
   * Adds binding metadata to the current `nodeInfo`, and binding effects
   * for all part dependencies to `templateInfo`.
   *
   * @param {Function} constructor Class that `_parseTemplate` is currently
   *   running on
   * @param {TemplateInfo} templateInfo Template metadata for current template
   * @param {NodeInfo} nodeInfo Node metadata for current template node
   * @param {string} kind Binding kind, either 'property', 'attribute', or 'text'
   * @param {string} target Target property name
   * @param {!Array<!BindingPart>} parts Array of binding part metadata
   * @param {string=} literal Literal text surrounding binding parts (specified
   *   only for 'property' bindings, since these must be initialized as part
   *   of boot-up)
   * @return {void}
   * @private
   */
  function addBinding(constructor, templateInfo, nodeInfo, kind, target, parts, literal) {
    // Create binding metadata and add to nodeInfo
    nodeInfo.bindings = nodeInfo.bindings || [];
    let /** Binding */ binding = { kind, target, parts, literal, isCompound: (parts.length !== 1) };
    nodeInfo.bindings.push(binding);
    // Add listener info to binding metadata
    if (shouldAddListener(binding)) {
      let {event, negate} = binding.parts[0];
      binding.listenerEvent = event || (CaseMap.camelToDashCase(target) + '-changed');
      binding.listenerNegate = negate;
    }
    // Add "propagate" property effects to templateInfo
    let index = templateInfo.nodeInfoList.length;
    for (let i=0; i<binding.parts.length; i++) {
      let part = binding.parts[i];
      part.compoundIndex = i;
      addEffectForBindingPart(constructor, templateInfo, binding, part, index);
    }
  }

  /**
   * Adds property effects to the given `templateInfo` for the given binding
   * part.
   *
   * @param {Function} constructor Class that `_parseTemplate` is currently
   *   running on
   * @param {TemplateInfo} templateInfo Template metadata for current template
   * @param {!Binding} binding Binding metadata
   * @param {!BindingPart} part Binding part metadata
   * @param {number} index Index into `nodeInfoList` for this node
   * @return {void}
   */
  function addEffectForBindingPart(constructor, templateInfo, binding, part, index) {
    if (!part.literal) {
      if (binding.kind === 'attribute' && binding.target[0] === '-') {
        console.warn('Cannot set attribute ' + binding.target +
          ' because "-" is not a valid attribute starting character');
      } else {
        let dependencies = part.dependencies;
        let info = { index, binding, part, evaluator: constructor };
        for (let j=0; j<dependencies.length; j++) {
          let trigger = dependencies[j];
          if (typeof trigger == 'string') {
            trigger = parseArg(trigger);
            trigger.wildcard = true;
          }
          constructor._addTemplatePropertyEffect(templateInfo, trigger.rootProperty, {
            fn: runBindingEffect,
            info, trigger
          });
        }
      }
    }
  }

  /**
   * Implements the "binding" (property/path binding) effect.
   *
   * Note that binding syntax is overridable via `_parseBindings` and
   * `_evaluateBinding`.  This method will call `_evaluateBinding` for any
   * non-literal parts returned from `_parseBindings`.  However,
   * there is no support for _path_ bindings via custom binding parts,
   * as this is specific to Polymer's path binding syntax.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {string} path Name of property
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {?} info Effect metadata
   * @param {boolean} hasPaths True with `props` contains one or more paths
   * @param {Array} nodeList List of nodes associated with `nodeInfoList` template
   *   metadata
   * @return {void}
   * @private
   */
  function runBindingEffect(inst, path, props, oldProps, info, hasPaths, nodeList) {
    let node = nodeList[info.index];
    let binding = info.binding;
    let part = info.part;
    // Subpath notification: transform path and set to client
    // e.g.: foo="{{obj.sub}}", path: 'obj.sub.prop', set 'foo.prop'=obj.sub.prop
    if (hasPaths && part.source && (path.length > part.source.length) &&
        (binding.kind == 'property') && !binding.isCompound &&
        node.__isPropertyEffectsClient &&
        node.__dataHasAccessor && node.__dataHasAccessor[binding.target]) {
      let value = props[path];
      path = Polymer.Path.translate(part.source, binding.target, path);
      if (node._setPendingPropertyOrPath(path, value, false, true)) {
        inst._enqueueClient(node);
      }
    } else {
      let value = info.evaluator._evaluateBinding(inst, part, path, props, oldProps, hasPaths);
      // Propagate value to child
      applyBindingValue(inst, node, binding, part, value);
    }
  }

  /**
   * Sets the value for an "binding" (binding) effect to a node,
   * either as a property or attribute.
   *
   * @param {!PropertyEffectsType} inst The instance owning the binding effect
   * @param {Node} node Target node for binding
   * @param {!Binding} binding Binding metadata
   * @param {!BindingPart} part Binding part metadata
   * @param {*} value Value to set
   * @return {void}
   * @private
   */
  function applyBindingValue(inst, node, binding, part, value) {
    value = computeBindingValue(node, value, binding, part);
    if (Polymer.sanitizeDOMValue) {
      value = Polymer.sanitizeDOMValue(value, binding.target, binding.kind, node);
    }
    if (binding.kind == 'attribute') {
      // Attribute binding
      inst._valueToNodeAttribute(/** @type {Element} */(node), value, binding.target);
    } else {
      // Property binding
      let prop = binding.target;
      if (node.__isPropertyEffectsClient &&
          node.__dataHasAccessor && node.__dataHasAccessor[prop]) {
        if (!node[TYPES.READ_ONLY] || !node[TYPES.READ_ONLY][prop]) {
          if (node._setPendingProperty(prop, value)) {
            inst._enqueueClient(node);
          }
        }
      } else  {
        inst._setUnmanagedPropertyToNode(node, prop, value);
      }
    }
  }

  /**
   * Transforms an "binding" effect value based on compound & negation
   * effect metadata, as well as handling for special-case properties
   *
   * @param {Node} node Node the value will be set to
   * @param {*} value Value to set
   * @param {!Binding} binding Binding metadata
   * @param {!BindingPart} part Binding part metadata
   * @return {*} Transformed value to set
   * @private
   */
  function computeBindingValue(node, value, binding, part) {
    if (binding.isCompound) {
      let storage = node.__dataCompoundStorage[binding.target];
      storage[part.compoundIndex] = value;
      value = storage.join('');
    }
    if (binding.kind !== 'attribute') {
      // Some browsers serialize `undefined` to `"undefined"`
      if (binding.target === 'textContent' ||
          (binding.target === 'value' &&
            (node.localName === 'input' || node.localName === 'textarea'))) {
        value = value == undefined ? '' : value;
      }
    }
    return value;
  }

  /**
   * Returns true if a binding's metadata meets all the requirements to allow
   * 2-way binding, and therefore a `<property>-changed` event listener should be
   * added:
   * - used curly braces
   * - is a property (not attribute) binding
   * - is not a textContent binding
   * - is not compound
   *
   * @param {!Binding} binding Binding metadata
   * @return {boolean} True if 2-way listener should be added
   * @private
   */
  function shouldAddListener(binding) {
    return Boolean(binding.target) &&
           binding.kind != 'attribute' &&
           binding.kind != 'text' &&
           !binding.isCompound &&
           binding.parts[0].mode === '{';
  }

  /**
   * Setup compound binding storage structures, notify listeners, and dataHost
   * references onto the bound nodeList.
   *
   * @param {!PropertyEffectsType} inst Instance that bas been previously bound
   * @param {TemplateInfo} templateInfo Template metadata
   * @return {void}
   * @private
   */
  function setupBindings(inst, templateInfo) {
    // Setup compound storage, dataHost, and notify listeners
    let {nodeList, nodeInfoList} = templateInfo;
    if (nodeInfoList.length) {
      for (let i=0; i < nodeInfoList.length; i++) {
        let info = nodeInfoList[i];
        let node = nodeList[i];
        let bindings = info.bindings;
        if (bindings) {
          for (let i=0; i<bindings.length; i++) {
            let binding = bindings[i];
            setupCompoundStorage(node, binding);
            addNotifyListener(node, inst, binding);
          }
        }
        node.__dataHost = inst;
      }
    }
  }

  /**
   * Initializes `__dataCompoundStorage` local storage on a bound node with
   * initial literal data for compound bindings, and sets the joined
   * literal parts to the bound property.
   *
   * When changes to compound parts occur, they are first set into the compound
   * storage array for that property, and then the array is joined to result in
   * the final value set to the property/attribute.
   *
   * @param {Node} node Bound node to initialize
   * @param {Binding} binding Binding metadata
   * @return {void}
   * @private
   */
  function setupCompoundStorage(node, binding) {
    if (binding.isCompound) {
      // Create compound storage map
      let storage = node.__dataCompoundStorage ||
        (node.__dataCompoundStorage = {});
      let parts = binding.parts;
      // Copy literals from parts into storage for this binding
      let literals = new Array(parts.length);
      for (let j=0; j<parts.length; j++) {
        literals[j] = parts[j].literal;
      }
      let target = binding.target;
      storage[target] = literals;
      // Configure properties with their literal parts
      if (binding.literal && binding.kind == 'property') {
        node[target] = binding.literal;
      }
    }
  }

  /**
   * Adds a 2-way binding notification event listener to the node specified
   *
   * @param {Object} node Child element to add listener to
   * @param {!PropertyEffectsType} inst Host element instance to handle notification event
   * @param {Binding} binding Binding metadata
   * @return {void}
   * @private
   */
  function addNotifyListener(node, inst, binding) {
    if (binding.listenerEvent) {
      let part = binding.parts[0];
      node.addEventListener(binding.listenerEvent, function(e) {
        handleNotification(e, inst, binding.target, part.source, part.negate);
      });
    }
  }

  // -- for method-based effects (complexObserver & computed) --------------

  /**
   * Adds property effects for each argument in the method signature (and
   * optionally, for the method name if `dynamic` is true) that calls the
   * provided effect function.
   *
   * @param {Element | Object} model Prototype or instance
   * @param {!MethodSignature} sig Method signature metadata
   * @param {string} type Type of property effect to add
   * @param {Function} effectFn Function to run when arguments change
   * @param {*=} methodInfo Effect-specific information to be included in
   *   method effect metadata
   * @param {boolean|Object=} dynamicFn Boolean or object map indicating whether
   *   method names should be included as a dependency to the effect. Note,
   *   defaults to true if the signature is static (sig.static is true).
   * @return {void}
   * @private
   */
  function createMethodEffect(model, sig, type, effectFn, methodInfo, dynamicFn) {
    dynamicFn = sig.static || (dynamicFn &&
      (typeof dynamicFn !== 'object' || dynamicFn[sig.methodName]));
    let info = {
      methodName: sig.methodName,
      args: sig.args,
      methodInfo,
      dynamicFn
    };
    for (let i=0, arg; (i<sig.args.length) && (arg=sig.args[i]); i++) {
      if (!arg.literal) {
        model._addPropertyEffect(arg.rootProperty, type, {
          fn: effectFn, info: info, trigger: arg
        });
      }
    }
    if (dynamicFn) {
      model._addPropertyEffect(sig.methodName, type, {
        fn: effectFn, info: info
      });
    }
  }

  /**
   * Calls a method with arguments marshaled from properties on the instance
   * based on the method signature contained in the effect metadata.
   *
   * Multi-property observers, computed properties, and inline computing
   * functions call this function to invoke the method, then use the return
   * value accordingly.
   *
   * @param {!PropertyEffectsType} inst The instance the effect will be run on
   * @param {string} property Name of property
   * @param {Object} props Bag of current property changes
   * @param {Object} oldProps Bag of previous values for changed properties
   * @param {?} info Effect metadata
   * @return {*} Returns the return value from the method invocation
   * @private
   */
  function runMethodEffect(inst, property, props, oldProps, info) {
    // Instances can optionally have a _methodHost which allows redirecting where
    // to find methods. Currently used by `templatize`.
    let context = inst._methodHost || inst;
    let fn = context[info.methodName];
    if (fn) {
      let args = inst._marshalArgs(info.args, property, props);
      return fn.apply(context, args);
    } else if (!info.dynamicFn) {
      console.warn('method `' + info.methodName + '` not defined');
    }
  }

  const emptyArray = [];

  // Regular expressions used for binding
  const IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$\\-*]*' + ')';
  const NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
  const SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
  const DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';
  const STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';
  const ARGUMENT = '(?:(' + IDENT + '|' + NUMBER + '|' +  STRING + ')\\s*' + ')';
  const ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\s*' + ARGUMENT + ')*' + ')';
  const ARGUMENT_LIST = '(?:' + '\\(\\s*' +
                                '(?:' + ARGUMENTS + '?' + ')' +
                              '\\)\\s*' + ')';
  const BINDING = '(' + IDENT + '\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3
  const OPEN_BRACKET = '(\\[\\[|{{)' + '\\s*';
  const CLOSE_BRACKET = '(?:]]|}})';
  const NEGATE = '(?:(!)\\s*)?'; // Group 2
  const EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
  const bindingRegex = new RegExp(EXPRESSION, "g");

  /**
   * Create a string from binding parts of all the literal parts
   *
   * @param {!Array<BindingPart>} parts All parts to stringify
   * @return {string} String made from the literal parts
   */
  function literalFromParts(parts) {
    let s = '';
    for (let i=0; i<parts.length; i++) {
      let literal = parts[i].literal;
      s += literal || '';
    }
    return s;
  }

  /**
   * Parses an expression string for a method signature, and returns a metadata
   * describing the method in terms of `methodName`, `static` (whether all the
   * arguments are literals), and an array of `args`
   *
   * @param {string} expression The expression to parse
   * @return {?MethodSignature} The method metadata object if a method expression was
   *   found, otherwise `undefined`
   * @private
   */
  function parseMethod(expression) {
    // tries to match valid javascript property names
    let m = expression.match(/([^\s]+?)\(([\s\S]*)\)/);
    if (m) {
      let methodName = m[1];
      let sig = { methodName, static: true, args: emptyArray };
      if (m[2].trim()) {
        // replace escaped commas with comma entity, split on un-escaped commas
        let args = m[2].replace(/\\,/g, '&comma;').split(',');
        return parseArgs(args, sig);
      } else {
        return sig;
      }
    }
    return null;
  }

  /**
   * Parses an array of arguments and sets the `args` property of the supplied
   * signature metadata object. Sets the `static` property to false if any
   * argument is a non-literal.
   *
   * @param {!Array<string>} argList Array of argument names
   * @param {!MethodSignature} sig Method signature metadata object
   * @return {!MethodSignature} The updated signature metadata object
   * @private
   */
  function parseArgs(argList, sig) {
    sig.args = argList.map(function(rawArg) {
      let arg = parseArg(rawArg);
      if (!arg.literal) {
        sig.static = false;
      }
      return arg;
    }, this);
    return sig;
  }

  /**
   * Parses an individual argument, and returns an argument metadata object
   * with the following fields:
   *
   *   {
   *     value: 'prop',        // property/path or literal value
   *     literal: false,       // whether argument is a literal
   *     structured: false,    // whether the property is a path
   *     rootProperty: 'prop', // the root property of the path
   *     wildcard: false       // whether the argument was a wildcard '.*' path
   *   }
   *
   * @param {string} rawArg The string value of the argument
   * @return {!MethodArg} Argument metadata object
   * @private
   */
  function parseArg(rawArg) {
    // clean up whitespace
    let arg = rawArg.trim()
      // replace comma entity with comma
      .replace(/&comma;/g, ',')
      // repair extra escape sequences; note only commas strictly need
      // escaping, but we allow any other char to be escaped since its
      // likely users will do this
      .replace(/\\(.)/g, '\$1')
      ;
    // basic argument descriptor
    let a = {
      name: arg,
      value: '',
      literal: false
    };
    // detect literal value (must be String or Number)
    let fc = arg[0];
    if (fc === '-') {
      fc = arg[1];
    }
    if (fc >= '0' && fc <= '9') {
      fc = '#';
    }
    switch(fc) {
      case "'":
      case '"':
        a.value = arg.slice(1, -1);
        a.literal = true;
        break;
      case '#':
        a.value = Number(arg);
        a.literal = true;
        break;
    }
    // if not literal, look for structured path
    if (!a.literal) {
      a.rootProperty = Polymer.Path.root(arg);
      // detect structured path (has dots)
      a.structured = Polymer.Path.isPath(arg);
      if (a.structured) {
        a.wildcard = (arg.slice(-2) == '.*');
        if (a.wildcard) {
          a.name = arg.slice(0, -2);
        }
      }
    }
    return a;
  }

  // data api

  /**
   * Sends array splice notifications (`.splices` and `.length`)
   *
   * Note: this implementation only accepts normalized paths
   *
   * @param {!PropertyEffectsType} inst Instance to send notifications to
   * @param {Array} array The array the mutations occurred on
   * @param {string} path The path to the array that was mutated
   * @param {Array} splices Array of splice records
   * @return {void}
   * @private
   */
  function notifySplices(inst, array, path, splices) {
    let splicesPath = path + '.splices';
    inst.notifyPath(splicesPath, { indexSplices: splices });
    inst.notifyPath(path + '.length', array.length);
    // Null here to allow potentially large splice records to be GC'ed.
    inst.__data[splicesPath] = {indexSplices: null};
  }

  /**
   * Creates a splice record and sends an array splice notification for
   * the described mutation
   *
   * Note: this implementation only accepts normalized paths
   *
   * @param {!PropertyEffectsType} inst Instance to send notifications to
   * @param {Array} array The array the mutations occurred on
   * @param {string} path The path to the array that was mutated
   * @param {number} index Index at which the array mutation occurred
   * @param {number} addedCount Number of added items
   * @param {Array} removed Array of removed items
   * @return {void}
   * @private
   */
  function notifySplice(inst, array, path, index, addedCount, removed) {
    notifySplices(inst, array, path, [{
      index: index,
      addedCount: addedCount,
      removed: removed,
      object: array,
      type: 'splice'
    }]);
  }

  /**
   * Returns an upper-cased version of the string.
   *
   * @param {string} name String to uppercase
   * @return {string} Uppercased string
   * @private
   */
  function upper(name) {
    return name[0].toUpperCase() + name.substring(1);
  }

  /**
   * Element class mixin that provides meta-programming for Polymer's template
   * binding and data observation (collectively, "property effects") system.
   *
   * This mixin uses provides the following key static methods for adding
   * property effects to an element class:
   * - `addPropertyEffect`
   * - `createPropertyObserver`
   * - `createMethodObserver`
   * - `createNotifyingProperty`
   * - `createReadOnlyProperty`
   * - `createReflectedProperty`
   * - `createComputedProperty`
   * - `bindTemplate`
   *
   * Each method creates one or more property accessors, along with metadata
   * used by this mixin's implementation of `_propertiesChanged` to perform
   * the property effects.
   *
   * Underscored versions of the above methods also exist on the element
   * prototype for adding property effects on instances at runtime.
   *
   * Note that this mixin overrides several `PropertyAccessors` methods, in
   * many cases to maintain guarantees provided by the Polymer 1.x features;
   * notably it changes property accessors to be synchronous by default
   * whereas the default when using `PropertyAccessors` standalone is to be
   * async by default.
   *
   * @mixinFunction
   * @polymer
   * @appliesMixin Polymer.TemplateStamp
   * @appliesMixin Polymer.PropertyAccessors
   * @memberof Polymer
   * @summary Element class mixin that provides meta-programming for Polymer's
   * template binding and data observation system.
   */
  Polymer.PropertyEffects = Polymer.dedupingMixin(superClass => {

    /**
     * @constructor
     * @extends {superClass}
     * @implements {Polymer_PropertyAccessors}
     * @implements {Polymer_TemplateStamp}
     * @unrestricted
     * @private
     */
    const propertyEffectsBase = Polymer.TemplateStamp(Polymer.PropertyAccessors(superClass));

    /**
     * @polymer
     * @mixinClass
     * @implements {Polymer_PropertyEffects}
     * @extends {propertyEffectsBase}
     * @unrestricted
     */
    class PropertyEffects extends propertyEffectsBase {

      constructor() {
        super();
        /** @type {boolean} */
        // Used to identify users of this mixin, ala instanceof
        this.__isPropertyEffectsClient = true;
        /** @type {number} */
        // NOTE: used to track re-entrant calls to `_flushProperties`
        // path changes dirty check against `__dataTemp` only during one "turn"
        // and are cleared when `__dataCounter` returns to 0.
        this.__dataCounter = 0;
        /** @type {boolean} */
        this.__dataClientsReady;
        /** @type {Array} */
        this.__dataPendingClients;
        /** @type {Object} */
        this.__dataToNotify;
        /** @type {Object} */
        this.__dataLinkedPaths;
        /** @type {boolean} */
        this.__dataHasPaths;
        /** @type {Object} */
        this.__dataCompoundStorage;
        /** @type {Polymer_PropertyEffects} */
        this.__dataHost;
        /** @type {!Object} */
        this.__dataTemp;
        /** @type {boolean} */
        this.__dataClientsInitialized;
        /** @type {!Object} */
        this.__data;
        /** @type {!Object} */
        this.__dataPending;
        /** @type {!Object} */
        this.__dataOld;
        /** @type {Object} */
        this.__computeEffects;
        /** @type {Object} */
        this.__reflectEffects;
        /** @type {Object} */
        this.__notifyEffects;
        /** @type {Object} */
        this.__propagateEffects;
        /** @type {Object} */
        this.__observeEffects;
        /** @type {Object} */
        this.__readOnly;
        /** @type {!TemplateInfo} */
        this.__templateInfo;
      }

      get PROPERTY_EFFECT_TYPES() {
        return TYPES;
      }

      /**
       * @return {void}
       */
      _initializeProperties() {
        super._initializeProperties();
        hostStack.registerHost(this);
        this.__dataClientsReady = false;
        this.__dataPendingClients = null;
        this.__dataToNotify = null;
        this.__dataLinkedPaths = null;
        this.__dataHasPaths = false;
        // May be set on instance prior to upgrade
        this.__dataCompoundStorage = this.__dataCompoundStorage || null;
        this.__dataHost = this.__dataHost || null;
        this.__dataTemp = {};
        this.__dataClientsInitialized = false;
      }

      /**
       * Overrides `Polymer.PropertyAccessors` implementation to provide a
       * more efficient implementation of initializing properties from
       * the prototype on the instance.
       *
       * @override
       * @param {Object} props Properties to initialize on the prototype
       * @return {void}
       */
      _initializeProtoProperties(props) {
        this.__data = Object.create(props);
        this.__dataPending = Object.create(props);
        this.__dataOld = {};
      }

      /**
       * Overrides `Polymer.PropertyAccessors` implementation to avoid setting
       * `_setProperty`'s `shouldNotify: true`.
       *
       * @override
       * @param {Object} props Properties to initialize on the instance
       * @return {void}
       */
      _initializeInstanceProperties(props) {
        let readOnly = this[TYPES.READ_ONLY];
        for (let prop in props) {
          if (!readOnly || !readOnly[prop]) {
            this.__dataPending = this.__dataPending || {};
            this.__dataOld = this.__dataOld || {};
            this.__data[prop] = this.__dataPending[prop] = props[prop];
          }
        }
      }

      // Prototype setup ----------------------------------------

      /**
       * Equivalent to static `addPropertyEffect` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} property Property that should trigger the effect
       * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
       * @param {Object=} effect Effect metadata object
       * @return {void}
       * @protected
       */
      _addPropertyEffect(property, type, effect) {
        this._createPropertyAccessor(property, type == TYPES.READ_ONLY);
        // effects are accumulated into arrays per property based on type
        let effects = ensureOwnEffectMap(this, type)[property];
        if (!effects) {
          effects = this[type][property] = [];
        }
        effects.push(effect);
      }

      /**
       * Removes the given property effect.
       *
       * @param {string} property Property the effect was associated with
       * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
       * @param {Object=} effect Effect metadata object to remove
       * @return {void}
       */
      _removePropertyEffect(property, type, effect) {
        let effects = ensureOwnEffectMap(this, type)[property];
        let idx = effects.indexOf(effect);
        if (idx >= 0) {
          effects.splice(idx, 1);
        }
      }

      /**
       * Returns whether the current prototype/instance has a property effect
       * of a certain type.
       *
       * @param {string} property Property name
       * @param {string=} type Effect type, from this.PROPERTY_EFFECT_TYPES
       * @return {boolean} True if the prototype/instance has an effect of this type
       * @protected
       */
      _hasPropertyEffect(property, type) {
        let effects = this[type];
        return Boolean(effects && effects[property]);
      }

      /**
       * Returns whether the current prototype/instance has a "read only"
       * accessor for the given property.
       *
       * @param {string} property Property name
       * @return {boolean} True if the prototype/instance has an effect of this type
       * @protected
       */
      _hasReadOnlyEffect(property) {
        return this._hasPropertyEffect(property, TYPES.READ_ONLY);
      }

      /**
       * Returns whether the current prototype/instance has a "notify"
       * property effect for the given property.
       *
       * @param {string} property Property name
       * @return {boolean} True if the prototype/instance has an effect of this type
       * @protected
       */
      _hasNotifyEffect(property) {
        return this._hasPropertyEffect(property, TYPES.NOTIFY);
      }

      /**
       * Returns whether the current prototype/instance has a "reflect to attribute"
       * property effect for the given property.
       *
       * @param {string} property Property name
       * @return {boolean} True if the prototype/instance has an effect of this type
       * @protected
       */
      _hasReflectEffect(property) {
        return this._hasPropertyEffect(property, TYPES.REFLECT);
      }

      /**
       * Returns whether the current prototype/instance has a "computed"
       * property effect for the given property.
       *
       * @param {string} property Property name
       * @return {boolean} True if the prototype/instance has an effect of this type
       * @protected
       */
      _hasComputedEffect(property) {
        return this._hasPropertyEffect(property, TYPES.COMPUTE);
      }

      // Runtime ----------------------------------------

      /**
       * Sets a pending property or path.  If the root property of the path in
       * question had no accessor, the path is set, otherwise it is enqueued
       * via `_setPendingProperty`.
       *
       * This function isolates relatively expensive functionality necessary
       * for the public API (`set`, `setProperties`, `notifyPath`, and property
       * change listeners via {{...}} bindings), such that it is only done
       * when paths enter the system, and not at every propagation step.  It
       * also sets a `__dataHasPaths` flag on the instance which is used to
       * fast-path slower path-matching code in the property effects host paths.
       *
       * `path` can be a path string or array of path parts as accepted by the
       * public API.
       *
       * @param {string | !Array<number|string>} path Path to set
       * @param {*} value Value to set
       * @param {boolean=} shouldNotify Set to true if this change should
       *  cause a property notification event dispatch
       * @param {boolean=} isPathNotification If the path being set is a path
       *   notification of an already changed value, as opposed to a request
       *   to set and notify the change.  In the latter `false` case, a dirty
       *   check is performed and then the value is set to the path before
       *   enqueuing the pending property change.
       * @return {boolean} Returns true if the property/path was enqueued in
       *   the pending changes bag.
       * @protected
       */
      _setPendingPropertyOrPath(path, value, shouldNotify, isPathNotification) {
        if (isPathNotification ||
            Polymer.Path.root(Array.isArray(path) ? path[0] : path) !== path) {
          // Dirty check changes being set to a path against the actual object,
          // since this is the entry point for paths into the system; from here
          // the only dirty checks are against the `__dataTemp` cache to prevent
          // duplicate work in the same turn only. Note, if this was a notification
          // of a change already set to a path (isPathNotification: true),
          // we always let the change through and skip the `set` since it was
          // already dirty checked at the point of entry and the underlying
          // object has already been updated
          if (!isPathNotification) {
            let old = Polymer.Path.get(this, path);
            path = /** @type {string} */ (Polymer.Path.set(this, path, value));
            // Use property-accessor's simpler dirty check
            if (!path || !super._shouldPropertyChange(path, value, old)) {
              return false;
            }
          }
          this.__dataHasPaths = true;
          if (this._setPendingProperty(/**@type{string}*/(path), value, shouldNotify)) {
            computeLinkedPaths(this, path, value);
            return true;
          }
        } else {
          if (this.__dataHasAccessor && this.__dataHasAccessor[path]) {
            return this._setPendingProperty(/**@type{string}*/(path), value, shouldNotify);
          } else {
            this[path] = value;
          }
        }
        return false;
      }

      /**
       * Applies a value to a non-Polymer element/node's property.
       *
       * The implementation makes a best-effort at binding interop:
       * Some native element properties have side-effects when
       * re-setting the same value (e.g. setting `<input>.value` resets the
       * cursor position), so we do a dirty-check before setting the value.
       * However, for better interop with non-Polymer custom elements that
       * accept objects, we explicitly re-set object changes coming from the
       * Polymer world (which may include deep object changes without the
       * top reference changing), erring on the side of providing more
       * information.
       *
       * Users may override this method to provide alternate approaches.
       *
       * @param {!Node} node The node to set a property on
       * @param {string} prop The property to set
       * @param {*} value The value to set
       * @return {void}
       * @protected
       */
      _setUnmanagedPropertyToNode(node, prop, value) {
        // It is a judgment call that resetting primitives is
        // "bad" and resettings objects is also "good"; alternatively we could
        // implement a whitelist of tag & property values that should never
        // be reset (e.g. <input>.value && <select>.value)
        if (value !== node[prop] || typeof value == 'object') {
          node[prop] = value;
        }
      }

      /**
       * Overrides the `PropertiesChanged` implementation to introduce special
       * dirty check logic depending on the property & value being set:
       *
       * 1. Any value set to a path (e.g. 'obj.prop': 42 or 'obj.prop': {...})
       *    Stored in `__dataTemp`, dirty checked against `__dataTemp`
       * 2. Object set to simple property (e.g. 'prop': {...})
       *    Stored in `__dataTemp` and `__data`, dirty checked against
       *    `__dataTemp` by default implementation of `_shouldPropertyChange`
       * 3. Primitive value set to simple property (e.g. 'prop': 42)
       *    Stored in `__data`, dirty checked against `__data`
       *
       * The dirty-check is important to prevent cycles due to two-way
       * notification, but paths and objects are only dirty checked against any
       * previous value set during this turn via a "temporary cache" that is
       * cleared when the last `_propertiesChanged` exits. This is so:
       * a. any cached array paths (e.g. 'array.3.prop') may be invalidated
       *    due to array mutations like shift/unshift/splice; this is fine
       *    since path changes are dirty-checked at user entry points like `set`
       * b. dirty-checking for objects only lasts one turn to allow the user
       *    to mutate the object in-place and re-set it with the same identity
       *    and have all sub-properties re-propagated in a subsequent turn.
       *
       * The temp cache is not necessarily sufficient to prevent invalid array
       * paths, since a splice can happen during the same turn (with pathological
       * user code); we could introduce a "fixup" for temporarily cached array
       * paths if needed: https://github.com/Polymer/polymer/issues/4227
       *
       * @override
       * @param {string} property Name of the property
       * @param {*} value Value to set
       * @param {boolean=} shouldNotify True if property should fire notification
       *   event (applies only for `notify: true` properties)
       * @return {boolean} Returns true if the property changed
       */
      _setPendingProperty(property, value, shouldNotify) {
        let isPath = this.__dataHasPaths && Polymer.Path.isPath(property);
        let prevProps = isPath ? this.__dataTemp : this.__data;
        if (this._shouldPropertyChange(property, value, prevProps[property])) {
          if (!this.__dataPending) {
            this.__dataPending = {};
            this.__dataOld = {};
          }
          // Ensure old is captured from the last turn
          if (!(property in this.__dataOld)) {
            this.__dataOld[property] = this.__data[property];
          }
          // Paths are stored in temporary cache (cleared at end of turn),
          // which is used for dirty-checking, all others stored in __data
          if (isPath) {
            this.__dataTemp[property] = value;
          } else {
            this.__data[property] = value;
          }
          // All changes go into pending property bag, passed to _propertiesChanged
          this.__dataPending[property] = value;
          // Track properties that should notify separately
          if (isPath || (this[TYPES.NOTIFY] && this[TYPES.NOTIFY][property])) {
            this.__dataToNotify = this.__dataToNotify || {};
            this.__dataToNotify[property] = shouldNotify;
          }
          return true;
        }
        return false;
      }

      /**
       * Overrides base implementation to ensure all accessors set `shouldNotify`
       * to true, for per-property notification tracking.
       *
       * @override
       * @param {string} property Name of the property
       * @param {*} value Value to set
       * @return {void}
       */
      _setProperty(property, value) {
        if (this._setPendingProperty(property, value, true)) {
          this._invalidateProperties();
        }
      }

      /**
       * Overrides `PropertyAccessor`'s default async queuing of
       * `_propertiesChanged`: if `__dataReady` is false (has not yet been
       * manually flushed), the function no-ops; otherwise flushes
       * `_propertiesChanged` synchronously.
       *
       * @override
       * @return {void}
       */
      _invalidateProperties() {
        if (this.__dataReady) {
          this._flushProperties();
        }
      }

      /**
       * Enqueues the given client on a list of pending clients, whose
       * pending property changes can later be flushed via a call to
       * `_flushClients`.
       *
       * @param {Object} client PropertyEffects client to enqueue
       * @return {void}
       * @protected
       */
      _enqueueClient(client) {
        this.__dataPendingClients = this.__dataPendingClients || [];
        if (client !== this) {
          this.__dataPendingClients.push(client);
        }
      }

      /**
       * Overrides superclass implementation.
       *
       * @return {void}
       * @protected
       */
      _flushProperties() {
        this.__dataCounter++;
        super._flushProperties();
        this.__dataCounter--;
      }

      /**
       * Flushes any clients previously enqueued via `_enqueueClient`, causing
       * their `_flushProperties` method to run.
       *
       * @return {void}
       * @protected
       */
      _flushClients() {
        if (!this.__dataClientsReady) {
          this.__dataClientsReady = true;
          this._readyClients();
          // Override point where accessors are turned on; importantly,
          // this is after clients have fully readied, providing a guarantee
          // that any property effects occur only after all clients are ready.
          this.__dataReady = true;
        } else {
          this.__enableOrFlushClients();
        }
      }

      // NOTE: We ensure clients either enable or flush as appropriate. This
      // handles two corner cases:
      // (1) clients flush properly when connected/enabled before the host
      // enables; e.g.
      //   (a) Templatize stamps with no properties and does not flush and
      //   (b) the instance is inserted into dom and
      //   (c) then the instance flushes.
      // (2) clients enable properly when not connected/enabled when the host
      // flushes; e.g.
      //   (a) a template is runtime stamped and not yet connected/enabled
      //   (b) a host sets a property, causing stamped dom to flush
      //   (c) the stamped dom enables.
      __enableOrFlushClients() {
        let clients = this.__dataPendingClients;
        if (clients) {
          this.__dataPendingClients = null;
          for (let i=0; i < clients.length; i++) {
            let client = clients[i];
            if (!client.__dataEnabled) {
              client._enableProperties();
            } else if (client.__dataPending) {
              client._flushProperties();
            }
          }
        }
      }

      /**
       * Perform any initial setup on client dom. Called before the first
       * `_flushProperties` call on client dom and before any element
       * observers are called.
       *
       * @return {void}
       * @protected
       */
      _readyClients() {
        this.__enableOrFlushClients();
      }

      /**
       * Sets a bag of property changes to this instance, and
       * synchronously processes all effects of the properties as a batch.
       *
       * Property names must be simple properties, not paths.  Batched
       * path propagation is not supported.
       *
       * @param {Object} props Bag of one or more key-value pairs whose key is
       *   a property and value is the new value to set for that property.
       * @param {boolean=} setReadOnly When true, any private values set in
       *   `props` will be set. By default, `setProperties` will not set
       *   `readOnly: true` root properties.
       * @return {void}
       * @public
       */
      setProperties(props, setReadOnly) {
        for (let path in props) {
          if (setReadOnly || !this[TYPES.READ_ONLY] || !this[TYPES.READ_ONLY][path]) {
            //TODO(kschaaf): explicitly disallow paths in setProperty?
            // wildcard observers currently only pass the first changed path
            // in the `info` object, and you could do some odd things batching
            // paths, e.g. {'foo.bar': {...}, 'foo': null}
            this._setPendingPropertyOrPath(path, props[path], true);
          }
        }
        this._invalidateProperties();
      }

      /**
       * Overrides `PropertyAccessors` so that property accessor
       * side effects are not enabled until after client dom is fully ready.
       * Also calls `_flushClients` callback to ensure client dom is enabled
       * that was not enabled as a result of flushing properties.
       *
       * @override
       * @return {void}
       */
      ready() {
        // It is important that `super.ready()` is not called here as it
        // immediately turns on accessors. Instead, we wait until `readyClients`
        // to enable accessors to provide a guarantee that clients are ready
        // before processing any accessors side effects.
        this._flushProperties();
        // If no data was pending, `_flushProperties` will not `flushClients`
        // so ensure this is done.
        if (!this.__dataClientsReady) {
          this._flushClients();
        }
        // Before ready, client notifications do not trigger _flushProperties.
        // Therefore a flush is necessary here if data has been set.
        if (this.__dataPending) {
          this._flushProperties();
        }
      }

      /**
       * Implements `PropertyAccessors`'s properties changed callback.
       *
       * Runs each class of effects for the batch of changed properties in
       * a specific order (compute, propagate, reflect, observe, notify).
       *
       * @param {!Object} currentProps Bag of all current accessor values
       * @param {!Object} changedProps Bag of properties changed since the last
       *   call to `_propertiesChanged`
       * @param {!Object} oldProps Bag of previous values for each property
       *   in `changedProps`
       * @return {void}
       */
      _propertiesChanged(currentProps, changedProps, oldProps) {
        // ----------------------------
        // let c = Object.getOwnPropertyNames(changedProps || {});
        // window.debug && console.group(this.localName + '#' + this.id + ': ' + c);
        // if (window.debug) { debugger; }
        // ----------------------------
        let hasPaths = this.__dataHasPaths;
        this.__dataHasPaths = false;
        // Compute properties
        runComputedEffects(this, changedProps, oldProps, hasPaths);
        // Clear notify properties prior to possible reentry (propagate, observe),
        // but after computing effects have a chance to add to them
        let notifyProps = this.__dataToNotify;
        this.__dataToNotify = null;
        // Propagate properties to clients
        this._propagatePropertyChanges(changedProps, oldProps, hasPaths);
        // Flush clients
        this._flushClients();
        // Reflect properties
        runEffects(this, this[TYPES.REFLECT], changedProps, oldProps, hasPaths);
        // Observe properties
        runEffects(this, this[TYPES.OBSERVE], changedProps, oldProps, hasPaths);
        // Notify properties to host
        if (notifyProps) {
          runNotifyEffects(this, notifyProps, changedProps, oldProps, hasPaths);
        }
        // Clear temporary cache at end of turn
        if (this.__dataCounter == 1) {
          this.__dataTemp = {};
        }
        // ----------------------------
        // window.debug && console.groupEnd(this.localName + '#' + this.id + ': ' + c);
        // ----------------------------
      }

      /**
       * Called to propagate any property changes to stamped template nodes
       * managed by this element.
       *
       * @param {Object} changedProps Bag of changed properties
       * @param {Object} oldProps Bag of previous values for changed properties
       * @param {boolean} hasPaths True with `props` contains one or more paths
       * @return {void}
       * @protected
       */
      _propagatePropertyChanges(changedProps, oldProps, hasPaths) {
        if (this[TYPES.PROPAGATE]) {
          runEffects(this, this[TYPES.PROPAGATE], changedProps, oldProps, hasPaths);
        }
        let templateInfo = this.__templateInfo;
        while (templateInfo) {
          runEffects(this, templateInfo.propertyEffects, changedProps, oldProps,
            hasPaths, templateInfo.nodeList);
          templateInfo = templateInfo.nextTemplateInfo;
        }
      }

      /**
       * Aliases one data path as another, such that path notifications from one
       * are routed to the other.
       *
       * @param {string | !Array<string|number>} to Target path to link.
       * @param {string | !Array<string|number>} from Source path to link.
       * @return {void}
       * @public
       */
      linkPaths(to, from) {
        to = Polymer.Path.normalize(to);
        from = Polymer.Path.normalize(from);
        this.__dataLinkedPaths = this.__dataLinkedPaths || {};
        this.__dataLinkedPaths[to] = from;
      }

      /**
       * Removes a data path alias previously established with `_linkPaths`.
       *
       * Note, the path to unlink should be the target (`to`) used when
       * linking the paths.
       *
       * @param {string | !Array<string|number>} path Target path to unlink.
       * @return {void}
       * @public
       */
      unlinkPaths(path) {
        path = Polymer.Path.normalize(path);
        if (this.__dataLinkedPaths) {
          delete this.__dataLinkedPaths[path];
        }
      }

      /**
       * Notify that an array has changed.
       *
       * Example:
       *
       *     this.items = [ {name: 'Jim'}, {name: 'Todd'}, {name: 'Bill'} ];
       *     ...
       *     this.items.splice(1, 1, {name: 'Sam'});
       *     this.items.push({name: 'Bob'});
       *     this.notifySplices('items', [
       *       { index: 1, removed: [{name: 'Todd'}], addedCount: 1, object: this.items, type: 'splice' },
       *       { index: 3, removed: [], addedCount: 1, object: this.items, type: 'splice'}
       *     ]);
       *
       * @param {string} path Path that should be notified.
       * @param {Array} splices Array of splice records indicating ordered
       *   changes that occurred to the array. Each record should have the
       *   following fields:
       *    * index: index at which the change occurred
       *    * removed: array of items that were removed from this index
       *    * addedCount: number of new items added at this index
       *    * object: a reference to the array in question
       *    * type: the string literal 'splice'
       *
       *   Note that splice records _must_ be normalized such that they are
       *   reported in index order (raw results from `Object.observe` are not
       *   ordered and must be normalized/merged before notifying).
       * @return {void}
       * @public
      */
      notifySplices(path, splices) {
        let info = {path: ''};
        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
        notifySplices(this, array, info.path, splices);
      }

      /**
       * Convenience method for reading a value from a path.
       *
       * Note, if any part in the path is undefined, this method returns
       * `undefined` (this method does not throw when dereferencing undefined
       * paths).
       *
       * @param {(string|!Array<(string|number)>)} path Path to the value
       *   to read.  The path may be specified as a string (e.g. `foo.bar.baz`)
       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
       *   bracketed expressions are not supported; string-based path parts
       *   *must* be separated by dots.  Note that when dereferencing array
       *   indices, the index may be used as a dotted part directly
       *   (e.g. `users.12.name` or `['users', 12, 'name']`).
       * @param {Object=} root Root object from which the path is evaluated.
       * @return {*} Value at the path, or `undefined` if any part of the path
       *   is undefined.
       * @public
       */
      get(path, root) {
        return Polymer.Path.get(root || this, path);
      }

      /**
       * Convenience method for setting a value to a path and notifying any
       * elements bound to the same path.
       *
       * Note, if any part in the path except for the last is undefined,
       * this method does nothing (this method does not throw when
       * dereferencing undefined paths).
       *
       * @param {(string|!Array<(string|number)>)} path Path to the value
       *   to write.  The path may be specified as a string (e.g. `'foo.bar.baz'`)
       *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
       *   bracketed expressions are not supported; string-based path parts
       *   *must* be separated by dots.  Note that when dereferencing array
       *   indices, the index may be used as a dotted part directly
       *   (e.g. `'users.12.name'` or `['users', 12, 'name']`).
       * @param {*} value Value to set at the specified path.
       * @param {Object=} root Root object from which the path is evaluated.
       *   When specified, no notification will occur.
       * @return {void}
       * @public
      */
      set(path, value, root) {
        if (root) {
          Polymer.Path.set(root, path, value);
        } else {
          if (!this[TYPES.READ_ONLY] || !this[TYPES.READ_ONLY][/** @type {string} */(path)]) {
            if (this._setPendingPropertyOrPath(path, value, true)) {
              this._invalidateProperties();
            }
          }
        }
      }

      /**
       * Adds items onto the end of the array at the path specified.
       *
       * The arguments after `path` and return value match that of
       * `Array.prototype.push`.
       *
       * This method notifies other paths to the same array that a
       * splice occurred to the array.
       *
       * @param {string | !Array<string|number>} path Path to array.
       * @param {...*} items Items to push onto array
       * @return {number} New length of the array.
       * @public
       */
      push(path, ...items) {
        let info = {path: ''};
        let array = /** @type {Array}*/(Polymer.Path.get(this, path, info));
        let len = array.length;
        let ret = array.push(...items);
        if (items.length) {
          notifySplice(this, array, info.path, len, items.length, []);
        }
        return ret;
      }

      /**
       * Removes an item from the end of array at the path specified.
       *
       * The arguments after `path` and return value match that of
       * `Array.prototype.pop`.
       *
       * This method notifies other paths to the same array that a
       * splice occurred to the array.
       *
       * @param {string | !Array<string|number>} path Path to array.
       * @return {*} Item that was removed.
       * @public
       */
      pop(path) {
        let info = {path: ''};
        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
        let hadLength = Boolean(array.length);
        let ret = array.pop();
        if (hadLength) {
          notifySplice(this, array, info.path, array.length, 0, [ret]);
        }
        return ret;
      }

      /**
       * Starting from the start index specified, removes 0 or more items
       * from the array and inserts 0 or more new items in their place.
       *
       * The arguments after `path` and return value match that of
       * `Array.prototype.splice`.
       *
       * This method notifies other paths to the same array that a
       * splice occurred to the array.
       *
       * @param {string | !Array<string|number>} path Path to array.
       * @param {number} start Index from which to start removing/inserting.
       * @param {number} deleteCount Number of items to remove.
       * @param {...*} items Items to insert into array.
       * @return {Array} Array of removed items.
       * @public
       */
      splice(path, start, deleteCount, ...items) {
        let info = {path : ''};
        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
        // Normalize fancy native splice handling of crazy start values
        if (start < 0) {
          start = array.length - Math.floor(-start);
        } else if (start) {
          start = Math.floor(start);
        }
        // array.splice does different things based on the number of arguments
        // you pass in. Therefore, array.splice(0) and array.splice(0, undefined)
        // do different things. In the former, the whole array is cleared. In the
        // latter, no items are removed.
        // This means that we need to detect whether 1. one of the arguments
        // is actually passed in and then 2. determine how many arguments
        // we should pass on to the native array.splice
        //
        let ret;
        // Omit any additional arguments if they were not passed in
        if (arguments.length === 2) {
          ret = array.splice(start);
        // Either start was undefined and the others were defined, but in this
        // case we can safely pass on all arguments
        //
        // Note: this includes the case where none of the arguments were passed in,
        // e.g. this.splice('array'). However, if both start and deleteCount
        // are undefined, array.splice will not modify the array (as expected)
        } else {
          ret = array.splice(start, deleteCount, ...items);
        }
        // At the end, check whether any items were passed in (e.g. insertions)
        // or if the return array contains items (e.g. deletions).
        // Only notify if items were added or deleted.
        if (items.length || ret.length) {
          notifySplice(this, array, info.path, start, items.length, ret);
        }
        return ret;
      }

      /**
       * Removes an item from the beginning of array at the path specified.
       *
       * The arguments after `path` and return value match that of
       * `Array.prototype.pop`.
       *
       * This method notifies other paths to the same array that a
       * splice occurred to the array.
       *
       * @param {string | !Array<string|number>} path Path to array.
       * @return {*} Item that was removed.
       * @public
       */
      shift(path) {
        let info = {path: ''};
        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
        let hadLength = Boolean(array.length);
        let ret = array.shift();
        if (hadLength) {
          notifySplice(this, array, info.path, 0, 0, [ret]);
        }
        return ret;
      }

      /**
       * Adds items onto the beginning of the array at the path specified.
       *
       * The arguments after `path` and return value match that of
       * `Array.prototype.push`.
       *
       * This method notifies other paths to the same array that a
       * splice occurred to the array.
       *
       * @param {string | !Array<string|number>} path Path to array.
       * @param {...*} items Items to insert info array
       * @return {number} New length of the array.
       * @public
       */
      unshift(path, ...items) {
        let info = {path: ''};
        let array = /** @type {Array} */(Polymer.Path.get(this, path, info));
        let ret = array.unshift(...items);
        if (items.length) {
          notifySplice(this, array, info.path, 0, items.length, []);
        }
        return ret;
      }

      /**
       * Notify that a path has changed.
       *
       * Example:
       *
       *     this.item.user.name = 'Bob';
       *     this.notifyPath('item.user.name');
       *
       * @param {string} path Path that should be notified.
       * @param {*=} value Value at the path (optional).
       * @return {void}
       * @public
      */
      notifyPath(path, value) {
        /** @type {string} */
        let propPath;
        if (arguments.length == 1) {
          // Get value if not supplied
          let info = {path: ''};
          value = Polymer.Path.get(this, path, info);
          propPath = info.path;
        } else if (Array.isArray(path)) {
          // Normalize path if needed
          propPath = Polymer.Path.normalize(path);
        } else {
          propPath = /** @type{string} */(path);
        }
        if (this._setPendingPropertyOrPath(propPath, value, true, true)) {
          this._invalidateProperties();
        }
      }

      /**
       * Equivalent to static `createReadOnlyProperty` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} property Property name
       * @param {boolean=} protectedSetter Creates a custom protected setter
       *   when `true`.
       * @return {void}
       * @protected
       */
      _createReadOnlyProperty(property, protectedSetter) {
        this._addPropertyEffect(property, TYPES.READ_ONLY);
        if (protectedSetter) {
          this['_set' + upper(property)] = /** @this {PropertyEffects} */function(value) {
            this._setProperty(property, value);
          };
        }
      }

      /**
       * Equivalent to static `createPropertyObserver` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} property Property name
       * @param {string|function(*,*)} method Function or name of observer method to call
       * @param {boolean=} dynamicFn Whether the method name should be included as
       *   a dependency to the effect.
       * @return {void}
       * @protected
       */
      _createPropertyObserver(property, method, dynamicFn) {
        let info = { property, method, dynamicFn: Boolean(dynamicFn) };
        this._addPropertyEffect(property, TYPES.OBSERVE, {
          fn: runObserverEffect, info, trigger: {name: property}
        });
        if (dynamicFn) {
          this._addPropertyEffect(/** @type {string} */(method), TYPES.OBSERVE, {
            fn: runObserverEffect, info, trigger: {name: method}
          });
        }
      }

      /**
       * Equivalent to static `createMethodObserver` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} expression Method expression
       * @param {boolean|Object=} dynamicFn Boolean or object map indicating
       *   whether method names should be included as a dependency to the effect.
       * @return {void}
       * @protected
       */
      _createMethodObserver(expression, dynamicFn) {
        let sig = parseMethod(expression);
        if (!sig) {
          throw new Error("Malformed observer expression '" + expression + "'");
        }
        createMethodEffect(this, sig, TYPES.OBSERVE, runMethodEffect, null, dynamicFn);
      }

      /**
       * Equivalent to static `createNotifyingProperty` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} property Property name
       * @return {void}
       * @protected
       */
      _createNotifyingProperty(property) {
        this._addPropertyEffect(property, TYPES.NOTIFY, {
          fn: runNotifyEffect,
          info: {
            eventName: CaseMap.camelToDashCase(property) + '-changed',
            property: property
          }
        });
      }

      /**
       * Equivalent to static `createReflectedProperty` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} property Property name
       * @return {void}
       * @protected
       */
      _createReflectedProperty(property) {
        let attr = this.constructor.attributeNameForProperty(property);
        if (attr[0] === '-') {
          console.warn('Property ' + property + ' cannot be reflected to attribute ' +
            attr + ' because "-" is not a valid starting attribute name. Use a lowercase first letter for the property instead.');
        } else {
          this._addPropertyEffect(property, TYPES.REFLECT, {
            fn: runReflectEffect,
            info: {
              attrName: attr
            }
          });
        }
      }

      /**
       * Equivalent to static `createComputedProperty` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * @param {string} property Name of computed property to set
       * @param {string} expression Method expression
       * @param {boolean|Object=} dynamicFn Boolean or object map indicating
       *   whether method names should be included as a dependency to the effect.
       * @return {void}
       * @protected
       */
      _createComputedProperty(property, expression, dynamicFn) {
        let sig = parseMethod(expression);
        if (!sig) {
          throw new Error("Malformed computed expression '" + expression + "'");
        }
        createMethodEffect(this, sig, TYPES.COMPUTE, runComputedEffect, property, dynamicFn);
      }

      /**
       * Gather the argument values for a method specified in the provided array
       * of argument metadata.
       *
       * The `path` and `value` arguments are used to fill in wildcard descriptor
       * when the method is being called as a result of a path notification.
       *
       * @param {!Array<!MethodArg>} args Array of argument metadata
       * @param {string} path Property/path name that triggered the method effect
       * @param {Object} props Bag of current property changes
       * @return {Array<*>} Array of argument values
       * @private
       */
      _marshalArgs(args, path, props) {
        const data = this.__data;
        let values = [];
        for (let i=0, l=args.length; i<l; i++) {
          let arg = args[i];
          let name = arg.name;
          let v;
          if (arg.literal) {
            v = arg.value;
          } else {
            if (arg.structured) {
              v = Polymer.Path.get(data, name);
              // when data is not stored e.g. `splices`
              if (v === undefined) {
                v = props[name];
              }
            } else {
              v = data[name];
            }
          }
          if (arg.wildcard) {
            // Only send the actual path changed info if the change that
            // caused the observer to run matched the wildcard
            let baseChanged = (name.indexOf(path + '.') === 0);
            let matches = (path.indexOf(name) === 0 && !baseChanged);
            values[i] = {
              path: matches ? path : name,
              value: matches ? props[path] : v,
              base: v
            };
          } else {
            values[i] = v;
          }
        }
        return values;
      }

      // -- static class methods ------------

      /**
       * Ensures an accessor exists for the specified property, and adds
       * to a list of "property effects" that will run when the accessor for
       * the specified property is set.  Effects are grouped by "type", which
       * roughly corresponds to a phase in effect processing.  The effect
       * metadata should be in the following form:
       *
       *     {
       *       fn: effectFunction, // Reference to function to call to perform effect
       *       info: { ... }       // Effect metadata passed to function
       *       trigger: {          // Optional triggering metadata; if not provided
       *         name: string      // the property is treated as a wildcard
       *         structured: boolean
       *         wildcard: boolean
       *       }
       *     }
       *
       * Effects are called from `_propertiesChanged` in the following order by
       * type:
       *
       * 1. COMPUTE
       * 2. PROPAGATE
       * 3. REFLECT
       * 4. OBSERVE
       * 5. NOTIFY
       *
       * Effect functions are called with the following signature:
       *
       *     effectFunction(inst, path, props, oldProps, info, hasPaths)
       *
       * @param {string} property Property that should trigger the effect
       * @param {string} type Effect type, from this.PROPERTY_EFFECT_TYPES
       * @param {Object=} effect Effect metadata object
       * @return {void}
       * @protected
       */
      static addPropertyEffect(property, type, effect) {
        this.prototype._addPropertyEffect(property, type, effect);
      }

      /**
       * Creates a single-property observer for the given property.
       *
       * @param {string} property Property name
       * @param {string|function(*,*)} method Function or name of observer method to call
       * @param {boolean=} dynamicFn Whether the method name should be included as
       *   a dependency to the effect.
       * @return {void}
       * @protected
       */
      static createPropertyObserver(property, method, dynamicFn) {
        this.prototype._createPropertyObserver(property, method, dynamicFn);
      }

      /**
       * Creates a multi-property "method observer" based on the provided
       * expression, which should be a string in the form of a normal JavaScript
       * function signature: `'methodName(arg1, [..., argn])'`.  Each argument
       * should correspond to a property or path in the context of this
       * prototype (or instance), or may be a literal string or number.
       *
       * @param {string} expression Method expression
       * @param {boolean|Object=} dynamicFn Boolean or object map indicating
       * @return {void}
       *   whether method names should be included as a dependency to the effect.
       * @protected
       */
      static createMethodObserver(expression, dynamicFn) {
        this.prototype._createMethodObserver(expression, dynamicFn);
      }

      /**
       * Causes the setter for the given property to dispatch `<property>-changed`
       * events to notify of changes to the property.
       *
       * @param {string} property Property name
       * @return {void}
       * @protected
       */
      static createNotifyingProperty(property) {
        this.prototype._createNotifyingProperty(property);
      }

      /**
       * Creates a read-only accessor for the given property.
       *
       * To set the property, use the protected `_setProperty` API.
       * To create a custom protected setter (e.g. `_setMyProp()` for
       * property `myProp`), pass `true` for `protectedSetter`.
       *
       * Note, if the property will have other property effects, this method
       * should be called first, before adding other effects.
       *
       * @param {string} property Property name
       * @param {boolean=} protectedSetter Creates a custom protected setter
       *   when `true`.
       * @return {void}
       * @protected
       */
      static createReadOnlyProperty(property, protectedSetter) {
        this.prototype._createReadOnlyProperty(property, protectedSetter);
      }

      /**
       * Causes the setter for the given property to reflect the property value
       * to a (dash-cased) attribute of the same name.
       *
       * @param {string} property Property name
       * @return {void}
       * @protected
       */
      static createReflectedProperty(property) {
        this.prototype._createReflectedProperty(property);
      }

      /**
       * Creates a computed property whose value is set to the result of the
       * method described by the given `expression` each time one or more
       * arguments to the method changes.  The expression should be a string
       * in the form of a normal JavaScript function signature:
       * `'methodName(arg1, [..., argn])'`
       *
       * @param {string} property Name of computed property to set
       * @param {string} expression Method expression
       * @param {boolean|Object=} dynamicFn Boolean or object map indicating whether
       *   method names should be included as a dependency to the effect.
       * @return {void}
       * @protected
       */
      static createComputedProperty(property, expression, dynamicFn) {
        this.prototype._createComputedProperty(property, expression, dynamicFn);
      }

      /**
       * Parses the provided template to ensure binding effects are created
       * for them, and then ensures property accessors are created for any
       * dependent properties in the template.  Binding effects for bound
       * templates are stored in a linked list on the instance so that
       * templates can be efficiently stamped and unstamped.
       *
       * @param {!HTMLTemplateElement} template Template containing binding
       *   bindings
       * @return {!TemplateInfo} Template metadata object
       * @protected
       */
      static bindTemplate(template) {
        return this.prototype._bindTemplate(template);
      }

      // -- binding ----------------------------------------------

      /**
       * Equivalent to static `bindTemplate` API but can be called on
       * an instance to add effects at runtime.  See that method for
       * full API docs.
       *
       * This method may be called on the prototype (for prototypical template
       * binding, to avoid creating accessors every instance) once per prototype,
       * and will be called with `runtimeBinding: true` by `_stampTemplate` to
       * create and link an instance of the template metadata associated with a
       * particular stamping.
       *
       * @param {!HTMLTemplateElement} template Template containing binding
       *   bindings
       * @param {boolean=} instanceBinding When false (default), performs
       *   "prototypical" binding of the template and overwrites any previously
       *   bound template for the class. When true (as passed from
       *   `_stampTemplate`), the template info is instanced and linked into
       *   the list of bound templates.
       * @return {!TemplateInfo} Template metadata object; for `runtimeBinding`,
       *   this is an instance of the prototypical template info
       * @protected
       */
      _bindTemplate(template, instanceBinding) {
        let templateInfo = this.constructor._parseTemplate(template);
        let wasPreBound = this.__templateInfo == templateInfo;
        // Optimization: since this is called twice for proto-bound templates,
        // don't attempt to recreate accessors if this template was pre-bound
        if (!wasPreBound) {
          for (let prop in templateInfo.propertyEffects) {
            this._createPropertyAccessor(prop);
          }
        }
        if (instanceBinding) {
          // For instance-time binding, create instance of template metadata
          // and link into list of templates if necessary
          templateInfo = /** @type {!TemplateInfo} */(Object.create(templateInfo));
          templateInfo.wasPreBound = wasPreBound;
          if (!wasPreBound && this.__templateInfo) {
            let last = this.__templateInfoLast || this.__templateInfo;
            this.__templateInfoLast = last.nextTemplateInfo = templateInfo;
            templateInfo.previousTemplateInfo = last;
            return templateInfo;
          }
        }
        return this.__templateInfo = templateInfo;
      }

      /**
       * Adds a property effect to the given template metadata, which is run
       * at the "propagate" stage of `_propertiesChanged` when the template
       * has been bound to the element via `_bindTemplate`.
       *
       * The `effect` object should match the format in `_addPropertyEffect`.
       *
       * @param {Object} templateInfo Template metadata to add effect to
       * @param {string} prop Property that should trigger the effect
       * @param {Object=} effect Effect metadata object
       * @return {void}
       * @protected
       */
      static _addTemplatePropertyEffect(templateInfo, prop, effect) {
        let hostProps = templateInfo.hostProps = templateInfo.hostProps || {};
        hostProps[prop] = true;
        let effects = templateInfo.propertyEffects = templateInfo.propertyEffects || {};
        let propEffects = effects[prop] = effects[prop] || [];
        propEffects.push(effect);
      }

      /**
       * Stamps the provided template and performs instance-time setup for
       * Polymer template features, including data bindings, declarative event
       * listeners, and the `this.$` map of `id`'s to nodes.  A document fragment
       * is returned containing the stamped DOM, ready for insertion into the
       * DOM.
       *
       * This method may be called more than once; however note that due to
       * `shadycss` polyfill limitations, only styles from templates prepared
       * using `ShadyCSS.prepareTemplate` will be correctly polyfilled (scoped
       * to the shadow root and support CSS custom properties), and note that
       * `ShadyCSS.prepareTemplate` may only be called once per element. As such,
       * any styles required by in runtime-stamped templates must be included
       * in the main element template.
       *
       * @param {!HTMLTemplateElement} template Template to stamp
       * @return {!StampedTemplate} Cloned template content
       * @override
       * @protected
       */
      _stampTemplate(template) {
        // Ensures that created dom is `_enqueueClient`'d to this element so
        // that it can be flushed on next call to `_flushProperties`
        hostStack.beginHosting(this);
        let dom = super._stampTemplate(template);
        hostStack.endHosting(this);
        let templateInfo = /** @type {!TemplateInfo} */(this._bindTemplate(template, true));
        // Add template-instance-specific data to instanced templateInfo
        templateInfo.nodeList = dom.nodeList;
        // Capture child nodes to allow unstamping of non-prototypical templates
        if (!templateInfo.wasPreBound) {
          let nodes = templateInfo.childNodes = [];
          for (let n=dom.firstChild; n; n=n.nextSibling) {
            nodes.push(n);
          }
        }
        dom.templateInfo = templateInfo;
        // Setup compound storage, 2-way listeners, and dataHost for bindings
        setupBindings(this, templateInfo);
        // Flush properties into template nodes if already booted
        if (this.__dataReady) {
          runEffects(this, templateInfo.propertyEffects, this.__data, null,
            false, templateInfo.nodeList);
        }
        return dom;
      }

      /**
       * Removes and unbinds the nodes previously contained in the provided
       * DocumentFragment returned from `_stampTemplate`.
       *
       * @param {!StampedTemplate} dom DocumentFragment previously returned
       *   from `_stampTemplate` associated with the nodes to be removed
       * @return {void}
       * @protected
       */
      _removeBoundDom(dom) {
        // Unlink template info
        let templateInfo = dom.templateInfo;
        if (templateInfo.previousTemplateInfo) {
          templateInfo.previousTemplateInfo.nextTemplateInfo =
            templateInfo.nextTemplateInfo;
        }
        if (templateInfo.nextTemplateInfo) {
          templateInfo.nextTemplateInfo.previousTemplateInfo =
            templateInfo.previousTemplateInfo;
        }
        if (this.__templateInfoLast == templateInfo) {
          this.__templateInfoLast = templateInfo.previousTemplateInfo;
        }
        templateInfo.previousTemplateInfo = templateInfo.nextTemplateInfo = null;
        // Remove stamped nodes
        let nodes = templateInfo.childNodes;
        for (let i=0; i<nodes.length; i++) {
          let node = nodes[i];
          node.parentNode.removeChild(node);
        }
      }

      /**
       * Overrides default `TemplateStamp` implementation to add support for
       * parsing bindings from `TextNode`'s' `textContent`.  A `bindings`
       * array is added to `nodeInfo` and populated with binding metadata
       * with information capturing the binding target, and a `parts` array
       * with one or more metadata objects capturing the source(s) of the
       * binding.
       *
       * @override
       * @param {Node} node Node to parse
       * @param {TemplateInfo} templateInfo Template metadata for current template
       * @param {NodeInfo} nodeInfo Node metadata for current template node
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       * @protected
       * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
       */
      static _parseTemplateNode(node, templateInfo, nodeInfo) {
        let noted = super._parseTemplateNode(node, templateInfo, nodeInfo);
        if (node.nodeType === Node.TEXT_NODE) {
          let parts = this._parseBindings(node.textContent, templateInfo);
          if (parts) {
            // Initialize the textContent with any literal parts
            // NOTE: default to a space here so the textNode remains; some browsers
            // (IE) omit an empty textNode following cloneNode/importNode.
            node.textContent = literalFromParts(parts) || ' ';
            addBinding(this, templateInfo, nodeInfo, 'text', 'textContent', parts);
            noted = true;
          }
        }
        return noted;
      }

      /**
       * Overrides default `TemplateStamp` implementation to add support for
       * parsing bindings from attributes.  A `bindings`
       * array is added to `nodeInfo` and populated with binding metadata
       * with information capturing the binding target, and a `parts` array
       * with one or more metadata objects capturing the source(s) of the
       * binding.
       *
       * @override
       * @param {Element} node Node to parse
       * @param {TemplateInfo} templateInfo Template metadata for current template
       * @param {NodeInfo} nodeInfo Node metadata for current template node
       * @param {string} name Attribute name
       * @param {string} value Attribute value
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       * @protected
       * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
       */
      static _parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value) {
        let parts = this._parseBindings(value, templateInfo);
        if (parts) {
          // Attribute or property
          let origName = name;
          let kind = 'property';
          // The only way we see a capital letter here is if the attr has
          // a capital letter in it per spec. In this case, to make sure
          // this binding works, we go ahead and make the binding to the attribute.
          if (capitalAttributeRegex.test(name)) {
            kind = 'attribute';
          } else if (name[name.length-1] == '$') {
            name = name.slice(0, -1);
            kind = 'attribute';
          }
          // Initialize attribute bindings with any literal parts
          let literal = literalFromParts(parts);
          if (literal && kind == 'attribute') {
            // Ensure a ShadyCSS template scoped style is not removed
            // when a class$ binding's initial literal value is set.
            if (name == 'class' && node.hasAttribute('class')) {
              literal += ' ' + node.getAttribute(name);
            }
            node.setAttribute(name, literal);
          }
          // Clear attribute before removing, since IE won't allow removing
          // `value` attribute if it previously had a value (can't
          // unconditionally set '' before removing since attributes with `$`
          // can't be set using setAttribute)
          if (node.localName === 'input' && origName === 'value') {
            node.setAttribute(origName, '');
          }
          // Remove annotation
          node.removeAttribute(origName);
          // Case hackery: attributes are lower-case, but bind targets
          // (properties) are case sensitive. Gambit is to map dash-case to
          // camel-case: `foo-bar` becomes `fooBar`.
          // Attribute bindings are excepted.
          if (kind === 'property') {
            name = Polymer.CaseMap.dashToCamelCase(name);
          }
          addBinding(this, templateInfo, nodeInfo, kind, name, parts, literal);
          return true;
        } else {
          return super._parseTemplateNodeAttribute(node, templateInfo, nodeInfo, name, value);
        }
      }

      /**
       * Overrides default `TemplateStamp` implementation to add support for
       * binding the properties that a nested template depends on to the template
       * as `_host_<property>`.
       *
       * @override
       * @param {Node} node Node to parse
       * @param {TemplateInfo} templateInfo Template metadata for current template
       * @param {NodeInfo} nodeInfo Node metadata for current template node
       * @return {boolean} `true` if the visited node added node-specific
       *   metadata to `nodeInfo`
       * @protected
       * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
       */
      static _parseTemplateNestedTemplate(node, templateInfo, nodeInfo) {
        let noted = super._parseTemplateNestedTemplate(node, templateInfo, nodeInfo);
        // Merge host props into outer template and add bindings
        let hostProps = nodeInfo.templateInfo.hostProps;
        let mode = '{';
        for (let source in hostProps) {
          let parts = [{ mode, source, dependencies: [source] }];
          addBinding(this, templateInfo, nodeInfo, 'property', '_host_' + source, parts);
        }
        return noted;
      }

      /**
       * Called to parse text in a template (either attribute values or
       * textContent) into binding metadata.
       *
       * Any overrides of this method should return an array of binding part
       * metadata  representing one or more bindings found in the provided text
       * and any "literal" text in between.  Any non-literal parts will be passed
       * to `_evaluateBinding` when any dependencies change.  The only required
       * fields of each "part" in the returned array are as follows:
       *
       * - `dependencies` - Array containing trigger metadata for each property
       *   that should trigger the binding to update
       * - `literal` - String containing text if the part represents a literal;
       *   in this case no `dependencies` are needed
       *
       * Additional metadata for use by `_evaluateBinding` may be provided in
       * each part object as needed.
       *
       * The default implementation handles the following types of bindings
       * (one or more may be intermixed with literal strings):
       * - Property binding: `[[prop]]`
       * - Path binding: `[[object.prop]]`
       * - Negated property or path bindings: `[[!prop]]` or `[[!object.prop]]`
       * - Two-way property or path bindings (supports negation):
       *   `{{prop}}`, `{{object.prop}}`, `{{!prop}}` or `{{!object.prop}}`
       * - Inline computed method (supports negation):
       *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
       *
       * The default implementation uses a regular expression for best
       * performance. However, the regular expression uses a white-list of
       * allowed characters in a data-binding, which causes problems for
       * data-bindings that do use characters not in this white-list.
       *
       * Instead of updating the white-list with all allowed characters,
       * there is a StrictBindingParser (see lib/mixins/strict-binding-parser)
       * that uses a state machine instead. This state machine is able to handle
       * all characters. However, it is slightly less performant, therefore we
       * extracted it into a separate optional mixin.
       *
       * @param {string} text Text to parse from attribute or textContent
       * @param {Object} templateInfo Current template metadata
       * @return {Array<!BindingPart>} Array of binding part metadata
       * @protected
       */
      static _parseBindings(text, templateInfo) {
        let parts = [];
        let lastIndex = 0;
        let m;
        // Example: "literal1{{prop}}literal2[[!compute(foo,bar)]]final"
        // Regex matches:
        //        Iteration 1:  Iteration 2:
        // m[1]: '{{'          '[['
        // m[2]: ''            '!'
        // m[3]: 'prop'        'compute(foo,bar)'
        while ((m = bindingRegex.exec(text)) !== null) {
          // Add literal part
          if (m.index > lastIndex) {
            parts.push({literal: text.slice(lastIndex, m.index)});
          }
          // Add binding part
          let mode = m[1][0];
          let negate = Boolean(m[2]);
          let source = m[3].trim();
          let customEvent = false, notifyEvent = '', colon = -1;
          if (mode == '{' && (colon = source.indexOf('::')) > 0) {
            notifyEvent = source.substring(colon + 2);
            source = source.substring(0, colon);
            customEvent = true;
          }
          let signature = parseMethod(source);
          let dependencies = [];
          if (signature) {
            // Inline computed function
            let {args, methodName} = signature;
            for (let i=0; i<args.length; i++) {
              let arg = args[i];
              if (!arg.literal) {
                dependencies.push(arg);
              }
            }
            let dynamicFns = templateInfo.dynamicFns;
            if (dynamicFns && dynamicFns[methodName] || signature.static) {
              dependencies.push(methodName);
              signature.dynamicFn = true;
            }
          } else {
            // Property or path
            dependencies.push(source);
          }
          parts.push({
            source, mode, negate, customEvent, signature, dependencies,
            event: notifyEvent
          });
          lastIndex = bindingRegex.lastIndex;
        }
        // Add a final literal part
        if (lastIndex && lastIndex < text.length) {
          let literal = text.substring(lastIndex);
          if (literal) {
            parts.push({
              literal: literal
            });
          }
        }
        if (parts.length) {
          return parts;
        } else {
          return null;
        }
      }

      /**
       * Called to evaluate a previously parsed binding part based on a set of
       * one or more changed dependencies.
       *
       * @param {this} inst Element that should be used as scope for
       *   binding dependencies
       * @param {BindingPart} part Binding part metadata
       * @param {string} path Property/path that triggered this effect
       * @param {Object} props Bag of current property changes
       * @param {Object} oldProps Bag of previous values for changed properties
       * @param {boolean} hasPaths True with `props` contains one or more paths
       * @return {*} Value the binding part evaluated to
       * @protected
       */
      static _evaluateBinding(inst, part, path, props, oldProps, hasPaths) {
        let value;
        if (part.signature) {
          value = runMethodEffect(inst, path, props, oldProps, part.signature);
        } else if (path != part.source) {
          value = Polymer.Path.get(inst, part.source);
        } else {
          if (hasPaths && Polymer.Path.isPath(path)) {
            value = Polymer.Path.get(inst, path);
          } else {
            value = inst.__data[path];
          }
        }
        if (part.negate) {
          value = !value;
        }
        return value;
      }

    }

    // make a typing for closure :P
    PropertyEffectsType = PropertyEffects;

    return PropertyEffects;
  });

  /**
   * Helper api for enqueuing client dom created by a host element.
   *
   * By default elements are flushed via `_flushProperties` when
   * `connectedCallback` is called. Elements attach their client dom to
   * themselves at `ready` time which results from this first flush.
   * This provides an ordering guarantee that the client dom an element
   * creates is flushed before the element itself (i.e. client `ready`
   * fires before host `ready`).
   *
   * However, if `_flushProperties` is called *before* an element is connected,
   * as for example `Templatize` does, this ordering guarantee cannot be
   * satisfied because no elements are connected. (Note: Bound elements that
   * receive data do become enqueued clients and are properly ordered but
   * unbound elements are not.)
   *
   * To maintain the desired "client before host" ordering guarantee for this
   * case we rely on the "host stack. Client nodes registers themselves with
   * the creating host element when created. This ensures that all client dom
   * is readied in the proper order, maintaining the desired guarantee.
   *
   * @private
   */
  let hostStack = {

    stack: [],

    /**
     * @param {*} inst Instance to add to hostStack
     * @return {void}
     * @this {hostStack}
     */
    registerHost(inst) {
      if (this.stack.length) {
        let host = this.stack[this.stack.length-1];
        host._enqueueClient(inst);
      }
    },

    /**
     * @param {*} inst Instance to begin hosting
     * @return {void}
     * @this {hostStack}
     */
    beginHosting(inst) {
      this.stack.push(inst);
    },

    /**
     * @param {*} inst Instance to end hosting
     * @return {void}
     * @this {hostStack}
     */
    endHosting(inst) {
      let stackLen = this.stack.length;
      if (stackLen && this.stack[stackLen-1] == inst) {
        this.stack.pop();
      }
    }

  };

})();


(function() {
  'use strict';

  /**
   * Provides basic tracking of element definitions (registrations) and
   * instance counts.
   *
   * @namespace
   * @summary Provides basic tracking of element definitions (registrations) and
   * instance counts.
   */
  Polymer.telemetry = {
    /**
     * Total number of Polymer element instances created.
     * @type {number}
     */
    instanceCount: 0,
    /**
     * Array of Polymer element classes that have been finalized.
     * @type {Array<Polymer.Element>}
     */
    registrations: [],
    /**
     * @param {!PolymerElementConstructor} prototype Element prototype to log
     * @this {this}
     * @private
     */
    _regLog: function(prototype) {
      console.log('[' + prototype.is + ']: registered');
    },
    /**
     * Registers a class prototype for telemetry purposes.
     * @param {HTMLElement} prototype Element prototype to register
     * @this {this}
     * @protected
     */
    register: function(prototype) {
      this.registrations.push(prototype);
      Polymer.log && this._regLog(prototype);
    },
    /**
     * Logs all elements registered with an `is` to the console.
     * @public
     * @this {this}
     */
    dumpRegistrations: function() {
      this.registrations.forEach(this._regLog);
    }
  };

})();


(function() {
  'use strict';

  /**
   * Creates a copy of `props` with each property normalized such that
   * upgraded it is an object with at least a type property { type: Type}.
   *
   * @param {Object} props Properties to normalize
   * @return {Object} Copy of input `props` with normalized properties that
   * are in the form {type: Type}
   * @private
   */
  function normalizeProperties(props) {
    const output = {};
    for (let p in props) {
      const o = props[p];
      output[p] = (typeof o === 'function') ? {type: o} : o;
    }
    return output;
  }

  /**
   * Mixin that provides a minimal starting point to using the PropertiesChanged
   * mixin by providing a mechanism to declare properties in a static
   * getter (e.g. static get properties() { return { foo: String } }). Changes
   * are reported via the `_propertiesChanged` method.
   *
   * This mixin provides no specific support for rendering. Users are expected
   * to create a ShadowRoot and put content into it and update it in whatever
   * way makes sense. This can be done in reaction to properties changing by
   * implementing `_propertiesChanged`.
   *
   * @mixinFunction
   * @polymer
   * @appliesMixin Polymer.PropertiesChanged
   * @memberof Polymer
   * @summary Mixin that provides a minimal starting point for using
   * the PropertiesChanged mixin by providing a declarative `properties` object.
   */
   Polymer.PropertiesMixin = Polymer.dedupingMixin(superClass => {

    /**
     * @constructor
     * @extends {superClass}
     * @implements {Polymer_PropertiesChanged}
     * @private
     */
    const base = Polymer.PropertiesChanged(superClass);

    /**
     * Returns the super class constructor for the given class, if it is an
     * instance of the PropertiesMixin.
     *
     * @param {!PropertiesMixinConstructor} constructor PropertiesMixin constructor
     * @return {PropertiesMixinConstructor} Super class constructor
     */
    function superPropertiesClass(constructor) {
      const superCtor = Object.getPrototypeOf(constructor);

      // Note, the `PropertiesMixin` class below only refers to the class
      // generated by this call to the mixin; the instanceof test only works
      // because the mixin is deduped and guaranteed only to apply once, hence
      // all constructors in a proto chain will see the same `PropertiesMixin`
      return (superCtor.prototype instanceof PropertiesMixin) ?
        /** @type {PropertiesMixinConstructor} */ (superCtor) : null;
    }

    /**
     * Returns a memoized version of the `properties` object for the
     * given class. Properties not in object format are converted to at
     * least {type}.
     *
     * @param {PropertiesMixinConstructor} constructor PropertiesMixin constructor
     * @return {Object} Memoized properties object
     */
    function ownProperties(constructor) {
      if (!constructor.hasOwnProperty(JSCompiler_renameProperty('__ownProperties', constructor))) {
        let props = null;

        if (constructor.hasOwnProperty(JSCompiler_renameProperty('properties', constructor))) {
          const properties = constructor.properties;
          
          if (properties) {
            props = normalizeProperties(properties);
          }
        }

        constructor.__ownProperties = props;
      }
      return constructor.__ownProperties;
    }

    /**
     * @polymer
     * @mixinClass
     * @extends {base}
     * @implements {Polymer_PropertiesMixin}
     * @unrestricted
     */
    class PropertiesMixin extends base {

      /**
       * Implements standard custom elements getter to observes the attributes
       * listed in `properties`.
       * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
       */
      static get observedAttributes() {
        if (!this.hasOwnProperty('__observedAttributes')) {
          Polymer.telemetry.register(this.prototype);
          const props = this._properties;
          this.__observedAttributes = props ? Object.keys(props).map(p => this.attributeNameForProperty(p)) : [];
        }
        return this.__observedAttributes;
      }

      /**
       * Finalizes an element definition, including ensuring any super classes
       * are also finalized. This includes ensuring property
       * accessors exist on the element prototype. This method calls
       * `_finalizeClass` to finalize each constructor in the prototype chain.
       * @return {void}
       */
      static finalize() {
        if (!this.hasOwnProperty(JSCompiler_renameProperty('__finalized', this))) {
          const superCtor = superPropertiesClass(/** @type {PropertiesMixinConstructor} */(this));
          if (superCtor) {
            superCtor.finalize();
          }
          this.__finalized = true;
          this._finalizeClass();
        }
      }

      /**
       * Finalize an element class. This includes ensuring property
       * accessors exist on the element prototype. This method is called by
       * `finalize` and finalizes the class constructor.
       *
       * @protected
       */
      static _finalizeClass() {
        const props = ownProperties(/** @type {PropertiesMixinConstructor} */(this));
        if (props) {
          this.createProperties(props);
        }
      }

      /**
       * Returns a memoized version of all properties, including those inherited
       * from super classes. Properties not in object format are converted to
       * at least {type}.
       *
       * @return {Object} Object containing properties for this class
       * @protected
       */
      static get _properties() {
        if (!this.hasOwnProperty(
          JSCompiler_renameProperty('__properties', this))) {
          const superCtor = superPropertiesClass(/** @type {PropertiesMixinConstructor} */(this));
          this.__properties = Object.assign({},
            superCtor && superCtor._properties,
            ownProperties(/** @type {PropertiesMixinConstructor} */(this)));
        }
        return this.__properties;
      }

      /**
       * Overrides `PropertiesChanged` method to return type specified in the
       * static `properties` object for the given property.
       * @param {string} name Name of property
       * @return {*} Type to which to deserialize attribute
       *
       * @protected
       */
      static typeForProperty(name) {
        const info = this._properties[name];
        return info && info.type;
      }

      /**
       * Overrides `PropertiesChanged` method and adds a call to
       * `finalize` which lazily configures the element's property accessors.
       * @override
       * @return {void}
       */
      _initializeProperties() {
        Polymer.telemetry.instanceCount++;
        this.constructor.finalize();
        super._initializeProperties();
      }

      /**
       * Called when the element is added to a document.
       * Calls `_enableProperties` to turn on property system from
       * `PropertiesChanged`.
       * @suppress {missingProperties} Super may or may not implement the callback
       * @return {void}
       */
      connectedCallback() {
        if (super.connectedCallback) {
          super.connectedCallback();
        }
        this._enableProperties();
      }

      /**
       * Called when the element is removed from a document
       * @suppress {missingProperties} Super may or may not implement the callback
       * @return {void}
       */
      disconnectedCallback() {
        if (super.disconnectedCallback) {
          super.disconnectedCallback();
        }
      }

    }

    return PropertiesMixin;

  });

})();



(function() {
  'use strict';

  const builtCSS = window.ShadyCSS && window.ShadyCSS['cssBuild'];

  /**
   * Element class mixin that provides the core API for Polymer's meta-programming
   * features including template stamping, data-binding, attribute deserialization,
   * and property change observation.
   *
   * Subclassers may provide the following static getters to return metadata
   * used to configure Polymer's features for the class:
   *
   * - `static get is()`: When the template is provided via a `dom-module`,
   *   users should return the `dom-module` id from a static `is` getter.  If
   *   no template is needed or the template is provided directly via the
   *   `template` getter, there is no need to define `is` for the element.
   *
   * - `static get template()`: Users may provide the template directly (as
   *   opposed to via `dom-module`) by implementing a static `template` getter.
   *   The getter may return an `HTMLTemplateElement` or a string, which will
   *   automatically be parsed into a template.
   *
   * - `static get properties()`: Should return an object describing
   *   property-related metadata used by Polymer features (key: property name
   *   value: object containing property metadata). Valid keys in per-property
   *   metadata include:
   *   - `type` (String|Number|Object|Array|...): Used by
   *     `attributeChangedCallback` to determine how string-based attributes
   *     are deserialized to JavaScript property values.
   *   - `notify` (boolean): Causes a change in the property to fire a
   *     non-bubbling event called `<property>-changed`. Elements that have
   *     enabled two-way binding to the property use this event to observe changes.
   *   - `readOnly` (boolean): Creates a getter for the property, but no setter.
   *     To set a read-only property, use the private setter method
   *     `_setProperty(property, value)`.
   *   - `observer` (string): Observer method name that will be called when
   *     the property changes. The arguments of the method are
   *     `(value, previousValue)`.
   *   - `computed` (string): String describing method and dependent properties
   *     for computing the value of this property (e.g. `'computeFoo(bar, zot)'`).
   *     Computed properties are read-only by default and can only be changed
   *     via the return value of the computing method.
   *
   * - `static get observers()`: Array of strings describing multi-property
   *   observer methods and their dependent properties (e.g.
   *   `'observeABC(a, b, c)'`).
   *
   * The base class provides default implementations for the following standard
   * custom element lifecycle callbacks; users may override these, but should
   * call the super method to ensure
   * - `constructor`: Run when the element is created or upgraded
   * - `connectedCallback`: Run each time the element is connected to the
   *   document
   * - `disconnectedCallback`: Run each time the element is disconnected from
   *   the document
   * - `attributeChangedCallback`: Run each time an attribute in
   *   `observedAttributes` is set or removed (note: this element's default
   *   `observedAttributes` implementation will automatically return an array
   *   of dash-cased attributes based on `properties`)
   *
   * @mixinFunction
   * @polymer
   * @appliesMixin Polymer.PropertyEffects
   * @appliesMixin Polymer.PropertiesMixin
   * @memberof Polymer
   * @property rootPath {string} Set to the value of `Polymer.rootPath`,
   *   which defaults to the main document path
   * @property importPath {string} Set to the value of the class's static
   *   `importPath` property, which defaults to the path of this element's
   *   `dom-module` (when `is` is used), but can be overridden for other
   *   import strategies.
   * @summary Element class mixin that provides the core API for Polymer's
   * meta-programming features.
   */
  Polymer.ElementMixin = Polymer.dedupingMixin(base => {

    /**
     * @constructor
     * @extends {base}
     * @implements {Polymer_PropertyEffects}
     * @implements {Polymer_PropertiesMixin}
     * @private
     */
    const polymerElementBase = Polymer.PropertiesMixin(Polymer.PropertyEffects(base));

    /**
     * Returns a list of properties with default values.
     * This list is created as an optimization since it is a subset of
     * the list returned from `_properties`.
     * This list is used in `_initializeProperties` to set property defaults.
     *
     * @param {PolymerElementConstructor} constructor Element class
     * @return {PolymerElementProperties} Flattened properties for this class
     *   that have default values
     * @private
     */
    function propertyDefaults(constructor) {
      if (!constructor.hasOwnProperty(
        JSCompiler_renameProperty('__propertyDefaults', constructor))) {
        constructor.__propertyDefaults = null;
        let props = constructor._properties;
        for (let p in props) {
          let info = props[p];
          if ('value' in info) {
            constructor.__propertyDefaults = constructor.__propertyDefaults || {};
            constructor.__propertyDefaults[p] = info;
          }
        }
      }
      return constructor.__propertyDefaults;
    }

    /**
     * Returns a memoized version of the `observers` array.
     * @param {PolymerElementConstructor} constructor Element class
     * @return {Array} Array containing own observers for the given class
     * @protected
     */
    function ownObservers(constructor) {
      if (!constructor.hasOwnProperty(
        JSCompiler_renameProperty('__ownObservers', constructor))) {
          constructor.__ownObservers =
          constructor.hasOwnProperty(JSCompiler_renameProperty('observers', constructor)) ?
          /** @type {PolymerElementConstructor} */ (constructor).observers : null;
      }
      return constructor.__ownObservers;
    }

    /**
     * Creates effects for a property.
     *
     * Note, once a property has been set to
     * `readOnly`, `computed`, `reflectToAttribute`, or `notify`
     * these values may not be changed. For example, a subclass cannot
     * alter these settings. However, additional `observers` may be added
     * by subclasses.
     *
     * The info object should contain property metadata as follows:
     *
     * * `type`: {function} type to which an attribute matching the property
     * is deserialized. Note the property is camel-cased from a dash-cased
     * attribute. For example, 'foo-bar' attribute is deserialized to a
     * property named 'fooBar'.
     *
     * * `readOnly`: {boolean} creates a readOnly property and
     * makes a private setter for the private of the form '_setFoo' for a
     * property 'foo',
     *
     * * `computed`: {string} creates a computed property. A computed property
     * is also automatically set to `readOnly: true`. The value is calculated
     * by running a method and arguments parsed from the given string. For
     * example 'compute(foo)' will compute a given property when the
     * 'foo' property changes by executing the 'compute' method. This method
     * must return the computed value.
     *
     * * `reflectToAttribute`: {boolean} If true, the property value is reflected
     * to an attribute of the same name. Note, the attribute is dash-cased
     * so a property named 'fooBar' is reflected as 'foo-bar'.
     *
     * * `notify`: {boolean} sends a non-bubbling notification event when
     * the property changes. For example, a property named 'foo' sends an
     * event named 'foo-changed' with `event.detail` set to the value of
     * the property.
     *
     * * observer: {string} name of a method that runs when the property
     * changes. The arguments of the method are (value, previousValue).
     *
     * Note: Users may want control over modifying property
     * effects via subclassing. For example, a user might want to make a
     * reflectToAttribute property not do so in a subclass. We've chosen to
     * disable this because it leads to additional complication.
     * For example, a readOnly effect generates a special setter. If a subclass
     * disables the effect, the setter would fail unexpectedly.
     * Based on feedback, we may want to try to make effects more malleable
     * and/or provide an advanced api for manipulating them.
     * Also consider adding warnings when an effect cannot be changed.
     *
     * @param {!PolymerElement} proto Element class prototype to add accessors
     *   and effects to
     * @param {string} name Name of the property.
     * @param {Object} info Info object from which to create property effects.
     * Supported keys:
     * @param {Object} allProps Flattened map of all properties defined in this
     *   element (including inherited properties)
     * @return {void}
     * @private
     */
    function createPropertyFromConfig(proto, name, info, allProps) {
      // computed forces readOnly...
      if (info.computed) {
        info.readOnly = true;
      }
      // Note, since all computed properties are readOnly, this prevents
      // adding additional computed property effects (which leads to a confusing
      // setup where multiple triggers for setting a property)
      // While we do have `hasComputedEffect` this is set on the property's
      // dependencies rather than itself.
      if (info.computed && !proto._hasReadOnlyEffect(name)) {
        proto._createComputedProperty(name, info.computed, allProps);
      }
      if (info.readOnly && !proto._hasReadOnlyEffect(name)) {
        proto._createReadOnlyProperty(name, !info.computed);
      }
      if (info.reflectToAttribute && !proto._hasReflectEffect(name)) {
        proto._createReflectedProperty(name);
      }
      if (info.notify && !proto._hasNotifyEffect(name)) {
        proto._createNotifyingProperty(name);
      }
      // always add observer
      if (info.observer) {
        proto._createPropertyObserver(name, info.observer, allProps[info.observer]);
      }
      // always create the mapping from attribute back to property for deserialization.
      proto._addPropertyToAttributeMap(name);
    }

    /**
     * Process all style elements in the element template. Styles with the
     * `include` attribute are processed such that any styles in
     * the associated "style modules" are included in the element template.
     * @param {PolymerElementConstructor} klass Element class
     * @param {!HTMLTemplateElement} template Template to process
     * @param {string} is Name of element
     * @param {string} baseURI Base URI for element
     * @private
     */
    function processElementStyles(klass, template, is, baseURI) {
      if (!builtCSS) {
        const templateStyles = template.content.querySelectorAll('style');
        const stylesWithImports = Polymer.StyleGather.stylesFromTemplate(template);
        // insert styles from <link rel="import" type="css"> at the top of the template
        const linkedStyles = Polymer.StyleGather.stylesFromModuleImports(is);
        const firstTemplateChild = template.content.firstElementChild;
        for (let idx = 0; idx < linkedStyles.length; idx++) {
          let s = linkedStyles[idx];
          s.textContent = klass._processStyleText(s.textContent, baseURI);
          template.content.insertBefore(s, firstTemplateChild);
        }
        // keep track of the last "concrete" style in the template we have encountered
        let templateStyleIndex = 0;
        // ensure all gathered styles are actually in this template.
        for (let i = 0; i < stylesWithImports.length; i++) {
          let s = stylesWithImports[i];
          let templateStyle = templateStyles[templateStyleIndex];
          // if the style is not in this template, it's been "included" and
          // we put a clone of it in the template before the style that included it
          if (templateStyle !== s) {
            s = s.cloneNode(true);
            templateStyle.parentNode.insertBefore(s, templateStyle);
          } else {
            templateStyleIndex++;
          }
          s.textContent = klass._processStyleText(s.textContent, baseURI);
        }
      }
      if (window.ShadyCSS) {
        window.ShadyCSS.prepareTemplate(template, is);
      }
    }

    /**
     * Look up template from dom-module for element
     *
     * @param {!string} is Element name to look up
     * @return {!HTMLTemplateElement} Template found in dom module, or
     *   undefined if not found
     * @protected
     */
    function getTemplateFromDomModule(is) {
      let template = null;
      if (is && Polymer.DomModule) {
        template = Polymer.DomModule.import(is, 'template');
        // Under strictTemplatePolicy, require any element with an `is`
        // specified to have a dom-module
        if (Polymer.strictTemplatePolicy && !template) {
          throw new Error(`strictTemplatePolicy: expecting dom-module or null template for ${is}`);
        }
      }
      return template;
    }

  /**
     * @polymer
     * @mixinClass
     * @unrestricted
     * @implements {Polymer_ElementMixin}
     */
    class PolymerElement extends polymerElementBase {

      /**
       * Override of PropertiesMixin _finalizeClass to create observers and
       * find the template.
       * @return {void}
       * @protected
       * @override
       * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
       */
      static _finalizeClass() {
        super._finalizeClass();
        const observers = ownObservers(this);
        if (observers) {
          this.createObservers(observers, this._properties);
        }
        this._prepareTemplate();
      }

      static _prepareTemplate() {
        // note: create "working" template that is finalized at instance time
        let template = /** @type {PolymerElementConstructor} */ (this).template;
        if (template) {
          if (typeof template === 'string') {
            let t = document.createElement('template');
            t.innerHTML = template;
            template = t;
          } else if (!Polymer.legacyOptimizations) {
             template = template.cloneNode(true);
          }
        }

        this.prototype._template = template;
      }

      /**
       * Override of PropertiesChanged createProperties to create accessors
       * and property effects for all of the properties.
       * @return {void}
       * @protected
       * @override
       */
      static createProperties(props) {
        for (let p in props) {
          createPropertyFromConfig(this.prototype, p, props[p], props);
        }
      }

      /**
       * Creates observers for the given `observers` array.
       * Leverages `PropertyEffects` to create observers.
       * @param {Object} observers Array of observer descriptors for
       *   this class
       * @param {Object} dynamicFns Object containing keys for any properties
       *   that are functions and should trigger the effect when the function
       *   reference is changed
       * @return {void}
       * @protected
       */
      static createObservers(observers, dynamicFns) {
        const proto = this.prototype;
        for (let i=0; i < observers.length; i++) {
          proto._createMethodObserver(observers[i], dynamicFns);
        }
      }

      /**
       * Returns the template that will be stamped into this element's shadow root.
       *
       * If a `static get is()` getter is defined, the default implementation
       * will return the first `<template>` in a `dom-module` whose `id`
       * matches this element's `is`.
       *
       * Users may override this getter to return an arbitrary template
       * (in which case the `is` getter is unnecessary). The template returned
       * may be either an `HTMLTemplateElement` or a string that will be
       * automatically parsed into a template.
       *
       * Note that when subclassing, if the super class overrode the default
       * implementation and the subclass would like to provide an alternate
       * template via a `dom-module`, it should override this getter and
       * return `Polymer.DomModule.import(this.is, 'template')`.
       *
       * If a subclass would like to modify the super class template, it should
       * clone it rather than modify it in place.  If the getter does expensive
       * work such as cloning/modifying a template, it should memoize the
       * template for maximum performance:
       *
       *   let memoizedTemplate;
       *   class MySubClass extends MySuperClass {
       *     static get template() {
       *       if (!memoizedTemplate) {
       *         memoizedTemplate = MySuperClass.template.cloneNode(true);
       *         let subContent = document.createElement('div');
       *         subContent.textContent = 'This came from MySubClass';
       *         memoizedTemplate.content.appendChild(subContent);
       *       }
       *       return memoizedTemplate;
       *     }
       *   }
       *
       * @return {HTMLTemplateElement|string} Template to be stamped
       */
      static get template() {
        // Explanation of template-related properties:
        // - constructor.template (this getter): the template for the class.
        //     This can come from the prototype (for legacy elements), from a
        //     dom-module, or from the super class's template (or can be overridden
        //     altogether by the user)
        // - constructor._template: memoized version of constructor.template
        // - prototype._template: working template for the element, which will be
        //     parsed and modified in place. It is a cloned version of
        //     constructor.template, saved in _finalizeClass(). Note that before
        //     this getter is called, for legacy elements this could be from a
        //     _template field on the info object passed to Polymer(), a behavior,
        //     or set in registered(); once the static getter runs, a clone of it
        //     will overwrite it on the prototype as the working template.
        if (!this.hasOwnProperty(JSCompiler_renameProperty('_template', this))) {
          this._template =
            // If user has put template on prototype (e.g. in legacy via registered
            // callback or info object), prefer that first
            this.prototype.hasOwnProperty(JSCompiler_renameProperty('_template', this.prototype)) ?
            this.prototype._template :
            // Look in dom-module associated with this element's is
            (getTemplateFromDomModule(/** @type {PolymerElementConstructor}*/ (this).is) ||
            // Next look for superclass template (call the super impl this
            // way so that `this` points to the superclass)
            Object.getPrototypeOf(/** @type {PolymerElementConstructor}*/ (this).prototype).constructor.template);
        }
        return this._template;
      }

      /**
       * Set the template.
       *
       * @param {!HTMLTemplateElement|string} value Template to set.
       */
      static set template(value) {
        this._template = value;
      }

      /**
       * Path matching the url from which the element was imported.
       *
       * This path is used to resolve url's in template style cssText.
       * The `importPath` property is also set on element instances and can be
       * used to create bindings relative to the import path.
       *
       * For elements defined in ES modules, users should implement
       * `static get importMeta() { return import.meta; }`, and the default
       * implementation of `importPath` will  return `import.meta.url`'s path.
       * For elements defined in HTML imports, this getter will return the path
       * to the document containing a `dom-module` element matching this
       * element's static `is` property.
       *
       * Note, this path should contain a trailing `/`.
       *
       * @return {string} The import path for this element class
       * @suppress {missingProperties}
       */
      static get importPath() {
        if (!this.hasOwnProperty(JSCompiler_renameProperty('_importPath', this))) {
          const meta = this.importMeta;
          if (meta) {
            this._importPath = Polymer.ResolveUrl.pathFromUrl(meta.url);
          } else {
            const module = Polymer.DomModule && Polymer.DomModule.import(/** @type {PolymerElementConstructor} */ (this).is);
            this._importPath = (module && module.assetpath) ||
              Object.getPrototypeOf(/** @type {PolymerElementConstructor}*/ (this).prototype).constructor.importPath;
          }
        }
        return this._importPath;
      }

      constructor() {
        super();
        /** @type {HTMLTemplateElement} */
        this._template;
        /** @type {string} */
        this._importPath;
        /** @type {string} */
        this.rootPath;
        /** @type {string} */
        this.importPath;
        /** @type {StampedTemplate | HTMLElement | ShadowRoot} */
        this.root;
        /** @type {!Object<string, !Element>} */
        this.$;
      }

      /**
       * Overrides the default `Polymer.PropertyAccessors` to ensure class
       * metaprogramming related to property accessors and effects has
       * completed (calls `finalize`).
       *
       * It also initializes any property defaults provided via `value` in
       * `properties` metadata.
       *
       * @return {void}
       * @override
       * @suppress {invalidCasts}
       */
      _initializeProperties() {
        this.constructor.finalize();
        // note: finalize template when we have access to `localName` to
        // avoid dependence on `is` for polyfilling styling.
        this.constructor._finalizeTemplate(/** @type {!HTMLElement} */(this).localName);
        super._initializeProperties();
        // set path defaults
        this.rootPath = Polymer.rootPath;
        this.importPath = this.constructor.importPath;
        // apply property defaults...
        let p$ = propertyDefaults(this.constructor);
        if (!p$) {
          return;
        }
        for (let p in p$) {
          let info = p$[p];
          // Don't set default value if there is already an own property, which
          // happens when a `properties` property with default but no effects had
          // a property set (e.g. bound) by its host before upgrade
          if (!this.hasOwnProperty(p)) {
            let value = typeof info.value == 'function' ?
              info.value.call(this) :
              info.value;
            // Set via `_setProperty` if there is an accessor, to enable
            // initializing readOnly property defaults
            if (this._hasAccessor(p)) {
              this._setPendingProperty(p, value, true);
            } else {
              this[p] = value;
            }
          }
        }
      }

      /**
       * Gather style text for a style element in the template.
       *
       * @param {string} cssText Text containing styling to process
       * @param {string} baseURI Base URI to rebase CSS paths against
       * @return {string} The processed CSS text
       * @protected
       */
      static _processStyleText(cssText, baseURI) {
        return Polymer.ResolveUrl.resolveCss(cssText, baseURI);
      }

      /**
      * Configures an element `proto` to function with a given `template`.
      * The element name `is` and extends `ext` must be specified for ShadyCSS
      * style scoping.
      *
      * @param {string} is Tag name (or type extension name) for this element
      * @return {void}
      * @protected
      */
      static _finalizeTemplate(is) {
        /** @const {HTMLTemplateElement} */
        const template = this.prototype._template;
        if (template && !template.__polymerFinalized) {
          template.__polymerFinalized = true;
          const importPath = this.importPath;
          const baseURI = importPath ? Polymer.ResolveUrl.resolveUrl(importPath) : '';
          // e.g. support `include="module-name"`, and ShadyCSS
          processElementStyles(this, template, is, baseURI);
          this.prototype._bindTemplate(template);
        }
      }

      /**
       * Provides a default implementation of the standard Custom Elements
       * `connectedCallback`.
       *
       * The default implementation enables the property effects system and
       * flushes any pending properties, and updates shimmed CSS properties
       * when using the ShadyCSS scoping/custom properties polyfill.
       *
       * @suppress {missingProperties, invalidCasts} Super may or may not implement the callback
       * @return {void}
       */
      connectedCallback() {
        if (window.ShadyCSS && this._template) {
          window.ShadyCSS.styleElement(/** @type {!HTMLElement} */(this));
        }
        super.connectedCallback();
      }

      /**
       * Stamps the element template.
       *
       * @return {void}
       * @override
       */
      ready() {
        if (this._template) {
          this.root = this._stampTemplate(this._template);
          this.$ = this.root.$;
        }
        super.ready();
      }

      /**
       * Implements `PropertyEffects`'s `_readyClients` call. Attaches
       * element dom by calling `_attachDom` with the dom stamped from the
       * element's template via `_stampTemplate`. Note that this allows
       * client dom to be attached to the element prior to any observers
       * running.
       *
       * @return {void}
       * @override
       */
      _readyClients() {
        if (this._template) {
          this.root = this._attachDom(/** @type {StampedTemplate} */(this.root));
        }
        // The super._readyClients here sets the clients initialized flag.
        // We must wait to do this until after client dom is created/attached
        // so that this flag can be checked to prevent notifications fired
        // during this process from being handled before clients are ready.
        super._readyClients();
      }


      /**
       * Attaches an element's stamped dom to itself. By default,
       * this method creates a `shadowRoot` and adds the dom to it.
       * However, this method may be overridden to allow an element
       * to put its dom in another location.
       *
       * @throws {Error}
       * @suppress {missingReturn}
       * @param {StampedTemplate} dom to attach to the element.
       * @return {ShadowRoot} node to which the dom has been attached.
       */
      _attachDom(dom) {
        if (this.attachShadow) {
          if (dom) {
            if (!this.shadowRoot) {
              this.attachShadow({mode: 'open'});
            }
            this.shadowRoot.appendChild(dom);
            return this.shadowRoot;
          }
          return null;
        } else {
          throw new Error('ShadowDOM not available. ' +
            // TODO(sorvell): move to compile-time conditional when supported
          'Polymer.Element can create dom as children instead of in ' +
          'ShadowDOM by setting `this.root = this;\` before \`ready\`.');
        }
      }

      /**
       * When using the ShadyCSS scoping and custom property shim, causes all
       * shimmed styles in this element (and its subtree) to be updated
       * based on current custom property values.
       *
       * The optional parameter overrides inline custom property styles with an
       * object of properties where the keys are CSS properties, and the values
       * are strings.
       *
       * Example: `this.updateStyles({'--color': 'blue'})`
       *
       * These properties are retained unless a value of `null` is set.
       *
       * Note: This function does not support updating CSS mixins.
       * You can not dynamically change the value of an `@apply`.
       *
       * @param {Object=} properties Bag of custom property key/values to
       *   apply to this element.
       * @return {void}
       * @suppress {invalidCasts}
       */
      updateStyles(properties) {
        if (window.ShadyCSS) {
          window.ShadyCSS.styleSubtree(/** @type {!HTMLElement} */(this), properties);
        }
      }

      /**
       * Rewrites a given URL relative to a base URL. The base URL defaults to
       * the original location of the document containing the `dom-module` for
       * this element. This method will return the same URL before and after
       * bundling.
       *
       * Note that this function performs no resolution for URLs that start
       * with `/` (absolute URLs) or `#` (hash identifiers).  For general purpose
       * URL resolution, use `window.URL`.
       *
       * @param {string} url URL to resolve.
       * @param {string=} base Optional base URL to resolve against, defaults
       * to the element's `importPath`
       * @return {string} Rewritten URL relative to base
       */
      resolveUrl(url, base) {
        if (!base && this.importPath) {
          base = Polymer.ResolveUrl.resolveUrl(this.importPath);
        }
        return Polymer.ResolveUrl.resolveUrl(url, base);
      }

      /**
       * Overrides `PropertyAccessors` to add map of dynamic functions on
       * template info, for consumption by `PropertyEffects` template binding
       * code. This map determines which method templates should have accessors
       * created for them.
       *
       * @override
       * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
       */
      static _parseTemplateContent(template, templateInfo, nodeInfo) {
        templateInfo.dynamicFns = templateInfo.dynamicFns || this._properties;
        return super._parseTemplateContent(template, templateInfo, nodeInfo);
      }

    }

    return PolymerElement;
  });

  /**
   * When using the ShadyCSS scoping and custom property shim, causes all
   * shimmed `styles` (via `custom-style`) in the document (and its subtree)
   * to be updated based on current custom property values.
   *
   * The optional parameter overrides inline custom property styles with an
   * object of properties where the keys are CSS properties, and the values
   * are strings.
   *
   * Example: `Polymer.updateStyles({'--color': 'blue'})`
   *
   * These properties are retained unless a value of `null` is set.
   *
   * @param {Object=} props Bag of custom property key/values to
   *   apply to the document.
   * @return {void}
   */
  Polymer.updateStyles = function(props) {
    if (window.ShadyCSS) {
      window.ShadyCSS.styleDocument(props);
    }
  };

})();


(function() {
  'use strict';

  /**
   * @summary Collapse multiple callbacks into one invocation after a timer.
   * @memberof Polymer
   */
  class Debouncer {
    constructor() {
      this._asyncModule = null;
      this._callback = null;
      this._timer = null;
    }
    /**
     * Sets the scheduler; that is, a module with the Async interface,
     * a callback and optional arguments to be passed to the run function
     * from the async module.
     *
     * @param {!AsyncInterface} asyncModule Object with Async interface.
     * @param {function()} callback Callback to run.
     * @return {void}
     */
    setConfig(asyncModule, callback) {
      this._asyncModule = asyncModule;
      this._callback = callback;
      this._timer = this._asyncModule.run(() => {
        this._timer = null;
        this._callback();
      });
    }
    /**
     * Cancels an active debouncer and returns a reference to itself.
     *
     * @return {void}
     */
    cancel() {
      if (this.isActive()) {
        this._asyncModule.cancel(this._timer);
        this._timer = null;
      }
    }
    /**
     * Flushes an active debouncer and returns a reference to itself.
     *
     * @return {void}
     */
    flush() {
      if (this.isActive()) {
        this.cancel();
        this._callback();
      }
    }
    /**
     * Returns true if the debouncer is active.
     *
     * @return {boolean} True if active.
     */
    isActive() {
      return this._timer != null;
    }
    /**
     * Creates a debouncer if no debouncer is passed as a parameter
     * or it cancels an active debouncer otherwise. The following
     * example shows how a debouncer can be called multiple times within a
     * microtask and "debounced" such that the provided callback function is
     * called once. Add this method to a custom element:
     *
     * _debounceWork() {
     *   this._debounceJob = Polymer.Debouncer.debounce(this._debounceJob,
     *       Polymer.Async.microTask, () => {
     *     this._doWork();
     *   });
     * }
     *
     * If the `_debounceWork` method is called multiple times within the same
     * microtask, the `_doWork` function will be called only once at the next
     * microtask checkpoint.
     *
     * Note: In testing it is often convenient to avoid asynchrony. To accomplish
     * this with a debouncer, you can use `Polymer.enqueueDebouncer` and
     * `Polymer.flush`. For example, extend the above example by adding
     * `Polymer.enqueueDebouncer(this._debounceJob)` at the end of the
     * `_debounceWork` method. Then in a test, call `Polymer.flush` to ensure
     * the debouncer has completed.
     *
     * @param {Debouncer?} debouncer Debouncer object.
     * @param {!AsyncInterface} asyncModule Object with Async interface
     * @param {function()} callback Callback to run.
     * @return {!Debouncer} Returns a debouncer object.
     */
    static debounce(debouncer, asyncModule, callback) {
      if (debouncer instanceof Debouncer) {
        debouncer.cancel();
      } else {
        debouncer = new Debouncer();
      }
      debouncer.setConfig(asyncModule, callback);
      return debouncer;
    }
  }

  /** @const */
  Polymer.Debouncer = Debouncer;
})();


(function() {

  'use strict';

  // detect native touch action support
  let HAS_NATIVE_TA = typeof document.head.style.touchAction === 'string';
  let GESTURE_KEY = '__polymerGestures';
  let HANDLED_OBJ = '__polymerGesturesHandled';
  let TOUCH_ACTION = '__polymerGesturesTouchAction';
  // radius for tap and track
  let TAP_DISTANCE = 25;
  let TRACK_DISTANCE = 5;
  // number of last N track positions to keep
  let TRACK_LENGTH = 2;

  // Disabling "mouse" handlers for 2500ms is enough
  let MOUSE_TIMEOUT = 2500;
  let MOUSE_EVENTS = ['mousedown', 'mousemove', 'mouseup', 'click'];
  // an array of bitmask values for mapping MouseEvent.which to MouseEvent.buttons
  let MOUSE_WHICH_TO_BUTTONS = [0, 1, 4, 2];
  let MOUSE_HAS_BUTTONS = (function() {
    try {
      return new MouseEvent('test', {buttons: 1}).buttons === 1;
    } catch (e) {
      return false;
    }
  })();

  /**
   * @param {string} name Possible mouse event name
   * @return {boolean} true if mouse event, false if not
   */
  function isMouseEvent(name) {
    return MOUSE_EVENTS.indexOf(name) > -1;
  }

  /* eslint no-empty: ["error", { "allowEmptyCatch": true }] */
  // check for passive event listeners
  let SUPPORTS_PASSIVE = false;
  (function() {
    try {
      let opts = Object.defineProperty({}, 'passive', {get() {SUPPORTS_PASSIVE = true;}});
      window.addEventListener('test', null, opts);
      window.removeEventListener('test', null, opts);
    } catch(e) {}
  })();

  /**
   * Generate settings for event listeners, dependant on `Polymer.passiveTouchGestures`
   *
   * @param {string} eventName Event name to determine if `{passive}` option is needed
   * @return {{passive: boolean} | undefined} Options to use for addEventListener and removeEventListener
   */
  function PASSIVE_TOUCH(eventName) {
    if (isMouseEvent(eventName) || eventName === 'touchend') {
      return;
    }
    if (HAS_NATIVE_TA && SUPPORTS_PASSIVE && Polymer.passiveTouchGestures) {
      return {passive: true};
    } else {
      return;
    }
  }

  // Check for touch-only devices
  let IS_TOUCH_ONLY = navigator.userAgent.match(/iP(?:[oa]d|hone)|Android/);

  let GestureRecognizer = function(){}; // eslint-disable-line no-unused-vars
  /** @type {function(): void} */
  GestureRecognizer.prototype.reset;
  /** @type {function(MouseEvent): void | undefined} */
  GestureRecognizer.prototype.mousedown;
  /** @type {(function(MouseEvent): void | undefined)} */
  GestureRecognizer.prototype.mousemove;
  /** @type {(function(MouseEvent): void | undefined)} */
  GestureRecognizer.prototype.mouseup;
  /** @type {(function(TouchEvent): void | undefined)} */
  GestureRecognizer.prototype.touchstart;
  /** @type {(function(TouchEvent): void | undefined)} */
  GestureRecognizer.prototype.touchmove;
  /** @type {(function(TouchEvent): void | undefined)} */
  GestureRecognizer.prototype.touchend;
  /** @type {(function(MouseEvent): void | undefined)} */
  GestureRecognizer.prototype.click;

  // keep track of any labels hit by the mouseCanceller
  /** @type {!Array<!HTMLLabelElement>} */
  const clickedLabels = [];

  /** @type {!Object<boolean>} */
  const labellable = {
    'button': true,
    'input': true,
    'keygen': true,
    'meter': true,
    'output': true,
    'textarea': true,
    'progress': true,
    'select': true
  };

  // Defined at https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#enabling-and-disabling-form-controls:-the-disabled-attribute
  /** @type {!Object<boolean>} */
  const canBeDisabled = {
    'button': true,
    'command': true,
    'fieldset': true,
    'input': true,
    'keygen': true,
    'optgroup': true,
    'option': true,
    'select': true,
    'textarea': true
  };

  /**
   * @param {HTMLElement} el Element to check labelling status
   * @return {boolean} element can have labels
   */
  function canBeLabelled(el) {
    return labellable[el.localName] || false;
  }

  /**
   * @param {HTMLElement} el Element that may be labelled.
   * @return {!Array<!HTMLLabelElement>} Relevant label for `el`
   */
  function matchingLabels(el) {
    let labels = Array.from(/** @type {HTMLInputElement} */(el).labels || []);
    // IE doesn't have `labels` and Safari doesn't populate `labels`
    // if element is in a shadowroot.
    // In this instance, finding the non-ancestor labels is enough,
    // as the mouseCancellor code will handle ancstor labels
    if (!labels.length) {
      labels = [];
      let root = el.getRootNode();
      // if there is an id on `el`, check for all labels with a matching `for` attribute
      if (el.id) {
        let matching = root.querySelectorAll(`label[for = ${el.id}]`);
        for (let i = 0; i < matching.length; i++) {
          labels.push(/** @type {!HTMLLabelElement} */(matching[i]));
        }
      }
    }
    return labels;
  }

  // touch will make synthetic mouse events
  // `preventDefault` on touchend will cancel them,
  // but this breaks `<input>` focus and link clicks
  // disable mouse handlers for MOUSE_TIMEOUT ms after
  // a touchend to ignore synthetic mouse events
  let mouseCanceller = function(mouseEvent) {
    // Check for sourceCapabilities, used to distinguish synthetic events
    // if mouseEvent did not come from a device that fires touch events,
    // it was made by a real mouse and should be counted
    // http://wicg.github.io/InputDeviceCapabilities/#dom-inputdevicecapabilities-firestouchevents
    let sc = mouseEvent.sourceCapabilities;
    if (sc && !sc.firesTouchEvents) {
      return;
    }
    // skip synthetic mouse events
    mouseEvent[HANDLED_OBJ] = {skip: true};
    // disable "ghost clicks"
    if (mouseEvent.type === 'click') {
      let clickFromLabel = false;
      let path = mouseEvent.composedPath && mouseEvent.composedPath();
      if (path) {
        for (let i = 0; i < path.length; i++) {
          if (path[i].nodeType === Node.ELEMENT_NODE) {
            if (path[i].localName === 'label') {
              clickedLabels.push(path[i]);
            } else if (canBeLabelled(path[i])) {
              let ownerLabels = matchingLabels(path[i]);
              // check if one of the clicked labels is labelling this element
              for (let j = 0; j < ownerLabels.length; j++) {
                clickFromLabel = clickFromLabel || clickedLabels.indexOf(ownerLabels[j]) > -1;
              }
            }
          }
          if (path[i] === POINTERSTATE.mouse.target) {
            return;
          }
        }
      }
      // if one of the clicked labels was labelling the target element,
      // this is not a ghost click
      if (clickFromLabel) {
        return;
      }
      mouseEvent.preventDefault();
      mouseEvent.stopPropagation();
    }
  };

  /**
   * @param {boolean=} setup True to add, false to remove.
   * @return {void}
   */
  function setupTeardownMouseCanceller(setup) {
    let events = IS_TOUCH_ONLY ? ['click'] : MOUSE_EVENTS;
    for (let i = 0, en; i < events.length; i++) {
      en = events[i];
      if (setup) {
        // reset clickLabels array
        clickedLabels.length = 0;
        document.addEventListener(en, mouseCanceller, true);
      } else {
        document.removeEventListener(en, mouseCanceller, true);
      }
    }
  }

  function ignoreMouse(e) {
    if (!POINTERSTATE.mouse.mouseIgnoreJob) {
      setupTeardownMouseCanceller(true);
    }
    let unset = function() {
      setupTeardownMouseCanceller();
      POINTERSTATE.mouse.target = null;
      POINTERSTATE.mouse.mouseIgnoreJob = null;
    };
    POINTERSTATE.mouse.target = e.composedPath()[0];
    POINTERSTATE.mouse.mouseIgnoreJob = Polymer.Debouncer.debounce(
          POINTERSTATE.mouse.mouseIgnoreJob
        , Polymer.Async.timeOut.after(MOUSE_TIMEOUT)
        , unset);
  }

  /**
   * @param {MouseEvent} ev event to test for left mouse button down
   * @return {boolean} has left mouse button down
   */
  function hasLeftMouseButton(ev) {
    let type = ev.type;
    // exit early if the event is not a mouse event
    if (!isMouseEvent(type)) {
      return false;
    }
    // ev.button is not reliable for mousemove (0 is overloaded as both left button and no buttons)
    // instead we use ev.buttons (bitmask of buttons) or fall back to ev.which (deprecated, 0 for no buttons, 1 for left button)
    if (type === 'mousemove') {
      // allow undefined for testing events
      let buttons = ev.buttons === undefined ? 1 : ev.buttons;
      if ((ev instanceof window.MouseEvent) && !MOUSE_HAS_BUTTONS) {
        buttons = MOUSE_WHICH_TO_BUTTONS[ev.which] || 0;
      }
      // buttons is a bitmask, check that the left button bit is set (1)
      return Boolean(buttons & 1);
    } else {
      // allow undefined for testing events
      let button = ev.button === undefined ? 0 : ev.button;
      // ev.button is 0 in mousedown/mouseup/click for left button activation
      return button === 0;
    }
  }

  function isSyntheticClick(ev) {
    if (ev.type === 'click') {
      // ev.detail is 0 for HTMLElement.click in most browsers
      if (ev.detail === 0) {
        return true;
      }
      // in the worst case, check that the x/y position of the click is within
      // the bounding box of the target of the event
      // Thanks IE 10 >:(
      let t = Gestures._findOriginalTarget(ev);
      // make sure the target of the event is an element so we can use getBoundingClientRect,
      // if not, just assume it is a synthetic click
      if (!t.nodeType || /** @type {Element} */(t).nodeType !== Node.ELEMENT_NODE) {
        return true;
      }
      let bcr = /** @type {Element} */(t).getBoundingClientRect();
      // use page x/y to account for scrolling
      let x = ev.pageX, y = ev.pageY;
      // ev is a synthetic click if the position is outside the bounding box of the target
      return !((x >= bcr.left && x <= bcr.right) && (y >= bcr.top && y <= bcr.bottom));
    }
    return false;
  }

  let POINTERSTATE = {
    mouse: {
      target: null,
      mouseIgnoreJob: null
    },
    touch: {
      x: 0,
      y: 0,
      id: -1,
      scrollDecided: false
    }
  };

  function firstTouchAction(ev) {
    let ta = 'auto';
    let path = ev.composedPath && ev.composedPath();
    if (path) {
      for (let i = 0, n; i < path.length; i++) {
        n = path[i];
        if (n[TOUCH_ACTION]) {
          ta = n[TOUCH_ACTION];
          break;
        }
      }
    }
    return ta;
  }

  function trackDocument(stateObj, movefn, upfn) {
    stateObj.movefn = movefn;
    stateObj.upfn = upfn;
    document.addEventListener('mousemove', movefn);
    document.addEventListener('mouseup', upfn);
  }

  function untrackDocument(stateObj) {
    document.removeEventListener('mousemove', stateObj.movefn);
    document.removeEventListener('mouseup', stateObj.upfn);
    stateObj.movefn = null;
    stateObj.upfn = null;
  }

  // use a document-wide touchend listener to start the ghost-click prevention mechanism
  // Use passive event listeners, if supported, to not affect scrolling performance
  document.addEventListener('touchend', ignoreMouse, SUPPORTS_PASSIVE ? {passive: true} : false);

  /**
   * Module for adding listeners to a node for the following normalized
   * cross-platform "gesture" events:
   * - `down` - mouse or touch went down
   * - `up` - mouse or touch went up
   * - `tap` - mouse click or finger tap
   * - `track` - mouse drag or touch move
   *
   * @namespace
   * @memberof Polymer
   * @summary Module for adding cross-platform gesture event listeners.
   */
  const Gestures = {
    gestures: {},
    recognizers: [],

    /**
     * Finds the element rendered on the screen at the provided coordinates.
     *
     * Similar to `document.elementFromPoint`, but pierces through
     * shadow roots.
     *
     * @memberof Polymer.Gestures
     * @param {number} x Horizontal pixel coordinate
     * @param {number} y Vertical pixel coordinate
     * @return {Element} Returns the deepest shadowRoot inclusive element
     * found at the screen position given.
     */
    deepTargetFind: function(x, y) {
      let node = document.elementFromPoint(x, y);
      let next = node;
      // this code path is only taken when native ShadowDOM is used
      // if there is a shadowroot, it may have a node at x/y
      // if there is not a shadowroot, exit the loop
      while (next && next.shadowRoot && !window.ShadyDOM) {
        // if there is a node at x/y in the shadowroot, look deeper
        let oldNext = next;
        next = next.shadowRoot.elementFromPoint(x, y);
        // on Safari, elementFromPoint may return the shadowRoot host
        if (oldNext === next) {
          break;
        }
        if (next) {
          node = next;
        }
      }
      return node;
    },
    /**
     * a cheaper check than ev.composedPath()[0];
     *
     * @private
     * @param {Event} ev Event.
     * @return {EventTarget} Returns the event target.
     */
    _findOriginalTarget: function(ev) {
      // shadowdom
      if (ev.composedPath) {
        const targets = /** @type {!Array<!EventTarget>} */(ev.composedPath());
        // It shouldn't be, but sometimes targets is empty (window on Safari).
        return targets.length > 0 ? targets[0] : ev.target;
      }
      // shadydom
      return ev.target;
    },

    /**
     * @private
     * @param {Event} ev Event.
     * @return {void}
     */
    _handleNative: function(ev) {
      let handled;
      let type = ev.type;
      let node = ev.currentTarget;
      let gobj = node[GESTURE_KEY];
      if (!gobj) {
        return;
      }
      let gs = gobj[type];
      if (!gs) {
        return;
      }
      if (!ev[HANDLED_OBJ]) {
        ev[HANDLED_OBJ] = {};
        if (type.slice(0, 5) === 'touch') {
          ev = /** @type {TouchEvent} */(ev); // eslint-disable-line no-self-assign
          let t = ev.changedTouches[0];
          if (type === 'touchstart') {
            // only handle the first finger
            if (ev.touches.length === 1) {
              POINTERSTATE.touch.id = t.identifier;
            }
          }
          if (POINTERSTATE.touch.id !== t.identifier) {
            return;
          }
          if (!HAS_NATIVE_TA) {
            if (type === 'touchstart' || type === 'touchmove') {
              Gestures._handleTouchAction(ev);
            }
          }
        }
      }
      handled = ev[HANDLED_OBJ];
      // used to ignore synthetic mouse events
      if (handled.skip) {
        return;
      }
      // reset recognizer state
      for (let i = 0, r; i < Gestures.recognizers.length; i++) {
        r = Gestures.recognizers[i];
        if (gs[r.name] && !handled[r.name]) {
          if (r.flow && r.flow.start.indexOf(ev.type) > -1 && r.reset) {
            r.reset();
          }
        }
      }
      // enforce gesture recognizer order
      for (let i = 0, r; i < Gestures.recognizers.length; i++) {
        r = Gestures.recognizers[i];
        if (gs[r.name] && !handled[r.name]) {
          handled[r.name] = true;
          r[type](ev);
        }
      }
    },

    /**
     * @private
     * @param {TouchEvent} ev Event.
     * @return {void}
     */
    _handleTouchAction: function(ev) {
      let t = ev.changedTouches[0];
      let type = ev.type;
      if (type === 'touchstart') {
        POINTERSTATE.touch.x = t.clientX;
        POINTERSTATE.touch.y = t.clientY;
        POINTERSTATE.touch.scrollDecided = false;
      } else if (type === 'touchmove') {
        if (POINTERSTATE.touch.scrollDecided) {
          return;
        }
        POINTERSTATE.touch.scrollDecided = true;
        let ta = firstTouchAction(ev);
        let prevent = false;
        let dx = Math.abs(POINTERSTATE.touch.x - t.clientX);
        let dy = Math.abs(POINTERSTATE.touch.y - t.clientY);
        if (!ev.cancelable) {
          // scrolling is happening
        } else if (ta === 'none') {
          prevent = true;
        } else if (ta === 'pan-x') {
          prevent = dy > dx;
        } else if (ta === 'pan-y') {
          prevent = dx > dy;
        }
        if (prevent) {
          ev.preventDefault();
        } else {
          Gestures.prevent('track');
        }
      }
    },

    /**
     * Adds an event listener to a node for the given gesture type.
     *
     * @memberof Polymer.Gestures
     * @param {!Node} node Node to add listener on
     * @param {string} evType Gesture type: `down`, `up`, `track`, or `tap`
     * @param {!function(!Event):void} handler Event listener function to call
     * @return {boolean} Returns true if a gesture event listener was added.
     * @this {Gestures}
     */
    addListener: function(node, evType, handler) {
      if (this.gestures[evType]) {
        this._add(node, evType, handler);
        return true;
      }
      return false;
    },

    /**
     * Removes an event listener from a node for the given gesture type.
     *
     * @memberof Polymer.Gestures
     * @param {!Node} node Node to remove listener from
     * @param {string} evType Gesture type: `down`, `up`, `track`, or `tap`
     * @param {!function(!Event):void} handler Event listener function previously passed to
     *  `addListener`.
     * @return {boolean} Returns true if a gesture event listener was removed.
     * @this {Gestures}
     */
    removeListener: function(node, evType, handler) {
      if (this.gestures[evType]) {
        this._remove(node, evType, handler);
        return true;
      }
      return false;
    },

    /**
     * automate the event listeners for the native events
     *
     * @private
     * @param {!HTMLElement} node Node on which to add the event.
     * @param {string} evType Event type to add.
     * @param {function(!Event)} handler Event handler function.
     * @return {void}
     * @this {Gestures}
     */
    _add: function(node, evType, handler) {
      let recognizer = this.gestures[evType];
      let deps = recognizer.deps;
      let name = recognizer.name;
      let gobj = node[GESTURE_KEY];
      if (!gobj) {
        node[GESTURE_KEY] = gobj = {};
      }
      for (let i = 0, dep, gd; i < deps.length; i++) {
        dep = deps[i];
        // don't add mouse handlers on iOS because they cause gray selection overlays
        if (IS_TOUCH_ONLY && isMouseEvent(dep) && dep !== 'click') {
          continue;
        }
        gd = gobj[dep];
        if (!gd) {
          gobj[dep] = gd = {_count: 0};
        }
        if (gd._count === 0) {
          node.addEventListener(dep, this._handleNative, PASSIVE_TOUCH(dep));
        }
        gd[name] = (gd[name] || 0) + 1;
        gd._count = (gd._count || 0) + 1;
      }
      node.addEventListener(evType, handler);
      if (recognizer.touchAction) {
        this.setTouchAction(node, recognizer.touchAction);
      }
    },

    /**
     * automate event listener removal for native events
     *
     * @private
     * @param {!HTMLElement} node Node on which to remove the event.
     * @param {string} evType Event type to remove.
     * @param {function(Event?)} handler Event handler function.
     * @return {void}
     * @this {Gestures}
     */
    _remove: function(node, evType, handler) {
      let recognizer = this.gestures[evType];
      let deps = recognizer.deps;
      let name = recognizer.name;
      let gobj = node[GESTURE_KEY];
      if (gobj) {
        for (let i = 0, dep, gd; i < deps.length; i++) {
          dep = deps[i];
          gd = gobj[dep];
          if (gd && gd[name]) {
            gd[name] = (gd[name] || 1) - 1;
            gd._count = (gd._count || 1) - 1;
            if (gd._count === 0) {
              node.removeEventListener(dep, this._handleNative, PASSIVE_TOUCH(dep));
            }
          }
        }
      }
      node.removeEventListener(evType, handler);
    },

    /**
     * Registers a new gesture event recognizer for adding new custom
     * gesture event types.
     *
     * @memberof Polymer.Gestures
     * @param {!GestureRecognizer} recog Gesture recognizer descriptor
     * @return {void}
     * @this {Gestures}
     */
    register: function(recog) {
      this.recognizers.push(recog);
      for (let i = 0; i < recog.emits.length; i++) {
        this.gestures[recog.emits[i]] = recog;
      }
    },

    /**
     * @private
     * @param {string} evName Event name.
     * @return {Object} Returns the gesture for the given event name.
     * @this {Gestures}
     */
    _findRecognizerByEvent: function(evName) {
      for (let i = 0, r; i < this.recognizers.length; i++) {
        r = this.recognizers[i];
        for (let j = 0, n; j < r.emits.length; j++) {
          n = r.emits[j];
          if (n === evName) {
            return r;
          }
        }
      }
      return null;
    },

    /**
     * Sets scrolling direction on node.
     *
     * This value is checked on first move, thus it should be called prior to
     * adding event listeners.
     *
     * @memberof Polymer.Gestures
     * @param {!Element} node Node to set touch action setting on
     * @param {string} value Touch action value
     * @return {void}
     */
    setTouchAction: function(node, value) {
      if (HAS_NATIVE_TA) {
        // NOTE: add touchAction async so that events can be added in
        // custom element constructors. Otherwise we run afoul of custom
        // elements restriction against settings attributes (style) in the
        // constructor.
        Polymer.Async.microTask.run(() => {
          node.style.touchAction = value;
        });
      }
      node[TOUCH_ACTION] = value;
    },

    /**
     * Dispatches an event on the `target` element of `type` with the given
     * `detail`.
     * @private
     * @param {!EventTarget} target The element on which to fire an event.
     * @param {string} type The type of event to fire.
     * @param {!Object=} detail The detail object to populate on the event.
     * @return {void}
     */
    _fire: function(target, type, detail) {
      let ev = new Event(type, { bubbles: true, cancelable: true, composed: true });
      ev.detail = detail;
      target.dispatchEvent(ev);
      // forward `preventDefault` in a clean way
      if (ev.defaultPrevented) {
        let preventer = detail.preventer || detail.sourceEvent;
        if (preventer && preventer.preventDefault) {
          preventer.preventDefault();
        }
      }
    },

    /**
     * Prevents the dispatch and default action of the given event name.
     *
     * @memberof Polymer.Gestures
     * @param {string} evName Event name.
     * @return {void}
     * @this {Gestures}
     */
    prevent: function(evName) {
      let recognizer = this._findRecognizerByEvent(evName);
      if (recognizer.info) {
        recognizer.info.prevent = true;
      }
    },

    /**
     * Reset the 2500ms timeout on processing mouse input after detecting touch input.
     *
     * Touch inputs create synthesized mouse inputs anywhere from 0 to 2000ms after the touch.
     * This method should only be called during testing with simulated touch inputs.
     * Calling this method in production may cause duplicate taps or other Gestures.
     *
     * @memberof Polymer.Gestures
     * @return {void}
     */
    resetMouseCanceller: function() {
      if (POINTERSTATE.mouse.mouseIgnoreJob) {
        POINTERSTATE.mouse.mouseIgnoreJob.flush();
      }
    }
  };

  /* eslint-disable valid-jsdoc */

  Gestures.register({
    name: 'downup',
    deps: ['mousedown', 'touchstart', 'touchend'],
    flow: {
      start: ['mousedown', 'touchstart'],
      end: ['mouseup', 'touchend']
    },
    emits: ['down', 'up'],

    info: {
      movefn: null,
      upfn: null
    },

    /**
     * @this {GestureRecognizer}
     * @return {void}
     */
    reset: function() {
      untrackDocument(this.info);
    },

    /**
     * @this {GestureRecognizer}
     * @param {MouseEvent} e
     * @return {void}
     */
    mousedown: function(e) {
      if (!hasLeftMouseButton(e)) {
        return;
      }
      let t = Gestures._findOriginalTarget(e);
      let self = this;
      let movefn = function movefn(e) {
        if (!hasLeftMouseButton(e)) {
          self._fire('up', t, e);
          untrackDocument(self.info);
        }
      };
      let upfn = function upfn(e) {
        if (hasLeftMouseButton(e)) {
          self._fire('up', t, e);
        }
        untrackDocument(self.info);
      };
      trackDocument(this.info, movefn, upfn);
      this._fire('down', t, e);
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchstart: function(e) {
      this._fire('down', Gestures._findOriginalTarget(e), e.changedTouches[0], e);
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchend: function(e) {
      this._fire('up', Gestures._findOriginalTarget(e), e.changedTouches[0], e);
    },
    /**
     * @param {string} type
     * @param {!EventTarget} target
     * @param {Event} event
     * @param {Function} preventer
     * @return {void}
     */
    _fire: function(type, target, event, preventer) {
      Gestures._fire(target, type, {
        x: event.clientX,
        y: event.clientY,
        sourceEvent: event,
        preventer: preventer,
        prevent: function(e) {
          return Gestures.prevent(e);
        }
      });
    }
  });

  Gestures.register({
    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: false,
      moves: [],
      /** @this {GestureRecognizer} */
      addMove: function(move) {
        if (this.moves.length > TRACK_LENGTH) {
          this.moves.shift();
        }
        this.moves.push(move);
      },
      movefn: null,
      upfn: null,
      prevent: false
    },

    /**
     * @this {GestureRecognizer}
     * @return {void}
     */
    reset: function() {
      this.info.state = 'start';
      this.info.started = false;
      this.info.moves = [];
      this.info.x = 0;
      this.info.y = 0;
      this.info.prevent = false;
      untrackDocument(this.info);
    },

    /**
     * @this {GestureRecognizer}
     * @param {number} x
     * @param {number} y
     * @return {boolean}
     */
    hasMovedEnough: function(x, y) {
      if (this.info.prevent) {
        return false;
      }
      if (this.info.started) {
        return true;
      }
      let dx = Math.abs(this.info.x - x);
      let dy = Math.abs(this.info.y - y);
      return (dx >= TRACK_DISTANCE || dy >= TRACK_DISTANCE);
    },
    /**
     * @this {GestureRecognizer}
     * @param {MouseEvent} e
     * @return {void}
     */
    mousedown: function(e) {
      if (!hasLeftMouseButton(e)) {
        return;
      }
      let t = Gestures._findOriginalTarget(e);
      let self = this;
      let movefn = function movefn(e) {
        let x = e.clientX, y = e.clientY;
        if (self.hasMovedEnough(x, y)) {
          // first move is 'start', subsequent moves are 'move', mouseup is 'end'
          self.info.state = self.info.started ? (e.type === 'mouseup' ? 'end' : 'track') : 'start';
          if (self.info.state === 'start') {
            // if and only if tracking, always prevent tap
            Gestures.prevent('tap');
          }
          self.info.addMove({x: x, y: y});
          if (!hasLeftMouseButton(e)) {
            // always _fire "end"
            self.info.state = 'end';
            untrackDocument(self.info);
          }
          self._fire(t, e);
          self.info.started = true;
        }
      };
      let upfn = function upfn(e) {
        if (self.info.started) {
          movefn(e);
        }

        // remove the temporary listeners
        untrackDocument(self.info);
      };
      // add temporary document listeners as mouse retargets
      trackDocument(this.info, movefn, upfn);
      this.info.x = e.clientX;
      this.info.y = e.clientY;
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchstart: function(e) {
      let ct = e.changedTouches[0];
      this.info.x = ct.clientX;
      this.info.y = ct.clientY;
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchmove: function(e) {
      let t = Gestures._findOriginalTarget(e);
      let ct = e.changedTouches[0];
      let x = ct.clientX, y = ct.clientY;
      if (this.hasMovedEnough(x, y)) {
        if (this.info.state === 'start') {
          // if and only if tracking, always prevent tap
          Gestures.prevent('tap');
        }
        this.info.addMove({x: x, y: y});
        this._fire(t, ct);
        this.info.state = 'track';
        this.info.started = true;
      }
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchend: function(e) {
      let t = Gestures._findOriginalTarget(e);
      let ct = e.changedTouches[0];
      // only trackend if track was started and not aborted
      if (this.info.started) {
        // reset started state on up
        this.info.state = 'end';
        this.info.addMove({x: ct.clientX, y: ct.clientY});
        this._fire(t, ct, e);
      }
    },

    /**
     * @this {GestureRecognizer}
     * @param {!EventTarget} target
     * @param {Touch} touch
     * @return {void}
     */
    _fire: function(target, touch) {
      let secondlast = this.info.moves[this.info.moves.length - 2];
      let lastmove = this.info.moves[this.info.moves.length - 1];
      let dx = lastmove.x - this.info.x;
      let dy = lastmove.y - this.info.y;
      let ddx, ddy = 0;
      if (secondlast) {
        ddx = lastmove.x - secondlast.x;
        ddy = lastmove.y - secondlast.y;
      }
      Gestures._fire(target, 'track', {
        state: this.info.state,
        x: touch.clientX,
        y: touch.clientY,
        dx: dx,
        dy: dy,
        ddx: ddx,
        ddy: ddy,
        sourceEvent: touch,
        hover: function() {
          return Gestures.deepTargetFind(touch.clientX, touch.clientY);
        }
      });
    }

  });

  Gestures.register({
    name: 'tap',
    deps: ['mousedown', 'click', 'touchstart', 'touchend'],
    flow: {
      start: ['mousedown', 'touchstart'],
      end: ['click', 'touchend']
    },
    emits: ['tap'],
    info: {
      x: NaN,
      y: NaN,
      prevent: false
    },
    /**
     * @this {GestureRecognizer}
     * @return {void}
     */
    reset: function() {
      this.info.x = NaN;
      this.info.y = NaN;
      this.info.prevent = false;
    },
    /**
     * @this {GestureRecognizer}
     * @param {MouseEvent} e
     * @return {void}
     */
    save: function(e) {
      this.info.x = e.clientX;
      this.info.y = e.clientY;
    },
    /**
     * @this {GestureRecognizer}
     * @param {MouseEvent} e
     * @return {void}
     */
    mousedown: function(e) {
      if (hasLeftMouseButton(e)) {
        this.save(e);
      }
    },
    /**
     * @this {GestureRecognizer}
     * @param {MouseEvent} e
     * @return {void}
     */
    click: function(e) {
      if (hasLeftMouseButton(e)) {
        this.forward(e);
      }
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchstart: function(e) {
      this.save(e.changedTouches[0], e);
    },
    /**
     * @this {GestureRecognizer}
     * @param {TouchEvent} e
     * @return {void}
     */
    touchend: function(e) {
      this.forward(e.changedTouches[0], e);
    },
    /**
     * @this {GestureRecognizer}
     * @param {Event | Touch} e
     * @param {Event=} preventer
     * @return {void}
     */
    forward: function(e, preventer) {
      let dx = Math.abs(e.clientX - this.info.x);
      let dy = Math.abs(e.clientY - this.info.y);
      // find original target from `preventer` for TouchEvents, or `e` for MouseEvents
      let t = Gestures._findOriginalTarget(/** @type {Event} */(preventer || e));
      if (!t || (canBeDisabled[/** @type {!HTMLElement} */(t).localName] && t.hasAttribute('disabled'))) {
        return;
      }
      // dx,dy can be NaN if `click` has been simulated and there was no `down` for `start`
      if (isNaN(dx) || isNaN(dy) || (dx <= TAP_DISTANCE && dy <= TAP_DISTANCE) || isSyntheticClick(e)) {
        // prevent taps from being generated if an event has canceled them
        if (!this.info.prevent) {
          Gestures._fire(t, 'tap', {
            x: e.clientX,
            y: e.clientY,
            sourceEvent: e,
            preventer: preventer
          });
        }
      }
    }
  });

  /* eslint-enable valid-jsdoc */

  /** @deprecated */
  Gestures.findOriginalTarget = Gestures._findOriginalTarget;

  /** @deprecated */
  Gestures.add = Gestures.addListener;

  /** @deprecated */
  Gestures.remove = Gestures.removeListener;

  Polymer.Gestures = Gestures;

})();


(function() {

  'use strict';

  /**
   * @const {Polymer.Gestures}
   */
  const gestures = Polymer.Gestures;

  /**
   * Element class mixin that provides API for adding Polymer's cross-platform
   * gesture events to nodes.
   *
   * The API is designed to be compatible with override points implemented
   * in `Polymer.TemplateStamp` such that declarative event listeners in
   * templates will support gesture events when this mixin is applied along with
   * `Polymer.TemplateStamp`.
   *
   * @mixinFunction
   * @polymer
   * @memberof Polymer
   * @summary Element class mixin that provides API for adding Polymer's cross-platform
   * gesture events to nodes
   */
  Polymer.GestureEventListeners = Polymer.dedupingMixin(superClass => {

    /**
     * @polymer
     * @mixinClass
     * @implements {Polymer_GestureEventListeners}
     */
    class GestureEventListeners extends superClass {

      /**
       * Add the event listener to the node if it is a gestures event.
       *
       * @param {!Node} node Node to add event listener to
       * @param {string} eventName Name of event
       * @param {function(!Event):void} handler Listener function to add
       * @return {void}
       */
      _addEventListenerToNode(node, eventName, handler) {
        if (!gestures.addListener(node, eventName, handler)) {
          super._addEventListenerToNode(node, eventName, handler);
        }
      }

      /**
       * Remove the event listener to the node if it is a gestures event.
       *
       * @param {!Node} node Node to remove event listener from
       * @param {string} eventName Name of event
       * @param {function(!Event):void} handler Listener function to remove
       * @return {void}
       */
      _removeEventListenerFromNode(node, eventName, handler) {
        if (!gestures.removeListener(node, eventName, handler)) {
          super._removeEventListenerFromNode(node, eventName, handler);
        }
      }

    }

    return GestureEventListeners;

  });

})();


  (function() {
    'use strict';

    const HOST_DIR = /:host\(:dir\((ltr|rtl)\)\)/g;
    const HOST_DIR_REPLACMENT = ':host([dir="$1"])';

    const EL_DIR = /([\s\w-#\.\[\]\*]*):dir\((ltr|rtl)\)/g;
    const EL_DIR_REPLACMENT = ':host([dir="$2"]) $1';

    const DIR_CHECK = /:dir\((?:ltr|rtl)\)/;
    
    const SHIM_SHADOW = Boolean(window['ShadyDOM'] && window['ShadyDOM']['inUse']);

    /**
     * @type {!Array<!Polymer_DirMixin>}
     */
    const DIR_INSTANCES = [];

    /** @type {MutationObserver} */
    let observer = null;

    let DOCUMENT_DIR = '';

    function getRTL() {
      DOCUMENT_DIR = document.documentElement.getAttribute('dir');
    }

    /**
     * @param {!Polymer_DirMixin} instance Instance to set RTL status on
     */
    function setRTL(instance) {
      if (!instance.__autoDirOptOut) {
        const el = /** @type {!HTMLElement} */(instance);
        el.setAttribute('dir', DOCUMENT_DIR);
      }
    }

    function updateDirection() {
      getRTL();
      DOCUMENT_DIR = document.documentElement.getAttribute('dir');
      for (let i = 0; i < DIR_INSTANCES.length; i++) {
        setRTL(DIR_INSTANCES[i]);
      }
    }

    function takeRecords() {
      if (observer && observer.takeRecords().length) {
        updateDirection();
      }
    }

    /**
     * Element class mixin that allows elements to use the `:dir` CSS Selector to have
     * text direction specific styling.
     *
     * With this mixin, any stylesheet provided in the template will transform `:dir` into
     * `:host([dir])` and sync direction with the page via the element's `dir` attribute.
     *
     * Elements can opt out of the global page text direction by setting the `dir` attribute
     * directly in `ready()` or in HTML.
     *
     * Caveats:
     * - Applications must set `<html dir="ltr">` or `<html dir="rtl">` to sync direction
     * - Automatic left-to-right or right-to-left styling is sync'd with the `<html>` element only.
     * - Changing `dir` at runtime is supported.
     * - Opting out of the global direction styling is permanent
     *
     * @mixinFunction
     * @polymer
     * @appliesMixin Polymer.PropertyAccessors
     * @memberof Polymer
     */
    Polymer.DirMixin = Polymer.dedupingMixin((base) => {

      if (!SHIM_SHADOW) {
        if (!observer) {
          getRTL();
          observer = new MutationObserver(updateDirection);
          observer.observe(document.documentElement, {attributes: true, attributeFilter: ['dir']});
        }
      }

      /**
       * @constructor
       * @extends {base}
       * @implements {Polymer_PropertyAccessors}
       * @private
       */
      const elementBase = Polymer.PropertyAccessors(base);

      /**
       * @polymer
       * @mixinClass
       * @implements {Polymer_DirMixin}
       */
      class Dir extends elementBase {

        /**
         * @override
         * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
         */
        static _processStyleText(cssText, baseURI) {
          cssText = super._processStyleText(cssText, baseURI);
          if (!SHIM_SHADOW && DIR_CHECK.test(cssText)) {
            cssText = this._replaceDirInCssText(cssText);
            this.__activateDir = true;
          }
          return cssText;
        }

        /**
         * Replace `:dir` in the given CSS text
         *
         * @param {string} text CSS text to replace DIR
         * @return {string} Modified CSS
         */
        static _replaceDirInCssText(text) {
          let replacedText = text;
          replacedText = replacedText.replace(HOST_DIR, HOST_DIR_REPLACMENT);
          replacedText = replacedText.replace(EL_DIR, EL_DIR_REPLACMENT);
          return replacedText;
        }

        constructor() {
          super();
          /** @type {boolean} */
          this.__autoDirOptOut = false;
        }

        /**
         * @suppress {invalidCasts} Closure doesn't understand that `this` is an HTMLElement
         * @return {void}
         */
        ready() {
          super.ready();
          this.__autoDirOptOut = /** @type {!HTMLElement} */(this).hasAttribute('dir');
        }

        /**
         * @suppress {missingProperties} If it exists on elementBase, it can be super'd
         * @return {void}
         */
        connectedCallback() {
          if (elementBase.prototype.connectedCallback) {
            super.connectedCallback();
          }
          if (this.constructor.__activateDir) {
            takeRecords();
            DIR_INSTANCES.push(this);
            setRTL(this);
          }
        }

        /**
         * @suppress {missingProperties} If it exists on elementBase, it can be super'd
         * @return {void}
         */
        disconnectedCallback() {
          if (elementBase.prototype.disconnectedCallback) {
            super.disconnectedCallback();
          }
          if (this.constructor.__activateDir) {
            const idx = DIR_INSTANCES.indexOf(this);
            if (idx > -1) {
              DIR_INSTANCES.splice(idx, 1);
            }
          }
        }
      }

      Dir.__activateDir = false;

      return Dir;
    });
  })();



(function() {

  'use strict';

  // run a callback when HTMLImports are ready or immediately if
  // this api is not available.
  function whenImportsReady(cb) {
    if (window.HTMLImports) {
      HTMLImports.whenReady(cb);
    } else {
      cb();
    }
  }

  /**
   * Convenience method for importing an HTML document imperatively.
   *
   * This method creates a new `<link rel="import">` element with
   * the provided URL and appends it to the document to start loading.
   * In the `onload` callback, the `import` property of the `link`
   * element will contain the imported document contents.
   *
   * @memberof Polymer
   * @param {string} href URL to document to load.
   * @param {?function(!Event):void=} onload Callback to notify when an import successfully
   *   loaded.
   * @param {?function(!ErrorEvent):void=} onerror Callback to notify when an import
   *   unsuccessfully loaded.
   * @param {boolean=} optAsync True if the import should be loaded `async`.
   *   Defaults to `false`.
   * @return {!HTMLLinkElement} The link element for the URL to be loaded.
   */
  Polymer.importHref = function(href, onload, onerror, optAsync) {
    let link = /** @type {HTMLLinkElement} */
      (document.head.querySelector('link[href="' + href + '"][import-href]'));
    if (!link) {
      link = /** @type {HTMLLinkElement} */ (document.createElement('link'));
      link.rel = 'import';
      link.href = href;
      link.setAttribute('import-href', '');
    }
    // always ensure link has `async` attribute if user specified one,
    // even if it was previously not async. This is considered less confusing.
    if (optAsync) {
      link.setAttribute('async', '');
    }
    // NOTE: the link may now be in 3 states: (1) pending insertion,
    // (2) inflight, (3) already loaded. In each case, we need to add
    // event listeners to process callbacks.
    let cleanup = function() {
      link.removeEventListener('load', loadListener);
      link.removeEventListener('error', errorListener);
    };
    let loadListener = function(event) {
      cleanup();
      // In case of a successful load, cache the load event on the link so
      // that it can be used to short-circuit this method in the future when
      // it is called with the same href param.
      link.__dynamicImportLoaded = true;
      if (onload) {
        whenImportsReady(() => {
          onload(event);
        });
      }
    };
    let errorListener = function(event) {
      cleanup();
      // In case of an error, remove the link from the document so that it
      // will be automatically created again the next time `importHref` is
      // called.
      if (link.parentNode) {
        link.parentNode.removeChild(link);
      }
      if (onerror) {
        whenImportsReady(() => {
          onerror(event);
        });
      }
    };
    link.addEventListener('load', loadListener);
    link.addEventListener('error', errorListener);
    if (link.parentNode == null) {
      document.head.appendChild(link);
    // if the link already loaded, dispatch a fake load event
    // so that listeners are called and get a proper event argument.
    } else if (link.__dynamicImportLoaded) {
      link.dispatchEvent(new Event('load'));
    }
    return link;
  };

})();


(function() {

  'use strict';

  let scheduled = false;
  let beforeRenderQueue = [];
  let afterRenderQueue = [];

  function schedule() {
    scheduled = true;
    // before next render
    requestAnimationFrame(function() {
      scheduled = false;
      flushQueue(beforeRenderQueue);
      // after the render
      setTimeout(function() {
        runQueue(afterRenderQueue);
      });
    });
  }

  function flushQueue(queue) {
    while (queue.length) {
      callMethod(queue.shift());
    }
  }

  function runQueue(queue) {
    for (let i=0, l=queue.length; i < l; i++) {
      callMethod(queue.shift());
    }
  }

  function callMethod(info) {
    const context = info[0];
    const callback = info[1];
    const args = info[2];
    try {
      callback.apply(context, args);
    } catch(e) {
      setTimeout(() => {
        throw e;
      });
    }
  }

  function flush() {
    while (beforeRenderQueue.length || afterRenderQueue.length) {
      flushQueue(beforeRenderQueue);
      flushQueue(afterRenderQueue);
    }
    scheduled = false;
  }

  /**
   * Module for scheduling flushable pre-render and post-render tasks.
   *
   * @namespace
   * @memberof Polymer
   * @summary Module for scheduling flushable pre-render and post-render tasks.
   */
  Polymer.RenderStatus = {

    /**
     * Enqueues a callback which will be run before the next render, at
     * `requestAnimationFrame` timing.
     *
     * This method is useful for enqueuing work that requires DOM measurement,
     * since measurement may not be reliable in custom element callbacks before
     * the first render, as well as for batching measurement tasks in general.
     *
     * Tasks in this queue may be flushed by calling `Polymer.RenderStatus.flush()`.
     *
     * @memberof Polymer.RenderStatus
     * @param {*} context Context object the callback function will be bound to
     * @param {function(...*):void} callback Callback function
     * @param {!Array=} args An array of arguments to call the callback function with
     * @return {void}
     */
    beforeNextRender: function(context, callback, args) {
      if (!scheduled) {
        schedule();
      }
      beforeRenderQueue.push([context, callback, args]);
    },

    /**
     * Enqueues a callback which will be run after the next render, equivalent
     * to one task (`setTimeout`) after the next `requestAnimationFrame`.
     *
     * This method is useful for tuning the first-render performance of an
     * element or application by deferring non-critical work until after the
     * first paint.  Typical non-render-critical work may include adding UI
     * event listeners and aria attributes.
     *
     * @memberof Polymer.RenderStatus
     * @param {*} context Context object the callback function will be bound to
     * @param {function(...*):void} callback Callback function
     * @param {!Array=} args An array of arguments to call the callback function with
     * @return {void}
     */
    afterNextRender: function(context, callback, args) {
      if (!scheduled) {
        schedule();
      }
      afterRenderQueue.push([context, callback, args]);
    },

    /**
     * Flushes all `beforeNextRender` tasks, followed by all `afterNextRender`
     * tasks.
     *
     * @memberof Polymer.RenderStatus
     * @return {void}
     */
    flush: flush

  };

})();


(function() {
  'use strict';

  // unresolved

  function resolve() {
    document.body.removeAttribute('unresolved');
  }

  if (window.WebComponents) {
    window.addEventListener('WebComponentsReady', resolve);
  } else {
    if (document.readyState === 'interactive' || document.readyState === 'complete') {
      resolve();
    } else {
      window.addEventListener('DOMContentLoaded', resolve);
    }
  }

})();


(function() {

  'use strict';

  function newSplice(index, removed, addedCount) {
    return {
      index: index,
      removed: removed,
      addedCount: addedCount
    };
  }

  const EDIT_LEAVE = 0;
  const EDIT_UPDATE = 1;
  const EDIT_ADD = 2;
  const EDIT_DELETE = 3;

  // Note: This function is *based* on the computation of the Levenshtein
  // "edit" distance. The one change is that "updates" are treated as two
  // edits - not one. With Array splices, an update is really a delete
  // followed by an add. By retaining this, we optimize for "keeping" the
  // maximum array items in the original array. For example:
  //
  //   'xxxx123' -> '123yyyy'
  //
  // With 1-edit updates, the shortest path would be just to update all seven
  // characters. With 2-edit updates, we delete 4, leave 3, and add 4. This
  // leaves the substring '123' intact.
  function calcEditDistances(current, currentStart, currentEnd,
                              old, oldStart, oldEnd) {
    // "Deletion" columns
    let rowCount = oldEnd - oldStart + 1;
    let columnCount = currentEnd - currentStart + 1;
    let distances = new Array(rowCount);

    // "Addition" rows. Initialize null column.
    for (let i = 0; i < rowCount; i++) {
      distances[i] = new Array(columnCount);
      distances[i][0] = i;
    }

    // Initialize null row
    for (let j = 0; j < columnCount; j++)
      distances[0][j] = j;

    for (let i = 1; i < rowCount; i++) {
      for (let j = 1; j < columnCount; j++) {
        if (equals(current[currentStart + j - 1], old[oldStart + i - 1]))
          distances[i][j] = distances[i - 1][j - 1];
        else {
          let north = distances[i - 1][j] + 1;
          let west = distances[i][j - 1] + 1;
          distances[i][j] = north < west ? north : west;
        }
      }
    }

    return distances;
  }

  // This starts at the final weight, and walks "backward" by finding
  // the minimum previous weight recursively until the origin of the weight
  // matrix.
  function spliceOperationsFromEditDistances(distances) {
    let i = distances.length - 1;
    let j = distances[0].length - 1;
    let current = distances[i][j];
    let edits = [];
    while (i > 0 || j > 0) {
      if (i == 0) {
        edits.push(EDIT_ADD);
        j--;
        continue;
      }
      if (j == 0) {
        edits.push(EDIT_DELETE);
        i--;
        continue;
      }
      let northWest = distances[i - 1][j - 1];
      let west = distances[i - 1][j];
      let north = distances[i][j - 1];

      let min;
      if (west < north)
        min = west < northWest ? west : northWest;
      else
        min = north < northWest ? north : northWest;

      if (min == northWest) {
        if (northWest == current) {
          edits.push(EDIT_LEAVE);
        } else {
          edits.push(EDIT_UPDATE);
          current = northWest;
        }
        i--;
        j--;
      } else if (min == west) {
        edits.push(EDIT_DELETE);
        i--;
        current = west;
      } else {
        edits.push(EDIT_ADD);
        j--;
        current = north;
      }
    }

    edits.reverse();
    return edits;
  }

  /**
   * Splice Projection functions:
   *
   * A splice map is a representation of how a previous array of items
   * was transformed into a new array of items. Conceptually it is a list of
   * tuples of
   *
   *   <index, removed, addedCount>
   *
   * which are kept in ascending index order of. The tuple represents that at
   * the |index|, |removed| sequence of items were removed, and counting forward
   * from |index|, |addedCount| items were added.
   */

  /**
   * Lacking individual splice mutation information, the minimal set of
   * splices can be synthesized given the previous state and final state of an
   * array. The basic approach is to calculate the edit distance matrix and
   * choose the shortest path through it.
   *
   * Complexity: O(l * p)
   *   l: The length of the current array
   *   p: The length of the old array
   *
   * @param {!Array} current The current "changed" array for which to
   * calculate splices.
   * @param {number} currentStart Starting index in the `current` array for
   * which splices are calculated.
   * @param {number} currentEnd Ending index in the `current` array for
   * which splices are calculated.
   * @param {!Array} old The original "unchanged" array to compare `current`
   * against to determine splices.
   * @param {number} oldStart Starting index in the `old` array for
   * which splices are calculated.
   * @param {number} oldEnd Ending index in the `old` array for
   * which splices are calculated.
   * @return {!Array} Returns an array of splice record objects. Each of these
   * contains: `index` the location where the splice occurred; `removed`
   * the array of removed items from this location; `addedCount` the number
   * of items added at this location.
   */
  function calcSplices(current, currentStart, currentEnd,
                        old, oldStart, oldEnd) {
    let prefixCount = 0;
    let suffixCount = 0;
    let splice;

    let minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);
    if (currentStart == 0 && oldStart == 0)
      prefixCount = sharedPrefix(current, old, minLength);

    if (currentEnd == current.length && oldEnd == old.length)
      suffixCount = sharedSuffix(current, old, minLength - prefixCount);

    currentStart += prefixCount;
    oldStart += prefixCount;
    currentEnd -= suffixCount;
    oldEnd -= suffixCount;

    if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0)
      return [];

    if (currentStart == currentEnd) {
      splice = newSplice(currentStart, [], 0);
      while (oldStart < oldEnd)
        splice.removed.push(old[oldStart++]);

      return [ splice ];
    } else if (oldStart == oldEnd)
      return [ newSplice(currentStart, [], currentEnd - currentStart) ];

    let ops = spliceOperationsFromEditDistances(
        calcEditDistances(current, currentStart, currentEnd,
                               old, oldStart, oldEnd));

    splice = undefined;
    let splices = [];
    let index = currentStart;
    let oldIndex = oldStart;
    for (let i = 0; i < ops.length; i++) {
      switch(ops[i]) {
        case EDIT_LEAVE:
          if (splice) {
            splices.push(splice);
            splice = undefined;
          }

          index++;
          oldIndex++;
          break;
        case EDIT_UPDATE:
          if (!splice)
            splice = newSplice(index, [], 0);

          splice.addedCount++;
          index++;

          splice.removed.push(old[oldIndex]);
          oldIndex++;
          break;
        case EDIT_ADD:
          if (!splice)
            splice = newSplice(index, [], 0);

          splice.addedCount++;
          index++;
          break;
        case EDIT_DELETE:
          if (!splice)
            splice = newSplice(index, [], 0);

          splice.removed.push(old[oldIndex]);
          oldIndex++;
          break;
      }
    }

    if (splice) {
      splices.push(splice);
    }
    return splices;
  }

  function sharedPrefix(current, old, searchLength) {
    for (let i = 0; i < searchLength; i++)
      if (!equals(current[i], old[i]))
        return i;
    return searchLength;
  }

  function sharedSuffix(current, old, searchLength) {
    let index1 = current.length;
    let index2 = old.length;
    let count = 0;
    while (count < searchLength && equals(current[--index1], old[--index2]))
      count++;

    return count;
  }

  function calculateSplices(current, previous) {
    return calcSplices(current, 0, current.length, previous, 0,
                            previous.length);
  }

  function equals(currentValue, previousValue) {
    return currentValue === previousValue;
  }

  /**
   * @namespace
   * @memberof Polymer
   * @summary Module that provides utilities for diffing arrays.
   */
  Polymer.ArraySplice = {
    /**
     * Returns an array of splice records indicating the minimum edits required
     * to transform the `previous` array into the `current` array.
     *
     * Splice records are ordered by index and contain the following fields:
     * - `index`: index where edit started
     * - `removed`: array of removed items from this index
     * - `addedCount`: number of items added at this index
     *
     * This function is based on the Levenshtein "minimum edit distance"
     * algorithm. Note that updates are treated as removal followed by addition.
     *
     * The worst-case time complexity of this algorithm is `O(l * p)`
     *   l: The length of the current array
     *   p: The length of the previous array
     *
     * However, the worst-case complexity is reduced by an `O(n)` optimization
     * to detect any shared prefix & suffix between the two arrays and only
     * perform the more expensive minimum edit distance calculation over the
     * non-shared portions of the arrays.
     *
     * @function
     * @memberof Polymer.ArraySplice
     * @param {!Array} current The "changed" array for which splices will be
     * calculated.
     * @param {!Array} previous The "unchanged" original array to compare
     * `current` against to determine the splices.
     * @return {!Array} Returns an array of splice record objects. Each of these
     * contains: `index` the location where the splice occurred; `removed`
     * the array of removed items from this location; `addedCount` the number
     * of items added at this location.
     */
    calculateSplices
  };

})();


(function() {
  'use strict';

  /**
   * Returns true if `node` is a slot element
   * @param {Node} node Node to test.
   * @return {boolean} Returns true if the given `node` is a slot
   * @private
   */
  function isSlot(node) {
    return (node.localName === 'slot');
  }

  /**
   * Class that listens for changes (additions or removals) to
   * "flattened nodes" on a given `node`. The list of flattened nodes consists
   * of a node's children and, for any children that are `<slot>` elements,
   * the expanded flattened list of `assignedNodes`.
   * For example, if the observed node has children `<a></a><slot></slot><b></b>`
   * and the `<slot>` has one `<div>` assigned to it, then the flattened
   * nodes list is `<a></a><div></div><b></b>`. If the `<slot>` has other
   * `<slot>` elements assigned to it, these are flattened as well.
   *
   * The provided `callback` is called whenever any change to this list
   * of flattened nodes occurs, where an addition or removal of a node is
   * considered a change. The `callback` is called with one argument, an object
   * containing an array of any `addedNodes` and `removedNodes`.
   *
   * Note: the callback is called asynchronous to any changes
   * at a microtask checkpoint. This is because observation is performed using
   * `MutationObserver` and the `<slot>` element's `slotchange` event which
   * are asynchronous.
   *
   * An example:
   * ```js
   * class TestSelfObserve extends Polymer.Element {
   *   static get is() { return 'test-self-observe';}
   *   connectedCallback() {
   *     super.connectedCallback();
   *     this._observer = new Polymer.FlattenedNodesObserver(this, (info) => {
   *       this.info = info;
   *     });
   *   }
   *   disconnectedCallback() {
   *     super.disconnectedCallback();
   *     this._observer.disconnect();
   *   }
   * }
   * customElements.define(TestSelfObserve.is, TestSelfObserve);
   * ```
   *
   * @memberof Polymer
   * @summary Class that listens for changes (additions or removals) to
   * "flattened nodes" on a given `node`.
   */
  class FlattenedNodesObserver {

    /**
     * Returns the list of flattened nodes for the given `node`.
     * This list consists of a node's children and, for any children
     * that are `<slot>` elements, the expanded flattened list of `assignedNodes`.
     * For example, if the observed node has children `<a></a><slot></slot><b></b>`
     * and the `<slot>` has one `<div>` assigned to it, then the flattened
     * nodes list is `<a></a><div></div><b></b>`. If the `<slot>` has other
     * `<slot>` elements assigned to it, these are flattened as well.
     *
     * @param {HTMLElement|HTMLSlotElement} node The node for which to return the list of flattened nodes.
     * @return {Array} The list of flattened nodes for the given `node`.
    */
    static getFlattenedNodes(node) {
      if (isSlot(node)) {
        node = /** @type {HTMLSlotElement} */(node); // eslint-disable-line no-self-assign
        return node.assignedNodes({flatten: true});
      } else {
        return Array.from(node.childNodes).map((node) => {
          if (isSlot(node)) {
            node = /** @type {HTMLSlotElement} */(node); // eslint-disable-line no-self-assign
            return node.assignedNodes({flatten: true});
          } else {
            return [node];
          }
        }).reduce((a, b) => a.concat(b), []);
      }
    }

    /**
     * @param {Element} target Node on which to listen for changes.
     * @param {?function(!Element, { target: !Element, addedNodes: !Array<!Element>, removedNodes: !Array<!Element> }):void} callback Function called when there are additions
     * or removals from the target's list of flattened nodes.
    */
    constructor(target, callback) {
      /**
       * @type {MutationObserver}
       * @private
       */
      this._shadyChildrenObserver = null;
      /**
       * @type {MutationObserver}
       * @private
       */
      this._nativeChildrenObserver = null;
      this._connected = false;
      /**
       * @type {Element}
       * @private
       */
      this._target = target;
      this.callback = callback;
      this._effectiveNodes = [];
      this._observer = null;
      this._scheduled = false;
      /**
       * @type {function()}
       * @private
       */
      this._boundSchedule = () => {
        this._schedule();
      };
      this.connect();
      this._schedule();
    }

    /**
     * Activates an observer. This method is automatically called when
     * a `FlattenedNodesObserver` is created. It should only be called to
     * re-activate an observer that has been deactivated via the `disconnect` method.
     *
     * @return {void}
     */
    connect() {
      if (isSlot(this._target)) {
        this._listenSlots([this._target]);
      } else if (this._target.children) {
        this._listenSlots(this._target.children);
        if (window.ShadyDOM) {
          this._shadyChildrenObserver =
            ShadyDOM.observeChildren(this._target, (mutations) => {
              this._processMutations(mutations);
            });
        } else {
          this._nativeChildrenObserver =
            new MutationObserver((mutations) => {
              this._processMutations(mutations);
            });
          this._nativeChildrenObserver.observe(this._target, {childList: true});
        }
      }
      this._connected = true;
    }

    /**
     * Deactivates the flattened nodes observer. After calling this method
     * the observer callback will not be called when changes to flattened nodes
     * occur. The `connect` method may be subsequently called to reactivate
     * the observer.
     *
     * @return {void}
     */
    disconnect() {
      if (isSlot(this._target)) {
        this._unlistenSlots([this._target]);
      } else if (this._target.children) {
        this._unlistenSlots(this._target.children);
        if (window.ShadyDOM && this._shadyChildrenObserver) {
          ShadyDOM.unobserveChildren(this._shadyChildrenObserver);
          this._shadyChildrenObserver = null;
        } else if (this._nativeChildrenObserver) {
          this._nativeChildrenObserver.disconnect();
          this._nativeChildrenObserver = null;
        }
      }
      this._connected = false;
    }

    /**
     * @return {void}
     * @private
     */
    _schedule() {
      if (!this._scheduled) {
        this._scheduled = true;
        Polymer.Async.microTask.run(() => this.flush());
      }
    }

    /**
     * @param {Array<MutationRecord>} mutations Mutations signaled by the mutation observer
     * @return {void}
     * @private
     */
    _processMutations(mutations) {
      this._processSlotMutations(mutations);
      this.flush();
    }

    /**
     * @param {Array<MutationRecord>} mutations Mutations signaled by the mutation observer
     * @return {void}
     * @private
     */
    _processSlotMutations(mutations) {
      if (mutations) {
        for (let i=0; i < mutations.length; i++) {
          let mutation = mutations[i];
          if (mutation.addedNodes) {
            this._listenSlots(mutation.addedNodes);
          }
          if (mutation.removedNodes) {
            this._unlistenSlots(mutation.removedNodes);
          }
        }
      }
    }

    /**
     * Flushes the observer causing any pending changes to be immediately
     * delivered the observer callback. By default these changes are delivered
     * asynchronously at the next microtask checkpoint.
     *
     * @return {boolean} Returns true if any pending changes caused the observer
     * callback to run.
     */
    flush() {
      if (!this._connected) {
        return false;
      }
      if (window.ShadyDOM) {
        ShadyDOM.flush();
      }
      if (this._nativeChildrenObserver) {
        this._processSlotMutations(this._nativeChildrenObserver.takeRecords());
      } else if (this._shadyChildrenObserver) {
        this._processSlotMutations(this._shadyChildrenObserver.takeRecords());
      }
      this._scheduled = false;
      let info = {
        target: this._target,
        addedNodes: [],
        removedNodes: []
      };
      let newNodes = this.constructor.getFlattenedNodes(this._target);
      let splices = Polymer.ArraySplice.calculateSplices(newNodes,
        this._effectiveNodes);
      // process removals
      for (let i=0, s; (i<splices.length) && (s=splices[i]); i++) {
        for (let j=0, n; (j < s.removed.length) && (n=s.removed[j]); j++) {
          info.removedNodes.push(n);
        }
      }
      // process adds
      for (let i=0, s; (i<splices.length) && (s=splices[i]); i++) {
        for (let j=s.index; j < s.index + s.addedCount; j++) {
          info.addedNodes.push(newNodes[j]);
        }
      }
      // update cache
      this._effectiveNodes = newNodes;
      let didFlush = false;
      if (info.addedNodes.length || info.removedNodes.length) {
        didFlush = true;
        this.callback.call(this._target, info);
      }
      return didFlush;
    }

    /**
     * @param {!Array<Element|Node>|!NodeList<Node>} nodeList Nodes that could change
     * @return {void}
     * @private
     */
    _listenSlots(nodeList) {
      for (let i=0; i < nodeList.length; i++) {
        let n = nodeList[i];
        if (isSlot(n)) {
          n.addEventListener('slotchange', this._boundSchedule);
        }
      }
    }

    /**
     * @param {!Array<Element|Node>|!NodeList<Node>} nodeList Nodes that could change
     * @return {void}
     * @private
     */
    _unlistenSlots(nodeList) {
      for (let i=0; i < nodeList.length; i++) {
        let n = nodeList[i];
        if (isSlot(n)) {
          n.removeEventListener('slotchange', this._boundSchedule);
        }
      }
    }

  }

  Polymer.FlattenedNodesObserver = FlattenedNodesObserver;

})();


(function() {
  'use strict';

  let debouncerQueue = [];

  /**
   * Adds a `Polymer.Debouncer` to a list of globally flushable tasks.
   *
   * @memberof Polymer
   * @param {!Polymer.Debouncer} debouncer Debouncer to enqueue
   * @return {void}
   */
  Polymer.enqueueDebouncer = function(debouncer) {
    debouncerQueue.push(debouncer);
  };

  function flushDebouncers() {
    const didFlush = Boolean(debouncerQueue.length);
    while (debouncerQueue.length) {
      try {
        debouncerQueue.shift().flush();
      } catch(e) {
        setTimeout(() => {
          throw e;
        });
      }
    }
    return didFlush;
  }

  /**
   * Forces several classes of asynchronously queued tasks to flush:
   * - Debouncers added via `enqueueDebouncer`
   * - ShadyDOM distribution
   *
   * @memberof Polymer
   * @return {void}
   */
  Polymer.flush = function() {
    let shadyDOM, debouncers;
    do {
      shadyDOM = window.ShadyDOM && ShadyDOM.flush();
      if (window.ShadyCSS && window.ShadyCSS.ScopingShim) {
        window.ShadyCSS.ScopingShim.flush();
      }
      debouncers = flushDebouncers();
    } while (shadyDOM || debouncers);
  };

})();


(function() {
  'use strict';

  const p = Element.prototype;
  /**
   * @const {function(this:Node, string): boolean}
   */
  const normalizedMatchesSelector = p.matches || p.matchesSelector ||
    p.mozMatchesSelector || p.msMatchesSelector ||
    p.oMatchesSelector || p.webkitMatchesSelector;

  /**
   * Cross-platform `element.matches` shim.
   *
   * @function matchesSelector
   * @memberof Polymer.dom
   * @param {!Node} node Node to check selector against
   * @param {string} selector Selector to match
   * @return {boolean} True if node matched selector
   */
  const matchesSelector = function(node, selector) {
    return normalizedMatchesSelector.call(node, selector);
  };

  /**
   * Node API wrapper class returned from `Polymer.dom.(target)` when
   * `target` is a `Node`.
   *
   * @memberof Polymer
   */
  class DomApi {

    /**
     * @param {Node} node Node for which to create a Polymer.dom helper object.
     */
    constructor(node) {
      this.node = node;
    }

    /**
     * Returns an instance of `Polymer.FlattenedNodesObserver` that
     * listens for node changes on this element.
     *
     * @param {function(!Element, { target: !Element, addedNodes: !Array<!Element>, removedNodes: !Array<!Element> }):void} callback Called when direct or distributed children
     *   of this element changes
     * @return {!Polymer.FlattenedNodesObserver} Observer instance
     */
    observeNodes(callback) {
      return new Polymer.FlattenedNodesObserver(this.node, callback);
    }

    /**
     * Disconnects an observer previously created via `observeNodes`
     *
     * @param {!Polymer.FlattenedNodesObserver} observerHandle Observer instance
     *   to disconnect.
     * @return {void}
     */
    unobserveNodes(observerHandle) {
      observerHandle.disconnect();
    }

    /**
     * Provided as a backwards-compatible API only.  This method does nothing.
     * @return {void}
     */
    notifyObserver() {}

    /**
     * Returns true if the provided node is contained with this element's
     * light-DOM children or shadow root, including any nested shadow roots
     * of children therein.
     *
     * @param {Node} node Node to test
     * @return {boolean} Returns true if the given `node` is contained within
     *   this element's light or shadow DOM.
     */
    deepContains(node) {
      if (this.node.contains(node)) {
        return true;
      }
      let n = node;
      let doc = node.ownerDocument;
      // walk from node to `this` or `document`
      while (n && n !== doc && n !== this.node) {
        // use logical parentnode, or native ShadowRoot host
        n = n.parentNode || n.host;
      }
      return n === this.node;
    }

    /**
     * Returns the root node of this node.  Equivalent to `getRoodNode()`.
     *
     * @return {Node} Top most element in the dom tree in which the node
     * exists. If the node is connected to a document this is either a
     * shadowRoot or the document; otherwise, it may be the node
     * itself or a node or document fragment containing it.
     */
    getOwnerRoot() {
      return this.node.getRootNode();
    }

    /**
     * For slot elements, returns the nodes assigned to the slot; otherwise
     * an empty array. It is equivalent to `<slot>.addignedNodes({flatten:true})`.
     *
     * @return {!Array<!Node>} Array of assigned nodes
     */
    getDistributedNodes() {
      return (this.node.localName === 'slot') ?
        this.node.assignedNodes({flatten: true}) :
        [];
    }

    /**
     * Returns an array of all slots this element was distributed to.
     *
     * @return {!Array<!HTMLSlotElement>} Description
     */
    getDestinationInsertionPoints() {
      let ip$ = [];
      let n = this.node.assignedSlot;
      while (n) {
        ip$.push(n);
        n = n.assignedSlot;
      }
      return ip$;
    }

    /**
     * Calls `importNode` on the `ownerDocument` for this node.
     *
     * @param {!Node} node Node to import
     * @param {boolean} deep True if the node should be cloned deeply during
     *   import
     * @return {Node} Clone of given node imported to this owner document
     */
    importNode(node, deep) {
      let doc = this.node instanceof Document ? this.node :
        this.node.ownerDocument;
      return doc.importNode(node, deep);
    }

    /**
     * @return {!Array<!Node>} Returns a flattened list of all child nodes and
     * nodes assigned to child slots.
     */
    getEffectiveChildNodes() {
      return Polymer.FlattenedNodesObserver.getFlattenedNodes(this.node);
    }

    /**
     * Returns a filtered list of flattened child elements for this element based
     * on the given selector.
     *
     * @param {string} selector Selector to filter nodes against
     * @return {!Array<!HTMLElement>} List of flattened child elements
     */
    queryDistributedElements(selector) {
      let c$ = this.getEffectiveChildNodes();
      let list = [];
      for (let i=0, l=c$.length, c; (i<l) && (c=c$[i]); i++) {
        if ((c.nodeType === Node.ELEMENT_NODE) &&
            matchesSelector(c, selector)) {
          list.push(c);
        }
      }
      return list;
    }

    /**
     * For shadow roots, returns the currently focused element within this
     * shadow root.
     *
     * @return {Node|undefined} Currently focused element
     */
    get activeElement() {
      let node = this.node;
      return node._activeElement !== undefined ? node._activeElement : node.activeElement;
    }
  }

  function forwardMethods(proto, methods) {
    for (let i=0; i < methods.length; i++) {
      let method = methods[i];
      /* eslint-disable valid-jsdoc */
      proto[method] = /** @this {DomApi} */ function() {
        return this.node[method].apply(this.node, arguments);
      };
      /* eslint-enable */
    }
  }

  function forwardReadOnlyProperties(proto, properties) {
    for (let i=0; i < properties.length; i++) {
      let name = properties[i];
      Object.defineProperty(proto, name, {
        get: function() {
          const domApi = /** @type {DomApi} */(this);
          return domApi.node[name];
        },
        configurable: true
      });
    }
  }

  function forwardProperties(proto, properties) {
    for (let i=0; i < properties.length; i++) {
      let name = properties[i];
      Object.defineProperty(proto, name, {
        get: function() {
          const domApi = /** @type {DomApi} */(this);
          return domApi.node[name];
        },
        set: function(value) {
          /** @type {DomApi} */ (this).node[name] = value;
        },
        configurable: true
      });
    }
  }

  forwardMethods(DomApi.prototype, [
    'cloneNode', 'appendChild', 'insertBefore', 'removeChild',
    'replaceChild', 'setAttribute', 'removeAttribute',
    'querySelector', 'querySelectorAll'
  ]);

  forwardReadOnlyProperties(DomApi.prototype, [
    'parentNode', 'firstChild', 'lastChild',
    'nextSibling', 'previousSibling', 'firstElementChild',
    'lastElementChild', 'nextElementSibling', 'previousElementSibling',
    'childNodes', 'children', 'classList'
  ]);

  forwardProperties(DomApi.prototype, [
    'textContent', 'innerHTML'
  ]);


  /**
   * Event API wrapper class returned from `Polymer.dom.(target)` when
   * `target` is an `Event`.
   */
  class EventApi {
    constructor(event) {
      this.event = event;
    }

    /**
     * Returns the first node on the `composedPath` of this event.
     *
     * @return {!EventTarget} The node this event was dispatched to
     */
    get rootTarget() {
      return this.event.composedPath()[0];
    }

    /**
     * Returns the local (re-targeted) target for this event.
     *
     * @return {!EventTarget} The local (re-targeted) target for this event.
     */
    get localTarget() {
      return this.event.target;
    }

    /**
     * Returns the `composedPath` for this event.
     * @return {!Array<!EventTarget>} The nodes this event propagated through
     */
    get path() {
      return this.event.composedPath();
    }
  }

  Polymer.DomApi = DomApi;

  /**
   * @function
   * @param {boolean=} deep
   * @return {!Node}
   */
  Polymer.DomApi.prototype.cloneNode;
  /**
   * @function
   * @param {!Node} node
   * @return {!Node}
   */
  Polymer.DomApi.prototype.appendChild;
  /**
   * @function
   * @param {!Node} newChild
   * @param {Node} refChild
   * @return {!Node}
   */
  Polymer.DomApi.prototype.insertBefore;
  /**
   * @function
   * @param {!Node} node
   * @return {!Node}
   */
  Polymer.DomApi.prototype.removeChild;
  /**
   * @function
   * @param {!Node} oldChild
   * @param {!Node} newChild
   * @return {!Node}
   */
  Polymer.DomApi.prototype.replaceChild;
  /**
   * @function
   * @param {string} name
   * @param {string} value
   * @return {void}
   */
  Polymer.DomApi.prototype.setAttribute;
  /**
   * @function
   * @param {string} name
   * @return {void}
   */
  Polymer.DomApi.prototype.removeAttribute;
  /**
   * @function
   * @param {string} selector
   * @return {?Element}
   */
  Polymer.DomApi.prototype.querySelector;
  /**
   * @function
   * @param {string} selector
   * @return {!NodeList<!Element>}
   */
  Polymer.DomApi.prototype.querySelectorAll;

  /**
   * Legacy DOM and Event manipulation API wrapper factory used to abstract
   * differences between native Shadow DOM and "Shady DOM" when polyfilling on
   * older browsers.
   *
   * Note that in Polymer 2.x use of `Polymer.dom` is no longer required and
   * in the majority of cases simply facades directly to the standard native
   * API.
   *
   * @namespace
   * @summary Legacy DOM and Event manipulation API wrapper factory used to
   * abstract differences between native Shadow DOM and "Shady DOM."
   * @memberof Polymer
   * @param {(Node|Event)=} obj Node or event to operate on
   * @return {!DomApi|!EventApi} Wrapper providing either node API or event API
   */
  Polymer.dom = function(obj) {
    obj = obj || document;
    if (!obj.__domApi) {
      let helper;
      if (obj instanceof Event) {
        helper = new EventApi(obj);
      } else {
        helper = new DomApi(obj);
      }
      obj.__domApi = helper;
    }
    return obj.__domApi;
  };

  Polymer.dom.matchesSelector = matchesSelector;

  /**
   * Forces several classes of asynchronously queued tasks to flush:
   * - Debouncers added via `Polymer.enqueueDebouncer`
   * - ShadyDOM distribution
   *
   * This method facades to `Polymer.flush`.
   *
   * @memberof Polymer.dom
   */
  Polymer.dom.flush = Polymer.flush;

  /**
   * Adds a `Polymer.Debouncer` to a list of globally flushable tasks.
   *
   * This method facades to `Polymer.enqueueDebouncer`.
   *
   * @memberof Polymer.dom
   * @param {!Polymer.Debouncer} debouncer Debouncer to enqueue
   */
  Polymer.dom.addDebouncer = Polymer.enqueueDebouncer;
})();


(function() {

  'use strict';

  let styleInterface = window.ShadyCSS;

  /**
   * Element class mixin that provides Polymer's "legacy" API intended to be
   * backward-compatible to the greatest extent possible with the API
   * found on the Polymer 1.x `Polymer.Base` prototype applied to all elements
   * defined using the `Polymer({...})` function.
   *
   * @mixinFunction
   * @polymer
   * @appliesMixin Polymer.ElementMixin
   * @appliesMixin Polymer.GestureEventListeners
   * @property isAttached {boolean} Set to `true` in this element's
   *   `connectedCallback` and `false` in `disconnectedCallback`
   * @memberof Polymer
   * @summary Element class mixin that provides Polymer's "legacy" API
   */
  Polymer.LegacyElementMixin = Polymer.dedupingMixin((base) => {

    /**
     * @constructor
     * @extends {base}
     * @implements {Polymer_ElementMixin}
     * @implements {Polymer_GestureEventListeners}
     * @implements {Polymer_DirMixin}
     * @private
     */
    const legacyElementBase = Polymer.DirMixin(Polymer.GestureEventListeners(Polymer.ElementMixin(base)));

    /**
     * Map of simple names to touch action names
     * @dict
     */
    const DIRECTION_MAP = {
      'x': 'pan-x',
      'y': 'pan-y',
      'none': 'none',
      'all': 'auto'
    };

    /**
     * @polymer
     * @mixinClass
     * @extends {legacyElementBase}
     * @implements {Polymer_LegacyElementMixin}
     * @unrestricted
     */
    class LegacyElement extends legacyElementBase {

      constructor() {
        super();
        /** @type {boolean} */
        this.isAttached;
        /** @type {WeakMap<!Element, !Object<string, !Function>>} */
        this.__boundListeners;
        /** @type {Object<string, Function>} */
        this._debouncers;
      }

      /**
       * Forwards `importMeta` from the prototype (i.e. from the info object
       * passed to `Polymer({...})`) to the static API.
       *
       * @return {!Object} The `import.meta` object set on the prototype
       * @suppress {missingProperties} `this` is always in the instance in
       *  closure for some reason even in a static method, rather than the class
       */
      static get importMeta() {
        return this.prototype.importMeta;
      }

      /**
       * Legacy callback called during the `constructor`, for overriding
       * by the user.
       * @return {void}
       */
      created() {}

      /**
       * Provides an implementation of `connectedCallback`
       * which adds Polymer legacy API's `attached` method.
       * @return {void}
       * @override
       */
      connectedCallback() {
        super.connectedCallback();
        this.isAttached = true;
        this.attached();
      }

      /**
       * Legacy callback called during `connectedCallback`, for overriding
       * by the user.
       * @return {void}
       */
      attached() {}

      /**
       * Provides an implementation of `disconnectedCallback`
       * which adds Polymer legacy API's `detached` method.
       * @return {void}
       * @override
       */
      disconnectedCallback() {
        super.disconnectedCallback();
        this.isAttached = false;
        this.detached();
      }

      /**
       * Legacy callback called during `disconnectedCallback`, for overriding
       * by the user.
       * @return {void}
       */
      detached() {}

      /**
       * Provides an override implementation of `attributeChangedCallback`
       * which adds the Polymer legacy API's `attributeChanged` method.
       * @param {string} name Name of attribute.
       * @param {?string} old Old value of attribute.
       * @param {?string} value Current value of attribute.
       * @param {?string} namespace Attribute namespace.
       * @return {void}
       * @override
       */
      attributeChangedCallback(name, old, value, namespace) {
        if (old !== value) {
          super.attributeChangedCallback(name, old, value, namespace);
          this.attributeChanged(name, old, value);
        }
      }

      /**
       * Legacy callback called during `attributeChangedChallback`, for overriding
       * by the user.
       * @param {string} name Name of attribute.
       * @param {?string} old Old value of attribute.
       * @param {?string} value Current value of attribute.
       * @return {void}
       */
      attributeChanged(name, old, value) {} // eslint-disable-line no-unused-vars

      /**
       * Overrides the default `Polymer.PropertyEffects` implementation to
       * add support for class initialization via the `_registered` callback.
       * This is called only when the first instance of the element is created.
       *
       * @return {void}
       * @override
       * @suppress {invalidCasts}
       */
      _initializeProperties() {
        let proto = Object.getPrototypeOf(this);
        if (!proto.hasOwnProperty('__hasRegisterFinished')) {
          this._registered();
          // backstop in case the `_registered` implementation does not set this
          proto.__hasRegisterFinished = true;
        }
        super._initializeProperties();
        this.root = /** @type {HTMLElement} */(this);
        this.created();
        // Ensure listeners are applied immediately so that they are
        // added before declarative event listeners. This allows an element to
        // decorate itself via an event prior to any declarative listeners
        // seeing the event. Note, this ensures compatibility with 1.x ordering.
        this._applyListeners();
      }

      /**
       * Called automatically when an element is initializing.
       * Users may override this method to perform class registration time
       * work. The implementation should ensure the work is performed
       * only once for the class.
       * @protected
       * @return {void}
       */
      _registered() {}

      /**
       * Overrides the default `Polymer.PropertyEffects` implementation to
       * add support for installing `hostAttributes` and `listeners`.
       *
       * @return {void}
       * @override
       */
      ready() {
        this._ensureAttributes();
        super.ready();
      }

      /**
       * Ensures an element has required attributes. Called when the element
       * is being readied via `ready`. Users should override to set the
       * element's required attributes. The implementation should be sure
       * to check and not override existing attributes added by
       * the user of the element. Typically, setting attributes should be left
       * to the element user and not done here; reasonable exceptions include
       * setting aria roles and focusability.
       * @protected
       * @return {void}
       */
      _ensureAttributes() {}

      /**
       * Adds element event listeners. Called when the element
       * is being readied via `ready`. Users should override to
       * add any required element event listeners.
       * In performance critical elements, the work done here should be kept
       * to a minimum since it is done before the element is rendered. In
       * these elements, consider adding listeners asynchronously so as not to
       * block render.
       * @protected
       * @return {void}
       */
      _applyListeners() {}

      /**
       * Converts a typed JavaScript value to a string.
       *
       * Note this method is provided as backward-compatible legacy API
       * only.  It is not directly called by any Polymer features. To customize
       * how properties are serialized to attributes for attribute bindings and
       * `reflectToAttribute: true` properties as well as this method, override
       * the `_serializeValue` method provided by `Polymer.PropertyAccessors`.
       *
       * @param {*} value Value to deserialize
       * @return {string | undefined} Serialized value
       */
      serialize(value) {
        return this._serializeValue(value);
      }

      /**
       * Converts a string to a typed JavaScript value.
       *
       * Note this method is provided as backward-compatible legacy API
       * only.  It is not directly called by any Polymer features.  To customize
       * how attributes are deserialized to properties for in
       * `attributeChangedCallback`, override `_deserializeValue` method
       * provided by `Polymer.PropertyAccessors`.
       *
       * @param {string} value String to deserialize
       * @param {*} type Type to deserialize the string to
       * @return {*} Returns the deserialized value in the `type` given.
       */
      deserialize(value, type) {
        return this._deserializeValue(value, type);
      }

      /**
       * Serializes a property to its associated attribute.
       *
       * Note this method is provided as backward-compatible legacy API
       * only.  It is not directly called by any Polymer features.
       *
       * @param {string} property Property name to reflect.
       * @param {string=} attribute Attribute name to reflect.
       * @param {*=} value Property value to reflect.
       * @return {void}
       */
      reflectPropertyToAttribute(property, attribute, value) {
        this._propertyToAttribute(property, attribute, value);
      }

      /**
       * Sets a typed value to an HTML attribute on a node.
       *
       * Note this method is provided as backward-compatible legacy API
       * only.  It is not directly called by any Polymer features.
       *
       * @param {*} value Value to serialize.
       * @param {string} attribute Attribute name to serialize to.
       * @param {Element} node Element to set attribute to.
       * @return {void}
       */
      serializeValueToAttribute(value, attribute, node) {
        this._valueToNodeAttribute(/** @type {Element} */ (node || this), value, attribute);
      }

      /**
       * Copies own properties (including accessor descriptors) from a source
       * object to a target object.
       *
       * @param {Object} prototype Target object to copy properties to.
       * @param {Object} api Source object to copy properties from.
       * @return {Object} prototype object that was passed as first argument.
       */
      extend(prototype, api) {
        if (!(prototype && api)) {
          return prototype || api;
        }
        let n$ = Object.getOwnPropertyNames(api);
        for (let i=0, n; (i<n$.length) && (n=n$[i]); i++) {
          let pd = Object.getOwnPropertyDescriptor(api, n);
          if (pd) {
            Object.defineProperty(prototype, n, pd);
          }
        }
        return prototype;
      }

      /**
       * Copies props from a source object to a target object.
       *
       * Note, this method uses a simple `for...in` strategy for enumerating
       * properties.  To ensure only `ownProperties` are copied from source
       * to target and that accessor implementations are copied, use `extend`.
       *
       * @param {!Object} target Target object to copy properties to.
       * @param {!Object} source Source object to copy properties from.
       * @return {!Object} Target object that was passed as first argument.
       */
      mixin(target, source) {
        for (let i in source) {
          target[i] = source[i];
        }
        return target;
      }

      /**
       * Sets the prototype of an object.
       *
       * Note this method is provided as backward-compatible legacy API
       * only.  It is not directly called by any Polymer features.
       * @param {Object} object The object on which to set the prototype.
       * @param {Object} prototype The prototype that will be set on the given
       * `object`.
       * @return {Object} Returns the given `object` with its prototype set
       * to the given `prototype` object.
       */
      chainObject(object, prototype) {
        if (object && prototype && object !== prototype) {
          object.__proto__ = prototype;
        }
        return object;
      }

      /* **** Begin Template **** */

      /**
       * Calls `importNode` on the `content` of the `template` specified and
       * returns a document fragment containing the imported content.
       *
       * @param {HTMLTemplateElement} template HTML template element to instance.
       * @return {!DocumentFragment} Document fragment containing the imported
       *   template content.
      */
      instanceTemplate(template) {
        let content = this.constructor._contentForTemplate(template);
        let dom = /** @type {!DocumentFragment} */
          (document.importNode(content, true));
        return dom;
      }

      /* **** Begin Events **** */



      /**
       * Dispatches a custom event with an optional detail value.
       *
       * @param {string} type Name of event type.
       * @param {*=} detail Detail value containing event-specific
       *   payload.
       * @param {{ bubbles: (boolean|undefined), cancelable: (boolean|undefined), composed: (boolean|undefined) }=}
       *  options Object specifying options.  These may include:
       *  `bubbles` (boolean, defaults to `true`),
       *  `cancelable` (boolean, defaults to false), and
       *  `node` on which to fire the event (HTMLElement, defaults to `this`).
       * @return {!Event} The new event that was fired.
       */
      fire(type, detail, options) {
        options = options || {};
        detail = (detail === null || detail === undefined) ? {} : detail;
        let event = new Event(type, {
          bubbles: options.bubbles === undefined ? true : options.bubbles,
          cancelable: Boolean(options.cancelable),
          composed: options.composed === undefined ? true: options.composed
        });
        event.detail = detail;
        let node = options.node || this;
        node.dispatchEvent(event);
        return event;
      }

      /**
       * Convenience method to add an event listener on a given element,
       * late bound to a named method on this element.
       *
       * @param {Element} node Element to add event listener to.
       * @param {string} eventName Name of event to listen for.
       * @param {string} methodName Name of handler method on `this` to call.
       * @return {void}
       */
      listen(node, eventName, methodName) {
        node = /** @type {!Element} */ (node || this);
        let hbl = this.__boundListeners ||
          (this.__boundListeners = new WeakMap());
        let bl = hbl.get(node);
        if (!bl) {
          bl = {};
          hbl.set(node, bl);
        }
        let key = eventName + methodName;
        if (!bl[key]) {
          bl[key] = this._addMethodEventListenerToNode(
            node, eventName, methodName, this);
        }
      }

      /**
       * Convenience method to remove an event listener from a given element,
       * late bound to a named method on this element.
       *
       * @param {Element} node Element to remove event listener from.
       * @param {string} eventName Name of event to stop listening to.
       * @param {string} methodName Name of handler method on `this` to not call
       anymore.
       * @return {void}
       */
      unlisten(node, eventName, methodName) {
        node = /** @type {!Element} */ (node || this);
        let bl = this.__boundListeners && this.__boundListeners.get(node);
        let key = eventName + methodName;
        let handler = bl && bl[key];
        if (handler) {
          this._removeEventListenerFromNode(node, eventName, handler);
          bl[key] = null;
        }
      }

      /**
       * Override scrolling behavior to all direction, one direction, or none.
       *
       * Valid scroll directions:
       *   - 'all': scroll in any direction
       *   - 'x': scroll only in the 'x' direction
       *   - 'y': scroll only in the 'y' direction
       *   - 'none': disable scrolling for this node
       *
       * @param {string=} direction Direction to allow scrolling
       * Defaults to `all`.
       * @param {Element=} node Element to apply scroll direction setting.
       * Defaults to `this`.
       * @return {void}
       */
      setScrollDirection(direction, node) {
        Polymer.Gestures.setTouchAction(/** @type {Element} */ (node || this), DIRECTION_MAP[direction] || 'auto');
      }
      /* **** End Events **** */

      /**
       * Convenience method to run `querySelector` on this local DOM scope.
       *
       * This function calls `Polymer.dom(this.root).querySelector(slctr)`.
       *
       * @param {string} slctr Selector to run on this local DOM scope
       * @return {Element} Element found by the selector, or null if not found.
       */
      $$(slctr) {
        return this.root.querySelector(slctr);
      }

      /**
       * Return the element whose local dom within which this element
       * is contained. This is a shorthand for
       * `this.getRootNode().host`.
       * @this {Element}
       */
      get domHost() {
        let root = this.getRootNode();
        return (root instanceof DocumentFragment) ? /** @type {ShadowRoot} */ (root).host : root;
      }

      /**
       * Force this element to distribute its children to its local dom.
       * This should not be necessary as of Polymer 2.0.2 and is provided only
       * for backwards compatibility.
       * @return {void}
       */
      distributeContent() {
        if (window.ShadyDOM && this.shadowRoot) {
          ShadyDOM.flush();
        }
      }

      /**
       * Returns a list of nodes that are the effective childNodes. The effective
       * childNodes list is the same as the element's childNodes except that
       * any `<content>` elements are replaced with the list of nodes distributed
       * to the `<content>`, the result of its `getDistributedNodes` method.
       * @return {!Array<!Node>} List of effective child nodes.
       * @suppress {invalidCasts} LegacyElementMixin must be applied to an HTMLElement
       */
      getEffectiveChildNodes() {
        const thisEl = /** @type {Element} */ (this);
        const domApi = /** @type {Polymer.DomApi} */(Polymer.dom(thisEl));
        return domApi.getEffectiveChildNodes();
      }

      /**
       * Returns a list of nodes distributed within this element that match
       * `selector`. These can be dom children or elements distributed to
       * children that are insertion points.
       * @param {string} selector Selector to run.
       * @return {!Array<!Node>} List of distributed elements that match selector.
       * @suppress {invalidCasts} LegacyElementMixin must be applied to an HTMLElement
       */
      queryDistributedElements(selector) {
        const thisEl = /** @type {Element} */ (this);
        const domApi = /** @type {Polymer.DomApi} */(Polymer.dom(thisEl));
        return domApi.queryDistributedElements(selector);
      }

      /**
       * Returns a list of elements that are the effective children. The effective
       * children list is the same as the element's children except that
       * any `<content>` elements are replaced with the list of elements
       * distributed to the `<content>`.
       *
       * @return {!Array<!Node>} List of effective children.
       */
      getEffectiveChildren() {
        let list = this.getEffectiveChildNodes();
        return list.filter(function(/** @type {!Node} */ n) {
          return (n.nodeType === Node.ELEMENT_NODE);
        });
      }

      /**
       * Returns a string of text content that is the concatenation of the
       * text content's of the element's effective childNodes (the elements
       * returned by <a href="#getEffectiveChildNodes>getEffectiveChildNodes</a>.
       *
       * @return {string} List of effective children.
       */
      getEffectiveTextContent() {
        let cn = this.getEffectiveChildNodes();
        let tc = [];
        for (let i=0, c; (c = cn[i]); i++) {
          if (c.nodeType !== Node.COMMENT_NODE) {
            tc.push(c.textContent);
          }
        }
        return tc.join('');
      }

      /**
       * Returns the first effective childNode within this element that
       * match `selector`. These can be dom child nodes or elements distributed
       * to children that are insertion points.
       * @param {string} selector Selector to run.
       * @return {Node} First effective child node that matches selector.
       */
      queryEffectiveChildren(selector) {
        let e$ = this.queryDistributedElements(selector);
        return e$ && e$[0];
      }

      /**
       * Returns a list of effective childNodes within this element that
       * match `selector`. These can be dom child nodes or elements distributed
       * to children that are insertion points.
       * @param {string} selector Selector to run.
       * @return {!Array<!Node>} List of effective child nodes that match selector.
       */
      queryAllEffectiveChildren(selector) {
        return this.queryDistributedElements(selector);
      }

      /**
       * Returns a list of nodes distributed to this element's `<slot>`.
       *
       * If this element contains more than one `<slot>` in its local DOM,
       * an optional selector may be passed to choose the desired content.
       *
       * @param {string=} slctr CSS selector to choose the desired
       *   `<slot>`.  Defaults to `content`.
       * @return {!Array<!Node>} List of distributed nodes for the `<slot>`.
       */
      getContentChildNodes(slctr) {
        let content = this.root.querySelector(slctr || 'slot');
        return content ? /** @type {Polymer.DomApi} */(Polymer.dom(content)).getDistributedNodes() : [];
      }

      /**
       * Returns a list of element children distributed to this element's
       * `<slot>`.
       *
       * If this element contains more than one `<slot>` in its
       * local DOM, an optional selector may be passed to choose the desired
       * content.  This method differs from `getContentChildNodes` in that only
       * elements are returned.
       *
       * @param {string=} slctr CSS selector to choose the desired
       *   `<content>`.  Defaults to `content`.
       * @return {!Array<!HTMLElement>} List of distributed nodes for the
       *   `<slot>`.
       * @suppress {invalidCasts}
       */
      getContentChildren(slctr) {
        let children = /** @type {!Array<!HTMLElement>} */(this.getContentChildNodes(slctr).filter(function(n) {
          return (n.nodeType === Node.ELEMENT_NODE);
        }));
        return children;
      }

      /**
       * Checks whether an element is in this element's light DOM tree.
       *
       * @param {?Node} node The element to be checked.
       * @return {boolean} true if node is in this element's light DOM tree.
       * @suppress {invalidCasts} LegacyElementMixin must be applied to an HTMLElement
       */
      isLightDescendant(node) {
        const thisNode = /** @type {Node} */ (this);
        return thisNode !== node && thisNode.contains(node) &&
          thisNode.getRootNode() === node.getRootNode();
      }

      /**
       * Checks whether an element is in this element's local DOM tree.
       *
       * @param {!Element} node The element to be checked.
       * @return {boolean} true if node is in this element's local DOM tree.
       */
      isLocalDescendant(node) {
        return this.root === node.getRootNode();
      }

      /**
       * No-op for backwards compatibility. This should now be handled by
       * ShadyCss library.
       * @param  {*} container Unused
       * @param  {*} shouldObserve Unused
       * @return {void}
       */
      scopeSubtree(container, shouldObserve) { // eslint-disable-line no-unused-vars
      }

      /**
       * Returns the computed style value for the given property.
       * @param {string} property The css property name.
       * @return {string} Returns the computed css property value for the given
       * `property`.
       * @suppress {invalidCasts} LegacyElementMixin must be applied to an HTMLElement
       */
      getComputedStyleValue(property) {
        return styleInterface.getComputedStyleValue(/** @type {!Element} */(this), property);
      }

      // debounce

      /**
       * Call `debounce` to collapse multiple requests for a named task into
       * one invocation which is made after the wait time has elapsed with
       * no new request.  If no wait time is given, the callback will be called
       * at microtask timing (guaranteed before paint).
       *
       *     debouncedClickAction(e) {
       *       // will not call `processClick` more than once per 100ms
       *       this.debounce('click', function() {
       *        this.processClick();
       *       } 100);
       *     }
       *
       * @param {string} jobName String to identify the debounce job.
       * @param {function():void} callback Function that is called (with `this`
       *   context) when the wait time elapses.
       * @param {number} wait Optional wait time in milliseconds (ms) after the
       *   last signal that must elapse before invoking `callback`
       * @return {!Object} Returns a debouncer object on which exists the
       * following methods: `isActive()` returns true if the debouncer is
       * active; `cancel()` cancels the debouncer if it is active;
       * `flush()` immediately invokes the debounced callback if the debouncer
       * is active.
       */
      debounce(jobName, callback, wait) {
        this._debouncers = this._debouncers || {};
        return this._debouncers[jobName] = Polymer.Debouncer.debounce(
              this._debouncers[jobName]
            , wait > 0 ? Polymer.Async.timeOut.after(wait) : Polymer.Async.microTask
            , callback.bind(this));
      }

      /**
       * Returns whether a named debouncer is active.
       *
       * @param {string} jobName The name of the debouncer started with `debounce`
       * @return {boolean} Whether the debouncer is active (has not yet fired).
       */
      isDebouncerActive(jobName) {
        this._debouncers = this._debouncers || {};
        let debouncer = this._debouncers[jobName];
        return !!(debouncer && debouncer.isActive());
      }

      /**
       * Immediately calls the debouncer `callback` and inactivates it.
       *
       * @param {string} jobName The name of the debouncer started with `debounce`
       * @return {void}
       */
      flushDebouncer(jobName) {
        this._debouncers = this._debouncers || {};
        let debouncer = this._debouncers[jobName];
        if (debouncer) {
          debouncer.flush();
        }
      }

      /**
       * Cancels an active debouncer.  The `callback` will not be called.
       *
       * @param {string} jobName The name of the debouncer started with `debounce`
       * @return {void}
       */
      cancelDebouncer(jobName) {
        this._debouncers = this._debouncers || {};
        let debouncer = this._debouncers[jobName];
        if (debouncer) {
          debouncer.cancel();
        }
      }

      /**
       * Runs a callback function asynchronously.
       *
       * By default (if no waitTime is specified), async callbacks are run at
       * microtask timing, which will occur before paint.
       *
       * @param {!Function} callback The callback function to run, bound to `this`.
       * @param {number=} waitTime Time to wait before calling the
       *   `callback`.  If unspecified or 0, the callback will be run at microtask
       *   timing (before paint).
       * @return {number} Handle that may be used to cancel the async job.
       */
      async(callback, waitTime) {
        return waitTime > 0 ? Polymer.Async.timeOut.run(callback.bind(this), waitTime) :
            ~Polymer.Async.microTask.run(callback.bind(this));
      }

      /**
       * Cancels an async operation started with `async`.
       *
       * @param {number} handle Handle returned from original `async` call to
       *   cancel.
       * @return {void}
       */
      cancelAsync(handle) {
        handle < 0 ? Polymer.Async.microTask.cancel(~handle) :
            Polymer.Async.timeOut.cancel(handle);
      }

      // other

      /**
       * Convenience method for creating an element and configuring it.
       *
       * @param {string} tag HTML element tag to create.
       * @param {Object=} props Object of properties to configure on the
       *    instance.
       * @return {!Element} Newly created and configured element.
       */
      create(tag, props) {
        let elt = document.createElement(tag);
        if (props) {
          if (elt.setProperties) {
            elt.setProperties(props);
          } else {
            for (let n in props) {
              elt[n] = props[n];
            }
          }
        }
        return elt;
      }

      /**
       * Convenience method for importing an HTML document imperatively.
       *
       * This method creates a new `<link rel="import">` element with
       * the provided URL and appends it to the document to start loading.
       * In the `onload` callback, the `import` property of the `link`
       * element will contain the imported document contents.
       *
       * @param {string} href URL to document to load.
       * @param {?function(!Event):void=} onload Callback to notify when an import successfully
       *   loaded.
       * @param {?function(!ErrorEvent):void=} onerror Callback to notify when an import
       *   unsuccessfully loaded.
       * @param {boolean=} optAsync True if the import should be loaded `async`.
       *   Defaults to `false`.
       * @return {!HTMLLinkElement} The link element for the URL to be loaded.
       */
      importHref(href, onload, onerror, optAsync) { // eslint-disable-line no-unused-vars
        let loadFn = onload ? onload.bind(this) : null;
        let errorFn = onerror ? onerror.bind(this) : null;
        return Polymer.importHref(href, loadFn, errorFn, optAsync);
      }

      /**
       * Polyfill for Element.prototype.matches, which is sometimes still
       * prefixed.
       *
       * @param {string} selector Selector to test.
       * @param {!Element=} node Element to test the selector against.
       * @return {boolean} Whether the element matches the selector.
       */
      elementMatches(selector, node) {
        return Polymer.dom.matchesSelector(/** @type {!Element} */ (node || this), selector);
      }

      /**
       * Toggles an HTML attribute on or off.
       *
       * @param {string} name HTML attribute name
       * @param {boolean=} bool Boolean to force the attribute on or off.
       *    When unspecified, the state of the attribute will be reversed.
       * @param {Element=} node Node to target.  Defaults to `this`.
       * @return {void}
       */
      toggleAttribute(name, bool, node) {
        node = /** @type {Element} */ (node || this);
        if (arguments.length == 1) {
          bool = !node.hasAttribute(name);
        }
        if (bool) {
          node.setAttribute(name, '');
        } else {
          node.removeAttribute(name);
        }
      }


      /**
       * Toggles a CSS class on or off.
       *
       * @param {string} name CSS class name
       * @param {boolean=} bool Boolean to force the class on or off.
       *    When unspecified, the state of the class will be reversed.
       * @param {Element=} node Node to target.  Defaults to `this`.
       * @return {void}
       */
      toggleClass(name, bool, node) {
        node = /** @type {Element} */ (node || this);
        if (arguments.length == 1) {
          bool = !node.classList.contains(name);
        }
        if (bool) {
          node.classList.add(name);
        } else {
          node.classList.remove(name);
        }
      }

      /**
       * Cross-platform helper for setting an element's CSS `transform` property.
       *
       * @param {string} transformText Transform setting.
       * @param {Element=} node Element to apply the transform to.
       * Defaults to `this`
       * @return {void}
       */
      transform(transformText, node) {
        node = /** @type {Element} */ (node || this);
        node.style.webkitTransform = transformText;
        node.style.transform = transformText;
      }

      /**
       * Cross-platform helper for setting an element's CSS `translate3d`
       * property.
       *
       * @param {number} x X offset.
       * @param {number} y Y offset.
       * @param {number} z Z offset.
       * @param {Element=} node Element to apply the transform to.
       * Defaults to `this`.
       * @return {void}
       */
      translate3d(x, y, z, node) {
        node = /** @type {Element} */ (node || this);
        this.transform('translate3d(' + x + ',' + y + ',' + z + ')', node);
      }

      /**
       * Removes an item from an array, if it exists.
       *
       * If the array is specified by path, a change notification is
       * generated, so that observers, data bindings and computed
       * properties watching that path can update.
       *
       * If the array is passed directly, **no change
       * notification is generated**.
       *
       * @param {string | !Array<number|string>} arrayOrPath Path to array from which to remove the item
       *   (or the array itself).
       * @param {*} item Item to remove.
       * @return {Array} Array containing item removed.
       */
      arrayDelete(arrayOrPath, item) {
        let index;
        if (Array.isArray(arrayOrPath)) {
          index = arrayOrPath.indexOf(item);
          if (index >= 0) {
            return arrayOrPath.splice(index, 1);
          }
        } else {
          let arr = Polymer.Path.get(this, arrayOrPath);
          index = arr.indexOf(item);
          if (index >= 0) {
            return this.splice(arrayOrPath, index, 1);
          }
        }
        return null;
      }

      // logging

      /**
       * Facades `console.log`/`warn`/`error` as override point.
       *
       * @param {string} level One of 'log', 'warn', 'error'
       * @param {Array} args Array of strings or objects to log
       * @return {void}
       */
      _logger(level, args) {
        // accept ['foo', 'bar'] and [['foo', 'bar']]
        if (Array.isArray(args) && args.length === 1 && Array.isArray(args[0])) {
          args = args[0];
        }
        switch(level) {
          case 'log':
          case 'warn':
          case 'error':
            console[level](...args);
        }
      }

      /**
       * Facades `console.log` as an override point.
       *
       * @param {...*} args Array of strings or objects to log
       * @return {void}
       */
      _log(...args) {
        this._logger('log', args);
      }

      /**
       * Facades `console.warn` as an override point.
       *
       * @param {...*} args Array of strings or objects to log
       * @return {void}
       */
      _warn(...args) {
        this._logger('warn', args);
      }

      /**
       * Facades `console.error` as an override point.
       *
       * @param {...*} args Array of strings or objects to log
       * @return {void}
       */
      _error(...args) {
        this._logger('error', args);
      }

      /**
       * Formats a message using the element type an a method name.
       *
       * @param {string} methodName Method name to associate with message
       * @param {...*} args Array of strings or objects to log
       * @return {Array} Array with formatting information for `console`
       *   logging.
       */
      _logf(methodName, ...args) {
        return ['[%s::%s]', this.is, methodName, ...args];
      }

    }

    LegacyElement.prototype.is = '';

    return LegacyElement;

  });

})();



  (function() {

    'use strict';

    const lifecycleProps = {
      attached: true,
      detached: true,
      ready: true,
      created: true,
      beforeRegister: true,
      registered: true,
      attributeChanged: true,
      listeners: true,
      hostAttributes: true
    };

    const excludeOnInfo = {
      attached: true,
      detached: true,
      ready: true,
      created: true,
      beforeRegister: true,
      registered: true,
      attributeChanged: true,
      behaviors: true,
      _noAccessors: true
    };

    const excludeOnBehaviors = Object.assign({
      listeners: true,
      hostAttributes: true,
      properties: true,
      observers: true,
    }, excludeOnInfo);

    function copyProperties(source, target, excludeProps) {
      const noAccessors = source._noAccessors;
      for (let p in source) {
        if (!(p in excludeProps)) {
          if (noAccessors) {
            target[p] = source[p];
          } else {
            let pd = Object.getOwnPropertyDescriptor(source, p);
            if (pd) {
              // ensure property is configurable so that a later behavior can
              // re-configure it.
              pd.configurable = true;
              Object.defineProperty(target, p, pd);
            }
          }
        }
      }
    }

    /**
     * Applies a "legacy" behavior or array of behaviors to the provided class.
     *
     * Note: this method will automatically also apply the `Polymer.LegacyElementMixin`
     * to ensure that any legacy behaviors can rely on legacy Polymer API on
     * the underlying element.
     *
     * @template T
     * @param {!Object|!Array<!Object>} behaviors Behavior object or array of behaviors.
     * @param {function(new:T)} klass Element class.
     * @return {function(new:T)} Returns a new Element class extended by the
     * passed in `behaviors` and also by `Polymer.LegacyElementMixin`.
     * @memberof Polymer
     * @suppress {invalidCasts, checkTypes}
     */
    function mixinBehaviors(behaviors, klass) {
      return GenerateClassFromInfo({}, Polymer.LegacyElementMixin(klass), behaviors);
    }

    // NOTE:
    // 1.x
    // Behaviors were mixed in *in reverse order* and de-duped on the fly.
    // The rule was that behavior properties were copied onto the element
    // prototype if and only if the property did not already exist.
    // Given: Polymer{ behaviors: [A, B, C, A, B]}, property copy order was:
    // (1), B, (2), A, (3) C. This means prototype properties win over
    // B properties win over A win over C. This mirrors what would happen
    // with inheritance if element extended B extended A extended C.
    //
    // Again given, Polymer{ behaviors: [A, B, C, A, B]}, the resulting
    // `behaviors` array was [C, A, B].
    // Behavior lifecycle methods were called in behavior array order
    // followed by the element, e.g. (1) C.created, (2) A.created,
    // (3) B.created, (4) element.created. There was no support for
    // super, and "super-behavior" methods were callable only by name).
    //
    // 2.x
    // Behaviors are made into proper mixins which live in the
    // element's prototype chain. Behaviors are placed in the element prototype
    // eldest to youngest and de-duped youngest to oldest:
    // So, first [A, B, C, A, B] becomes [C, A, B] then,
    // the element prototype becomes (oldest) (1) Polymer.Element, (2) class(C),
    // (3) class(A), (4) class(B), (5) class(Polymer({...})).
    // Result:
    // This means element properties win over B properties win over A win
    // over C. (same as 1.x)
    // If lifecycle is called (super then me), order is
    // (1) C.created, (2) A.created, (3) B.created, (4) element.created
    // (again same as 1.x)
    function applyBehaviors(proto, behaviors, lifecycle) {
      for (let i=0; i<behaviors.length; i++) {
        applyInfo(proto, behaviors[i], lifecycle, excludeOnBehaviors);
      }
    }

    function applyInfo(proto, info, lifecycle, excludeProps) {
      copyProperties(info, proto, excludeProps);
      for (let p in lifecycleProps) {
        if (info[p]) {
          lifecycle[p] = lifecycle[p] || [];
          lifecycle[p].push(info[p]);
        }
      }
    }

    /**
     * @param {Array} behaviors List of behaviors to flatten.
     * @param {Array=} list Target list to flatten behaviors into.
     * @param {Array=} exclude List of behaviors to exclude from the list.
     * @return {!Array} Returns the list of flattened behaviors.
     */
    function flattenBehaviors(behaviors, list, exclude) {
      list = list || [];
      for (let i=behaviors.length-1; i >= 0; i--) {
        let b = behaviors[i];
        if (b) {
          if (Array.isArray(b)) {
            flattenBehaviors(b, list);
          } else {
            // dedup
            if (list.indexOf(b) < 0 && (!exclude || exclude.indexOf(b) < 0)) {
              list.unshift(b);
            }
          }
        } else {
          console.warn('behavior is null, check for missing or 404 import');
        }
      }
      return list;
    }

    /* Note about construction and extension of legacy classes.
      [Changed in Q4 2018 to optimize performance.]

      When calling `Polymer` or `mixinBehaviors`, the generated class below is
      made. The list of behaviors was previously made into one generated class per
      behavior, but this is no longer the case as behaviors are now called
      manually. Note, there may *still* be multiple generated classes in the
      element's prototype chain if extension is used with `mixinBehaviors`.

      The generated class is directly tied to the info object and behaviors
      used to create it. That list of behaviors is filtered so it's only the
      behaviors not active on the superclass. In order to call through to the
      entire list of lifecycle methods, it's important to call `super`.

      The element's `properties` and `observers` are controlled via the finalization
      mechanism provided by `PropertiesMixin`. `Properties` and `observers` are
      collected by manually traversing the prototype chain and merging.

      To limit changes, the `_registered` method is called via `_initializeProperties`
      and not `_finalizeClass`.
    */
    /**
     * @param {!PolymerInit} info Polymer info object
     * @param {function(new:HTMLElement)} Base base class to extend with info object
     * @param {Object} behaviors behaviors to copy into the element
     * @return {function(new:HTMLElement)} Generated class
     * @suppress {checkTypes}
     * @private
     */
    function GenerateClassFromInfo(info, Base, behaviors) {

      // manages behavior and lifecycle processing (filled in after class definition)
      let behaviorList;
      const lifecycle = {};

      /** @private */
      class PolymerGenerated extends Base {

        // explicitly not calling super._finalizeClass
        static _finalizeClass() {
          // if calling via a subclass that hasn't been generated, pass through to super
          if (!this.hasOwnProperty(window.JSCompiler_renameProperty('generatedFrom', this))) {
            super._finalizeClass();
          } else {
            // interleave properties and observers per behavior and `info`
            if (behaviorList) {
              for (let i=0, b; i < behaviorList.length; i++) {
                b = behaviorList[i];
                if (b.properties) {
                  this.createProperties(b.properties);
                }
                if (b.observers) {
                  this.createObservers(b.observers, b.properties);
                }
              }
            }
            if (info.properties) {
              this.createProperties(info.properties);
            }
            if (info.observers) {
              this.createObservers(info.observers, info.properties);
            }
            // make sure to prepare the element template
            this._prepareTemplate();
          }
        }

        static get properties() {
          const properties = {};
          if (behaviorList) {
            for (let i=0; i < behaviorList.length; i++) {
              Object.assign(properties, behaviorList[i].properties);
            }
          }
          Object.assign(properties, info.properties);
          return properties;
        }

        static get observers() {
          let observers = [];
          if (behaviorList) {
            for (let i=0, b; i < behaviorList.length; i++) {
              b = behaviorList[i];
              if (b.observers) {
                observers = observers.concat(b.observers);
              }
            }
          }
          if (info.observers) {
            observers = observers.concat(info.observers);
          }
          return observers;
        }

        /**
         * @return {void}
         */
        created() {
          super.created();
          const list = lifecycle.created;
          if (list) {
            for (let i=0; i < list.length; i++) {
              list[i].call(this);
            }
          }
        }

        /**
         * @return {void}
         */
        _registered() {
          /* NOTE: `beforeRegister` is called here for bc, but the behavior
            is different than in 1.x. In 1.0, the method was called *after*
            mixing prototypes together but *before* processing of meta-objects.
            However, dynamic effects can still be set here and can be done either
            in `beforeRegister` or `registered`. It is no longer possible to set
            `is` in `beforeRegister` as you could in 1.x.
          */
          // only proceed if the generated class' prototype has not been registered.
          const generatedProto = PolymerGenerated.prototype;
          if (!generatedProto.hasOwnProperty('__hasRegisterFinished')) {
            generatedProto.__hasRegisterFinished = true;
            // ensure superclass is registered first.
            super._registered();
            // copy properties onto the generated class lazily if we're optimizing,
            if (Polymer.legacyOptimizations) {
              copyPropertiesToProto(generatedProto);
            }
            // make sure legacy lifecycle is called on the *element*'s prototype
            // and not the generated class prototype; if the element has been
            // extended, these are *not* the same.
            const proto = Object.getPrototypeOf(this);
            let list = lifecycle.beforeRegister;
            if (list) {
              for (let i=0; i < list.length; i++) {
                list[i].call(proto);
              }
            }
            list = lifecycle.registered;
            if (list) {
              for (let i=0; i < list.length; i++) {
                list[i].call(proto);
              }
            }
          }
        }

        /**
         * @return {void}
         */
        _applyListeners() {
          super._applyListeners();
          const list = lifecycle.listeners;
          if (list) {
            for (let i=0; i < list.length; i++) {
              const listeners = list[i];
              if (listeners) {
                for (let l in listeners) {
                  this._addMethodEventListenerToNode(this, l, listeners[l]);
                }
              }
            }
          }
        }

        // note: exception to "super then me" rule;
        // do work before calling super so that super attributes
        // only apply if not already set.
        /**
         * @return {void}
         */
        _ensureAttributes() {
          const list = lifecycle.hostAttributes;
          if (list) {
            for (let i=list.length-1; i >= 0; i--) {
              const hostAttributes = list[i];
              for (let a in hostAttributes) {
                  this._ensureAttribute(a, hostAttributes[a]);
                }
            }
          }
          super._ensureAttributes();
        }

        /**
         * @return {void}
         */
        ready() {
          super.ready();
          let list = lifecycle.ready;
          if (list) {
            for (let i=0; i < list.length; i++) {
              list[i].call(this);
            }
          }
        }

        /**
         * @return {void}
         */
        attached() {
          super.attached();
          let list = lifecycle.attached;
          if (list) {
            for (let i=0; i < list.length; i++) {
              list[i].call(this);
            }
          }
        }

        /**
         * @return {void}
         */
        detached() {
          super.detached();
          let list = lifecycle.detached;
          if (list) {
            for (let i=0; i < list.length; i++) {
              list[i].call(this);
            }
          }
        }

        /**
         * Implements native Custom Elements `attributeChangedCallback` to
         * set an attribute value to a property via `_attributeToProperty`.
         *
         * @param {string} name Name of attribute that changed
         * @param {?string} old Old attribute value
         * @param {?string} value New attribute value
         * @return {void}
         */
        attributeChanged(name, old, value) {
          super.attributeChanged();
          let list = lifecycle.attributeChanged;
          if (list) {
            for (let i=0; i < list.length; i++) {
              list[i].call(this, name, old, value);
            }
          }
        }
      }

      // apply behaviors, note actual copying is done lazily at first instance creation
      if (behaviors) {
        // NOTE: ensure the behavior is extending a class with
        // legacy element api. This is necessary since behaviors expect to be able
        // to access 1.x legacy api.
        if (!Array.isArray(behaviors)) {
          behaviors = [behaviors];
        }
        let superBehaviors = Base.prototype.behaviors;
        // get flattened, deduped list of behaviors *not* already on super class
        behaviorList = flattenBehaviors(behaviors, null, superBehaviors);
        PolymerGenerated.prototype.behaviors = superBehaviors ?
          superBehaviors.concat(behaviors) : behaviorList;
      }

      const copyPropertiesToProto = (proto) => {
        if (behaviorList) {
          applyBehaviors(proto, behaviorList, lifecycle);
        }
        applyInfo(proto, info, lifecycle, excludeOnInfo);
      };

      // copy properties if we're not optimizing
      if (!Polymer.legacyOptimizations) {
        copyPropertiesToProto(PolymerGenerated.prototype);
      }

      PolymerGenerated.generatedFrom = info;

      return PolymerGenerated;
    }

    /**
     * Generates a class that extends `Polymer.LegacyElement` based on the
     * provided info object.  Metadata objects on the `info` object
     * (`properties`, `observers`, `listeners`, `behaviors`, `is`) are used
     * for Polymer's meta-programming systems, and any functions are copied
     * to the generated class.
     *
     * Valid "metadata" values are as follows:
     *
     * `is`: String providing the tag name to register the element under. In
     * addition, if a `dom-module` with the same id exists, the first template
     * in that `dom-module` will be stamped into the shadow root of this element,
     * with support for declarative event listeners (`on-...`), Polymer data
     * bindings (`[[...]]` and `{{...}}`), and id-based node finding into
     * `this.$`.
     *
     * `properties`: Object describing property-related metadata used by Polymer
     * features (key: property names, value: object containing property metadata).
     * Valid keys in per-property metadata include:
     * - `type` (String|Number|Object|Array|...): Used by
     *   `attributeChangedCallback` to determine how string-based attributes
     *   are deserialized to JavaScript property values.
     * - `notify` (boolean): Causes a change in the property to fire a
     *   non-bubbling event called `<property>-changed`. Elements that have
     *   enabled two-way binding to the property use this event to observe changes.
     * - `readOnly` (boolean): Creates a getter for the property, but no setter.
     *   To set a read-only property, use the private setter method
     *   `_setProperty(property, value)`.
     * - `observer` (string): Observer method name that will be called when
     *   the property changes. The arguments of the method are
     *   `(value, previousValue)`.
     * - `computed` (string): String describing method and dependent properties
     *   for computing the value of this property (e.g. `'computeFoo(bar, zot)'`).
     *   Computed properties are read-only by default and can only be changed
     *   via the return value of the computing method.
     *
     * `observers`: Array of strings describing multi-property observer methods
     *  and their dependent properties (e.g. `'observeABC(a, b, c)'`).
     *
     * `listeners`: Object describing event listeners to be added to each
     *  instance of this element (key: event name, value: method name).
     *
     * `behaviors`: Array of additional `info` objects containing metadata
     * and callbacks in the same format as the `info` object here which are
     * merged into this element.
     *
     * `hostAttributes`: Object listing attributes to be applied to the host
     *  once created (key: attribute name, value: attribute value).  Values
     *  are serialized based on the type of the value.  Host attributes should
     *  generally be limited to attributes such as `tabIndex` and `aria-...`.
     *  Attributes in `hostAttributes` are only applied if a user-supplied
     *  attribute is not already present (attributes in markup override
     *  `hostAttributes`).
     *
     * In addition, the following Polymer-specific callbacks may be provided:
     * - `registered`: called after first instance of this element,
     * - `created`: called during `constructor`
     * - `attached`: called during `connectedCallback`
     * - `detached`: called during `disconnectedCallback`
     * - `ready`: called before first `attached`, after all properties of
     *   this element have been propagated to its template and all observers
     *   have run
     *
     * @param {!PolymerInit} info Object containing Polymer metadata and functions
     *   to become class methods.
     * @template T
     * @param {function(T):T} mixin Optional mixin to apply to legacy base class
     *   before extending with Polymer metaprogramming.
     * @return {function(new:HTMLElement)} Generated class
     * @memberof Polymer
     */
    Polymer.Class = function(info, mixin) {
      if (!info) {
        console.warn('Polymer.Class requires `info` argument');
      }
      let klass = mixin ? mixin(Polymer.LegacyElementMixin(HTMLElement)) :
          Polymer.LegacyElementMixin(HTMLElement);
      klass = GenerateClassFromInfo(info, klass, info.behaviors);
      if (info._enableDisableUpgrade) {
        klass = Polymer.DisableUpgradeMixin(klass);
      }
      // decorate klass with registration info
      klass.is = klass.prototype.is = info.is;
      return klass;
    };

    Polymer.mixinBehaviors = mixinBehaviors;

  })();




  (function() {
    'use strict';

    /**
     * Legacy class factory and registration helper for defining Polymer
     * elements.
     *
     * This method is equivalent to
     * `customElements.define(info.is, Polymer.Class(info));`
     *
     * See `Polymer.Class` for details on valid legacy metadata format for `info`.
     *
     * @global
     * @override
     * @function Polymer
     * @param {!PolymerInit} info Object containing Polymer metadata and functions
     *   to become class methods.
     * @return {function(new: HTMLElement)} Generated class
     * @suppress {duplicate, invalidCasts, checkTypes}
     */
    window.Polymer._polymerFn = function(info) {
      // if input is a `class` (aka a function with a prototype), use the prototype
      // remember that the `constructor` will never be called
      let klass;
      if (typeof info === 'function') {
        klass = info;
      } else {
        klass = Polymer.Class(info);
      }
      customElements.define(klass.is, /** @type {!HTMLElement} */(klass));
      return klass;
    };

  })();



(function() {
  'use strict';

  // Common implementation for mixin & behavior
  function mutablePropertyChange(inst, property, value, old, mutableData) {
    let isObject;
    if (mutableData) {
      isObject = (typeof value === 'object' && value !== null);
      // Pull `old` for Objects from temp cache, but treat `null` as a primitive
      if (isObject) {
        old = inst.__dataTemp[property];
      }
    }
    // Strict equality check, but return false for NaN===NaN
    let shouldChange = (old !== value && (old === old || value === value));
    // Objects are stored in temporary cache (cleared at end of
    // turn), which is used for dirty-checking
    if (isObject && shouldChange) {
      inst.__dataTemp[property] = value;
    }
    return shouldChange;
  }

  /**
   * Element class mixin to skip strict dirty-checking for objects and arrays
   * (always consider them to be "dirty"), for use on elements utilizing
   * `Polymer.PropertyEffects`
   *
   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
   * objects, which means that any deep modifications to an object or array will
   * not be propagated unless "immutable" data patterns are used (i.e. all object
   * references from the root to the mutation were changed).
   *
   * Polymer also provides a proprietary data mutation and path notification API
   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
   * mutation and notification of deep changes in an object graph to all elements
   * bound to the same object graph.
   *
   * In cases where neither immutable patterns nor the data mutation API can be
   * used, applying this mixin will cause Polymer to skip dirty checking for
   * objects and arrays (always consider them to be "dirty").  This allows a
   * user to make a deep modification to a bound object graph, and then either
   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
   * elements that wish to be updated based on deep mutations must apply this
   * mixin or otherwise skip strict dirty checking for objects/arrays.
   * Specifically, any elements in the binding tree between the source of a
   * mutation and the consumption of it must apply this mixin or enable the
   * `Polymer.OptionalMutableData` mixin.
   *
   * In order to make the dirty check strategy configurable, see
   * `Polymer.OptionalMutableData`.
   *
   * Note, the performance characteristics of propagating large object graphs
   * will be worse as opposed to using strict dirty checking with immutable
   * patterns or Polymer's path notification API.
   *
   * @mixinFunction
   * @polymer
   * @memberof Polymer
   * @summary Element class mixin to skip strict dirty-checking for objects
   *   and arrays
   */
  Polymer.MutableData = Polymer.dedupingMixin(superClass => {

    /**
     * @polymer
     * @mixinClass
     * @implements {Polymer_MutableData}
     */
    class MutableData extends superClass {
      /**
       * Overrides `Polymer.PropertyEffects` to provide option for skipping
       * strict equality checking for Objects and Arrays.
       *
       * This method pulls the value to dirty check against from the `__dataTemp`
       * cache (rather than the normal `__data` cache) for Objects.  Since the temp
       * cache is cleared at the end of a turn, this implementation allows
       * side-effects of deep object changes to be processed by re-setting the
       * same object (using the temp cache as an in-turn backstop to prevent
       * cycles due to 2-way notification).
       *
       * @param {string} property Property name
       * @param {*} value New property value
       * @param {*} old Previous property value
       * @return {boolean} Whether the property should be considered a change
       * @protected
       */
      _shouldPropertyChange(property, value, old) {
        return mutablePropertyChange(this, property, value, old, true);
      }

    }

    return MutableData;

  });


  /**
   * Element class mixin to add the optional ability to skip strict
   * dirty-checking for objects and arrays (always consider them to be
   * "dirty") by setting a `mutable-data` attribute on an element instance.
   *
   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
   * objects, which means that any deep modifications to an object or array will
   * not be propagated unless "immutable" data patterns are used (i.e. all object
   * references from the root to the mutation were changed).
   *
   * Polymer also provides a proprietary data mutation and path notification API
   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
   * mutation and notification of deep changes in an object graph to all elements
   * bound to the same object graph.
   *
   * In cases where neither immutable patterns nor the data mutation API can be
   * used, applying this mixin will allow Polymer to skip dirty checking for
   * objects and arrays (always consider them to be "dirty").  This allows a
   * user to make a deep modification to a bound object graph, and then either
   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
   * elements that wish to be updated based on deep mutations must apply this
   * mixin or otherwise skip strict dirty checking for objects/arrays.
   * Specifically, any elements in the binding tree between the source of a
   * mutation and the consumption of it must enable this mixin or apply the
   * `Polymer.MutableData` mixin.
   *
   * While this mixin adds the ability to forgo Object/Array dirty checking,
   * the `mutableData` flag defaults to false and must be set on the instance.
   *
   * Note, the performance characteristics of propagating large object graphs
   * will be worse by relying on `mutableData: true` as opposed to using
   * strict dirty checking with immutable patterns or Polymer's path notification
   * API.
   *
   * @mixinFunction
   * @polymer
   * @memberof Polymer
   * @summary Element class mixin to optionally skip strict dirty-checking
   *   for objects and arrays
   */
  Polymer.OptionalMutableData = Polymer.dedupingMixin(superClass => {

    /**
     * @mixinClass
     * @polymer
     * @implements {Polymer_OptionalMutableData}
     */
    class OptionalMutableData extends superClass {

      static get properties() {
        return {
          /**
           * Instance-level flag for configuring the dirty-checking strategy
           * for this element.  When true, Objects and Arrays will skip dirty
           * checking, otherwise strict equality checking will be used.
           */
          mutableData: Boolean
        };
      }

      /**
       * Overrides `Polymer.PropertyEffects` to provide option for skipping
       * strict equality checking for Objects and Arrays.
       *
       * When `this.mutableData` is true on this instance, this method
       * pulls the value to dirty check against from the `__dataTemp` cache
       * (rather than the normal `__data` cache) for Objects.  Since the temp
       * cache is cleared at the end of a turn, this implementation allows
       * side-effects of deep object changes to be processed by re-setting the
       * same object (using the temp cache as an in-turn backstop to prevent
       * cycles due to 2-way notification).
       *
       * @param {string} property Property name
       * @param {*} value New property value
       * @param {*} old Previous property value
       * @return {boolean} Whether the property should be considered a change
       * @protected
       */
      _shouldPropertyChange(property, value, old) {
        return mutablePropertyChange(this, property, value, old, this.mutableData);
      }
    }

    return OptionalMutableData;

  });

  // Export for use by legacy behavior
  Polymer.MutableData._mutablePropertyChange = mutablePropertyChange;

})();


  (function() {
    'use strict';

    // Base class for HTMLTemplateElement extension that has property effects
    // machinery for propagating host properties to children. This is an ES5
    // class only because Babel (incorrectly) requires super() in the class
    // constructor even though no `this` is used and it returns an instance.
    let newInstance = null;

    /**
     * @constructor
     * @extends {HTMLTemplateElement}
     * @private
     */
    function HTMLTemplateElementExtension() { return newInstance; }
    HTMLTemplateElementExtension.prototype = Object.create(HTMLTemplateElement.prototype, {
      constructor: {
        value: HTMLTemplateElementExtension,
        writable: true
      }
    });

    /**
     * @constructor
     * @implements {Polymer_PropertyEffects}
     * @extends {HTMLTemplateElementExtension}
     * @private
     */
    const DataTemplate = Polymer.PropertyEffects(HTMLTemplateElementExtension);

    /**
     * @constructor
     * @implements {Polymer_MutableData}
     * @extends {DataTemplate}
     * @private
     */
    const MutableDataTemplate = Polymer.MutableData(DataTemplate);

    // Applies a DataTemplate subclass to a <template> instance
    function upgradeTemplate(template, constructor) {
      newInstance = template;
      Object.setPrototypeOf(template, constructor.prototype);
      new constructor();
      newInstance = null;
    }

    /**
     * Base class for TemplateInstance.
     * @constructor
     * @implements {Polymer_PropertyEffects}
     * @private
     */
    const base = Polymer.PropertyEffects(class {});

    /**
     * @polymer
     * @customElement
     * @appliesMixin Polymer.PropertyEffects
     * @unrestricted
     */
    class TemplateInstanceBase extends base {
      constructor(props) {
        super();
        this._configureProperties(props);
        this.root = this._stampTemplate(this.__dataHost);
        // Save list of stamped children
        let children = this.children = [];
        for (let n = this.root.firstChild; n; n=n.nextSibling) {
          children.push(n);
          n.__templatizeInstance = this;
        }
        if (this.__templatizeOwner &&
          this.__templatizeOwner.__hideTemplateChildren__) {
          this._showHideChildren(true);
        }
        // Flush props only when props are passed if instance props exist
        // or when there isn't instance props.
        let options = this.__templatizeOptions;
        if ((props && options.instanceProps) || !options.instanceProps) {
          this._enableProperties();
        }
      }
      /**
       * Configure the given `props` by calling `_setPendingProperty`. Also
       * sets any properties stored in `__hostProps`.
       * @private
       * @param {Object} props Object of property name-value pairs to set.
       * @return {void}
       */
      _configureProperties(props) {
        let options = this.__templatizeOptions;
        if (options.forwardHostProp) {
          for (let hprop in this.__hostProps) {
            this._setPendingProperty(hprop, this.__dataHost['_host_' + hprop]);
          }
        }
        // Any instance props passed in the constructor will overwrite host props;
        // normally this would be a user error but we don't specifically filter them
        for (let iprop in props) {
          this._setPendingProperty(iprop, props[iprop]);
        }
      }
      /**
       * Forwards a host property to this instance.  This method should be
       * called on instances from the `options.forwardHostProp` callback
       * to propagate changes of host properties to each instance.
       *
       * Note this method enqueues the change, which are flushed as a batch.
       *
       * @param {string} prop Property or path name
       * @param {*} value Value of the property to forward
       * @return {void}
       */
      forwardHostProp(prop, value) {
        if (this._setPendingPropertyOrPath(prop, value, false, true)) {
          this.__dataHost._enqueueClient(this);
        }
      }

      /**
       * Override point for adding custom or simulated event handling.
       *
       * @param {!Node} node Node to add event listener to
       * @param {string} eventName Name of event
       * @param {function(!Event):void} handler Listener function to add
       * @return {void}
       */
      _addEventListenerToNode(node, eventName, handler) {
        if (this._methodHost && this.__templatizeOptions.parentModel) {
          // If this instance should be considered a parent model, decorate
          // events this template instance as `model`
          this._methodHost._addEventListenerToNode(node, eventName, (e) => {
            e.model = this;
            handler(e);
          });
        } else {
          // Otherwise delegate to the template's host (which could be)
          // another template instance
          let templateHost = this.__dataHost.__dataHost;
          if (templateHost) {
            templateHost._addEventListenerToNode(node, eventName, handler);
          }
        }
      }
      /**
       * Shows or hides the template instance top level child elements. For
       * text nodes, `textContent` is removed while "hidden" and replaced when
       * "shown."
       * @param {boolean} hide Set to true to hide the children;
       * set to false to show them.
       * @return {void}
       * @protected
       */
      _showHideChildren(hide) {
        let c = this.children;
        for (let i=0; i<c.length; i++) {
          let n = c[i];
          // Ignore non-changes
          if (Boolean(hide) != Boolean(n.__hideTemplateChildren__)) {
            if (n.nodeType === Node.TEXT_NODE) {
              if (hide) {
                n.__polymerTextContent__ = n.textContent;
                n.textContent = '';
              } else {
                n.textContent = n.__polymerTextContent__;
              }
            // remove and replace slot
            } else if (n.localName === 'slot') {
              if (hide) {
                n.__polymerReplaced__ = document.createComment('hidden-slot');
                n.parentNode.replaceChild(n.__polymerReplaced__, n);
              } else {
                const replace = n.__polymerReplaced__;
                if (replace) {
                  replace.parentNode.replaceChild(n, replace);
                }
              }
            }

            else if (n.style) {
              if (hide) {
                n.__polymerDisplay__ = n.style.display;
                n.style.display = 'none';
              } else {
                n.style.display = n.__polymerDisplay__;
              }
            }
          }
          n.__hideTemplateChildren__ = hide;
          if (n._showHideChildren) {
            n._showHideChildren(hide);
          }
        }
      }
      /**
       * Overrides default property-effects implementation to intercept
       * textContent bindings while children are "hidden" and cache in
       * private storage for later retrieval.
       *
       * @param {!Node} node The node to set a property on
       * @param {string} prop The property to set
       * @param {*} value The value to set
       * @return {void}
       * @protected
       */
      _setUnmanagedPropertyToNode(node, prop, value) {
        if (node.__hideTemplateChildren__ &&
            node.nodeType == Node.TEXT_NODE && prop == 'textContent') {
          node.__polymerTextContent__ = value;
        } else {
          super._setUnmanagedPropertyToNode(node, prop, value);
        }
      }
      /**
       * Find the parent model of this template instance.  The parent model
       * is either another templatize instance that had option `parentModel: true`,
       * or else the host element.
       *
       * @return {!Polymer_PropertyEffects} The parent model of this instance
       */
      get parentModel() {
        let model = this.__parentModel;
        if (!model) {
          let options;
          model = this;
          do {
            // A template instance's `__dataHost` is a <template>
            // `model.__dataHost.__dataHost` is the template's host
            model = model.__dataHost.__dataHost;
          } while ((options = model.__templatizeOptions) && !options.parentModel);
          this.__parentModel = model;
        }
        return model;
      }

      /**
       * Stub of HTMLElement's `dispatchEvent`, so that effects that may
       * dispatch events safely no-op.
       *
       * @param {Event} event Event to dispatch
       * @return {boolean} Always true.
       */
       dispatchEvent(event) { // eslint-disable-line no-unused-vars
         return true;
      }
    }

    /** @type {!DataTemplate} */
    TemplateInstanceBase.prototype.__dataHost;
    /** @type {!TemplatizeOptions} */
    TemplateInstanceBase.prototype.__templatizeOptions;
    /** @type {!Polymer_PropertyEffects} */
    TemplateInstanceBase.prototype._methodHost;
    /** @type {!Object} */
    TemplateInstanceBase.prototype.__templatizeOwner;
    /** @type {!Object} */
    TemplateInstanceBase.prototype.__hostProps;

    /**
     * @constructor
     * @extends {TemplateInstanceBase}
     * @implements {Polymer_MutableData}
     * @private
     */
    const MutableTemplateInstanceBase = Polymer.MutableData(TemplateInstanceBase);

    function findMethodHost(template) {
      // Technically this should be the owner of the outermost template.
      // In shadow dom, this is always getRootNode().host, but we can
      // approximate this via cooperation with our dataHost always setting
      // `_methodHost` as long as there were bindings (or id's) on this
      // instance causing it to get a dataHost.
      let templateHost = template.__dataHost;
      return templateHost && templateHost._methodHost || templateHost;
    }

    /* eslint-disable valid-jsdoc */
    /**
     * @suppress {missingProperties} class.prototype is not defined for some reason
     */
    function createTemplatizerClass(template, templateInfo, options) {
      // Anonymous class created by the templatize
      let base = options.mutableData ?
        MutableTemplateInstanceBase : TemplateInstanceBase;
      // Affordance for global mixins onto TemplatizeInstance
      if (Polymer.Templatize.mixin) {
        base = Polymer.Templatize.mixin(base);
      }
      /**
       * @constructor
       * @extends {base}
       * @private
       */
      let klass = class extends base { };
      klass.prototype.__templatizeOptions = options;
      klass.prototype._bindTemplate(template);
      addNotifyEffects(klass, template, templateInfo, options);
      return klass;
    }

    /**
     * @suppress {missingProperties} class.prototype is not defined for some reason
     */
    function addPropagateEffects(template, templateInfo, options) {
      let userForwardHostProp = options.forwardHostProp;
      if (userForwardHostProp) {
        // Provide data API and property effects on memoized template class
        let klass = templateInfo.templatizeTemplateClass;
        if (!klass) {
          let base = options.mutableData ? MutableDataTemplate : DataTemplate;
          /** @private */
          klass = templateInfo.templatizeTemplateClass =
            class TemplatizedTemplate extends base {};
          // Add template - >instances effects
          // and host <- template effects
          let hostProps = templateInfo.hostProps;
          for (let prop in hostProps) {
            klass.prototype._addPropertyEffect('_host_' + prop,
              klass.prototype.PROPERTY_EFFECT_TYPES.PROPAGATE,
              {fn: createForwardHostPropEffect(prop, userForwardHostProp)});
            klass.prototype._createNotifyingProperty('_host_' + prop);
          }
        }
        upgradeTemplate(template, klass);
        // Mix any pre-bound data into __data; no need to flush this to
        // instances since they pull from the template at instance-time
        if (template.__dataProto) {
          // Note, generally `__dataProto` could be chained, but it's guaranteed
          // to not be since this is a vanilla template we just added effects to
          Object.assign(template.__data, template.__dataProto);
        }
        // Clear any pending data for performance
        template.__dataTemp = {};
        template.__dataPending = null;
        template.__dataOld = null;
        template._enableProperties();
      }
    }
    /* eslint-enable valid-jsdoc */

    function createForwardHostPropEffect(hostProp, userForwardHostProp) {
      return function forwardHostProp(template, prop, props) {
        userForwardHostProp.call(template.__templatizeOwner,
          prop.substring('_host_'.length), props[prop]);
      };
    }

    function addNotifyEffects(klass, template, templateInfo, options) {
      let hostProps = templateInfo.hostProps || {};
      for (let iprop in options.instanceProps) {
        delete hostProps[iprop];
        let userNotifyInstanceProp = options.notifyInstanceProp;
        if (userNotifyInstanceProp) {
          klass.prototype._addPropertyEffect(iprop,
            klass.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,
            {fn: createNotifyInstancePropEffect(iprop, userNotifyInstanceProp)});
        }
      }
      if (options.forwardHostProp && template.__dataHost) {
        for (let hprop in hostProps) {
          klass.prototype._addPropertyEffect(hprop,
            klass.prototype.PROPERTY_EFFECT_TYPES.NOTIFY,
            {fn: createNotifyHostPropEffect()});
        }
      }
    }

    function createNotifyInstancePropEffect(instProp, userNotifyInstanceProp) {
      return function notifyInstanceProp(inst, prop, props) {
        userNotifyInstanceProp.call(inst.__templatizeOwner,
          inst, prop, props[prop]);
      };
    }

    function createNotifyHostPropEffect() {
      return function notifyHostProp(inst, prop, props) {
        inst.__dataHost._setPendingPropertyOrPath('_host_' + prop, props[prop], true, true);
      };
    }

    /**
     * Module for preparing and stamping instances of templates that utilize
     * Polymer's data-binding and declarative event listener features.
     *
     * Example:
     *
     *     // Get a template from somewhere, e.g. light DOM
     *     let template = this.querySelector('template');
     *     // Prepare the template
     *     let TemplateClass = Polymer.Templatize.templatize(template);
     *     // Instance the template with an initial data model
     *     let instance = new TemplateClass({myProp: 'initial'});
     *     // Insert the instance's DOM somewhere, e.g. element's shadow DOM
     *     this.shadowRoot.appendChild(instance.root);
     *     // Changing a property on the instance will propagate to bindings
     *     // in the template
     *     instance.myProp = 'new value';
     *
     * The `options` dictionary passed to `templatize` allows for customizing
     * features of the generated template class, including how outer-scope host
     * properties should be forwarded into template instances, how any instance
     * properties added into the template's scope should be notified out to
     * the host, and whether the instance should be decorated as a "parent model"
     * of any event handlers.
     *
     *     // Customize property forwarding and event model decoration
     *     let TemplateClass = Polymer.Templatize.templatize(template, this, {
     *       parentModel: true,
     *       forwardHostProp(property, value) {...},
     *       instanceProps: {...},
     *       notifyInstanceProp(instance, property, value) {...},
     *     });
     *
     * @namespace
     * @memberof Polymer
     * @summary Module for preparing and stamping instances of templates
     *   utilizing Polymer templating features.
     */
    Polymer.Templatize = {

      /**
       * Returns an anonymous `Polymer.PropertyEffects` class bound to the
       * `<template>` provided.  Instancing the class will result in the
       * template being stamped into a document fragment stored as the instance's
       * `root` property, after which it can be appended to the DOM.
       *
       * Templates may utilize all Polymer data-binding features as well as
       * declarative event listeners.  Event listeners and inline computing
       * functions in the template will be called on the host of the template.
       *
       * The constructor returned takes a single argument dictionary of initial
       * property values to propagate into template bindings.  Additionally
       * host properties can be forwarded in, and instance properties can be
       * notified out by providing optional callbacks in the `options` dictionary.
       *
       * Valid configuration in `options` are as follows:
       *
       * - `forwardHostProp(property, value)`: Called when a property referenced
       *   in the template changed on the template's host. As this library does
       *   not retain references to templates instanced by the user, it is the
       *   templatize owner's responsibility to forward host property changes into
       *   user-stamped instances.  The `instance.forwardHostProp(property, value)`
       *    method on the generated class should be called to forward host
       *   properties into the template to prevent unnecessary property-changed
       *   notifications. Any properties referenced in the template that are not
       *   defined in `instanceProps` will be notified up to the template's host
       *   automatically.
       * - `instanceProps`: Dictionary of property names that will be added
       *   to the instance by the templatize owner.  These properties shadow any
       *   host properties, and changes within the template to these properties
       *   will result in `notifyInstanceProp` being called.
       * - `mutableData`: When `true`, the generated class will skip strict
       *   dirty-checking for objects and arrays (always consider them to be
       *   "dirty").
       * - `notifyInstanceProp(instance, property, value)`: Called when
       *   an instance property changes.  Users may choose to call `notifyPath`
       *   on e.g. the owner to notify the change.
       * - `parentModel`: When `true`, events handled by declarative event listeners
       *   (`on-event="handler"`) will be decorated with a `model` property pointing
       *   to the template instance that stamped it.  It will also be returned
       *   from `instance.parentModel` in cases where template instance nesting
       *   causes an inner model to shadow an outer model.
       *
       * All callbacks are called bound to the `owner`. Any context
       * needed for the callbacks (such as references to `instances` stamped)
       * should be stored on the `owner` such that they can be retrieved via
       * `this`.
       *
       * When `options.forwardHostProp` is declared as an option, any properties
       * referenced in the template will be automatically forwarded from the host of
       * the `<template>` to instances, with the exception of any properties listed in
       * the `options.instanceProps` object.  `instanceProps` are assumed to be
       * managed by the owner of the instances, either passed into the constructor
       * or set after the fact.  Note, any properties passed into the constructor will
       * always be set to the instance (regardless of whether they would normally
       * be forwarded from the host).
       *
       * Note that `templatize()` can be run only once for a given `<template>`.
       * Further calls will result in an error. Also, there is a special
       * behavior if the template was duplicated through a mechanism such as
       * `<dom-repeat>` or `<test-fixture>`. In this case, all calls to
       * `templatize()` return the same class for all duplicates of a template.
       * The class returned from `templatize()` is generated only once using
       * the `options` from the first call. This means that any `options`
       * provided to subsequent calls will be ignored. Therefore, it is very
       * important not to close over any variables inside the callbacks. Also,
       * arrow functions must be avoided because they bind the outer `this`.
       * Inside the callbacks, any contextual information can be accessed
       * through `this`, which points to the `owner`.
       *
       * @memberof Polymer.Templatize
       * @param {!HTMLTemplateElement} template Template to templatize
       * @param {Polymer_PropertyEffects=} owner Owner of the template instances;
       *   any optional callbacks will be bound to this owner.
       * @param {Object=} options Options dictionary (see summary for details)
       * @return {function(new:TemplateInstanceBase)} Generated class bound to the template
       *   provided
       * @suppress {invalidCasts}
       */
      templatize(template, owner, options) {
        // Under strictTemplatePolicy, the templatized element must be owned
        // by a (trusted) Polymer element, indicated by existence of _methodHost;
        // e.g. for dom-if & dom-repeat in main document, _methodHost is null
        if (Polymer.strictTemplatePolicy && !findMethodHost(template)) {
          throw new Error('strictTemplatePolicy: template owner not trusted');
        }
        options = /** @type {!TemplatizeOptions} */(options || {});
        if (template.__templatizeOwner) {
          throw new Error('A <template> can only be templatized once');
        }
        template.__templatizeOwner = owner;
        const ctor = owner ? owner.constructor : TemplateInstanceBase;
        let templateInfo = ctor._parseTemplate(template);
        // Get memoized base class for the prototypical template, which
        // includes property effects for binding template & forwarding
        let baseClass = templateInfo.templatizeInstanceClass;
        if (!baseClass) {
          baseClass = createTemplatizerClass(template, templateInfo, options);
          templateInfo.templatizeInstanceClass = baseClass;
        }
        // Host property forwarding must be installed onto template instance
        addPropagateEffects(template, templateInfo, options);
        // Subclass base class and add reference for this specific template
        /** @private */
        let klass = class TemplateInstance extends baseClass {};
        klass.prototype._methodHost = findMethodHost(template);
        klass.prototype.__dataHost = template;
        klass.prototype.__templatizeOwner = owner;
        klass.prototype.__hostProps = templateInfo.hostProps;
        klass = /** @type {function(new:TemplateInstanceBase)} */(klass); //eslint-disable-line no-self-assign
        return klass;
      },

      /**
       * Returns the template "model" associated with a given element, which
       * serves as the binding scope for the template instance the element is
       * contained in. A template model is an instance of
       * `TemplateInstanceBase`, and should be used to manipulate data
       * associated with this template instance.
       *
       * Example:
       *
       *   let model = modelForElement(el);
       *   if (model.index < 10) {
       *     model.set('item.checked', true);
       *   }
       *
       * @memberof Polymer.Templatize
       * @param {HTMLTemplateElement} template The model will be returned for
       *   elements stamped from this template
       * @param {Node=} node Node for which to return a template model.
       * @return {TemplateInstanceBase} Template instance representing the
       *   binding scope for the element
       */
      modelForElement(template, node) {
        let model;
        while (node) {
          // An element with a __templatizeInstance marks the top boundary
          // of a scope; walk up until we find one, and then ensure that
          // its __dataHost matches `this`, meaning this dom-repeat stamped it
          if ((model = node.__templatizeInstance)) {
            // Found an element stamped by another template; keep walking up
            // from its __dataHost
            if (model.__dataHost != template) {
              node = model.__dataHost;
            } else {
              return model;
            }
          } else {
            // Still in a template scope, keep going up until
            // a __templatizeInstance is found
            node = node.parentNode;
          }
        }
        return null;
      }
    };

    Polymer.TemplateInstanceBase = TemplateInstanceBase;

  })();



  (function() {
    'use strict';

    let TemplateInstanceBase = Polymer.TemplateInstanceBase; // eslint-disable-line

    /**
     * @typedef {{
     *   _templatizerTemplate: HTMLTemplateElement,
     *   _parentModel: boolean,
     *   _instanceProps: Object,
     *   _forwardHostPropV2: Function,
     *   _notifyInstancePropV2: Function,
     *   ctor: TemplateInstanceBase
     * }}
     */
    let TemplatizerUser; // eslint-disable-line

    /**
     * The `Polymer.Templatizer` behavior adds methods to generate instances of
     * templates that are each managed by an anonymous `Polymer.PropertyEffects`
     * instance where data-bindings in the stamped template content are bound to
     * accessors on itself.
     *
     * This behavior is provided in Polymer 2.x as a hybrid-element convenience
     * only.  For non-hybrid usage, the `Polymer.Templatize` library
     * should be used instead.
     *
     * Example:
     *
     *     // Get a template from somewhere, e.g. light DOM
     *     let template = this.querySelector('template');
     *     // Prepare the template
     *     this.templatize(template);
     *     // Instance the template with an initial data model
     *     let instance = this.stamp({myProp: 'initial'});
     *     // Insert the instance's DOM somewhere, e.g. light DOM
     *     Polymer.dom(this).appendChild(instance.root);
     *     // Changing a property on the instance will propagate to bindings
     *     // in the template
     *     instance.myProp = 'new value';
     *
     * Users of `Templatizer` may need to implement the following abstract
     * API's to determine how properties and paths from the host should be
     * forwarded into to instances:
     *
     *     _forwardHostPropV2: function(prop, value)
     *
     * Likewise, users may implement these additional abstract API's to determine
     * how instance-specific properties that change on the instance should be
     * forwarded out to the host, if necessary.
     *
     *     _notifyInstancePropV2: function(inst, prop, value)
     *
     * In order to determine which properties are instance-specific and require
     * custom notification via `_notifyInstanceProp`, define an `_instanceProps`
     * object containing keys for each instance prop, for example:
     *
     *     _instanceProps: {
     *       item: true,
     *       index: true
     *     }
     *
     * Any properties used in the template that are not defined in _instanceProp
     * will be forwarded out to the Templatize `owner` automatically.
     *
     * Users may also implement the following abstract function to show or
     * hide any DOM generated using `stamp`:
     *
     *     _showHideChildren: function(shouldHide)
     *
     * Note that some callbacks are suffixed with `V2` in the Polymer 2.x behavior
     * as the implementations will need to differ from the callbacks required
     * by the 1.x Templatizer API due to changes in the `TemplateInstance` API
     * between versions 1.x and 2.x.
     *
     * @polymerBehavior
     */
    Polymer.Templatizer = {

      /**
       * Generates an anonymous `TemplateInstance` class (stored as `this.ctor`)
       * for the provided template.  This method should be called once per
       * template to prepare an element for stamping the template, followed
       * by `stamp` to create new instances of the template.
       *
       * @param {!HTMLTemplateElement} template Template to prepare
       * @param {boolean=} mutableData When `true`, the generated class will skip
       *   strict dirty-checking for objects and arrays (always consider them to
       *   be "dirty"). Defaults to false.
       * @return {void}
       * @this {TemplatizerUser}
       */
      templatize(template, mutableData) {
        this._templatizerTemplate = template;
        this.ctor = Polymer.Templatize.templatize(template, this, {
          mutableData: Boolean(mutableData),
          parentModel: this._parentModel,
          instanceProps: this._instanceProps,
          forwardHostProp: this._forwardHostPropV2,
          notifyInstanceProp: this._notifyInstancePropV2
        });
      },

      /**
       * Creates an instance of the template prepared by `templatize`.  The object
       * returned is an instance of the anonymous class generated by `templatize`
       * whose `root` property is a document fragment containing newly cloned
       * template content, and which has property accessors corresponding to
       * properties referenced in template bindings.
       *
       * @param {Object=} model Object containing initial property values to
       *   populate into the template bindings.
       * @return {TemplateInstanceBase} Returns the created instance of
       * the template prepared by `templatize`.
       * @this {TemplatizerUser}
       */
      stamp(model) {
        return new this.ctor(model);
      },

      /**
       * Returns the template "model" (`TemplateInstance`) associated with
       * a given element, which serves as the binding scope for the template
       * instance the element is contained in.  A template model should be used
       * to manipulate data associated with this template instance.
       *
       * @param {HTMLElement} el Element for which to return a template model.
       * @return {TemplateInstanceBase} Model representing the binding scope for
       *   the element.
       * @this {TemplatizerUser}
       */
      modelForElement(el) {
        return Polymer.Templatize.modelForElement(this._templatizerTemplate, el);
      }
    };

  })();



  (function() {
    'use strict';

    /**
     * @constructor
     * @extends {HTMLElement}
     * @implements {Polymer_PropertyEffects}
     * @implements {Polymer_OptionalMutableData}
     * @implements {Polymer_GestureEventListeners}
     * @private
     */
    const domBindBase =
      Polymer.GestureEventListeners(
        Polymer.OptionalMutableData(
          Polymer.PropertyEffects(HTMLElement)));

    /**
     * Custom element to allow using Polymer's template features (data binding,
     * declarative event listeners, etc.) in the main document without defining
     * a new custom element.
     *
     * `<template>` tags utilizing bindings may be wrapped with the `<dom-bind>`
     * element, which will immediately stamp the wrapped template into the main
     * document and bind elements to the `dom-bind` element itself as the
     * binding scope.
     *
     * @polymer
     * @customElement
     * @appliesMixin Polymer.PropertyEffects
     * @appliesMixin Polymer.OptionalMutableData
     * @appliesMixin Polymer.GestureEventListeners
     * @extends {domBindBase}
     * @memberof Polymer
     * @summary Custom element to allow using Polymer's template features (data
     *   binding, declarative event listeners, etc.) in the main document.
     */
    class DomBind extends domBindBase {

      static get observedAttributes() { return ['mutable-data']; }

      constructor() {
        super();
        if (Polymer.strictTemplatePolicy) {
          throw new Error(`strictTemplatePolicy: dom-bind not allowed`);
        }
        this.root = null;
        this.$ = null;
        this.__children = null;
      }

      /** @return {void} */
      attributeChangedCallback() {
        // assumes only one observed attribute
        this.mutableData = true;
      }

      /** @return {void} */
      connectedCallback() {
        this.style.display = 'none';
        this.render();
      }

      /** @return {void} */
      disconnectedCallback() {
        this.__removeChildren();
      }

      __insertChildren() {
        this.parentNode.insertBefore(this.root, this);
      }

      __removeChildren() {
        if (this.__children) {
          for (let i=0; i<this.__children.length; i++) {
            this.root.appendChild(this.__children[i]);
          }
        }
      }

      /**
       * Forces the element to render its content. This is typically only
       * necessary to call if HTMLImports with the async attribute are used.
       * @return {void}
       */
      render() {
        let template;
        if (!this.__children) {
          template = /** @type {HTMLTemplateElement} */(template || this.querySelector('template'));
          if (!template) {
            // Wait until childList changes and template should be there by then
            let observer = new MutationObserver(() => {
              template = /** @type {HTMLTemplateElement} */(this.querySelector('template'));
              if (template) {
                observer.disconnect();
                this.render();
              } else {
                throw new Error('dom-bind requires a <template> child');
              }
            });
            observer.observe(this, {childList: true});
            return;
          }
          this.root = this._stampTemplate(template);
          this.$ = this.root.$;
          this.__children = [];
          for (let n=this.root.firstChild; n; n=n.nextSibling) {
            this.__children[this.__children.length] = n;
          }
          this._enableProperties();
        }
        this.__insertChildren();
        this.dispatchEvent(new CustomEvent('dom-change', {
          bubbles: true,
          composed: true
        }));
      }

    }

    customElements.define('dom-bind', DomBind);

    /** @const */
    Polymer.DomBind = DomBind;

  })();



  (function() {
    'use strict';

    /**
     * Class representing a static string value which can be used to filter
     * strings by asseting that they have been created via this class. The
     * `value` property returns the string passed to the constructor.
     */
    class LiteralString {
      constructor(string) {
        /** @type {string} */
        this.value = string.toString();
      }
      /**
       * @return {string} LiteralString string value
       */
      toString() {
        return this.value;
      }
    }

    /**
     * @param {*} value Object to stringify into HTML
     * @return {string} HTML stringified form of `obj`
     */
    function literalValue(value) {
      if (value instanceof LiteralString) {
        return /** @type {!LiteralString} */(value).value;
      } else {
        throw new Error(`non-literal value passed to Polymer.htmlLiteral: ${value}`);
      }
    }

    /**
     * @param {*} value Object to stringify into HTML
     * @return {string} HTML stringified form of `obj`
     */
    function htmlValue(value) {
      if (value instanceof HTMLTemplateElement) {
        return /** @type {!HTMLTemplateElement } */(value).innerHTML;
      } else if (value instanceof LiteralString) {
        return literalValue(value);
      } else {
        throw new Error(`non-template value passed to Polymer.html: ${value}`);
      }
    }

    /**
     * A template literal tag that creates an HTML <template> element from the
     * contents of the string.
     *
     * This allows you to write a Polymer Template in JavaScript.
     *
     * Templates can be composed by interpolating `HTMLTemplateElement`s in
     * expressions in the JavaScript template literal. The nested template's
     * `innerHTML` is included in the containing template.  The only other
     * values allowed in expressions are those returned from `Polymer.htmlLiteral`
     * which ensures only literal values from JS source ever reach the HTML, to
     * guard against XSS risks.
     *
     * All other values are disallowed in expressions to help prevent XSS
     * attacks; however, `Polymer.htmlLiteral` can be used to compose static
     * string values into templates. This is useful to compose strings into
     * places that do not accept html, like the css text of a `style`
     * element.
     *
     * Example:
     *
     *     static get template() {
     *       return Polymer.html`
     *         <style>:host{ content:"..." }</style>
     *         <div class="shadowed">${this.partialTemplate}</div>
     *         ${super.template}
     *       `;
     *     }
     *     static get partialTemplate() { return Polymer.html`<span>Partial!</span>`; }
     *
     * @memberof Polymer
     * @param {!ITemplateArray} strings Constant parts of tagged template literal
     * @param {...*} values Variable parts of tagged template literal
     * @return {!HTMLTemplateElement} Constructed HTMLTemplateElement
     */
    Polymer.html = function html(strings, ...values) {
      const template = /** @type {!HTMLTemplateElement} */(document.createElement('template'));
      template.innerHTML = values.reduce((acc, v, idx) =>
          acc + htmlValue(v) + strings[idx + 1], strings[0]);
      return template;
    };

    /**
     * An html literal tag that can be used with `Polymer.html` to compose.
     * a literal string.
     *
     * Example:
     *
     *     static get template() {
     *       return Polymer.html`
     *         <style>
     *           :host { display: block; }
     *           ${styleTemplate}
     *         </style>
     *         <div class="shadowed">${staticValue}</div>
     *         ${super.template}
     *       `;
     *     }
     *     static get styleTemplate() { return Polymer.htmlLiteral`.shadowed { background: gray; }`; }
     *
     * @memberof Polymer
     * @param {!ITemplateArray} strings Constant parts of tagged template literal
     * @param {...*} values Variable parts of tagged template literal
     * @return {!LiteralString} Constructed literal string
     */
    Polymer.htmlLiteral = function(strings, ...values) {
      return new LiteralString(values.reduce((acc, v, idx) =>
          acc + literalValue(v) + strings[idx + 1], strings[0]));
    };
  })();


(function() {
  'use strict';

  /**
   * Base class that provides the core API for Polymer's meta-programming
   * features including template stamping, data-binding, attribute deserialization,
   * and property change observation.
   *
   * @customElement
   * @memberof Polymer
   * @constructor
   * @implements {Polymer_ElementMixin}
   * @extends {HTMLElement}
   * @appliesMixin Polymer.ElementMixin
   * @summary Custom element base class that provides the core API for Polymer's
   *   key meta-programming features including template stamping, data-binding,
   *   attribute deserialization, and property change observation
   */
  Polymer.Element = Polymer.ElementMixin(HTMLElement);

  // NOTE: this is here for modulizer to export `html` for the module version of this file
  Polymer.html = Polymer.html;
})();


(function() {
  'use strict';

  let TemplateInstanceBase = Polymer.TemplateInstanceBase; // eslint-disable-line

  /**
   * @constructor
   * @implements {Polymer_OptionalMutableData}
   * @extends {Polymer.Element}
   * @private
   */
  const domRepeatBase = Polymer.OptionalMutableData(Polymer.Element);

  /**
   * The `<dom-repeat>` element will automatically stamp and binds one instance
   * of template content to each object in a user-provided array.
   * `dom-repeat` accepts an `items` property, and one instance of the template
   * is stamped for each item into the DOM at the location of the `dom-repeat`
   * element.  The `item` property will be set on each instance's binding
   * scope, thus templates should bind to sub-properties of `item`.
   *
   * Example:
   *
   * ```html
   * <dom-module id="employee-list">
   *
   *   <template>
   *
   *     <div> Employee list: </div>
   *     <dom-repeat items="{{employees}}">
   *       <template>
   *         <div>First name: <span>{{item.first}}</span></div>
   *         <div>Last name: <span>{{item.last}}</span></div>
   *       </template>
   *     </dom-repeat>
   *
   *   </template>
   *
   * </dom-module>
   * ```
   *
   * With the following custom element definition:
   *
   * ```js
   * class EmployeeList extends Polymer.Element {
   *   static get is() { return 'employee-list'; }
   *   static get properties() {
   *     return {
   *       employees: {
   *         value() {
   *           return [
   *             {first: 'Bob', last: 'Smith'},
   *             {first: 'Sally', last: 'Johnson'},
   *             ...
   *           ];
   *         }
   *       }
   *     };
   *   }
   * }
   * ```
   *
   * Notifications for changes to items sub-properties will be forwarded to template
   * instances, which will update via the normal structured data notification system.
   *
   * Mutations to the `items` array itself should be made using the Array
   * mutation API's on `Polymer.Base` (`push`, `pop`, `splice`, `shift`,
   * `unshift`), and template instances will be kept in sync with the data in the
   * array.
   *
   * Events caught by event handlers within the `dom-repeat` template will be
   * decorated with a `model` property, which represents the binding scope for
   * each template instance.  The model is an instance of Polymer.Base, and should
   * be used to manipulate data on the instance, for example
   * `event.model.set('item.checked', true);`.
   *
   * Alternatively, the model for a template instance for an element stamped by
   * a `dom-repeat` can be obtained using the `modelForElement` API on the
   * `dom-repeat` that stamped it, for example
   * `this.$.domRepeat.modelForElement(event.target).set('item.checked', true);`.
   * This may be useful for manipulating instance data of event targets obtained
   * by event handlers on parents of the `dom-repeat` (event delegation).
   *
   * A view-specific filter/sort may be applied to each `dom-repeat` by supplying a
   * `filter` and/or `sort` property.  This may be a string that names a function on
   * the host, or a function may be assigned to the property directly.  The functions
   * should implemented following the standard `Array` filter/sort API.
   *
   * In order to re-run the filter or sort functions based on changes to sub-fields
   * of `items`, the `observe` property may be set as a space-separated list of
   * `item` sub-fields that should cause a re-filter/sort when modified.  If
   * the filter or sort function depends on properties not contained in `items`,
   * the user should observe changes to those properties and call `render` to update
   * the view based on the dependency change.
   *
   * For example, for an `dom-repeat` with a filter of the following:
   *
   * ```js
   * isEngineer(item) {
   *   return item.type == 'engineer' || item.manager.type == 'engineer';
   * }
   * ```
   *
   * Then the `observe` property should be configured as follows:
   *
   * ```html
   * <dom-repeat items="{{employees}}" filter="isEngineer" observe="type manager.type">
   * ```
   *
   * @customElement
   * @polymer
   * @memberof Polymer
   * @extends {domRepeatBase}
   * @appliesMixin Polymer.OptionalMutableData
   * @summary Custom element for stamping instance of a template bound to
   *   items in an array.
   */
  class DomRepeat extends domRepeatBase {

    // Not needed to find template; can be removed once the analyzer
    // can find the tag name from customElements.define call
    static get is() { return 'dom-repeat'; }

    static get template() { return null; }

    static get properties() {

      /**
       * Fired whenever DOM is added or removed by this template (by
       * default, rendering occurs lazily).  To force immediate rendering, call
       * `render`.
       *
       * @event dom-change
       */
      return {

        /**
         * An array containing items determining how many instances of the template
         * to stamp and that that each template instance should bind to.
         */
        items: {
          type: Array
        },

        /**
         * The name of the variable to add to the binding scope for the array
         * element associated with a given template instance.
         */
        as: {
          type: String,
          value: 'item'
        },

        /**
         * The name of the variable to add to the binding scope with the index
         * of the instance in the sorted and filtered list of rendered items.
         * Note, for the index in the `this.items` array, use the value of the
         * `itemsIndexAs` property.
         */
        indexAs: {
          type: String,
          value: 'index'
        },

        /**
         * The name of the variable to add to the binding scope with the index
         * of the instance in the `this.items` array. Note, for the index of
         * this instance in the sorted and filtered list of rendered items,
         * use the value of the `indexAs` property.
         */
        itemsIndexAs: {
          type: String,
          value: 'itemsIndex'
        },

        /**
         * A function that should determine the sort order of the items.  This
         * property should either be provided as a string, indicating a method
         * name on the element's host, or else be an actual function.  The
         * function should match the sort function passed to `Array.sort`.
         * Using a sort function has no effect on the underlying `items` array.
         */
        sort: {
          type: Function,
          observer: '__sortChanged'
        },

        /**
         * A function that can be used to filter items out of the view.  This
         * property should either be provided as a string, indicating a method
         * name on the element's host, or else be an actual function.  The
         * function should match the sort function passed to `Array.filter`.
         * Using a filter function has no effect on the underlying `items` array.
         */
        filter: {
          type: Function,
          observer: '__filterChanged'
        },

        /**
         * When using a `filter` or `sort` function, the `observe` property
         * should be set to a space-separated list of the names of item
         * sub-fields that should trigger a re-sort or re-filter when changed.
         * These should generally be fields of `item` that the sort or filter
         * function depends on.
         */
        observe: {
          type: String,
          observer: '__observeChanged'
        },

        /**
         * When using a `filter` or `sort` function, the `delay` property
         * determines a debounce time in ms after a change to observed item
         * properties that must pass before the filter or sort is re-run.
         * This is useful in rate-limiting shuffling of the view when
         * item changes may be frequent.
         */
        delay: Number,

        /**
         * Count of currently rendered items after `filter` (if any) has been applied.
         * If "chunking mode" is enabled, `renderedItemCount` is updated each time a
         * set of template instances is rendered.
         *
         */
        renderedItemCount: {
          type: Number,
          notify: true,
          readOnly: true
        },

        /**
         * Defines an initial count of template instances to render after setting
         * the `items` array, before the next paint, and puts the `dom-repeat`
         * into "chunking mode".  The remaining items will be created and rendered
         * incrementally at each animation frame therof until all instances have
         * been rendered.
         */
        initialCount: {
          type: Number,
          observer: '__initializeChunking'
        },

        /**
         * When `initialCount` is used, this property defines a frame rate (in
         * fps) to target by throttling the number of instances rendered each
         * frame to not exceed the budget for the target frame rate.  The
         * framerate is effectively the number of `requestAnimationFrame`s that
         * it tries to allow to actually fire in a given second. It does this
         * by measuring the time between `rAF`s and continuously adjusting the
         * number of items created each `rAF` to maintain the target framerate.
         * Setting this to a higher number allows lower latency and higher
         * throughput for event handlers and other tasks, but results in a
         * longer time for the remaining items to complete rendering.
         */
        targetFramerate: {
          type: Number,
          value: 20
        },

        _targetFrameTime: {
          type: Number,
          computed: '__computeFrameTime(targetFramerate)'
        }

      };

    }

    static get observers() {
      return [ '__itemsChanged(items.*)' ];
    }

    constructor() {
      super();
      this.__instances = [];
      this.__limit = Infinity;
      this.__pool = [];
      this.__renderDebouncer = null;
      this.__itemsIdxToInstIdx = {};
      this.__chunkCount = null;
      this.__lastChunkTime = null;
      this.__sortFn = null;
      this.__filterFn = null;
      this.__observePaths = null;
      this.__ctor = null;
      this.__isDetached = true;
      this.template = null;
    }

    /**
     * @return {void}
     */
    disconnectedCallback() {
      super.disconnectedCallback();
      this.__isDetached = true;
      for (let i=0; i<this.__instances.length; i++) {
        this.__detachInstance(i);
      }
    }

    /**
     * @return {void}
     */
    connectedCallback() {
      super.connectedCallback();
      this.style.display = 'none';
      // only perform attachment if the element was previously detached.
      if (this.__isDetached) {
        this.__isDetached = false;
        let parent = this.parentNode;
        for (let i=0; i<this.__instances.length; i++) {
          this.__attachInstance(i, parent);
        }
      }
    }

    __ensureTemplatized() {
      // Templatizing (generating the instance constructor) needs to wait
      // until ready, since won't have its template content handed back to
      // it until then
      if (!this.__ctor) {
        let template = this.template = /** @type {HTMLTemplateElement} */(this.querySelector('template'));
        if (!template) {
          // // Wait until childList changes and template should be there by then
          let observer = new MutationObserver(() => {
            if (this.querySelector('template')) {
              observer.disconnect();
              this.__render();
            } else {
              throw new Error('dom-repeat requires a <template> child');
            }
          });
          observer.observe(this, {childList: true});
          return false;
        }
        // Template instance props that should be excluded from forwarding
        let instanceProps = {};
        instanceProps[this.as] = true;
        instanceProps[this.indexAs] = true;
        instanceProps[this.itemsIndexAs] = true;
        this.__ctor = Polymer.Templatize.templatize(template, this, {
          mutableData: this.mutableData,
          parentModel: true,
          instanceProps: instanceProps,
          /**
           * @this {this}
           * @param {string} prop Property to set
           * @param {*} value Value to set property to
           */
          forwardHostProp: function(prop, value) {
            let i$ = this.__instances;
            for (let i=0, inst; (i<i$.length) && (inst=i$[i]); i++) {
              inst.forwardHostProp(prop, value);
            }
          },
          /**
           * @this {this}
           * @param {Object} inst Instance to notify
           * @param {string} prop Property to notify
           * @param {*} value Value to notify
           */
          notifyInstanceProp: function(inst, prop, value) {
            if (Polymer.Path.matches(this.as, prop)) {
              let idx = inst[this.itemsIndexAs];
              if (prop == this.as) {
                this.items[idx] = value;
              }
              let path = Polymer.Path.translate(this.as, 'items.' + idx, prop);
              this.notifyPath(path, value);
            }
          }
        });
      }
      return true;
    }

    __getMethodHost() {
      // Technically this should be the owner of the outermost template.
      // In shadow dom, this is always getRootNode().host, but we can
      // approximate this via cooperation with our dataHost always setting
      // `_methodHost` as long as there were bindings (or id's) on this
      // instance causing it to get a dataHost.
      return this.__dataHost._methodHost || this.__dataHost;
    }

    __functionFromPropertyValue(functionOrMethodName) {
      if (typeof functionOrMethodName === 'string') {
        let methodName = functionOrMethodName;
        let obj = this.__getMethodHost();
        return function() { return obj[methodName].apply(obj, arguments); };
      }

      return functionOrMethodName;
    }

    __sortChanged(sort) {
      this.__sortFn = this.__functionFromPropertyValue(sort);
      if (this.items) { this.__debounceRender(this.__render); }
    }

    __filterChanged(filter) {
      this.__filterFn = this.__functionFromPropertyValue(filter);
      if (this.items) { this.__debounceRender(this.__render); }
    }

    __computeFrameTime(rate) {
      return Math.ceil(1000/rate);
    }

    __initializeChunking() {
      if (this.initialCount) {
        this.__limit = this.initialCount;
        this.__chunkCount = this.initialCount;
        this.__lastChunkTime = performance.now();
      }
    }

    __tryRenderChunk() {
      // Debounced so that multiple calls through `_render` between animation
      // frames only queue one new rAF (e.g. array mutation & chunked render)
      if (this.items && this.__limit < this.items.length) {
        this.__debounceRender(this.__requestRenderChunk);
      }
    }

    __requestRenderChunk() {
      requestAnimationFrame(()=>this.__renderChunk());
    }

    __renderChunk() {
      // Simple auto chunkSize throttling algorithm based on feedback loop:
      // measure actual time between frames and scale chunk count by ratio
      // of target/actual frame time
      let currChunkTime = performance.now();
      let ratio = this._targetFrameTime / (currChunkTime - this.__lastChunkTime);
      this.__chunkCount = Math.round(this.__chunkCount * ratio) || 1;
      this.__limit += this.__chunkCount;
      this.__lastChunkTime = currChunkTime;
      this.__debounceRender(this.__render);
    }

    __observeChanged() {
      this.__observePaths = this.observe &&
        this.observe.replace('.*', '.').split(' ');
    }

    __itemsChanged(change) {
      if (this.items && !Array.isArray(this.items)) {
        console.warn('dom-repeat expected array for `items`, found', this.items);
      }
      // If path was to an item (e.g. 'items.3' or 'items.3.foo'), forward the
      // path to that instance synchronously (returns false for non-item paths)
      if (!this.__handleItemPath(change.path, change.value)) {
        // Otherwise, the array was reset ('items') or spliced ('items.splices'),
        // so queue a full refresh
        this.__initializeChunking();
        this.__debounceRender(this.__render);
      }
    }

    __handleObservedPaths(path) {
      // Handle cases where path changes should cause a re-sort/filter
      if (this.__sortFn || this.__filterFn) {
        if (!path) {
          // Always re-render if the item itself changed
          this.__debounceRender(this.__render, this.delay);
        } else if (this.__observePaths) {
          // Otherwise, re-render if the path changed matches an observed path
          let paths = this.__observePaths;
          for (let i=0; i<paths.length; i++) {
            if (path.indexOf(paths[i]) === 0) {
              this.__debounceRender(this.__render, this.delay);
            }
          }
        }
      }
    }

    /**
     * @param {function(this:DomRepeat)} fn Function to debounce.
     * @param {number=} delay Delay in ms to debounce by.
     */
    __debounceRender(fn, delay = 0) {
      this.__renderDebouncer = Polymer.Debouncer.debounce(
            this.__renderDebouncer
          , delay > 0 ? Polymer.Async.timeOut.after(delay) : Polymer.Async.microTask
          , fn.bind(this));
      Polymer.enqueueDebouncer(this.__renderDebouncer);
    }

    /**
     * Forces the element to render its content. Normally rendering is
     * asynchronous to a provoking change. This is done for efficiency so
     * that multiple changes trigger only a single render. The render method
     * should be called if, for example, template rendering is required to
     * validate application state.
     * @return {void}
     */
    render() {
      // Queue this repeater, then flush all in order
      this.__debounceRender(this.__render);
      Polymer.flush();
    }

    __render() {
      if (!this.__ensureTemplatized()) {
        // No template found yet
        return;
      }
      this.__applyFullRefresh();
      // Reset the pool
      // TODO(kschaaf): Reuse pool across turns and nested templates
      // Now that objects/arrays are re-evaluated when set, we can safely
      // reuse pooled instances across turns, however we still need to decide
      // semantics regarding how long to hold, how many to hold, etc.
      this.__pool.length = 0;
      // Set rendered item count
      this._setRenderedItemCount(this.__instances.length);
      // Notify users
      this.dispatchEvent(new CustomEvent('dom-change', {
        bubbles: true,
        composed: true
      }));
      // Check to see if we need to render more items
      this.__tryRenderChunk();
    }

    __applyFullRefresh() {
      let items = this.items || [];
      let isntIdxToItemsIdx = new Array(items.length);
      for (let i=0; i<items.length; i++) {
        isntIdxToItemsIdx[i] = i;
      }
      // Apply user filter
      if (this.__filterFn) {
        isntIdxToItemsIdx = isntIdxToItemsIdx.filter((i, idx, array) =>
          this.__filterFn(items[i], idx, array));
      }
      // Apply user sort
      if (this.__sortFn) {
        isntIdxToItemsIdx.sort((a, b) => this.__sortFn(items[a], items[b]));
      }
      // items->inst map kept for item path forwarding
      const itemsIdxToInstIdx = this.__itemsIdxToInstIdx = {};
      let instIdx = 0;
      // Generate instances and assign items
      const limit = Math.min(isntIdxToItemsIdx.length, this.__limit);
      for (; instIdx<limit; instIdx++) {
        let inst = this.__instances[instIdx];
        let itemIdx = isntIdxToItemsIdx[instIdx];
        let item = items[itemIdx];
        itemsIdxToInstIdx[itemIdx] = instIdx;
        if (inst) {
          inst._setPendingProperty(this.as, item);
          inst._setPendingProperty(this.indexAs, instIdx);
          inst._setPendingProperty(this.itemsIndexAs, itemIdx);
          inst._flushProperties();
        } else {
          this.__insertInstance(item, instIdx, itemIdx);
        }
      }
      // Remove any extra instances from previous state
      for (let i=this.__instances.length-1; i>=instIdx; i--) {
        this.__detachAndRemoveInstance(i);
      }
    }

    __detachInstance(idx) {
      let inst = this.__instances[idx];
      for (let i=0; i<inst.children.length; i++) {
        let el = inst.children[i];
        inst.root.appendChild(el);
      }
      return inst;
    }

    __attachInstance(idx, parent) {
      let inst = this.__instances[idx];
      parent.insertBefore(inst.root, this);
    }

    __detachAndRemoveInstance(idx) {
      let inst = this.__detachInstance(idx);
      if (inst) {
        this.__pool.push(inst);
      }
      this.__instances.splice(idx, 1);
    }

    __stampInstance(item, instIdx, itemIdx) {
      let model = {};
      model[this.as] = item;
      model[this.indexAs] = instIdx;
      model[this.itemsIndexAs] = itemIdx;
      return new this.__ctor(model);
    }

    __insertInstance(item, instIdx, itemIdx) {
      let inst = this.__pool.pop();
      if (inst) {
        // TODO(kschaaf): If the pool is shared across turns, hostProps
        // need to be re-set to reused instances in addition to item
        inst._setPendingProperty(this.as, item);
        inst._setPendingProperty(this.indexAs, instIdx);
        inst._setPendingProperty(this.itemsIndexAs, itemIdx);
        inst._flushProperties();
      } else {
        inst = this.__stampInstance(item, instIdx, itemIdx);
      }
      let beforeRow = this.__instances[instIdx + 1];
      let beforeNode = beforeRow ? beforeRow.children[0] : this;
      this.parentNode.insertBefore(inst.root, beforeNode);
      this.__instances[instIdx] = inst;
      return inst;
    }

    // Implements extension point from Templatize mixin
    /**
     * Shows or hides the template instance top level child elements. For
     * text nodes, `textContent` is removed while "hidden" and replaced when
     * "shown."
     * @param {boolean} hidden Set to true to hide the children;
     * set to false to show them.
     * @return {void}
     * @protected
     */
    _showHideChildren(hidden) {
      for (let i=0; i<this.__instances.length; i++) {
        this.__instances[i]._showHideChildren(hidden);
      }
    }

    // Called as a side effect of a host items.<key>.<path> path change,
    // responsible for notifying item.<path> changes to inst for key
    __handleItemPath(path, value) {
      let itemsPath = path.slice(6); // 'items.'.length == 6
      let dot = itemsPath.indexOf('.');
      let itemsIdx = dot < 0 ? itemsPath : itemsPath.substring(0, dot);
      // If path was index into array...
      if (itemsIdx == parseInt(itemsIdx, 10)) {
        let itemSubPath = dot < 0 ? '' : itemsPath.substring(dot+1);
        // If the path is observed, it will trigger a full refresh
        this.__handleObservedPaths(itemSubPath);
        // Note, even if a rull refresh is triggered, always do the path
        // notification because unless mutableData is used for dom-repeat
        // and all elements in the instance subtree, a full refresh may
        // not trigger the proper update.
        let instIdx = this.__itemsIdxToInstIdx[itemsIdx];
        let inst = this.__instances[instIdx];
        if (inst) {
          let itemPath = this.as + (itemSubPath ? '.' + itemSubPath : '');
          // This is effectively `notifyPath`, but avoids some of the overhead
          // of the public API
          inst._setPendingPropertyOrPath(itemPath, value, false, true);
          inst._flushProperties();
        }
        return true;
      }
    }

    /**
     * Returns the item associated with a given element stamped by
     * this `dom-repeat`.
     *
     * Note, to modify sub-properties of the item,
     * `modelForElement(el).set('item.<sub-prop>', value)`
     * should be used.
     *
     * @param {!HTMLElement} el Element for which to return the item.
     * @return {*} Item associated with the element.
     */
    itemForElement(el) {
      let instance = this.modelForElement(el);
      return instance && instance[this.as];
    }

    /**
     * Returns the inst index for a given element stamped by this `dom-repeat`.
     * If `sort` is provided, the index will reflect the sorted order (rather
     * than the original array order).
     *
     * @param {!HTMLElement} el Element for which to return the index.
     * @return {?number} Row index associated with the element (note this may
     *   not correspond to the array index if a user `sort` is applied).
     */
    indexForElement(el) {
      let instance = this.modelForElement(el);
      return instance && instance[this.indexAs];
    }

    /**
     * Returns the template "model" associated with a given element, which
     * serves as the binding scope for the template instance the element is
     * contained in. A template model is an instance of `Polymer.Base`, and
     * should be used to manipulate data associated with this template instance.
     *
     * Example:
     *
     *   let model = modelForElement(el);
     *   if (model.index < 10) {
     *     model.set('item.checked', true);
     *   }
     *
     * @param {!HTMLElement} el Element for which to return a template model.
     * @return {TemplateInstanceBase} Model representing the binding scope for
     *   the element.
     */
    modelForElement(el) {
      return Polymer.Templatize.modelForElement(this.template, el);
    }

  }

  customElements.define(DomRepeat.is, DomRepeat);

  /** @const */
  Polymer.DomRepeat = DomRepeat;

})();




(function() {
  'use strict';

  /**
   * The `<dom-if>` element will stamp a light-dom `<template>` child when
   * the `if` property becomes truthy, and the template can use Polymer
   * data-binding and declarative event features when used in the context of
   * a Polymer element's template.
   *
   * When `if` becomes falsy, the stamped content is hidden but not
   * removed from dom. When `if` subsequently becomes truthy again, the content
   * is simply re-shown. This approach is used due to its favorable performance
   * characteristics: the expense of creating template content is paid only
   * once and lazily.
   *
   * Set the `restamp` property to true to force the stamped content to be
   * created / destroyed when the `if` condition changes.
   *
   * @customElement
   * @polymer
   * @extends Polymer.Element
   * @memberof Polymer
   * @summary Custom element that conditionally stamps and hides or removes
   *   template content based on a boolean flag.
   */
  class DomIf extends Polymer.Element {

    // Not needed to find template; can be removed once the analyzer
    // can find the tag name from customElements.define call
    static get is() { return 'dom-if'; }

    static get template() { return null; }

    static get properties() {

      return {

        /**
         * Fired whenever DOM is added or removed/hidden by this template (by
         * default, rendering occurs lazily).  To force immediate rendering, call
         * `render`.
         *
         * @event dom-change
         */

        /**
         * A boolean indicating whether this template should stamp.
         */
        if: {
          type: Boolean,
          observer: '__debounceRender'
        },

        /**
         * When true, elements will be removed from DOM and discarded when `if`
         * becomes false and re-created and added back to the DOM when `if`
         * becomes true.  By default, stamped elements will be hidden but left
         * in the DOM when `if` becomes false, which is generally results
         * in better performance.
         */
        restamp: {
          type: Boolean,
          observer: '__debounceRender'
        }

      };

    }

    constructor() {
      super();
      this.__renderDebouncer = null;
      this.__invalidProps = null;
      this.__instance = null;
      this._lastIf = false;
      this.__ctor = null;
    }

    __debounceRender() {
      // Render is async for 2 reasons:
      // 1. To eliminate dom creation trashing if user code thrashes `if` in the
      //    same turn. This was more common in 1.x where a compound computed
      //    property could result in the result changing multiple times, but is
      //    mitigated to a large extent by batched property processing in 2.x.
      // 2. To avoid double object propagation when a bag including values bound
      //    to the `if` property as well as one or more hostProps could enqueue
      //    the <dom-if> to flush before the <template>'s host property
      //    forwarding. In that scenario creating an instance would result in
      //    the host props being set once, and then the enqueued changes on the
      //    template would set properties a second time, potentially causing an
      //    object to be set to an instance more than once.  Creating the
      //    instance async from flushing data ensures this doesn't happen. If
      //    we wanted a sync option in the future, simply having <dom-if> flush
      //    (or clear) its template's pending host properties before creating
      //    the instance would also avoid the problem.
      this.__renderDebouncer = Polymer.Debouncer.debounce(
            this.__renderDebouncer
          , Polymer.Async.microTask
          , () => this.__render());
      Polymer.enqueueDebouncer(this.__renderDebouncer);
    }

    /**
     * @return {void}
     */
    disconnectedCallback() {
      super.disconnectedCallback();
      if (!this.parentNode ||
          (this.parentNode.nodeType == Node.DOCUMENT_FRAGMENT_NODE &&
           !this.parentNode.host)) {
        this.__teardownInstance();
      }
    }

    /**
     * @return {void}
     */
    connectedCallback() {
      super.connectedCallback();
      this.style.display = 'none';
      if (this.if) {
        this.__debounceRender();
      }
    }

    /**
     * Forces the element to render its content. Normally rendering is
     * asynchronous to a provoking change. This is done for efficiency so
     * that multiple changes trigger only a single render. The render method
     * should be called if, for example, template rendering is required to
     * validate application state.
     * @return {void}
     */
    render() {
      Polymer.flush();
    }

    __render() {
      if (this.if) {
        if (!this.__ensureInstance()) {
          // No template found yet
          return;
        }
        this._showHideChildren();
      } else if (this.restamp) {
        this.__teardownInstance();
      }
      if (!this.restamp && this.__instance) {
        this._showHideChildren();
      }
      if (this.if != this._lastIf) {
        this.dispatchEvent(new CustomEvent('dom-change', {
          bubbles: true,
          composed: true
        }));
        this._lastIf = this.if;
      }
    }

    __ensureInstance() {
      let parentNode = this.parentNode;
      // Guard against element being detached while render was queued
      if (parentNode) {
        if (!this.__ctor) {
          let template = /** @type {HTMLTemplateElement} */(this.querySelector('template'));
          if (!template) {
            // Wait until childList changes and template should be there by then
            let observer = new MutationObserver(() => {
              if (this.querySelector('template')) {
                observer.disconnect();
                this.__render();
              } else {
                throw new Error('dom-if requires a <template> child');
              }
            });
            observer.observe(this, {childList: true});
            return false;
          }
          this.__ctor = Polymer.Templatize.templatize(template, this, {
            // dom-if templatizer instances require `mutable: true`, as
            // `__syncHostProperties` relies on that behavior to sync objects
            mutableData: true,
            /**
             * @param {string} prop Property to forward
             * @param {*} value Value of property
             * @this {this}
             */
            forwardHostProp: function(prop, value) {
              if (this.__instance) {
                if (this.if) {
                  this.__instance.forwardHostProp(prop, value);
                } else {
                  // If we have an instance but are squelching host property
                  // forwarding due to if being false, note the invalidated
                  // properties so `__syncHostProperties` can sync them the next
                  // time `if` becomes true
                  this.__invalidProps = this.__invalidProps || Object.create(null);
                  this.__invalidProps[Polymer.Path.root(prop)] = true;
                }
              }
            }
          });
        }
        if (!this.__instance) {
          this.__instance = new this.__ctor();
          parentNode.insertBefore(this.__instance.root, this);
        } else {
          this.__syncHostProperties();
          let c$ = this.__instance.children;
          if (c$ && c$.length) {
            // Detect case where dom-if was re-attached in new position
            let lastChild = this.previousSibling;
            if (lastChild !== c$[c$.length-1]) {
              for (let i=0, n; (i<c$.length) && (n=c$[i]); i++) {
                parentNode.insertBefore(n, this);
              }
            }
          }
        }
      }
      return true;
    }

    __syncHostProperties() {
      let props = this.__invalidProps;
      if (props) {
        for (let prop in props) {
          this.__instance._setPendingProperty(prop, this.__dataHost[prop]);
        }
        this.__invalidProps = null;
        this.__instance._flushProperties();
      }
    }

    __teardownInstance() {
      if (this.__instance) {
        let c$ = this.__instance.children;
        if (c$ && c$.length) {
          // use first child parent, for case when dom-if may have been detached
          let parent = c$[0].parentNode;
          // Instance children may be disconnected from parents when dom-if
          // detaches if a tree was innerHTML'ed
          if (parent) {
            for (let i=0, n; (i<c$.length) && (n=c$[i]); i++) {
              parent.removeChild(n);
            }
          }
        }
        this.__instance = null;
        this.__invalidProps = null;
      }
    }

    /**
     * Shows or hides the template instance top level child elements. For
     * text nodes, `textContent` is removed while "hidden" and replaced when
     * "shown."
     * @return {void}
     * @protected
     */
    _showHideChildren() {
      let hidden = this.__hideTemplateChildren__ || !this.if;
      if (this.__instance) {
        this.__instance._showHideChildren(hidden);
      }
    }

  }

  customElements.define(DomIf.is, DomIf);

  /** @const */
  Polymer.DomIf = DomIf;

})();


(function() {
  'use strict';

  /**
   * Element mixin for recording dynamic associations between item paths in a
   * master `items` array and a `selected` array such that path changes to the
   * master array (at the host) element or elsewhere via data-binding) are
   * correctly propagated to items in the selected array and vice-versa.
   *
   * The `items` property accepts an array of user data, and via the
   * `select(item)` and `deselect(item)` API, updates the `selected` property
   * which may be bound to other parts of the application, and any changes to
   * sub-fields of `selected` item(s) will be kept in sync with items in the
   * `items` array.  When `multi` is false, `selected` is a property
   * representing the last selected item.  When `multi` is true, `selected`
   * is an array of multiply selected items.
   *
   * @polymer
   * @mixinFunction
   * @appliesMixin Polymer.ElementMixin
   * @memberof Polymer
   * @summary Element mixin for recording dynamic associations between item paths in a
   * master `items` array and a `selected` array
   */
  let ArraySelectorMixin = Polymer.dedupingMixin(superClass => {

    /**
     * @constructor
     * @extends {superClass}
     * @implements {Polymer_ElementMixin}
     * @private
     */
    let elementBase = Polymer.ElementMixin(superClass);

    /**
     * @polymer
     * @mixinClass
     * @implements {Polymer_ArraySelectorMixin}
     * @unrestricted
     */
    class ArraySelectorMixin extends elementBase {

      static get properties() {

        return {

          /**
           * An array containing items from which selection will be made.
           */
          items: {
            type: Array,
          },

          /**
           * When `true`, multiple items may be selected at once (in this case,
           * `selected` is an array of currently selected items).  When `false`,
           * only one item may be selected at a time.
           */
          multi: {
            type: Boolean,
            value: false,
          },

          /**
           * When `multi` is true, this is an array that contains any selected.
           * When `multi` is false, this is the currently selected item, or `null`
           * if no item is selected.
           * @type {?(Object|Array<!Object>)}
           */
          selected: {
            type: Object,
            notify: true
          },

          /**
           * When `multi` is false, this is the currently selected item, or `null`
           * if no item is selected.
           * @type {?Object}
           */
          selectedItem: {
            type: Object,
            notify: true
          },

          /**
           * When `true`, calling `select` on an item that is already selected
           * will deselect the item.
           */
          toggle: {
            type: Boolean,
            value: false
          }

        };
      }

      static get observers() {
        return ['__updateSelection(multi, items.*)'];
      }

      constructor() {
        super();
        this.__lastItems = null;
        this.__lastMulti = null;
        this.__selectedMap = null;
      }

      __updateSelection(multi, itemsInfo) {
        let path = itemsInfo.path;
        if (path == 'items') {
          // Case 1 - items array changed, so diff against previous array and
          // deselect any removed items and adjust selected indices
          let newItems = itemsInfo.base || [];
          let lastItems = this.__lastItems;
          let lastMulti = this.__lastMulti;
          if (multi !== lastMulti) {
            this.clearSelection();
          }
          if (lastItems) {
            let splices = Polymer.ArraySplice.calculateSplices(newItems, lastItems);
            this.__applySplices(splices);
          }
          this.__lastItems = newItems;
          this.__lastMulti = multi;
        } else if (itemsInfo.path == 'items.splices') {
          // Case 2 - got specific splice information describing the array mutation:
          // deselect any removed items and adjust selected indices
          this.__applySplices(itemsInfo.value.indexSplices);
        } else {
          // Case 3 - an array element was changed, so deselect the previous
          // item for that index if it was previously selected
          let part = path.slice('items.'.length);
          let idx = parseInt(part, 10);
          if ((part.indexOf('.') < 0) && part == idx) {
            this.__deselectChangedIdx(idx);
          }
        }
      }

      __applySplices(splices) {
        let selected = this.__selectedMap;
        // Adjust selected indices and mark removals
        for (let i=0; i<splices.length; i++) {
          let s = splices[i];
          selected.forEach((idx, item) => {
            if (idx < s.index) {
              // no change
            } else if (idx >= s.index + s.removed.length) {
              // adjust index
              selected.set(item, idx + s.addedCount - s.removed.length);
            } else {
              // remove index
              selected.set(item, -1);
            }
          });
          for (let j=0; j<s.addedCount; j++) {
            let idx = s.index + j;
            if (selected.has(this.items[idx])) {
              selected.set(this.items[idx], idx);
            }
          }
        }
        // Update linked paths
        this.__updateLinks();
        // Remove selected items that were removed from the items array
        let sidx = 0;
        selected.forEach((idx, item) => {
          if (idx < 0) {
            if (this.multi) {
              this.splice('selected', sidx, 1);
            } else {
              this.selected = this.selectedItem = null;
            }
            selected.delete(item);
          } else {
            sidx++;
          }
        });
      }

      __updateLinks() {
        this.__dataLinkedPaths = {};
        if (this.multi) {
          let sidx = 0;
          this.__selectedMap.forEach(idx => {
            if (idx >= 0) {
              this.linkPaths('items.' + idx, 'selected.' + sidx++);
            }
          });
        } else {
          this.__selectedMap.forEach(idx => {
            this.linkPaths('selected', 'items.' + idx);
            this.linkPaths('selectedItem', 'items.' + idx);
          });
        }
      }

      /**
       * Clears the selection state.
       * @return {void}
       */
      clearSelection() {
        // Unbind previous selection
        this.__dataLinkedPaths = {};
        // The selected map stores 3 pieces of information:
        // key: items array object
        // value: items array index
        // order: selected array index
        this.__selectedMap = new Map();
        // Initialize selection
        this.selected = this.multi ? [] : null;
        this.selectedItem = null;
      }

      /**
       * Returns whether the item is currently selected.
       *
       * @param {*} item Item from `items` array to test
       * @return {boolean} Whether the item is selected
       */
      isSelected(item) {
        return this.__selectedMap.has(item);
      }

      /**
       * Returns whether the item is currently selected.
       *
       * @param {number} idx Index from `items` array to test
       * @return {boolean} Whether the item is selected
       */
      isIndexSelected(idx) {
        return this.isSelected(this.items[idx]);
      }

      __deselectChangedIdx(idx) {
        let sidx = this.__selectedIndexForItemIndex(idx);
        if (sidx >= 0) {
          let i = 0;
          this.__selectedMap.forEach((idx, item) => {
            if (sidx == i++) {
              this.deselect(item);
            }
          });
        }
      }

      __selectedIndexForItemIndex(idx) {
        let selected = this.__dataLinkedPaths['items.' + idx];
        if (selected) {
          return parseInt(selected.slice('selected.'.length), 10);
        }
      }

      /**
       * Deselects the given item if it is already selected.
       *
       * @param {*} item Item from `items` array to deselect
       * @return {void}
       */
      deselect(item) {
        let idx = this.__selectedMap.get(item);
        if (idx >= 0) {
          this.__selectedMap.delete(item);
          let sidx;
          if (this.multi) {
            sidx = this.__selectedIndexForItemIndex(idx);
          }
          this.__updateLinks();
          if (this.multi) {
            this.splice('selected', sidx, 1);
          } else {
            this.selected = this.selectedItem = null;
          }
        }
      }

      /**
       * Deselects the given index if it is already selected.
       *
       * @param {number} idx Index from `items` array to deselect
       * @return {void}
       */
      deselectIndex(idx) {
        this.deselect(this.items[idx]);
      }

      /**
       * Selects the given item.  When `toggle` is true, this will automatically
       * deselect the item if already selected.
       *
       * @param {*} item Item from `items` array to select
       * @return {void}
       */
      select(item) {
        this.selectIndex(this.items.indexOf(item));
      }

      /**
       * Selects the given index.  When `toggle` is true, this will automatically
       * deselect the item if already selected.
       *
       * @param {number} idx Index from `items` array to select
       * @return {void}
       */
      selectIndex(idx) {
        let item = this.items[idx];
        if (!this.isSelected(item)) {
          if (!this.multi) {
            this.__selectedMap.clear();
          }
          this.__selectedMap.set(item, idx);
          this.__updateLinks();
          if (this.multi) {
            this.push('selected', item);
          } else {
            this.selected = this.selectedItem = item;
          }
        } else if (this.toggle) {
          this.deselectIndex(idx);
        }
      }

    }

    return ArraySelectorMixin;

  });

  // export mixin
  Polymer.ArraySelectorMixin = ArraySelectorMixin;

  /**
   * @constructor
   * @extends {Polymer.Element}
   * @implements {Polymer_ArraySelectorMixin}
   * @private
   */
  let baseArraySelector = ArraySelectorMixin(Polymer.Element);

  /**
   * Element implementing the `Polymer.ArraySelector` mixin, which records
   * dynamic associations between item paths in a master `items` array and a
   * `selected` array such that path changes to the master array (at the host)
   * element or elsewhere via data-binding) are correctly propagated to items
   * in the selected array and vice-versa.
   *
   * The `items` property accepts an array of user data, and via the
   * `select(item)` and `deselect(item)` API, updates the `selected` property
   * which may be bound to other parts of the application, and any changes to
   * sub-fields of `selected` item(s) will be kept in sync with items in the
   * `items` array.  When `multi` is false, `selected` is a property
   * representing the last selected item.  When `multi` is true, `selected`
   * is an array of multiply selected items.
   *
   * Example:
   *
   * ```html
   * <dom-module id="employee-list">
   *
   *   <template>
   *
   *     <div> Employee list: </div>
   *     <dom-repeat id="employeeList" items="{{employees}}">
   *       <template>
   *         <div>First name: <span>{{item.first}}</span></div>
   *           <div>Last name: <span>{{item.last}}</span></div>
   *           <button on-click="toggleSelection">Select</button>
   *       </template>
   *     </dom-repeat>
   *
   *     <array-selector id="selector" items="{{employees}}" selected="{{selected}}" multi toggle></array-selector>
   *
   *     <div> Selected employees: </div>
   *     <dom-repeat items="{{selected}}">
   *       <template>
   *         <div>First name: <span>{{item.first}}</span></div>
   *         <div>Last name: <span>{{item.last}}</span></div>
   *       </template>
   *     </dom-repeat>
   *
   *   </template>
   *
   * </dom-module>
   * ```
   *
   * ```js
   *class EmployeeList extends Polymer.Element {
   *  static get is() { return 'employee-list'; }
   *  static get properties() {
   *    return {
   *      employees: {
   *        value() {
   *          return [
   *            {first: 'Bob', last: 'Smith'},
   *            {first: 'Sally', last: 'Johnson'},
   *            ...
   *          ];
   *        }
   *      }
   *    };
   *  }
   *  toggleSelection(e) {
   *    let item = this.$.employeeList.itemForElement(e.target);
   *    this.$.selector.select(item);
   *  }
   *}
   * ```
   *
   * @polymer
   * @customElement
   * @extends {baseArraySelector}
   * @appliesMixin Polymer.ArraySelectorMixin
   * @memberof Polymer
   * @summary Custom element that links paths between an input `items` array and
   *   an output `selected` item or array based on calls to its selection API.
   */
  class ArraySelector extends baseArraySelector {
    // Not needed to find template; can be removed once the analyzer
    // can find the tag name from customElements.define call
    static get is() { return 'array-selector'; }
  }
  customElements.define(ArraySelector.is, ArraySelector);

  /** @const */
  Polymer.ArraySelector = ArraySelector;

})();


(function(){/*

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
*/
'use strict';var c=null,f=window.HTMLImports&&window.HTMLImports.whenReady||null,g;function h(a){requestAnimationFrame(function(){f?f(a):(c||(c=new Promise(function(a){g=a}),"complete"===document.readyState?g():document.addEventListener("readystatechange",function(){"complete"===document.readyState&&g()})),c.then(function(){a&&a()}))})};var k=null,l=null;function m(){this.customStyles=[];this.enqueued=!1;h(function(){window.ShadyCSS.flushCustomStyles&&window.ShadyCSS.flushCustomStyles()})}function n(a){!a.enqueued&&l&&(a.enqueued=!0,h(l))}m.prototype.c=function(a){a.__seenByShadyCSS||(a.__seenByShadyCSS=!0,this.customStyles.push(a),n(this))};m.prototype.b=function(a){if(a.__shadyCSSCachedStyle)return a.__shadyCSSCachedStyle;var b;a.getStyle?b=a.getStyle():b=a;return b};
m.prototype.a=function(){for(var a=this.customStyles,b=0;b<a.length;b++){var d=a[b];if(!d.__shadyCSSCachedStyle){var e=this.b(d);e&&(e=e.__appliedElement||e,k&&k(e),d.__shadyCSSCachedStyle=e)}}return a};m.prototype.addCustomStyle=m.prototype.c;m.prototype.getStyleForCustomStyle=m.prototype.b;m.prototype.processStyles=m.prototype.a;
Object.defineProperties(m.prototype,{transformCallback:{get:function(){return k},set:function(a){k=a}},validateCallback:{get:function(){return l},set:function(a){var b=!1;l||(b=!0);l=a;b&&n(this)}}});function p(a,b){for(var d in b)null===d?a.style.removeProperty(d):a.style.setProperty(d,b[d])};var q=!(window.ShadyDOM&&window.ShadyDOM.inUse),r;function t(a){r=a&&a.shimcssproperties?!1:q||!(navigator.userAgent.match(/AppleWebKit\/601|Edge\/15/)||!window.CSS||!CSS.supports||!CSS.supports("box-shadow","0 0 0 var(--foo)"))}var u;window.ShadyCSS&&void 0!==window.ShadyCSS.cssBuild&&(u=window.ShadyCSS.cssBuild);var v=!(!window.ShadyCSS||!window.ShadyCSS.disableRuntime);
window.ShadyCSS&&void 0!==window.ShadyCSS.nativeCss?r=window.ShadyCSS.nativeCss:window.ShadyCSS?(t(window.ShadyCSS),window.ShadyCSS=void 0):t(window.WebComponents&&window.WebComponents.flags);var w=r,x=u;var y=new m;window.ShadyCSS||(window.ShadyCSS={prepareTemplate:function(){},prepareTemplateDom:function(){},prepareTemplateStyles:function(){},styleSubtree:function(a,b){y.a();p(a,b)},styleElement:function(){y.a()},styleDocument:function(a){y.a();p(document.body,a)},getComputedStyleValue:function(a,b){return(a=window.getComputedStyle(a).getPropertyValue(b))?a.trim():""},flushCustomStyles:function(){},nativeCss:w,nativeShadow:q,cssBuild:x,disableRuntime:v});window.ShadyCSS.CustomStyleInterface=y;}).call(this);




(function() {
  'use strict';

  const attr = 'include';

  const CustomStyleInterface = window.ShadyCSS.CustomStyleInterface;

  /**
   * Custom element for defining styles in the main document that can take
   * advantage of [shady DOM](https://github.com/webcomponents/shadycss) shims
   * for style encapsulation, custom properties, and custom mixins.
   *
   * - Document styles defined in a `<custom-style>` are shimmed to ensure they
   *   do not leak into local DOM when running on browsers without native
   *   Shadow DOM.
   * - Custom properties can be defined in a `<custom-style>`. Use the `html` selector
   *   to define custom properties that apply to all custom elements.
   * - Custom mixins can be defined in a `<custom-style>`, if you import the optional
   *   [apply shim](https://github.com/webcomponents/shadycss#about-applyshim)
   *   (`shadycss/apply-shim.html`).
   *
   * To use:
   *
   * - Import `custom-style.html`.
   * - Place a `<custom-style>` element in the main document, wrapping an inline `<style>` tag that
   *   contains the CSS rules you want to shim.
   *
   * For example:
   *
   * ```html
   * <!-- import apply shim--only required if using mixins -->
   * <link rel="import" href="bower_components/shadycss/apply-shim.html">
   * <!-- import custom-style element -->
   * <link rel="import" href="bower_components/polymer/lib/elements/custom-style.html">
   *
   * <custom-style>
   *   <style>
   *     html {
   *       --custom-color: blue;
   *       --custom-mixin: {
   *         font-weight: bold;
   *         color: red;
   *       };
   *     }
   *   </style>
   * </custom-style>
   * ```
   *
   * @customElement
   * @extends HTMLElement
   * @memberof Polymer
   * @summary Custom element for defining styles in the main document that can
   *   take advantage of Polymer's style scoping and custom properties shims.
   */
  class CustomStyle extends HTMLElement {
    constructor() {
      super();
      this._style = null;
      CustomStyleInterface.addCustomStyle(this);
    }
    /**
     * Returns the light-DOM `<style>` child this element wraps.  Upon first
     * call any style modules referenced via the `include` attribute will be
     * concatenated to this element's `<style>`.
     *
     * @return {HTMLStyleElement} This element's light-DOM `<style>`
     */
    getStyle() {
      if (this._style) {
        return this._style;
      }
      const style = /** @type {HTMLStyleElement} */(this.querySelector('style'));
      if (!style) {
        return null;
      }
      this._style = style;
      const include = style.getAttribute(attr);
      if (include) {
        style.removeAttribute(attr);
        style.textContent = Polymer.StyleGather.cssFromModules(include) + style.textContent;
      }
      /*
      HTML Imports styling the main document are deprecated in Chrome
      https://crbug.com/523952

      If this element is not in the main document, then it must be in an HTML Import document.
      In that case, move the custom style to the main document.

      The ordering of `<custom-style>` should stay the same as when loaded by HTML Imports, but there may be odd
      cases of ordering w.r.t the main document styles.
      */
      if (this.ownerDocument !== window.document) {
        window.document.head.appendChild(this);
      }
      return this._style;
    }
  }

  window.customElements.define('custom-style', CustomStyle);

  /** @const */
  Polymer.CustomStyle = CustomStyle;
})();


(function() {
  'use strict';

  let mutablePropertyChange;
  /** @suppress {missingProperties} */
  (() => {
    mutablePropertyChange = Polymer.MutableData._mutablePropertyChange;
  })();

  /**
   * Legacy element behavior to skip strict dirty-checking for objects and arrays,
   * (always consider them to be "dirty") for use on legacy API Polymer elements.
   *
   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
   * objects, which means that any deep modifications to an object or array will
   * not be propagated unless "immutable" data patterns are used (i.e. all object
   * references from the root to the mutation were changed).
   *
   * Polymer also provides a proprietary data mutation and path notification API
   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
   * mutation and notification of deep changes in an object graph to all elements
   * bound to the same object graph.
   *
   * In cases where neither immutable patterns nor the data mutation API can be
   * used, applying this mixin will cause Polymer to skip dirty checking for
   * objects and arrays (always consider them to be "dirty").  This allows a
   * user to make a deep modification to a bound object graph, and then either
   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
   * elements that wish to be updated based on deep mutations must apply this
   * mixin or otherwise skip strict dirty checking for objects/arrays.
   * Specifically, any elements in the binding tree between the source of a
   * mutation and the consumption of it must apply this behavior or enable the
   * `Polymer.OptionalMutableDataBehavior`.
   *
   * In order to make the dirty check strategy configurable, see
   * `Polymer.OptionalMutableDataBehavior`.
   *
   * Note, the performance characteristics of propagating large object graphs
   * will be worse as opposed to using strict dirty checking with immutable
   * patterns or Polymer's path notification API.
   *
   * @polymerBehavior
   * @memberof Polymer
   * @summary Behavior to skip strict dirty-checking for objects and
   *   arrays
   */
  Polymer.MutableDataBehavior = {

    /**
     * Overrides `Polymer.PropertyEffects` to provide option for skipping
     * strict equality checking for Objects and Arrays.
     *
     * This method pulls the value to dirty check against from the `__dataTemp`
     * cache (rather than the normal `__data` cache) for Objects.  Since the temp
     * cache is cleared at the end of a turn, this implementation allows
     * side-effects of deep object changes to be processed by re-setting the
     * same object (using the temp cache as an in-turn backstop to prevent
     * cycles due to 2-way notification).
     *
     * @param {string} property Property name
     * @param {*} value New property value
     * @param {*} old Previous property value
     * @return {boolean} Whether the property should be considered a change
     * @protected
     */
    _shouldPropertyChange(property, value, old) {
      return mutablePropertyChange(this, property, value, old, true);
    }
  };

  /**
   * Legacy element behavior to add the optional ability to skip strict
   * dirty-checking for objects and arrays (always consider them to be
   * "dirty") by setting a `mutable-data` attribute on an element instance.
   *
   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
   * objects, which means that any deep modifications to an object or array will
   * not be propagated unless "immutable" data patterns are used (i.e. all object
   * references from the root to the mutation were changed).
   *
   * Polymer also provides a proprietary data mutation and path notification API
   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
   * mutation and notification of deep changes in an object graph to all elements
   * bound to the same object graph.
   *
   * In cases where neither immutable patterns nor the data mutation API can be
   * used, applying this mixin will allow Polymer to skip dirty checking for
   * objects and arrays (always consider them to be "dirty").  This allows a
   * user to make a deep modification to a bound object graph, and then either
   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
   * elements that wish to be updated based on deep mutations must apply this
   * mixin or otherwise skip strict dirty checking for objects/arrays.
   * Specifically, any elements in the binding tree between the source of a
   * mutation and the consumption of it must enable this behavior or apply the
   * `Polymer.OptionalMutableDataBehavior`.
   *
   * While this behavior adds the ability to forgo Object/Array dirty checking,
   * the `mutableData` flag defaults to false and must be set on the instance.
   *
   * Note, the performance characteristics of propagating large object graphs
   * will be worse by relying on `mutableData: true` as opposed to using
   * strict dirty checking with immutable patterns or Polymer's path notification
   * API.
   *
   * @polymerBehavior
   * @memberof Polymer
   * @summary Behavior to optionally skip strict dirty-checking for objects and
   *   arrays
   */
  Polymer.OptionalMutableDataBehavior = {

    properties: {
      /**
       * Instance-level flag for configuring the dirty-checking strategy
       * for this element.  When true, Objects and Arrays will skip dirty
       * checking, otherwise strict equality checking will be used.
       */
      mutableData: Boolean
    },

    /**
     * Overrides `Polymer.PropertyEffects` to skip strict equality checking
     * for Objects and Arrays.
     *
     * Pulls the value to dirty check against from the `__dataTemp` cache
     * (rather than the normal `__data` cache) for Objects.  Since the temp
     * cache is cleared at the end of a turn, this implementation allows
     * side-effects of deep object changes to be processed by re-setting the
     * same object (using the temp cache as an in-turn backstop to prevent
     * cycles due to 2-way notification).
     *
     * @param {string} property Property name
     * @param {*} value New property value
     * @param {*} old Previous property value
     * @return {boolean} Whether the property should be considered a change
     * @this {this}
     * @protected
     */
    _shouldPropertyChange(property, value, old) {
      return mutablePropertyChange(this, property, value, old, this.mutableData);
    }
  };

})();



  // bc
  Polymer.Base = Polymer.LegacyElementMixin(HTMLElement).prototype;

  // NOTE: this is here for modulizer to export `html` for the module version of this file
  Polymer.html = Polymer.html;

//# sourceURL=build://iron-flex-layout/iron-flex-layout.html.js
(function(){var b=document.createElement("style");b.textContent="[hidden] { display: none !important; }";document.head.appendChild(b)})();

//# sourceURL=build://iron-a11y-keys-behavior/iron-a11y-keys-behavior.html.js
(function(){function b(w,C){var G="";if(w)if(w=w.toLowerCase()," "===w||A.test(w))G="space";else if(y.test(w))G="esc";else if(1==w.length){if(!C||q.test(w))G=w}else G=x.test(w)?w.replace("arrow",""):"multiply"==w?"*":w;return G}function d(w){var C="";w&&(w in p?C=p[w]:u.test(w)?(w=parseInt(w.replace("U+","0x"),16),C=String.fromCharCode(w).toLowerCase()):C=w.toLowerCase());return C}function f(w){var C="";Number(w)&&(C=65<=w&&90>=w?String.fromCharCode(32+w):112<=w&&123>=w?"f"+(w-112+1):48<=w&&57>=w?
String(w-48):96<=w&&105>=w?String(w-96):m[w]);return C}function h(w,C){return w.key?b(w.key,C):w.detail&&w.detail.key?b(w.detail.key,C):d(w.keyIdentifier)||f(w.keyCode)||""}function k(w,C){return h(C,w.hasModifiers)===w.key&&(!w.hasModifiers||!!C.shiftKey===!!w.shiftKey&&!!C.ctrlKey===!!w.ctrlKey&&!!C.altKey===!!w.altKey&&!!C.metaKey===!!w.metaKey)}function t(w){return 1===w.length?{combo:w,key:w,event:"keydown"}:w.split("+").reduce(function(C,G){var D=G.split(":");G=D[0];D=D[1];G in n?(C[n[G]]=!0,
C.hasModifiers=!0):(C.key=G,C.event=D||"keydown");return C},{combo:w.split(":").shift()})}function l(w){return w.trim().split(" ").map(function(C){return t(C)})}var p={"U+0008":"backspace","U+0009":"tab","U+001B":"esc","U+0020":"space","U+007F":"del"},m={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:"*"},n={shift:"shiftKey",ctrl:"ctrlKey",alt:"altKey",meta:"metaKey"},q=/[a-z0-9*]/,u=/U\+/,x=/^arrow/,
A=/^space(bar)?/,y=/^escape$/;Polymer.IronA11yKeysBehavior={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(w,C){this._imperativeKeyBindings[w]=C;this._prepKeyBindings();this._resetKeyEventListeners()},removeOwnKeyBindings:function(){this._imperativeKeyBindings={};this._prepKeyBindings();this._resetKeyEventListeners()},keyboardEventMatchesKeys:function(w,C){C=l(C);for(var G=0;G<C.length;++G)if(k(C[G],w))return!0;return!1},_collectKeyBindings:function(){var w=this.behaviors.map(function(C){return C.keyBindings});-1===w.indexOf(this.keyBindings)&&w.push(this.keyBindings);return w},
_prepKeyBindings:function(){this._keyBindings={};this._collectKeyBindings().forEach(function(G){for(var D in G)this._addKeyBinding(D,G[D])},this);for(var w in this._imperativeKeyBindings)this._addKeyBinding(w,this._imperativeKeyBindings[w]);for(var C in this._keyBindings)this._keyBindings[C].sort(function(G,D){G=G[0].hasModifiers;return G===D[0].hasModifiers?0:G?-1:1})},_addKeyBinding:function(w,C){l(w).forEach(function(G){this._keyBindings[G.event]=this._keyBindings[G.event]||[];this._keyBindings[G.event].push([G,
C])},this)},_resetKeyEventListeners:function(){this._unlistenKeyEventListeners();this.isAttached&&this._listenKeyEventListeners()},_listenKeyEventListeners:function(){this.keyEventTarget&&Object.keys(this._keyBindings).forEach(function(w){var C=this._onKeyBindingEvent.bind(this,this._keyBindings[w]);this._boundKeyHandlers.push([this.keyEventTarget,w,C]);this.keyEventTarget.addEventListener(w,C)},this)},_unlistenKeyEventListeners:function(){for(var w,C,G;this._boundKeyHandlers.length;)w=this._boundKeyHandlers.pop(),
C=w[0],G=w[1],w=w[2],C.removeEventListener(G,w)},_onKeyBindingEvent:function(w,C){this.stopKeyboardEventPropagation&&C.stopPropagation();if(!C.defaultPrevented)for(var G=0;G<w.length;G++){var D=w[G][0],B=w[G][1];if(k(D,C)&&(this._triggerKeyHandler(D,B,C),C.defaultPrevented))break}},_triggerKeyHandler:function(w,C,G){var D=Object.create(w);D.keyboardEvent=G;w=new CustomEvent(w.event,{detail:D,cancelable:!0});this[C].call(this,w);w.defaultPrevented&&G.preventDefault()}}})();

//# sourceURL=build://iron-behaviors/iron-control-state.html.js
Polymer.IronControlState={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)}},__handleEventRetargeting:{type:Boolean,value:function(){return!this.shadowRoot&&!Polymer.Element}}},observers:["_changedControlState(focused, disabled)"],ready:function(){this.addEventListener("focus",
this._boundFocusBlurHandler,!0);this.addEventListener("blur",this._boundFocusBlurHandler,!0)},_focusBlurHandler:function(b){if(Polymer.Element)this._setFocused("focus"===b.type);else if(b.target===this)this._setFocused("focus"===b.type);else if(this.__handleEventRetargeting){var d=Polymer.dom(b).localTarget;this.isLightDescendant(d)||this.fire(b.type,{sourceEvent:b},{node:this,bubbles:b.bubbles,cancelable:b.cancelable})}},_disabledChanged:function(b){this.setAttribute("aria-disabled",b?"true":"false");
this.style.pointerEvents=b?"none":"";b?(this._oldTabIndex=this.getAttribute("tabindex"),this._setFocused(!1),this.tabIndex=-1,this.blur()):void 0!==this._oldTabIndex&&(null===this._oldTabIndex?this.removeAttribute("tabindex"):this.setAttribute("tabindex",this._oldTabIndex))},_changedControlState:function(){this._controlStateChanged&&this._controlStateChanged()}};

//# sourceURL=build://iron-behaviors/iron-button-state.html.js
Polymer.IronButtonStateImpl={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(b){this._detectKeyboardFocus(b);b||this._setPressed(!1)},_detectKeyboardFocus:function(b){this._setReceivedFocusFromKeyboard(!this.pointerDown&&b)},_userActivate:function(b){this.active!==
b&&(this.active=b,this.fire("change"))},_downHandler:function(){this._setPointerDown(!0);this._setPressed(!0);this._setReceivedFocusFromKeyboard(!1)},_upHandler:function(){this._setPointerDown(!1);this._setPressed(!1)},_spaceKeyDownHandler:function(b){b=b.detail.keyboardEvent;var d=Polymer.dom(b).localTarget;this.isLightDescendant(d)||(b.preventDefault(),b.stopImmediatePropagation(),this._setPressed(!0))},_spaceKeyUpHandler:function(b){b=Polymer.dom(b.detail.keyboardEvent).localTarget;this.isLightDescendant(b)||
(this.pressed&&this._asyncClick(),this._setPressed(!1))},_asyncClick:function(){this.async(function(){this.click()},1)},_pressedChanged:function(){this._changedButtonState()},_ariaActiveAttributeChanged:function(b,d){d&&d!=b&&this.hasAttribute(d)&&this.removeAttribute(d)},_activeChanged:function(b){this.toggles?this.setAttribute(this.ariaActiveAttribute,b?"true":"false"):this.removeAttribute(this.ariaActiveAttribute);this._changedButtonState()},_controlStateChanged:function(){this.disabled?this._setPressed(!1):
this._changedButtonState()},_changedButtonState:function(){this._buttonStateChanged&&this._buttonStateChanged()}};Polymer.IronButtonState=[Polymer.IronA11yKeysBehavior,Polymer.IronButtonStateImpl];

//# sourceURL=build://paper-ripple/paper-ripple.html.js
(function(){function b(h){this.element=h;this.width=this.boundingRect.width;this.height=this.boundingRect.height;this.size=Math.max(this.width,this.height)}function d(h){this.element=h;this.color=window.getComputedStyle(h).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");Polymer.dom(this.waveContainer).appendChild(this.wave);this.resetInteractionState()}
var f={distance:function(h,k,t,l){h-=t;k-=l;return Math.sqrt(h*h+k*k)},now:window.performance&&window.performance.now?window.performance.now.bind(window.performance):Date.now};b.prototype={get boundingRect(){return this.element.getBoundingClientRect()},furthestCornerDistanceFrom:function(h,k){var t=f.distance(h,k,0,0),l=f.distance(h,k,this.width,0),p=f.distance(h,k,0,this.height);h=f.distance(h,k,this.width,this.height);return Math.max(t,l,p,h)}};d.MAX_RADIUS=300;d.prototype={get recenters(){return this.element.recenters},
get center(){return this.element.center},get mouseDownElapsed(){if(!this.mouseDownStart)return 0;var h=f.now()-this.mouseDownStart;this.mouseUpStart&&(h-=this.mouseUpElapsed);return h},get mouseUpElapsed(){return this.mouseUpStart?f.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 h=1.1*Math.min(Math.sqrt(this.containerMetrics.width*this.containerMetrics.width+this.containerMetrics.height*this.containerMetrics.height),d.MAX_RADIUS)+5;return Math.abs(h*(1-Math.pow(80,-(this.mouseInteractionSeconds/(1.1-h/d.MAX_RADIUS*.2)))))},get opacity(){return this.mouseUpStart?Math.max(0,this.initialOpacity-this.mouseUpElapsedSeconds*this.opacityDecayVelocity):this.initialOpacity},get outerOpacity(){return Math.max(0,
Math.min(.3*this.mouseUpElapsedSeconds,this.opacity))},get isOpacityFullyDecayed(){return.01>this.opacity&&this.radius>=Math.min(this.maxRadius,d.MAX_RADIUS)},get isRestingAtMaxRadius(){return this.opacity>=this.initialOpacity&&this.radius>=Math.min(this.maxRadius,d.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.slideDistance=this.yEnd=this.xEnd=this.yStart=this.xStart=this.mouseUpStart=this.mouseDownStart=this.maxRadius=0;this.containerMetrics=new b(this.element)},draw:function(){this.wave.style.opacity=this.opacity;var h=this.radius/
(this.containerMetrics.size/2);var k=this.xNow-this.containerMetrics.width/2;var t=this.yNow-this.containerMetrics.height/2;this.waveContainer.style.webkitTransform="translate("+k+"px, "+t+"px)";this.waveContainer.style.transform="translate3d("+k+"px, "+t+"px, 0)";this.wave.style.webkitTransform="scale("+h+","+h+")";this.wave.style.transform="scale3d("+h+","+h+",1)"},downAction:function(h){var k=this.containerMetrics.width/2,t=this.containerMetrics.height/2;this.resetInteractionState();this.mouseDownStart=
f.now();this.center?(this.xStart=k,this.yStart=t,this.slideDistance=f.distance(this.xStart,this.yStart,this.xEnd,this.yEnd)):(this.xStart=h?h.detail.x-this.containerMetrics.boundingRect.left:this.containerMetrics.width/2,this.yStart=h?h.detail.y-this.containerMetrics.boundingRect.top:this.containerMetrics.height/2);this.recenters&&(this.xEnd=k,this.yEnd=t,this.slideDistance=f.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(){this.isMouseDown&&(this.mouseUpStart=f.now())},remove:function(){Polymer.dom(this.waveContainer.parentNode).removeChild(this.waveContainer)}};Polymer({is:"paper-ripple",
behaviors:[Polymer.IronA11yKeysBehavior],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(){var h=this.keyEventTarget=11==this.parentNode.nodeType?Polymer.dom(this).getOwnerRoot().host:this.parentNode;this.listen(h,"up","uiUpAction");this.listen(h,"down","uiDownAction")},detached:function(){this.unlisten(this.keyEventTarget,"up","uiUpAction");this.unlisten(this.keyEventTarget,"down","uiDownAction");this.keyEventTarget=
null},get shouldKeepAnimating(){for(var h=0;h<this.ripples.length;++h)if(!this.ripples[h].isAnimationComplete)return!0;return!1},simulatedRipple:function(){this.downAction(null);this.async(function(){this.upAction()},1)},uiDownAction:function(h){this.noink||this.downAction(h)},downAction:function(h){this.holdDown&&0<this.ripples.length||(this.addRipple().downAction(h),this._animating||(this._animating=!0,this.animate()))},uiUpAction:function(h){this.noink||this.upAction(h)},upAction:function(h){this.holdDown||
(this.ripples.forEach(function(k){k.upAction(h)}),this._animating=!0,this.animate())},onAnimationComplete:function(){this._animating=!1;this.$.background.style.backgroundColor=null;this.fire("transitionend")},addRipple:function(){var h=new d(this);Polymer.dom(this.$.waves).appendChild(h.waveContainer);this.$.background.style.backgroundColor=h.color;this.ripples.push(h);this._setAnimating(!0);return h},removeRipple:function(h){var k=this.ripples.indexOf(h);0>k||(this.ripples.splice(k,1),h.remove(),
this.ripples.length||this._setAnimating(!1))},animate:function(){if(this._animating){var h;for(h=0;h<this.ripples.length;++h){var k=this.ripples[h];k.draw();this.$.background.style.opacity=k.outerOpacity;k.isOpacityFullyDecayed&&!k.isRestingAtMaxRadius&&this.removeRipple(k)}if(this.shouldKeepAnimating||0!==this.ripples.length)window.requestAnimationFrame(this._boundAnimate);else this.onAnimationComplete()}},_onEnterKeydown:function(){this.uiDownAction();this.async(this.uiUpAction,1)},_onSpaceKeydown:function(){this.uiDownAction()},
_onSpaceKeyup:function(){this.uiUpAction()},_holdDownChanged:function(h,k){void 0!==k&&(h?this.downAction():this.upAction())}})})();

//# sourceURL=build://paper-behaviors/paper-ripple-behavior.html.js
Polymer.PaperRippleBehavior={properties:{noink:{type:Boolean,observer:"_noinkChanged"},_rippleContainer:{type:Object}},_buttonStateChanged:function(){this.focused&&this.ensureRipple()},_downHandler:function(b){Polymer.IronButtonStateImpl._downHandler.call(this,b);this.pressed&&this.ensureRipple(b)},ensureRipple:function(b){if(!this.hasRipple()){this._ripple=this._createRipple();this._ripple.noink=this.noink;var d=this._rippleContainer||this.root;d&&Polymer.dom(d).appendChild(this._ripple);if(b){d=
Polymer.dom(this._rippleContainer||this);var f=Polymer.dom(b).rootTarget;d.deepContains(f)&&this._ripple.uiDownAction(b)}}},getRipple:function(){this.ensureRipple();return this._ripple},hasRipple:function(){return!!this._ripple},_createRipple:function(){return document.createElement("paper-ripple")},_noinkChanged:function(b){this.hasRipple()&&(this._ripple.noink=b)}};

//# sourceURL=build://paper-behaviors/paper-button-behavior.html.js
Polymer.PaperButtonBehaviorImpl={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 b=1;this.disabled?b=0:this.active||this.pressed?b=4:this.receivedFocusFromKeyboard&&(b=3);this._setElevation(b)},_computeKeyboardClass:function(b){this.toggleClass("keyboard-focus",
b)},_spaceKeyDownHandler:function(b){Polymer.IronButtonStateImpl._spaceKeyDownHandler.call(this,b);this.hasRipple()&&1>this.getRipple().ripples.length&&this._ripple.uiDownAction()},_spaceKeyUpHandler:function(b){Polymer.IronButtonStateImpl._spaceKeyUpHandler.call(this,b);this.hasRipple()&&this._ripple.uiUpAction()}};Polymer.PaperButtonBehavior=[Polymer.IronButtonState,Polymer.IronControlState,Polymer.PaperRippleBehavior,Polymer.PaperButtonBehaviorImpl];

//# sourceURL=build://paper-button/paper-button.html.js
Polymer({is:"paper-button",behaviors:[Polymer.PaperButtonBehavior],properties:{raised:{type:Boolean,reflectToAttribute:!0,value:!1,observer:"_calculateElevation"}},_calculateElevation:function(){this.raised?Polymer.PaperButtonBehaviorImpl._calculateElevation.apply(this):this._setElevation(0)}});

//# sourceURL=build://iron-meta/iron-meta.html.js
(function(){Polymer.IronMeta=function(d){Polymer.IronMeta[" "](d);this.type=d&&d.type||"default";this.key=d&&d.key;d&&"value"in d&&(this.value=d.value)};Polymer.IronMeta[" "]=function(){};Polymer.IronMeta.types={};Polymer.IronMeta.prototype={get value(){var d=this.type,f=this.key;if(d&&f)return Polymer.IronMeta.types[d]&&Polymer.IronMeta.types[d][f]},set value(d){var f=this.type,h=this.key;f&&h&&(f=Polymer.IronMeta.types[f]=Polymer.IronMeta.types[f]||{},null==d?delete f[h]:f[h]=d)},get list(){if(this.type){var d=
Polymer.IronMeta.types[this.type];return d?Object.keys(d).map(function(f){return b[this.type][f]},this):[]}},byKey:function(d){this.key=d;return this.value}};var b=Polymer.IronMeta.types;Polymer({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(d,f,h){d=new Polymer.IronMeta({type:d,
key:f});void 0!==h&&h!==d.value?d.value=h:this.value!==d.value&&(this.value=d.value);return d},get list(){return this.__meta&&this.__meta.list},_selfChanged:function(d){d&&(this.value=this)},byKey:function(d){return(new Polymer.IronMeta({type:this.type,key:d})).value}})})();

//# sourceURL=build://iron-validatable-behavior/iron-validatable-behavior.html.js
Polymer.IronValidatableBehaviorMeta=null;
Polymer.IronValidatableBehavior={properties:{validator:{type:String},invalid:{notify:!0,reflectToAttribute:!0,type:Boolean,value:!1,observer:"_invalidChanged"}},registered:function(){Polymer.IronValidatableBehaviorMeta=new Polymer.IronMeta({type:"validator"})},_invalidChanged:function(){this.invalid?this.setAttribute("aria-invalid","true"):this.removeAttribute("aria-invalid")},get _validator(){return Polymer.IronValidatableBehaviorMeta&&Polymer.IronValidatableBehaviorMeta.byKey(this.validator)},hasValidator:function(){return null!=
this._validator},validate:function(b){this.invalid=void 0===b&&void 0!==this.value?!this._getValidity(this.value):!this._getValidity(b);return!this.invalid},_getValidity:function(b){return this.hasValidator()?this._validator.validate(b):!0}};

//# sourceURL=build://iron-form-element-behavior/iron-form-element-behavior.html.js
Polymer.IronFormElementBehavior={properties:{name:{type:String},value:{notify:!0,type:String},required:{type:Boolean,value:!1},_parentForm:{type:Object}},attached:function(){Polymer.Element||this.fire("iron-form-element-register")},detached:function(){!Polymer.Element&&this._parentForm&&this._parentForm.fire("iron-form-element-unregister",{target:this})}};

//# sourceURL=build://iron-checked-element-behavior/iron-checked-element-behavior.html.js
Polymer.IronCheckedElementBehaviorImpl={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(){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(){if(void 0===this.value||null===this.value)this.value="on"}};Polymer.IronCheckedElementBehavior=[Polymer.IronFormElementBehavior,Polymer.IronValidatableBehavior,Polymer.IronCheckedElementBehaviorImpl];

//# sourceURL=build://paper-behaviors/paper-inky-focus-behavior.html.js
Polymer.PaperInkyFocusBehaviorImpl={observers:["_focusedChanged(receivedFocusFromKeyboard)"],_focusedChanged:function(b){b&&this.ensureRipple();this.hasRipple()&&(this._ripple.holdDown=b)},_createRipple:function(){var b=Polymer.PaperRippleBehavior._createRipple();b.id="ink";b.setAttribute("center","");b.classList.add("circle");return b}};Polymer.PaperInkyFocusBehavior=[Polymer.IronButtonState,Polymer.IronControlState,Polymer.PaperRippleBehavior,Polymer.PaperInkyFocusBehaviorImpl];

//# sourceURL=build://paper-behaviors/paper-checked-element-behavior.html.js
Polymer.PaperCheckedElementBehaviorImpl={_checkedChanged:function(){Polymer.IronCheckedElementBehaviorImpl._checkedChanged.call(this);this.hasRipple()&&(this.checked?this._ripple.setAttribute("checked",""):this._ripple.removeAttribute("checked"))},_buttonStateChanged:function(){Polymer.PaperRippleBehavior._buttonStateChanged.call(this);!this.disabled&&this.isAttached&&(this.checked=this.active)}};
Polymer.PaperCheckedElementBehavior=[Polymer.PaperInkyFocusBehavior,Polymer.IronCheckedElementBehavior,Polymer.PaperCheckedElementBehaviorImpl];

//# sourceURL=build://paper-checkbox/paper-checkbox.html.js
Polymer({is:"paper-checkbox",behaviors:[Polymer.PaperCheckedElementBehavior],hostAttributes:{role:"checkbox","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},attached:function(){Polymer.RenderStatus.afterNextRender(this,function(){if("-1px"===this.getComputedStyleValue("--calculated-paper-checkbox-ink-size").trim()){var b=this.getComputedStyleValue("--calculated-paper-checkbox-size").trim(),d="px",f=b.match(/[A-Za-z]+$/);null!==f&&(d=f[0]);b=parseFloat(b);
f=8/3*b;"px"===d&&(f=Math.floor(f),f%2!==b%2&&f++);this.updateStyles({"--paper-checkbox-ink-size":f+d})}})},_computeCheckboxClass:function(b,d){var f="";b&&(f+="checked ");d&&(f+="invalid");return f},_computeCheckmarkClass:function(b){return b?"":"hidden"},_createRipple:function(){this._rippleContainer=this.$.checkboxContainer;return Polymer.PaperInkyFocusBehaviorImpl._createRipple.call(this)}});

//# sourceURL=build://iron-icon/iron-icon.html.js
Polymer({is:"iron-icon",properties:{icon:{type:String},theme:{type:String},src:{type:String},_meta:{value:Polymer.Base.create("iron-meta",{type:"iconset"})}},observers:["_updateIcon(_meta, isAttached)","_updateIcon(theme, isAttached)","_srcChanged(src, isAttached)","_iconChanged(icon, isAttached)"],_DEFAULT_ICONSET:"icons",_iconChanged:function(b){b=(b||"").split(":");this._iconName=b.pop();this._iconsetName=b.pop()||this._DEFAULT_ICONSET;this._updateIcon()},_srcChanged:function(){this._updateIcon()},
_usesIconset:function(){return this.icon||!this.src},_updateIcon:function(){this._usesIconset()?(this._img&&this._img.parentNode&&Polymer.dom(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.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,Polymer.dom(this.root).appendChild(this._img))}});

//# sourceURL=build://iron-a11y-announcer/iron-a11y-announcer.html.js
(function(){Polymer.IronA11yAnnouncer=function(){};Polymer.IronA11yAnnouncer=Polymer({is:"iron-a11y-announcer",properties:{mode:{type:String,value:"polite"},_text:{type:String,value:""}},created:function(){Polymer.IronA11yAnnouncer.instance||(Polymer.IronA11yAnnouncer.instance=this);document.body.addEventListener("iron-announce",this._onIronAnnounce.bind(this))},announce:function(b){this._text="";this.async(function(){this._text=b},100)},_onIronAnnounce:function(b){b.detail&&b.detail.text&&this.announce(b.detail.text)}});
Polymer.IronA11yAnnouncer.instance=null;Polymer.IronA11yAnnouncer.requestAvailability=function(){Polymer.IronA11yAnnouncer.instance||(Polymer.IronA11yAnnouncer.instance=document.createElement("iron-a11y-announcer"));document.body.appendChild(Polymer.IronA11yAnnouncer.instance)}})();

//# sourceURL=build://iron-input/iron-input.html.js
Polymer({is:"iron-input",behaviors:[Polymer.IronValidatableBehavior],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(){Polymer.IronA11yAnnouncer.requestAvailability();this._previousValidInput="";this._patternAlreadyChecked=!1},attached:function(){this._observer=
Polymer.dom(this).observeNodes(function(){this._initSlottedInput()}.bind(this))},detached:function(){this._observer&&(Polymer.dom(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(){if(this.allowedPattern)var b=new RegExp(this.allowedPattern);
else switch(this.inputElement.type){case "number":b=/[0-9.,e-]/}return b},_bindValueChanged:function(b,d){d&&(void 0===b?d.value=null:b!==d.value&&(this.inputElement.value=b),this.autoValidate&&this.validate(),this.fire("bind-value-changed",{value:b}))},_onInput:function(){!this.allowedPattern||this._patternAlreadyChecked||this._checkPatternValidity()||(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(b){var d=19==b.keyCode||20==b.keyCode||45==b.keyCode||46==b.keyCode||144==b.keyCode||145==b.keyCode||32<b.keyCode&&41>b.keyCode||111<b.keyCode&&124>b.keyCode;return!(8==b.keyCode||9==b.keyCode||13==b.keyCode||27==b.keyCode)&&!(0==b.charCode&&d)},_onKeypress:function(b){if(this.allowedPattern||"number"===this.inputElement.type){var d=this._patternRegExp;if(d&&!(b.metaKey||b.ctrlKey||b.altKey)){this._patternAlreadyChecked=
!0;var f=String.fromCharCode(b.charCode);this._isPrintable(b)&&!d.test(f)&&(b.preventDefault(),this._announceInvalidCharacter("Invalid character "+f+" not entered."))}}},_checkPatternValidity:function(){var b=this._patternRegExp;if(!b)return!0;for(var d=0;d<this.inputElement.value.length;d++)if(!b.test(this.inputElement.value[d]))return!1;return!0},validate:function(){if(!this.inputElement)return this.invalid=!1,!0;var b=this.inputElement.checkValidity();b&&(this.required&&""===this.bindValue?b=!1:
this.hasValidator()&&(b=Polymer.IronValidatableBehavior.validate.call(this,this.bindValue)));this.invalid=!b;this.fire("iron-input-validate");return b},_announceInvalidCharacter:function(b){this.fire("iron-announce",{text:b})},_computeValue:function(b){return b}});

//# sourceURL=build://paper-input/paper-input-behavior.html.js
Polymer.PaperInputHelper={};Polymer.PaperInputHelper.NextLabelID=1;Polymer.PaperInputHelper.NextAddonID=1;Polymer.PaperInputHelper.NextInputID=1;
Polymer.PaperInputBehaviorImpl={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(){this.$||(this.$={});this.$.input||(this._generateInputId(),this.$.input=this.$$("#"+this._inputId));return this.$.input},get _focusableElement(){return this.inputElement},created:function(){this._typesThatHaveText="date datetime datetime-local month time week file".split(" ")},attached:function(){this._updateAriaLabelledBy();
!Polymer.Element&&this.inputElement&&-1!==this._typesThatHaveText.indexOf(this.inputElement.type)&&(this.alwaysFloatLabel=!0)},_appendStringWithSpace:function(b,d){return b?b+" "+d:d},_onAddonAttached:function(b){b=Polymer.dom(b).rootTarget;if(b.id)this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,b.id);else{var d="paper-input-add-on-"+Polymer.PaperInputHelper.NextAddonID++;b.id=d;this._ariaDescribedBy=this._appendStringWithSpace(this._ariaDescribedBy,d)}},validate:function(){return this.inputElement.validate()},
_focusBlurHandler:function(b){Polymer.IronControlState._focusBlurHandler.call(this,b);this.focused&&!this._shiftTabPressed&&this._focusableElement&&this._focusableElement.focus()},_onShiftTabDown:function(){var b=this.getAttribute("tabindex");this._shiftTabPressed=!0;this.setAttribute("tabindex","-1");this.async(function(){this.setAttribute("tabindex",b);this._shiftTabPressed=!1},1)},_handleAutoValidate:function(){this.autoValidate&&this.validate()},updateValueAndPreserveCaret:function(b){try{var d=
this.inputElement.selectionStart;this.value=b;this.inputElement.selectionStart=d;this.inputElement.selectionEnd=d}catch(f){this.value=b}},_computeAlwaysFloatLabel:function(b,d){return d||b},_updateAriaLabelledBy:function(){var b=Polymer.dom(this.root).querySelector("label");if(b){if(b.id)var d=b.id;else d="paper-input-label-"+Polymer.PaperInputHelper.NextLabelID++,b.id=d;this._ariaLabelledBy=d}else this._ariaLabelledBy=""},_generateInputId:function(){this._inputId&&""!==this._inputId||(this._inputId=
"input-"+Polymer.PaperInputHelper.NextInputID++)},_onChange:function(b){this.shadowRoot&&this.fire(b.type,{sourceEvent:b},{node:this,bubbles:b.bubbles,cancelable:b.cancelable})},_autofocusChanged:function(){if(this.autofocus&&this._focusableElement){var b=document.activeElement;b instanceof HTMLElement&&b!==document.body&&b!==document.documentElement||this._focusableElement.focus()}}};Polymer.PaperInputBehavior=[Polymer.IronControlState,Polymer.IronA11yKeysBehavior,Polymer.PaperInputBehaviorImpl];

//# sourceURL=build://paper-input/paper-input-addon-behavior.html.js
Polymer.PaperInputAddonBehavior={attached:function(){this.fire("addon-attached")},update:function(){}};

//# sourceURL=build://paper-input/paper-input-char-counter.html.js
Polymer({is:"paper-input-char-counter",behaviors:[Polymer.PaperInputAddonBehavior],properties:{_charCounterStr:{type:String,value:"0"}},update:function(b){if(b.inputElement){b.value=b.value||"";var d=b.value.toString().length.toString();b.inputElement.hasAttribute("maxlength")&&(d+="/"+b.inputElement.getAttribute("maxlength"));this._charCounterStr=d}}});

//# sourceURL=build://paper-input/paper-input-container.html.js
Polymer({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 Polymer.CaseMap.dashToCamelCase(this.attrForValue)},get _inputElement(){return Polymer.dom(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(b){this._addons||(this._addons=[]);b=b.target;-1===this._addons.indexOf(b)&&(this._addons.push(b),this.isAttached&&this._handleValue(this._inputElement))},_onFocus:function(){this._setFocused(!0)},_onBlur:function(){this._setFocused(!1);this._handleValueAndAutoValidate(this._inputElement)},_onInput:function(b){this._handleValueAndAutoValidate(b.target)},_onValueChanged:function(b){var d=
b.target;if(this.__isFirstValueUpdate&&(this.__isFirstValueUpdate=!1,void 0===d.value||""===d.value))return;this._handleValueAndAutoValidate(b.target)},_handleValue:function(b){var d=this._inputElementValue;d||0===d||"number"===b.type&&!b.checkValidity()?this._inputHasContent=!0:this._inputHasContent=!1;this.updateAddons({inputElement:b,value:d,invalid:this.invalid})},_handleValueAndAutoValidate:function(b){this.autoValidate&&b&&(this.invalid=!(b.validate?b.validate(this._inputElementValue):b.checkValidity()));
this._handleValue(b)},_onIronInputValidate:function(){this.invalid=this._inputElement.invalid},_invalidChanged:function(){this._addons&&this.updateAddons({invalid:this.invalid})},updateAddons:function(b){for(var d,f=0;d=this._addons[f];f++)d.update(b)},_computeInputContentClass:function(b,d,f,h,k){var t="input-content";b?(k&&(t+=" label-is-hidden"),h&&(t+=" is-invalid")):(b=this.querySelector("label"),d||k?(t+=" label-is-floating",this.$.labelAndInputContainer.style.position="static",h?t+=" is-invalid":
f&&(t+=" label-is-highlighted")):(b&&(this.$.labelAndInputContainer.style.position="relative"),h&&(t+=" is-invalid")));f&&(t+=" focused");return t},_computeUnderlineClass:function(b,d){var f="underline";d?f+=" is-invalid":b&&(f+=" is-highlighted");return f},_computeAddOnContentClass:function(b,d){var f="add-on-content";d?f+=" is-invalid":b&&(f+=" is-highlighted");return f}});

//# sourceURL=build://paper-input/paper-input-error.html.js
Polymer({is:"paper-input-error",behaviors:[Polymer.PaperInputAddonBehavior],properties:{invalid:{readOnly:!0,reflectToAttribute:!0,type:Boolean}},update:function(b){this._setInvalid(b.invalid)}});

//# sourceURL=build://paper-input/paper-input.html.js
Polymer({is:"paper-input",behaviors:[Polymer.PaperInputBehavior,Polymer.IronFormElementBehavior],properties:{value:{type:String}},beforeRegister:function(){var b="function"==typeof document.createElement("iron-input")._initSlottedInput?"v1":"v0",d=Polymer.DomModule.import("paper-input","template");b=Polymer.DomModule.import("paper-input","template#"+b);(d=d.content.querySelector("#template-placeholder"))&&d.parentNode.replaceChild(b.content,d)},get _focusableElement(){return Polymer.Element?this.inputElement._inputElement:
this.inputElement},listeners:{"iron-input-ready":"_onIronInputReady"},_onIronInputReady:function(){this.$.nativeInput||(this.$.nativeInput=this.$$("input"));this.inputElement&&-1!==this._typesThatHaveText.indexOf(this.$.nativeInput.type)&&(this.alwaysFloatLabel=!0);this.inputElement.bindValue&&this.$.container._handleValueAndAutoValidate(this.inputElement)}});

//# sourceURL=build://iron-fit-behavior/iron-fit-behavior.html.js
Polymer.IronFitBehavior={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},_fitInfo:{type:Object}},get _fitWidth(){return this.fitInto===window?this.fitInto.innerWidth:this.fitInto.getBoundingClientRect().width},
get _fitHeight(){return this.fitInto===window?this.fitInto.innerHeight:this.fitInto.getBoundingClientRect().height},get _fitLeft(){return this.fitInto===window?0:this.fitInto.getBoundingClientRect().left},get _fitTop(){return this.fitInto===window?0:this.fitInto.getBoundingClientRect().top},get _defaultPositionTarget(){var b=Polymer.dom(this).parentNode;b&&b.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&(b=b.host);return b},get _localeHorizontalAlign(){if(this._isRTL){if("right"===this.horizontalAlign)return"left";
if("left"===this.horizontalAlign)return"right"}return this.horizontalAlign},get __shouldPosition(){return(this.horizontalAlign||this.verticalAlign)&&this.positionTarget},attached:function(){"undefined"===typeof this._isRTL&&(this._isRTL="rtl"==window.getComputedStyle(this).direction);this.positionTarget=this.positionTarget||this._defaultPositionTarget;this.autoFitOnAttach&&("none"===window.getComputedStyle(this).display?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 b=window.getComputedStyle(this),d=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:"auto"!==b.top?"top":"auto"!==b.bottom?"bottom":null,horizontally:"auto"!==b.left?"left":"auto"!==b.right?"right":null},sizedBy:{height:"none"!==d.maxHeight,width:"none"!==d.maxWidth,minWidth:parseInt(d.minWidth,10)||0,minHeight:parseInt(d.minHeight,10)||0},margin:{top:parseInt(b.marginTop,10)||0,right:parseInt(b.marginRight,10)||0,bottom:parseInt(b.marginBottom,10)||0,left:parseInt(b.marginLeft,10)||0}}}},resetFit:function(){var b=
this._fitInfo||{},d;for(d in b.sizerInlineStyle)this.sizingTarget.style[d]=b.sizerInlineStyle[d];for(d in b.inlineStyle)this.style[d]=b.inlineStyle[d];this._fitInfo=null},refit:function(){var b=this.sizingTarget.scrollLeft,d=this.sizingTarget.scrollTop;this.resetFit();this.fit();this.sizingTarget.scrollLeft=b;this.sizingTarget.scrollTop=d},position:function(){if(this.__shouldPosition){this._discoverInfo();this.style.position="fixed";this.sizingTarget.style.boxSizing="border-box";this.style.left="0px";
this.style.top="0px";var b=this.getBoundingClientRect(),d=this.__getNormalizedRect(this.positionTarget),f=this.__getNormalizedRect(this.fitInto),h=this._fitInfo.margin,k=this.__getPosition(this._localeHorizontalAlign,this.verticalAlign,{width:b.width+h.left+h.right,height:b.height+h.top+h.bottom},b,d,f);d=k.left+h.left;k=k.top+h.top;var t=Math.min(f.right-h.right,d+b.width),l=Math.min(f.bottom-h.bottom,k+b.height);d=Math.max(f.left+h.left,Math.min(d,t-this._fitInfo.sizedBy.minWidth));k=Math.max(f.top+
h.top,Math.min(k,l-this._fitInfo.sizedBy.minHeight));this.sizingTarget.style.maxWidth=Math.max(t-d,this._fitInfo.sizedBy.minWidth)+"px";this.sizingTarget.style.maxHeight=Math.max(l-k,this._fitInfo.sizedBy.minHeight)+"px";this.style.left=d-b.left+"px";this.style.top=k-b.top+"px"}},constrain:function(){if(!this.__shouldPosition){this._discoverInfo();var b=this._fitInfo;b.positionedBy.vertically||(this.style.position="fixed",this.style.top="0px");b.positionedBy.horizontally||(this.style.position="fixed",
this.style.left="0px");this.sizingTarget.style.boxSizing="border-box";var d=this.getBoundingClientRect();b.sizedBy.height||this.__sizeDimension(d,b.positionedBy.vertically,"top","bottom","Height");b.sizedBy.width||this.__sizeDimension(d,b.positionedBy.horizontally,"left","right","Width")}},_sizeDimension:function(b,d,f,h,k){this.__sizeDimension(b,d,f,h,k)},__sizeDimension:function(b,d,f,h,k){var t=this._fitInfo,l=this.__getNormalizedRect(this.fitInto);l="Width"===k?l.width:l.height;d=d===h;var p=
"offset"+k;this.sizingTarget.style["max"+k]=l-t.margin[d?f:h]-(d?l-b[h]:b[f])-(this[p]-this.sizingTarget[p])+"px"},center:function(){if(!this.__shouldPosition){this._discoverInfo();var b=this._fitInfo.positionedBy;if(!b.vertically||!b.horizontally){this.style.position="fixed";b.vertically||(this.style.top="0px");b.horizontally||(this.style.left="0px");var d=this.getBoundingClientRect(),f=this.__getNormalizedRect(this.fitInto);b.vertically||(this.style.top=f.top-d.top+(f.height-d.height)/2+"px");b.horizontally||
(this.style.left=f.left-d.left+(f.width-d.width)/2+"px")}}},__getNormalizedRect:function(b){return b===document.documentElement||b===window?{top:0,left:0,width:window.innerWidth,height:window.innerHeight,right:window.innerWidth,bottom:window.innerHeight}:b.getBoundingClientRect()},__getOffscreenArea:function(b,d,f){return Math.abs(Math.min(0,b.top)+Math.min(0,f.bottom-(b.top+d.height)))*d.width+Math.abs(Math.min(0,b.left)+Math.min(0,f.right-(b.left+d.width)))*d.height},__getPosition:function(b,d,
f,h,k,t){var l=[{verticalAlign:"top",horizontalAlign:"left",top:k.top+this.verticalOffset,left:k.left+this.horizontalOffset},{verticalAlign:"top",horizontalAlign:"right",top:k.top+this.verticalOffset,left:k.right-f.width-this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"left",top:k.bottom-f.height-this.verticalOffset,left:k.left+this.horizontalOffset},{verticalAlign:"bottom",horizontalAlign:"right",top:k.bottom-f.height-this.verticalOffset,left:k.right-f.width-this.horizontalOffset}];
if(this.noOverlap){for(var p=0,m=l.length;p<m;p++){var n={},q;for(q in l[p])n[q]=l[p][q];l.push(n)}l[0].top=l[1].top+=k.height;l[2].top=l[3].top-=k.height;l[4].left=l[6].left+=k.width;l[5].left=l[7].left-=k.width}d="auto"===d?null:d;b="auto"===b?null:b;b&&"center"!==b||(l.push({verticalAlign:"top",horizontalAlign:"center",top:k.top+this.verticalOffset+(this.noOverlap?k.height:0),left:k.left-h.width/2+k.width/2+this.horizontalOffset}),l.push({verticalAlign:"bottom",horizontalAlign:"center",top:k.bottom-
f.height-this.verticalOffset-(this.noOverlap?k.height:0),left:k.left-h.width/2+k.width/2+this.horizontalOffset}));d&&"middle"!==d||(l.push({verticalAlign:"middle",horizontalAlign:"left",top:k.top-h.height/2+k.height/2+this.verticalOffset,left:k.left+this.horizontalOffset+(this.noOverlap?k.width:0)}),l.push({verticalAlign:"middle",horizontalAlign:"right",top:k.top-h.height/2+k.height/2+this.verticalOffset,left:k.right-f.width-this.horizontalOffset-(this.noOverlap?k.width:0)}));"middle"===d&&"center"===
b&&l.push({verticalAlign:"middle",horizontalAlign:"center",top:k.top-h.height/2+k.height/2+this.verticalOffset,left:k.left-h.width/2+k.width/2+this.horizontalOffset});for(p=0;p<l.length;p++){h=l[p];k=h.verticalAlign===d;m=h.horizontalAlign===b;if(!this.dynamicAlign&&!this.noOverlap&&k&&m){var u=h;break}n=(!d||k)&&(!b||m);if(this.dynamicAlign||n){h.offscreenArea=this.__getOffscreenArea(h,f,t);if(0===h.offscreenArea&&n){u=h;break}u=u||h;n=h.offscreenArea-u.offscreenArea;if(0>n||0===n&&(k||m))u=h}}return u}};

//# sourceURL=build://iron-resizable-behavior/iron-resizable-behavior.html.js
Polymer.IronResizableBehavior={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)},attached:function(){this._requestResizeNotifications()},detached:function(){this._parentResizable?this._parentResizable.stopResizeNotificationsFor(this):window.removeEventListener("resize",
this._boundNotifyResize);this._parentResizable=null},notifyResize:function(){this.isAttached&&(this._interestedResizables.forEach(function(b){this.resizerShouldNotify(b)&&this._notifyDescendant(b)},this),this._fireResize())},assignParentResizable:function(b){this._parentResizable=b},stopResizeNotificationsFor:function(b){var d=this._interestedResizables.indexOf(b);-1<d&&(this._interestedResizables.splice(d,1),this.unlisten(b,"iron-resize","_onDescendantIronResize"))},resizerShouldNotify:function(){return!0},
_onDescendantIronResize:function(b){this._notifyingDescendant?b.stopPropagation():Polymer.Settings.useShadow||this._fireResize()},_fireResize:function(){this.fire("iron-resize",null,{node:this,bubbles:!1})},_onIronRequestResizeNotifications:function(b){var d=Polymer.dom(b).rootTarget;d!==this&&(-1===this._interestedResizables.indexOf(d)&&(this._interestedResizables.push(d),this.listen(d,"iron-resize","_onDescendantIronResize")),d.assignParentResizable(this),this._notifyDescendant(d),b.stopPropagation())},
_parentResizableChanged:function(b){b&&window.removeEventListener("resize",this._boundNotifyResize)},_notifyDescendant:function(b){this.isAttached&&(this._notifyingDescendant=!0,b.notifyResize(),this._notifyingDescendant=!1)},_requestResizeNotifications:function(){if(this.isAttached)if("loading"===document.readyState){var b=this._requestResizeNotifications.bind(this);document.addEventListener("readystatechange",function f(){document.removeEventListener("readystatechange",f);b()})}else this.fire("iron-request-resize-notifications",
null,{node:this,bubbles:!0,cancelable:!0}),this._parentResizable||(window.addEventListener("resize",this._boundNotifyResize),this.notifyResize())}};

//# sourceURL=build://iron-overlay-behavior/iron-overlay-backdrop.html.js
(function(){Polymer({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&&Polymer.dom(document.body).appendChild(this)},open:function(){this.opened=!0},close:function(){this.opened=!1},complete:function(){this.opened||this.parentNode!==
document.body||Polymer.dom(this.parentNode).removeChild(this)},_onTransitionend:function(b){b&&b.target===this&&this.complete()},_openedChanged:function(b){b?this.prepare():(b=window.getComputedStyle(this),"0s"!==b.transitionDuration&&0!=b.opacity||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)))}})})();

//# sourceURL=build://iron-overlay-behavior/iron-overlay-manager.html.js
Polymer.IronOverlayManagerClass=function(){this._overlays=[];this._minimumZ=101;this._backdropElement=null;Polymer.Gestures.add(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)};
Polymer.IronOverlayManagerClass.prototype={constructor:Polymer.IronOverlayManagerClass,get backdropElement(){this._backdropElement||(this._backdropElement=document.createElement("iron-overlay-backdrop"));return this._backdropElement},get deepActiveElement(){var b=document.activeElement;b&&!1!==b instanceof Element||(b=document.body);for(;b.root&&Polymer.dom(b.root).activeElement;)b=Polymer.dom(b.root).activeElement;return b},_bringOverlayAtIndexToFront:function(b){var d=this._overlays[b];if(d){var f=
this._overlays.length-1,h=this._overlays[f];h&&this._shouldBeBehindOverlay(d,h)&&f--;if(!(b>=f)){h=Math.max(this.currentOverlayZ(),this._minimumZ);for(this._getZ(d)<=h&&this._applyOverlayZ(d,h);b<f;)this._overlays[b]=this._overlays[b+1],b++;this._overlays[f]=d}}},addOrRemoveOverlay:function(b){b.opened?this.addOverlay(b):this.removeOverlay(b)},addOverlay:function(b){var d=this._overlays.indexOf(b);if(0<=d)this._bringOverlayAtIndexToFront(d);else{d=this._overlays.length;var f=this._overlays[d-1],h=
Math.max(this._getZ(f),this._minimumZ),k=this._getZ(b);f&&this._shouldBeBehindOverlay(b,f)&&(this._applyOverlayZ(f,h),d--,h=Math.max(this._getZ(this._overlays[d-1]),this._minimumZ));k<=h&&this._applyOverlayZ(b,h);this._overlays.splice(d,0,b)}this.trackBackdrop()},removeOverlay:function(b){b=this._overlays.indexOf(b);-1!==b&&(this._overlays.splice(b,1),this.trackBackdrop())},currentOverlay:function(){return this._overlays[this._overlays.length-1]},currentOverlayZ:function(){return this._getZ(this.currentOverlay())},
ensureMinimumZ:function(b){this._minimumZ=Math.max(this._minimumZ,b)},focusOverlay:function(){var b=this.currentOverlay();b&&b._applyFocus()},trackBackdrop:function(){var b=this._overlayWithBackdrop();if(b||this._backdropElement)this.backdropElement.style.zIndex=this._getZ(b)-1,this.backdropElement.opened=!!b,this.backdropElement.prepare()},getBackdrops:function(){for(var b=[],d=0;d<this._overlays.length;d++)this._overlays[d].withBackdrop&&b.push(this._overlays[d]);return b},backdropZ:function(){return this._getZ(this._overlayWithBackdrop())-
1},_overlayWithBackdrop:function(){for(var b=this._overlays.length-1;0<=b;b--)if(this._overlays[b].withBackdrop)return this._overlays[b]},_getZ:function(b){var d=this._minimumZ;b&&(b=Number(b.style.zIndex||window.getComputedStyle(b).zIndex),b===b&&(d=b));return d},_setZ:function(b,d){b.style.zIndex=d},_applyOverlayZ:function(b,d){this._setZ(b,d+2)},_overlayInPath:function(b){b=b||[];for(var d=0;d<b.length;d++)if(b[d]._manager===this)return b[d]},_onCaptureClick:function(b){var d=this._overlays.length-
1;if(-1!==d)for(var f=Polymer.dom(b).path,h;(h=this._overlays[d])&&this._overlayInPath(f)!==h;)if(h._onCaptureClick(b),h.allowClickThrough)d--;else break},_onCaptureFocus:function(b){var d=this.currentOverlay();d&&d._onCaptureFocus(b)},_onCaptureKeyDown:function(b){var d=this.currentOverlay();d&&(Polymer.IronA11yKeysBehavior.keyboardEventMatchesKeys(b,"esc")?d._onCaptureEsc(b):Polymer.IronA11yKeysBehavior.keyboardEventMatchesKeys(b,"tab")&&d._onCaptureTab(b))},_shouldBeBehindOverlay:function(b,d){return!b.alwaysOnTop&&
d.alwaysOnTop}};Polymer.IronOverlayManager=new Polymer.IronOverlayManagerClass;

//# sourceURL=build://iron-overlay-behavior/iron-scroll-manager.html.js
(function(){var b=0,d=0,f=null,h=[],k=["wheel","mousewheel","DOMMouseScroll","touchstart","touchmove"];Polymer.IronScrollManager={get currentLockingElement(){return this._lockingElements[this._lockingElements.length-1]},elementIsScrollLocked:function(t){var l=this.currentLockingElement;if(void 0===l)return!1;if(this._hasCachedLockedElement(t))return!0;if(this._hasCachedUnlockedElement(t))return!1;(l=!!l&&l!==t&&!this._composedTreeContains(l,t))?this._lockedElementCache.push(t):this._unlockedElementCache.push(t);
return l},pushScrollLock:function(t){0<=this._lockingElements.indexOf(t)||(0===this._lockingElements.length&&this._lockScrollInteractions(),this._lockingElements.push(t),this._lockedElementCache=[],this._unlockedElementCache=[])},removeScrollLock:function(t){t=this._lockingElements.indexOf(t);-1!==t&&(this._lockingElements.splice(t,1),this._lockedElementCache=[],this._unlockedElementCache=[],0===this._lockingElements.length&&this._unlockScrollInteractions())},_lockingElements:[],_lockedElementCache:null,
_unlockedElementCache:null,_hasCachedLockedElement:function(t){return-1<this._lockedElementCache.indexOf(t)},_hasCachedUnlockedElement:function(t){return-1<this._unlockedElementCache.indexOf(t)},_composedTreeContains:function(t,l){var p,m;if(t.contains(l))return!0;t=Polymer.dom(t).querySelectorAll("content,slot");for(p=0;p<t.length;++p){var n=Polymer.dom(t[p]).getDistributedNodes();for(m=0;m<n.length;++m)if(n[m].nodeType===Node.ELEMENT_NODE&&this._composedTreeContains(n[m],l))return!0}return!1},_scrollInteractionHandler:function(t){t.cancelable&&
this._shouldPreventScrolling(t)&&t.preventDefault();t.targetTouches&&(t=t.targetTouches[0],b=t.pageX,d=t.pageY)},_lockScrollInteractions:function(){this._boundScrollHandler=this._boundScrollHandler||this._scrollInteractionHandler.bind(this);for(var t=0,l=k.length;t<l;t++)document.addEventListener(k[t],this._boundScrollHandler,{capture:!0,passive:!1})},_unlockScrollInteractions:function(){for(var t=0,l=k.length;t<l;t++)document.removeEventListener(k[t],this._boundScrollHandler,{capture:!0,passive:!1})},
_shouldPreventScrolling:function(t){var l=Polymer.dom(t).rootTarget;"touchmove"!==t.type&&f!==l&&(f=l,h=this._getScrollableNodes(Polymer.dom(t).path));if(!h.length)return!0;if("touchstart"===t.type)return!1;t=this._getScrollInfo(t);return!this._getScrollingNode(h,t.deltaX,t.deltaY)},_getScrollableNodes:function(t){for(var l=[],p=t.indexOf(this.currentLockingElement),m=0;m<=p;m++)if(t[m].nodeType===Node.ELEMENT_NODE){var n=t[m],q=n.style;"scroll"!==q.overflow&&"auto"!==q.overflow&&(q=window.getComputedStyle(n));
"scroll"!==q.overflow&&"auto"!==q.overflow||l.push(n)}return l},_getScrollingNode:function(t,l,p){if(l||p)for(var m=Math.abs(p)>=Math.abs(l),n=0;n<t.length;n++){var q=t[n];if(m?0>p?0<q.scrollTop:q.scrollTop<q.scrollHeight-q.clientHeight:0>l?0<q.scrollLeft:q.scrollLeft<q.scrollWidth-q.clientWidth)return q}},_getScrollInfo:function(t){var l={deltaX:t.deltaX,deltaY:t.deltaY};"deltaX"in t||("wheelDeltaX"in t&&"wheelDeltaY"in t?(l.deltaX=-t.wheelDeltaX,l.deltaY=-t.wheelDeltaY):"wheelDelta"in t?(l.deltaX=
0,l.deltaY=-t.wheelDelta):"axis"in t?(l.deltaX=1===t.axis?t.detail:0,l.deltaY=2===t.axis?t.detail:0):t.targetTouches&&(t=t.targetTouches[0],l.deltaX=b-t.pageX,l.deltaY=d-t.pageY));return l}}})();

//# sourceURL=build://iron-overlay-behavior/iron-focusables-helper.html.js
(function(){var b=Element.prototype,d=b.matches||b.matchesSelector||b.mozMatchesSelector||b.msMatchesSelector||b.oMatchesSelector||b.webkitMatchesSelector;Polymer.IronFocusablesHelper={getTabbableNodes:function(f){var h=[];return this._collectTabbableNodes(f,h)?this._sortByTabIndex(h):h},isFocusable:function(f){return d.call(f,"input, select, textarea, button, object")?d.call(f,":not([disabled])"):d.call(f,"a[href], area[href], iframe, [tabindex], [contentEditable]")},isTabbable:function(f){return this.isFocusable(f)&&
d.call(f,':not([tabindex\x3d"-1"])')&&this._isVisible(f)},_normalizedTabIndex:function(f){return this.isFocusable(f)?(f=f.getAttribute("tabindex")||0,Number(f)):-1},_collectTabbableNodes:function(f,h){if(f.nodeType!==Node.ELEMENT_NODE||!this._isVisible(f))return!1;var k=this._normalizedTabIndex(f),t=0<k;0<=k&&h.push(f);f="content"===f.localName||"slot"===f.localName?Polymer.dom(f).getDistributedNodes():Polymer.dom(f.root||f).children;for(k=0;k<f.length;k++)t=this._collectTabbableNodes(f[k],h)||t;
return t},_isVisible:function(f){var h=f.style;return"hidden"!==h.visibility&&"none"!==h.display?(h=window.getComputedStyle(f),"hidden"!==h.visibility&&"none"!==h.display):!1},_sortByTabIndex:function(f){var h=f.length;if(2>h)return f;var k=Math.ceil(h/2);h=this._sortByTabIndex(f.slice(0,k));f=this._sortByTabIndex(f.slice(k));return this._mergeSortByTabIndex(h,f)},_mergeSortByTabIndex:function(f,h){for(var k=[];0<f.length&&0<h.length;)this._hasLowerTabOrder(f[0],h[0])?k.push(h.shift()):k.push(f.shift());
return k.concat(f,h)},_hasLowerTabOrder:function(f,h){f=Math.max(f.tabIndex,0);h=Math.max(h.tabIndex,0);return 0===f||0===h?h>f:f>h}}})();

//# sourceURL=build://iron-overlay-behavior/iron-overlay-behavior.html.js
(function(){Polymer.IronOverlayBehaviorImpl={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:Polymer.IronOverlayManager},_focusedChild:{type:Object}},listeners:{"iron-resize":"_onIronResize"},observers:["__updateScrollObservers(isAttached, opened, scrollAction)"],get backdropElement(){return this._manager.backdropElement},get _focusNode(){return this._focusedChild||Polymer.dom(this).querySelector("[autofocus]")||this},get _focusableNodes(){return Polymer.IronFocusablesHelper.getTabbableNodes(this)},ready:function(){this.__shouldRemoveTabIndex=
this.__isAnimating=!1;this.__firstFocusableNode=this.__lastFocusableNode=null;this.__rafs={};this.__scrollTop=this.__scrollLeft=this.__restoreFocusNode=null;this.__onCaptureScroll=this.__onCaptureScroll.bind(this);this.__rootNodes=null;this._ensureSetup()},attached:function(){this.opened&&this._openedChanged(this.opened);this._observer=Polymer.dom(this).observeNodes(this._onNodesChange)},detached:function(){Polymer.dom(this).unobserveNodes(this._observer);this._observer=null;for(var b in this.__rafs)null!==
this.__rafs[b]&&cancelAnimationFrame(this.__rafs[b]);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(b){this.fire("iron-overlay-canceled",b,{cancelable:!0}).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(b){b?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{this._focusNode.blur();this._focusedChild=null;if(this.restoreFocusOnClose&&
this.__restoreFocusNode){var b=this._manager.deepActiveElement;(b===document.body||Polymer.dom(this).deepContains(b))&&this.__restoreFocusNode.focus()}this.__restoreFocusNode=null;(b=this._manager.currentOverlay())&&this!==b&&b._applyFocus()}},_onCaptureClick:function(b){this.noCancelOnOutsideClick||this.cancel(b)},_onCaptureFocus:function(b){if(this.withBackdrop){var d=Polymer.dom(b).path;-1===d.indexOf(this)?(b.stopPropagation(),this._applyFocus()):this._focusedChild=d[0]}},_onCaptureEsc:function(b){this.noCancelOnEscKey||
this.cancel(b)},_onCaptureTab:function(b){if(this.withBackdrop){this.__ensureFirstLastFocusables();var d=b.shiftKey,f=d?this.__firstFocusableNode:this.__lastFocusableNode;d=d?this.__lastFocusableNode:this.__firstFocusableNode;if(f===d)f=!0;else{var h=this._manager.deepActiveElement;f=h===f||h===this}f&&(b.preventDefault(),this._focusedChild=d,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(){if(!this.__firstFocusableNode||!this.__lastFocusableNode){var b=this._focusableNodes;this.__firstFocusableNode=b[0];this.__lastFocusableNode=b[b.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(b,d){var f=this.__rafs;
null!==f[b]&&cancelAnimationFrame(f[b]);f[b]=requestAnimationFrame(function(){f[b]=null;d.call(this)}.bind(this))},__updateScrollObservers:function(b,d,f){b&&d&&this.__isValidScrollAction(f)?("lock"===f&&(this.__saveScrollPosition(),Polymer.IronScrollManager.pushScrollLock(this)),this.__addScrollListeners()):(Polymer.IronScrollManager.removeScrollLock(this),this.__removeScrollListeners())},__addScrollListeners:function(){if(!this.__rootNodes){this.__rootNodes=[];if(Polymer.Settings.useShadow)for(var b=
this;b;)b.nodeType===Node.DOCUMENT_FRAGMENT_NODE&&b.host&&this.__rootNodes.push(b),b=b.host||b.assignedSlot||b.parentNode;this.__rootNodes.push(document)}this.__rootNodes.forEach(function(d){d.addEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})},this)},__removeScrollListeners:function(){this.__rootNodes&&this.__rootNodes.forEach(function(b){b.removeEventListener("scroll",this.__onCaptureScroll,{capture:!0,passive:!0})},this);this.isAttached||(this.__rootNodes=null)},__isValidScrollAction:function(b){return"lock"===
b||"refit"===b||"cancel"===b},__onCaptureScroll:function(b){if(!(this.__isAnimating||0<=Polymer.dom(b).path.indexOf(this)))switch(this.scrollAction){case "lock":this.__restoreScrollPosition();break;case "refit":this.__deraf("refit",this.refit);break;case "cancel":this.cancel(b)}},__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)}};Polymer.IronOverlayBehavior=[Polymer.IronFitBehavior,Polymer.IronResizableBehavior,
Polymer.IronOverlayBehaviorImpl]})();

//# sourceURL=build://neon-animation/neon-animatable-behavior.html.js
Polymer.NeonAnimatableBehavior={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(b,
d){for(var f in d)b[f]=d[f]},_cloneConfig:function(b){var d={isClone:!0};this._copyProperties(d,b);return d},_getAnimationConfigRecursive:function(b,d,f){if(this.animationConfig)if(this.animationConfig.value&&"function"===typeof this.animationConfig.value)this._warn(this._logf("playAnimation","Please put 'animationConfig' inside of your components 'properties' object instead of outside of it."));else{var h=b?this.animationConfig[b]:this.animationConfig;Array.isArray(h)||(h=[h]);if(h)for(var k,t=0;k=
h[t];t++)if(k.animatable)k.animatable._getAnimationConfigRecursive(k.type||b,d,f);else if(k.id){var l=d[k.id];l?(l.isClone||(d[k.id]=this._cloneConfig(l),l=d[k.id]),this._copyProperties(l,k)):d[k.id]=k}else f.push(k)}},getAnimationConfig:function(b){var d={},f=[];this._getAnimationConfigRecursive(b,d,f);for(var h in d)f.push(d[h]);return f}};

//# sourceURL=build://neon-animation/neon-animation-runner-behavior.html.js
Polymer.NeonAnimationRunnerBehaviorImpl={_configureAnimations:function(b){var d=[],f=[];if(0<b.length)for(var h,k=0;h=b[k];k++){var t=document.createElement(h.name);if(t.isNeonAnimation){var l=null;t.configure||(t.configure=function(){return null});l=t.configure(h);f.push({result:l,config:h})}else console.warn(this.is+":",h.name,"not found!")}for(b=0;b<f.length;b++){l=f[b].result;h=f[b].config;try{"function"!=typeof l.cancel&&(l=document.timeline.play(l))}catch(p){l=null,console.warn("Couldnt play",
"(",h.name,").",p)}l&&d.push({neonAnimation:t,config:h,animation:l})}return d},_shouldComplete:function(b){for(var d=!0,f=0;f<b.length;f++)if("finished"!=b[f].animation.playState){d=!1;break}return d},_complete:function(b){for(var d=0;d<b.length;d++)b[d].neonAnimation.complete(b[d].config);for(d=0;d<b.length;d++)b[d].animation.cancel()},playAnimation:function(b,d){var f=this.getAnimationConfig(b);if(f){this._active=this._active||{};this._active[b]&&(this._complete(this._active[b]),delete this._active[b]);
var h=this._configureAnimations(f);if(0==h.length)this.fire("neon-animation-finish",d,{bubbles:!1});else for(this._active[b]=h,f=0;f<h.length;f++)h[f].animation.onfinish=function(){this._shouldComplete(h)&&(this._complete(h),delete this._active[b],this.fire("neon-animation-finish",d,{bubbles:!1}))}.bind(this)}},cancelAnimation:function(){for(var b in this._active){var d=this._active[b],f;for(f in d)d[f].animation.cancel()}this._active={}}};
Polymer.NeonAnimationRunnerBehavior=[Polymer.NeonAnimatableBehavior,Polymer.NeonAnimationRunnerBehaviorImpl];

//# sourceURL=build://iron-dropdown/iron-dropdown-scroll-manager.html.js
(function(){Polymer.IronDropdownScrollManager=Polymer.IronScrollManager})();

//# sourceURL=build://iron-dropdown/iron-dropdown.html.js
(function(){Polymer({is:"iron-dropdown",behaviors:[Polymer.IronControlState,Polymer.IronA11yKeysBehavior,Polymer.IronOverlayBehavior,Polymer.NeonAnimationRunnerBehavior],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 b=Polymer.dom(this.$.content).getDistributedNodes(),d=0,f=b.length;d<f;d++)if(b[d].nodeType===Node.ELEMENT_NODE)return b[d]},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(),Polymer.IronOverlayBehaviorImpl._openedChanged.apply(this,arguments))},_renderOpened:function(){!this.noAnimations&&this.animationConfig.open?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("open")):Polymer.IronOverlayBehaviorImpl._renderOpened.apply(this,arguments)},
_renderClosed:function(){!this.noAnimations&&this.animationConfig.close?(this.$.contentWrapper.classList.add("animating"),this.playAnimation("close")):Polymer.IronOverlayBehaviorImpl._renderClosed.apply(this,arguments)},_onNeonAnimationFinish:function(){this.$.contentWrapper.classList.remove("animating");this.opened?this._finishRenderOpened():this._finishRenderClosed()},_updateAnimationConfig:function(){for(var b=this.containedElement,d=[].concat(this.openAnimationConfig||[]).concat(this.closeAnimationConfig||
[]),f=0;f<d.length;f++)d[f].node=b;this.animationConfig={open:this.openAnimationConfig,close:this.closeAnimationConfig}},_updateOverlayPosition:function(){this.isAttached&&this.notifyResize()},_allowOutsideScrollChanged:function(b){this._readied&&(b?this.scrollAction&&"lock"!==this.scrollAction||(this.scrollAction="refit"):this.scrollAction="lock")},_applyFocus:function(){var b=this.focusTarget||this.containedElement;b&&this.opened&&!this.noAutoFocus?b.focus():Polymer.IronOverlayBehaviorImpl._applyFocus.apply(this,
arguments)}})})();

//# sourceURL=build://neon-animation/neon-animation-behavior.html.js
Polymer.NeonAnimationBehavior={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(b){if(b.timing)for(var d in b.timing)this.animationTiming[d]=b.timing[d];return this.animationTiming},setPrefixedProperty:function(b,d,f){for(var h=
{transform:["webkitTransform"],transformOrigin:["mozTransformOrigin","webkitTransformOrigin"]}[d],k,t=0;k=h[t];t++)b.style[k]=f;b.style[d]=f},complete:function(){}};

//# sourceURL=build://neon-animation/animations/fade-in-animation.html.js
Polymer({is:"fade-in-animation",behaviors:[Polymer.NeonAnimationBehavior],configure:function(b){return this._effect=new KeyframeEffect(b.node,[{opacity:"0"},{opacity:"1"}],this.timingFromConfig(b))}});

//# sourceURL=build://neon-animation/animations/fade-out-animation.html.js
Polymer({is:"fade-out-animation",behaviors:[Polymer.NeonAnimationBehavior],configure:function(b){return this._effect=new KeyframeEffect(b.node,[{opacity:"1"},{opacity:"0"}],this.timingFromConfig(b))}});

//# sourceURL=build://paper-menu-button/paper-menu-button-animations.html.js
Polymer({is:"paper-menu-grow-height-animation",behaviors:[Polymer.NeonAnimationBehavior],configure:function(b){var d=b.node,f=d.getBoundingClientRect().height;return this._effect=new KeyframeEffect(d,[{height:f/2+"px"},{height:f+"px"}],this.timingFromConfig(b))}});Polymer({is:"paper-menu-grow-width-animation",behaviors:[Polymer.NeonAnimationBehavior],configure:function(b){var d=b.node,f=d.getBoundingClientRect().width;return this._effect=new KeyframeEffect(d,[{width:f/2+"px"},{width:f+"px"}],this.timingFromConfig(b))}});
Polymer({is:"paper-menu-shrink-width-animation",behaviors:[Polymer.NeonAnimationBehavior],configure:function(b){var d=b.node,f=d.getBoundingClientRect().width;return this._effect=new KeyframeEffect(d,[{width:f+"px"},{width:f-f/20+"px"}],this.timingFromConfig(b))}});
Polymer({is:"paper-menu-shrink-height-animation",behaviors:[Polymer.NeonAnimationBehavior],configure:function(b){var d=b.node,f=d.getBoundingClientRect().height;this.setPrefixedProperty(d,"transformOrigin","0 0");return this._effect=new KeyframeEffect(d,[{height:f+"px",transform:"translateY(0)"},{height:f/2+"px",transform:"translateY(-20px)"}],this.timingFromConfig(b))}});

//# sourceURL=build://paper-menu-button/paper-menu-button.html.js
(function(){var b={ANIMATION_CUBIC_BEZIER:"cubic-bezier(.3,.95,.5,1)",MAX_ANIMATION_TIME_MS:400};Polymer.PaperMenuButton=function(){};Polymer.PaperMenuButton.prototype.registered=function(){};Polymer.PaperMenuButton.prototype.addOwnKeyBinding=function(){};Polymer.PaperMenuButton.prototype.removeOwnKeyBindings=function(){};Polymer.PaperMenuButton.prototype.keyboardEventMatchesKeys=function(){};Polymer.PaperMenuButton.prototype._collectKeyBindings=function(){};Polymer.PaperMenuButton.prototype._prepKeyBindings=
function(){};Polymer.PaperMenuButton.prototype._addKeyBinding=function(){};Polymer.PaperMenuButton.prototype._resetKeyEventListeners=function(){};Polymer.PaperMenuButton.prototype._listenKeyEventListeners=function(){};Polymer.PaperMenuButton.prototype._unlistenKeyEventListeners=function(){};Polymer.PaperMenuButton.prototype._onKeyBindingEvent=function(){};Polymer.PaperMenuButton.prototype._triggerKeyHandler=function(){};Polymer.PaperMenuButton.prototype._focusBlurHandler=function(d){if(Polymer.Element)this._setFocused("focus"===
d.type);else if(d.target===this)this._setFocused("focus"===d.type);else if(this.__handleEventRetargeting){var f=Polymer.dom(d).localTarget;this.isLightDescendant(f)||this.fire(d.type,{sourceEvent:d},{node:this,bubbles:d.bubbles,cancelable:d.cancelable})}};Polymer.PaperMenuButton.prototype._changedControlState=function(){this._controlStateChanged&&this._controlStateChanged()};Polymer.PaperMenuButton.prototype._setFocused=function(){};Polymer.PaperMenuButton=Polymer({is:"paper-menu-button",behaviors:[Polymer.IronA11yKeysBehavior,
Polymer.IronControlState],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:b.ANIMATION_CUBIC_BEZIER}},{name:"paper-menu-grow-height-animation",timing:{delay:100,duration:275,easing:b.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:b.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},_dropdownContent:{type:Object}},hostAttributes:{role:"group","aria-haspopup":"true"},listeners:{"iron-activate":"_onIronActivate","iron-select":"_onIronSelect"},get contentElement(){for(var d=Polymer.dom(this.$.content).getDistributedNodes(),f=0,h=d.length;f<h;f++)if(d[f].nodeType===Node.ELEMENT_NODE)return d[f]},toggle:function(){this.opened?
this.close():this.open()},open:function(){this.disabled||this.$.dropdown.open()},close:function(){this.$.dropdown.close()},_onIronSelect:function(){this.ignoreSelect||this.close()},_onIronActivate:function(){this.closeOnActivate&&this.close()},_openedChanged:function(d,f){d?(this._dropdownContent=this.contentElement,this.fire("paper-dropdown-open")):null!=f&&this.fire("paper-dropdown-close")},_disabledChanged:function(d){Polymer.IronControlState._disabledChanged.apply(this,arguments);d&&this.opened&&
this.close()},__onIronOverlayCanceled:function(d){var f=this.$.trigger;-1<Polymer.dom(d.detail).path.indexOf(f)&&d.preventDefault()}});Object.keys(b).forEach(function(d){Polymer.PaperMenuButton[d]=b[d]})})();

//# sourceURL=build://iron-iconset-svg/iron-iconset-svg.html.js
Polymer({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 Polymer.IronMeta({type:"iconset",key:null,value:null})},attached:function(){this.style.display="none"},getIconNames:function(){this._icons=this._createIconMap();return Object.keys(this._icons).map(function(b){return this.name+":"+b},this)},applyIcon:function(b,d){this.removeIcon(b);
if(d=this._cloneIcon(d,this.rtlMirroring&&this._targetIsRTL(b))){var f=Polymer.dom(b.root||b);f.insertBefore(d,f.childNodes[0]);return b._svgIcon=d}return null},removeIcon:function(b){b._svgIcon&&(Polymer.dom(b.root||b).removeChild(b._svgIcon),b._svgIcon=null)},_targetIsRTL:function(b){null==this.__targetIsRTL&&(this.useGlobalRtlAttribute?this.__targetIsRTL="rtl"===(document.body&&document.body.hasAttribute("dir")?document.body:document.documentElement).getAttribute("dir"):(b&&b.nodeType!==Node.ELEMENT_NODE&&
(b=b.host),this.__targetIsRTL=b&&"rtl"===window.getComputedStyle(b).direction));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 b=Object.create(null);Polymer.dom(this).querySelectorAll("[id]").forEach(function(d){b[d.id]=d});return b},_cloneIcon:function(b,d){this._icons=this._icons||this._createIconMap();return this._prepareSvgClone(this._icons[b],
this.size,d)},_prepareSvgClone:function(b,d,f){if(b){b=b.cloneNode(!0);var h=document.createElementNS("http://www.w3.org/2000/svg","svg");d=b.getAttribute("viewBox")||"0 0 "+d+" "+d;var k="pointer-events: none; display: block; width: 100%; height: 100%;";f&&b.hasAttribute("mirror-in-rtl")&&(k+="-webkit-transform:scale(-1,1);transform:scale(-1,1);transform-origin:center;");h.setAttribute("viewBox",d);h.setAttribute("preserveAspectRatio","xMidYMid meet");h.setAttribute("focusable","false");h.style.cssText=
k;h.appendChild(b).removeAttribute("id");return h}return null}});

//# sourceURL=build://paper-dropdown-menu/paper-dropdown-menu.html.js
(function(){Polymer({is:"paper-dropdown-menu",behaviors:[Polymer.IronButtonState,Polymer.IronControlState,Polymer.IronFormElementBehavior,Polymer.IronValidatableBehavior],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}},listeners:{tap:"_onTap"},keyBindings:{"up down":"open",esc:"close"},hostAttributes:{role:"combobox","aria-autocomplete":"none","aria-haspopup":"true"},observers:["_selectedItemChanged(selectedItem)"],attached:function(){var b=
this.contentElement;b&&b.selectedItem&&this._setSelectedItem(b.selectedItem)},get contentElement(){for(var b=Polymer.dom(this.$.content).getDistributedNodes(),d=0,f=b.length;d<f;d++)if(b[d].nodeType===Node.ELEMENT_NODE)return b[d]},open:function(){this.$.menuButton.open()},close:function(){this.$.menuButton.close()},_onIronSelect:function(b){this._setSelectedItem(b.detail.item)},_onIronDeselect:function(){this._setSelectedItem(null)},_onTap:function(b){Polymer.Gestures.findOriginalTarget(b)===this&&
this.open()},_selectedItemChanged:function(b){this.value=b=b?b.label||b.getAttribute("label")||b.textContent.trim():"";this._setSelectedItemLabel(b)},_computeMenuVerticalOffset:function(b,d){return d?d:b?-4:8},_getValidity:function(){return this.disabled||!this.required||this.required&&!!this.value},_openedChanged:function(){var b=this.opened?"true":"false",d=this.contentElement;d&&d.setAttribute("aria-expanded",b)}})})();

//# sourceURL=build://iron-selector/iron-selection.html.js
Polymer.IronSelection=function(b){this.selection=[];this.selectCallback=b};
Polymer.IronSelection.prototype={get:function(){return this.multi?this.selection.slice():this.selection[0]},clear:function(b){this.selection.slice().forEach(function(d){(!b||0>b.indexOf(d))&&this.setItemSelected(d,!1)},this)},isSelected:function(b){return 0<=this.selection.indexOf(b)},setItemSelected:function(b,d){if(null!=b&&d!==this.isSelected(b)){if(d)this.selection.push(b);else{var f=this.selection.indexOf(b);0<=f&&this.selection.splice(f,1)}this.selectCallback&&this.selectCallback(b,d)}},select:function(b){this.multi?
this.toggle(b):this.get()!==b&&(this.setItemSelected(this.get(),!1),this.setItemSelected(b,!0))},toggle:function(b){this.setItemSelected(b,!this.isSelected(b))}};

//# sourceURL=build://iron-selector/iron-selectable.html.js
Polymer.IronSelectableBehavior={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 Polymer.IronSelection(this._applySelection.bind(this))},attached:function(){this._observer=this._observeItems(this);this._addListener(this.activateEvent)},detached:function(){this._observer&&Polymer.dom(this).unobserveNodes(this._observer);this._removeListener(this.activateEvent)},
indexOf:function(b){return this.items?this.items.indexOf(b):-1},select:function(b){this.selected=b},selectPrevious:function(){var b=this.items.length;b=(Number(this._valueToIndex(this.selected))-1+b)%b;this.selected=this._indexToValue(b)},selectNext:function(){var b=(Number(this._valueToIndex(this.selected))+1)%this.items.length;this.selected=this._indexToValue(b)},selectIndex:function(b){this.select(this._indexToValue(b))},forceSynchronousItemUpdate:function(){this._observer&&"function"===typeof this._observer.flush?
this._observer.flush():this._updateItems()},get _shouldUpdateSelection(){return null!=this.selected},_checkFallback:function(){this._updateSelected()},_addListener:function(b){this.listen(this,b,"_activateHandler")},_removeListener:function(b){this.unlisten(this,b,"_activateHandler")},_activateEventChanged:function(b,d){this._removeListener(d);this._addListener(b)},_updateItems:function(){var b=Polymer.dom(this).queryDistributedElements(this.selectable||"*");b=Array.prototype.filter.call(b,this._bindFilterItem);
this._setItems(b)},_updateAttrForSelected:function(){this.selectedItem&&(this.selected=this._valueForItem(this.selectedItem))},_updateSelected:function(){this._selectSelected(this.selected)},_selectSelected:function(){if(this.items){var b=this._valueToItem(this.selected);b?this._selection.select(b):this._selection.clear();this.fallbackSelection&&this.items.length&&void 0===this._selection.get()&&(this.selected=this.fallbackSelection)}},_filterItem:function(b){return!this._excludedLocalNames[b.localName]},
_valueToItem:function(b){return null==b?null:this.items[this._valueToIndex(b)]},_valueToIndex:function(b){if(this.attrForSelected)for(var d=0,f;f=this.items[d];d++){if(this._valueForItem(f)==b)return d}else return Number(b)},_indexToValue:function(b){if(this.attrForSelected){if(b=this.items[b])return this._valueForItem(b)}else return b},_valueForItem:function(b){if(!b)return null;if(!this.attrForSelected)return b=this.indexOf(b),-1===b?null:b;var d=b[Polymer.CaseMap.dashToCamelCase(this.attrForSelected)];
return void 0!=d?d:b.getAttribute(this.attrForSelected)},_applySelection:function(b,d){this.selectedClass&&this.toggleClass(this.selectedClass,d,b);this.selectedAttribute&&this.toggleAttribute(this.selectedAttribute,d,b);this._selectionChange();this.fire("iron-"+(d?"select":"deselect"),{item:b})},_selectionChange:function(){this._setSelectedItem(this._selection.get())},_observeItems:function(b){return Polymer.dom(b).observeNodes(function(d){this._updateItems();this._updateSelected();this.fire("iron-items-changed",
d,{bubbles:!1,cancelable:!1})})},_activateHandler:function(b){b=b.target;for(var d=this.items;b&&b!=this;){var f=d.indexOf(b);if(0<=f){d=this._indexToValue(f);this._itemActivate(d,b);break}b=b.parentNode}},_itemActivate:function(b,d){this.fire("iron-activate",{selected:b,item:d},{cancelable:!0}).defaultPrevented||this.select(b)}};

//# sourceURL=build://iron-selector/iron-multi-selectable.html.js
Polymer.IronMultiSelectableBehaviorImpl={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(b){this.multi?this._toggleSelected(b):this.selected=b},multiChanged:function(b){this._selection.multi=b;this._updateSelected()},get _shouldUpdateSelection(){return null!=this.selected||
null!=this.selectedValues&&this.selectedValues.length},_updateAttrForSelected:function(){this.multi?this.selectedItems&&0<this.selectedItems.length&&(this.selectedValues=this.selectedItems.map(function(b){return this._indexToValue(this.indexOf(b))},this).filter(function(b){return null!=b},this)):Polymer.IronSelectableBehavior._updateAttrForSelected.apply(this)},_updateSelected:function(){this.multi?this._selectMulti(this.selectedValues):this._selectSelected(this.selected)},_selectMulti:function(b){b=
b||[];b=(this._valuesToItems(b)||[]).filter(function(f){return null!==f&&void 0!==f});this._selection.clear(b);for(var d=0;d<b.length;d++)this._selection.setItemSelected(b[d],!0);this.fallbackSelection&&!this._selection.get().length&&this._valueToItem(this.fallbackSelection)&&this.select(this.fallbackSelection)},_selectionChange:function(){var b=this._selection.get();this.multi?(this._setSelectedItems(b),this._setSelectedItem(b.length?b[0]:null)):null!==b&&void 0!==b?(this._setSelectedItems([b]),
this._setSelectedItem(b)):(this._setSelectedItems([]),this._setSelectedItem(null))},_toggleSelected:function(b){var d=this.selectedValues.indexOf(b);0>d?this.push("selectedValues",b):this.splice("selectedValues",d,1)},_valuesToItems:function(b){return null==b?null:b.map(function(d){return this._valueToItem(d)},this)}};Polymer.IronMultiSelectableBehavior=[Polymer.IronSelectableBehavior,Polymer.IronMultiSelectableBehaviorImpl];

//# sourceURL=build://iron-menu-behavior/iron-menu-behavior.html.js
Polymer.IronMenuBehaviorImpl={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".split(" "),_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(b){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null);var d=this._valueToItem(b);d&&d.hasAttribute("disabled")||(this._setFocusedItem(d),Polymer.IronMultiSelectableBehaviorImpl.select.apply(this,arguments))},_resetTabindices:function(){var b=this.multi?
this.selectedItems&&this.selectedItems[0]:this.selectedItem;this.items.forEach(function(d){d.setAttribute("tabindex",d===b?"0":"-1")},this)},_updateMultiselectable:function(b){b?this.setAttribute("aria-multiselectable","true"):this.removeAttribute("aria-multiselectable")},_focusWithKeyboardEvent:function(b){if(-1===this._MODIFIER_KEYS.indexOf(b.key)){this.cancelDebouncer("_clearSearchText");var d=this._searchText||"";d+=(b.key&&1==b.key.length?b.key:String.fromCharCode(b.keyCode)).toLocaleLowerCase();
b=d.length;for(var f=0,h;h=this.items[f];f++)if(!h.hasAttribute("disabled")){var k=this.attrForItemTitle||"textContent";k=(h[k]||h.getAttribute(k)||"").trim();if(!(k.length<b)&&k.slice(0,b).toLocaleLowerCase()==d){this._setFocusedItem(h);break}}this._searchText=d;this.debounce("_clearSearchText",this._clearSearchText,this._SEARCH_RESET_TIMEOUT_MS)}},_clearSearchText:function(){this._searchText=""},_focusPrevious:function(){for(var b=this.items.length,d=Number(this.indexOf(this.focusedItem)),f=1;f<
b+1;f++){var h=this.items[(d-f+b)%b];if(!h.hasAttribute("disabled")){var k=Polymer.dom(h).getOwnerRoot()||document;this._setFocusedItem(h);if(Polymer.dom(k).activeElement==h)break}}},_focusNext:function(){for(var b=this.items.length,d=Number(this.indexOf(this.focusedItem)),f=1;f<b+1;f++){var h=this.items[(d+f)%b];if(!h.hasAttribute("disabled")){var k=Polymer.dom(h).getOwnerRoot()||document;this._setFocusedItem(h);if(Polymer.dom(k).activeElement==h)break}}},_applySelection:function(b,d){d?b.setAttribute("aria-selected",
"true"):b.removeAttribute("aria-selected");Polymer.IronSelectableBehavior._applySelection.apply(this,arguments)},_focusedItemChanged:function(b,d){d&&d.setAttribute("tabindex","-1");!b||b.hasAttribute("disabled")||this.disabled||(b.setAttribute("tabindex","0"),b.focus())},_onIronItemsChanged:function(b){b.detail.addedNodes.length&&this._resetTabindices()},_onShiftTabDown:function(){var b=this.getAttribute("tabindex");Polymer.IronMenuBehaviorImpl._shiftTabPressed=!0;this._setFocusedItem(null);this.setAttribute("tabindex",
"-1");this.async(function(){this.setAttribute("tabindex",b);Polymer.IronMenuBehaviorImpl._shiftTabPressed=!1},1)},_onFocus:function(b){!Polymer.IronMenuBehaviorImpl._shiftTabPressed&&(b=Polymer.dom(b).rootTarget,b===this||"undefined"===typeof b.tabIndex||this.isLightDescendant(b))&&(this._defaultFocusAsync=this.async(function(){var d=this.multi?this.selectedItems&&this.selectedItems[0]:this.selectedItem;this._setFocusedItem(null);d?this._setFocusedItem(d):this.items[0]&&this._focusNext()}))},_onUpKey:function(b){this._focusPrevious();
b.detail.keyboardEvent.preventDefault()},_onDownKey:function(b){this._focusNext();b.detail.keyboardEvent.preventDefault()},_onEscKey:function(){var b=this.focusedItem;b&&b.blur()},_onKeydown:function(b){this.keyboardEventMatchesKeys(b,"up down esc")||this._focusWithKeyboardEvent(b);b.stopPropagation()},_activateHandler:function(b){Polymer.IronSelectableBehavior._activateHandler.call(this,b);b.stopPropagation()},_disabledChanged:function(b){b?(this._previousTabIndex=this.hasAttribute("tabindex")?this.tabIndex:
0,this.removeAttribute("tabindex")):this.hasAttribute("tabindex")||this.setAttribute("tabindex",this._previousTabIndex)}};Polymer.IronMenuBehaviorImpl._shiftTabPressed=!1;Polymer.IronMenuBehavior=[Polymer.IronMultiSelectableBehavior,Polymer.IronA11yKeysBehavior,Polymer.IronMenuBehaviorImpl];

//# sourceURL=build://paper-listbox/paper-listbox.html.js
(function(){Polymer({is:"paper-listbox",behaviors:[Polymer.IronMenuBehavior],hostAttributes:{role:"listbox"}})})();

//# sourceURL=build://paper-item/paper-item-behavior.html.js
Polymer.PaperItemBehaviorImpl={hostAttributes:{role:"option",tabindex:"0"}};Polymer.PaperItemBehavior=[Polymer.IronButtonState,Polymer.IronControlState,Polymer.PaperItemBehaviorImpl];

//# sourceURL=build://paper-item/paper-item.html.js
Polymer({is:"paper-item",behaviors:[Polymer.PaperItemBehavior]});

/*

 Lodash <https://lodash.com/>
 Copyright JS Foundation and other contributors <https://js.foundation/>
 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
*/
(function(){var undefined;var VERSION="4.17.5";var LARGE_ARRAY_SIZE=200;var CORE_ERROR_TEXT="Unsupported core-js use. Try https://npms.io/search?q\x3dponyfill.",FUNC_ERROR_TEXT="Expected a function";var HASH_UNDEFINED="__lodash_hash_undefined__";var MAX_MEMOIZE_SIZE=500;var PLACEHOLDER="__lodash_placeholder__";var CLONE_DEEP_FLAG=1,CLONE_FLAT_FLAG=2,CLONE_SYMBOLS_FLAG=4;var COMPARE_PARTIAL_FLAG=1,COMPARE_UNORDERED_FLAG=2;var WRAP_BIND_FLAG=1,WRAP_BIND_KEY_FLAG=2,WRAP_CURRY_BOUND_FLAG=4,WRAP_CURRY_FLAG=
8,WRAP_CURRY_RIGHT_FLAG=16,WRAP_PARTIAL_FLAG=32,WRAP_PARTIAL_RIGHT_FLAG=64,WRAP_ARY_FLAG=128,WRAP_REARG_FLAG=256,WRAP_FLIP_FLAG=512;var DEFAULT_TRUNC_LENGTH=30,DEFAULT_TRUNC_OMISSION="...";var HOT_COUNT=800,HOT_SPAN=16;var LAZY_FILTER_FLAG=1,LAZY_MAP_FLAG=2,LAZY_WHILE_FLAG=3;var INFINITY=1/0,MAX_SAFE_INTEGER=9007199254740991,MAX_INTEGER=1.7976931348623157E308,NAN=0/0;var MAX_ARRAY_LENGTH=4294967295,MAX_ARRAY_INDEX=MAX_ARRAY_LENGTH-1,HALF_MAX_ARRAY_LENGTH=MAX_ARRAY_LENGTH>>>1;var wrapFlags=[["ary",
WRAP_ARY_FLAG],["bind",WRAP_BIND_FLAG],["bindKey",WRAP_BIND_KEY_FLAG],["curry",WRAP_CURRY_FLAG],["curryRight",WRAP_CURRY_RIGHT_FLAG],["flip",WRAP_FLIP_FLAG],["partial",WRAP_PARTIAL_FLAG],["partialRight",WRAP_PARTIAL_RIGHT_FLAG],["rearg",WRAP_REARG_FLAG]];var argsTag="[object Arguments]",arrayTag="[object Array]",asyncTag="[object AsyncFunction]",boolTag="[object Boolean]",dateTag="[object Date]",domExcTag="[object DOMException]",errorTag="[object Error]",funcTag="[object Function]",genTag="[object GeneratorFunction]",
mapTag="[object Map]",numberTag="[object Number]",nullTag="[object Null]",objectTag="[object Object]",promiseTag="[object Promise]",proxyTag="[object Proxy]",regexpTag="[object RegExp]",setTag="[object Set]",stringTag="[object String]",symbolTag="[object Symbol]",undefinedTag="[object Undefined]",weakMapTag="[object WeakMap]",weakSetTag="[object WeakSet]";var arrayBufferTag="[object ArrayBuffer]",dataViewTag="[object DataView]",float32Tag="[object Float32Array]",float64Tag="[object Float64Array]",
int8Tag="[object Int8Array]",int16Tag="[object Int16Array]",int32Tag="[object Int32Array]",uint8Tag="[object Uint8Array]",uint8ClampedTag="[object Uint8ClampedArray]",uint16Tag="[object Uint16Array]",uint32Tag="[object Uint32Array]";var reEmptyStringLeading=/\b__p \+= '';/g,reEmptyStringMiddle=/\b(__p \+=) '' \+/g,reEmptyStringTrailing=/(__e\(.*?\)|\b__t\)) \+\n'';/g;var reEscapedHtml=/&(?:amp|lt|gt|quot|#39);/g,reUnescapedHtml=/[&<>"']/g,reHasEscapedHtml=RegExp(reEscapedHtml.source),reHasUnescapedHtml=
RegExp(reUnescapedHtml.source);var reEscape=/<%-([\s\S]+?)%>/g,reEvaluate=/<%([\s\S]+?)%>/g,reInterpolate=/<%=([\s\S]+?)%>/g;var reIsDeepProp=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,reIsPlainProp=/^\w*$/,rePropName=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;var reRegExpChar=/[\\^$.*+?()[\]{}|]/g,reHasRegExpChar=RegExp(reRegExpChar.source);var reTrim=/^\s+|\s+$/g,reTrimStart=/^\s+/,reTrimEnd=/\s+$/;var reWrapComment=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
reWrapDetails=/\{\n\/\* \[wrapped with (.+)\] \*/,reSplitDetails=/,? & /;var reAsciiWord=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;var reEscapeChar=/\\(\\)?/g;var reEsTemplate=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;var reFlags=/\w*$/;var reIsBadHex=/^[-+]0x[0-9a-f]+$/i;var reIsBinary=/^0b[01]+$/i;var reIsHostCtor=/^\[object .+?Constructor\]$/;var reIsOctal=/^0o[0-7]+$/i;var reIsUint=/^(?:0|[1-9]\d*)$/;var reLatin=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;var reNoMatch=/($^)/;var reUnescapedString=
/['\n\r\u2028\u2029\\]/g;var rsAstralRange="\\ud800-\\udfff",rsComboMarksRange="\\u0300-\\u036f",reComboHalfMarksRange="\\ufe20-\\ufe2f",rsComboSymbolsRange="\\u20d0-\\u20ff",rsComboRange=rsComboMarksRange+reComboHalfMarksRange+rsComboSymbolsRange,rsDingbatRange="\\u2700-\\u27bf",rsLowerRange="a-z\\xdf-\\xf6\\xf8-\\xff",rsMathOpRange="\\xac\\xb1\\xd7\\xf7",rsNonCharRange="\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf",rsPunctuationRange="\\u2000-\\u206f",rsSpaceRange=" \\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",
rsUpperRange="A-Z\\xc0-\\xd6\\xd8-\\xde",rsVarRange="\\ufe0e\\ufe0f",rsBreakRange=rsMathOpRange+rsNonCharRange+rsPunctuationRange+rsSpaceRange;var rsApos="['\u2019]",rsAstral="["+rsAstralRange+"]",rsBreak="["+rsBreakRange+"]",rsCombo="["+rsComboRange+"]",rsDigits="\\d+",rsDingbat="["+rsDingbatRange+"]",rsLower="["+rsLowerRange+"]",rsMisc="[^"+rsAstralRange+rsBreakRange+rsDigits+rsDingbatRange+rsLowerRange+rsUpperRange+"]",rsFitz="\\ud83c[\\udffb-\\udfff]",rsModifier="(?:"+rsCombo+"|"+rsFitz+")",rsNonAstral=
"[^"+rsAstralRange+"]",rsRegional="(?:\\ud83c[\\udde6-\\uddff]){2}",rsSurrPair="[\\ud800-\\udbff][\\udc00-\\udfff]",rsUpper="["+rsUpperRange+"]",rsZWJ="\\u200d";var rsMiscLower="(?:"+rsLower+"|"+rsMisc+")",rsMiscUpper="(?:"+rsUpper+"|"+rsMisc+")",rsOptContrLower="(?:"+rsApos+"(?:d|ll|m|re|s|t|ve))?",rsOptContrUpper="(?:"+rsApos+"(?:D|LL|M|RE|S|T|VE))?",reOptMod=rsModifier+"?",rsOptVar="["+rsVarRange+"]?",rsOptJoin="(?:"+rsZWJ+"(?:"+[rsNonAstral,rsRegional,rsSurrPair].join("|")+")"+rsOptVar+reOptMod+
")*",rsOrdLower="\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?\x3d\\b|[A-Z_])",rsOrdUpper="\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?\x3d\\b|[a-z_])",rsSeq=rsOptVar+reOptMod+rsOptJoin,rsEmoji="(?:"+[rsDingbat,rsRegional,rsSurrPair].join("|")+")"+rsSeq,rsSymbol="(?:"+[rsNonAstral+rsCombo+"?",rsCombo,rsRegional,rsSurrPair,rsAstral].join("|")+")";var reApos=RegExp(rsApos,"g");var reComboMark=RegExp(rsCombo,"g");var reUnicode=RegExp(rsFitz+"(?\x3d"+rsFitz+")|"+rsSymbol+rsSeq,"g");var reUnicodeWord=RegExp([rsUpper+"?"+
rsLower+"+"+rsOptContrLower+"(?\x3d"+[rsBreak,rsUpper,"$"].join("|")+")",rsMiscUpper+"+"+rsOptContrUpper+"(?\x3d"+[rsBreak,rsUpper+rsMiscLower,"$"].join("|")+")",rsUpper+"?"+rsMiscLower+"+"+rsOptContrLower,rsUpper+"+"+rsOptContrUpper,rsOrdUpper,rsOrdLower,rsDigits,rsEmoji].join("|"),"g");var reHasUnicode=RegExp("["+rsZWJ+rsAstralRange+rsComboRange+rsVarRange+"]");var reHasUnicodeWord=/[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;var contextProps=["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"];var templateCounter=-1;var typedArrayTags={};typedArrayTags[float32Tag]=typedArrayTags[float64Tag]=typedArrayTags[int8Tag]=typedArrayTags[int16Tag]=typedArrayTags[int32Tag]=typedArrayTags[uint8Tag]=typedArrayTags[uint8ClampedTag]=
typedArrayTags[uint16Tag]=typedArrayTags[uint32Tag]=true;typedArrayTags[argsTag]=typedArrayTags[arrayTag]=typedArrayTags[arrayBufferTag]=typedArrayTags[boolTag]=typedArrayTags[dataViewTag]=typedArrayTags[dateTag]=typedArrayTags[errorTag]=typedArrayTags[funcTag]=typedArrayTags[mapTag]=typedArrayTags[numberTag]=typedArrayTags[objectTag]=typedArrayTags[regexpTag]=typedArrayTags[setTag]=typedArrayTags[stringTag]=typedArrayTags[weakMapTag]=false;var cloneableTags={};cloneableTags[argsTag]=cloneableTags[arrayTag]=
cloneableTags[arrayBufferTag]=cloneableTags[dataViewTag]=cloneableTags[boolTag]=cloneableTags[dateTag]=cloneableTags[float32Tag]=cloneableTags[float64Tag]=cloneableTags[int8Tag]=cloneableTags[int16Tag]=cloneableTags[int32Tag]=cloneableTags[mapTag]=cloneableTags[numberTag]=cloneableTags[objectTag]=cloneableTags[regexpTag]=cloneableTags[setTag]=cloneableTags[stringTag]=cloneableTags[symbolTag]=cloneableTags[uint8Tag]=cloneableTags[uint8ClampedTag]=cloneableTags[uint16Tag]=cloneableTags[uint32Tag]=true;
cloneableTags[errorTag]=cloneableTags[funcTag]=cloneableTags[weakMapTag]=false;var deburredLetters={"\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"};var htmlEscapes={"\x26":"\x26amp;","\x3c":"\x26lt;","\x3e":"\x26gt;",'"':"\x26quot;","'":"\x26#39;"};var htmlUnescapes={"\x26amp;":"\x26","\x26lt;":"\x3c","\x26gt;":"\x3e","\x26quot;":'"',"\x26#39;":"'"};var stringEscapes={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"};var freeParseFloat=parseFloat,freeParseInt=parseInt;var freeGlobal=typeof global=="object"&&global&&global.Object===Object&&global;var freeSelf=typeof self=="object"&&
self&&self.Object===Object&&self;var root=freeGlobal||freeSelf||Function("return this")();var freeExports=typeof exports=="object"&&exports&&!exports.nodeType&&exports;var freeModule=freeExports&&typeof module=="object"&&module&&!module.nodeType&&module;var moduleExports=freeModule&&freeModule.exports===freeExports;var freeProcess=moduleExports&&freeGlobal.process;var nodeUtil=function(){try{return freeProcess&&freeProcess.binding&&freeProcess.binding("util")}catch(e){}}();var nodeIsArrayBuffer=nodeUtil&&
nodeUtil.isArrayBuffer,nodeIsDate=nodeUtil&&nodeUtil.isDate,nodeIsMap=nodeUtil&&nodeUtil.isMap,nodeIsRegExp=nodeUtil&&nodeUtil.isRegExp,nodeIsSet=nodeUtil&&nodeUtil.isSet,nodeIsTypedArray=nodeUtil&&nodeUtil.isTypedArray;function apply(func,thisArg,args){switch(args.length){case 0:return func.call(thisArg);case 1:return func.call(thisArg,args[0]);case 2:return func.call(thisArg,args[0],args[1]);case 3:return func.call(thisArg,args[0],args[1],args[2])}return func.apply(thisArg,args)}function arrayAggregator(array,
setter,iteratee,accumulator){var index=-1,length=array==null?0:array.length;while(++index<length){var value=array[index];setter(accumulator,value,iteratee(value),array)}return accumulator}function arrayEach(array,iteratee){var index=-1,length=array==null?0:array.length;while(++index<length)if(iteratee(array[index],index,array)===false)break;return array}function arrayEachRight(array,iteratee){var length=array==null?0:array.length;while(length--)if(iteratee(array[length],length,array)===false)break;
return array}function arrayEvery(array,predicate){var index=-1,length=array==null?0:array.length;while(++index<length)if(!predicate(array[index],index,array))return false;return true}function arrayFilter(array,predicate){var index=-1,length=array==null?0:array.length,resIndex=0,result=[];while(++index<length){var value=array[index];if(predicate(value,index,array))result[resIndex++]=value}return result}function arrayIncludes(array,value){var length=array==null?0:array.length;return!!length&&baseIndexOf(array,
value,0)>-1}function arrayIncludesWith(array,value,comparator){var index=-1,length=array==null?0:array.length;while(++index<length)if(comparator(value,array[index]))return true;return false}function arrayMap(array,iteratee){var index=-1,length=array==null?0:array.length,result=Array(length);while(++index<length)result[index]=iteratee(array[index],index,array);return result}function arrayPush(array,values){var index=-1,length=values.length,offset=array.length;while(++index<length)array[offset+index]=
values[index];return array}function arrayReduce(array,iteratee,accumulator,initAccum){var index=-1,length=array==null?0:array.length;if(initAccum&&length)accumulator=array[++index];while(++index<length)accumulator=iteratee(accumulator,array[index],index,array);return accumulator}function arrayReduceRight(array,iteratee,accumulator,initAccum){var length=array==null?0:array.length;if(initAccum&&length)accumulator=array[--length];while(length--)accumulator=iteratee(accumulator,array[length],length,array);
return accumulator}function arraySome(array,predicate){var index=-1,length=array==null?0:array.length;while(++index<length)if(predicate(array[index],index,array))return true;return false}var asciiSize=baseProperty("length");function asciiToArray(string){return string.split("")}function asciiWords(string){return string.match(reAsciiWord)||[]}function baseFindKey(collection,predicate,eachFunc){var result;eachFunc(collection,function(value,key,collection){if(predicate(value,key,collection)){result=key;
return false}});return result}function baseFindIndex(array,predicate,fromIndex,fromRight){var length=array.length,index=fromIndex+(fromRight?1:-1);while(fromRight?index--:++index<length)if(predicate(array[index],index,array))return index;return-1}function baseIndexOf(array,value,fromIndex){return value===value?strictIndexOf(array,value,fromIndex):baseFindIndex(array,baseIsNaN,fromIndex)}function baseIndexOfWith(array,value,fromIndex,comparator){var index=fromIndex-1,length=array.length;while(++index<
length)if(comparator(array[index],value))return index;return-1}function baseIsNaN(value){return value!==value}function baseMean(array,iteratee){var length=array==null?0:array.length;return length?baseSum(array,iteratee)/length:NAN}function baseProperty(key){return function(object){return object==null?undefined:object[key]}}function basePropertyOf(object){return function(key){return object==null?undefined:object[key]}}function baseReduce(collection,iteratee,accumulator,initAccum,eachFunc){eachFunc(collection,
function(value,index,collection){accumulator=initAccum?(initAccum=false,value):iteratee(accumulator,value,index,collection)});return accumulator}function baseSortBy(array,comparer){var length=array.length;array.sort(comparer);while(length--)array[length]=array[length].value;return array}function baseSum(array,iteratee){var result,index=-1,length=array.length;while(++index<length){var current=iteratee(array[index]);if(current!==undefined)result=result===undefined?current:result+current}return result}
function baseTimes(n,iteratee){var index=-1,result=Array(n);while(++index<n)result[index]=iteratee(index);return result}function baseToPairs(object,props){return arrayMap(props,function(key){return[key,object[key]]})}function baseUnary(func){return function(value){return func(value)}}function baseValues(object,props){return arrayMap(props,function(key){return object[key]})}function cacheHas(cache,key){return cache.has(key)}function charsStartIndex(strSymbols,chrSymbols){var index=-1,length=strSymbols.length;
while(++index<length&&baseIndexOf(chrSymbols,strSymbols[index],0)>-1);return index}function charsEndIndex(strSymbols,chrSymbols){var index=strSymbols.length;while(index--&&baseIndexOf(chrSymbols,strSymbols[index],0)>-1);return index}function countHolders(array,placeholder){var length=array.length,result=0;while(length--)if(array[length]===placeholder)++result;return result}var deburrLetter=basePropertyOf(deburredLetters);var escapeHtmlChar=basePropertyOf(htmlEscapes);function escapeStringChar(chr){return"\\"+
stringEscapes[chr]}function getValue(object,key){return object==null?undefined:object[key]}function hasUnicode(string){return reHasUnicode.test(string)}function hasUnicodeWord(string){return reHasUnicodeWord.test(string)}function iteratorToArray(iterator){var data,result=[];while(!(data=iterator.next()).done)result.push(data.value);return result}function mapToArray(map){var index=-1,result=Array(map.size);map.forEach(function(value,key){result[++index]=[key,value]});return result}function overArg(func,
transform){return function(arg){return func(transform(arg))}}function replaceHolders(array,placeholder){var index=-1,length=array.length,resIndex=0,result=[];while(++index<length){var value=array[index];if(value===placeholder||value===PLACEHOLDER){array[index]=PLACEHOLDER;result[resIndex++]=index}}return result}function safeGet(object,key){return key=="__proto__"?undefined:object[key]}function setToArray(set){var index=-1,result=Array(set.size);set.forEach(function(value){result[++index]=value});
return result}function setToPairs(set){var index=-1,result=Array(set.size);set.forEach(function(value){result[++index]=[value,value]});return result}function strictIndexOf(array,value,fromIndex){var index=fromIndex-1,length=array.length;while(++index<length)if(array[index]===value)return index;return-1}function strictLastIndexOf(array,value,fromIndex){var index=fromIndex+1;while(index--)if(array[index]===value)return index;return index}function stringSize(string){return hasUnicode(string)?unicodeSize(string):
asciiSize(string)}function stringToArray(string){return hasUnicode(string)?unicodeToArray(string):asciiToArray(string)}var unescapeHtmlChar=basePropertyOf(htmlUnescapes);function unicodeSize(string){var result=reUnicode.lastIndex=0;while(reUnicode.test(string))++result;return result}function unicodeToArray(string){return string.match(reUnicode)||[]}function unicodeWords(string){return string.match(reUnicodeWord)||[]}var runInContext=function runInContext(context){context=context==null?root:_.defaults(root.Object(),
context,_.pick(root,contextProps));var Array=context.Array,Date=context.Date,Error=context.Error,Function=context.Function,Math=context.Math,Object=context.Object,RegExp=context.RegExp,String=context.String,TypeError=context.TypeError;var arrayProto=Array.prototype,funcProto=Function.prototype,objectProto=Object.prototype;var coreJsData=context["__core-js_shared__"];var funcToString=funcProto.toString;var hasOwnProperty=objectProto.hasOwnProperty;var idCounter=0;var maskSrcKey=function(){var uid=
/[^.]+$/.exec(coreJsData&&coreJsData.keys&&coreJsData.keys.IE_PROTO||"");return uid?"Symbol(src)_1."+uid:""}();var nativeObjectToString=objectProto.toString;var objectCtorString=funcToString.call(Object);var oldDash=root._;var reIsNative=RegExp("^"+funcToString.call(hasOwnProperty).replace(reRegExpChar,"\\$\x26").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");var Buffer=moduleExports?context.Buffer:undefined,Symbol=context.Symbol,Uint8Array=context.Uint8Array,allocUnsafe=
Buffer?Buffer.allocUnsafe:undefined,getPrototype=overArg(Object.getPrototypeOf,Object),objectCreate=Object.create,propertyIsEnumerable=objectProto.propertyIsEnumerable,splice=arrayProto.splice,spreadableSymbol=Symbol?Symbol.isConcatSpreadable:undefined,symIterator=Symbol?Symbol.iterator:undefined,symToStringTag=Symbol?Symbol.toStringTag:undefined;var defineProperty=function(){try{var func=getNative(Object,"defineProperty");func({},"",{});return func}catch(e){}}();var ctxClearTimeout=context.clearTimeout!==
root.clearTimeout&&context.clearTimeout,ctxNow=Date&&Date.now!==root.Date.now&&Date.now,ctxSetTimeout=context.setTimeout!==root.setTimeout&&context.setTimeout;var nativeCeil=Math.ceil,nativeFloor=Math.floor,nativeGetSymbols=Object.getOwnPropertySymbols,nativeIsBuffer=Buffer?Buffer.isBuffer:undefined,nativeIsFinite=context.isFinite,nativeJoin=arrayProto.join,nativeKeys=overArg(Object.keys,Object),nativeMax=Math.max,nativeMin=Math.min,nativeNow=Date.now,nativeParseInt=context.parseInt,nativeRandom=
Math.random,nativeReverse=arrayProto.reverse;var DataView=getNative(context,"DataView"),Map=getNative(context,"Map"),Promise=getNative(context,"Promise"),Set=getNative(context,"Set"),WeakMap=getNative(context,"WeakMap"),nativeCreate=getNative(Object,"create");var metaMap=WeakMap&&new WeakMap;var realNames={};var dataViewCtorString=toSource(DataView),mapCtorString=toSource(Map),promiseCtorString=toSource(Promise),setCtorString=toSource(Set),weakMapCtorString=toSource(WeakMap);var symbolProto=Symbol?
Symbol.prototype:undefined,symbolValueOf=symbolProto?symbolProto.valueOf:undefined,symbolToString=symbolProto?symbolProto.toString:undefined;function lodash(value){if(isObjectLike(value)&&!isArray(value)&&!(value instanceof LazyWrapper)){if(value instanceof LodashWrapper)return value;if(hasOwnProperty.call(value,"__wrapped__"))return wrapperClone(value)}return new LodashWrapper(value)}var baseCreate=function(){function object(){}return function(proto){if(!isObject(proto))return{};if(objectCreate)return objectCreate(proto);
object.prototype=proto;var result=new object;object.prototype=undefined;return result}}();function baseLodash(){}function LodashWrapper(value,chainAll){this.__wrapped__=value;this.__actions__=[];this.__chain__=!!chainAll;this.__index__=0;this.__values__=undefined}lodash.templateSettings={"escape":reEscape,"evaluate":reEvaluate,"interpolate":reInterpolate,"variable":"","imports":{"_":lodash}};lodash.prototype=baseLodash.prototype;lodash.prototype.constructor=lodash;LodashWrapper.prototype=baseCreate(baseLodash.prototype);
LodashWrapper.prototype.constructor=LodashWrapper;function LazyWrapper(value){this.__wrapped__=value;this.__actions__=[];this.__dir__=1;this.__filtered__=false;this.__iteratees__=[];this.__takeCount__=MAX_ARRAY_LENGTH;this.__views__=[]}function lazyClone(){var result=new LazyWrapper(this.__wrapped__);result.__actions__=copyArray(this.__actions__);result.__dir__=this.__dir__;result.__filtered__=this.__filtered__;result.__iteratees__=copyArray(this.__iteratees__);result.__takeCount__=this.__takeCount__;
result.__views__=copyArray(this.__views__);return result}function lazyReverse(){if(this.__filtered__){var result=new LazyWrapper(this);result.__dir__=-1;result.__filtered__=true}else{result=this.clone();result.__dir__*=-1}return result}function lazyValue(){var array=this.__wrapped__.value(),dir=this.__dir__,isArr=isArray(array),isRight=dir<0,arrLength=isArr?array.length:0,view=getView(0,arrLength,this.__views__),start=view.start,end=view.end,length=end-start,index=isRight?end:start-1,iteratees=this.__iteratees__,
iterLength=iteratees.length,resIndex=0,takeCount=nativeMin(length,this.__takeCount__);if(!isArr||!isRight&&arrLength==length&&takeCount==length)return baseWrapperValue(array,this.__actions__);var result=[];outer:while(length--&&resIndex<takeCount){index+=dir;var iterIndex=-1,value=array[index];while(++iterIndex<iterLength){var data=iteratees[iterIndex],iteratee=data.iteratee,type=data.type,computed=iteratee(value);if(type==LAZY_MAP_FLAG)value=computed;else if(!computed)if(type==LAZY_FILTER_FLAG)continue outer;
else break outer}result[resIndex++]=value}return result}LazyWrapper.prototype=baseCreate(baseLodash.prototype);LazyWrapper.prototype.constructor=LazyWrapper;function Hash(entries){var index=-1,length=entries==null?0:entries.length;this.clear();while(++index<length){var entry=entries[index];this.set(entry[0],entry[1])}}function hashClear(){this.__data__=nativeCreate?nativeCreate(null):{};this.size=0}function hashDelete(key){var result=this.has(key)&&delete this.__data__[key];this.size-=result?1:0;
return result}function hashGet(key){var data=this.__data__;if(nativeCreate){var result=data[key];return result===HASH_UNDEFINED?undefined:result}return hasOwnProperty.call(data,key)?data[key]:undefined}function hashHas(key){var data=this.__data__;return nativeCreate?data[key]!==undefined:hasOwnProperty.call(data,key)}function hashSet(key,value){var data=this.__data__;this.size+=this.has(key)?0:1;data[key]=nativeCreate&&value===undefined?HASH_UNDEFINED:value;return this}Hash.prototype.clear=hashClear;
Hash.prototype["delete"]=hashDelete;Hash.prototype.get=hashGet;Hash.prototype.has=hashHas;Hash.prototype.set=hashSet;function ListCache(entries){var index=-1,length=entries==null?0:entries.length;this.clear();while(++index<length){var entry=entries[index];this.set(entry[0],entry[1])}}function listCacheClear(){this.__data__=[];this.size=0}function listCacheDelete(key){var data=this.__data__,index=assocIndexOf(data,key);if(index<0)return false;var lastIndex=data.length-1;if(index==lastIndex)data.pop();
else splice.call(data,index,1);--this.size;return true}function listCacheGet(key){var data=this.__data__,index=assocIndexOf(data,key);return index<0?undefined:data[index][1]}function listCacheHas(key){return assocIndexOf(this.__data__,key)>-1}function listCacheSet(key,value){var data=this.__data__,index=assocIndexOf(data,key);if(index<0){++this.size;data.push([key,value])}else data[index][1]=value;return this}ListCache.prototype.clear=listCacheClear;ListCache.prototype["delete"]=listCacheDelete;ListCache.prototype.get=
listCacheGet;ListCache.prototype.has=listCacheHas;ListCache.prototype.set=listCacheSet;function MapCache(entries){var index=-1,length=entries==null?0:entries.length;this.clear();while(++index<length){var entry=entries[index];this.set(entry[0],entry[1])}}function mapCacheClear(){this.size=0;this.__data__={"hash":new Hash,"map":new (Map||ListCache),"string":new Hash}}function mapCacheDelete(key){var result=getMapData(this,key)["delete"](key);this.size-=result?1:0;return result}function mapCacheGet(key){return getMapData(this,
key).get(key)}function mapCacheHas(key){return getMapData(this,key).has(key)}function mapCacheSet(key,value){var data=getMapData(this,key),size=data.size;data.set(key,value);this.size+=data.size==size?0:1;return this}MapCache.prototype.clear=mapCacheClear;MapCache.prototype["delete"]=mapCacheDelete;MapCache.prototype.get=mapCacheGet;MapCache.prototype.has=mapCacheHas;MapCache.prototype.set=mapCacheSet;function SetCache(values){var index=-1,length=values==null?0:values.length;this.__data__=new MapCache;
while(++index<length)this.add(values[index])}function setCacheAdd(value){this.__data__.set(value,HASH_UNDEFINED);return this}function setCacheHas(value){return this.__data__.has(value)}SetCache.prototype.add=SetCache.prototype.push=setCacheAdd;SetCache.prototype.has=setCacheHas;function Stack(entries){var data=this.__data__=new ListCache(entries);this.size=data.size}function stackClear(){this.__data__=new ListCache;this.size=0}function stackDelete(key){var data=this.__data__,result=data["delete"](key);
this.size=data.size;return result}function stackGet(key){return this.__data__.get(key)}function stackHas(key){return this.__data__.has(key)}function stackSet(key,value){var data=this.__data__;if(data instanceof ListCache){var pairs=data.__data__;if(!Map||pairs.length<LARGE_ARRAY_SIZE-1){pairs.push([key,value]);this.size=++data.size;return this}data=this.__data__=new MapCache(pairs)}data.set(key,value);this.size=data.size;return this}Stack.prototype.clear=stackClear;Stack.prototype["delete"]=stackDelete;
Stack.prototype.get=stackGet;Stack.prototype.has=stackHas;Stack.prototype.set=stackSet;function arrayLikeKeys(value,inherited){var isArr=isArray(value),isArg=!isArr&&isArguments(value),isBuff=!isArr&&!isArg&&isBuffer(value),isType=!isArr&&!isArg&&!isBuff&&isTypedArray(value),skipIndexes=isArr||isArg||isBuff||isType,result=skipIndexes?baseTimes(value.length,String):[],length=result.length;for(var key in value)if((inherited||hasOwnProperty.call(value,key))&&!(skipIndexes&&(key=="length"||isBuff&&(key==
"offset"||key=="parent")||isType&&(key=="buffer"||key=="byteLength"||key=="byteOffset")||isIndex(key,length))))result.push(key);return result}function arraySample(array){var length=array.length;return length?array[baseRandom(0,length-1)]:undefined}function arraySampleSize(array,n){return shuffleSelf(copyArray(array),baseClamp(n,0,array.length))}function arrayShuffle(array){return shuffleSelf(copyArray(array))}function assignMergeValue(object,key,value){if(value!==undefined&&!eq(object[key],value)||
value===undefined&&!(key in object))baseAssignValue(object,key,value)}function assignValue(object,key,value){var objValue=object[key];if(!(hasOwnProperty.call(object,key)&&eq(objValue,value))||value===undefined&&!(key in object))baseAssignValue(object,key,value)}function assocIndexOf(array,key){var length=array.length;while(length--)if(eq(array[length][0],key))return length;return-1}function baseAggregator(collection,setter,iteratee,accumulator){baseEach(collection,function(value,key,collection){setter(accumulator,
value,iteratee(value),collection)});return accumulator}function baseAssign(object,source){return object&&copyObject(source,keys(source),object)}function baseAssignIn(object,source){return object&&copyObject(source,keysIn(source),object)}function baseAssignValue(object,key,value){if(key=="__proto__"&&defineProperty)defineProperty(object,key,{"configurable":true,"enumerable":true,"value":value,"writable":true});else object[key]=value}function baseAt(object,paths){var index=-1,length=paths.length,result=
Array(length),skip=object==null;while(++index<length)result[index]=skip?undefined:get(object,paths[index]);return result}function baseClamp(number,lower,upper){if(number===number){if(upper!==undefined)number=number<=upper?number:upper;if(lower!==undefined)number=number>=lower?number:lower}return number}function baseClone(value,bitmask,customizer,key,object,stack){var result,isDeep=bitmask&CLONE_DEEP_FLAG,isFlat=bitmask&CLONE_FLAT_FLAG,isFull=bitmask&CLONE_SYMBOLS_FLAG;if(customizer)result=object?
customizer(value,key,object,stack):customizer(value);if(result!==undefined)return result;if(!isObject(value))return value;var isArr=isArray(value);if(isArr){result=initCloneArray(value);if(!isDeep)return copyArray(value,result)}else{var tag=getTag(value),isFunc=tag==funcTag||tag==genTag;if(isBuffer(value))return cloneBuffer(value,isDeep);if(tag==objectTag||tag==argsTag||isFunc&&!object){result=isFlat||isFunc?{}:initCloneObject(value);if(!isDeep)return isFlat?copySymbolsIn(value,baseAssignIn(result,
value)):copySymbols(value,baseAssign(result,value))}else{if(!cloneableTags[tag])return object?value:{};result=initCloneByTag(value,tag,isDeep)}}stack||(stack=new Stack);var stacked=stack.get(value);if(stacked)return stacked;stack.set(value,result);if(isSet(value)){value.forEach(function(subValue){result.add(baseClone(subValue,bitmask,customizer,subValue,value,stack))});return result}if(isMap(value)){value.forEach(function(subValue,key){result.set(key,baseClone(subValue,bitmask,customizer,key,value,
stack))});return result}var keysFunc=isFull?isFlat?getAllKeysIn:getAllKeys:isFlat?keysIn:keys;var props=isArr?undefined:keysFunc(value);arrayEach(props||value,function(subValue,key){if(props){key=subValue;subValue=value[key]}assignValue(result,key,baseClone(subValue,bitmask,customizer,key,value,stack))});return result}function baseConforms(source){var props=keys(source);return function(object){return baseConformsTo(object,source,props)}}function baseConformsTo(object,source,props){var length=props.length;
if(object==null)return!length;object=Object(object);while(length--){var key=props[length],predicate=source[key],value=object[key];if(value===undefined&&!(key in object)||!predicate(value))return false}return true}function baseDelay(func,wait,args){if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);return setTimeout(function(){func.apply(undefined,args)},wait)}function baseDifference(array,values,iteratee,comparator){var index=-1,includes=arrayIncludes,isCommon=true,length=array.length,
result=[],valuesLength=values.length;if(!length)return result;if(iteratee)values=arrayMap(values,baseUnary(iteratee));if(comparator){includes=arrayIncludesWith;isCommon=false}else if(values.length>=LARGE_ARRAY_SIZE){includes=cacheHas;isCommon=false;values=new SetCache(values)}outer:while(++index<length){var value=array[index],computed=iteratee==null?value:iteratee(value);value=comparator||value!==0?value:0;if(isCommon&&computed===computed){var valuesIndex=valuesLength;while(valuesIndex--)if(values[valuesIndex]===
computed)continue outer;result.push(value)}else if(!includes(values,computed,comparator))result.push(value)}return result}var baseEach=createBaseEach(baseForOwn);var baseEachRight=createBaseEach(baseForOwnRight,true);function baseEvery(collection,predicate){var result=true;baseEach(collection,function(value,index,collection){result=!!predicate(value,index,collection);return result});return result}function baseExtremum(array,iteratee,comparator){var index=-1,length=array.length;while(++index<length){var value=
array[index],current=iteratee(value);if(current!=null&&(computed===undefined?current===current&&!isSymbol(current):comparator(current,computed)))var computed=current,result=value}return result}function baseFill(array,value,start,end){var length=array.length;start=toInteger(start);if(start<0)start=-start>length?0:length+start;end=end===undefined||end>length?length:toInteger(end);if(end<0)end+=length;end=start>end?0:toLength(end);while(start<end)array[start++]=value;return array}function baseFilter(collection,
predicate){var result=[];baseEach(collection,function(value,index,collection){if(predicate(value,index,collection))result.push(value)});return result}function baseFlatten(array,depth,predicate,isStrict,result){var index=-1,length=array.length;predicate||(predicate=isFlattenable);result||(result=[]);while(++index<length){var value=array[index];if(depth>0&&predicate(value))if(depth>1)baseFlatten(value,depth-1,predicate,isStrict,result);else arrayPush(result,value);else if(!isStrict)result[result.length]=
value}return result}var baseFor=createBaseFor();var baseForRight=createBaseFor(true);function baseForOwn(object,iteratee){return object&&baseFor(object,iteratee,keys)}function baseForOwnRight(object,iteratee){return object&&baseForRight(object,iteratee,keys)}function baseFunctions(object,props){return arrayFilter(props,function(key){return isFunction(object[key])})}function baseGet(object,path){path=castPath(path,object);var index=0,length=path.length;while(object!=null&&index<length)object=object[toKey(path[index++])];
return index&&index==length?object:undefined}function baseGetAllKeys(object,keysFunc,symbolsFunc){var result=keysFunc(object);return isArray(object)?result:arrayPush(result,symbolsFunc(object))}function baseGetTag(value){if(value==null)return value===undefined?undefinedTag:nullTag;return symToStringTag&&symToStringTag in Object(value)?getRawTag(value):objectToString(value)}function baseGt(value,other){return value>other}function baseHas(object,key){return object!=null&&hasOwnProperty.call(object,
key)}function baseHasIn(object,key){return object!=null&&key in Object(object)}function baseInRange(number,start,end){return number>=nativeMin(start,end)&&number<nativeMax(start,end)}function baseIntersection(arrays,iteratee,comparator){var includes=comparator?arrayIncludesWith:arrayIncludes,length=arrays[0].length,othLength=arrays.length,othIndex=othLength,caches=Array(othLength),maxLength=Infinity,result=[];while(othIndex--){var array=arrays[othIndex];if(othIndex&&iteratee)array=arrayMap(array,
baseUnary(iteratee));maxLength=nativeMin(array.length,maxLength);caches[othIndex]=!comparator&&(iteratee||length>=120&&array.length>=120)?new SetCache(othIndex&&array):undefined}array=arrays[0];var index=-1,seen=caches[0];outer:while(++index<length&&result.length<maxLength){var value=array[index],computed=iteratee?iteratee(value):value;value=comparator||value!==0?value:0;if(!(seen?cacheHas(seen,computed):includes(result,computed,comparator))){othIndex=othLength;while(--othIndex){var cache=caches[othIndex];
if(!(cache?cacheHas(cache,computed):includes(arrays[othIndex],computed,comparator)))continue outer}if(seen)seen.push(computed);result.push(value)}}return result}function baseInverter(object,setter,iteratee,accumulator){baseForOwn(object,function(value,key,object){setter(accumulator,iteratee(value),key,object)});return accumulator}function baseInvoke(object,path,args){path=castPath(path,object);object=parent(object,path);var func=object==null?object:object[toKey(last(path))];return func==null?undefined:
apply(func,object,args)}function baseIsArguments(value){return isObjectLike(value)&&baseGetTag(value)==argsTag}function baseIsArrayBuffer(value){return isObjectLike(value)&&baseGetTag(value)==arrayBufferTag}function baseIsDate(value){return isObjectLike(value)&&baseGetTag(value)==dateTag}function baseIsEqual(value,other,bitmask,customizer,stack){if(value===other)return true;if(value==null||other==null||!isObjectLike(value)&&!isObjectLike(other))return value!==value&&other!==other;return baseIsEqualDeep(value,
other,bitmask,customizer,baseIsEqual,stack)}function baseIsEqualDeep(object,other,bitmask,customizer,equalFunc,stack){var objIsArr=isArray(object),othIsArr=isArray(other),objTag=objIsArr?arrayTag:getTag(object),othTag=othIsArr?arrayTag:getTag(other);objTag=objTag==argsTag?objectTag:objTag;othTag=othTag==argsTag?objectTag:othTag;var objIsObj=objTag==objectTag,othIsObj=othTag==objectTag,isSameTag=objTag==othTag;if(isSameTag&&isBuffer(object)){if(!isBuffer(other))return false;objIsArr=true;objIsObj=
false}if(isSameTag&&!objIsObj){stack||(stack=new Stack);return objIsArr||isTypedArray(object)?equalArrays(object,other,bitmask,customizer,equalFunc,stack):equalByTag(object,other,objTag,bitmask,customizer,equalFunc,stack)}if(!(bitmask&COMPARE_PARTIAL_FLAG)){var objIsWrapped=objIsObj&&hasOwnProperty.call(object,"__wrapped__"),othIsWrapped=othIsObj&&hasOwnProperty.call(other,"__wrapped__");if(objIsWrapped||othIsWrapped){var objUnwrapped=objIsWrapped?object.value():object,othUnwrapped=othIsWrapped?other.value():
other;stack||(stack=new Stack);return equalFunc(objUnwrapped,othUnwrapped,bitmask,customizer,stack)}}if(!isSameTag)return false;stack||(stack=new Stack);return equalObjects(object,other,bitmask,customizer,equalFunc,stack)}function baseIsMap(value){return isObjectLike(value)&&getTag(value)==mapTag}function baseIsMatch(object,source,matchData,customizer){var index=matchData.length,length=index,noCustomizer=!customizer;if(object==null)return!length;object=Object(object);while(index--){var data=matchData[index];
if(noCustomizer&&data[2]?data[1]!==object[data[0]]:!(data[0]in object))return false}while(++index<length){data=matchData[index];var key=data[0],objValue=object[key],srcValue=data[1];if(noCustomizer&&data[2]){if(objValue===undefined&&!(key in object))return false}else{var stack=new Stack;if(customizer)var result=customizer(objValue,srcValue,key,object,source,stack);if(!(result===undefined?baseIsEqual(srcValue,objValue,COMPARE_PARTIAL_FLAG|COMPARE_UNORDERED_FLAG,customizer,stack):result))return false}}return true}
function baseIsNative(value){if(!isObject(value)||isMasked(value))return false;var pattern=isFunction(value)?reIsNative:reIsHostCtor;return pattern.test(toSource(value))}function baseIsRegExp(value){return isObjectLike(value)&&baseGetTag(value)==regexpTag}function baseIsSet(value){return isObjectLike(value)&&getTag(value)==setTag}function baseIsTypedArray(value){return isObjectLike(value)&&isLength(value.length)&&!!typedArrayTags[baseGetTag(value)]}function baseIteratee(value){if(typeof value=="function")return value;
if(value==null)return identity;if(typeof value=="object")return isArray(value)?baseMatchesProperty(value[0],value[1]):baseMatches(value);return property(value)}function baseKeys(object){if(!isPrototype(object))return nativeKeys(object);var result=[];for(var key in Object(object))if(hasOwnProperty.call(object,key)&&key!="constructor")result.push(key);return result}function baseKeysIn(object){if(!isObject(object))return nativeKeysIn(object);var isProto=isPrototype(object),result=[];for(var key in object)if(!(key==
"constructor"&&(isProto||!hasOwnProperty.call(object,key))))result.push(key);return result}function baseLt(value,other){return value<other}function baseMap(collection,iteratee){var index=-1,result=isArrayLike(collection)?Array(collection.length):[];baseEach(collection,function(value,key,collection){result[++index]=iteratee(value,key,collection)});return result}function baseMatches(source){var matchData=getMatchData(source);if(matchData.length==1&&matchData[0][2])return matchesStrictComparable(matchData[0][0],
matchData[0][1]);return function(object){return object===source||baseIsMatch(object,source,matchData)}}function baseMatchesProperty(path,srcValue){if(isKey(path)&&isStrictComparable(srcValue))return matchesStrictComparable(toKey(path),srcValue);return function(object){var objValue=get(object,path);return objValue===undefined&&objValue===srcValue?hasIn(object,path):baseIsEqual(srcValue,objValue,COMPARE_PARTIAL_FLAG|COMPARE_UNORDERED_FLAG)}}function baseMerge(object,source,srcIndex,customizer,stack){if(object===
source)return;baseFor(source,function(srcValue,key){if(isObject(srcValue)){stack||(stack=new Stack);baseMergeDeep(object,source,key,srcIndex,baseMerge,customizer,stack)}else{var newValue=customizer?customizer(safeGet(object,key),srcValue,key+"",object,source,stack):undefined;if(newValue===undefined)newValue=srcValue;assignMergeValue(object,key,newValue)}},keysIn)}function baseMergeDeep(object,source,key,srcIndex,mergeFunc,customizer,stack){var objValue=safeGet(object,key),srcValue=safeGet(source,
key),stacked=stack.get(srcValue);if(stacked){assignMergeValue(object,key,stacked);return}var newValue=customizer?customizer(objValue,srcValue,key+"",object,source,stack):undefined;var isCommon=newValue===undefined;if(isCommon){var isArr=isArray(srcValue),isBuff=!isArr&&isBuffer(srcValue),isTyped=!isArr&&!isBuff&&isTypedArray(srcValue);newValue=srcValue;if(isArr||isBuff||isTyped)if(isArray(objValue))newValue=objValue;else if(isArrayLikeObject(objValue))newValue=copyArray(objValue);else if(isBuff){isCommon=
false;newValue=cloneBuffer(srcValue,true)}else if(isTyped){isCommon=false;newValue=cloneTypedArray(srcValue,true)}else newValue=[];else if(isPlainObject(srcValue)||isArguments(srcValue)){newValue=objValue;if(isArguments(objValue))newValue=toPlainObject(objValue);else if(!isObject(objValue)||srcIndex&&isFunction(objValue))newValue=initCloneObject(srcValue)}else isCommon=false}if(isCommon){stack.set(srcValue,newValue);mergeFunc(newValue,srcValue,srcIndex,customizer,stack);stack["delete"](srcValue)}assignMergeValue(object,
key,newValue)}function baseNth(array,n){var length=array.length;if(!length)return;n+=n<0?length:0;return isIndex(n,length)?array[n]:undefined}function baseOrderBy(collection,iteratees,orders){var index=-1;iteratees=arrayMap(iteratees.length?iteratees:[identity],baseUnary(getIteratee()));var result=baseMap(collection,function(value,key,collection){var criteria=arrayMap(iteratees,function(iteratee){return iteratee(value)});return{"criteria":criteria,"index":++index,"value":value}});return baseSortBy(result,
function(object,other){return compareMultiple(object,other,orders)})}function basePick(object,paths){return basePickBy(object,paths,function(value,path){return hasIn(object,path)})}function basePickBy(object,paths,predicate){var index=-1,length=paths.length,result={};while(++index<length){var path=paths[index],value=baseGet(object,path);if(predicate(value,path))baseSet(result,castPath(path,object),value)}return result}function basePropertyDeep(path){return function(object){return baseGet(object,path)}}
function basePullAll(array,values,iteratee,comparator){var indexOf=comparator?baseIndexOfWith:baseIndexOf,index=-1,length=values.length,seen=array;if(array===values)values=copyArray(values);if(iteratee)seen=arrayMap(array,baseUnary(iteratee));while(++index<length){var fromIndex=0,value=values[index],computed=iteratee?iteratee(value):value;while((fromIndex=indexOf(seen,computed,fromIndex,comparator))>-1){if(seen!==array)splice.call(seen,fromIndex,1);splice.call(array,fromIndex,1)}}return array}function basePullAt(array,
indexes){var length=array?indexes.length:0,lastIndex=length-1;while(length--){var index=indexes[length];if(length==lastIndex||index!==previous){var previous=index;if(isIndex(index))splice.call(array,index,1);else baseUnset(array,index)}}return array}function baseRandom(lower,upper){return lower+nativeFloor(nativeRandom()*(upper-lower+1))}function baseRange(start,end,step,fromRight){var index=-1,length=nativeMax(nativeCeil((end-start)/(step||1)),0),result=Array(length);while(length--){result[fromRight?
length:++index]=start;start+=step}return result}function baseRepeat(string,n){var result="";if(!string||n<1||n>MAX_SAFE_INTEGER)return result;do{if(n%2)result+=string;n=nativeFloor(n/2);if(n)string+=string}while(n);return result}function baseRest(func,start){return setToString(overRest(func,start,identity),func+"")}function baseSample(collection){return arraySample(values(collection))}function baseSampleSize(collection,n){var array=values(collection);return shuffleSelf(array,baseClamp(n,0,array.length))}
function baseSet(object,path,value,customizer){if(!isObject(object))return object;path=castPath(path,object);var index=-1,length=path.length,lastIndex=length-1,nested=object;while(nested!=null&&++index<length){var key=toKey(path[index]),newValue=value;if(index!=lastIndex){var objValue=nested[key];newValue=customizer?customizer(objValue,key,nested):undefined;if(newValue===undefined)newValue=isObject(objValue)?objValue:isIndex(path[index+1])?[]:{}}assignValue(nested,key,newValue);nested=nested[key]}return object}
var baseSetData=!metaMap?identity:function(func,data){metaMap.set(func,data);return func};var baseSetToString=!defineProperty?identity:function(func,string){return defineProperty(func,"toString",{"configurable":true,"enumerable":false,"value":constant(string),"writable":true})};function baseShuffle(collection){return shuffleSelf(values(collection))}function baseSlice(array,start,end){var index=-1,length=array.length;if(start<0)start=-start>length?0:length+start;end=end>length?length:end;if(end<0)end+=
length;length=start>end?0:end-start>>>0;start>>>=0;var result=Array(length);while(++index<length)result[index]=array[index+start];return result}function baseSome(collection,predicate){var result;baseEach(collection,function(value,index,collection){result=predicate(value,index,collection);return!result});return!!result}function baseSortedIndex(array,value,retHighest){var low=0,high=array==null?low:array.length;if(typeof value=="number"&&value===value&&high<=HALF_MAX_ARRAY_LENGTH){while(low<high){var mid=
low+high>>>1,computed=array[mid];if(computed!==null&&!isSymbol(computed)&&(retHighest?computed<=value:computed<value))low=mid+1;else high=mid}return high}return baseSortedIndexBy(array,value,identity,retHighest)}function baseSortedIndexBy(array,value,iteratee,retHighest){value=iteratee(value);var low=0,high=array==null?0:array.length,valIsNaN=value!==value,valIsNull=value===null,valIsSymbol=isSymbol(value),valIsUndefined=value===undefined;while(low<high){var mid=nativeFloor((low+high)/2),computed=
iteratee(array[mid]),othIsDefined=computed!==undefined,othIsNull=computed===null,othIsReflexive=computed===computed,othIsSymbol=isSymbol(computed);if(valIsNaN)var setLow=retHighest||othIsReflexive;else if(valIsUndefined)setLow=othIsReflexive&&(retHighest||othIsDefined);else if(valIsNull)setLow=othIsReflexive&&othIsDefined&&(retHighest||!othIsNull);else if(valIsSymbol)setLow=othIsReflexive&&othIsDefined&&!othIsNull&&(retHighest||!othIsSymbol);else if(othIsNull||othIsSymbol)setLow=false;else setLow=
retHighest?computed<=value:computed<value;if(setLow)low=mid+1;else high=mid}return nativeMin(high,MAX_ARRAY_INDEX)}function baseSortedUniq(array,iteratee){var index=-1,length=array.length,resIndex=0,result=[];while(++index<length){var value=array[index],computed=iteratee?iteratee(value):value;if(!index||!eq(computed,seen)){var seen=computed;result[resIndex++]=value===0?0:value}}return result}function baseToNumber(value){if(typeof value=="number")return value;if(isSymbol(value))return NAN;return+value}
function baseToString(value){if(typeof value=="string")return value;if(isArray(value))return arrayMap(value,baseToString)+"";if(isSymbol(value))return symbolToString?symbolToString.call(value):"";var result=value+"";return result=="0"&&1/value==-INFINITY?"-0":result}function baseUniq(array,iteratee,comparator){var index=-1,includes=arrayIncludes,length=array.length,isCommon=true,result=[],seen=result;if(comparator){isCommon=false;includes=arrayIncludesWith}else if(length>=LARGE_ARRAY_SIZE){var set=
iteratee?null:createSet(array);if(set)return setToArray(set);isCommon=false;includes=cacheHas;seen=new SetCache}else seen=iteratee?[]:result;outer:while(++index<length){var value=array[index],computed=iteratee?iteratee(value):value;value=comparator||value!==0?value:0;if(isCommon&&computed===computed){var seenIndex=seen.length;while(seenIndex--)if(seen[seenIndex]===computed)continue outer;if(iteratee)seen.push(computed);result.push(value)}else if(!includes(seen,computed,comparator)){if(seen!==result)seen.push(computed);
result.push(value)}}return result}function baseUnset(object,path){path=castPath(path,object);object=parent(object,path);return object==null||delete object[toKey(last(path))]}function baseUpdate(object,path,updater,customizer){return baseSet(object,path,updater(baseGet(object,path)),customizer)}function baseWhile(array,predicate,isDrop,fromRight){var length=array.length,index=fromRight?length:-1;while((fromRight?index--:++index<length)&&predicate(array[index],index,array));return isDrop?baseSlice(array,
fromRight?0:index,fromRight?index+1:length):baseSlice(array,fromRight?index+1:0,fromRight?length:index)}function baseWrapperValue(value,actions){var result=value;if(result instanceof LazyWrapper)result=result.value();return arrayReduce(actions,function(result,action){return action.func.apply(action.thisArg,arrayPush([result],action.args))},result)}function baseXor(arrays,iteratee,comparator){var length=arrays.length;if(length<2)return length?baseUniq(arrays[0]):[];var index=-1,result=Array(length);
while(++index<length){var array=arrays[index],othIndex=-1;while(++othIndex<length)if(othIndex!=index)result[index]=baseDifference(result[index]||array,arrays[othIndex],iteratee,comparator)}return baseUniq(baseFlatten(result,1),iteratee,comparator)}function baseZipObject(props,values,assignFunc){var index=-1,length=props.length,valsLength=values.length,result={};while(++index<length){var value=index<valsLength?values[index]:undefined;assignFunc(result,props[index],value)}return result}function castArrayLikeObject(value){return isArrayLikeObject(value)?
value:[]}function castFunction(value){return typeof value=="function"?value:identity}function castPath(value,object){if(isArray(value))return value;return isKey(value,object)?[value]:stringToPath(toString(value))}var castRest=baseRest;function castSlice(array,start,end){var length=array.length;end=end===undefined?length:end;return!start&&end>=length?array:baseSlice(array,start,end)}var clearTimeout=ctxClearTimeout||function(id){return root.clearTimeout(id)};function cloneBuffer(buffer,isDeep){if(isDeep)return buffer.slice();
var length=buffer.length,result=allocUnsafe?allocUnsafe(length):new buffer.constructor(length);buffer.copy(result);return result}function cloneArrayBuffer(arrayBuffer){var result=new arrayBuffer.constructor(arrayBuffer.byteLength);(new Uint8Array(result)).set(new Uint8Array(arrayBuffer));return result}function cloneDataView(dataView,isDeep){var buffer=isDeep?cloneArrayBuffer(dataView.buffer):dataView.buffer;return new dataView.constructor(buffer,dataView.byteOffset,dataView.byteLength)}function cloneRegExp(regexp){var result=
new regexp.constructor(regexp.source,reFlags.exec(regexp));result.lastIndex=regexp.lastIndex;return result}function cloneSymbol(symbol){return symbolValueOf?Object(symbolValueOf.call(symbol)):{}}function cloneTypedArray(typedArray,isDeep){var buffer=isDeep?cloneArrayBuffer(typedArray.buffer):typedArray.buffer;return new typedArray.constructor(buffer,typedArray.byteOffset,typedArray.length)}function compareAscending(value,other){if(value!==other){var valIsDefined=value!==undefined,valIsNull=value===
null,valIsReflexive=value===value,valIsSymbol=isSymbol(value);var othIsDefined=other!==undefined,othIsNull=other===null,othIsReflexive=other===other,othIsSymbol=isSymbol(other);if(!othIsNull&&!othIsSymbol&&!valIsSymbol&&value>other||valIsSymbol&&othIsDefined&&othIsReflexive&&!othIsNull&&!othIsSymbol||valIsNull&&othIsDefined&&othIsReflexive||!valIsDefined&&othIsReflexive||!valIsReflexive)return 1;if(!valIsNull&&!valIsSymbol&&!othIsSymbol&&value<other||othIsSymbol&&valIsDefined&&valIsReflexive&&!valIsNull&&
!valIsSymbol||othIsNull&&valIsDefined&&valIsReflexive||!othIsDefined&&valIsReflexive||!othIsReflexive)return-1}return 0}function compareMultiple(object,other,orders){var index=-1,objCriteria=object.criteria,othCriteria=other.criteria,length=objCriteria.length,ordersLength=orders.length;while(++index<length){var result=compareAscending(objCriteria[index],othCriteria[index]);if(result){if(index>=ordersLength)return result;var order=orders[index];return result*(order=="desc"?-1:1)}}return object.index-
other.index}function composeArgs(args,partials,holders,isCurried){var argsIndex=-1,argsLength=args.length,holdersLength=holders.length,leftIndex=-1,leftLength=partials.length,rangeLength=nativeMax(argsLength-holdersLength,0),result=Array(leftLength+rangeLength),isUncurried=!isCurried;while(++leftIndex<leftLength)result[leftIndex]=partials[leftIndex];while(++argsIndex<holdersLength)if(isUncurried||argsIndex<argsLength)result[holders[argsIndex]]=args[argsIndex];while(rangeLength--)result[leftIndex++]=
args[argsIndex++];return result}function composeArgsRight(args,partials,holders,isCurried){var argsIndex=-1,argsLength=args.length,holdersIndex=-1,holdersLength=holders.length,rightIndex=-1,rightLength=partials.length,rangeLength=nativeMax(argsLength-holdersLength,0),result=Array(rangeLength+rightLength),isUncurried=!isCurried;while(++argsIndex<rangeLength)result[argsIndex]=args[argsIndex];var offset=argsIndex;while(++rightIndex<rightLength)result[offset+rightIndex]=partials[rightIndex];while(++holdersIndex<
holdersLength)if(isUncurried||argsIndex<argsLength)result[offset+holders[holdersIndex]]=args[argsIndex++];return result}function copyArray(source,array){var index=-1,length=source.length;array||(array=Array(length));while(++index<length)array[index]=source[index];return array}function copyObject(source,props,object,customizer){var isNew=!object;object||(object={});var index=-1,length=props.length;while(++index<length){var key=props[index];var newValue=customizer?customizer(object[key],source[key],
key,object,source):undefined;if(newValue===undefined)newValue=source[key];if(isNew)baseAssignValue(object,key,newValue);else assignValue(object,key,newValue)}return object}function copySymbols(source,object){return copyObject(source,getSymbols(source),object)}function copySymbolsIn(source,object){return copyObject(source,getSymbolsIn(source),object)}function createAggregator(setter,initializer){return function(collection,iteratee){var func=isArray(collection)?arrayAggregator:baseAggregator,accumulator=
initializer?initializer():{};return func(collection,setter,getIteratee(iteratee,2),accumulator)}}function createAssigner(assigner){return baseRest(function(object,sources){var index=-1,length=sources.length,customizer=length>1?sources[length-1]:undefined,guard=length>2?sources[2]:undefined;customizer=assigner.length>3&&typeof customizer=="function"?(length--,customizer):undefined;if(guard&&isIterateeCall(sources[0],sources[1],guard)){customizer=length<3?undefined:customizer;length=1}object=Object(object);
while(++index<length){var source=sources[index];if(source)assigner(object,source,index,customizer)}return object})}function createBaseEach(eachFunc,fromRight){return function(collection,iteratee){if(collection==null)return collection;if(!isArrayLike(collection))return eachFunc(collection,iteratee);var length=collection.length,index=fromRight?length:-1,iterable=Object(collection);while(fromRight?index--:++index<length)if(iteratee(iterable[index],index,iterable)===false)break;return collection}}function createBaseFor(fromRight){return function(object,
iteratee,keysFunc){var index=-1,iterable=Object(object),props=keysFunc(object),length=props.length;while(length--){var key=props[fromRight?length:++index];if(iteratee(iterable[key],key,iterable)===false)break}return object}}function createBind(func,bitmask,thisArg){var isBind=bitmask&WRAP_BIND_FLAG,Ctor=createCtor(func);function wrapper(){var fn=this&&this!==root&&this instanceof wrapper?Ctor:func;return fn.apply(isBind?thisArg:this,arguments)}return wrapper}function createCaseFirst(methodName){return function(string){string=
toString(string);var strSymbols=hasUnicode(string)?stringToArray(string):undefined;var chr=strSymbols?strSymbols[0]:string.charAt(0);var trailing=strSymbols?castSlice(strSymbols,1).join(""):string.slice(1);return chr[methodName]()+trailing}}function createCompounder(callback){return function(string){return arrayReduce(words(deburr(string).replace(reApos,"")),callback,"")}}function createCtor(Ctor){return function(){var args=arguments;switch(args.length){case 0:return new Ctor;case 1:return new Ctor(args[0]);
case 2:return new Ctor(args[0],args[1]);case 3:return new Ctor(args[0],args[1],args[2]);case 4:return new Ctor(args[0],args[1],args[2],args[3]);case 5:return new Ctor(args[0],args[1],args[2],args[3],args[4]);case 6:return new Ctor(args[0],args[1],args[2],args[3],args[4],args[5]);case 7:return new Ctor(args[0],args[1],args[2],args[3],args[4],args[5],args[6])}var thisBinding=baseCreate(Ctor.prototype),result=Ctor.apply(thisBinding,args);return isObject(result)?result:thisBinding}}function createCurry(func,
bitmask,arity){var Ctor=createCtor(func);function wrapper(){var length=arguments.length,args=Array(length),index=length,placeholder=getHolder(wrapper);while(index--)args[index]=arguments[index];var holders=length<3&&args[0]!==placeholder&&args[length-1]!==placeholder?[]:replaceHolders(args,placeholder);length-=holders.length;if(length<arity)return createRecurry(func,bitmask,createHybrid,wrapper.placeholder,undefined,args,holders,undefined,undefined,arity-length);var fn=this&&this!==root&&this instanceof
wrapper?Ctor:func;return apply(fn,this,args)}return wrapper}function createFind(findIndexFunc){return function(collection,predicate,fromIndex){var iterable=Object(collection);if(!isArrayLike(collection)){var iteratee=getIteratee(predicate,3);collection=keys(collection);predicate=function(key){return iteratee(iterable[key],key,iterable)}}var index=findIndexFunc(collection,predicate,fromIndex);return index>-1?iterable[iteratee?collection[index]:index]:undefined}}function createFlow(fromRight){return flatRest(function(funcs){var length=
funcs.length,index=length,prereq=LodashWrapper.prototype.thru;if(fromRight)funcs.reverse();while(index--){var func=funcs[index];if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);if(prereq&&!wrapper&&getFuncName(func)=="wrapper")var wrapper=new LodashWrapper([],true)}index=wrapper?index:length;while(++index<length){func=funcs[index];var funcName=getFuncName(func),data=funcName=="wrapper"?getData(func):undefined;if(data&&isLaziable(data[0])&&data[1]==(WRAP_ARY_FLAG|WRAP_CURRY_FLAG|WRAP_PARTIAL_FLAG|
WRAP_REARG_FLAG)&&!data[4].length&&data[9]==1)wrapper=wrapper[getFuncName(data[0])].apply(wrapper,data[3]);else wrapper=func.length==1&&isLaziable(func)?wrapper[funcName]():wrapper.thru(func)}return function(){var args=arguments,value=args[0];if(wrapper&&args.length==1&&isArray(value))return wrapper.plant(value).value();var index=0,result=length?funcs[index].apply(this,args):value;while(++index<length)result=funcs[index].call(this,result);return result}})}function createHybrid(func,bitmask,thisArg,
partials,holders,partialsRight,holdersRight,argPos,ary,arity){var isAry=bitmask&WRAP_ARY_FLAG,isBind=bitmask&WRAP_BIND_FLAG,isBindKey=bitmask&WRAP_BIND_KEY_FLAG,isCurried=bitmask&(WRAP_CURRY_FLAG|WRAP_CURRY_RIGHT_FLAG),isFlip=bitmask&WRAP_FLIP_FLAG,Ctor=isBindKey?undefined:createCtor(func);function wrapper(){var length=arguments.length,args=Array(length),index=length;while(index--)args[index]=arguments[index];if(isCurried)var placeholder=getHolder(wrapper),holdersCount=countHolders(args,placeholder);
if(partials)args=composeArgs(args,partials,holders,isCurried);if(partialsRight)args=composeArgsRight(args,partialsRight,holdersRight,isCurried);length-=holdersCount;if(isCurried&&length<arity){var newHolders=replaceHolders(args,placeholder);return createRecurry(func,bitmask,createHybrid,wrapper.placeholder,thisArg,args,newHolders,argPos,ary,arity-length)}var thisBinding=isBind?thisArg:this,fn=isBindKey?thisBinding[func]:func;length=args.length;if(argPos)args=reorder(args,argPos);else if(isFlip&&length>
1)args.reverse();if(isAry&&ary<length)args.length=ary;if(this&&this!==root&&this instanceof wrapper)fn=Ctor||createCtor(fn);return fn.apply(thisBinding,args)}return wrapper}function createInverter(setter,toIteratee){return function(object,iteratee){return baseInverter(object,setter,toIteratee(iteratee),{})}}function createMathOperation(operator,defaultValue){return function(value,other){var result;if(value===undefined&&other===undefined)return defaultValue;if(value!==undefined)result=value;if(other!==
undefined){if(result===undefined)return other;if(typeof value=="string"||typeof other=="string"){value=baseToString(value);other=baseToString(other)}else{value=baseToNumber(value);other=baseToNumber(other)}result=operator(value,other)}return result}}function createOver(arrayFunc){return flatRest(function(iteratees){iteratees=arrayMap(iteratees,baseUnary(getIteratee()));return baseRest(function(args){var thisArg=this;return arrayFunc(iteratees,function(iteratee){return apply(iteratee,thisArg,args)})})})}
function createPadding(length,chars){chars=chars===undefined?" ":baseToString(chars);var charsLength=chars.length;if(charsLength<2)return charsLength?baseRepeat(chars,length):chars;var result=baseRepeat(chars,nativeCeil(length/stringSize(chars)));return hasUnicode(chars)?castSlice(stringToArray(result),0,length).join(""):result.slice(0,length)}function createPartial(func,bitmask,thisArg,partials){var isBind=bitmask&WRAP_BIND_FLAG,Ctor=createCtor(func);function wrapper(){var argsIndex=-1,argsLength=
arguments.length,leftIndex=-1,leftLength=partials.length,args=Array(leftLength+argsLength),fn=this&&this!==root&&this instanceof wrapper?Ctor:func;while(++leftIndex<leftLength)args[leftIndex]=partials[leftIndex];while(argsLength--)args[leftIndex++]=arguments[++argsIndex];return apply(fn,isBind?thisArg:this,args)}return wrapper}function createRange(fromRight){return function(start,end,step){if(step&&typeof step!="number"&&isIterateeCall(start,end,step))end=step=undefined;start=toFinite(start);if(end===
undefined){end=start;start=0}else end=toFinite(end);step=step===undefined?start<end?1:-1:toFinite(step);return baseRange(start,end,step,fromRight)}}function createRelationalOperation(operator){return function(value,other){if(!(typeof value=="string"&&typeof other=="string")){value=toNumber(value);other=toNumber(other)}return operator(value,other)}}function createRecurry(func,bitmask,wrapFunc,placeholder,thisArg,partials,holders,argPos,ary,arity){var isCurry=bitmask&WRAP_CURRY_FLAG,newHolders=isCurry?
holders:undefined,newHoldersRight=isCurry?undefined:holders,newPartials=isCurry?partials:undefined,newPartialsRight=isCurry?undefined:partials;bitmask|=isCurry?WRAP_PARTIAL_FLAG:WRAP_PARTIAL_RIGHT_FLAG;bitmask&=~(isCurry?WRAP_PARTIAL_RIGHT_FLAG:WRAP_PARTIAL_FLAG);if(!(bitmask&WRAP_CURRY_BOUND_FLAG))bitmask&=~(WRAP_BIND_FLAG|WRAP_BIND_KEY_FLAG);var newData=[func,bitmask,thisArg,newPartials,newHolders,newPartialsRight,newHoldersRight,argPos,ary,arity];var result=wrapFunc.apply(undefined,newData);if(isLaziable(func))setData(result,
newData);result.placeholder=placeholder;return setWrapToString(result,func,bitmask)}function createRound(methodName){var func=Math[methodName];return function(number,precision){number=toNumber(number);precision=precision==null?0:nativeMin(toInteger(precision),292);if(precision){var pair=(toString(number)+"e").split("e"),value=func(pair[0]+"e"+(+pair[1]+precision));pair=(toString(value)+"e").split("e");return+(pair[0]+"e"+(+pair[1]-precision))}return func(number)}}var createSet=!(Set&&1/setToArray(new Set([,
-0]))[1]==INFINITY)?noop:function(values){return new Set(values)};function createToPairs(keysFunc){return function(object){var tag=getTag(object);if(tag==mapTag)return mapToArray(object);if(tag==setTag)return setToPairs(object);return baseToPairs(object,keysFunc(object))}}function createWrap(func,bitmask,thisArg,partials,holders,argPos,ary,arity){var isBindKey=bitmask&WRAP_BIND_KEY_FLAG;if(!isBindKey&&typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);var length=partials?partials.length:
0;if(!length){bitmask&=~(WRAP_PARTIAL_FLAG|WRAP_PARTIAL_RIGHT_FLAG);partials=holders=undefined}ary=ary===undefined?ary:nativeMax(toInteger(ary),0);arity=arity===undefined?arity:toInteger(arity);length-=holders?holders.length:0;if(bitmask&WRAP_PARTIAL_RIGHT_FLAG){var partialsRight=partials,holdersRight=holders;partials=holders=undefined}var data=isBindKey?undefined:getData(func);var newData=[func,bitmask,thisArg,partials,holders,partialsRight,holdersRight,argPos,ary,arity];if(data)mergeData(newData,
data);func=newData[0];bitmask=newData[1];thisArg=newData[2];partials=newData[3];holders=newData[4];arity=newData[9]=newData[9]===undefined?isBindKey?0:func.length:nativeMax(newData[9]-length,0);if(!arity&&bitmask&(WRAP_CURRY_FLAG|WRAP_CURRY_RIGHT_FLAG))bitmask&=~(WRAP_CURRY_FLAG|WRAP_CURRY_RIGHT_FLAG);if(!bitmask||bitmask==WRAP_BIND_FLAG)var result=createBind(func,bitmask,thisArg);else if(bitmask==WRAP_CURRY_FLAG||bitmask==WRAP_CURRY_RIGHT_FLAG)result=createCurry(func,bitmask,arity);else if((bitmask==
WRAP_PARTIAL_FLAG||bitmask==(WRAP_BIND_FLAG|WRAP_PARTIAL_FLAG))&&!holders.length)result=createPartial(func,bitmask,thisArg,partials);else result=createHybrid.apply(undefined,newData);var setter=data?baseSetData:setData;return setWrapToString(setter(result,newData),func,bitmask)}function customDefaultsAssignIn(objValue,srcValue,key,object){if(objValue===undefined||eq(objValue,objectProto[key])&&!hasOwnProperty.call(object,key))return srcValue;return objValue}function customDefaultsMerge(objValue,srcValue,
key,object,source,stack){if(isObject(objValue)&&isObject(srcValue)){stack.set(srcValue,objValue);baseMerge(objValue,srcValue,undefined,customDefaultsMerge,stack);stack["delete"](srcValue)}return objValue}function customOmitClone(value){return isPlainObject(value)?undefined:value}function equalArrays(array,other,bitmask,customizer,equalFunc,stack){var isPartial=bitmask&COMPARE_PARTIAL_FLAG,arrLength=array.length,othLength=other.length;if(arrLength!=othLength&&!(isPartial&&othLength>arrLength))return false;
var stacked=stack.get(array);if(stacked&&stack.get(other))return stacked==other;var index=-1,result=true,seen=bitmask&COMPARE_UNORDERED_FLAG?new SetCache:undefined;stack.set(array,other);stack.set(other,array);while(++index<arrLength){var arrValue=array[index],othValue=other[index];if(customizer)var compared=isPartial?customizer(othValue,arrValue,index,other,array,stack):customizer(arrValue,othValue,index,array,other,stack);if(compared!==undefined){if(compared)continue;result=false;break}if(seen){if(!arraySome(other,
function(othValue,othIndex){if(!cacheHas(seen,othIndex)&&(arrValue===othValue||equalFunc(arrValue,othValue,bitmask,customizer,stack)))return seen.push(othIndex)})){result=false;break}}else if(!(arrValue===othValue||equalFunc(arrValue,othValue,bitmask,customizer,stack))){result=false;break}}stack["delete"](array);stack["delete"](other);return result}function equalByTag(object,other,tag,bitmask,customizer,equalFunc,stack){switch(tag){case dataViewTag:if(object.byteLength!=other.byteLength||object.byteOffset!=
other.byteOffset)return false;object=object.buffer;other=other.buffer;case arrayBufferTag:if(object.byteLength!=other.byteLength||!equalFunc(new Uint8Array(object),new Uint8Array(other)))return false;return true;case boolTag:case dateTag:case numberTag:return eq(+object,+other);case errorTag:return object.name==other.name&&object.message==other.message;case regexpTag:case stringTag:return object==other+"";case mapTag:var convert=mapToArray;case setTag:var isPartial=bitmask&COMPARE_PARTIAL_FLAG;convert||
(convert=setToArray);if(object.size!=other.size&&!isPartial)return false;var stacked=stack.get(object);if(stacked)return stacked==other;bitmask|=COMPARE_UNORDERED_FLAG;stack.set(object,other);var result=equalArrays(convert(object),convert(other),bitmask,customizer,equalFunc,stack);stack["delete"](object);return result;case symbolTag:if(symbolValueOf)return symbolValueOf.call(object)==symbolValueOf.call(other)}return false}function equalObjects(object,other,bitmask,customizer,equalFunc,stack){var isPartial=
bitmask&COMPARE_PARTIAL_FLAG,objProps=getAllKeys(object),objLength=objProps.length,othProps=getAllKeys(other),othLength=othProps.length;if(objLength!=othLength&&!isPartial)return false;var index=objLength;while(index--){var key=objProps[index];if(!(isPartial?key in other:hasOwnProperty.call(other,key)))return false}var stacked=stack.get(object);if(stacked&&stack.get(other))return stacked==other;var result=true;stack.set(object,other);stack.set(other,object);var skipCtor=isPartial;while(++index<objLength){key=
objProps[index];var objValue=object[key],othValue=other[key];if(customizer)var compared=isPartial?customizer(othValue,objValue,key,other,object,stack):customizer(objValue,othValue,key,object,other,stack);if(!(compared===undefined?objValue===othValue||equalFunc(objValue,othValue,bitmask,customizer,stack):compared)){result=false;break}skipCtor||(skipCtor=key=="constructor")}if(result&&!skipCtor){var objCtor=object.constructor,othCtor=other.constructor;if(objCtor!=othCtor&&("constructor"in object&&"constructor"in
other)&&!(typeof objCtor=="function"&&objCtor instanceof objCtor&&typeof othCtor=="function"&&othCtor instanceof othCtor))result=false}stack["delete"](object);stack["delete"](other);return result}function flatRest(func){return setToString(overRest(func,undefined,flatten),func+"")}function getAllKeys(object){return baseGetAllKeys(object,keys,getSymbols)}function getAllKeysIn(object){return baseGetAllKeys(object,keysIn,getSymbolsIn)}var getData=!metaMap?noop:function(func){return metaMap.get(func)};
function getFuncName(func){var result=func.name+"",array=realNames[result],length=hasOwnProperty.call(realNames,result)?array.length:0;while(length--){var data=array[length],otherFunc=data.func;if(otherFunc==null||otherFunc==func)return data.name}return result}function getHolder(func){var object=hasOwnProperty.call(lodash,"placeholder")?lodash:func;return object.placeholder}function getIteratee(){var result=lodash.iteratee||iteratee;result=result===iteratee?baseIteratee:result;return arguments.length?
result(arguments[0],arguments[1]):result}function getMapData(map,key){var data=map.__data__;return isKeyable(key)?data[typeof key=="string"?"string":"hash"]:data.map}function getMatchData(object){var result=keys(object),length=result.length;while(length--){var key=result[length],value=object[key];result[length]=[key,value,isStrictComparable(value)]}return result}function getNative(object,key){var value=getValue(object,key);return baseIsNative(value)?value:undefined}function getRawTag(value){var isOwn=
hasOwnProperty.call(value,symToStringTag),tag=value[symToStringTag];try{value[symToStringTag]=undefined;var unmasked=true}catch(e){}var result=nativeObjectToString.call(value);if(unmasked)if(isOwn)value[symToStringTag]=tag;else delete value[symToStringTag];return result}var getSymbols=!nativeGetSymbols?stubArray:function(object){if(object==null)return[];object=Object(object);return arrayFilter(nativeGetSymbols(object),function(symbol){return propertyIsEnumerable.call(object,symbol)})};var getSymbolsIn=
!nativeGetSymbols?stubArray:function(object){var result=[];while(object){arrayPush(result,getSymbols(object));object=getPrototype(object)}return result};var getTag=baseGetTag;if(DataView&&getTag(new DataView(new ArrayBuffer(1)))!=dataViewTag||Map&&getTag(new Map)!=mapTag||Promise&&getTag(Promise.resolve())!=promiseTag||Set&&getTag(new Set)!=setTag||WeakMap&&getTag(new WeakMap)!=weakMapTag)getTag=function(value){var result=baseGetTag(value),Ctor=result==objectTag?value.constructor:undefined,ctorString=
Ctor?toSource(Ctor):"";if(ctorString)switch(ctorString){case dataViewCtorString:return dataViewTag;case mapCtorString:return mapTag;case promiseCtorString:return promiseTag;case setCtorString:return setTag;case weakMapCtorString:return weakMapTag}return result};function getView(start,end,transforms){var index=-1,length=transforms.length;while(++index<length){var data=transforms[index],size=data.size;switch(data.type){case "drop":start+=size;break;case "dropRight":end-=size;break;case "take":end=nativeMin(end,
start+size);break;case "takeRight":start=nativeMax(start,end-size);break}}return{"start":start,"end":end}}function getWrapDetails(source){var match=source.match(reWrapDetails);return match?match[1].split(reSplitDetails):[]}function hasPath(object,path,hasFunc){path=castPath(path,object);var index=-1,length=path.length,result=false;while(++index<length){var key=toKey(path[index]);if(!(result=object!=null&&hasFunc(object,key)))break;object=object[key]}if(result||++index!=length)return result;length=
object==null?0:object.length;return!!length&&isLength(length)&&isIndex(key,length)&&(isArray(object)||isArguments(object))}function initCloneArray(array){var length=array.length,result=new array.constructor(length);if(length&&typeof array[0]=="string"&&hasOwnProperty.call(array,"index")){result.index=array.index;result.input=array.input}return result}function initCloneObject(object){return typeof object.constructor=="function"&&!isPrototype(object)?baseCreate(getPrototype(object)):{}}function initCloneByTag(object,
tag,isDeep){var Ctor=object.constructor;switch(tag){case arrayBufferTag:return cloneArrayBuffer(object);case boolTag:case dateTag:return new Ctor(+object);case dataViewTag:return cloneDataView(object,isDeep);case float32Tag:case float64Tag:case int8Tag:case int16Tag:case int32Tag:case uint8Tag:case uint8ClampedTag:case uint16Tag:case uint32Tag:return cloneTypedArray(object,isDeep);case mapTag:return new Ctor;case numberTag:case stringTag:return new Ctor(object);case regexpTag:return cloneRegExp(object);
case setTag:return new Ctor;case symbolTag:return cloneSymbol(object)}}function insertWrapDetails(source,details){var length=details.length;if(!length)return source;var lastIndex=length-1;details[lastIndex]=(length>1?"\x26 ":"")+details[lastIndex];details=details.join(length>2?", ":" ");return source.replace(reWrapComment,"{\n/* [wrapped with "+details+"] */\n")}function isFlattenable(value){return isArray(value)||isArguments(value)||!!(spreadableSymbol&&value&&value[spreadableSymbol])}function isIndex(value,
length){var type=typeof value;length=length==null?MAX_SAFE_INTEGER:length;return!!length&&(type=="number"||type!="symbol"&&reIsUint.test(value))&&(value>-1&&value%1==0&&value<length)}function isIterateeCall(value,index,object){if(!isObject(object))return false;var type=typeof index;if(type=="number"?isArrayLike(object)&&isIndex(index,object.length):type=="string"&&index in object)return eq(object[index],value);return false}function isKey(value,object){if(isArray(value))return false;var type=typeof value;
if(type=="number"||type=="symbol"||type=="boolean"||value==null||isSymbol(value))return true;return reIsPlainProp.test(value)||!reIsDeepProp.test(value)||object!=null&&value in Object(object)}function isKeyable(value){var type=typeof value;return type=="string"||type=="number"||type=="symbol"||type=="boolean"?value!=="__proto__":value===null}function isLaziable(func){var funcName=getFuncName(func),other=lodash[funcName];if(typeof other!="function"||!(funcName in LazyWrapper.prototype))return false;
if(func===other)return true;var data=getData(other);return!!data&&func===data[0]}function isMasked(func){return!!maskSrcKey&&maskSrcKey in func}var isMaskable=coreJsData?isFunction:stubFalse;function isPrototype(value){var Ctor=value&&value.constructor,proto=typeof Ctor=="function"&&Ctor.prototype||objectProto;return value===proto}function isStrictComparable(value){return value===value&&!isObject(value)}function matchesStrictComparable(key,srcValue){return function(object){if(object==null)return false;
return object[key]===srcValue&&(srcValue!==undefined||key in Object(object))}}function memoizeCapped(func){var result=memoize(func,function(key){if(cache.size===MAX_MEMOIZE_SIZE)cache.clear();return key});var cache=result.cache;return result}function mergeData(data,source){var bitmask=data[1],srcBitmask=source[1],newBitmask=bitmask|srcBitmask,isCommon=newBitmask<(WRAP_BIND_FLAG|WRAP_BIND_KEY_FLAG|WRAP_ARY_FLAG);var isCombo=srcBitmask==WRAP_ARY_FLAG&&bitmask==WRAP_CURRY_FLAG||srcBitmask==WRAP_ARY_FLAG&&
bitmask==WRAP_REARG_FLAG&&data[7].length<=source[8]||srcBitmask==(WRAP_ARY_FLAG|WRAP_REARG_FLAG)&&source[7].length<=source[8]&&bitmask==WRAP_CURRY_FLAG;if(!(isCommon||isCombo))return data;if(srcBitmask&WRAP_BIND_FLAG){data[2]=source[2];newBitmask|=bitmask&WRAP_BIND_FLAG?0:WRAP_CURRY_BOUND_FLAG}var value=source[3];if(value){var partials=data[3];data[3]=partials?composeArgs(partials,value,source[4]):value;data[4]=partials?replaceHolders(data[3],PLACEHOLDER):source[4]}value=source[5];if(value){partials=
data[5];data[5]=partials?composeArgsRight(partials,value,source[6]):value;data[6]=partials?replaceHolders(data[5],PLACEHOLDER):source[6]}value=source[7];if(value)data[7]=value;if(srcBitmask&WRAP_ARY_FLAG)data[8]=data[8]==null?source[8]:nativeMin(data[8],source[8]);if(data[9]==null)data[9]=source[9];data[0]=source[0];data[1]=newBitmask;return data}function nativeKeysIn(object){var result=[];if(object!=null)for(var key in Object(object))result.push(key);return result}function objectToString(value){return nativeObjectToString.call(value)}
function overRest(func,start,transform){start=nativeMax(start===undefined?func.length-1:start,0);return function(){var args=arguments,index=-1,length=nativeMax(args.length-start,0),array=Array(length);while(++index<length)array[index]=args[start+index];index=-1;var otherArgs=Array(start+1);while(++index<start)otherArgs[index]=args[index];otherArgs[start]=transform(array);return apply(func,this,otherArgs)}}function parent(object,path){return path.length<2?object:baseGet(object,baseSlice(path,0,-1))}
function reorder(array,indexes){var arrLength=array.length,length=nativeMin(indexes.length,arrLength),oldArray=copyArray(array);while(length--){var index=indexes[length];array[length]=isIndex(index,arrLength)?oldArray[index]:undefined}return array}var setData=shortOut(baseSetData);var setTimeout=ctxSetTimeout||function(func,wait){return root.setTimeout(func,wait)};var setToString=shortOut(baseSetToString);function setWrapToString(wrapper,reference,bitmask){var source=reference+"";return setToString(wrapper,
insertWrapDetails(source,updateWrapDetails(getWrapDetails(source),bitmask)))}function shortOut(func){var count=0,lastCalled=0;return function(){var stamp=nativeNow(),remaining=HOT_SPAN-(stamp-lastCalled);lastCalled=stamp;if(remaining>0){if(++count>=HOT_COUNT)return arguments[0]}else count=0;return func.apply(undefined,arguments)}}function shuffleSelf(array,size){var index=-1,length=array.length,lastIndex=length-1;size=size===undefined?length:size;while(++index<size){var rand=baseRandom(index,lastIndex),
value=array[rand];array[rand]=array[index];array[index]=value}array.length=size;return array}var stringToPath=memoizeCapped(function(string){var result=[];if(string.charCodeAt(0)===46)result.push("");string.replace(rePropName,function(match,number,quote,subString){result.push(quote?subString.replace(reEscapeChar,"$1"):number||match)});return result});function toKey(value){if(typeof value=="string"||isSymbol(value))return value;var result=value+"";return result=="0"&&1/value==-INFINITY?"-0":result}
function toSource(func){if(func!=null){try{return funcToString.call(func)}catch(e){}try{return func+""}catch(e$0){}}return""}function updateWrapDetails(details,bitmask){arrayEach(wrapFlags,function(pair){var value="_."+pair[0];if(bitmask&pair[1]&&!arrayIncludes(details,value))details.push(value)});return details.sort()}function wrapperClone(wrapper){if(wrapper instanceof LazyWrapper)return wrapper.clone();var result=new LodashWrapper(wrapper.__wrapped__,wrapper.__chain__);result.__actions__=copyArray(wrapper.__actions__);
result.__index__=wrapper.__index__;result.__values__=wrapper.__values__;return result}function chunk(array,size,guard){if(guard?isIterateeCall(array,size,guard):size===undefined)size=1;else size=nativeMax(toInteger(size),0);var length=array==null?0:array.length;if(!length||size<1)return[];var index=0,resIndex=0,result=Array(nativeCeil(length/size));while(index<length)result[resIndex++]=baseSlice(array,index,index+=size);return result}function compact(array){var index=-1,length=array==null?0:array.length,
resIndex=0,result=[];while(++index<length){var value=array[index];if(value)result[resIndex++]=value}return result}function concat(){var length=arguments.length;if(!length)return[];var args=Array(length-1),array=arguments[0],index=length;while(index--)args[index-1]=arguments[index];return arrayPush(isArray(array)?copyArray(array):[array],baseFlatten(args,1))}var difference=baseRest(function(array,values){return isArrayLikeObject(array)?baseDifference(array,baseFlatten(values,1,isArrayLikeObject,true)):
[]});var differenceBy=baseRest(function(array,values){var iteratee=last(values);if(isArrayLikeObject(iteratee))iteratee=undefined;return isArrayLikeObject(array)?baseDifference(array,baseFlatten(values,1,isArrayLikeObject,true),getIteratee(iteratee,2)):[]});var differenceWith=baseRest(function(array,values){var comparator=last(values);if(isArrayLikeObject(comparator))comparator=undefined;return isArrayLikeObject(array)?baseDifference(array,baseFlatten(values,1,isArrayLikeObject,true),undefined,comparator):
[]});function drop(array,n,guard){var length=array==null?0:array.length;if(!length)return[];n=guard||n===undefined?1:toInteger(n);return baseSlice(array,n<0?0:n,length)}function dropRight(array,n,guard){var length=array==null?0:array.length;if(!length)return[];n=guard||n===undefined?1:toInteger(n);n=length-n;return baseSlice(array,0,n<0?0:n)}function dropRightWhile(array,predicate){return array&&array.length?baseWhile(array,getIteratee(predicate,3),true,true):[]}function dropWhile(array,predicate){return array&&
array.length?baseWhile(array,getIteratee(predicate,3),true):[]}function fill(array,value,start,end){var length=array==null?0:array.length;if(!length)return[];if(start&&typeof start!="number"&&isIterateeCall(array,value,start)){start=0;end=length}return baseFill(array,value,start,end)}function findIndex(array,predicate,fromIndex){var length=array==null?0:array.length;if(!length)return-1;var index=fromIndex==null?0:toInteger(fromIndex);if(index<0)index=nativeMax(length+index,0);return baseFindIndex(array,
getIteratee(predicate,3),index)}function findLastIndex(array,predicate,fromIndex){var length=array==null?0:array.length;if(!length)return-1;var index=length-1;if(fromIndex!==undefined){index=toInteger(fromIndex);index=fromIndex<0?nativeMax(length+index,0):nativeMin(index,length-1)}return baseFindIndex(array,getIteratee(predicate,3),index,true)}function flatten(array){var length=array==null?0:array.length;return length?baseFlatten(array,1):[]}function flattenDeep(array){var length=array==null?0:array.length;
return length?baseFlatten(array,INFINITY):[]}function flattenDepth(array,depth){var length=array==null?0:array.length;if(!length)return[];depth=depth===undefined?1:toInteger(depth);return baseFlatten(array,depth)}function fromPairs(pairs){var index=-1,length=pairs==null?0:pairs.length,result={};while(++index<length){var pair=pairs[index];result[pair[0]]=pair[1]}return result}function head(array){return array&&array.length?array[0]:undefined}function indexOf(array,value,fromIndex){var length=array==
null?0:array.length;if(!length)return-1;var index=fromIndex==null?0:toInteger(fromIndex);if(index<0)index=nativeMax(length+index,0);return baseIndexOf(array,value,index)}function initial(array){var length=array==null?0:array.length;return length?baseSlice(array,0,-1):[]}var intersection=baseRest(function(arrays){var mapped=arrayMap(arrays,castArrayLikeObject);return mapped.length&&mapped[0]===arrays[0]?baseIntersection(mapped):[]});var intersectionBy=baseRest(function(arrays){var iteratee=last(arrays),
mapped=arrayMap(arrays,castArrayLikeObject);if(iteratee===last(mapped))iteratee=undefined;else mapped.pop();return mapped.length&&mapped[0]===arrays[0]?baseIntersection(mapped,getIteratee(iteratee,2)):[]});var intersectionWith=baseRest(function(arrays){var comparator=last(arrays),mapped=arrayMap(arrays,castArrayLikeObject);comparator=typeof comparator=="function"?comparator:undefined;if(comparator)mapped.pop();return mapped.length&&mapped[0]===arrays[0]?baseIntersection(mapped,undefined,comparator):
[]});function join(array,separator){return array==null?"":nativeJoin.call(array,separator)}function last(array){var length=array==null?0:array.length;return length?array[length-1]:undefined}function lastIndexOf(array,value,fromIndex){var length=array==null?0:array.length;if(!length)return-1;var index=length;if(fromIndex!==undefined){index=toInteger(fromIndex);index=index<0?nativeMax(length+index,0):nativeMin(index,length-1)}return value===value?strictLastIndexOf(array,value,index):baseFindIndex(array,
baseIsNaN,index,true)}function nth(array,n){return array&&array.length?baseNth(array,toInteger(n)):undefined}var pull=baseRest(pullAll);function pullAll(array,values){return array&&array.length&&values&&values.length?basePullAll(array,values):array}function pullAllBy(array,values,iteratee){return array&&array.length&&values&&values.length?basePullAll(array,values,getIteratee(iteratee,2)):array}function pullAllWith(array,values,comparator){return array&&array.length&&values&&values.length?basePullAll(array,
values,undefined,comparator):array}var pullAt=flatRest(function(array,indexes){var length=array==null?0:array.length,result=baseAt(array,indexes);basePullAt(array,arrayMap(indexes,function(index){return isIndex(index,length)?+index:index}).sort(compareAscending));return result});function remove(array,predicate){var result=[];if(!(array&&array.length))return result;var index=-1,indexes=[],length=array.length;predicate=getIteratee(predicate,3);while(++index<length){var value=array[index];if(predicate(value,
index,array)){result.push(value);indexes.push(index)}}basePullAt(array,indexes);return result}function reverse(array){return array==null?array:nativeReverse.call(array)}function slice(array,start,end){var length=array==null?0:array.length;if(!length)return[];if(end&&typeof end!="number"&&isIterateeCall(array,start,end)){start=0;end=length}else{start=start==null?0:toInteger(start);end=end===undefined?length:toInteger(end)}return baseSlice(array,start,end)}function sortedIndex(array,value){return baseSortedIndex(array,
value)}function sortedIndexBy(array,value,iteratee){return baseSortedIndexBy(array,value,getIteratee(iteratee,2))}function sortedIndexOf(array,value){var length=array==null?0:array.length;if(length){var index=baseSortedIndex(array,value);if(index<length&&eq(array[index],value))return index}return-1}function sortedLastIndex(array,value){return baseSortedIndex(array,value,true)}function sortedLastIndexBy(array,value,iteratee){return baseSortedIndexBy(array,value,getIteratee(iteratee,2),true)}function sortedLastIndexOf(array,
value){var length=array==null?0:array.length;if(length){var index=baseSortedIndex(array,value,true)-1;if(eq(array[index],value))return index}return-1}function sortedUniq(array){return array&&array.length?baseSortedUniq(array):[]}function sortedUniqBy(array,iteratee){return array&&array.length?baseSortedUniq(array,getIteratee(iteratee,2)):[]}function tail(array){var length=array==null?0:array.length;return length?baseSlice(array,1,length):[]}function take(array,n,guard){if(!(array&&array.length))return[];
n=guard||n===undefined?1:toInteger(n);return baseSlice(array,0,n<0?0:n)}function takeRight(array,n,guard){var length=array==null?0:array.length;if(!length)return[];n=guard||n===undefined?1:toInteger(n);n=length-n;return baseSlice(array,n<0?0:n,length)}function takeRightWhile(array,predicate){return array&&array.length?baseWhile(array,getIteratee(predicate,3),false,true):[]}function takeWhile(array,predicate){return array&&array.length?baseWhile(array,getIteratee(predicate,3)):[]}var union=baseRest(function(arrays){return baseUniq(baseFlatten(arrays,
1,isArrayLikeObject,true))});var unionBy=baseRest(function(arrays){var iteratee=last(arrays);if(isArrayLikeObject(iteratee))iteratee=undefined;return baseUniq(baseFlatten(arrays,1,isArrayLikeObject,true),getIteratee(iteratee,2))});var unionWith=baseRest(function(arrays){var comparator=last(arrays);comparator=typeof comparator=="function"?comparator:undefined;return baseUniq(baseFlatten(arrays,1,isArrayLikeObject,true),undefined,comparator)});function uniq(array){return array&&array.length?baseUniq(array):
[]}function uniqBy(array,iteratee){return array&&array.length?baseUniq(array,getIteratee(iteratee,2)):[]}function uniqWith(array,comparator){comparator=typeof comparator=="function"?comparator:undefined;return array&&array.length?baseUniq(array,undefined,comparator):[]}function unzip(array){if(!(array&&array.length))return[];var length=0;array=arrayFilter(array,function(group){if(isArrayLikeObject(group)){length=nativeMax(group.length,length);return true}});return baseTimes(length,function(index){return arrayMap(array,
baseProperty(index))})}function unzipWith(array,iteratee){if(!(array&&array.length))return[];var result=unzip(array);if(iteratee==null)return result;return arrayMap(result,function(group){return apply(iteratee,undefined,group)})}var without=baseRest(function(array,values){return isArrayLikeObject(array)?baseDifference(array,values):[]});var xor=baseRest(function(arrays){return baseXor(arrayFilter(arrays,isArrayLikeObject))});var xorBy=baseRest(function(arrays){var iteratee=last(arrays);if(isArrayLikeObject(iteratee))iteratee=
undefined;return baseXor(arrayFilter(arrays,isArrayLikeObject),getIteratee(iteratee,2))});var xorWith=baseRest(function(arrays){var comparator=last(arrays);comparator=typeof comparator=="function"?comparator:undefined;return baseXor(arrayFilter(arrays,isArrayLikeObject),undefined,comparator)});var zip=baseRest(unzip);function zipObject(props,values){return baseZipObject(props||[],values||[],assignValue)}function zipObjectDeep(props,values){return baseZipObject(props||[],values||[],baseSet)}var zipWith=
baseRest(function(arrays){var length=arrays.length,iteratee=length>1?arrays[length-1]:undefined;iteratee=typeof iteratee=="function"?(arrays.pop(),iteratee):undefined;return unzipWith(arrays,iteratee)});function chain(value){var result=lodash(value);result.__chain__=true;return result}function tap(value,interceptor){interceptor(value);return value}function thru(value,interceptor){return interceptor(value)}var wrapperAt=flatRest(function(paths){var length=paths.length,start=length?paths[0]:0,value=
this.__wrapped__,interceptor=function(object){return baseAt(object,paths)};if(length>1||this.__actions__.length||!(value instanceof LazyWrapper)||!isIndex(start))return this.thru(interceptor);value=value.slice(start,+start+(length?1:0));value.__actions__.push({"func":thru,"args":[interceptor],"thisArg":undefined});return(new LodashWrapper(value,this.__chain__)).thru(function(array){if(length&&!array.length)array.push(undefined);return array})});function wrapperChain(){return chain(this)}function wrapperCommit(){return new LodashWrapper(this.value(),
this.__chain__)}function wrapperNext(){if(this.__values__===undefined)this.__values__=toArray(this.value());var done=this.__index__>=this.__values__.length,value=done?undefined:this.__values__[this.__index__++];return{"done":done,"value":value}}function wrapperToIterator(){return this}function wrapperPlant(value){var result,parent=this;while(parent instanceof baseLodash){var clone=wrapperClone(parent);clone.__index__=0;clone.__values__=undefined;if(result)previous.__wrapped__=clone;else result=clone;
var previous=clone;parent=parent.__wrapped__}previous.__wrapped__=value;return result}function wrapperReverse(){var value=this.__wrapped__;if(value instanceof LazyWrapper){var wrapped=value;if(this.__actions__.length)wrapped=new LazyWrapper(this);wrapped=wrapped.reverse();wrapped.__actions__.push({"func":thru,"args":[reverse],"thisArg":undefined});return new LodashWrapper(wrapped,this.__chain__)}return this.thru(reverse)}function wrapperValue(){return baseWrapperValue(this.__wrapped__,this.__actions__)}
var countBy=createAggregator(function(result,value,key){if(hasOwnProperty.call(result,key))++result[key];else baseAssignValue(result,key,1)});function every(collection,predicate,guard){var func=isArray(collection)?arrayEvery:baseEvery;if(guard&&isIterateeCall(collection,predicate,guard))predicate=undefined;return func(collection,getIteratee(predicate,3))}function filter(collection,predicate){var func=isArray(collection)?arrayFilter:baseFilter;return func(collection,getIteratee(predicate,3))}var find=
createFind(findIndex);var findLast=createFind(findLastIndex);function flatMap(collection,iteratee){return baseFlatten(map(collection,iteratee),1)}function flatMapDeep(collection,iteratee){return baseFlatten(map(collection,iteratee),INFINITY)}function flatMapDepth(collection,iteratee,depth){depth=depth===undefined?1:toInteger(depth);return baseFlatten(map(collection,iteratee),depth)}function forEach(collection,iteratee){var func=isArray(collection)?arrayEach:baseEach;return func(collection,getIteratee(iteratee,
3))}function forEachRight(collection,iteratee){var func=isArray(collection)?arrayEachRight:baseEachRight;return func(collection,getIteratee(iteratee,3))}var groupBy=createAggregator(function(result,value,key){if(hasOwnProperty.call(result,key))result[key].push(value);else baseAssignValue(result,key,[value])});function includes(collection,value,fromIndex,guard){collection=isArrayLike(collection)?collection:values(collection);fromIndex=fromIndex&&!guard?toInteger(fromIndex):0;var length=collection.length;
if(fromIndex<0)fromIndex=nativeMax(length+fromIndex,0);return isString(collection)?fromIndex<=length&&collection.indexOf(value,fromIndex)>-1:!!length&&baseIndexOf(collection,value,fromIndex)>-1}var invokeMap=baseRest(function(collection,path,args){var index=-1,isFunc=typeof path=="function",result=isArrayLike(collection)?Array(collection.length):[];baseEach(collection,function(value){result[++index]=isFunc?apply(path,value,args):baseInvoke(value,path,args)});return result});var keyBy=createAggregator(function(result,
value,key){baseAssignValue(result,key,value)});function map(collection,iteratee){var func=isArray(collection)?arrayMap:baseMap;return func(collection,getIteratee(iteratee,3))}function orderBy(collection,iteratees,orders,guard){if(collection==null)return[];if(!isArray(iteratees))iteratees=iteratees==null?[]:[iteratees];orders=guard?undefined:orders;if(!isArray(orders))orders=orders==null?[]:[orders];return baseOrderBy(collection,iteratees,orders)}var partition=createAggregator(function(result,value,
key){result[key?0:1].push(value)},function(){return[[],[]]});function reduce(collection,iteratee,accumulator){var func=isArray(collection)?arrayReduce:baseReduce,initAccum=arguments.length<3;return func(collection,getIteratee(iteratee,4),accumulator,initAccum,baseEach)}function reduceRight(collection,iteratee,accumulator){var func=isArray(collection)?arrayReduceRight:baseReduce,initAccum=arguments.length<3;return func(collection,getIteratee(iteratee,4),accumulator,initAccum,baseEachRight)}function reject(collection,
predicate){var func=isArray(collection)?arrayFilter:baseFilter;return func(collection,negate(getIteratee(predicate,3)))}function sample(collection){var func=isArray(collection)?arraySample:baseSample;return func(collection)}function sampleSize(collection,n,guard){if(guard?isIterateeCall(collection,n,guard):n===undefined)n=1;else n=toInteger(n);var func=isArray(collection)?arraySampleSize:baseSampleSize;return func(collection,n)}function shuffle(collection){var func=isArray(collection)?arrayShuffle:
baseShuffle;return func(collection)}function size(collection){if(collection==null)return 0;if(isArrayLike(collection))return isString(collection)?stringSize(collection):collection.length;var tag=getTag(collection);if(tag==mapTag||tag==setTag)return collection.size;return baseKeys(collection).length}function some(collection,predicate,guard){var func=isArray(collection)?arraySome:baseSome;if(guard&&isIterateeCall(collection,predicate,guard))predicate=undefined;return func(collection,getIteratee(predicate,
3))}var sortBy=baseRest(function(collection,iteratees){if(collection==null)return[];var length=iteratees.length;if(length>1&&isIterateeCall(collection,iteratees[0],iteratees[1]))iteratees=[];else if(length>2&&isIterateeCall(iteratees[0],iteratees[1],iteratees[2]))iteratees=[iteratees[0]];return baseOrderBy(collection,baseFlatten(iteratees,1),[])});var now=ctxNow||function(){return root.Date.now()};function after(n,func){if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);n=toInteger(n);
return function(){if(--n<1)return func.apply(this,arguments)}}function ary(func,n,guard){n=guard?undefined:n;n=func&&n==null?func.length:n;return createWrap(func,WRAP_ARY_FLAG,undefined,undefined,undefined,undefined,n)}function before(n,func){var result;if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);n=toInteger(n);return function(){if(--n>0)result=func.apply(this,arguments);if(n<=1)func=undefined;return result}}var bind=baseRest(function(func,thisArg,partials){var bitmask=WRAP_BIND_FLAG;
if(partials.length){var holders=replaceHolders(partials,getHolder(bind));bitmask|=WRAP_PARTIAL_FLAG}return createWrap(func,bitmask,thisArg,partials,holders)});var bindKey=baseRest(function(object,key,partials){var bitmask=WRAP_BIND_FLAG|WRAP_BIND_KEY_FLAG;if(partials.length){var holders=replaceHolders(partials,getHolder(bindKey));bitmask|=WRAP_PARTIAL_FLAG}return createWrap(key,bitmask,object,partials,holders)});function curry(func,arity,guard){arity=guard?undefined:arity;var result=createWrap(func,
WRAP_CURRY_FLAG,undefined,undefined,undefined,undefined,undefined,arity);result.placeholder=curry.placeholder;return result}function curryRight(func,arity,guard){arity=guard?undefined:arity;var result=createWrap(func,WRAP_CURRY_RIGHT_FLAG,undefined,undefined,undefined,undefined,undefined,arity);result.placeholder=curryRight.placeholder;return result}function debounce(func,wait,options){var lastArgs,lastThis,maxWait,result,timerId,lastCallTime,lastInvokeTime=0,leading=false,maxing=false,trailing=true;
if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);wait=toNumber(wait)||0;if(isObject(options)){leading=!!options.leading;maxing="maxWait"in options;maxWait=maxing?nativeMax(toNumber(options.maxWait)||0,wait):maxWait;trailing="trailing"in options?!!options.trailing:trailing}function invokeFunc(time){var args=lastArgs,thisArg=lastThis;lastArgs=lastThis=undefined;lastInvokeTime=time;result=func.apply(thisArg,args);return result}function leadingEdge(time){lastInvokeTime=time;timerId=setTimeout(timerExpired,
wait);return leading?invokeFunc(time):result}function remainingWait(time){var timeSinceLastCall=time-lastCallTime,timeSinceLastInvoke=time-lastInvokeTime,timeWaiting=wait-timeSinceLastCall;return maxing?nativeMin(timeWaiting,maxWait-timeSinceLastInvoke):timeWaiting}function shouldInvoke(time){var timeSinceLastCall=time-lastCallTime,timeSinceLastInvoke=time-lastInvokeTime;return lastCallTime===undefined||timeSinceLastCall>=wait||timeSinceLastCall<0||maxing&&timeSinceLastInvoke>=maxWait}function timerExpired(){var time=
now();if(shouldInvoke(time))return trailingEdge(time);timerId=setTimeout(timerExpired,remainingWait(time))}function trailingEdge(time){timerId=undefined;if(trailing&&lastArgs)return invokeFunc(time);lastArgs=lastThis=undefined;return result}function cancel(){if(timerId!==undefined)clearTimeout(timerId);lastInvokeTime=0;lastArgs=lastCallTime=lastThis=timerId=undefined}function flush(){return timerId===undefined?result:trailingEdge(now())}function debounced(){var time=now(),isInvoking=shouldInvoke(time);
lastArgs=arguments;lastThis=this;lastCallTime=time;if(isInvoking){if(timerId===undefined)return leadingEdge(lastCallTime);if(maxing){timerId=setTimeout(timerExpired,wait);return invokeFunc(lastCallTime)}}if(timerId===undefined)timerId=setTimeout(timerExpired,wait);return result}debounced.cancel=cancel;debounced.flush=flush;return debounced}var defer=baseRest(function(func,args){return baseDelay(func,1,args)});var delay=baseRest(function(func,wait,args){return baseDelay(func,toNumber(wait)||0,args)});
function flip(func){return createWrap(func,WRAP_FLIP_FLAG)}function memoize(func,resolver){if(typeof func!="function"||resolver!=null&&typeof resolver!="function")throw new TypeError(FUNC_ERROR_TEXT);var memoized=function(){var args=arguments,key=resolver?resolver.apply(this,args):args[0],cache=memoized.cache;if(cache.has(key))return cache.get(key);var result=func.apply(this,args);memoized.cache=cache.set(key,result)||cache;return result};memoized.cache=new (memoize.Cache||MapCache);return memoized}
memoize.Cache=MapCache;function negate(predicate){if(typeof predicate!="function")throw new TypeError(FUNC_ERROR_TEXT);return function(){var args=arguments;switch(args.length){case 0:return!predicate.call(this);case 1:return!predicate.call(this,args[0]);case 2:return!predicate.call(this,args[0],args[1]);case 3:return!predicate.call(this,args[0],args[1],args[2])}return!predicate.apply(this,args)}}function once(func){return before(2,func)}var overArgs=castRest(function(func,transforms){transforms=transforms.length==
1&&isArray(transforms[0])?arrayMap(transforms[0],baseUnary(getIteratee())):arrayMap(baseFlatten(transforms,1),baseUnary(getIteratee()));var funcsLength=transforms.length;return baseRest(function(args){var index=-1,length=nativeMin(args.length,funcsLength);while(++index<length)args[index]=transforms[index].call(this,args[index]);return apply(func,this,args)})});var partial=baseRest(function(func,partials){var holders=replaceHolders(partials,getHolder(partial));return createWrap(func,WRAP_PARTIAL_FLAG,
undefined,partials,holders)});var partialRight=baseRest(function(func,partials){var holders=replaceHolders(partials,getHolder(partialRight));return createWrap(func,WRAP_PARTIAL_RIGHT_FLAG,undefined,partials,holders)});var rearg=flatRest(function(func,indexes){return createWrap(func,WRAP_REARG_FLAG,undefined,undefined,undefined,indexes)});function rest(func,start){if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);start=start===undefined?start:toInteger(start);return baseRest(func,start)}
function spread(func,start){if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);start=start==null?0:nativeMax(toInteger(start),0);return baseRest(function(args){var array=args[start],otherArgs=castSlice(args,0,start);if(array)arrayPush(otherArgs,array);return apply(func,this,otherArgs)})}function throttle(func,wait,options){var leading=true,trailing=true;if(typeof func!="function")throw new TypeError(FUNC_ERROR_TEXT);if(isObject(options)){leading="leading"in options?!!options.leading:
leading;trailing="trailing"in options?!!options.trailing:trailing}return debounce(func,wait,{"leading":leading,"maxWait":wait,"trailing":trailing})}function unary(func){return ary(func,1)}function wrap(value,wrapper){return partial(castFunction(wrapper),value)}function castArray(){if(!arguments.length)return[];var value=arguments[0];return isArray(value)?value:[value]}function clone(value){return baseClone(value,CLONE_SYMBOLS_FLAG)}function cloneWith(value,customizer){customizer=typeof customizer==
"function"?customizer:undefined;return baseClone(value,CLONE_SYMBOLS_FLAG,customizer)}function cloneDeep(value){return baseClone(value,CLONE_DEEP_FLAG|CLONE_SYMBOLS_FLAG)}function cloneDeepWith(value,customizer){customizer=typeof customizer=="function"?customizer:undefined;return baseClone(value,CLONE_DEEP_FLAG|CLONE_SYMBOLS_FLAG,customizer)}function conformsTo(object,source){return source==null||baseConformsTo(object,source,keys(source))}function eq(value,other){return value===other||value!==value&&
other!==other}var gt=createRelationalOperation(baseGt);var gte=createRelationalOperation(function(value,other){return value>=other});var isArguments=baseIsArguments(function(){return arguments}())?baseIsArguments:function(value){return isObjectLike(value)&&hasOwnProperty.call(value,"callee")&&!propertyIsEnumerable.call(value,"callee")};var isArray=Array.isArray;var isArrayBuffer=nodeIsArrayBuffer?baseUnary(nodeIsArrayBuffer):baseIsArrayBuffer;function isArrayLike(value){return value!=null&&isLength(value.length)&&
!isFunction(value)}function isArrayLikeObject(value){return isObjectLike(value)&&isArrayLike(value)}function isBoolean(value){return value===true||value===false||isObjectLike(value)&&baseGetTag(value)==boolTag}var isBuffer=nativeIsBuffer||stubFalse;var isDate=nodeIsDate?baseUnary(nodeIsDate):baseIsDate;function isElement(value){return isObjectLike(value)&&value.nodeType===1&&!isPlainObject(value)}function isEmpty(value){if(value==null)return true;if(isArrayLike(value)&&(isArray(value)||typeof value==
"string"||typeof value.splice=="function"||isBuffer(value)||isTypedArray(value)||isArguments(value)))return!value.length;var tag=getTag(value);if(tag==mapTag||tag==setTag)return!value.size;if(isPrototype(value))return!baseKeys(value).length;for(var key in value)if(hasOwnProperty.call(value,key))return false;return true}function isEqual(value,other){return baseIsEqual(value,other)}function isEqualWith(value,other,customizer){customizer=typeof customizer=="function"?customizer:undefined;var result=
customizer?customizer(value,other):undefined;return result===undefined?baseIsEqual(value,other,undefined,customizer):!!result}function isError(value){if(!isObjectLike(value))return false;var tag=baseGetTag(value);return tag==errorTag||tag==domExcTag||typeof value.message=="string"&&typeof value.name=="string"&&!isPlainObject(value)}function isFinite(value){return typeof value=="number"&&nativeIsFinite(value)}function isFunction(value){if(!isObject(value))return false;var tag=baseGetTag(value);return tag==
funcTag||tag==genTag||tag==asyncTag||tag==proxyTag}function isInteger(value){return typeof value=="number"&&value==toInteger(value)}function isLength(value){return typeof value=="number"&&value>-1&&value%1==0&&value<=MAX_SAFE_INTEGER}function isObject(value){var type=typeof value;return value!=null&&(type=="object"||type=="function")}function isObjectLike(value){return value!=null&&typeof value=="object"}var isMap=nodeIsMap?baseUnary(nodeIsMap):baseIsMap;function isMatch(object,source){return object===
source||baseIsMatch(object,source,getMatchData(source))}function isMatchWith(object,source,customizer){customizer=typeof customizer=="function"?customizer:undefined;return baseIsMatch(object,source,getMatchData(source),customizer)}function isNaN(value){return isNumber(value)&&value!=+value}function isNative(value){if(isMaskable(value))throw new Error(CORE_ERROR_TEXT);return baseIsNative(value)}function isNull(value){return value===null}function isNil(value){return value==null}function isNumber(value){return typeof value==
"number"||isObjectLike(value)&&baseGetTag(value)==numberTag}function isPlainObject(value){if(!isObjectLike(value)||baseGetTag(value)!=objectTag)return false;var proto=getPrototype(value);if(proto===null)return true;var Ctor=hasOwnProperty.call(proto,"constructor")&&proto.constructor;return typeof Ctor=="function"&&Ctor instanceof Ctor&&funcToString.call(Ctor)==objectCtorString}var isRegExp=nodeIsRegExp?baseUnary(nodeIsRegExp):baseIsRegExp;function isSafeInteger(value){return isInteger(value)&&value>=
-MAX_SAFE_INTEGER&&value<=MAX_SAFE_INTEGER}var isSet=nodeIsSet?baseUnary(nodeIsSet):baseIsSet;function isString(value){return typeof value=="string"||!isArray(value)&&isObjectLike(value)&&baseGetTag(value)==stringTag}function isSymbol(value){return typeof value=="symbol"||isObjectLike(value)&&baseGetTag(value)==symbolTag}var isTypedArray=nodeIsTypedArray?baseUnary(nodeIsTypedArray):baseIsTypedArray;function isUndefined(value){return value===undefined}function isWeakMap(value){return isObjectLike(value)&&
getTag(value)==weakMapTag}function isWeakSet(value){return isObjectLike(value)&&baseGetTag(value)==weakSetTag}var lt=createRelationalOperation(baseLt);var lte=createRelationalOperation(function(value,other){return value<=other});function toArray(value){if(!value)return[];if(isArrayLike(value))return isString(value)?stringToArray(value):copyArray(value);if(symIterator&&value[symIterator])return iteratorToArray(value[symIterator]());var tag=getTag(value),func=tag==mapTag?mapToArray:tag==setTag?setToArray:
values;return func(value)}function toFinite(value){if(!value)return value===0?value:0;value=toNumber(value);if(value===INFINITY||value===-INFINITY){var sign=value<0?-1:1;return sign*MAX_INTEGER}return value===value?value:0}function toInteger(value){var result=toFinite(value),remainder=result%1;return result===result?remainder?result-remainder:result:0}function toLength(value){return value?baseClamp(toInteger(value),0,MAX_ARRAY_LENGTH):0}function toNumber(value){if(typeof value=="number")return value;
if(isSymbol(value))return NAN;if(isObject(value)){var other=typeof value.valueOf=="function"?value.valueOf():value;value=isObject(other)?other+"":other}if(typeof value!="string")return value===0?value:+value;value=value.replace(reTrim,"");var isBinary=reIsBinary.test(value);return isBinary||reIsOctal.test(value)?freeParseInt(value.slice(2),isBinary?2:8):reIsBadHex.test(value)?NAN:+value}function toPlainObject(value){return copyObject(value,keysIn(value))}function toSafeInteger(value){return value?
baseClamp(toInteger(value),-MAX_SAFE_INTEGER,MAX_SAFE_INTEGER):value===0?value:0}function toString(value){return value==null?"":baseToString(value)}var assign=createAssigner(function(object,source){if(isPrototype(source)||isArrayLike(source)){copyObject(source,keys(source),object);return}for(var key in source)if(hasOwnProperty.call(source,key))assignValue(object,key,source[key])});var assignIn=createAssigner(function(object,source){copyObject(source,keysIn(source),object)});var assignInWith=createAssigner(function(object,
source,srcIndex,customizer){copyObject(source,keysIn(source),object,customizer)});var assignWith=createAssigner(function(object,source,srcIndex,customizer){copyObject(source,keys(source),object,customizer)});var at=flatRest(baseAt);function create(prototype,properties){var result=baseCreate(prototype);return properties==null?result:baseAssign(result,properties)}var defaults=baseRest(function(object,sources){object=Object(object);var index=-1;var length=sources.length;var guard=length>2?sources[2]:
undefined;if(guard&&isIterateeCall(sources[0],sources[1],guard))length=1;while(++index<length){var source=sources[index];var props=keysIn(source);var propsIndex=-1;var propsLength=props.length;while(++propsIndex<propsLength){var key=props[propsIndex];var value=object[key];if(value===undefined||eq(value,objectProto[key])&&!hasOwnProperty.call(object,key))object[key]=source[key]}}return object});var defaultsDeep=baseRest(function(args){args.push(undefined,customDefaultsMerge);return apply(mergeWith,
undefined,args)});function findKey(object,predicate){return baseFindKey(object,getIteratee(predicate,3),baseForOwn)}function findLastKey(object,predicate){return baseFindKey(object,getIteratee(predicate,3),baseForOwnRight)}function forIn(object,iteratee){return object==null?object:baseFor(object,getIteratee(iteratee,3),keysIn)}function forInRight(object,iteratee){return object==null?object:baseForRight(object,getIteratee(iteratee,3),keysIn)}function forOwn(object,iteratee){return object&&baseForOwn(object,
getIteratee(iteratee,3))}function forOwnRight(object,iteratee){return object&&baseForOwnRight(object,getIteratee(iteratee,3))}function functions(object){return object==null?[]:baseFunctions(object,keys(object))}function functionsIn(object){return object==null?[]:baseFunctions(object,keysIn(object))}function get(object,path,defaultValue){var result=object==null?undefined:baseGet(object,path);return result===undefined?defaultValue:result}function has(object,path){return object!=null&&hasPath(object,
path,baseHas)}function hasIn(object,path){return object!=null&&hasPath(object,path,baseHasIn)}var invert=createInverter(function(result,value,key){if(value!=null&&typeof value.toString!="function")value=nativeObjectToString.call(value);result[value]=key},constant(identity));var invertBy=createInverter(function(result,value,key){if(value!=null&&typeof value.toString!="function")value=nativeObjectToString.call(value);if(hasOwnProperty.call(result,value))result[value].push(key);else result[value]=[key]},
getIteratee);var invoke=baseRest(baseInvoke);function keys(object){return isArrayLike(object)?arrayLikeKeys(object):baseKeys(object)}function keysIn(object){return isArrayLike(object)?arrayLikeKeys(object,true):baseKeysIn(object)}function mapKeys(object,iteratee){var result={};iteratee=getIteratee(iteratee,3);baseForOwn(object,function(value,key,object){baseAssignValue(result,iteratee(value,key,object),value)});return result}function mapValues(object,iteratee){var result={};iteratee=getIteratee(iteratee,
3);baseForOwn(object,function(value,key,object){baseAssignValue(result,key,iteratee(value,key,object))});return result}var merge=createAssigner(function(object,source,srcIndex){baseMerge(object,source,srcIndex)});var mergeWith=createAssigner(function(object,source,srcIndex,customizer){baseMerge(object,source,srcIndex,customizer)});var omit=flatRest(function(object,paths){var result={};if(object==null)return result;var isDeep=false;paths=arrayMap(paths,function(path){path=castPath(path,object);isDeep||
(isDeep=path.length>1);return path});copyObject(object,getAllKeysIn(object),result);if(isDeep)result=baseClone(result,CLONE_DEEP_FLAG|CLONE_FLAT_FLAG|CLONE_SYMBOLS_FLAG,customOmitClone);var length=paths.length;while(length--)baseUnset(result,paths[length]);return result});function omitBy(object,predicate){return pickBy(object,negate(getIteratee(predicate)))}var pick=flatRest(function(object,paths){return object==null?{}:basePick(object,paths)});function pickBy(object,predicate){if(object==null)return{};
var props=arrayMap(getAllKeysIn(object),function(prop){return[prop]});predicate=getIteratee(predicate);return basePickBy(object,props,function(value,path){return predicate(value,path[0])})}function result(object,path,defaultValue){path=castPath(path,object);var index=-1,length=path.length;if(!length){length=1;object=undefined}while(++index<length){var value=object==null?undefined:object[toKey(path[index])];if(value===undefined){index=length;value=defaultValue}object=isFunction(value)?value.call(object):
value}return object}function set(object,path,value){return object==null?object:baseSet(object,path,value)}function setWith(object,path,value,customizer){customizer=typeof customizer=="function"?customizer:undefined;return object==null?object:baseSet(object,path,value,customizer)}var toPairs=createToPairs(keys);var toPairsIn=createToPairs(keysIn);function transform(object,iteratee,accumulator){var isArr=isArray(object),isArrLike=isArr||isBuffer(object)||isTypedArray(object);iteratee=getIteratee(iteratee,
4);if(accumulator==null){var Ctor=object&&object.constructor;if(isArrLike)accumulator=isArr?new Ctor:[];else if(isObject(object))accumulator=isFunction(Ctor)?baseCreate(getPrototype(object)):{};else accumulator={}}(isArrLike?arrayEach:baseForOwn)(object,function(value,index,object){return iteratee(accumulator,value,index,object)});return accumulator}function unset(object,path){return object==null?true:baseUnset(object,path)}function update(object,path,updater){return object==null?object:baseUpdate(object,
path,castFunction(updater))}function updateWith(object,path,updater,customizer){customizer=typeof customizer=="function"?customizer:undefined;return object==null?object:baseUpdate(object,path,castFunction(updater),customizer)}function values(object){return object==null?[]:baseValues(object,keys(object))}function valuesIn(object){return object==null?[]:baseValues(object,keysIn(object))}function clamp(number,lower,upper){if(upper===undefined){upper=lower;lower=undefined}if(upper!==undefined){upper=
toNumber(upper);upper=upper===upper?upper:0}if(lower!==undefined){lower=toNumber(lower);lower=lower===lower?lower:0}return baseClamp(toNumber(number),lower,upper)}function inRange(number,start,end){start=toFinite(start);if(end===undefined){end=start;start=0}else end=toFinite(end);number=toNumber(number);return baseInRange(number,start,end)}function random(lower,upper,floating){if(floating&&typeof floating!="boolean"&&isIterateeCall(lower,upper,floating))upper=floating=undefined;if(floating===undefined)if(typeof upper==
"boolean"){floating=upper;upper=undefined}else if(typeof lower=="boolean"){floating=lower;lower=undefined}if(lower===undefined&&upper===undefined){lower=0;upper=1}else{lower=toFinite(lower);if(upper===undefined){upper=lower;lower=0}else upper=toFinite(upper)}if(lower>upper){var temp=lower;lower=upper;upper=temp}if(floating||lower%1||upper%1){var rand=nativeRandom();return nativeMin(lower+rand*(upper-lower+freeParseFloat("1e-"+((rand+"").length-1))),upper)}return baseRandom(lower,upper)}var camelCase=
createCompounder(function(result,word,index){word=word.toLowerCase();return result+(index?capitalize(word):word)});function capitalize(string){return upperFirst(toString(string).toLowerCase())}function deburr(string){string=toString(string);return string&&string.replace(reLatin,deburrLetter).replace(reComboMark,"")}function endsWith(string,target,position){string=toString(string);target=baseToString(target);var length=string.length;position=position===undefined?length:baseClamp(toInteger(position),
0,length);var end=position;position-=target.length;return position>=0&&string.slice(position,end)==target}function escape(string){string=toString(string);return string&&reHasUnescapedHtml.test(string)?string.replace(reUnescapedHtml,escapeHtmlChar):string}function escapeRegExp(string){string=toString(string);return string&&reHasRegExpChar.test(string)?string.replace(reRegExpChar,"\\$\x26"):string}var kebabCase=createCompounder(function(result,word,index){return result+(index?"-":"")+word.toLowerCase()});
var lowerCase=createCompounder(function(result,word,index){return result+(index?" ":"")+word.toLowerCase()});var lowerFirst=createCaseFirst("toLowerCase");function pad(string,length,chars){string=toString(string);length=toInteger(length);var strLength=length?stringSize(string):0;if(!length||strLength>=length)return string;var mid=(length-strLength)/2;return createPadding(nativeFloor(mid),chars)+string+createPadding(nativeCeil(mid),chars)}function padEnd(string,length,chars){string=toString(string);
length=toInteger(length);var strLength=length?stringSize(string):0;return length&&strLength<length?string+createPadding(length-strLength,chars):string}function padStart(string,length,chars){string=toString(string);length=toInteger(length);var strLength=length?stringSize(string):0;return length&&strLength<length?createPadding(length-strLength,chars)+string:string}function parseInt(string,radix,guard){if(guard||radix==null)radix=0;else if(radix)radix=+radix;return nativeParseInt(toString(string).replace(reTrimStart,
""),radix||0)}function repeat(string,n,guard){if(guard?isIterateeCall(string,n,guard):n===undefined)n=1;else n=toInteger(n);return baseRepeat(toString(string),n)}function replace(){var args=arguments,string=toString(args[0]);return args.length<3?string:string.replace(args[1],args[2])}var snakeCase=createCompounder(function(result,word,index){return result+(index?"_":"")+word.toLowerCase()});function split(string,separator,limit){if(limit&&typeof limit!="number"&&isIterateeCall(string,separator,limit))separator=
limit=undefined;limit=limit===undefined?MAX_ARRAY_LENGTH:limit>>>0;if(!limit)return[];string=toString(string);if(string&&(typeof separator=="string"||separator!=null&&!isRegExp(separator))){separator=baseToString(separator);if(!separator&&hasUnicode(string))return castSlice(stringToArray(string),0,limit)}return string.split(separator,limit)}var startCase=createCompounder(function(result,word,index){return result+(index?" ":"")+upperFirst(word)});function startsWith(string,target,position){string=
toString(string);position=position==null?0:baseClamp(toInteger(position),0,string.length);target=baseToString(target);return string.slice(position,position+target.length)==target}function template(string,options,guard){var settings=lodash.templateSettings;if(guard&&isIterateeCall(string,options,guard))options=undefined;string=toString(string);options=assignInWith({},options,settings,customDefaultsAssignIn);var imports=assignInWith({},options.imports,settings.imports,customDefaultsAssignIn),importsKeys=
keys(imports),importsValues=baseValues(imports,importsKeys);var isEscaping,isEvaluating,index=0,interpolate=options.interpolate||reNoMatch,source="__p +\x3d '";var reDelimiters=RegExp((options.escape||reNoMatch).source+"|"+interpolate.source+"|"+(interpolate===reInterpolate?reEsTemplate:reNoMatch).source+"|"+(options.evaluate||reNoMatch).source+"|$","g");var sourceURL="//# sourceURL\x3d"+("sourceURL"in options?options.sourceURL:"lodash.templateSources["+ ++templateCounter+"]")+"\n";string.replace(reDelimiters,
function(match,escapeValue,interpolateValue,esTemplateValue,evaluateValue,offset){interpolateValue||(interpolateValue=esTemplateValue);source+=string.slice(index,offset).replace(reUnescapedString,escapeStringChar);if(escapeValue){isEscaping=true;source+="' +\n__e("+escapeValue+") +\n'"}if(evaluateValue){isEvaluating=true;source+="';\n"+evaluateValue+";\n__p +\x3d '"}if(interpolateValue)source+="' +\n((__t \x3d ("+interpolateValue+")) \x3d\x3d null ? '' : __t) +\n'";index=offset+match.length;return match});
source+="';\n";var variable=options.variable;if(!variable)source="with (obj) {\n"+source+"\n}\n";source=(isEvaluating?source.replace(reEmptyStringLeading,""):source).replace(reEmptyStringMiddle,"$1").replace(reEmptyStringTrailing,"$1;");source="function("+(variable||"obj")+") {\n"+(variable?"":"obj || (obj \x3d {});\n")+"var __t, __p \x3d ''"+(isEscaping?", __e \x3d _.escape":"")+(isEvaluating?", __j \x3d Array.prototype.join;\n"+"function print() { __p +\x3d __j.call(arguments, '') }\n":";\n")+source+
"return __p\n}";var result=attempt(function(){return Function(importsKeys,sourceURL+"return "+source).apply(undefined,importsValues)});result.source=source;if(isError(result))throw result;return result}function toLower(value){return toString(value).toLowerCase()}function toUpper(value){return toString(value).toUpperCase()}function trim(string,chars,guard){string=toString(string);if(string&&(guard||chars===undefined))return string.replace(reTrim,"");if(!string||!(chars=baseToString(chars)))return string;
var strSymbols=stringToArray(string),chrSymbols=stringToArray(chars),start=charsStartIndex(strSymbols,chrSymbols),end=charsEndIndex(strSymbols,chrSymbols)+1;return castSlice(strSymbols,start,end).join("")}function trimEnd(string,chars,guard){string=toString(string);if(string&&(guard||chars===undefined))return string.replace(reTrimEnd,"");if(!string||!(chars=baseToString(chars)))return string;var strSymbols=stringToArray(string),end=charsEndIndex(strSymbols,stringToArray(chars))+1;return castSlice(strSymbols,
0,end).join("")}function trimStart(string,chars,guard){string=toString(string);if(string&&(guard||chars===undefined))return string.replace(reTrimStart,"");if(!string||!(chars=baseToString(chars)))return string;var strSymbols=stringToArray(string),start=charsStartIndex(strSymbols,stringToArray(chars));return castSlice(strSymbols,start).join("")}function truncate(string,options){var length=DEFAULT_TRUNC_LENGTH,omission=DEFAULT_TRUNC_OMISSION;if(isObject(options)){var separator="separator"in options?
options.separator:separator;length="length"in options?toInteger(options.length):length;omission="omission"in options?baseToString(options.omission):omission}string=toString(string);var strLength=string.length;if(hasUnicode(string)){var strSymbols=stringToArray(string);strLength=strSymbols.length}if(length>=strLength)return string;var end=length-stringSize(omission);if(end<1)return omission;var result=strSymbols?castSlice(strSymbols,0,end).join(""):string.slice(0,end);if(separator===undefined)return result+
omission;if(strSymbols)end+=result.length-end;if(isRegExp(separator)){if(string.slice(end).search(separator)){var match,substring=result;if(!separator.global)separator=RegExp(separator.source,toString(reFlags.exec(separator))+"g");separator.lastIndex=0;while(match=separator.exec(substring))var newEnd=match.index;result=result.slice(0,newEnd===undefined?end:newEnd)}}else if(string.indexOf(baseToString(separator),end)!=end){var index=result.lastIndexOf(separator);if(index>-1)result=result.slice(0,index)}return result+
omission}function unescape(string){string=toString(string);return string&&reHasEscapedHtml.test(string)?string.replace(reEscapedHtml,unescapeHtmlChar):string}var upperCase=createCompounder(function(result,word,index){return result+(index?" ":"")+word.toUpperCase()});var upperFirst=createCaseFirst("toUpperCase");function words(string,pattern,guard){string=toString(string);pattern=guard?undefined:pattern;if(pattern===undefined)return hasUnicodeWord(string)?unicodeWords(string):asciiWords(string);return string.match(pattern)||
[]}var attempt=baseRest(function(func,args){try{return apply(func,undefined,args)}catch(e){return isError(e)?e:new Error(e)}});var bindAll=flatRest(function(object,methodNames){arrayEach(methodNames,function(key){key=toKey(key);baseAssignValue(object,key,bind(object[key],object))});return object});function cond(pairs){var length=pairs==null?0:pairs.length,toIteratee=getIteratee();pairs=!length?[]:arrayMap(pairs,function(pair){if(typeof pair[1]!="function")throw new TypeError(FUNC_ERROR_TEXT);return[toIteratee(pair[0]),
pair[1]]});return baseRest(function(args){var index=-1;while(++index<length){var pair=pairs[index];if(apply(pair[0],this,args))return apply(pair[1],this,args)}})}function conforms(source){return baseConforms(baseClone(source,CLONE_DEEP_FLAG))}function constant(value){return function(){return value}}function defaultTo(value,defaultValue){return value==null||value!==value?defaultValue:value}var flow=createFlow();var flowRight=createFlow(true);function identity(value){return value}function iteratee(func){return baseIteratee(typeof func==
"function"?func:baseClone(func,CLONE_DEEP_FLAG))}function matches(source){return baseMatches(baseClone(source,CLONE_DEEP_FLAG))}function matchesProperty(path,srcValue){return baseMatchesProperty(path,baseClone(srcValue,CLONE_DEEP_FLAG))}var method=baseRest(function(path,args){return function(object){return baseInvoke(object,path,args)}});var methodOf=baseRest(function(object,args){return function(path){return baseInvoke(object,path,args)}});function mixin(object,source,options){var props=keys(source),
methodNames=baseFunctions(source,props);if(options==null&&!(isObject(source)&&(methodNames.length||!props.length))){options=source;source=object;object=this;methodNames=baseFunctions(source,keys(source))}var chain=!(isObject(options)&&"chain"in options)||!!options.chain,isFunc=isFunction(object);arrayEach(methodNames,function(methodName){var func=source[methodName];object[methodName]=func;if(isFunc)object.prototype[methodName]=function(){var chainAll=this.__chain__;if(chain||chainAll){var result=
object(this.__wrapped__),actions=result.__actions__=copyArray(this.__actions__);actions.push({"func":func,"args":arguments,"thisArg":object});result.__chain__=chainAll;return result}return func.apply(object,arrayPush([this.value()],arguments))}});return object}function noConflict(){if(root._===this)root._=oldDash;return this}function noop(){}function nthArg(n){n=toInteger(n);return baseRest(function(args){return baseNth(args,n)})}var over=createOver(arrayMap);var overEvery=createOver(arrayEvery);
var overSome=createOver(arraySome);function property(path){return isKey(path)?baseProperty(toKey(path)):basePropertyDeep(path)}function propertyOf(object){return function(path){return object==null?undefined:baseGet(object,path)}}var range=createRange();var rangeRight=createRange(true);function stubArray(){return[]}function stubFalse(){return false}function stubObject(){return{}}function stubString(){return""}function stubTrue(){return true}function times(n,iteratee){n=toInteger(n);if(n<1||n>MAX_SAFE_INTEGER)return[];
var index=MAX_ARRAY_LENGTH,length=nativeMin(n,MAX_ARRAY_LENGTH);iteratee=getIteratee(iteratee);n-=MAX_ARRAY_LENGTH;var result=baseTimes(length,iteratee);while(++index<n)iteratee(index);return result}function toPath(value){if(isArray(value))return arrayMap(value,toKey);return isSymbol(value)?[value]:copyArray(stringToPath(toString(value)))}function uniqueId(prefix){var id=++idCounter;return toString(prefix)+id}var add=createMathOperation(function(augend,addend){return augend+addend},0);var ceil=createRound("ceil");
var divide=createMathOperation(function(dividend,divisor){return dividend/divisor},1);var floor=createRound("floor");function max(array){return array&&array.length?baseExtremum(array,identity,baseGt):undefined}function maxBy(array,iteratee){return array&&array.length?baseExtremum(array,getIteratee(iteratee,2),baseGt):undefined}function mean(array){return baseMean(array,identity)}function meanBy(array,iteratee){return baseMean(array,getIteratee(iteratee,2))}function min(array){return array&&array.length?
baseExtremum(array,identity,baseLt):undefined}function minBy(array,iteratee){return array&&array.length?baseExtremum(array,getIteratee(iteratee,2),baseLt):undefined}var multiply=createMathOperation(function(multiplier,multiplicand){return multiplier*multiplicand},1);var round=createRound("round");var subtract=createMathOperation(function(minuend,subtrahend){return minuend-subtrahend},0);function sum(array){return array&&array.length?baseSum(array,identity):0}function sumBy(array,iteratee){return array&&
array.length?baseSum(array,getIteratee(iteratee,2)):0}lodash.after=after;lodash.ary=ary;lodash.assign=assign;lodash.assignIn=assignIn;lodash.assignInWith=assignInWith;lodash.assignWith=assignWith;lodash.at=at;lodash.before=before;lodash.bind=bind;lodash.bindAll=bindAll;lodash.bindKey=bindKey;lodash.castArray=castArray;lodash.chain=chain;lodash.chunk=chunk;lodash.compact=compact;lodash.concat=concat;lodash.cond=cond;lodash.conforms=conforms;lodash.constant=constant;lodash.countBy=countBy;lodash.create=
create;lodash.curry=curry;lodash.curryRight=curryRight;lodash.debounce=debounce;lodash.defaults=defaults;lodash.defaultsDeep=defaultsDeep;lodash.defer=defer;lodash.delay=delay;lodash.difference=difference;lodash.differenceBy=differenceBy;lodash.differenceWith=differenceWith;lodash.drop=drop;lodash.dropRight=dropRight;lodash.dropRightWhile=dropRightWhile;lodash.dropWhile=dropWhile;lodash.fill=fill;lodash.filter=filter;lodash.flatMap=flatMap;lodash.flatMapDeep=flatMapDeep;lodash.flatMapDepth=flatMapDepth;
lodash.flatten=flatten;lodash.flattenDeep=flattenDeep;lodash.flattenDepth=flattenDepth;lodash.flip=flip;lodash.flow=flow;lodash.flowRight=flowRight;lodash.fromPairs=fromPairs;lodash.functions=functions;lodash.functionsIn=functionsIn;lodash.groupBy=groupBy;lodash.initial=initial;lodash.intersection=intersection;lodash.intersectionBy=intersectionBy;lodash.intersectionWith=intersectionWith;lodash.invert=invert;lodash.invertBy=invertBy;lodash.invokeMap=invokeMap;lodash.iteratee=iteratee;lodash.keyBy=
keyBy;lodash.keys=keys;lodash.keysIn=keysIn;lodash.map=map;lodash.mapKeys=mapKeys;lodash.mapValues=mapValues;lodash.matches=matches;lodash.matchesProperty=matchesProperty;lodash.memoize=memoize;lodash.merge=merge;lodash.mergeWith=mergeWith;lodash.method=method;lodash.methodOf=methodOf;lodash.mixin=mixin;lodash.negate=negate;lodash.nthArg=nthArg;lodash.omit=omit;lodash.omitBy=omitBy;lodash.once=once;lodash.orderBy=orderBy;lodash.over=over;lodash.overArgs=overArgs;lodash.overEvery=overEvery;lodash.overSome=
overSome;lodash.partial=partial;lodash.partialRight=partialRight;lodash.partition=partition;lodash.pick=pick;lodash.pickBy=pickBy;lodash.property=property;lodash.propertyOf=propertyOf;lodash.pull=pull;lodash.pullAll=pullAll;lodash.pullAllBy=pullAllBy;lodash.pullAllWith=pullAllWith;lodash.pullAt=pullAt;lodash.range=range;lodash.rangeRight=rangeRight;lodash.rearg=rearg;lodash.reject=reject;lodash.remove=remove;lodash.rest=rest;lodash.reverse=reverse;lodash.sampleSize=sampleSize;lodash.set=set;lodash.setWith=
setWith;lodash.shuffle=shuffle;lodash.slice=slice;lodash.sortBy=sortBy;lodash.sortedUniq=sortedUniq;lodash.sortedUniqBy=sortedUniqBy;lodash.split=split;lodash.spread=spread;lodash.tail=tail;lodash.take=take;lodash.takeRight=takeRight;lodash.takeRightWhile=takeRightWhile;lodash.takeWhile=takeWhile;lodash.tap=tap;lodash.throttle=throttle;lodash.thru=thru;lodash.toArray=toArray;lodash.toPairs=toPairs;lodash.toPairsIn=toPairsIn;lodash.toPath=toPath;lodash.toPlainObject=toPlainObject;lodash.transform=
transform;lodash.unary=unary;lodash.union=union;lodash.unionBy=unionBy;lodash.unionWith=unionWith;lodash.uniq=uniq;lodash.uniqBy=uniqBy;lodash.uniqWith=uniqWith;lodash.unset=unset;lodash.unzip=unzip;lodash.unzipWith=unzipWith;lodash.update=update;lodash.updateWith=updateWith;lodash.values=values;lodash.valuesIn=valuesIn;lodash.without=without;lodash.words=words;lodash.wrap=wrap;lodash.xor=xor;lodash.xorBy=xorBy;lodash.xorWith=xorWith;lodash.zip=zip;lodash.zipObject=zipObject;lodash.zipObjectDeep=
zipObjectDeep;lodash.zipWith=zipWith;lodash.entries=toPairs;lodash.entriesIn=toPairsIn;lodash.extend=assignIn;lodash.extendWith=assignInWith;mixin(lodash,lodash);lodash.add=add;lodash.attempt=attempt;lodash.camelCase=camelCase;lodash.capitalize=capitalize;lodash.ceil=ceil;lodash.clamp=clamp;lodash.clone=clone;lodash.cloneDeep=cloneDeep;lodash.cloneDeepWith=cloneDeepWith;lodash.cloneWith=cloneWith;lodash.conformsTo=conformsTo;lodash.deburr=deburr;lodash.defaultTo=defaultTo;lodash.divide=divide;lodash.endsWith=
endsWith;lodash.eq=eq;lodash.escape=escape;lodash.escapeRegExp=escapeRegExp;lodash.every=every;lodash.find=find;lodash.findIndex=findIndex;lodash.findKey=findKey;lodash.findLast=findLast;lodash.findLastIndex=findLastIndex;lodash.findLastKey=findLastKey;lodash.floor=floor;lodash.forEach=forEach;lodash.forEachRight=forEachRight;lodash.forIn=forIn;lodash.forInRight=forInRight;lodash.forOwn=forOwn;lodash.forOwnRight=forOwnRight;lodash.get=get;lodash.gt=gt;lodash.gte=gte;lodash.has=has;lodash.hasIn=hasIn;
lodash.head=head;lodash.identity=identity;lodash.includes=includes;lodash.indexOf=indexOf;lodash.inRange=inRange;lodash.invoke=invoke;lodash.isArguments=isArguments;lodash.isArray=isArray;lodash.isArrayBuffer=isArrayBuffer;lodash.isArrayLike=isArrayLike;lodash.isArrayLikeObject=isArrayLikeObject;lodash.isBoolean=isBoolean;lodash.isBuffer=isBuffer;lodash.isDate=isDate;lodash.isElement=isElement;lodash.isEmpty=isEmpty;lodash.isEqual=isEqual;lodash.isEqualWith=isEqualWith;lodash.isError=isError;lodash.isFinite=
isFinite;lodash.isFunction=isFunction;lodash.isInteger=isInteger;lodash.isLength=isLength;lodash.isMap=isMap;lodash.isMatch=isMatch;lodash.isMatchWith=isMatchWith;lodash.isNaN=isNaN;lodash.isNative=isNative;lodash.isNil=isNil;lodash.isNull=isNull;lodash.isNumber=isNumber;lodash.isObject=isObject;lodash.isObjectLike=isObjectLike;lodash.isPlainObject=isPlainObject;lodash.isRegExp=isRegExp;lodash.isSafeInteger=isSafeInteger;lodash.isSet=isSet;lodash.isString=isString;lodash.isSymbol=isSymbol;lodash.isTypedArray=
isTypedArray;lodash.isUndefined=isUndefined;lodash.isWeakMap=isWeakMap;lodash.isWeakSet=isWeakSet;lodash.join=join;lodash.kebabCase=kebabCase;lodash.last=last;lodash.lastIndexOf=lastIndexOf;lodash.lowerCase=lowerCase;lodash.lowerFirst=lowerFirst;lodash.lt=lt;lodash.lte=lte;lodash.max=max;lodash.maxBy=maxBy;lodash.mean=mean;lodash.meanBy=meanBy;lodash.min=min;lodash.minBy=minBy;lodash.stubArray=stubArray;lodash.stubFalse=stubFalse;lodash.stubObject=stubObject;lodash.stubString=stubString;lodash.stubTrue=
stubTrue;lodash.multiply=multiply;lodash.nth=nth;lodash.noConflict=noConflict;lodash.noop=noop;lodash.now=now;lodash.pad=pad;lodash.padEnd=padEnd;lodash.padStart=padStart;lodash.parseInt=parseInt;lodash.random=random;lodash.reduce=reduce;lodash.reduceRight=reduceRight;lodash.repeat=repeat;lodash.replace=replace;lodash.result=result;lodash.round=round;lodash.runInContext=runInContext;lodash.sample=sample;lodash.size=size;lodash.snakeCase=snakeCase;lodash.some=some;lodash.sortedIndex=sortedIndex;lodash.sortedIndexBy=
sortedIndexBy;lodash.sortedIndexOf=sortedIndexOf;lodash.sortedLastIndex=sortedLastIndex;lodash.sortedLastIndexBy=sortedLastIndexBy;lodash.sortedLastIndexOf=sortedLastIndexOf;lodash.startCase=startCase;lodash.startsWith=startsWith;lodash.subtract=subtract;lodash.sum=sum;lodash.sumBy=sumBy;lodash.template=template;lodash.times=times;lodash.toFinite=toFinite;lodash.toInteger=toInteger;lodash.toLength=toLength;lodash.toLower=toLower;lodash.toNumber=toNumber;lodash.toSafeInteger=toSafeInteger;lodash.toString=
toString;lodash.toUpper=toUpper;lodash.trim=trim;lodash.trimEnd=trimEnd;lodash.trimStart=trimStart;lodash.truncate=truncate;lodash.unescape=unescape;lodash.uniqueId=uniqueId;lodash.upperCase=upperCase;lodash.upperFirst=upperFirst;lodash.each=forEach;lodash.eachRight=forEachRight;lodash.first=head;mixin(lodash,function(){var source={};baseForOwn(lodash,function(func,methodName){if(!hasOwnProperty.call(lodash.prototype,methodName))source[methodName]=func});return source}(),{"chain":false});lodash.VERSION=
VERSION;arrayEach(["bind","bindKey","curry","curryRight","partial","partialRight"],function(methodName){lodash[methodName].placeholder=lodash});arrayEach(["drop","take"],function(methodName,index){LazyWrapper.prototype[methodName]=function(n){n=n===undefined?1:nativeMax(toInteger(n),0);var result=this.__filtered__&&!index?new LazyWrapper(this):this.clone();if(result.__filtered__)result.__takeCount__=nativeMin(n,result.__takeCount__);else result.__views__.push({"size":nativeMin(n,MAX_ARRAY_LENGTH),
"type":methodName+(result.__dir__<0?"Right":"")});return result};LazyWrapper.prototype[methodName+"Right"]=function(n){return this.reverse()[methodName](n).reverse()}});arrayEach(["filter","map","takeWhile"],function(methodName,index){var type=index+1,isFilter=type==LAZY_FILTER_FLAG||type==LAZY_WHILE_FLAG;LazyWrapper.prototype[methodName]=function(iteratee){var result=this.clone();result.__iteratees__.push({"iteratee":getIteratee(iteratee,3),"type":type});result.__filtered__=result.__filtered__||
isFilter;return result}});arrayEach(["head","last"],function(methodName,index){var takeName="take"+(index?"Right":"");LazyWrapper.prototype[methodName]=function(){return this[takeName](1).value()[0]}});arrayEach(["initial","tail"],function(methodName,index){var dropName="drop"+(index?"":"Right");LazyWrapper.prototype[methodName]=function(){return this.__filtered__?new LazyWrapper(this):this[dropName](1)}});LazyWrapper.prototype.compact=function(){return this.filter(identity)};LazyWrapper.prototype.find=
function(predicate){return this.filter(predicate).head()};LazyWrapper.prototype.findLast=function(predicate){return this.reverse().find(predicate)};LazyWrapper.prototype.invokeMap=baseRest(function(path,args){if(typeof path=="function")return new LazyWrapper(this);return this.map(function(value){return baseInvoke(value,path,args)})});LazyWrapper.prototype.reject=function(predicate){return this.filter(negate(getIteratee(predicate)))};LazyWrapper.prototype.slice=function(start,end){start=toInteger(start);
var result=this;if(result.__filtered__&&(start>0||end<0))return new LazyWrapper(result);if(start<0)result=result.takeRight(-start);else if(start)result=result.drop(start);if(end!==undefined){end=toInteger(end);result=end<0?result.dropRight(-end):result.take(end-start)}return result};LazyWrapper.prototype.takeRightWhile=function(predicate){return this.reverse().takeWhile(predicate).reverse()};LazyWrapper.prototype.toArray=function(){return this.take(MAX_ARRAY_LENGTH)};baseForOwn(LazyWrapper.prototype,
function(func,methodName){var checkIteratee=/^(?:filter|find|map|reject)|While$/.test(methodName),isTaker=/^(?:head|last)$/.test(methodName),lodashFunc=lodash[isTaker?"take"+(methodName=="last"?"Right":""):methodName],retUnwrapped=isTaker||/^find/.test(methodName);if(!lodashFunc)return;lodash.prototype[methodName]=function(){var value=this.__wrapped__,args=isTaker?[1]:arguments,isLazy=value instanceof LazyWrapper,iteratee=args[0],useLazy=isLazy||isArray(value);var interceptor=function(value){var result=
lodashFunc.apply(lodash,arrayPush([value],args));return isTaker&&chainAll?result[0]:result};if(useLazy&&checkIteratee&&typeof iteratee=="function"&&iteratee.length!=1)isLazy=useLazy=false;var chainAll=this.__chain__,isHybrid=!!this.__actions__.length,isUnwrapped=retUnwrapped&&!chainAll,onlyLazy=isLazy&&!isHybrid;if(!retUnwrapped&&useLazy){value=onlyLazy?value:new LazyWrapper(this);var result=func.apply(value,args);result.__actions__.push({"func":thru,"args":[interceptor],"thisArg":undefined});return new LodashWrapper(result,
chainAll)}if(isUnwrapped&&onlyLazy)return func.apply(this,args);result=this.thru(interceptor);return isUnwrapped?isTaker?result.value()[0]:result.value():result}});arrayEach(["pop","push","shift","sort","splice","unshift"],function(methodName){var func=arrayProto[methodName],chainName=/^(?:push|sort|unshift)$/.test(methodName)?"tap":"thru",retUnwrapped=/^(?:pop|shift)$/.test(methodName);lodash.prototype[methodName]=function(){var args=arguments;if(retUnwrapped&&!this.__chain__){var value=this.value();
return func.apply(isArray(value)?value:[],args)}return this[chainName](function(value){return func.apply(isArray(value)?value:[],args)})}});baseForOwn(LazyWrapper.prototype,function(func,methodName){var lodashFunc=lodash[methodName];if(lodashFunc){var key=lodashFunc.name+"",names=realNames[key]||(realNames[key]=[]);names.push({"name":methodName,"func":lodashFunc})}});realNames[createHybrid(undefined,WRAP_BIND_KEY_FLAG).name]=[{"name":"wrapper","func":undefined}];LazyWrapper.prototype.clone=lazyClone;
LazyWrapper.prototype.reverse=lazyReverse;LazyWrapper.prototype.value=lazyValue;lodash.prototype.at=wrapperAt;lodash.prototype.chain=wrapperChain;lodash.prototype.commit=wrapperCommit;lodash.prototype.next=wrapperNext;lodash.prototype.plant=wrapperPlant;lodash.prototype.reverse=wrapperReverse;lodash.prototype.toJSON=lodash.prototype.valueOf=lodash.prototype.value=wrapperValue;lodash.prototype.first=lodash.prototype.head;if(symIterator)lodash.prototype[symIterator]=wrapperToIterator;return lodash};
var _=runInContext();if(typeof define=="function"&&typeof define.amd=="object"&&define.amd){root._=_;define(function(){return _})}else if(freeModule){(freeModule.exports=_)._=_;freeExports._=_}else root._=_}).call(this);
//# sourceURL=build://vz-sorting/sorting.js
var rc;
(function(b){function d(k,t){let l;(function(m){m[m.NATURAL=0]="NATURAL";m[m.REAL=1]="REAL";m[m.EXPONENT_SIGN=2]="EXPONENT_SIGN";m[m.EXPONENT=3]="EXPONENT"})(l||(l={}));let p=l.NATURAL;for(;t<k.length;t++)if(p===l.NATURAL)if("."===k[t])p=l.REAL;else if("e"===k[t]||"E"===k[t])p=l.EXPONENT_SIGN;else{if(!f(k[t]))break}else if(p===l.REAL)if("e"===k[t]||"E"===k[t])p=l.EXPONENT_SIGN;else{if(!f(k[t]))break}else if(p===l.EXPONENT_SIGN)if(f(k[t])||"+"===k[t]||"-"===k[t])p=l.EXPONENT;else break;else if(p===l.EXPONENT&&
!f(k[t]))break;return t}function f(k){return"0"<=k&&"9">=k}function h(k){return"/"===k||"_"===k||f(k)}b.compareTagNames=function(k,t){let l=0,p=0;for(;;){if(l===k.length)return p===t.length?0:-1;if(p===t.length)return 1;if(f(k[l])&&f(t[p])){var m=l,n=p;l=d(k,l+1);p=d(t,p+1);m=parseFloat(k.slice(m,l));n=parseFloat(t.slice(n,p));if(m<n)return-1;if(m>n)return 1}else{if(h(k[l])){if(!h(t[p]))return-1}else{if(h(t[p]))return 1;if(k[l]<t[p])return-1;if(k[l]>t[p])return 1}l++;p++}}}})(rc||(rc={}));

//# sourceURL=build://tf-backend/requestManager.js
var vc;
(function(b){function d(q,u,x,A){const y=new XMLHttpRequest;y.open(q,u);x&&(y.withCredentials=x);A&&y.setRequestHeader("Content-Type",A);return y}function f(q){const u=new m;if(!q)return u.methodType=p.GET,u;u.methodType=p.POST;u.body=h(q);return u}function h(q){const u=new FormData;for(let x in q)x&&u.append(x,q[x]);return u}class k extends Error{constructor(){super(...arguments);this.name="RequestCancellationError"}}b.RequestCancellationError=k;class t extends Error{constructor(q){super(q);this.name=
"InvalidRequestOptionsError";Object.setPrototypeOf(this,t.prototype)}}b.InvalidRequestOptionsError=t;class l extends Error{constructor(q,u){super();this.message=`RequestNetworkError: ${q.status} at ${u}`;this.name="RequestNetworkError";this.req=q;this.url=u}}b.RequestNetworkError=l;let p;(function(q){q.GET="GET";q.POST="POST"})(p=b.HttpMethodType||(b.HttpMethodType={}));class m{validate(){if(this.methodType===p.GET&&this.body)throw new t("body must be missing for a GET request.");}}b.RequestOptions=
m;class n{constructor(q=1E3,u=3){this._queue=[];this._nActiveRequests=0;this._nSimultaneousRequests=q;this._maxRetries=u}request(q,u){u=f(u);return this.requestWithOptions(q,u)}requestWithOptions(q,u){u.validate();return(new Promise((x,A)=>{this._queue.push({resolve:x,reject:A});this.launchRequests()})).then(()=>this.promiseWithRetries(q,this._maxRetries,u)).then(x=>{this._nActiveRequests--;this.launchRequests();return x},x=>{"RequestNetworkError"===x.name&&(this._nActiveRequests--,this.launchRequests());
return Promise.reject(x)})}fetch(q,u){return(new Promise((x,A)=>{this._queue.push({resolve:x,reject:A});this.launchRequests()})).then(()=>{let x=1;return new Promise(A=>{const y=()=>{fetch(q,u).then(w=>{!w.ok&&this._maxRetries>x?(x++,y()):(A(w),this._nActiveRequests--,this.launchRequests())})};y()})})}clearQueue(){for(;0<this._queue.length;)this._queue.pop().reject(new k("Request cancelled by clearQueue"))}activeRequests(){return this._nActiveRequests}outstandingRequests(){return this._nActiveRequests+
this._queue.length}launchRequests(){for(;this._nActiveRequests<this._nSimultaneousRequests&&0<this._queue.length;)this._nActiveRequests++,this._queue.pop().resolve()}promiseWithRetries(q,u,x){return this._promiseFromUrl(q,x).then(A=>A,A=>0<u?this.promiseWithRetries(q,u-1,x):Promise.reject(A))}_promiseFromUrl(q,u){return new Promise((x,A)=>{const y=d(u.methodType,q,u.withCredentials,u.contentType);y.onload=function(){200===y.status?x(JSON.parse(y.responseText)):A(new l(y,q))};y.onerror=function(){A(new l(y,
q))};u.body?y.send(u.body):y.send()})}}b.RequestManager=n})(vc||(vc={}));

//# sourceURL=build://tf-backend/urlPathHelpers.js
(function(b){function d(f){return encodeURIComponent(f).replace(/\(/g,"%28").replace(/\)/g,"%29")}b.addParams=function(f,h){var k=Object.keys(h).sort().filter(l=>void 0!==h[l]);if(!k.length)return f;const t=-1!==f.indexOf("?")?"\x26":"?";k=[].concat(...k.map(l=>{const p=h[l];return(Array.isArray(p)?p:[p]).map(m=>`${l}=${d(m)}`)})).join("\x26");return f+t+k}})(vc||(vc={}));

//# sourceURL=build://tf-backend/router.js
(function(b){function d(t="data",l=new URLSearchParams(window.location.search)){"/"===t[t.length-1]&&(t=t.slice(0,t.length-1));return{environment:()=>f(t,"/environment"),experiments:()=>f(t,"/experiments"),pluginRoute:(p,m,n)=>f(t+"/plugin",`/${p}${m}`,n),pluginsListing:()=>f(t,"/plugins_listing",h({["experimentalPlugin"]:l.getAll("experimentalPlugin")})),runs:()=>f(t,"/runs"),runsForExperiment:p=>f(t,"/experiment_runs",h({experiment:String(p)}))}}function f(t,l,p=new URLSearchParams){t+=l;String(p)&&
(l=l.includes("?")?"\x26":"?",t+=l+String(p));return t}function h(t={}){const l=Object.keys(t).sort().filter(m=>t[m]),p=new URLSearchParams;l.forEach(m=>{const n=t[m];(Array.isArray(n)?n:[n]).forEach(q=>p.append(m,q))});return p}let k=d();b.createRouter=d;b.getRouter=function(){return k};b.setRouter=function(t){if(null==t)throw Error("Router required, but got: "+t);k=t};b.createSearchParam=h})(vc||(vc={}));

//# sourceURL=build://tf-backend/baseStore.js
(function(b){class d{constructor(h){this.listener=h}}b.ListenKey=d;class f{constructor(){this.requestManager=new b.RequestManager(1);this._listeners=new Set;this.initialized=!1}refresh(){return this.load().then(()=>{this.initialized=!0})}addListener(h){h=new d(h);this._listeners.add(h);return h}removeListenerByKey(h){this._listeners.delete(h)}emitChange(){this._listeners.forEach(h=>{try{h.listener()}catch(k){}})}}b.BaseStore=f})(vc||(vc={}));

//# sourceURL=build://tf-backend/environmentStore.js
(function(b){class d extends b.BaseStore{load(){const f=b.getRouter().environment();return this.requestManager.request(f).then(h=>{const k={dataLocation:h.data_location,windowTitle:h.window_title};void 0!==h.experiment_name&&(k.experimentName=h.experiment_name);void 0!==h.experiment_description&&(k.experimentDescription=h.experiment_description);void 0!==h.creation_time&&(k.creationTime=h.creation_time);_.isEqual(this.environment,k)||(this.environment=k,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}}b.EnvironmentStore=d;b.environmentStore=new d})(vc||(vc={}));

//# sourceURL=build://tf-backend/experimentsStore.js
(function(b){class d extends b.BaseStore{constructor(){super(...arguments);this._experiments=[]}load(){const f=b.getRouter().experiments();return this.requestManager.request(f).then(h=>{_.isEqual(this._experiments,h)||(this._experiments=h,this.emitChange())})}getExperiments(){return this._experiments.slice()}}b.ExperimentsStore=d;b.experimentsStore=new d})(vc||(vc={}));

//# sourceURL=build://tf-backend/runsStore.js
(function(b){class d extends b.BaseStore{constructor(){super(...arguments);this._runs=[]}load(){const f=b.getRouter().runs();return this.requestManager.request(f).then(h=>{_.isEqual(this._runs,h)||(this._runs=h,this.emitChange())})}getRuns(){return this._runs.slice()}}b.RunsStore=d;b.runsStore=new d})(vc||(vc={}));

//# sourceURL=build://tf-backend/backend.js
(function(b){b.TYPES=[];b.getRunsNamed=function(d){return _.keys(d).sort(rc.compareTagNames)};b.getTags=function(d){return _.union.apply(null,_.values(d)).sort(rc.compareTagNames)};b.filterTags=function(d,f){let h=[];f.forEach(k=>h=h.concat(d[k]));return _.uniq(h).sort(rc.compareTagNames)}})(vc||(vc={}));

//# sourceURL=build://tf-backend/canceller.js
(function(b){class d{constructor(){this.cancellationCount=0}cancellable(f){const h=this.cancellationCount;return k=>f({value:k,cancelled:this.cancellationCount!==h})}cancelAll(){this.cancellationCount++}}b.Canceller=d})(vc||(vc={}));

//# sourceURL=build://tf-backend/tf-backend-polymer.js
(function(b){Polymer({is:"tf-backend",_template:null,tf_backend:b})})(vc||(vc={}));

//# sourceURL=build://tf-categorization-utils/categorizationUtils.js
var $c;
(function(b){function d(m,n){const q=(()=>{try{return new RegExp(n)}catch(u){return null}})();return{name:n,metadata:{type:p.SEARCH_RESULTS,validRegex:!!q,universalRegex:".*"===n},items:q?m.filter(u=>u.match(q)):[]}}function f(m,n="/"){const q=[],u={};m.forEach(x=>{var A=x.indexOf(n);A=0<=A?x.slice(0,A):x;if(!u[A]){const y={name:A,metadata:{type:p.PREFIX_GROUP},items:[]};u[A]=y;q.push(y)}u[A].items.push(x)});return q}function h(m,n=""){n=[d(m,n)];m=f(m);return[].concat(n,m)}function k(m,n,q){const u=
vc.getTags(m);q=h(u,q);const x=t(_.pick(m,n));return q.map(({name:A,metadata:y,items:w})=>({name:A,metadata:y,items:w.map(C=>({tag:C,runs:(x.get(C)||[]).slice()}))}))}function t(m){const n=new Map;Object.keys(m).forEach(q=>{m[q].forEach(u=>{const x=n.get(u)||[];x.push(q);n.set(u,x)})});return n}function l(m,n){const q=rc.compareTagNames(m.tag,n.tag);return 0!=q?q:rc.compareTagNames(m.run,n.run)}let p;(function(m){m[m.SEARCH_RESULTS=0]="SEARCH_RESULTS";m[m.PREFIX_GROUP=1]="PREFIX_GROUP"})(p=b.CategoryType||
(b.CategoryType={}));b.categorizeBySearchQuery=d;b.categorizeByPrefix=f;b.categorize=h;b.categorizeTags=k;b.categorizeRunTagCombinations=function(m,n,q){return k(m,n,q).map(function(u){const x=_.flatten(u.items.map(({tag:A,runs:y})=>y.map(w=>({tag:A,run:w}))));x.sort(l);return{name:u.name,metadata:u.metadata,items:x}})}})($c||($c={}));

//# sourceURL=build://tf-globals/globals.js
var ad;(function(b){let d=!1;b.setUseHash=function(h){d=h};b.useHash=function(){return d};let f="";b.setFakeHash=function(h){f=h};b.getFakeHash=function(){return f}})(ad||(ad={}));

//# sourceURL=build://tf-globals/globals-polymer.js
(function(b){Polymer({is:"tf-globals",_template:null,tf_globals:b})})(ad||(ad={}));

//# sourceURL=build://tf-storage/listeners.js
var pd;
(function(b){class d{constructor(k){this.listener=k}}b.ListenKey=d;const f=new Set,h=new Set;window.addEventListener("hashchange",()=>{f.forEach(k=>k.listener())});window.addEventListener("storage",()=>{h.forEach(k=>k.listener())});b.addHashListener=function(k){k=new d(k);f.add(k);return k};b.addStorageListener=function(k){k=new d(k);h.add(k);return k};b.fireStorageChanged=function(){h.forEach(k=>k.listener())};b.removeHashListenerByKey=function(k){f.delete(k)};b.removeStorageListenerByKey=function(k){h.delete(k)}})(pd||
(pd={}));

//# sourceURL=build://tf-storage/storage.js
(function(b){function d(n,q){function u(w,C={}){const {defaultValue:G,useLocalStorage:D=!1}=C;w=D?window.localStorage.getItem(w):l(h())[w];return void 0==w?_.cloneDeep(G):n(w)}function x(w,C,G={}){const {defaultValue:D,useLocalStorage:B=!1,useLocationReplace:I=!1}=G;G=q(C);B?(window.localStorage.setItem(w,G),b.fireStorageChanged()):_.isEqual(C,u(w,{useLocalStorage:B}))||(_.isEqual(C,D)?p(w):(C=l(h()),C[w]=G,k(t(C),I)))}const A=[],y=[];return{get:u,set:x,getInitializer:function(w,C){const G=Object.assign({defaultValue:C.defaultValue,
polymerProperty:w,useLocalStorage:!1},C);return function(){const D=f(this,w),B=()=>{const N=u(D,G);_.isEqual(N,this[G.polymerProperty])||(this[G.polymerProperty]=N)},I=(G.useLocalStorage?b.addStorageListener:b.addHashListener)(()=>B());G.useLocalStorage?y.push(I):A.push(I);B();return this[G.polymerProperty]}},getObserver:function(w,C){const G=Object.assign({defaultValue:C.defaultValue,polymerProperty:w,useLocalStorage:!1},C);return function(){const D=f(this,w);x(D,this[G.polymerProperty],G)}},disposeBinding:function(){A.forEach(w=>
b.removeHashListenerByKey(w));y.forEach(w=>b.removeStorageListenerByKey(w))}}}function f(n,q){n=n[b.DISAMBIGUATOR];return(null==n?[q]:[n,q]).join(".")}function h(){return ad.useHash()?window.location.hash.slice(1):ad.getFakeHash()}function k(n,q=!1){ad.useHash()?q?window.location.replace("#"+n):window.location.hash=n:ad.setFakeHash(n)}function t(n){let q="";void 0!==n[b.TAB]&&(q+=n[b.TAB]);const u=Object.keys(n).map(x=>[x,n[x]]).filter(x=>x[0]!==b.TAB).map(x=>encodeURIComponent(x[0])+"\x3d"+encodeURIComponent(x[1])).join("\x26");
return 0<u.length?q+"\x26"+u:q}function l(n){const q={};n.split("\x26").forEach(u=>{u=u.split("\x3d");1===u.length?q[b.TAB]=u[0]:2===u.length&&(q[decodeURIComponent(u[0])]=decodeURIComponent(u[1]))});return q}function p(n){const q=l(h());delete q[n];k(t(q))}b.TAB="__tab__";b.DISAMBIGUATOR="disambiguator";b.urlDict=l(h());b.addHashListener(()=>{b.urlDict=l(h())});var m=d(n=>n,n=>n);b.getString=m.get;b.setString=m.set;b.getStringInitializer=m.getInitializer;b.getStringObserver=m.getObserver;b.disposeStringBinding=
m.disposeBinding;m=d(n=>"true"===n?!0:"false"===n?!1:void 0,n=>n.toString());b.getBoolean=m.get;b.setBoolean=m.set;b.getBooleanInitializer=m.getInitializer;b.getBooleanObserver=m.getObserver;b.disposeBooleanBinding=m.disposeBinding;m=d(n=>+n,n=>n.toString());b.getNumber=m.get;b.setNumber=m.set;b.getNumberInitializer=m.getInitializer;b.getNumberObserver=m.getObserver;b.disposeNumberBinding=m.disposeBinding;m=d(n=>JSON.parse(atob(n)),n=>btoa(JSON.stringify(n)));b.getObject=m.get;b.setObject=m.set;b.getObjectInitializer=
m.getInitializer;b.getObjectObserver=m.getObserver;b.disposeObjectBinding=m.disposeBinding;b.makeBindings=d;b.migrateLegacyURLScheme=function(){const n=new Set("examplesPath hideModelPane2 modelName1 modelName2 inferenceAddress1 inferenceAddress2 modelType modelVersion1 modelVersion2 modelSignature1 modelSignature2 maxExamples labelVocabPath multiClass sequenceExamples maxClassesToDisplay samplingOdds usePredictApi predictInputTensor predictOutputTensor".split(" ")),q=l(h());if("whatif"===q[b.TAB])for(let u of n)u in
q&&(q[`p.whatif.${u}`]=q[u]);k(t(q));this.urlDict=q}})(pd||(pd={}));

//# sourceURL=build://tf-storage/tf-storage-polymer.js
(function(b){Polymer({is:"tf-storage",_template:null,tf_storage:b})})(pd||(pd={}));

//# sourceURL=build://tf-categorization-utils/tf-tag-filterer.html.js
Polymer({is:"tf-tag-filterer",properties:{tagFilter:{type:String,notify:!0,computed:"_computeTagFilter(_tagFilter)"},_tagFilter:{type:String,value:pd.getStringInitializer("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"}),observer:"_tagFilterObserver"}},_tagFilterObserver:pd.getStringObserver("tagFilter",{defaultValue:"",useLocalStorage:!1,polymerProperty:"_tagFilter"}),_computeTagFilter(){return this._tagFilter}});

//# sourceURL=build://tf-dashboard-common/array-update-helper.js
var qd;(function(b){b.ArrayUpdateHelper={updateArrayProp(d,f,h){let k=this.get(d);if(!Array.isArray(f))throw RangeError(`Expected new value to '${d}' to be an array.`);Array.isArray(k)||(k=[],this.set(d,k));const t=new Set(f.map((m,n)=>h(m,n)));let l=0,p=0;for(;l<k.length&&p<f.length;)t.has(h(k[l],l))?(h(k[l],l)==h(f[p],p)?this.set(`${d}.${l}`,f[p]):this.splice(d,l,0,f[p]),p++,l++):this.splice(d,l,1);l<k.length&&this.splice(d,l);p<f.length&&this.push(d,...f.slice(p))}}})(qd||(qd={}));

//# sourceURL=build://tf-dashboard-common/tf-dashboard-layout.html.js
Polymer({is:"tf-dashboard-layout"});

//# sourceURL=build://tf-dashboard-common/tf-option-selector.html.js
Polymer({is:"tf-option-selector",properties:{name:String,selectedId:{type:String,notify:!0,observer:"_selectedIdChanged"}},attached:function(){this.async(function(){this.getEffectiveChildren().forEach(function(b){this.listen(b,"tap","_selectTarget")}.bind(this))})},_selectTarget:function(b){this.selectedId=b.currentTarget.id},_selectedIdChanged:function(){var b=this.queryEffectiveChildren("#"+this.selectedId);b&&(this.getEffectiveChildren().forEach(function(d){d.classList.remove("selected")}),b.classList.add("selected"))}});

//# sourceURL=build://iron-collapse/iron-collapse.html.js
Polymer({is:"iron-collapse",behaviors:[Polymer.IronResizableBehavior],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(b,d){b="auto"===b?"":b;d=d&&!this.noAnimation&&this.isAttached&&this._desiredSize!==b;this._desiredSize=b;this._updateTransition(!1);d&&(d=this._calcSize(),""===b&&(this.style[this._dimensionMax]="",b=this._calcSize()),this.style[this._dimensionMax]=d,this.scrollTop=
this.scrollTop,this._updateTransition(!0),d=b!==d);this.style[this._dimensionMax]=b;d||this._transitionEnd()},enableTransition:function(b){Polymer.Base._warn("`enableTransition()` is deprecated, use `noAnimation` instead.");this.noAnimation=!b},_updateTransition:function(b){this.style.transitionDuration=b&&!this.noAnimation?"":"0s"},_horizontalChanged:function(){this.style.transitionProperty=this._dimensionMaxCss;this.style["maxWidth"===this._dimensionMax?"maxHeight":"maxWidth"]="";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(b){Polymer.dom(b).rootTarget===this&&this._transitionEnd()},_calcSize:function(){return this.getBoundingClientRect()[this.dimension]+"px"}});

//# sourceURL=build://tf-paginated-view/tf-dom-repeat.html.js
var Jd;
(function(b){b.TfDomRepeatBehavior=[qd.ArrayUpdateHelper,{properties:{as:{type:String,value:"item"},_contentActive:{type:Boolean,value:!0},_domBootstrapped:{type:Boolean,value:!1},_ctor:{type:Function,value:()=>null},_renderedItems:{type:Array,value:()=>[]},_renderedTemplateInst:{type:Object,value:()=>new Map},_lruCachedItems:{type:Object,value:()=>new Map},_cacheSize:{type:Number,value:10},_getItemKey:{type:Function,value:()=>d=>JSON.stringify(d)}},observers:["_bootstrapDom(_itemsRendered, isAttached)","_updateDom(_renderedItems.*, _domBootstrapped)",
"_updateActive(_contentActive)","_trimCache(_cacheSize)"],setCacheSize(d){this._cacheSize=d},setGetItemKey(d){this._getItemKey=d},updateDom(d){this.updateArrayProp("_renderedItems",d,this._getItemKey)},_ensureTemplatized(){if(!this.isAttached)return!1;this._ctor||(this._ctor=Polymer.Templatize.templatize(this.querySelector("template"),this,{parentModel:!0,instanceProps:{[this.as]:!0,active:this._contentActive},forwardHostProp:function(d,f){this._renderedTemplateInst.forEach(h=>{h.forwardHostProp(d,
f)})}}));return!0},_bootstrapDom(){this._itemsRendered&&this._ensureTemplatized()&&!this._domBootstrapped&&(Array.from(this.children).forEach(d=>{Polymer.dom(this).removeChild(d)}),this._lruCachedItems.clear(),this._renderedItems.forEach((d,f)=>this._insertItem(d,f)),this._domBootstrapped=!0)},_updateActive(){this._domBootstrapped&&Array.from(this._renderedTemplateInst.values()).forEach(d=>{d.notifyPath("active",this._contentActive)})},_updateDom(d){if(this._domBootstrapped&&"_renderedItems"!=d.path&&
"_renderedItems.length"!=d.path)if("_renderedItems.splices"===d.path)d.value.indexSplices.forEach(f=>{const h=f.index,k=f.addedCount,t=f.object;f.removed.forEach(l=>{this._removeItem(l,this.children[h])});t.slice(h,h+k).forEach((l,p)=>this._insertItem(l,h+p));this._trimCache()});else{const f=this._getItemKey(d.value);this._renderedTemplateInst.has(f)?this._renderedTemplateInst.get(f).notifyPath(this.as,d.value):console.warn(`Expected '${f}' to exist in the DOM but `+"could not find one.")}},_insertItem(d,
f){if(!this._ensureTemplatized())throw Error("Expected templatized before inserting an item");const h=this._getItemKey(d);if(this._lruCachedItems.has(h))d=this._lruCachedItems.get(h),this._lruCachedItems.delete(h),this._renderedTemplateInst.get(h).notifyPath("active",this._contentActive);else{const k=new this._ctor({[this.as]:d,active:this._contentActive});d=k.root;this._renderedTemplateInst.set(h,k)}this.children[f]?Polymer.dom(this).insertBefore(d,this.children[f]):((d.nodeType==Node.DOCUMENT_FRAGMENT_NODE?
Array.from(d.children):[d]).forEach(k=>k.setAttribute("slot","items")),Polymer.dom(this).appendChild(d))},_removeItem(d,f){Polymer.dom(f.parentNode).removeChild(f);d=this._getItemKey(d);this._lruCachedItems.set(d,f);this._renderedTemplateInst.get(d).notifyPath("active",!1)},_trimCache(){for(;this._lruCachedItems.size>this._cacheSize;){const [d]=this._lruCachedItems.keys();this._lruCachedItems.delete(d);this._renderedTemplateInst.delete(d)}}}]})(Jd||(Jd={}));

//# sourceURL=build://tf-paginated-view/paginatedViewStore.js
var ne;
(function(b){let d=null;const f=new Set;b.addLimitListener=function(h){f.add(h)};b.removeLimitListener=function(h){f.delete(h)};b.getLimit=function(){null==d&&(d=pd.getNumber("TF.TensorBoard.PaginatedView.limit",{useLocalStorage:!0}),null==d||!isFinite(d)||0>=d)&&(d=12);return d};b.setLimit=function(h){if(h!==Math.floor(h))throw Error(`limit must be an integer, but got: ${h}`);if(0>=h)throw Error(`limit must be positive, but got: ${h}`);h!==d&&(d=h,pd.setNumber("TF.TensorBoard.PaginatedView.limit",d,
{useLocalStorage:!0}),f.forEach(k=>{k()}))}})(ne||(ne={}));

//# sourceURL=build://tf-paginated-view/tf-paginated-view-store.html.js
Polymer({is:"tf-paginated-view-store",_template:null,tf_paginated_view:ne});

//# sourceURL=build://tf-paginated-view/tf-category-paginated-view.html.js
Polymer({is:"tf-category-paginated-view",properties:{category:Object,initialOpened:Boolean,opened:{type:Boolean,notify:!0,readOnly:!0},_contentActive:{type:Boolean,computed:"_computeContentActive(opened)"},disablePagination:{type:Boolean,value:!1},_count:{type:Number,computed:"_computeCount(category.items.*)"},_hasMultiple:{type:Boolean,computed:"_computeHasMultiple(_count)"},_paneRendered:{type:Boolean,computed:"_computePaneRendered(category)",observer:"_onPaneRenderedChanged"},_itemsRendered:{type:Boolean,
computed:"_computeItemsRendered(opened, _paneRendered)"},_isSearchResults:{type:Boolean,computed:"_computeIsSearchResults(category.metadata.type)"},_isInvalidSearchResults:{type:Boolean,computed:"_computeIsInvalidSearchResults(category.metadata)"},_isUniversalSearchQuery:{type:Boolean,computed:"_computeIsUniversalSearchQuery(category.metadata)"},getCategoryItemKey:{type:Function,value:()=>b=>JSON.stringify(b),observer:"_getCategoryItemKeyChanged"},_limit:{type:Number,value:12,observer:"_limitChanged"},
_activeIndex:{type:Number,value:0},_currentPage:{type:Number,computed:"_computeCurrentPage(_limit, _activeIndex)"},_pageCount:{type:Number,computed:"_computePageCount(category.items.*, _limit)"},_multiplePagesExist:{type:Boolean,computed:"_computeMultiplePagesExist(_pageCount, disablePagination)"},_hasPreviousPage:{type:Boolean,computed:"_computeHasPreviousPage(_currentPage)"},_hasNextPage:{type:Boolean,computed:"_computeHasNextPage(_currentPage, _pageCount)"},_inputWidth:{type:String,computed:"_computeInputWidth(_pageCount)",
observer:"_updateInputWidth"},_pageInputValue:{type:String,computed:"_computePageInputValue(_pageInputFocused, _pageInputRawValue, _currentPage)",observer:"_updatePageInputValue"},_pageInputRawValue:{type:String,value:""},_pageInputFocused:{type:Boolean,value:!1}},observers:["_clampActiveIndex(category.items.*)","_updateRenderedItems(_itemsRendered, category.items.*, _limit, _activeIndex, _pageCount, disablePagination)"],behaviors:[Jd.TfDomRepeatBehavior],_computeCount(){return this.category.items.length},
_computeHasMultiple(){return 1<this._count},_togglePane(){this._setOpened(!this.opened)},_computeContentActive(){return this.opened},_onPaneRenderedChanged(b,d){b&&b!==d&&this.$.ifRendered.render()},_computePaneRendered(b){return!(b.metadata.type===$c.CategoryType.SEARCH_RESULTS&&""===b.name)},_computeItemsRendered(){return this._paneRendered&&this.opened},_computeIsSearchResults(b){return b===$c.CategoryType.SEARCH_RESULTS},_computeIsInvalidSearchResults(b){return b.type===$c.CategoryType.SEARCH_RESULTS&&
!b.validRegex},_computeIsUniversalSearchQuery(b){return b.type===$c.CategoryType.SEARCH_RESULTS&&b.universalRegex},_isCompositeSearch(){const b=this.category.metadata.type;return this.category.metadata.compositeSearch&&b===$c.CategoryType.SEARCH_RESULTS},ready(){this._setOpened(null==this.initialOpened?!0:this.initialOpened);this._limitListener=()=>{this.set("_limit",ne.getLimit())};ne.addLimitListener(this._limitListener);this._limitListener()},detached(){ne.removeLimitListener(this._limitListener)},
_updateRenderedItems(b,d,f,h,k,t){b&&(b=Math.floor(h/f),d=this.category.items||[],this.updateDom(t?d:d.slice(b*f,(b+1)*f),this.getCategoryItemKey))},_limitChanged(b){this.setCacheSize(2*b)},_getCategoryItemKeyChanged(){this.setGetItemKey(this.getCategoryItemKey)},_computeCurrentPage(b,d){return Math.floor(d/b)+1},_computePageCount(b,d){return this.category?Math.ceil(this.category.items.length/d):0},_computeMultiplePagesExist(b,d){return!d&&1<b},_computeHasPreviousPage(b){return 1<b},_computeHasNextPage(b,
d){return b<d},_computeInputWidth(b){return`calc(${b.toString().length}em + 20px)`},_setActiveIndex(b){const d=(this.category.items||[]).length-1;b>d&&(b=d);0>b&&(b=0);this.set("_activeIndex",b)},_clampActiveIndex(){this._setActiveIndex(this._activeIndex)},_performPreviousPage(){this._setActiveIndex(this._activeIndex-this._limit)},_performNextPage(){this._setActiveIndex(this._activeIndex+this._limit)},_computePageInputValue(b,d,f){return b?d:f.toString()},_handlePageInputEvent(b){this.set("_pageInputRawValue",
b.target.value);b=Number(b.target.value||NaN);isNaN(b)||this._setActiveIndex(this._limit*(Math.max(1,Math.min(b,this._pageCount))-1))},_handlePageChangeEvent(){this.set("_pageInputRawValue",this._currentPage.toString())},_handlePageFocusEvent(){this.set("_pageInputRawValue",this._pageInputValue);this.set("_pageInputFocused",!0)},_handlePageBlurEvent(){this.set("_pageInputFocused",!1)},_updatePageInputValue(b){const d=this.$$("#page-input input");d&&(d.value=b)},_updateInputWidth(){this.updateStyles({"--tf-category-paginated-view-page-input-width":this._inputWidth})}});

//# sourceURL=build://paper-dialog-behavior/paper-dialog-behavior.html.js
(function(){Polymer.PaperDialogBehaviorImpl={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(b,d){d&&(b?(this.__prevNoCancelOnOutsideClick=
this.noCancelOnOutsideClick,this.__prevNoCancelOnEscKey=this.noCancelOnEscKey,this.__prevWithBackdrop=this.withBackdrop,this.withBackdrop=this.noCancelOnEscKey=this.noCancelOnOutsideClick=!0):(this.noCancelOnOutsideClick=this.noCancelOnOutsideClick&&this.__prevNoCancelOnOutsideClick,this.noCancelOnEscKey=this.noCancelOnEscKey&&this.__prevNoCancelOnEscKey,this.withBackdrop=this.withBackdrop&&this.__prevWithBackdrop))},_updateClosingReasonConfirmed:function(b){this.closingReason=this.closingReason||
{};this.closingReason.confirmed=b},_onDialogClick:function(b){for(var d=Polymer.dom(b).path,f=0,h=d.indexOf(this);f<h;f++){var k=d[f];if(k.hasAttribute&&(k.hasAttribute("dialog-dismiss")||k.hasAttribute("dialog-confirm"))){this._updateClosingReasonConfirmed(k.hasAttribute("dialog-confirm"));this.close();b.stopPropagation();break}}}};Polymer.PaperDialogBehavior=[Polymer.IronOverlayBehavior,Polymer.PaperDialogBehaviorImpl]})();

//# sourceURL=build://paper-dialog/paper-dialog.html.js
Polymer({is:"paper-dialog",behaviors:[Polymer.PaperDialogBehavior,Polymer.NeonAnimationRunnerBehavior],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()}});

// https://d3js.org v5.7.0 Copyright 2018 Mike Bostock
!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n(t.d3=t.d3||{})}(this,function(t){"use strict";function n(t,n){return t<n?-1:t>n?1:t>=n?0:NaN}function e(t){var e;return 1===t.length&&(e=t,t=function(t,r){return n(e(t),r)}),{left:function(n,e,r,i){for(null==r&&(r=0),null==i&&(i=n.length);r<i;){var o=r+i>>>1;t(n[o],e)<0?r=o+1:i=o}return r},right:function(n,e,r,i){for(null==r&&(r=0),null==i&&(i=n.length);r<i;){var o=r+i>>>1;t(n[o],e)>0?i=o:r=o+1}return r}}}var r=e(n),i=r.right,o=r.left;function a(t,n){return[t,n]}function u(t){return null===t?NaN:+t}function f(t,n){var e,r,i=t.length,o=0,a=-1,f=0,c=0;if(null==n)for(;++a<i;)isNaN(e=u(t[a]))||(c+=(r=e-f)*(e-(f+=r/++o)));else for(;++a<i;)isNaN(e=u(n(t[a],a,t)))||(c+=(r=e-f)*(e-(f+=r/++o)));if(o>1)return c/(o-1)}function c(t,n){var e=f(t,n);return e?Math.sqrt(e):e}function s(t,n){var e,r,i,o=t.length,a=-1;if(null==n){for(;++a<o;)if(null!=(e=t[a])&&e>=e)for(r=i=e;++a<o;)null!=(e=t[a])&&(r>e&&(r=e),i<e&&(i=e))}else for(;++a<o;)if(null!=(e=n(t[a],a,t))&&e>=e)for(r=i=e;++a<o;)null!=(e=n(t[a],a,t))&&(r>e&&(r=e),i<e&&(i=e));return[r,i]}var l=Array.prototype,h=l.slice,d=l.map;function p(t){return function(){return t}}function v(t){return t}function g(t,n,e){t=+t,n=+n,e=(i=arguments.length)<2?(n=t,t=0,1):i<3?1:+e;for(var r=-1,i=0|Math.max(0,Math.ceil((n-t)/e)),o=new Array(i);++r<i;)o[r]=t+r*e;return o}var y=Math.sqrt(50),_=Math.sqrt(10),b=Math.sqrt(2);function m(t,n,e){var r,i,o,a,u=-1;if(e=+e,(t=+t)===(n=+n)&&e>0)return[t];if((r=n<t)&&(i=t,t=n,n=i),0===(a=x(t,n,e))||!isFinite(a))return[];if(a>0)for(t=Math.ceil(t/a),n=Math.floor(n/a),o=new Array(i=Math.ceil(n-t+1));++u<i;)o[u]=(t+u)*a;else for(t=Math.floor(t*a),n=Math.ceil(n*a),o=new Array(i=Math.ceil(t-n+1));++u<i;)o[u]=(t-u)/a;return r&&o.reverse(),o}function x(t,n,e){var r=(n-t)/Math.max(0,e),i=Math.floor(Math.log(r)/Math.LN10),o=r/Math.pow(10,i);return i>=0?(o>=y?10:o>=_?5:o>=b?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(o>=y?10:o>=_?5:o>=b?2:1)}function w(t,n,e){var r=Math.abs(n-t)/Math.max(0,e),i=Math.pow(10,Math.floor(Math.log(r)/Math.LN10)),o=r/i;return o>=y?i*=10:o>=_?i*=5:o>=b&&(i*=2),n<t?-i:i}function M(t){return Math.ceil(Math.log(t.length)/Math.LN2)+1}function A(t,n,e){if(null==e&&(e=u),r=t.length){if((n=+n)<=0||r<2)return+e(t[0],0,t);if(n>=1)return+e(t[r-1],r-1,t);var r,i=(r-1)*n,o=Math.floor(i),a=+e(t[o],o,t);return a+(+e(t[o+1],o+1,t)-a)*(i-o)}}function T(t,n){var e,r,i=t.length,o=-1;if(null==n){for(;++o<i;)if(null!=(e=t[o])&&e>=e)for(r=e;++o<i;)null!=(e=t[o])&&e>r&&(r=e)}else for(;++o<i;)if(null!=(e=n(t[o],o,t))&&e>=e)for(r=e;++o<i;)null!=(e=n(t[o],o,t))&&e>r&&(r=e);return r}function N(t){for(var n,e,r,i=t.length,o=-1,a=0;++o<i;)a+=t[o].length;for(e=new Array(a);--i>=0;)for(n=(r=t[i]).length;--n>=0;)e[--a]=r[n];return e}function S(t,n){var e,r,i=t.length,o=-1;if(null==n){for(;++o<i;)if(null!=(e=t[o])&&e>=e)for(r=e;++o<i;)null!=(e=t[o])&&r>e&&(r=e)}else for(;++o<i;)if(null!=(e=n(t[o],o,t))&&e>=e)for(r=e;++o<i;)null!=(e=n(t[o],o,t))&&r>e&&(r=e);return r}function E(t){if(!(i=t.length))return[];for(var n=-1,e=S(t,k),r=new Array(e);++n<e;)for(var i,o=-1,a=r[n]=new Array(i);++o<i;)a[o]=t[o][n];return r}function k(t){return t.length}var C=Array.prototype.slice;function P(t){return t}var z=1,R=2,L=3,D=4,U=1e-6;function q(t){return"translate("+(t+.5)+",0)"}function O(t){return"translate(0,"+(t+.5)+")"}function Y(){return!this.__axis}function B(t,n){var e=[],r=null,i=null,o=6,a=6,u=3,f=t===z||t===D?-1:1,c=t===D||t===R?"x":"y",s=t===z||t===L?q:O;function l(l){var h=null==r?n.ticks?n.ticks.apply(n,e):n.domain():r,d=null==i?n.tickFormat?n.tickFormat.apply(n,e):P:i,p=Math.max(o,0)+u,v=n.range(),g=+v[0]+.5,y=+v[v.length-1]+.5,_=(n.bandwidth?function(t){var n=Math.max(0,t.bandwidth()-1)/2;return t.round()&&(n=Math.round(n)),function(e){return+t(e)+n}}:function(t){return function(n){return+t(n)}})(n.copy()),b=l.selection?l.selection():l,m=b.selectAll(".domain").data([null]),x=b.selectAll(".tick").data(h,n).order(),w=x.exit(),M=x.enter().append("g").attr("class","tick"),A=x.select("line"),T=x.select("text");m=m.merge(m.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),x=x.merge(M),A=A.merge(M.append("line").attr("stroke","currentColor").attr(c+"2",f*o)),T=T.merge(M.append("text").attr("fill","currentColor").attr(c,f*p).attr("dy",t===z?"0em":t===L?"0.71em":"0.32em")),l!==b&&(m=m.transition(l),x=x.transition(l),A=A.transition(l),T=T.transition(l),w=w.transition(l).attr("opacity",U).attr("transform",function(t){return isFinite(t=_(t))?s(t):this.getAttribute("transform")}),M.attr("opacity",U).attr("transform",function(t){var n=this.parentNode.__axis;return s(n&&isFinite(n=n(t))?n:_(t))})),w.remove(),m.attr("d",t===D||t==R?a?"M"+f*a+","+g+"H0.5V"+y+"H"+f*a:"M0.5,"+g+"V"+y:a?"M"+g+","+f*a+"V0.5H"+y+"V"+f*a:"M"+g+",0.5H"+y),x.attr("opacity",1).attr("transform",function(t){return s(_(t))}),A.attr(c+"2",f*o),T.attr(c,f*p).text(d),b.filter(Y).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",t===R?"start":t===D?"end":"middle"),b.each(function(){this.__axis=_})}return l.scale=function(t){return arguments.length?(n=t,l):n},l.ticks=function(){return e=C.call(arguments),l},l.tickArguments=function(t){return arguments.length?(e=null==t?[]:C.call(t),l):e.slice()},l.tickValues=function(t){return arguments.length?(r=null==t?null:C.call(t),l):r&&r.slice()},l.tickFormat=function(t){return arguments.length?(i=t,l):i},l.tickSize=function(t){return arguments.length?(o=a=+t,l):o},l.tickSizeInner=function(t){return arguments.length?(o=+t,l):o},l.tickSizeOuter=function(t){return arguments.length?(a=+t,l):a},l.tickPadding=function(t){return arguments.length?(u=+t,l):u},l}var F={value:function(){}};function I(){for(var t,n=0,e=arguments.length,r={};n<e;++n){if(!(t=arguments[n]+"")||t in r)throw new Error("illegal type: "+t);r[t]=[]}return new H(r)}function H(t){this._=t}function j(t,n){for(var e,r=0,i=t.length;r<i;++r)if((e=t[r]).name===n)return e.value}function X(t,n,e){for(var r=0,i=t.length;r<i;++r)if(t[r].name===n){t[r]=F,t=t.slice(0,r).concat(t.slice(r+1));break}return null!=e&&t.push({name:n,value:e}),t}H.prototype=I.prototype={constructor:H,on:function(t,n){var e,r,i=this._,o=(r=i,(t+"").trim().split(/^|\s+/).map(function(t){var n="",e=t.indexOf(".");if(e>=0&&(n=t.slice(e+1),t=t.slice(0,e)),t&&!r.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:n}})),a=-1,u=o.length;if(!(arguments.length<2)){if(null!=n&&"function"!=typeof n)throw new Error("invalid callback: "+n);for(;++a<u;)if(e=(t=o[a]).type)i[e]=X(i[e],t.name,n);else if(null==n)for(e in i)i[e]=X(i[e],t.name,null);return this}for(;++a<u;)if((e=(t=o[a]).type)&&(e=j(i[e],t.name)))return e},copy:function(){var t={},n=this._;for(var e in n)t[e]=n[e].slice();return new H(t)},call:function(t,n){if((e=arguments.length-2)>0)for(var e,r,i=new Array(e),o=0;o<e;++o)i[o]=arguments[o+2];if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(o=0,e=(r=this._[t]).length;o<e;++o)r[o].value.apply(n,i)},apply:function(t,n,e){if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(var r=this._[t],i=0,o=r.length;i<o;++i)r[i].value.apply(n,e)}};var G="http://www.w3.org/1999/xhtml",V={svg:"http://www.w3.org/2000/svg",xhtml:G,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function $(t){var n=t+="",e=n.indexOf(":");return e>=0&&"xmlns"!==(n=t.slice(0,e))&&(t=t.slice(e+1)),V.hasOwnProperty(n)?{space:V[n],local:t}:t}function W(t){var n=$(t);return(n.local?function(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}:function(t){return function(){var n=this.ownerDocument,e=this.namespaceURI;return e===G&&n.documentElement.namespaceURI===G?n.createElement(t):n.createElementNS(e,t)}})(n)}function Z(){}function Q(t){return null==t?Z:function(){return this.querySelector(t)}}function J(){return[]}function K(t){return null==t?J:function(){return this.querySelectorAll(t)}}var tt=function(t){return function(){return this.matches(t)}};if("undefined"!=typeof document){var nt=document.documentElement;if(!nt.matches){var et=nt.webkitMatchesSelector||nt.msMatchesSelector||nt.mozMatchesSelector||nt.oMatchesSelector;tt=function(t){return function(){return et.call(this,t)}}}}var rt=tt;function it(t){return new Array(t.length)}function ot(t,n){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=n}ot.prototype={constructor:ot,appendChild:function(t){return this._parent.insertBefore(t,this._next)},insertBefore:function(t,n){return this._parent.insertBefore(t,n)},querySelector:function(t){return this._parent.querySelector(t)},querySelectorAll:function(t){return this._parent.querySelectorAll(t)}};var at="$";function ut(t,n,e,r,i,o){for(var a,u=0,f=n.length,c=o.length;u<c;++u)(a=n[u])?(a.__data__=o[u],r[u]=a):e[u]=new ot(t,o[u]);for(;u<f;++u)(a=n[u])&&(i[u]=a)}function ft(t,n,e,r,i,o,a){var u,f,c,s={},l=n.length,h=o.length,d=new Array(l);for(u=0;u<l;++u)(f=n[u])&&(d[u]=c=at+a.call(f,f.__data__,u,n),c in s?i[u]=f:s[c]=f);for(u=0;u<h;++u)(f=s[c=at+a.call(t,o[u],u,o)])?(r[u]=f,f.__data__=o[u],s[c]=null):e[u]=new ot(t,o[u]);for(u=0;u<l;++u)(f=n[u])&&s[d[u]]===f&&(i[u]=f)}function ct(t,n){return t<n?-1:t>n?1:t>=n?0:NaN}function st(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function lt(t,n){return t.style.getPropertyValue(n)||st(t).getComputedStyle(t,null).getPropertyValue(n)}function ht(t){return t.trim().split(/^|\s+/)}function dt(t){return t.classList||new pt(t)}function pt(t){this._node=t,this._names=ht(t.getAttribute("class")||"")}function vt(t,n){for(var e=dt(t),r=-1,i=n.length;++r<i;)e.add(n[r])}function gt(t,n){for(var e=dt(t),r=-1,i=n.length;++r<i;)e.remove(n[r])}function yt(){this.textContent=""}function _t(){this.innerHTML=""}function bt(){this.nextSibling&&this.parentNode.appendChild(this)}function mt(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function xt(){return null}function wt(){var t=this.parentNode;t&&t.removeChild(this)}function Mt(){return this.parentNode.insertBefore(this.cloneNode(!1),this.nextSibling)}function At(){return this.parentNode.insertBefore(this.cloneNode(!0),this.nextSibling)}pt.prototype={add:function(t){this._names.indexOf(t)<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var n=this._names.indexOf(t);n>=0&&(this._names.splice(n,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var Tt={};(t.event=null,"undefined"!=typeof document)&&("onmouseenter"in document.documentElement||(Tt={mouseenter:"mouseover",mouseleave:"mouseout"}));function Nt(t,n,e){return t=St(t,n,e),function(n){var e=n.relatedTarget;e&&(e===this||8&e.compareDocumentPosition(this))||t.call(this,n)}}function St(n,e,r){return function(i){var o=t.event;t.event=i;try{n.call(this,this.__data__,e,r)}finally{t.event=o}}}function Et(t){return function(){var n=this.__on;if(n){for(var e,r=0,i=-1,o=n.length;r<o;++r)e=n[r],t.type&&e.type!==t.type||e.name!==t.name?n[++i]=e:this.removeEventListener(e.type,e.listener,e.capture);++i?n.length=i:delete this.__on}}}function kt(t,n,e){var r=Tt.hasOwnProperty(t.type)?Nt:St;return function(i,o,a){var u,f=this.__on,c=r(n,o,a);if(f)for(var s=0,l=f.length;s<l;++s)if((u=f[s]).type===t.type&&u.name===t.name)return this.removeEventListener(u.type,u.listener,u.capture),this.addEventListener(u.type,u.listener=c,u.capture=e),void(u.value=n);this.addEventListener(t.type,c,e),u={type:t.type,name:t.name,value:n,listener:c,capture:e},f?f.push(u):this.__on=[u]}}function Ct(n,e,r,i){var o=t.event;n.sourceEvent=t.event,t.event=n;try{return e.apply(r,i)}finally{t.event=o}}function Pt(t,n,e){var r=st(t),i=r.CustomEvent;"function"==typeof i?i=new i(n,e):(i=r.document.createEvent("Event"),e?(i.initEvent(n,e.bubbles,e.cancelable),i.detail=e.detail):i.initEvent(n,!1,!1)),t.dispatchEvent(i)}var zt=[null];function Rt(t,n){this._groups=t,this._parents=n}function Lt(){return new Rt([[document.documentElement]],zt)}function Dt(t){return"string"==typeof t?new Rt([[document.querySelector(t)]],[document.documentElement]):new Rt([[t]],zt)}Rt.prototype=Lt.prototype={constructor:Rt,select:function(t){"function"!=typeof t&&(t=Q(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i<e;++i)for(var o,a,u=n[i],f=u.length,c=r[i]=new Array(f),s=0;s<f;++s)(o=u[s])&&(a=t.call(o,o.__data__,s,u))&&("__data__"in o&&(a.__data__=o.__data__),c[s]=a);return new Rt(r,this._parents)},selectAll:function(t){"function"!=typeof t&&(t=K(t));for(var n=this._groups,e=n.length,r=[],i=[],o=0;o<e;++o)for(var a,u=n[o],f=u.length,c=0;c<f;++c)(a=u[c])&&(r.push(t.call(a,a.__data__,c,u)),i.push(a));return new Rt(r,i)},filter:function(t){"function"!=typeof t&&(t=rt(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i<e;++i)for(var o,a=n[i],u=a.length,f=r[i]=[],c=0;c<u;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&f.push(o);return new Rt(r,this._parents)},data:function(t,n){if(!t)return p=new Array(this.size()),s=-1,this.each(function(t){p[++s]=t}),p;var e,r=n?ft:ut,i=this._parents,o=this._groups;"function"!=typeof t&&(e=t,t=function(){return e});for(var a=o.length,u=new Array(a),f=new Array(a),c=new Array(a),s=0;s<a;++s){var l=i[s],h=o[s],d=h.length,p=t.call(l,l&&l.__data__,s,i),v=p.length,g=f[s]=new Array(v),y=u[s]=new Array(v);r(l,h,g,y,c[s]=new Array(d),p,n);for(var _,b,m=0,x=0;m<v;++m)if(_=g[m]){for(m>=x&&(x=m+1);!(b=y[x])&&++x<v;);_._next=b||null}}return(u=new Rt(u,i))._enter=f,u._exit=c,u},enter:function(){return new Rt(this._enter||this._groups.map(it),this._parents)},exit:function(){return new Rt(this._exit||this._groups.map(it),this._parents)},merge:function(t){for(var n=this._groups,e=t._groups,r=n.length,i=e.length,o=Math.min(r,i),a=new Array(r),u=0;u<o;++u)for(var f,c=n[u],s=e[u],l=c.length,h=a[u]=new Array(l),d=0;d<l;++d)(f=c[d]||s[d])&&(h[d]=f);for(;u<r;++u)a[u]=n[u];return new Rt(a,this._parents)},order:function(){for(var t=this._groups,n=-1,e=t.length;++n<e;)for(var r,i=t[n],o=i.length-1,a=i[o];--o>=0;)(r=i[o])&&(a&&a!==r.nextSibling&&a.parentNode.insertBefore(r,a),a=r);return this},sort:function(t){function n(n,e){return n&&e?t(n.__data__,e.__data__):!n-!e}t||(t=ct);for(var e=this._groups,r=e.length,i=new Array(r),o=0;o<r;++o){for(var a,u=e[o],f=u.length,c=i[o]=new Array(f),s=0;s<f;++s)(a=u[s])&&(c[s]=a);c.sort(n)}return new Rt(i,this._parents).order()},call:function(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this},nodes:function(){var t=new Array(this.size()),n=-1;return this.each(function(){t[++n]=this}),t},node:function(){for(var t=this._groups,n=0,e=t.length;n<e;++n)for(var r=t[n],i=0,o=r.length;i<o;++i){var a=r[i];if(a)return a}return null},size:function(){var t=0;return this.each(function(){++t}),t},empty:function(){return!this.node()},each:function(t){for(var n=this._groups,e=0,r=n.length;e<r;++e)for(var i,o=n[e],a=0,u=o.length;a<u;++a)(i=o[a])&&t.call(i,i.__data__,a,o);return this},attr:function(t,n){var e=$(t);if(arguments.length<2){var r=this.node();return e.local?r.getAttributeNS(e.space,e.local):r.getAttribute(e)}return this.each((null==n?e.local?function(t){return function(){this.removeAttributeNS(t.space,t.local)}}:function(t){return function(){this.removeAttribute(t)}}:"function"==typeof n?e.local?function(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,e)}}:function(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttribute(t):this.setAttribute(t,e)}}:e.local?function(t,n){return function(){this.setAttributeNS(t.space,t.local,n)}}:function(t,n){return function(){this.setAttribute(t,n)}})(e,n))},style:function(t,n,e){return arguments.length>1?this.each((null==n?function(t){return function(){this.style.removeProperty(t)}}:"function"==typeof n?function(t,n,e){return function(){var r=n.apply(this,arguments);null==r?this.style.removeProperty(t):this.style.setProperty(t,r,e)}}:function(t,n,e){return function(){this.style.setProperty(t,n,e)}})(t,n,null==e?"":e)):lt(this.node(),t)},property:function(t,n){return arguments.length>1?this.each((null==n?function(t){return function(){delete this[t]}}:"function"==typeof n?function(t,n){return function(){var e=n.apply(this,arguments);null==e?delete this[t]:this[t]=e}}:function(t,n){return function(){this[t]=n}})(t,n)):this.node()[t]},classed:function(t,n){var e=ht(t+"");if(arguments.length<2){for(var r=dt(this.node()),i=-1,o=e.length;++i<o;)if(!r.contains(e[i]))return!1;return!0}return this.each(("function"==typeof n?function(t,n){return function(){(n.apply(this,arguments)?vt:gt)(this,t)}}:n?function(t){return function(){vt(this,t)}}:function(t){return function(){gt(this,t)}})(e,n))},text:function(t){return arguments.length?this.each(null==t?yt:("function"==typeof t?function(t){return function(){var n=t.apply(this,arguments);this.textContent=null==n?"":n}}:function(t){return function(){this.textContent=t}})(t)):this.node().textContent},html:function(t){return arguments.length?this.each(null==t?_t:("function"==typeof t?function(t){return function(){var n=t.apply(this,arguments);this.innerHTML=null==n?"":n}}:function(t){return function(){this.innerHTML=t}})(t)):this.node().innerHTML},raise:function(){return this.each(bt)},lower:function(){return this.each(mt)},append:function(t){var n="function"==typeof t?t:W(t);return this.select(function(){return this.appendChild(n.apply(this,arguments))})},insert:function(t,n){var e="function"==typeof t?t:W(t),r=null==n?xt:"function"==typeof n?n:Q(n);return this.select(function(){return this.insertBefore(e.apply(this,arguments),r.apply(this,arguments)||null)})},remove:function(){return this.each(wt)},clone:function(t){return this.select(t?At:Mt)},datum:function(t){return arguments.length?this.property("__data__",t):this.node().__data__},on:function(t,n,e){var r,i,o=function(t){return t.trim().split(/^|\s+/).map(function(t){var n="",e=t.indexOf(".");return e>=0&&(n=t.slice(e+1),t=t.slice(0,e)),{type:t,name:n}})}(t+""),a=o.length;if(!(arguments.length<2)){for(u=n?kt:Et,null==e&&(e=!1),r=0;r<a;++r)this.each(u(o[r],n,e));return this}var u=this.node().__on;if(u)for(var f,c=0,s=u.length;c<s;++c)for(r=0,f=u[c];r<a;++r)if((i=o[r]).type===f.type&&i.name===f.name)return f.value},dispatch:function(t,n){return this.each(("function"==typeof n?function(t,n){return function(){return Pt(this,t,n.apply(this,arguments))}}:function(t,n){return function(){return Pt(this,t,n)}})(t,n))}};var Ut=0;function qt(){return new Ot}function Ot(){this._="@"+(++Ut).toString(36)}function Yt(){for(var n,e=t.event;n=e.sourceEvent;)e=n;return e}function Bt(t,n){var e=t.ownerSVGElement||t;if(e.createSVGPoint){var r=e.createSVGPoint();return r.x=n.clientX,r.y=n.clientY,[(r=r.matrixTransform(t.getScreenCTM().inverse())).x,r.y]}var i=t.getBoundingClientRect();return[n.clientX-i.left-t.clientLeft,n.clientY-i.top-t.clientTop]}function Ft(t){var n=Yt();return n.changedTouches&&(n=n.changedTouches[0]),Bt(t,n)}function It(t,n,e){arguments.length<3&&(e=n,n=Yt().changedTouches);for(var r,i=0,o=n?n.length:0;i<o;++i)if((r=n[i]).identifier===e)return Bt(t,r);return null}function Ht(){t.event.stopImmediatePropagation()}function jt(){t.event.preventDefault(),t.event.stopImmediatePropagation()}function Xt(t){var n=t.document.documentElement,e=Dt(t).on("dragstart.drag",jt,!0);"onselectstart"in n?e.on("selectstart.drag",jt,!0):(n.__noselect=n.style.MozUserSelect,n.style.MozUserSelect="none")}function Gt(t,n){var e=t.document.documentElement,r=Dt(t).on("dragstart.drag",null);n&&(r.on("click.drag",jt,!0),setTimeout(function(){r.on("click.drag",null)},0)),"onselectstart"in e?r.on("selectstart.drag",null):(e.style.MozUserSelect=e.__noselect,delete e.__noselect)}function Vt(t){return function(){return t}}function $t(t,n,e,r,i,o,a,u,f,c){this.target=t,this.type=n,this.subject=e,this.identifier=r,this.active=i,this.x=o,this.y=a,this.dx=u,this.dy=f,this._=c}function Wt(){return!t.event.button}function Zt(){return this.parentNode}function Qt(n){return null==n?{x:t.event.x,y:t.event.y}:n}function Jt(){return"ontouchstart"in this}function Kt(t,n,e){t.prototype=n.prototype=e,e.constructor=t}function tn(t,n){var e=Object.create(t.prototype);for(var r in n)e[r]=n[r];return e}function nn(){}Ot.prototype=qt.prototype={constructor:Ot,get:function(t){for(var n=this._;!(n in t);)if(!(t=t.parentNode))return;return t[n]},set:function(t,n){return t[this._]=n},remove:function(t){return this._ in t&&delete t[this._]},toString:function(){return this._}},$t.prototype.on=function(){var t=this._.on.apply(this._,arguments);return t===this._?this:t};var en="\\s*([+-]?\\d+)\\s*",rn="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",on="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",an=/^#([0-9a-f]{3})$/,un=/^#([0-9a-f]{6})$/,fn=new RegExp("^rgb\\("+[en,en,en]+"\\)$"),cn=new RegExp("^rgb\\("+[on,on,on]+"\\)$"),sn=new RegExp("^rgba\\("+[en,en,en,rn]+"\\)$"),ln=new RegExp("^rgba\\("+[on,on,on,rn]+"\\)$"),hn=new RegExp("^hsl\\("+[rn,on,on]+"\\)$"),dn=new RegExp("^hsla\\("+[rn,on,on,rn]+"\\)$"),pn={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 vn(t){var n;return t=(t+"").trim().toLowerCase(),(n=an.exec(t))?new mn((n=parseInt(n[1],16))>>8&15|n>>4&240,n>>4&15|240&n,(15&n)<<4|15&n,1):(n=un.exec(t))?gn(parseInt(n[1],16)):(n=fn.exec(t))?new mn(n[1],n[2],n[3],1):(n=cn.exec(t))?new mn(255*n[1]/100,255*n[2]/100,255*n[3]/100,1):(n=sn.exec(t))?yn(n[1],n[2],n[3],n[4]):(n=ln.exec(t))?yn(255*n[1]/100,255*n[2]/100,255*n[3]/100,n[4]):(n=hn.exec(t))?wn(n[1],n[2]/100,n[3]/100,1):(n=dn.exec(t))?wn(n[1],n[2]/100,n[3]/100,n[4]):pn.hasOwnProperty(t)?gn(pn[t]):"transparent"===t?new mn(NaN,NaN,NaN,0):null}function gn(t){return new mn(t>>16&255,t>>8&255,255&t,1)}function yn(t,n,e,r){return r<=0&&(t=n=e=NaN),new mn(t,n,e,r)}function _n(t){return t instanceof nn||(t=vn(t)),t?new mn((t=t.rgb()).r,t.g,t.b,t.opacity):new mn}function bn(t,n,e,r){return 1===arguments.length?_n(t):new mn(t,n,e,null==r?1:r)}function mn(t,n,e,r){this.r=+t,this.g=+n,this.b=+e,this.opacity=+r}function xn(t){return((t=Math.max(0,Math.min(255,Math.round(t)||0)))<16?"0":"")+t.toString(16)}function wn(t,n,e,r){return r<=0?t=n=e=NaN:e<=0||e>=1?t=n=NaN:n<=0&&(t=NaN),new An(t,n,e,r)}function Mn(t,n,e,r){return 1===arguments.length?function(t){if(t instanceof An)return new An(t.h,t.s,t.l,t.opacity);if(t instanceof nn||(t=vn(t)),!t)return new An;if(t instanceof An)return t;var n=(t=t.rgb()).r/255,e=t.g/255,r=t.b/255,i=Math.min(n,e,r),o=Math.max(n,e,r),a=NaN,u=o-i,f=(o+i)/2;return u?(a=n===o?(e-r)/u+6*(e<r):e===o?(r-n)/u+2:(n-e)/u+4,u/=f<.5?o+i:2-o-i,a*=60):u=f>0&&f<1?0:a,new An(a,u,f,t.opacity)}(t):new An(t,n,e,null==r?1:r)}function An(t,n,e,r){this.h=+t,this.s=+n,this.l=+e,this.opacity=+r}function Tn(t,n,e){return 255*(t<60?n+(e-n)*t/60:t<180?e:t<240?n+(e-n)*(240-t)/60:n)}Kt(nn,vn,{displayable:function(){return this.rgb().displayable()},hex:function(){return this.rgb().hex()},toString:function(){return this.rgb()+""}}),Kt(mn,bn,tn(nn,{brighter:function(t){return t=null==t?1/.7:Math.pow(1/.7,t),new mn(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?.7:Math.pow(.7,t),new mn(this.r*t,this.g*t,this.b*t,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},hex:function(){return"#"+xn(this.r)+xn(this.g)+xn(this.b)},toString:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"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===t?")":", "+t+")")}})),Kt(An,Mn,tn(nn,{brighter:function(t){return t=null==t?1/.7:Math.pow(1/.7,t),new An(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?.7:Math.pow(.7,t),new An(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),n=isNaN(t)||isNaN(this.s)?0:this.s,e=this.l,r=e+(e<.5?e:1-e)*n,i=2*e-r;return new mn(Tn(t>=240?t-240:t+120,i,r),Tn(t,i,r),Tn(t<120?t+240:t-120,i,r),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 Nn=Math.PI/180,Sn=180/Math.PI,En=.96422,kn=1,Cn=.82521,Pn=4/29,zn=6/29,Rn=3*zn*zn,Ln=zn*zn*zn;function Dn(t){if(t instanceof qn)return new qn(t.l,t.a,t.b,t.opacity);if(t instanceof jn){if(isNaN(t.h))return new qn(t.l,0,0,t.opacity);var n=t.h*Nn;return new qn(t.l,Math.cos(n)*t.c,Math.sin(n)*t.c,t.opacity)}t instanceof mn||(t=_n(t));var e,r,i=Fn(t.r),o=Fn(t.g),a=Fn(t.b),u=On((.2225045*i+.7168786*o+.0606169*a)/kn);return i===o&&o===a?e=r=u:(e=On((.4360747*i+.3850649*o+.1430804*a)/En),r=On((.0139322*i+.0971045*o+.7141733*a)/Cn)),new qn(116*u-16,500*(e-u),200*(u-r),t.opacity)}function Un(t,n,e,r){return 1===arguments.length?Dn(t):new qn(t,n,e,null==r?1:r)}function qn(t,n,e,r){this.l=+t,this.a=+n,this.b=+e,this.opacity=+r}function On(t){return t>Ln?Math.pow(t,1/3):t/Rn+Pn}function Yn(t){return t>zn?t*t*t:Rn*(t-Pn)}function Bn(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function Fn(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function In(t){if(t instanceof jn)return new jn(t.h,t.c,t.l,t.opacity);if(t instanceof qn||(t=Dn(t)),0===t.a&&0===t.b)return new jn(NaN,0,t.l,t.opacity);var n=Math.atan2(t.b,t.a)*Sn;return new jn(n<0?n+360:n,Math.sqrt(t.a*t.a+t.b*t.b),t.l,t.opacity)}function Hn(t,n,e,r){return 1===arguments.length?In(t):new jn(t,n,e,null==r?1:r)}function jn(t,n,e,r){this.h=+t,this.c=+n,this.l=+e,this.opacity=+r}Kt(qn,Un,tn(nn,{brighter:function(t){return new qn(this.l+18*(null==t?1:t),this.a,this.b,this.opacity)},darker:function(t){return new qn(this.l-18*(null==t?1:t),this.a,this.b,this.opacity)},rgb:function(){var t=(this.l+16)/116,n=isNaN(this.a)?t:t+this.a/500,e=isNaN(this.b)?t:t-this.b/200;return new mn(Bn(3.1338561*(n=En*Yn(n))-1.6168667*(t=kn*Yn(t))-.4906146*(e=Cn*Yn(e))),Bn(-.9787684*n+1.9161415*t+.033454*e),Bn(.0719453*n-.2289914*t+1.4052427*e),this.opacity)}})),Kt(jn,Hn,tn(nn,{brighter:function(t){return new jn(this.h,this.c,this.l+18*(null==t?1:t),this.opacity)},darker:function(t){return new jn(this.h,this.c,this.l-18*(null==t?1:t),this.opacity)},rgb:function(){return Dn(this).rgb()}}));var Xn=-.14861,Gn=1.78277,Vn=-.29227,$n=-.90649,Wn=1.97294,Zn=Wn*$n,Qn=Wn*Gn,Jn=Gn*Vn-$n*Xn;function Kn(t,n,e,r){return 1===arguments.length?function(t){if(t instanceof te)return new te(t.h,t.s,t.l,t.opacity);t instanceof mn||(t=_n(t));var n=t.r/255,e=t.g/255,r=t.b/255,i=(Jn*r+Zn*n-Qn*e)/(Jn+Zn-Qn),o=r-i,a=(Wn*(e-i)-Vn*o)/$n,u=Math.sqrt(a*a+o*o)/(Wn*i*(1-i)),f=u?Math.atan2(a,o)*Sn-120:NaN;return new te(f<0?f+360:f,u,i,t.opacity)}(t):new te(t,n,e,null==r?1:r)}function te(t,n,e,r){this.h=+t,this.s=+n,this.l=+e,this.opacity=+r}function ne(t,n,e,r,i){var o=t*t,a=o*t;return((1-3*t+3*o-a)*n+(4-6*o+3*a)*e+(1+3*t+3*o-3*a)*r+a*i)/6}function ee(t){var n=t.length-1;return function(e){var r=e<=0?e=0:e>=1?(e=1,n-1):Math.floor(e*n),i=t[r],o=t[r+1],a=r>0?t[r-1]:2*i-o,u=r<n-1?t[r+2]:2*o-i;return ne((e-r/n)*n,a,i,o,u)}}function re(t){var n=t.length;return function(e){var r=Math.floor(((e%=1)<0?++e:e)*n),i=t[(r+n-1)%n],o=t[r%n],a=t[(r+1)%n],u=t[(r+2)%n];return ne((e-r/n)*n,i,o,a,u)}}function ie(t){return function(){return t}}function oe(t,n){return function(e){return t+e*n}}function ae(t,n){var e=n-t;return e?oe(t,e>180||e<-180?e-360*Math.round(e/360):e):ie(isNaN(t)?n:t)}function ue(t){return 1==(t=+t)?fe:function(n,e){return e-n?function(t,n,e){return t=Math.pow(t,e),n=Math.pow(n,e)-t,e=1/e,function(r){return Math.pow(t+r*n,e)}}(n,e,t):ie(isNaN(n)?e:n)}}function fe(t,n){var e=n-t;return e?oe(t,e):ie(isNaN(t)?n:t)}Kt(te,Kn,tn(nn,{brighter:function(t){return t=null==t?1/.7:Math.pow(1/.7,t),new te(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?.7:Math.pow(.7,t),new te(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=isNaN(this.h)?0:(this.h+120)*Nn,n=+this.l,e=isNaN(this.s)?0:this.s*n*(1-n),r=Math.cos(t),i=Math.sin(t);return new mn(255*(n+e*(Xn*r+Gn*i)),255*(n+e*(Vn*r+$n*i)),255*(n+e*(Wn*r)),this.opacity)}}));var ce=function t(n){var e=ue(n);function r(t,n){var r=e((t=bn(t)).r,(n=bn(n)).r),i=e(t.g,n.g),o=e(t.b,n.b),a=fe(t.opacity,n.opacity);return function(n){return t.r=r(n),t.g=i(n),t.b=o(n),t.opacity=a(n),t+""}}return r.gamma=t,r}(1);function se(t){return function(n){var e,r,i=n.length,o=new Array(i),a=new Array(i),u=new Array(i);for(e=0;e<i;++e)r=bn(n[e]),o[e]=r.r||0,a[e]=r.g||0,u[e]=r.b||0;return o=t(o),a=t(a),u=t(u),r.opacity=1,function(t){return r.r=o(t),r.g=a(t),r.b=u(t),r+""}}}var le=se(ee),he=se(re);function de(t,n){var e,r=n?n.length:0,i=t?Math.min(r,t.length):0,o=new Array(i),a=new Array(r);for(e=0;e<i;++e)o[e]=me(t[e],n[e]);for(;e<r;++e)a[e]=n[e];return function(t){for(e=0;e<i;++e)a[e]=o[e](t);return a}}function pe(t,n){var e=new Date;return n-=t=+t,function(r){return e.setTime(t+n*r),e}}function ve(t,n){return n-=t=+t,function(e){return t+n*e}}function ge(t,n){var e,r={},i={};for(e in null!==t&&"object"==typeof t||(t={}),null!==n&&"object"==typeof n||(n={}),n)e in t?r[e]=me(t[e],n[e]):i[e]=n[e];return function(t){for(e in r)i[e]=r[e](t);return i}}var ye=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,_e=new RegExp(ye.source,"g");function be(t,n){var e,r,i,o=ye.lastIndex=_e.lastIndex=0,a=-1,u=[],f=[];for(t+="",n+="";(e=ye.exec(t))&&(r=_e.exec(n));)(i=r.index)>o&&(i=n.slice(o,i),u[a]?u[a]+=i:u[++a]=i),(e=e[0])===(r=r[0])?u[a]?u[a]+=r:u[++a]=r:(u[++a]=null,f.push({i:a,x:ve(e,r)})),o=_e.lastIndex;return o<n.length&&(i=n.slice(o),u[a]?u[a]+=i:u[++a]=i),u.length<2?f[0]?function(t){return function(n){return t(n)+""}}(f[0].x):function(t){return function(){return t}}(n):(n=f.length,function(t){for(var e,r=0;r<n;++r)u[(e=f[r]).i]=e.x(t);return u.join("")})}function me(t,n){var e,r=typeof n;return null==n||"boolean"===r?ie(n):("number"===r?ve:"string"===r?(e=vn(n))?(n=e,ce):be:n instanceof vn?ce:n instanceof Date?pe:Array.isArray(n)?de:"function"!=typeof n.valueOf&&"function"!=typeof n.toString||isNaN(n)?ge:ve)(t,n)}function xe(t,n){return n-=t=+t,function(e){return Math.round(t+n*e)}}var we,Me,Ae,Te,Ne=180/Math.PI,Se={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function Ee(t,n,e,r,i,o){var a,u,f;return(a=Math.sqrt(t*t+n*n))&&(t/=a,n/=a),(f=t*e+n*r)&&(e-=t*f,r-=n*f),(u=Math.sqrt(e*e+r*r))&&(e/=u,r/=u,f/=u),t*r<n*e&&(t=-t,n=-n,f=-f,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(n,t)*Ne,skewX:Math.atan(f)*Ne,scaleX:a,scaleY:u}}function ke(t,n,e,r){function i(t){return t.length?t.pop()+" ":""}return function(o,a){var u=[],f=[];return o=t(o),a=t(a),function(t,r,i,o,a,u){if(t!==i||r!==o){var f=a.push("translate(",null,n,null,e);u.push({i:f-4,x:ve(t,i)},{i:f-2,x:ve(r,o)})}else(i||o)&&a.push("translate("+i+n+o+e)}(o.translateX,o.translateY,a.translateX,a.translateY,u,f),function(t,n,e,o){t!==n?(t-n>180?n+=360:n-t>180&&(t+=360),o.push({i:e.push(i(e)+"rotate(",null,r)-2,x:ve(t,n)})):n&&e.push(i(e)+"rotate("+n+r)}(o.rotate,a.rotate,u,f),function(t,n,e,o){t!==n?o.push({i:e.push(i(e)+"skewX(",null,r)-2,x:ve(t,n)}):n&&e.push(i(e)+"skewX("+n+r)}(o.skewX,a.skewX,u,f),function(t,n,e,r,o,a){if(t!==e||n!==r){var u=o.push(i(o)+"scale(",null,",",null,")");a.push({i:u-4,x:ve(t,e)},{i:u-2,x:ve(n,r)})}else 1===e&&1===r||o.push(i(o)+"scale("+e+","+r+")")}(o.scaleX,o.scaleY,a.scaleX,a.scaleY,u,f),o=a=null,function(t){for(var n,e=-1,r=f.length;++e<r;)u[(n=f[e]).i]=n.x(t);return u.join("")}}}var Ce=ke(function(t){return"none"===t?Se:(we||(we=document.createElement("DIV"),Me=document.documentElement,Ae=document.defaultView),we.style.transform=t,t=Ae.getComputedStyle(Me.appendChild(we),null).getPropertyValue("transform"),Me.removeChild(we),Ee(+(t=t.slice(7,-1).split(","))[0],+t[1],+t[2],+t[3],+t[4],+t[5]))},"px, ","px)","deg)"),Pe=ke(function(t){return null==t?Se:(Te||(Te=document.createElementNS("http://www.w3.org/2000/svg","g")),Te.setAttribute("transform",t),(t=Te.transform.baseVal.consolidate())?Ee((t=t.matrix).a,t.b,t.c,t.d,t.e,t.f):Se)},", ",")",")"),ze=Math.SQRT2,Re=2,Le=4,De=1e-12;function Ue(t){return((t=Math.exp(t))+1/t)/2}function qe(t,n){var e,r,i=t[0],o=t[1],a=t[2],u=n[0],f=n[1],c=n[2],s=u-i,l=f-o,h=s*s+l*l;if(h<De)r=Math.log(c/a)/ze,e=function(t){return[i+t*s,o+t*l,a*Math.exp(ze*t*r)]};else{var d=Math.sqrt(h),p=(c*c-a*a+Le*h)/(2*a*Re*d),v=(c*c-a*a-Le*h)/(2*c*Re*d),g=Math.log(Math.sqrt(p*p+1)-p),y=Math.log(Math.sqrt(v*v+1)-v);r=(y-g)/ze,e=function(t){var n,e=t*r,u=Ue(g),f=a/(Re*d)*(u*(n=ze*e+g,((n=Math.exp(2*n))-1)/(n+1))-function(t){return((t=Math.exp(t))-1/t)/2}(g));return[i+f*s,o+f*l,a*u/Ue(ze*e+g)]}}return e.duration=1e3*r,e}function Oe(t){return function(n,e){var r=t((n=Mn(n)).h,(e=Mn(e)).h),i=fe(n.s,e.s),o=fe(n.l,e.l),a=fe(n.opacity,e.opacity);return function(t){return n.h=r(t),n.s=i(t),n.l=o(t),n.opacity=a(t),n+""}}}var Ye=Oe(ae),Be=Oe(fe);function Fe(t){return function(n,e){var r=t((n=Hn(n)).h,(e=Hn(e)).h),i=fe(n.c,e.c),o=fe(n.l,e.l),a=fe(n.opacity,e.opacity);return function(t){return n.h=r(t),n.c=i(t),n.l=o(t),n.opacity=a(t),n+""}}}var Ie=Fe(ae),He=Fe(fe);function je(t){return function n(e){function r(n,r){var i=t((n=Kn(n)).h,(r=Kn(r)).h),o=fe(n.s,r.s),a=fe(n.l,r.l),u=fe(n.opacity,r.opacity);return function(t){return n.h=i(t),n.s=o(t),n.l=a(Math.pow(t,e)),n.opacity=u(t),n+""}}return e=+e,r.gamma=n,r}(1)}var Xe=je(ae),Ge=je(fe);var Ve,$e,We=0,Ze=0,Qe=0,Je=1e3,Ke=0,tr=0,nr=0,er="object"==typeof performance&&performance.now?performance:Date,rr="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(t){setTimeout(t,17)};function ir(){return tr||(rr(or),tr=er.now()+nr)}function or(){tr=0}function ar(){this._call=this._time=this._next=null}function ur(t,n,e){var r=new ar;return r.restart(t,n,e),r}function fr(){ir(),++We;for(var t,n=Ve;n;)(t=tr-n._time)>=0&&n._call.call(null,t),n=n._next;--We}function cr(){tr=(Ke=er.now())+nr,We=Ze=0;try{fr()}finally{We=0,function(){var t,n,e=Ve,r=1/0;for(;e;)e._call?(r>e._time&&(r=e._time),t=e,e=e._next):(n=e._next,e._next=null,e=t?t._next=n:Ve=n);$e=t,lr(r)}(),tr=0}}function sr(){var t=er.now(),n=t-Ke;n>Je&&(nr-=n,Ke=t)}function lr(t){We||(Ze&&(Ze=clearTimeout(Ze)),t-tr>24?(t<1/0&&(Ze=setTimeout(cr,t-er.now()-nr)),Qe&&(Qe=clearInterval(Qe))):(Qe||(Ke=er.now(),Qe=setInterval(sr,Je)),We=1,rr(cr)))}function hr(t,n,e){var r=new ar;return n=null==n?0:+n,r.restart(function(e){r.stop(),t(e+n)},n,e),r}ar.prototype=ur.prototype={constructor:ar,restart:function(t,n,e){if("function"!=typeof t)throw new TypeError("callback is not a function");e=(null==e?ir():+e)+(null==n?0:+n),this._next||$e===this||($e?$e._next=this:Ve=this,$e=this),this._call=t,this._time=e,lr()},stop:function(){this._call&&(this._call=null,this._time=1/0,lr())}};var dr=I("start","end","interrupt"),pr=[],vr=0,gr=1,yr=2,_r=3,br=4,mr=5,xr=6;function wr(t,n,e,r,i,o){var a=t.__transition;if(a){if(e in a)return}else t.__transition={};!function(t,n,e){var r,i=t.__transition;function o(f){var c,s,l,h;if(e.state!==gr)return u();for(c in i)if((h=i[c]).name===e.name){if(h.state===_r)return hr(o);h.state===br?(h.state=xr,h.timer.stop(),h.on.call("interrupt",t,t.__data__,h.index,h.group),delete i[c]):+c<n&&(h.state=xr,h.timer.stop(),delete i[c])}if(hr(function(){e.state===_r&&(e.state=br,e.timer.restart(a,e.delay,e.time),a(f))}),e.state=yr,e.on.call("start",t,t.__data__,e.index,e.group),e.state===yr){for(e.state=_r,r=new Array(l=e.tween.length),c=0,s=-1;c<l;++c)(h=e.tween[c].value.call(t,t.__data__,e.index,e.group))&&(r[++s]=h);r.length=s+1}}function a(n){for(var i=n<e.duration?e.ease.call(null,n/e.duration):(e.timer.restart(u),e.state=mr,1),o=-1,a=r.length;++o<a;)r[o].call(null,i);e.state===mr&&(e.on.call("end",t,t.__data__,e.index,e.group),u())}function u(){for(var r in e.state=xr,e.timer.stop(),delete i[n],i)return;delete t.__transition}i[n]=e,e.timer=ur(function(t){e.state=gr,e.timer.restart(o,e.delay,e.time),e.delay<=t&&o(t-e.delay)},0,e.time)}(t,e,{name:n,index:r,group:i,on:dr,tween:pr,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:vr})}function Mr(t,n){var e=Tr(t,n);if(e.state>vr)throw new Error("too late; already scheduled");return e}function Ar(t,n){var e=Tr(t,n);if(e.state>yr)throw new Error("too late; already started");return e}function Tr(t,n){var e=t.__transition;if(!e||!(e=e[n]))throw new Error("transition not found");return e}function Nr(t,n){var e,r,i,o=t.__transition,a=!0;if(o){for(i in n=null==n?null:n+"",o)(e=o[i]).name===n?(r=e.state>yr&&e.state<mr,e.state=xr,e.timer.stop(),r&&e.on.call("interrupt",t,t.__data__,e.index,e.group),delete o[i]):a=!1;a&&delete t.__transition}}function Sr(t,n,e){var r=t._id;return t.each(function(){var t=Ar(this,r);(t.value||(t.value={}))[n]=e.apply(this,arguments)}),function(t){return Tr(t,r).value[n]}}function Er(t,n){var e;return("number"==typeof n?ve:n instanceof vn?ce:(e=vn(n))?(n=e,ce):be)(t,n)}var kr=Lt.prototype.constructor;var Cr=0;function Pr(t,n,e,r){this._groups=t,this._parents=n,this._name=e,this._id=r}function zr(t){return Lt().transition(t)}function Rr(){return++Cr}var Lr=Lt.prototype;function Dr(t){return((t*=2)<=1?t*t:--t*(2-t)+1)/2}function Ur(t){return((t*=2)<=1?t*t*t:(t-=2)*t*t+2)/2}Pr.prototype=zr.prototype={constructor:Pr,select:function(t){var n=this._name,e=this._id;"function"!=typeof t&&(t=Q(t));for(var r=this._groups,i=r.length,o=new Array(i),a=0;a<i;++a)for(var u,f,c=r[a],s=c.length,l=o[a]=new Array(s),h=0;h<s;++h)(u=c[h])&&(f=t.call(u,u.__data__,h,c))&&("__data__"in u&&(f.__data__=u.__data__),l[h]=f,wr(l[h],n,e,h,l,Tr(u,e)));return new Pr(o,this._parents,n,e)},selectAll:function(t){var n=this._name,e=this._id;"function"!=typeof t&&(t=K(t));for(var r=this._groups,i=r.length,o=[],a=[],u=0;u<i;++u)for(var f,c=r[u],s=c.length,l=0;l<s;++l)if(f=c[l]){for(var h,d=t.call(f,f.__data__,l,c),p=Tr(f,e),v=0,g=d.length;v<g;++v)(h=d[v])&&wr(h,n,e,v,d,p);o.push(d),a.push(f)}return new Pr(o,a,n,e)},filter:function(t){"function"!=typeof t&&(t=rt(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i<e;++i)for(var o,a=n[i],u=a.length,f=r[i]=[],c=0;c<u;++c)(o=a[c])&&t.call(o,o.__data__,c,a)&&f.push(o);return new Pr(r,this._parents,this._name,this._id)},merge:function(t){if(t._id!==this._id)throw new Error;for(var n=this._groups,e=t._groups,r=n.length,i=e.length,o=Math.min(r,i),a=new Array(r),u=0;u<o;++u)for(var f,c=n[u],s=e[u],l=c.length,h=a[u]=new Array(l),d=0;d<l;++d)(f=c[d]||s[d])&&(h[d]=f);for(;u<r;++u)a[u]=n[u];return new Pr(a,this._parents,this._name,this._id)},selection:function(){return new kr(this._groups,this._parents)},transition:function(){for(var t=this._name,n=this._id,e=Rr(),r=this._groups,i=r.length,o=0;o<i;++o)for(var a,u=r[o],f=u.length,c=0;c<f;++c)if(a=u[c]){var s=Tr(a,n);wr(a,t,e,c,u,{time:s.time+s.delay+s.duration,delay:0,duration:s.duration,ease:s.ease})}return new Pr(r,this._parents,t,e)},call:Lr.call,nodes:Lr.nodes,node:Lr.node,size:Lr.size,empty:Lr.empty,each:Lr.each,on:function(t,n){var e=this._id;return arguments.length<2?Tr(this.node(),e).on.on(t):this.each(function(t,n,e){var r,i,o=function(t){return(t+"").trim().split(/^|\s+/).every(function(t){var n=t.indexOf(".");return n>=0&&(t=t.slice(0,n)),!t||"start"===t})}(n)?Mr:Ar;return function(){var a=o(this,t),u=a.on;u!==r&&(i=(r=u).copy()).on(n,e),a.on=i}}(e,t,n))},attr:function(t,n){var e=$(t),r="transform"===e?Pe:Er;return this.attrTween(t,"function"==typeof n?(e.local?function(t,n,e){var r,i,o;return function(){var a,u=e(this);if(null!=u)return(a=this.getAttributeNS(t.space,t.local))===u?null:a===r&&u===i?o:o=n(r=a,i=u);this.removeAttributeNS(t.space,t.local)}}:function(t,n,e){var r,i,o;return function(){var a,u=e(this);if(null!=u)return(a=this.getAttribute(t))===u?null:a===r&&u===i?o:o=n(r=a,i=u);this.removeAttribute(t)}})(e,r,Sr(this,"attr."+t,n)):null==n?(e.local?function(t){return function(){this.removeAttributeNS(t.space,t.local)}}:function(t){return function(){this.removeAttribute(t)}})(e):(e.local?function(t,n,e){var r,i;return function(){var o=this.getAttributeNS(t.space,t.local);return o===e?null:o===r?i:i=n(r=o,e)}}:function(t,n,e){var r,i;return function(){var o=this.getAttribute(t);return o===e?null:o===r?i:i=n(r=o,e)}})(e,r,n+""))},attrTween:function(t,n){var e="attr."+t;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(null==n)return this.tween(e,null);if("function"!=typeof n)throw new Error;var r=$(t);return this.tween(e,(r.local?function(t,n){function e(){var e=this,r=n.apply(e,arguments);return r&&function(n){e.setAttributeNS(t.space,t.local,r(n))}}return e._value=n,e}:function(t,n){function e(){var e=this,r=n.apply(e,arguments);return r&&function(n){e.setAttribute(t,r(n))}}return e._value=n,e})(r,n))},style:function(t,n,e){var r="transform"==(t+="")?Ce:Er;return null==n?this.styleTween(t,function(t,n){var e,r,i;return function(){var o=lt(this,t),a=(this.style.removeProperty(t),lt(this,t));return o===a?null:o===e&&a===r?i:i=n(e=o,r=a)}}(t,r)).on("end.style."+t,function(t){return function(){this.style.removeProperty(t)}}(t)):this.styleTween(t,"function"==typeof n?function(t,n,e){var r,i,o;return function(){var a=lt(this,t),u=e(this);return null==u&&(this.style.removeProperty(t),u=lt(this,t)),a===u?null:a===r&&u===i?o:o=n(r=a,i=u)}}(t,r,Sr(this,"style."+t,n)):function(t,n,e){var r,i;return function(){var o=lt(this,t);return o===e?null:o===r?i:i=n(r=o,e)}}(t,r,n+""),e)},styleTween:function(t,n,e){var r="style."+(t+="");if(arguments.length<2)return(r=this.tween(r))&&r._value;if(null==n)return this.tween(r,null);if("function"!=typeof n)throw new Error;return this.tween(r,function(t,n,e){function r(){var r=this,i=n.apply(r,arguments);return i&&function(n){r.style.setProperty(t,i(n),e)}}return r._value=n,r}(t,n,null==e?"":e))},text:function(t){return this.tween("text","function"==typeof t?function(t){return function(){var n=t(this);this.textContent=null==n?"":n}}(Sr(this,"text",t)):function(t){return function(){this.textContent=t}}(null==t?"":t+""))},remove:function(){return this.on("end.remove",(t=this._id,function(){var n=this.parentNode;for(var e in this.__transition)if(+e!==t)return;n&&n.removeChild(this)}));var t},tween:function(t,n){var e=this._id;if(t+="",arguments.length<2){for(var r,i=Tr(this.node(),e).tween,o=0,a=i.length;o<a;++o)if((r=i[o]).name===t)return r.value;return null}return this.each((null==n?function(t,n){var e,r;return function(){var i=Ar(this,t),o=i.tween;if(o!==e)for(var a=0,u=(r=e=o).length;a<u;++a)if(r[a].name===n){(r=r.slice()).splice(a,1);break}i.tween=r}}:function(t,n,e){var r,i;if("function"!=typeof e)throw new Error;return function(){var o=Ar(this,t),a=o.tween;if(a!==r){i=(r=a).slice();for(var u={name:n,value:e},f=0,c=i.length;f<c;++f)if(i[f].name===n){i[f]=u;break}f===c&&i.push(u)}o.tween=i}})(e,t,n))},delay:function(t){var n=this._id;return arguments.length?this.each(("function"==typeof t?function(t,n){return function(){Mr(this,t).delay=+n.apply(this,arguments)}}:function(t,n){return n=+n,function(){Mr(this,t).delay=n}})(n,t)):Tr(this.node(),n).delay},duration:function(t){var n=this._id;return arguments.length?this.each(("function"==typeof t?function(t,n){return function(){Ar(this,t).duration=+n.apply(this,arguments)}}:function(t,n){return n=+n,function(){Ar(this,t).duration=n}})(n,t)):Tr(this.node(),n).duration},ease:function(t){var n=this._id;return arguments.length?this.each(function(t,n){if("function"!=typeof n)throw new Error;return function(){Ar(this,t).ease=n}}(n,t)):Tr(this.node(),n).ease}};var qr=function t(n){function e(t){return Math.pow(t,n)}return n=+n,e.exponent=t,e}(3),Or=function t(n){function e(t){return 1-Math.pow(1-t,n)}return n=+n,e.exponent=t,e}(3),Yr=function t(n){function e(t){return((t*=2)<=1?Math.pow(t,n):2-Math.pow(2-t,n))/2}return n=+n,e.exponent=t,e}(3),Br=Math.PI,Fr=Br/2;function Ir(t){return(1-Math.cos(Br*t))/2}function Hr(t){return((t*=2)<=1?Math.pow(2,10*t-10):2-Math.pow(2,10-10*t))/2}function jr(t){return((t*=2)<=1?1-Math.sqrt(1-t*t):Math.sqrt(1-(t-=2)*t)+1)/2}var Xr=4/11,Gr=6/11,Vr=8/11,$r=.75,Wr=9/11,Zr=10/11,Qr=.9375,Jr=21/22,Kr=63/64,ti=1/Xr/Xr;function ni(t){return(t=+t)<Xr?ti*t*t:t<Vr?ti*(t-=Gr)*t+$r:t<Zr?ti*(t-=Wr)*t+Qr:ti*(t-=Jr)*t+Kr}var ei=function t(n){function e(t){return t*t*((n+1)*t-n)}return n=+n,e.overshoot=t,e}(1.70158),ri=function t(n){function e(t){return--t*t*((n+1)*t+n)+1}return n=+n,e.overshoot=t,e}(1.70158),ii=function t(n){function e(t){return((t*=2)<1?t*t*((n+1)*t-n):(t-=2)*t*((n+1)*t+n)+2)/2}return n=+n,e.overshoot=t,e}(1.70158),oi=2*Math.PI,ai=function t(n,e){var r=Math.asin(1/(n=Math.max(1,n)))*(e/=oi);function i(t){return n*Math.pow(2,10*--t)*Math.sin((r-t)/e)}return i.amplitude=function(n){return t(n,e*oi)},i.period=function(e){return t(n,e)},i}(1,.3),ui=function t(n,e){var r=Math.asin(1/(n=Math.max(1,n)))*(e/=oi);function i(t){return 1-n*Math.pow(2,-10*(t=+t))*Math.sin((t+r)/e)}return i.amplitude=function(n){return t(n,e*oi)},i.period=function(e){return t(n,e)},i}(1,.3),fi=function t(n,e){var r=Math.asin(1/(n=Math.max(1,n)))*(e/=oi);function i(t){return((t=2*t-1)<0?n*Math.pow(2,10*t)*Math.sin((r-t)/e):2-n*Math.pow(2,-10*t)*Math.sin((r+t)/e))/2}return i.amplitude=function(n){return t(n,e*oi)},i.period=function(e){return t(n,e)},i}(1,.3),ci={time:null,delay:0,duration:250,ease:Ur};function si(t,n){for(var e;!(e=t.__transition)||!(e=e[n]);)if(!(t=t.parentNode))return ci.time=ir(),ci;return e}Lt.prototype.interrupt=function(t){return this.each(function(){Nr(this,t)})},Lt.prototype.transition=function(t){var n,e;t instanceof Pr?(n=t._id,t=t._name):(n=Rr(),(e=ci).time=ir(),t=null==t?null:t+"");for(var r=this._groups,i=r.length,o=0;o<i;++o)for(var a,u=r[o],f=u.length,c=0;c<f;++c)(a=u[c])&&wr(a,t,n,c,u,e||si(a,n));return new Pr(r,this._parents,t,n)};var li=[null];function hi(t){return function(){return t}}function di(t,n,e){this.target=t,this.type=n,this.selection=e}function pi(){t.event.stopImmediatePropagation()}function vi(){t.event.preventDefault(),t.event.stopImmediatePropagation()}var gi={name:"drag"},yi={name:"space"},_i={name:"handle"},bi={name:"center"},mi={name:"x",handles:["e","w"].map(Ei),input:function(t,n){return t&&[[t[0],n[0][1]],[t[1],n[1][1]]]},output:function(t){return t&&[t[0][0],t[1][0]]}},xi={name:"y",handles:["n","s"].map(Ei),input:function(t,n){return t&&[[n[0][0],t[0]],[n[1][0],t[1]]]},output:function(t){return t&&[t[0][1],t[1][1]]}},wi={name:"xy",handles:["n","e","s","w","nw","ne","se","sw"].map(Ei),input:function(t){return t},output:function(t){return t}},Mi={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"},Ai={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},Ti={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},Ni={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},Si={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function Ei(t){return{type:t}}function ki(){return!t.event.button}function Ci(){var t=this.ownerSVGElement||this;return[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]}function Pi(t){for(;!t.__brush;)if(!(t=t.parentNode))return;return t.__brush}function zi(t){return t[0][0]===t[1][0]||t[0][1]===t[1][1]}function Ri(n){var e,r=Ci,i=ki,o=I(u,"start","brush","end"),a=6;function u(t){var e=t.property("__brush",h).selectAll(".overlay").data([Ei("overlay")]);e.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",Mi.overlay).merge(e).each(function(){var t=Pi(this).extent;Dt(this).attr("x",t[0][0]).attr("y",t[0][1]).attr("width",t[1][0]-t[0][0]).attr("height",t[1][1]-t[0][1])}),t.selectAll(".selection").data([Ei("selection")]).enter().append("rect").attr("class","selection").attr("cursor",Mi.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var r=t.selectAll(".handle").data(n.handles,function(t){return t.type});r.exit().remove(),r.enter().append("rect").attr("class",function(t){return"handle handle--"+t.type}).attr("cursor",function(t){return Mi[t.type]}),t.each(f).attr("fill","none").attr("pointer-events","all").style("-webkit-tap-highlight-color","rgba(0,0,0,0)").on("mousedown.brush touchstart.brush",l)}function f(){var t=Dt(this),n=Pi(this).selection;n?(t.selectAll(".selection").style("display",null).attr("x",n[0][0]).attr("y",n[0][1]).attr("width",n[1][0]-n[0][0]).attr("height",n[1][1]-n[0][1]),t.selectAll(".handle").style("display",null).attr("x",function(t){return"e"===t.type[t.type.length-1]?n[1][0]-a/2:n[0][0]-a/2}).attr("y",function(t){return"s"===t.type[0]?n[1][1]-a/2:n[0][1]-a/2}).attr("width",function(t){return"n"===t.type||"s"===t.type?n[1][0]-n[0][0]+a:a}).attr("height",function(t){return"e"===t.type||"w"===t.type?n[1][1]-n[0][1]+a:a})):t.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function c(t,n){return t.__brush.emitter||new s(t,n)}function s(t,n){this.that=t,this.args=n,this.state=t.__brush,this.active=0}function l(){if(t.event.touches){if(t.event.changedTouches.length<t.event.touches.length)return vi()}else if(e)return;if(i.apply(this,arguments)){var r,o,a,u,s,l,h,d,p,v,g,y,_,b=this,m=t.event.target.__data__.type,x="selection"===(t.event.metaKey?m="overlay":m)?gi:t.event.altKey?bi:_i,w=n===xi?null:Ni[m],M=n===mi?null:Si[m],A=Pi(b),T=A.extent,N=A.selection,S=T[0][0],E=T[0][1],k=T[1][0],C=T[1][1],P=w&&M&&t.event.shiftKey,z=Ft(b),R=z,L=c(b,arguments).beforestart();"overlay"===m?A.selection=N=[[r=n===xi?S:z[0],a=n===mi?E:z[1]],[s=n===xi?k:r,h=n===mi?C:a]]:(r=N[0][0],a=N[0][1],s=N[1][0],h=N[1][1]),o=r,u=a,l=s,d=h;var D=Dt(b).attr("pointer-events","none"),U=D.selectAll(".overlay").attr("cursor",Mi[m]);if(t.event.touches)D.on("touchmove.brush",O,!0).on("touchend.brush touchcancel.brush",B,!0);else{var q=Dt(t.event.view).on("keydown.brush",function(){switch(t.event.keyCode){case 16:P=w&&M;break;case 18:x===_i&&(w&&(s=l-p*w,r=o+p*w),M&&(h=d-v*M,a=u+v*M),x=bi,Y());break;case 32:x!==_i&&x!==bi||(w<0?s=l-p:w>0&&(r=o-p),M<0?h=d-v:M>0&&(a=u-v),x=yi,U.attr("cursor",Mi.selection),Y());break;default:return}vi()},!0).on("keyup.brush",function(){switch(t.event.keyCode){case 16:P&&(y=_=P=!1,Y());break;case 18:x===bi&&(w<0?s=l:w>0&&(r=o),M<0?h=d:M>0&&(a=u),x=_i,Y());break;case 32:x===yi&&(t.event.altKey?(w&&(s=l-p*w,r=o+p*w),M&&(h=d-v*M,a=u+v*M),x=bi):(w<0?s=l:w>0&&(r=o),M<0?h=d:M>0&&(a=u),x=_i),U.attr("cursor",Mi[m]),Y());break;default:return}vi()},!0).on("mousemove.brush",O,!0).on("mouseup.brush",B,!0);Xt(t.event.view)}pi(),Nr(b),f.call(b),L.start()}function O(){var t=Ft(b);!P||y||_||(Math.abs(t[0]-R[0])>Math.abs(t[1]-R[1])?_=!0:y=!0),R=t,g=!0,vi(),Y()}function Y(){var t;switch(p=R[0]-z[0],v=R[1]-z[1],x){case yi:case gi:w&&(p=Math.max(S-r,Math.min(k-s,p)),o=r+p,l=s+p),M&&(v=Math.max(E-a,Math.min(C-h,v)),u=a+v,d=h+v);break;case _i:w<0?(p=Math.max(S-r,Math.min(k-r,p)),o=r+p,l=s):w>0&&(p=Math.max(S-s,Math.min(k-s,p)),o=r,l=s+p),M<0?(v=Math.max(E-a,Math.min(C-a,v)),u=a+v,d=h):M>0&&(v=Math.max(E-h,Math.min(C-h,v)),u=a,d=h+v);break;case bi:w&&(o=Math.max(S,Math.min(k,r-p*w)),l=Math.max(S,Math.min(k,s+p*w))),M&&(u=Math.max(E,Math.min(C,a-v*M)),d=Math.max(E,Math.min(C,h+v*M)))}l<o&&(w*=-1,t=r,r=s,s=t,t=o,o=l,l=t,m in Ai&&U.attr("cursor",Mi[m=Ai[m]])),d<u&&(M*=-1,t=a,a=h,h=t,t=u,u=d,d=t,m in Ti&&U.attr("cursor",Mi[m=Ti[m]])),A.selection&&(N=A.selection),y&&(o=N[0][0],l=N[1][0]),_&&(u=N[0][1],d=N[1][1]),N[0][0]===o&&N[0][1]===u&&N[1][0]===l&&N[1][1]===d||(A.selection=[[o,u],[l,d]],f.call(b),L.brush())}function B(){if(pi(),t.event.touches){if(t.event.touches.length)return;e&&clearTimeout(e),e=setTimeout(function(){e=null},500),D.on("touchmove.brush touchend.brush touchcancel.brush",null)}else Gt(t.event.view,g),q.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);D.attr("pointer-events","all"),U.attr("cursor",Mi.overlay),A.selection&&(N=A.selection),zi(N)&&(A.selection=null,f.call(b)),L.end()}}function h(){var t=this.__brush||{selection:null};return t.extent=r.apply(this,arguments),t.dim=n,t}return u.move=function(t,e){t.selection?t.on("start.brush",function(){c(this,arguments).beforestart().start()}).on("interrupt.brush end.brush",function(){c(this,arguments).end()}).tween("brush",function(){var t=this,r=t.__brush,i=c(t,arguments),o=r.selection,a=n.input("function"==typeof e?e.apply(this,arguments):e,r.extent),u=me(o,a);function s(n){r.selection=1===n&&zi(a)?null:u(n),f.call(t),i.brush()}return o&&a?s:s(1)}):t.each(function(){var t=arguments,r=this.__brush,i=n.input("function"==typeof e?e.apply(this,t):e,r.extent),o=c(this,t).beforestart();Nr(this),r.selection=null==i||zi(i)?null:i,f.call(this),o.start().brush().end()})},s.prototype={beforestart:function(){return 1==++this.active&&(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 0==--this.active&&(delete this.state.emitter,this.emit("end")),this},emit:function(t){Ct(new di(u,t,n.output(this.state.selection)),o.apply,o,[t,this.that,this.args])}},u.extent=function(t){return arguments.length?(r="function"==typeof t?t:hi([[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]]),u):r},u.filter=function(t){return arguments.length?(i="function"==typeof t?t:hi(!!t),u):i},u.handleSize=function(t){return arguments.length?(a=+t,u):a},u.on=function(){var t=o.on.apply(o,arguments);return t===o?u:t},u}var Li=Math.cos,Di=Math.sin,Ui=Math.PI,qi=Ui/2,Oi=2*Ui,Yi=Math.max;var Bi=Array.prototype.slice;function Fi(t){return function(){return t}}var Ii=Math.PI,Hi=2*Ii,ji=Hi-1e-6;function Xi(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function Gi(){return new Xi}function Vi(t){return t.source}function $i(t){return t.target}function Wi(t){return t.radius}function Zi(t){return t.startAngle}function Qi(t){return t.endAngle}Xi.prototype=Gi.prototype={constructor:Xi,moveTo:function(t,n){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+n)},closePath:function(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(t,n){this._+="L"+(this._x1=+t)+","+(this._y1=+n)},quadraticCurveTo:function(t,n,e,r){this._+="Q"+ +t+","+ +n+","+(this._x1=+e)+","+(this._y1=+r)},bezierCurveTo:function(t,n,e,r,i,o){this._+="C"+ +t+","+ +n+","+ +e+","+ +r+","+(this._x1=+i)+","+(this._y1=+o)},arcTo:function(t,n,e,r,i){t=+t,n=+n,e=+e,r=+r,i=+i;var o=this._x1,a=this._y1,u=e-t,f=r-n,c=o-t,s=a-n,l=c*c+s*s;if(i<0)throw new Error("negative radius: "+i);if(null===this._x1)this._+="M"+(this._x1=t)+","+(this._y1=n);else if(l>1e-6)if(Math.abs(s*u-f*c)>1e-6&&i){var h=e-o,d=r-a,p=u*u+f*f,v=h*h+d*d,g=Math.sqrt(p),y=Math.sqrt(l),_=i*Math.tan((Ii-Math.acos((p+l-v)/(2*g*y)))/2),b=_/y,m=_/g;Math.abs(b-1)>1e-6&&(this._+="L"+(t+b*c)+","+(n+b*s)),this._+="A"+i+","+i+",0,0,"+ +(s*h>c*d)+","+(this._x1=t+m*u)+","+(this._y1=n+m*f)}else this._+="L"+(this._x1=t)+","+(this._y1=n);else;},arc:function(t,n,e,r,i,o){t=+t,n=+n;var a=(e=+e)*Math.cos(r),u=e*Math.sin(r),f=t+a,c=n+u,s=1^o,l=o?r-i:i-r;if(e<0)throw new Error("negative radius: "+e);null===this._x1?this._+="M"+f+","+c:(Math.abs(this._x1-f)>1e-6||Math.abs(this._y1-c)>1e-6)&&(this._+="L"+f+","+c),e&&(l<0&&(l=l%Hi+Hi),l>ji?this._+="A"+e+","+e+",0,1,"+s+","+(t-a)+","+(n-u)+"A"+e+","+e+",0,1,"+s+","+(this._x1=f)+","+(this._y1=c):l>1e-6&&(this._+="A"+e+","+e+",0,"+ +(l>=Ii)+","+s+","+(this._x1=t+e*Math.cos(i))+","+(this._y1=n+e*Math.sin(i))))},rect:function(t,n,e,r){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+n)+"h"+ +e+"v"+ +r+"h"+-e+"Z"},toString:function(){return this._}};function Ji(){}function Ki(t,n){var e=new Ji;if(t instanceof Ji)t.each(function(t,n){e.set(n,t)});else if(Array.isArray(t)){var r,i=-1,o=t.length;if(null==n)for(;++i<o;)e.set(i,t[i]);else for(;++i<o;)e.set(n(r=t[i],i,t),r)}else if(t)for(var a in t)e.set(a,t[a]);return e}function to(){return{}}function no(t,n,e){t[n]=e}function eo(){return Ki()}function ro(t,n,e){t.set(n,e)}function io(){}Ji.prototype=Ki.prototype={constructor:Ji,has:function(t){return"$"+t in this},get:function(t){return this["$"+t]},set:function(t,n){return this["$"+t]=n,this},remove:function(t){var n="$"+t;return n in this&&delete this[n]},clear:function(){for(var t in this)"$"===t[0]&&delete this[t]},keys:function(){var t=[];for(var n in this)"$"===n[0]&&t.push(n.slice(1));return t},values:function(){var t=[];for(var n in this)"$"===n[0]&&t.push(this[n]);return t},entries:function(){var t=[];for(var n in this)"$"===n[0]&&t.push({key:n.slice(1),value:this[n]});return t},size:function(){var t=0;for(var n in this)"$"===n[0]&&++t;return t},empty:function(){for(var t in this)if("$"===t[0])return!1;return!0},each:function(t){for(var n in this)"$"===n[0]&&t(this[n],n.slice(1),this)}};var oo=Ki.prototype;function ao(t,n){var e=new io;if(t instanceof io)t.each(function(t){e.add(t)});else if(t){var r=-1,i=t.length;if(null==n)for(;++r<i;)e.add(t[r]);else for(;++r<i;)e.add(n(t[r],r,t))}return e}io.prototype=ao.prototype={constructor:io,has:oo.has,add:function(t){return this["$"+(t+="")]=t,this},remove:oo.remove,clear:oo.clear,values:oo.keys,size:oo.size,empty:oo.empty,each:oo.each};var uo=Array.prototype.slice;function fo(t,n){return t-n}function co(t){return function(){return t}}function so(t,n){for(var e,r=-1,i=n.length;++r<i;)if(e=lo(t,n[r]))return e;return 0}function lo(t,n){for(var e=n[0],r=n[1],i=-1,o=0,a=t.length,u=a-1;o<a;u=o++){var f=t[o],c=f[0],s=f[1],l=t[u],h=l[0],d=l[1];if(ho(f,l,n))return 0;s>r!=d>r&&e<(h-c)*(r-s)/(d-s)+c&&(i=-i)}return i}function ho(t,n,e){var r,i,o,a;return function(t,n,e){return(n[0]-t[0])*(e[1]-t[1])==(e[0]-t[0])*(n[1]-t[1])}(t,n,e)&&(i=t[r=+(t[0]===n[0])],o=e[r],a=n[r],i<=o&&o<=a||a<=o&&o<=i)}function po(){}var vo=[[],[[[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 go(){var t=1,n=1,e=M,r=u;function i(t){var n=e(t);if(Array.isArray(n))n=n.slice().sort(fo);else{var r=s(t),i=r[0],a=r[1];n=w(i,a,n),n=g(Math.floor(i/n)*n,Math.floor(a/n)*n,n)}return n.map(function(n){return o(t,n)})}function o(e,i){var o=[],u=[];return function(e,r,i){var o,u,f,c,s,l,h=new Array,d=new Array;o=u=-1,c=e[0]>=r,vo[c<<1].forEach(p);for(;++o<t-1;)f=c,c=e[o+1]>=r,vo[f|c<<1].forEach(p);vo[c<<0].forEach(p);for(;++u<n-1;){for(o=-1,c=e[u*t+t]>=r,s=e[u*t]>=r,vo[c<<1|s<<2].forEach(p);++o<t-1;)f=c,c=e[u*t+t+o+1]>=r,l=s,s=e[u*t+o+1]>=r,vo[f|c<<1|s<<2|l<<3].forEach(p);vo[c|s<<3].forEach(p)}o=-1,s=e[u*t]>=r,vo[s<<2].forEach(p);for(;++o<t-1;)l=s,s=e[u*t+o+1]>=r,vo[s<<2|l<<3].forEach(p);function p(t){var n,e,r=[t[0][0]+o,t[0][1]+u],f=[t[1][0]+o,t[1][1]+u],c=a(r),s=a(f);(n=d[c])?(e=h[s])?(delete d[n.end],delete h[e.start],n===e?(n.ring.push(f),i(n.ring)):h[n.start]=d[e.end]={start:n.start,end:e.end,ring:n.ring.concat(e.ring)}):(delete d[n.end],n.ring.push(f),d[n.end=s]=n):(n=h[s])?(e=d[c])?(delete h[n.start],delete d[e.end],n===e?(n.ring.push(f),i(n.ring)):h[e.start]=d[n.end]={start:e.start,end:n.end,ring:e.ring.concat(n.ring)}):(delete h[n.start],n.ring.unshift(r),h[n.start=c]=n):h[c]=d[s]={start:c,end:s,ring:[r,f]}}vo[s<<3].forEach(p)}(e,i,function(t){r(t,e,i),function(t){for(var n=0,e=t.length,r=t[e-1][1]*t[0][0]-t[e-1][0]*t[0][1];++n<e;)r+=t[n-1][1]*t[n][0]-t[n-1][0]*t[n][1];return r}(t)>0?o.push([t]):u.push(t)}),u.forEach(function(t){for(var n,e=0,r=o.length;e<r;++e)if(-1!==so((n=o[e])[0],t))return void n.push(t)}),{type:"MultiPolygon",value:i,coordinates:o}}function a(n){return 2*n[0]+n[1]*(t+1)*4}function u(e,r,i){e.forEach(function(e){var o,a=e[0],u=e[1],f=0|a,c=0|u,s=r[c*t+f];a>0&&a<t&&f===a&&(o=r[c*t+f-1],e[0]=a+(i-o)/(s-o)-.5),u>0&&u<n&&c===u&&(o=r[(c-1)*t+f],e[1]=u+(i-o)/(s-o)-.5)})}return i.contour=o,i.size=function(e){if(!arguments.length)return[t,n];var r=Math.ceil(e[0]),o=Math.ceil(e[1]);if(!(r>0&&o>0))throw new Error("invalid size");return t=r,n=o,i},i.thresholds=function(t){return arguments.length?(e="function"==typeof t?t:Array.isArray(t)?co(uo.call(t)):co(t),i):e},i.smooth=function(t){return arguments.length?(r=t?u:po,i):r===u},i}function yo(t,n,e){for(var r=t.width,i=t.height,o=1+(e<<1),a=0;a<i;++a)for(var u=0,f=0;u<r+e;++u)u<r&&(f+=t.data[u+a*r]),u>=e&&(u>=o&&(f-=t.data[u-o+a*r]),n.data[u-e+a*r]=f/Math.min(u+1,r-1+o-u,o))}function _o(t,n,e){for(var r=t.width,i=t.height,o=1+(e<<1),a=0;a<r;++a)for(var u=0,f=0;u<i+e;++u)u<i&&(f+=t.data[a+u*r]),u>=e&&(u>=o&&(f-=t.data[a+(u-o)*r]),n.data[a+(u-e)*r]=f/Math.min(u+1,i-1+o-u,o))}function bo(t){return t[0]}function mo(t){return t[1]}function xo(){return 1}var wo={},Mo={},Ao=34,To=10,No=13;function So(t){return new Function("d","return {"+t.map(function(t,n){return JSON.stringify(t)+": d["+n+"]"}).join(",")+"}")}function Eo(t){var n=new RegExp('["'+t+"\n\r]"),e=t.charCodeAt(0);function r(t,n){var r,i=[],o=t.length,a=0,u=0,f=o<=0,c=!1;function s(){if(f)return Mo;if(c)return c=!1,wo;var n,r,i=a;if(t.charCodeAt(i)===Ao){for(;a++<o&&t.charCodeAt(a)!==Ao||t.charCodeAt(++a)===Ao;);return(n=a)>=o?f=!0:(r=t.charCodeAt(a++))===To?c=!0:r===No&&(c=!0,t.charCodeAt(a)===To&&++a),t.slice(i+1,n-1).replace(/""/g,'"')}for(;a<o;){if((r=t.charCodeAt(n=a++))===To)c=!0;else if(r===No)c=!0,t.charCodeAt(a)===To&&++a;else if(r!==e)continue;return t.slice(i,n)}return f=!0,t.slice(i,o)}for(t.charCodeAt(o-1)===To&&--o,t.charCodeAt(o-1)===No&&--o;(r=s())!==Mo;){for(var l=[];r!==wo&&r!==Mo;)l.push(r),r=s();n&&null==(l=n(l,u++))||i.push(l)}return i}function i(n){return n.map(o).join(t)}function o(t){return null==t?"":n.test(t+="")?'"'+t.replace(/"/g,'""')+'"':t}return{parse:function(t,n){var e,i,o=r(t,function(t,r){if(e)return e(t,r-1);i=t,e=n?function(t,n){var e=So(t);return function(r,i){return n(e(r),i,t)}}(t,n):So(t)});return o.columns=i||[],o},parseRows:r,format:function(n,e){return null==e&&(e=function(t){var n=Object.create(null),e=[];return t.forEach(function(t){for(var r in t)r in n||e.push(n[r]=r)}),e}(n)),[e.map(o).join(t)].concat(n.map(function(n){return e.map(function(t){return o(n[t])}).join(t)})).join("\n")},formatRows:function(t){return t.map(i).join("\n")}}}var ko=Eo(","),Co=ko.parse,Po=ko.parseRows,zo=ko.format,Ro=ko.formatRows,Lo=Eo("\t"),Do=Lo.parse,Uo=Lo.parseRows,qo=Lo.format,Oo=Lo.formatRows;function Yo(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.blob()}function Bo(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.arrayBuffer()}function Fo(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.text()}function Io(t,n){return fetch(t,n).then(Fo)}function Ho(t){return function(n,e,r){return 2===arguments.length&&"function"==typeof e&&(r=e,e=void 0),Io(n,e).then(function(n){return t(n,r)})}}var jo=Ho(Co),Xo=Ho(Do);function Go(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.json()}function Vo(t){return function(n,e){return Io(n,e).then(function(n){return(new DOMParser).parseFromString(n,t)})}}var $o=Vo("application/xml"),Wo=Vo("text/html"),Zo=Vo("image/svg+xml");function Qo(t){return function(){return t}}function Jo(){return 1e-6*(Math.random()-.5)}function Ko(t,n,e,r){if(isNaN(n)||isNaN(e))return t;var i,o,a,u,f,c,s,l,h,d=t._root,p={data:r},v=t._x0,g=t._y0,y=t._x1,_=t._y1;if(!d)return t._root=p,t;for(;d.length;)if((c=n>=(o=(v+y)/2))?v=o:y=o,(s=e>=(a=(g+_)/2))?g=a:_=a,i=d,!(d=d[l=s<<1|c]))return i[l]=p,t;if(u=+t._x.call(null,d.data),f=+t._y.call(null,d.data),n===u&&e===f)return p.next=d,i?i[l]=p:t._root=p,t;do{i=i?i[l]=new Array(4):t._root=new Array(4),(c=n>=(o=(v+y)/2))?v=o:y=o,(s=e>=(a=(g+_)/2))?g=a:_=a}while((l=s<<1|c)==(h=(f>=a)<<1|u>=o));return i[h]=d,i[l]=p,t}function ta(t,n,e,r,i){this.node=t,this.x0=n,this.y0=e,this.x1=r,this.y1=i}function na(t){return t[0]}function ea(t){return t[1]}function ra(t,n,e){var r=new ia(null==n?na:n,null==e?ea:e,NaN,NaN,NaN,NaN);return null==t?r:r.addAll(t)}function ia(t,n,e,r,i,o){this._x=t,this._y=n,this._x0=e,this._y0=r,this._x1=i,this._y1=o,this._root=void 0}function oa(t){for(var n={data:t.data},e=n;t=t.next;)e=e.next={data:t.data};return n}var aa=ra.prototype=ia.prototype;function ua(t){return t.x+t.vx}function fa(t){return t.y+t.vy}function ca(t){return t.index}function sa(t,n){var e=t.get(n);if(!e)throw new Error("missing: "+n);return e}function la(t){return t.x}function ha(t){return t.y}aa.copy=function(){var t,n,e=new ia(this._x,this._y,this._x0,this._y0,this._x1,this._y1),r=this._root;if(!r)return e;if(!r.length)return e._root=oa(r),e;for(t=[{source:r,target:e._root=new Array(4)}];r=t.pop();)for(var i=0;i<4;++i)(n=r.source[i])&&(n.length?t.push({source:n,target:r.target[i]=new Array(4)}):r.target[i]=oa(n));return e},aa.add=function(t){var n=+this._x.call(null,t),e=+this._y.call(null,t);return Ko(this.cover(n,e),n,e,t)},aa.addAll=function(t){var n,e,r,i,o=t.length,a=new Array(o),u=new Array(o),f=1/0,c=1/0,s=-1/0,l=-1/0;for(e=0;e<o;++e)isNaN(r=+this._x.call(null,n=t[e]))||isNaN(i=+this._y.call(null,n))||(a[e]=r,u[e]=i,r<f&&(f=r),r>s&&(s=r),i<c&&(c=i),i>l&&(l=i));for(s<f&&(f=this._x0,s=this._x1),l<c&&(c=this._y0,l=this._y1),this.cover(f,c).cover(s,l),e=0;e<o;++e)Ko(this,a[e],u[e],t[e]);return this},aa.cover=function(t,n){if(isNaN(t=+t)||isNaN(n=+n))return this;var e=this._x0,r=this._y0,i=this._x1,o=this._y1;if(isNaN(e))i=(e=Math.floor(t))+1,o=(r=Math.floor(n))+1;else{if(!(e>t||t>i||r>n||n>o))return this;var a,u,f=i-e,c=this._root;switch(u=(n<(r+o)/2)<<1|t<(e+i)/2){case 0:do{(a=new Array(4))[u]=c,c=a}while(o=r+(f*=2),t>(i=e+f)||n>o);break;case 1:do{(a=new Array(4))[u]=c,c=a}while(o=r+(f*=2),(e=i-f)>t||n>o);break;case 2:do{(a=new Array(4))[u]=c,c=a}while(r=o-(f*=2),t>(i=e+f)||r>n);break;case 3:do{(a=new Array(4))[u]=c,c=a}while(r=o-(f*=2),(e=i-f)>t||r>n)}this._root&&this._root.length&&(this._root=c)}return this._x0=e,this._y0=r,this._x1=i,this._y1=o,this},aa.data=function(){var t=[];return this.visit(function(n){if(!n.length)do{t.push(n.data)}while(n=n.next)}),t},aa.extent=function(t){return arguments.length?this.cover(+t[0][0],+t[0][1]).cover(+t[1][0],+t[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]},aa.find=function(t,n,e){var r,i,o,a,u,f,c,s=this._x0,l=this._y0,h=this._x1,d=this._y1,p=[],v=this._root;for(v&&p.push(new ta(v,s,l,h,d)),null==e?e=1/0:(s=t-e,l=n-e,h=t+e,d=n+e,e*=e);f=p.pop();)if(!(!(v=f.node)||(i=f.x0)>h||(o=f.y0)>d||(a=f.x1)<s||(u=f.y1)<l))if(v.length){var g=(i+a)/2,y=(o+u)/2;p.push(new ta(v[3],g,y,a,u),new ta(v[2],i,y,g,u),new ta(v[1],g,o,a,y),new ta(v[0],i,o,g,y)),(c=(n>=y)<<1|t>=g)&&(f=p[p.length-1],p[p.length-1]=p[p.length-1-c],p[p.length-1-c]=f)}else{var _=t-+this._x.call(null,v.data),b=n-+this._y.call(null,v.data),m=_*_+b*b;if(m<e){var x=Math.sqrt(e=m);s=t-x,l=n-x,h=t+x,d=n+x,r=v.data}}return r},aa.remove=function(t){if(isNaN(o=+this._x.call(null,t))||isNaN(a=+this._y.call(null,t)))return this;var n,e,r,i,o,a,u,f,c,s,l,h,d=this._root,p=this._x0,v=this._y0,g=this._x1,y=this._y1;if(!d)return this;if(d.length)for(;;){if((c=o>=(u=(p+g)/2))?p=u:g=u,(s=a>=(f=(v+y)/2))?v=f:y=f,n=d,!(d=d[l=s<<1|c]))return this;if(!d.length)break;(n[l+1&3]||n[l+2&3]||n[l+3&3])&&(e=n,h=l)}for(;d.data!==t;)if(r=d,!(d=d.next))return this;return(i=d.next)&&delete d.next,r?(i?r.next=i:delete r.next,this):n?(i?n[l]=i:delete n[l],(d=n[0]||n[1]||n[2]||n[3])&&d===(n[3]||n[2]||n[1]||n[0])&&!d.length&&(e?e[h]=d:this._root=d),this):(this._root=i,this)},aa.removeAll=function(t){for(var n=0,e=t.length;n<e;++n)this.remove(t[n]);return this},aa.root=function(){return this._root},aa.size=function(){var t=0;return this.visit(function(n){if(!n.length)do{++t}while(n=n.next)}),t},aa.visit=function(t){var n,e,r,i,o,a,u=[],f=this._root;for(f&&u.push(new ta(f,this._x0,this._y0,this._x1,this._y1));n=u.pop();)if(!t(f=n.node,r=n.x0,i=n.y0,o=n.x1,a=n.y1)&&f.length){var c=(r+o)/2,s=(i+a)/2;(e=f[3])&&u.push(new ta(e,c,s,o,a)),(e=f[2])&&u.push(new ta(e,r,s,c,a)),(e=f[1])&&u.push(new ta(e,c,i,o,s)),(e=f[0])&&u.push(new ta(e,r,i,c,s))}return this},aa.visitAfter=function(t){var n,e=[],r=[];for(this._root&&e.push(new ta(this._root,this._x0,this._y0,this._x1,this._y1));n=e.pop();){var i=n.node;if(i.length){var o,a=n.x0,u=n.y0,f=n.x1,c=n.y1,s=(a+f)/2,l=(u+c)/2;(o=i[0])&&e.push(new ta(o,a,u,s,l)),(o=i[1])&&e.push(new ta(o,s,u,f,l)),(o=i[2])&&e.push(new ta(o,a,l,s,c)),(o=i[3])&&e.push(new ta(o,s,l,f,c))}r.push(n)}for(;n=r.pop();)t(n.node,n.x0,n.y0,n.x1,n.y1);return this},aa.x=function(t){return arguments.length?(this._x=t,this):this._x},aa.y=function(t){return arguments.length?(this._y=t,this):this._y};var da=10,pa=Math.PI*(3-Math.sqrt(5));function va(t,n){if((e=(t=n?t.toExponential(n-1):t.toExponential()).indexOf("e"))<0)return null;var e,r=t.slice(0,e);return[r.length>1?r[0]+r.slice(2):r,+t.slice(e+1)]}function ga(t){return(t=va(Math.abs(t)))?t[1]:NaN}var ya,_a=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function ba(t){return new ma(t)}function ma(t){if(!(n=_a.exec(t)))throw new Error("invalid format: "+t);var n;this.fill=n[1]||" ",this.align=n[2]||">",this.sign=n[3]||"-",this.symbol=n[4]||"",this.zero=!!n[5],this.width=n[6]&&+n[6],this.comma=!!n[7],this.precision=n[8]&&+n[8].slice(1),this.trim=!!n[9],this.type=n[10]||""}function xa(t,n){var e=va(t,n);if(!e)return t+"";var r=e[0],i=e[1];return i<0?"0."+new Array(-i).join("0")+r:r.length>i+1?r.slice(0,i+1)+"."+r.slice(i+1):r+new Array(i-r.length+2).join("0")}ba.prototype=ma.prototype,ma.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(null==this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(null==this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var wa={"%":function(t,n){return(100*t).toFixed(n)},b:function(t){return Math.round(t).toString(2)},c:function(t){return t+""},d:function(t){return Math.round(t).toString(10)},e:function(t,n){return t.toExponential(n)},f:function(t,n){return t.toFixed(n)},g:function(t,n){return t.toPrecision(n)},o:function(t){return Math.round(t).toString(8)},p:function(t,n){return xa(100*t,n)},r:xa,s:function(t,n){var e=va(t,n);if(!e)return t+"";var r=e[0],i=e[1],o=i-(ya=3*Math.max(-8,Math.min(8,Math.floor(i/3))))+1,a=r.length;return o===a?r:o>a?r+new Array(o-a+1).join("0"):o>0?r.slice(0,o)+"."+r.slice(o):"0."+new Array(1-o).join("0")+va(t,Math.max(0,n+o-1))[0]},X:function(t){return Math.round(t).toString(16).toUpperCase()},x:function(t){return Math.round(t).toString(16)}};function Ma(t){return t}var Aa,Ta=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function Na(t){var n,e,r=t.grouping&&t.thousands?(n=t.grouping,e=t.thousands,function(t,r){for(var i=t.length,o=[],a=0,u=n[0],f=0;i>0&&u>0&&(f+u+1>r&&(u=Math.max(1,r-f)),o.push(t.substring(i-=u,i+u)),!((f+=u+1)>r));)u=n[a=(a+1)%n.length];return o.reverse().join(e)}):Ma,i=t.currency,o=t.decimal,a=t.numerals?function(t){return function(n){return n.replace(/[0-9]/g,function(n){return t[+n]})}}(t.numerals):Ma,u=t.percent||"%";function f(t){var n=(t=ba(t)).fill,e=t.align,f=t.sign,c=t.symbol,s=t.zero,l=t.width,h=t.comma,d=t.precision,p=t.trim,v=t.type;"n"===v?(h=!0,v="g"):wa[v]||(null==d&&(d=12),p=!0,v="g"),(s||"0"===n&&"="===e)&&(s=!0,n="0",e="=");var g="$"===c?i[0]:"#"===c&&/[boxX]/.test(v)?"0"+v.toLowerCase():"",y="$"===c?i[1]:/[%p]/.test(v)?u:"",_=wa[v],b=/[defgprs%]/.test(v);function m(t){var i,u,c,m=g,x=y;if("c"===v)x=_(t)+x,t="";else{var w=(t=+t)<0;if(t=_(Math.abs(t),d),p&&(t=function(t){t:for(var n,e=t.length,r=1,i=-1;r<e;++r)switch(t[r]){case".":i=n=r;break;case"0":0===i&&(i=r),n=r;break;default:if(i>0){if(!+t[r])break t;i=0}}return i>0?t.slice(0,i)+t.slice(n+1):t}(t)),w&&0==+t&&(w=!1),m=(w?"("===f?f:"-":"-"===f||"("===f?"":f)+m,x=("s"===v?Ta[8+ya/3]:"")+x+(w&&"("===f?")":""),b)for(i=-1,u=t.length;++i<u;)if(48>(c=t.charCodeAt(i))||c>57){x=(46===c?o+t.slice(i+1):t.slice(i))+x,t=t.slice(0,i);break}}h&&!s&&(t=r(t,1/0));var M=m.length+t.length+x.length,A=M<l?new Array(l-M+1).join(n):"";switch(h&&s&&(t=r(A+t,A.length?l-x.length:1/0),A=""),e){case"<":t=m+t+x+A;break;case"=":t=m+A+t+x;break;case"^":t=A.slice(0,M=A.length>>1)+m+t+x+A.slice(M);break;default:t=A+m+t+x}return a(t)}return d=null==d?6:/[gprs]/.test(v)?Math.max(1,Math.min(21,d)):Math.max(0,Math.min(20,d)),m.toString=function(){return t+""},m}return{format:f,formatPrefix:function(t,n){var e=f(((t=ba(t)).type="f",t)),r=3*Math.max(-8,Math.min(8,Math.floor(ga(n)/3))),i=Math.pow(10,-r),o=Ta[8+r/3];return function(t){return e(i*t)+o}}}}function Sa(n){return Aa=Na(n),t.format=Aa.format,t.formatPrefix=Aa.formatPrefix,Aa}function Ea(t){return Math.max(0,-ga(Math.abs(t)))}function ka(t,n){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(ga(n)/3)))-ga(Math.abs(t)))}function Ca(t,n){return t=Math.abs(t),n=Math.abs(n)-t,Math.max(0,ga(n)-ga(t))+1}function Pa(){return new za}function za(){this.reset()}Sa({decimal:".",thousands:",",grouping:[3],currency:["$",""]}),za.prototype={constructor:za,reset:function(){this.s=this.t=0},add:function(t){La(Ra,t,this.t),La(this,Ra.s,this.s),this.s?this.t+=Ra.t:this.s=Ra.t},valueOf:function(){return this.s}};var Ra=new za;function La(t,n,e){var r=t.s=n+e,i=r-n,o=r-i;t.t=n-o+(e-i)}var Da=1e-6,Ua=1e-12,qa=Math.PI,Oa=qa/2,Ya=qa/4,Ba=2*qa,Fa=180/qa,Ia=qa/180,Ha=Math.abs,ja=Math.atan,Xa=Math.atan2,Ga=Math.cos,Va=Math.ceil,$a=Math.exp,Wa=Math.log,Za=Math.pow,Qa=Math.sin,Ja=Math.sign||function(t){return t>0?1:t<0?-1:0},Ka=Math.sqrt,tu=Math.tan;function nu(t){return t>1?0:t<-1?qa:Math.acos(t)}function eu(t){return t>1?Oa:t<-1?-Oa:Math.asin(t)}function ru(t){return(t=Qa(t/2))*t}function iu(){}function ou(t,n){t&&uu.hasOwnProperty(t.type)&&uu[t.type](t,n)}var au={Feature:function(t,n){ou(t.geometry,n)},FeatureCollection:function(t,n){for(var e=t.features,r=-1,i=e.length;++r<i;)ou(e[r].geometry,n)}},uu={Sphere:function(t,n){n.sphere()},Point:function(t,n){t=t.coordinates,n.point(t[0],t[1],t[2])},MultiPoint:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)t=e[r],n.point(t[0],t[1],t[2])},LineString:function(t,n){fu(t.coordinates,n,0)},MultiLineString:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)fu(e[r],n,0)},Polygon:function(t,n){cu(t.coordinates,n)},MultiPolygon:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)cu(e[r],n)},GeometryCollection:function(t,n){for(var e=t.geometries,r=-1,i=e.length;++r<i;)ou(e[r],n)}};function fu(t,n,e){var r,i=-1,o=t.length-e;for(n.lineStart();++i<o;)r=t[i],n.point(r[0],r[1],r[2]);n.lineEnd()}function cu(t,n){var e=-1,r=t.length;for(n.polygonStart();++e<r;)fu(t[e],n,1);n.polygonEnd()}function su(t,n){t&&au.hasOwnProperty(t.type)?au[t.type](t,n):ou(t,n)}var lu,hu,du,pu,vu,gu=Pa(),yu=Pa(),_u={point:iu,lineStart:iu,lineEnd:iu,polygonStart:function(){gu.reset(),_u.lineStart=bu,_u.lineEnd=mu},polygonEnd:function(){var t=+gu;yu.add(t<0?Ba+t:t),this.lineStart=this.lineEnd=this.point=iu},sphere:function(){yu.add(Ba)}};function bu(){_u.point=xu}function mu(){wu(lu,hu)}function xu(t,n){_u.point=wu,lu=t,hu=n,du=t*=Ia,pu=Ga(n=(n*=Ia)/2+Ya),vu=Qa(n)}function wu(t,n){var e=(t*=Ia)-du,r=e>=0?1:-1,i=r*e,o=Ga(n=(n*=Ia)/2+Ya),a=Qa(n),u=vu*a,f=pu*o+u*Ga(i),c=u*r*Qa(i);gu.add(Xa(c,f)),du=t,pu=o,vu=a}function Mu(t){return[Xa(t[1],t[0]),eu(t[2])]}function Au(t){var n=t[0],e=t[1],r=Ga(e);return[r*Ga(n),r*Qa(n),Qa(e)]}function Tu(t,n){return t[0]*n[0]+t[1]*n[1]+t[2]*n[2]}function Nu(t,n){return[t[1]*n[2]-t[2]*n[1],t[2]*n[0]-t[0]*n[2],t[0]*n[1]-t[1]*n[0]]}function Su(t,n){t[0]+=n[0],t[1]+=n[1],t[2]+=n[2]}function Eu(t,n){return[t[0]*n,t[1]*n,t[2]*n]}function ku(t){var n=Ka(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]);t[0]/=n,t[1]/=n,t[2]/=n}var Cu,Pu,zu,Ru,Lu,Du,Uu,qu,Ou,Yu,Bu,Fu,Iu,Hu,ju,Xu,Gu,Vu,$u,Wu,Zu,Qu,Ju,Ku,tf,nf,ef=Pa(),rf={point:of,lineStart:uf,lineEnd:ff,polygonStart:function(){rf.point=cf,rf.lineStart=sf,rf.lineEnd=lf,ef.reset(),_u.polygonStart()},polygonEnd:function(){_u.polygonEnd(),rf.point=of,rf.lineStart=uf,rf.lineEnd=ff,gu<0?(Cu=-(zu=180),Pu=-(Ru=90)):ef>Da?Ru=90:ef<-Da&&(Pu=-90),Yu[0]=Cu,Yu[1]=zu}};function of(t,n){Ou.push(Yu=[Cu=t,zu=t]),n<Pu&&(Pu=n),n>Ru&&(Ru=n)}function af(t,n){var e=Au([t*Ia,n*Ia]);if(qu){var r=Nu(qu,e),i=Nu([r[1],-r[0],0],r);ku(i),i=Mu(i);var o,a=t-Lu,u=a>0?1:-1,f=i[0]*Fa*u,c=Ha(a)>180;c^(u*Lu<f&&f<u*t)?(o=i[1]*Fa)>Ru&&(Ru=o):c^(u*Lu<(f=(f+360)%360-180)&&f<u*t)?(o=-i[1]*Fa)<Pu&&(Pu=o):(n<Pu&&(Pu=n),n>Ru&&(Ru=n)),c?t<Lu?hf(Cu,t)>hf(Cu,zu)&&(zu=t):hf(t,zu)>hf(Cu,zu)&&(Cu=t):zu>=Cu?(t<Cu&&(Cu=t),t>zu&&(zu=t)):t>Lu?hf(Cu,t)>hf(Cu,zu)&&(zu=t):hf(t,zu)>hf(Cu,zu)&&(Cu=t)}else Ou.push(Yu=[Cu=t,zu=t]);n<Pu&&(Pu=n),n>Ru&&(Ru=n),qu=e,Lu=t}function uf(){rf.point=af}function ff(){Yu[0]=Cu,Yu[1]=zu,rf.point=of,qu=null}function cf(t,n){if(qu){var e=t-Lu;ef.add(Ha(e)>180?e+(e>0?360:-360):e)}else Du=t,Uu=n;_u.point(t,n),af(t,n)}function sf(){_u.lineStart()}function lf(){cf(Du,Uu),_u.lineEnd(),Ha(ef)>Da&&(Cu=-(zu=180)),Yu[0]=Cu,Yu[1]=zu,qu=null}function hf(t,n){return(n-=t)<0?n+360:n}function df(t,n){return t[0]-n[0]}function pf(t,n){return t[0]<=t[1]?t[0]<=n&&n<=t[1]:n<t[0]||t[1]<n}var vf={sphere:iu,point:gf,lineStart:_f,lineEnd:xf,polygonStart:function(){vf.lineStart=wf,vf.lineEnd=Mf},polygonEnd:function(){vf.lineStart=_f,vf.lineEnd=xf}};function gf(t,n){t*=Ia;var e=Ga(n*=Ia);yf(e*Ga(t),e*Qa(t),Qa(n))}function yf(t,n,e){Iu+=(t-Iu)/++Bu,Hu+=(n-Hu)/Bu,ju+=(e-ju)/Bu}function _f(){vf.point=bf}function bf(t,n){t*=Ia;var e=Ga(n*=Ia);Ku=e*Ga(t),tf=e*Qa(t),nf=Qa(n),vf.point=mf,yf(Ku,tf,nf)}function mf(t,n){t*=Ia;var e=Ga(n*=Ia),r=e*Ga(t),i=e*Qa(t),o=Qa(n),a=Xa(Ka((a=tf*o-nf*i)*a+(a=nf*r-Ku*o)*a+(a=Ku*i-tf*r)*a),Ku*r+tf*i+nf*o);Fu+=a,Xu+=a*(Ku+(Ku=r)),Gu+=a*(tf+(tf=i)),Vu+=a*(nf+(nf=o)),yf(Ku,tf,nf)}function xf(){vf.point=gf}function wf(){vf.point=Af}function Mf(){Tf(Qu,Ju),vf.point=gf}function Af(t,n){Qu=t,Ju=n,t*=Ia,n*=Ia,vf.point=Tf;var e=Ga(n);Ku=e*Ga(t),tf=e*Qa(t),nf=Qa(n),yf(Ku,tf,nf)}function Tf(t,n){t*=Ia;var e=Ga(n*=Ia),r=e*Ga(t),i=e*Qa(t),o=Qa(n),a=tf*o-nf*i,u=nf*r-Ku*o,f=Ku*i-tf*r,c=Ka(a*a+u*u+f*f),s=eu(c),l=c&&-s/c;$u+=l*a,Wu+=l*u,Zu+=l*f,Fu+=s,Xu+=s*(Ku+(Ku=r)),Gu+=s*(tf+(tf=i)),Vu+=s*(nf+(nf=o)),yf(Ku,tf,nf)}function Nf(t){return function(){return t}}function Sf(t,n){function e(e,r){return e=t(e,r),n(e[0],e[1])}return t.invert&&n.invert&&(e.invert=function(e,r){return(e=n.invert(e,r))&&t.invert(e[0],e[1])}),e}function Ef(t,n){return[t>qa?t-Ba:t<-qa?t+Ba:t,n]}function kf(t,n,e){return(t%=Ba)?n||e?Sf(Pf(t),zf(n,e)):Pf(t):n||e?zf(n,e):Ef}function Cf(t){return function(n,e){return[(n+=t)>qa?n-Ba:n<-qa?n+Ba:n,e]}}function Pf(t){var n=Cf(t);return n.invert=Cf(-t),n}function zf(t,n){var e=Ga(t),r=Qa(t),i=Ga(n),o=Qa(n);function a(t,n){var a=Ga(n),u=Ga(t)*a,f=Qa(t)*a,c=Qa(n),s=c*e+u*r;return[Xa(f*i-s*o,u*e-c*r),eu(s*i+f*o)]}return a.invert=function(t,n){var a=Ga(n),u=Ga(t)*a,f=Qa(t)*a,c=Qa(n),s=c*i-f*o;return[Xa(f*i+c*o,u*e+s*r),eu(s*e-u*r)]},a}function Rf(t){function n(n){return(n=t(n[0]*Ia,n[1]*Ia))[0]*=Fa,n[1]*=Fa,n}return t=kf(t[0]*Ia,t[1]*Ia,t.length>2?t[2]*Ia:0),n.invert=function(n){return(n=t.invert(n[0]*Ia,n[1]*Ia))[0]*=Fa,n[1]*=Fa,n},n}function Lf(t,n,e,r,i,o){if(e){var a=Ga(n),u=Qa(n),f=r*e;null==i?(i=n+r*Ba,o=n-f/2):(i=Df(a,i),o=Df(a,o),(r>0?i<o:i>o)&&(i+=r*Ba));for(var c,s=i;r>0?s>o:s<o;s-=f)c=Mu([a,-u*Ga(s),-u*Qa(s)]),t.point(c[0],c[1])}}function Df(t,n){(n=Au(n))[0]-=t,ku(n);var e=nu(-n[1]);return((-n[2]<0?-e:e)+Ba-Da)%Ba}function Uf(){var t,n=[];return{point:function(n,e){t.push([n,e])},lineStart:function(){n.push(t=[])},lineEnd:iu,rejoin:function(){n.length>1&&n.push(n.pop().concat(n.shift()))},result:function(){var e=n;return n=[],t=null,e}}}function qf(t,n){return Ha(t[0]-n[0])<Da&&Ha(t[1]-n[1])<Da}function Of(t,n,e,r){this.x=t,this.z=n,this.o=e,this.e=r,this.v=!1,this.n=this.p=null}function Yf(t,n,e,r,i){var o,a,u=[],f=[];if(t.forEach(function(t){if(!((n=t.length-1)<=0)){var n,e,r=t[0],a=t[n];if(qf(r,a)){for(i.lineStart(),o=0;o<n;++o)i.point((r=t[o])[0],r[1]);i.lineEnd()}else u.push(e=new Of(r,t,null,!0)),f.push(e.o=new Of(r,null,e,!1)),u.push(e=new Of(a,t,null,!1)),f.push(e.o=new Of(a,null,e,!0))}}),u.length){for(f.sort(n),Bf(u),Bf(f),o=0,a=f.length;o<a;++o)f[o].e=e=!e;for(var c,s,l=u[0];;){for(var h=l,d=!0;h.v;)if((h=h.n)===l)return;c=h.z,i.lineStart();do{if(h.v=h.o.v=!0,h.e){if(d)for(o=0,a=c.length;o<a;++o)i.point((s=c[o])[0],s[1]);else r(h.x,h.n.x,1,i);h=h.n}else{if(d)for(c=h.p.z,o=c.length-1;o>=0;--o)i.point((s=c[o])[0],s[1]);else r(h.x,h.p.x,-1,i);h=h.p}c=(h=h.o).z,d=!d}while(!h.v);i.lineEnd()}}}function Bf(t){if(n=t.length){for(var n,e,r=0,i=t[0];++r<n;)i.n=e=t[r],e.p=i,i=e;i.n=e=t[0],e.p=i}}Ef.invert=Ef;var Ff=Pa();function If(t,n){var e=n[0],r=n[1],i=Qa(r),o=[Qa(e),-Ga(e),0],a=0,u=0;Ff.reset(),1===i?r=Oa+Da:-1===i&&(r=-Oa-Da);for(var f=0,c=t.length;f<c;++f)if(l=(s=t[f]).length)for(var s,l,h=s[l-1],d=h[0],p=h[1]/2+Ya,v=Qa(p),g=Ga(p),y=0;y<l;++y,d=b,v=x,g=w,h=_){var _=s[y],b=_[0],m=_[1]/2+Ya,x=Qa(m),w=Ga(m),M=b-d,A=M>=0?1:-1,T=A*M,N=T>qa,S=v*x;if(Ff.add(Xa(S*A*Qa(T),g*w+S*Ga(T))),a+=N?M+A*Ba:M,N^d>=e^b>=e){var E=Nu(Au(h),Au(_));ku(E);var k=Nu(o,E);ku(k);var C=(N^M>=0?-1:1)*eu(k[2]);(r>C||r===C&&(E[0]||E[1]))&&(u+=N^M>=0?1:-1)}}return(a<-Da||a<Da&&Ff<-Da)^1&u}function Hf(t,n,e,r){return function(i){var o,a,u,f=n(i),c=Uf(),s=n(c),l=!1,h={point:d,lineStart:v,lineEnd:g,polygonStart:function(){h.point=y,h.lineStart=_,h.lineEnd=b,a=[],o=[]},polygonEnd:function(){h.point=d,h.lineStart=v,h.lineEnd=g,a=N(a);var t=If(o,r);a.length?(l||(i.polygonStart(),l=!0),Yf(a,Xf,t,e,i)):t&&(l||(i.polygonStart(),l=!0),i.lineStart(),e(null,null,1,i),i.lineEnd()),l&&(i.polygonEnd(),l=!1),a=o=null},sphere:function(){i.polygonStart(),i.lineStart(),e(null,null,1,i),i.lineEnd(),i.polygonEnd()}};function d(n,e){t(n,e)&&i.point(n,e)}function p(t,n){f.point(t,n)}function v(){h.point=p,f.lineStart()}function g(){h.point=d,f.lineEnd()}function y(t,n){u.push([t,n]),s.point(t,n)}function _(){s.lineStart(),u=[]}function b(){y(u[0][0],u[0][1]),s.lineEnd();var t,n,e,r,f=s.clean(),h=c.result(),d=h.length;if(u.pop(),o.push(u),u=null,d)if(1&f){if((n=(e=h[0]).length-1)>0){for(l||(i.polygonStart(),l=!0),i.lineStart(),t=0;t<n;++t)i.point((r=e[t])[0],r[1]);i.lineEnd()}}else d>1&&2&f&&h.push(h.pop().concat(h.shift())),a.push(h.filter(jf))}return h}}function jf(t){return t.length>1}function Xf(t,n){return((t=t.x)[0]<0?t[1]-Oa-Da:Oa-t[1])-((n=n.x)[0]<0?n[1]-Oa-Da:Oa-n[1])}var Gf=Hf(function(){return!0},function(t){var n,e=NaN,r=NaN,i=NaN;return{lineStart:function(){t.lineStart(),n=1},point:function(o,a){var u=o>0?qa:-qa,f=Ha(o-e);Ha(f-qa)<Da?(t.point(e,r=(r+a)/2>0?Oa:-Oa),t.point(i,r),t.lineEnd(),t.lineStart(),t.point(u,r),t.point(o,r),n=0):i!==u&&f>=qa&&(Ha(e-i)<Da&&(e-=i*Da),Ha(o-u)<Da&&(o-=u*Da),r=function(t,n,e,r){var i,o,a=Qa(t-e);return Ha(a)>Da?ja((Qa(n)*(o=Ga(r))*Qa(e)-Qa(r)*(i=Ga(n))*Qa(t))/(i*o*a)):(n+r)/2}(e,r,o,a),t.point(i,r),t.lineEnd(),t.lineStart(),t.point(u,r),n=0),t.point(e=o,r=a),i=u},lineEnd:function(){t.lineEnd(),e=r=NaN},clean:function(){return 2-n}}},function(t,n,e,r){var i;if(null==t)i=e*Oa,r.point(-qa,i),r.point(0,i),r.point(qa,i),r.point(qa,0),r.point(qa,-i),r.point(0,-i),r.point(-qa,-i),r.point(-qa,0),r.point(-qa,i);else if(Ha(t[0]-n[0])>Da){var o=t[0]<n[0]?qa:-qa;i=e*o/2,r.point(-o,i),r.point(0,i),r.point(o,i)}else r.point(n[0],n[1])},[-qa,-Oa]);function Vf(t){var n=Ga(t),e=6*Ia,r=n>0,i=Ha(n)>Da;function o(t,e){return Ga(t)*Ga(e)>n}function a(t,e,r){var i=[1,0,0],o=Nu(Au(t),Au(e)),a=Tu(o,o),u=o[0],f=a-u*u;if(!f)return!r&&t;var c=n*a/f,s=-n*u/f,l=Nu(i,o),h=Eu(i,c);Su(h,Eu(o,s));var d=l,p=Tu(h,d),v=Tu(d,d),g=p*p-v*(Tu(h,h)-1);if(!(g<0)){var y=Ka(g),_=Eu(d,(-p-y)/v);if(Su(_,h),_=Mu(_),!r)return _;var b,m=t[0],x=e[0],w=t[1],M=e[1];x<m&&(b=m,m=x,x=b);var A=x-m,T=Ha(A-qa)<Da;if(!T&&M<w&&(b=w,w=M,M=b),T||A<Da?T?w+M>0^_[1]<(Ha(_[0]-m)<Da?w:M):w<=_[1]&&_[1]<=M:A>qa^(m<=_[0]&&_[0]<=x)){var N=Eu(d,(-p+y)/v);return Su(N,h),[_,Mu(N)]}}}function u(n,e){var i=r?t:qa-t,o=0;return n<-i?o|=1:n>i&&(o|=2),e<-i?o|=4:e>i&&(o|=8),o}return Hf(o,function(t){var n,e,f,c,s;return{lineStart:function(){c=f=!1,s=1},point:function(l,h){var d,p=[l,h],v=o(l,h),g=r?v?0:u(l,h):v?u(l+(l<0?qa:-qa),h):0;if(!n&&(c=f=v)&&t.lineStart(),v!==f&&(!(d=a(n,p))||qf(n,d)||qf(p,d))&&(p[0]+=Da,p[1]+=Da,v=o(p[0],p[1])),v!==f)s=0,v?(t.lineStart(),d=a(p,n),t.point(d[0],d[1])):(d=a(n,p),t.point(d[0],d[1]),t.lineEnd()),n=d;else if(i&&n&&r^v){var y;g&e||!(y=a(p,n,!0))||(s=0,r?(t.lineStart(),t.point(y[0][0],y[0][1]),t.point(y[1][0],y[1][1]),t.lineEnd()):(t.point(y[1][0],y[1][1]),t.lineEnd(),t.lineStart(),t.point(y[0][0],y[0][1])))}!v||n&&qf(n,p)||t.point(p[0],p[1]),n=p,f=v,e=g},lineEnd:function(){f&&t.lineEnd(),n=null},clean:function(){return s|(c&&f)<<1}}},function(n,r,i,o){Lf(o,t,e,i,n,r)},r?[0,-t]:[-qa,t-qa])}var $f=1e9,Wf=-$f;function Zf(t,n,e,r){function i(i,o){return t<=i&&i<=e&&n<=o&&o<=r}function o(i,o,u,c){var s=0,l=0;if(null==i||(s=a(i,u))!==(l=a(o,u))||f(i,o)<0^u>0)do{c.point(0===s||3===s?t:e,s>1?r:n)}while((s=(s+u+4)%4)!==l);else c.point(o[0],o[1])}function a(r,i){return Ha(r[0]-t)<Da?i>0?0:3:Ha(r[0]-e)<Da?i>0?2:1:Ha(r[1]-n)<Da?i>0?1:0:i>0?3:2}function u(t,n){return f(t.x,n.x)}function f(t,n){var e=a(t,1),r=a(n,1);return e!==r?e-r:0===e?n[1]-t[1]:1===e?t[0]-n[0]:2===e?t[1]-n[1]:n[0]-t[0]}return function(a){var f,c,s,l,h,d,p,v,g,y,_,b=a,m=Uf(),x={point:w,lineStart:function(){x.point=M,c&&c.push(s=[]);y=!0,g=!1,p=v=NaN},lineEnd:function(){f&&(M(l,h),d&&g&&m.rejoin(),f.push(m.result()));x.point=w,g&&b.lineEnd()},polygonStart:function(){b=m,f=[],c=[],_=!0},polygonEnd:function(){var n=function(){for(var n=0,e=0,i=c.length;e<i;++e)for(var o,a,u=c[e],f=1,s=u.length,l=u[0],h=l[0],d=l[1];f<s;++f)o=h,a=d,l=u[f],h=l[0],d=l[1],a<=r?d>r&&(h-o)*(r-a)>(d-a)*(t-o)&&++n:d<=r&&(h-o)*(r-a)<(d-a)*(t-o)&&--n;return n}(),e=_&&n,i=(f=N(f)).length;(e||i)&&(a.polygonStart(),e&&(a.lineStart(),o(null,null,1,a),a.lineEnd()),i&&Yf(f,u,n,o,a),a.polygonEnd());b=a,f=c=s=null}};function w(t,n){i(t,n)&&b.point(t,n)}function M(o,a){var u=i(o,a);if(c&&s.push([o,a]),y)l=o,h=a,d=u,y=!1,u&&(b.lineStart(),b.point(o,a));else if(u&&g)b.point(o,a);else{var f=[p=Math.max(Wf,Math.min($f,p)),v=Math.max(Wf,Math.min($f,v))],m=[o=Math.max(Wf,Math.min($f,o)),a=Math.max(Wf,Math.min($f,a))];!function(t,n,e,r,i,o){var a,u=t[0],f=t[1],c=0,s=1,l=n[0]-u,h=n[1]-f;if(a=e-u,l||!(a>0)){if(a/=l,l<0){if(a<c)return;a<s&&(s=a)}else if(l>0){if(a>s)return;a>c&&(c=a)}if(a=i-u,l||!(a<0)){if(a/=l,l<0){if(a>s)return;a>c&&(c=a)}else if(l>0){if(a<c)return;a<s&&(s=a)}if(a=r-f,h||!(a>0)){if(a/=h,h<0){if(a<c)return;a<s&&(s=a)}else if(h>0){if(a>s)return;a>c&&(c=a)}if(a=o-f,h||!(a<0)){if(a/=h,h<0){if(a>s)return;a>c&&(c=a)}else if(h>0){if(a<c)return;a<s&&(s=a)}return c>0&&(t[0]=u+c*l,t[1]=f+c*h),s<1&&(n[0]=u+s*l,n[1]=f+s*h),!0}}}}}(f,m,t,n,e,r)?u&&(b.lineStart(),b.point(o,a),_=!1):(g||(b.lineStart(),b.point(f[0],f[1])),b.point(m[0],m[1]),u||b.lineEnd(),_=!1)}p=o,v=a,g=u}return x}}var Qf,Jf,Kf,tc=Pa(),nc={sphere:iu,point:iu,lineStart:function(){nc.point=rc,nc.lineEnd=ec},lineEnd:iu,polygonStart:iu,polygonEnd:iu};function ec(){nc.point=nc.lineEnd=iu}function rc(t,n){Qf=t*=Ia,Jf=Qa(n*=Ia),Kf=Ga(n),nc.point=ic}function ic(t,n){t*=Ia;var e=Qa(n*=Ia),r=Ga(n),i=Ha(t-Qf),o=Ga(i),a=r*Qa(i),u=Kf*e-Jf*r*o,f=Jf*e+Kf*r*o;tc.add(Xa(Ka(a*a+u*u),f)),Qf=t,Jf=e,Kf=r}function oc(t){return tc.reset(),su(t,nc),+tc}var ac=[null,null],uc={type:"LineString",coordinates:ac};function fc(t,n){return ac[0]=t,ac[1]=n,oc(uc)}var cc={Feature:function(t,n){return lc(t.geometry,n)},FeatureCollection:function(t,n){for(var e=t.features,r=-1,i=e.length;++r<i;)if(lc(e[r].geometry,n))return!0;return!1}},sc={Sphere:function(){return!0},Point:function(t,n){return hc(t.coordinates,n)},MultiPoint:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)if(hc(e[r],n))return!0;return!1},LineString:function(t,n){return dc(t.coordinates,n)},MultiLineString:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)if(dc(e[r],n))return!0;return!1},Polygon:function(t,n){return pc(t.coordinates,n)},MultiPolygon:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)if(pc(e[r],n))return!0;return!1},GeometryCollection:function(t,n){for(var e=t.geometries,r=-1,i=e.length;++r<i;)if(lc(e[r],n))return!0;return!1}};function lc(t,n){return!(!t||!sc.hasOwnProperty(t.type))&&sc[t.type](t,n)}function hc(t,n){return 0===fc(t,n)}function dc(t,n){var e=fc(t[0],t[1]);return fc(t[0],n)+fc(n,t[1])<=e+Da}function pc(t,n){return!!If(t.map(vc),gc(n))}function vc(t){return(t=t.map(gc)).pop(),t}function gc(t){return[t[0]*Ia,t[1]*Ia]}function yc(t,n,e){var r=g(t,n-Da,e).concat(n);return function(t){return r.map(function(n){return[t,n]})}}function _c(t,n,e){var r=g(t,n-Da,e).concat(n);return function(t){return r.map(function(n){return[n,t]})}}function bc(){var t,n,e,r,i,o,a,u,f,c,s,l,h=10,d=h,p=90,v=360,y=2.5;function _(){return{type:"MultiLineString",coordinates:b()}}function b(){return g(Va(r/p)*p,e,p).map(s).concat(g(Va(u/v)*v,a,v).map(l)).concat(g(Va(n/h)*h,t,h).filter(function(t){return Ha(t%p)>Da}).map(f)).concat(g(Va(o/d)*d,i,d).filter(function(t){return Ha(t%v)>Da}).map(c))}return _.lines=function(){return b().map(function(t){return{type:"LineString",coordinates:t}})},_.outline=function(){return{type:"Polygon",coordinates:[s(r).concat(l(a).slice(1),s(e).reverse().slice(1),l(u).reverse().slice(1))]}},_.extent=function(t){return arguments.length?_.extentMajor(t).extentMinor(t):_.extentMinor()},_.extentMajor=function(t){return arguments.length?(r=+t[0][0],e=+t[1][0],u=+t[0][1],a=+t[1][1],r>e&&(t=r,r=e,e=t),u>a&&(t=u,u=a,a=t),_.precision(y)):[[r,u],[e,a]]},_.extentMinor=function(e){return arguments.length?(n=+e[0][0],t=+e[1][0],o=+e[0][1],i=+e[1][1],n>t&&(e=n,n=t,t=e),o>i&&(e=o,o=i,i=e),_.precision(y)):[[n,o],[t,i]]},_.step=function(t){return arguments.length?_.stepMajor(t).stepMinor(t):_.stepMinor()},_.stepMajor=function(t){return arguments.length?(p=+t[0],v=+t[1],_):[p,v]},_.stepMinor=function(t){return arguments.length?(h=+t[0],d=+t[1],_):[h,d]},_.precision=function(h){return arguments.length?(y=+h,f=yc(o,i,90),c=_c(n,t,y),s=yc(u,a,90),l=_c(r,e,y),_):y},_.extentMajor([[-180,-90+Da],[180,90-Da]]).extentMinor([[-180,-80-Da],[180,80+Da]])}function mc(t){return t}var xc,wc,Mc,Ac,Tc=Pa(),Nc=Pa(),Sc={point:iu,lineStart:iu,lineEnd:iu,polygonStart:function(){Sc.lineStart=Ec,Sc.lineEnd=Pc},polygonEnd:function(){Sc.lineStart=Sc.lineEnd=Sc.point=iu,Tc.add(Ha(Nc)),Nc.reset()},result:function(){var t=Tc/2;return Tc.reset(),t}};function Ec(){Sc.point=kc}function kc(t,n){Sc.point=Cc,xc=Mc=t,wc=Ac=n}function Cc(t,n){Nc.add(Ac*t-Mc*n),Mc=t,Ac=n}function Pc(){Cc(xc,wc)}var zc=1/0,Rc=zc,Lc=-zc,Dc=Lc,Uc={point:function(t,n){t<zc&&(zc=t);t>Lc&&(Lc=t);n<Rc&&(Rc=n);n>Dc&&(Dc=n)},lineStart:iu,lineEnd:iu,polygonStart:iu,polygonEnd:iu,result:function(){var t=[[zc,Rc],[Lc,Dc]];return Lc=Dc=-(Rc=zc=1/0),t}};var qc,Oc,Yc,Bc,Fc=0,Ic=0,Hc=0,jc=0,Xc=0,Gc=0,Vc=0,$c=0,Wc=0,Zc={point:Qc,lineStart:Jc,lineEnd:ns,polygonStart:function(){Zc.lineStart=es,Zc.lineEnd=rs},polygonEnd:function(){Zc.point=Qc,Zc.lineStart=Jc,Zc.lineEnd=ns},result:function(){var t=Wc?[Vc/Wc,$c/Wc]:Gc?[jc/Gc,Xc/Gc]:Hc?[Fc/Hc,Ic/Hc]:[NaN,NaN];return Fc=Ic=Hc=jc=Xc=Gc=Vc=$c=Wc=0,t}};function Qc(t,n){Fc+=t,Ic+=n,++Hc}function Jc(){Zc.point=Kc}function Kc(t,n){Zc.point=ts,Qc(Yc=t,Bc=n)}function ts(t,n){var e=t-Yc,r=n-Bc,i=Ka(e*e+r*r);jc+=i*(Yc+t)/2,Xc+=i*(Bc+n)/2,Gc+=i,Qc(Yc=t,Bc=n)}function ns(){Zc.point=Qc}function es(){Zc.point=is}function rs(){os(qc,Oc)}function is(t,n){Zc.point=os,Qc(qc=Yc=t,Oc=Bc=n)}function os(t,n){var e=t-Yc,r=n-Bc,i=Ka(e*e+r*r);jc+=i*(Yc+t)/2,Xc+=i*(Bc+n)/2,Gc+=i,Vc+=(i=Bc*t-Yc*n)*(Yc+t),$c+=i*(Bc+n),Wc+=3*i,Qc(Yc=t,Bc=n)}function as(t){this._context=t}as.prototype={_radius:4.5,pointRadius:function(t){return this._radius=t,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._context.closePath(),this._point=NaN},point:function(t,n){switch(this._point){case 0:this._context.moveTo(t,n),this._point=1;break;case 1:this._context.lineTo(t,n);break;default:this._context.moveTo(t+this._radius,n),this._context.arc(t,n,this._radius,0,Ba)}},result:iu};var us,fs,cs,ss,ls,hs=Pa(),ds={point:iu,lineStart:function(){ds.point=ps},lineEnd:function(){us&&vs(fs,cs),ds.point=iu},polygonStart:function(){us=!0},polygonEnd:function(){us=null},result:function(){var t=+hs;return hs.reset(),t}};function ps(t,n){ds.point=vs,fs=ss=t,cs=ls=n}function vs(t,n){ss-=t,ls-=n,hs.add(Ka(ss*ss+ls*ls)),ss=t,ls=n}function gs(){this._string=[]}function ys(t){return"m0,"+t+"a"+t+","+t+" 0 1,1 0,"+-2*t+"a"+t+","+t+" 0 1,1 0,"+2*t+"z"}function _s(t){return function(n){var e=new bs;for(var r in t)e[r]=t[r];return e.stream=n,e}}function bs(){}function ms(t,n,e){var r=t.clipExtent&&t.clipExtent();return t.scale(150).translate([0,0]),null!=r&&t.clipExtent(null),su(e,t.stream(Uc)),n(Uc.result()),null!=r&&t.clipExtent(r),t}function xs(t,n,e){return ms(t,function(e){var r=n[1][0]-n[0][0],i=n[1][1]-n[0][1],o=Math.min(r/(e[1][0]-e[0][0]),i/(e[1][1]-e[0][1])),a=+n[0][0]+(r-o*(e[1][0]+e[0][0]))/2,u=+n[0][1]+(i-o*(e[1][1]+e[0][1]))/2;t.scale(150*o).translate([a,u])},e)}function ws(t,n,e){return xs(t,[[0,0],n],e)}function Ms(t,n,e){return ms(t,function(e){var r=+n,i=r/(e[1][0]-e[0][0]),o=(r-i*(e[1][0]+e[0][0]))/2,a=-i*e[0][1];t.scale(150*i).translate([o,a])},e)}function As(t,n,e){return ms(t,function(e){var r=+n,i=r/(e[1][1]-e[0][1]),o=-i*e[0][0],a=(r-i*(e[1][1]+e[0][1]))/2;t.scale(150*i).translate([o,a])},e)}gs.prototype={_radius:4.5,_circle:ys(4.5),pointRadius:function(t){return(t=+t)!==this._radius&&(this._radius=t,this._circle=null),this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._string.push("Z"),this._point=NaN},point:function(t,n){switch(this._point){case 0:this._string.push("M",t,",",n),this._point=1;break;case 1:this._string.push("L",t,",",n);break;default:null==this._circle&&(this._circle=ys(this._radius)),this._string.push("M",t,",",n,this._circle)}},result:function(){if(this._string.length){var t=this._string.join("");return this._string=[],t}return null}},bs.prototype={constructor:bs,point:function(t,n){this.stream.point(t,n)},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()}};var Ts=16,Ns=Ga(30*Ia);function Ss(t,n){return+n?function(t,n){function e(r,i,o,a,u,f,c,s,l,h,d,p,v,g){var y=c-r,_=s-i,b=y*y+_*_;if(b>4*n&&v--){var m=a+h,x=u+d,w=f+p,M=Ka(m*m+x*x+w*w),A=eu(w/=M),T=Ha(Ha(w)-1)<Da||Ha(o-l)<Da?(o+l)/2:Xa(x,m),N=t(T,A),S=N[0],E=N[1],k=S-r,C=E-i,P=_*k-y*C;(P*P/b>n||Ha((y*k+_*C)/b-.5)>.3||a*h+u*d+f*p<Ns)&&(e(r,i,o,a,u,f,S,E,T,m/=M,x/=M,w,v,g),g.point(S,E),e(S,E,T,m,x,w,c,s,l,h,d,p,v,g))}}return function(n){var r,i,o,a,u,f,c,s,l,h,d,p,v={point:g,lineStart:y,lineEnd:b,polygonStart:function(){n.polygonStart(),v.lineStart=m},polygonEnd:function(){n.polygonEnd(),v.lineStart=y}};function g(e,r){e=t(e,r),n.point(e[0],e[1])}function y(){s=NaN,v.point=_,n.lineStart()}function _(r,i){var o=Au([r,i]),a=t(r,i);e(s,l,c,h,d,p,s=a[0],l=a[1],c=r,h=o[0],d=o[1],p=o[2],Ts,n),n.point(s,l)}function b(){v.point=g,n.lineEnd()}function m(){y(),v.point=x,v.lineEnd=w}function x(t,n){_(r=t,n),i=s,o=l,a=h,u=d,f=p,v.point=_}function w(){e(s,l,c,h,d,p,i,o,r,a,u,f,Ts,n),v.lineEnd=b,b()}return v}}(t,n):function(t){return _s({point:function(n,e){n=t(n,e),this.stream.point(n[0],n[1])}})}(t)}var Es=_s({point:function(t,n){this.stream.point(t*Ia,n*Ia)}});function ks(t,n,e,r){var i=Ga(r),o=Qa(r),a=i*t,u=o*t,f=i/t,c=o/t,s=(o*e-i*n)/t,l=(o*n+i*e)/t;function h(t,r){return[a*t-u*r+n,e-u*t-a*r]}return h.invert=function(t,n){return[f*t-c*n+s,l-c*t-f*n]},h}function Cs(t){return Ps(function(){return t})()}function Ps(t){var n,e,r,i,o,a,u,f,c,s,l=150,h=480,d=250,p=0,v=0,g=0,y=0,_=0,b=0,m=null,x=Gf,w=null,M=mc,A=.5;function T(t){return f(t[0]*Ia,t[1]*Ia)}function N(t){return(t=f.invert(t[0],t[1]))&&[t[0]*Fa,t[1]*Fa]}function S(){var t=ks(l,0,0,b).apply(null,n(p,v)),r=(b?ks:function(t,n,e){function r(r,i){return[n+t*r,e-t*i]}return r.invert=function(r,i){return[(r-n)/t,(e-i)/t]},r})(l,h-t[0],d-t[1],b);return e=kf(g,y,_),u=Sf(n,r),f=Sf(e,u),a=Ss(u,A),E()}function E(){return c=s=null,T}return T.stream=function(t){return c&&s===t?c:c=Es(function(t){return _s({point:function(n,e){var r=t(n,e);return this.stream.point(r[0],r[1])}})}(e)(x(a(M(s=t)))))},T.preclip=function(t){return arguments.length?(x=t,m=void 0,E()):x},T.postclip=function(t){return arguments.length?(M=t,w=r=i=o=null,E()):M},T.clipAngle=function(t){return arguments.length?(x=+t?Vf(m=t*Ia):(m=null,Gf),E()):m*Fa},T.clipExtent=function(t){return arguments.length?(M=null==t?(w=r=i=o=null,mc):Zf(w=+t[0][0],r=+t[0][1],i=+t[1][0],o=+t[1][1]),E()):null==w?null:[[w,r],[i,o]]},T.scale=function(t){return arguments.length?(l=+t,S()):l},T.translate=function(t){return arguments.length?(h=+t[0],d=+t[1],S()):[h,d]},T.center=function(t){return arguments.length?(p=t[0]%360*Ia,v=t[1]%360*Ia,S()):[p*Fa,v*Fa]},T.rotate=function(t){return arguments.length?(g=t[0]%360*Ia,y=t[1]%360*Ia,_=t.length>2?t[2]%360*Ia:0,S()):[g*Fa,y*Fa,_*Fa]},T.angle=function(t){return arguments.length?(b=t%360*Ia,S()):b*Fa},T.precision=function(t){return arguments.length?(a=Ss(u,A=t*t),E()):Ka(A)},T.fitExtent=function(t,n){return xs(T,t,n)},T.fitSize=function(t,n){return ws(T,t,n)},T.fitWidth=function(t,n){return Ms(T,t,n)},T.fitHeight=function(t,n){return As(T,t,n)},function(){return n=t.apply(this,arguments),T.invert=n.invert&&N,S()}}function zs(t){var n=0,e=qa/3,r=Ps(t),i=r(n,e);return i.parallels=function(t){return arguments.length?r(n=t[0]*Ia,e=t[1]*Ia):[n*Fa,e*Fa]},i}function Rs(t,n){var e=Qa(t),r=(e+Qa(n))/2;if(Ha(r)<Da)return function(t){var n=Ga(t);function e(t,e){return[t*n,Qa(e)/n]}return e.invert=function(t,e){return[t/n,eu(e*n)]},e}(t);var i=1+e*(2*r-e),o=Ka(i)/r;function a(t,n){var e=Ka(i-2*r*Qa(n))/r;return[e*Qa(t*=r),o-e*Ga(t)]}return a.invert=function(t,n){var e=o-n;return[Xa(t,Ha(e))/r*Ja(e),eu((i-(t*t+e*e)*r*r)/(2*r))]},a}function Ls(){return zs(Rs).scale(155.424).center([0,33.6442])}function Ds(){return Ls().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}function Us(t){return function(n,e){var r=Ga(n),i=Ga(e),o=t(r*i);return[o*i*Qa(n),o*Qa(e)]}}function qs(t){return function(n,e){var r=Ka(n*n+e*e),i=t(r),o=Qa(i),a=Ga(i);return[Xa(n*o,r*a),eu(r&&e*o/r)]}}var Os=Us(function(t){return Ka(2/(1+t))});Os.invert=qs(function(t){return 2*eu(t/2)});var Ys=Us(function(t){return(t=nu(t))&&t/Qa(t)});function Bs(t,n){return[t,Wa(tu((Oa+n)/2))]}function Fs(t){var n,e,r,i=Cs(t),o=i.center,a=i.scale,u=i.translate,f=i.clipExtent,c=null;function s(){var o=qa*a(),u=i(Rf(i.rotate()).invert([0,0]));return f(null==c?[[u[0]-o,u[1]-o],[u[0]+o,u[1]+o]]:t===Bs?[[Math.max(u[0]-o,c),n],[Math.min(u[0]+o,e),r]]:[[c,Math.max(u[1]-o,n)],[e,Math.min(u[1]+o,r)]])}return i.scale=function(t){return arguments.length?(a(t),s()):a()},i.translate=function(t){return arguments.length?(u(t),s()):u()},i.center=function(t){return arguments.length?(o(t),s()):o()},i.clipExtent=function(t){return arguments.length?(null==t?c=n=e=r=null:(c=+t[0][0],n=+t[0][1],e=+t[1][0],r=+t[1][1]),s()):null==c?null:[[c,n],[e,r]]},s()}function Is(t){return tu((Oa+t)/2)}function Hs(t,n){var e=Ga(t),r=t===n?Qa(t):Wa(e/Ga(n))/Wa(Is(n)/Is(t)),i=e*Za(Is(t),r)/r;if(!r)return Bs;function o(t,n){i>0?n<-Oa+Da&&(n=-Oa+Da):n>Oa-Da&&(n=Oa-Da);var e=i/Za(Is(n),r);return[e*Qa(r*t),i-e*Ga(r*t)]}return o.invert=function(t,n){var e=i-n,o=Ja(r)*Ka(t*t+e*e);return[Xa(t,Ha(e))/r*Ja(e),2*ja(Za(i/o,1/r))-Oa]},o}function js(t,n){return[t,n]}function Xs(t,n){var e=Ga(t),r=t===n?Qa(t):(e-Ga(n))/(n-t),i=e/r+t;if(Ha(r)<Da)return js;function o(t,n){var e=i-n,o=r*t;return[e*Qa(o),i-e*Ga(o)]}return o.invert=function(t,n){var e=i-n;return[Xa(t,Ha(e))/r*Ja(e),i-Ja(r)*Ka(t*t+e*e)]},o}Ys.invert=qs(function(t){return t}),Bs.invert=function(t,n){return[t,2*ja($a(n))-Oa]},js.invert=js;var Gs=1.340264,Vs=-.081106,$s=893e-6,Ws=.003796,Zs=Ka(3)/2;function Qs(t,n){var e=eu(Zs*Qa(n)),r=e*e,i=r*r*r;return[t*Ga(e)/(Zs*(Gs+3*Vs*r+i*(7*$s+9*Ws*r))),e*(Gs+Vs*r+i*($s+Ws*r))]}function Js(t,n){var e=Ga(n),r=Ga(t)*e;return[e*Qa(t)/r,Qa(n)/r]}function Ks(t,n,e,r){return 1===t&&1===n&&0===e&&0===r?mc:_s({point:function(i,o){this.stream.point(i*t+e,o*n+r)}})}function tl(t,n){var e=n*n,r=e*e;return[t*(.8707-.131979*e+r*(r*(.003971*e-.001529*r)-.013791)),n*(1.007226+e*(.015085+r*(.028874*e-.044475-.005916*r)))]}function nl(t,n){return[Ga(n)*Qa(t),Qa(n)]}function el(t,n){var e=Ga(n),r=1+Ga(t)*e;return[e*Qa(t)/r,Qa(n)/r]}function rl(t,n){return[Wa(tu((Oa+n)/2)),-t]}function il(t,n){return t.parent===n.parent?1:2}function ol(t,n){return t+n.x}function al(t,n){return Math.max(t,n.y)}function ul(t){var n=0,e=t.children,r=e&&e.length;if(r)for(;--r>=0;)n+=e[r].value;else n=1;t.value=n}function fl(t,n){var e,r,i,o,a,u=new hl(t),f=+t.value&&(u.value=t.value),c=[u];for(null==n&&(n=cl);e=c.pop();)if(f&&(e.value=+e.data.value),(i=n(e.data))&&(a=i.length))for(e.children=new Array(a),o=a-1;o>=0;--o)c.push(r=e.children[o]=new hl(i[o])),r.parent=e,r.depth=e.depth+1;return u.eachBefore(ll)}function cl(t){return t.children}function sl(t){t.data=t.data.data}function ll(t){var n=0;do{t.height=n}while((t=t.parent)&&t.height<++n)}function hl(t){this.data=t,this.depth=this.height=0,this.parent=null}Qs.invert=function(t,n){for(var e,r=n,i=r*r,o=i*i*i,a=0;a<12&&(o=(i=(r-=e=(r*(Gs+Vs*i+o*($s+Ws*i))-n)/(Gs+3*Vs*i+o*(7*$s+9*Ws*i)))*r)*i*i,!(Ha(e)<Ua));++a);return[Zs*t*(Gs+3*Vs*i+o*(7*$s+9*Ws*i))/Ga(r),eu(Qa(r)/Zs)]},Js.invert=qs(ja),tl.invert=function(t,n){var e,r=n,i=25;do{var o=r*r,a=o*o;r-=e=(r*(1.007226+o*(.015085+a*(.028874*o-.044475-.005916*a)))-n)/(1.007226+o*(.045255+a*(.259866*o-.311325-.005916*11*a)))}while(Ha(e)>Da&&--i>0);return[t/(.8707+(o=r*r)*(o*(o*o*o*(.003971-.001529*o)-.013791)-.131979)),r]},nl.invert=qs(eu),el.invert=qs(function(t){return 2*ja(t)}),rl.invert=function(t,n){return[-n,2*ja($a(t))-Oa]},hl.prototype=fl.prototype={constructor:hl,count:function(){return this.eachAfter(ul)},each:function(t){var n,e,r,i,o=this,a=[o];do{for(n=a.reverse(),a=[];o=n.pop();)if(t(o),e=o.children)for(r=0,i=e.length;r<i;++r)a.push(e[r])}while(a.length);return this},eachAfter:function(t){for(var n,e,r,i=this,o=[i],a=[];i=o.pop();)if(a.push(i),n=i.children)for(e=0,r=n.length;e<r;++e)o.push(n[e]);for(;i=a.pop();)t(i);return this},eachBefore:function(t){for(var n,e,r=this,i=[r];r=i.pop();)if(t(r),n=r.children)for(e=n.length-1;e>=0;--e)i.push(n[e]);return this},sum:function(t){return this.eachAfter(function(n){for(var e=+t(n.data)||0,r=n.children,i=r&&r.length;--i>=0;)e+=r[i].value;n.value=e})},sort:function(t){return this.eachBefore(function(n){n.children&&n.children.sort(t)})},path:function(t){for(var n=this,e=function(t,n){if(t===n)return t;var e=t.ancestors(),r=n.ancestors(),i=null;for(t=e.pop(),n=r.pop();t===n;)i=t,t=e.pop(),n=r.pop();return i}(n,t),r=[n];n!==e;)n=n.parent,r.push(n);for(var i=r.length;t!==e;)r.splice(i,0,t),t=t.parent;return r},ancestors:function(){for(var t=this,n=[t];t=t.parent;)n.push(t);return n},descendants:function(){var t=[];return this.each(function(n){t.push(n)}),t},leaves:function(){var t=[];return this.eachBefore(function(n){n.children||t.push(n)}),t},links:function(){var t=this,n=[];return t.each(function(e){e!==t&&n.push({source:e.parent,target:e})}),n},copy:function(){return fl(this).eachBefore(sl)}};var dl=Array.prototype.slice;function pl(t){for(var n,e,r=0,i=(t=function(t){for(var n,e,r=t.length;r;)e=Math.random()*r--|0,n=t[r],t[r]=t[e],t[e]=n;return t}(dl.call(t))).length,o=[];r<i;)n=t[r],e&&yl(e,n)?++r:(e=bl(o=vl(o,n)),r=0);return e}function vl(t,n){var e,r;if(_l(n,t))return[n];for(e=0;e<t.length;++e)if(gl(n,t[e])&&_l(ml(t[e],n),t))return[t[e],n];for(e=0;e<t.length-1;++e)for(r=e+1;r<t.length;++r)if(gl(ml(t[e],t[r]),n)&&gl(ml(t[e],n),t[r])&&gl(ml(t[r],n),t[e])&&_l(xl(t[e],t[r],n),t))return[t[e],t[r],n];throw new Error}function gl(t,n){var e=t.r-n.r,r=n.x-t.x,i=n.y-t.y;return e<0||e*e<r*r+i*i}function yl(t,n){var e=t.r-n.r+1e-6,r=n.x-t.x,i=n.y-t.y;return e>0&&e*e>r*r+i*i}function _l(t,n){for(var e=0;e<n.length;++e)if(!yl(t,n[e]))return!1;return!0}function bl(t){switch(t.length){case 1:return{x:(n=t[0]).x,y:n.y,r:n.r};case 2:return ml(t[0],t[1]);case 3:return xl(t[0],t[1],t[2])}var n}function ml(t,n){var e=t.x,r=t.y,i=t.r,o=n.x,a=n.y,u=n.r,f=o-e,c=a-r,s=u-i,l=Math.sqrt(f*f+c*c);return{x:(e+o+f/l*s)/2,y:(r+a+c/l*s)/2,r:(l+i+u)/2}}function xl(t,n,e){var r=t.x,i=t.y,o=t.r,a=n.x,u=n.y,f=n.r,c=e.x,s=e.y,l=e.r,h=r-a,d=r-c,p=i-u,v=i-s,g=f-o,y=l-o,_=r*r+i*i-o*o,b=_-a*a-u*u+f*f,m=_-c*c-s*s+l*l,x=d*p-h*v,w=(p*m-v*b)/(2*x)-r,M=(v*g-p*y)/x,A=(d*b-h*m)/(2*x)-i,T=(h*y-d*g)/x,N=M*M+T*T-1,S=2*(o+w*M+A*T),E=w*w+A*A-o*o,k=-(N?(S+Math.sqrt(S*S-4*N*E))/(2*N):E/S);return{x:r+w+M*k,y:i+A+T*k,r:k}}function wl(t,n,e){var r,i,o,a,u=t.x-n.x,f=t.y-n.y,c=u*u+f*f;c?(i=n.r+e.r,i*=i,a=t.r+e.r,i>(a*=a)?(r=(c+a-i)/(2*c),o=Math.sqrt(Math.max(0,a/c-r*r)),e.x=t.x-r*u-o*f,e.y=t.y-r*f+o*u):(r=(c+i-a)/(2*c),o=Math.sqrt(Math.max(0,i/c-r*r)),e.x=n.x+r*u-o*f,e.y=n.y+r*f+o*u)):(e.x=n.x+e.r,e.y=n.y)}function Ml(t,n){var e=t.r+n.r-1e-6,r=n.x-t.x,i=n.y-t.y;return e>0&&e*e>r*r+i*i}function Al(t){var n=t._,e=t.next._,r=n.r+e.r,i=(n.x*e.r+e.x*n.r)/r,o=(n.y*e.r+e.y*n.r)/r;return i*i+o*o}function Tl(t){this._=t,this.next=null,this.previous=null}function Nl(t){if(!(i=t.length))return 0;var n,e,r,i,o,a,u,f,c,s,l;if((n=t[0]).x=0,n.y=0,!(i>1))return n.r;if(e=t[1],n.x=-e.r,e.x=n.r,e.y=0,!(i>2))return n.r+e.r;wl(e,n,r=t[2]),n=new Tl(n),e=new Tl(e),r=new Tl(r),n.next=r.previous=e,e.next=n.previous=r,r.next=e.previous=n;t:for(u=3;u<i;++u){wl(n._,e._,r=t[u]),r=new Tl(r),f=e.next,c=n.previous,s=e._.r,l=n._.r;do{if(s<=l){if(Ml(f._,r._)){e=f,n.next=e,e.previous=n,--u;continue t}s+=f._.r,f=f.next}else{if(Ml(c._,r._)){(n=c).next=e,e.previous=n,--u;continue t}l+=c._.r,c=c.previous}}while(f!==c.next);for(r.previous=n,r.next=e,n.next=e.previous=e=r,o=Al(n);(r=r.next)!==e;)(a=Al(r))<o&&(n=r,o=a);e=n.next}for(n=[e._],r=e;(r=r.next)!==e;)n.push(r._);for(r=pl(n),u=0;u<i;++u)(n=t[u]).x-=r.x,n.y-=r.y;return r.r}function Sl(t){if("function"!=typeof t)throw new Error;return t}function El(){return 0}function kl(t){return function(){return t}}function Cl(t){return Math.sqrt(t.value)}function Pl(t){return function(n){n.children||(n.r=Math.max(0,+t(n)||0))}}function zl(t,n){return function(e){if(r=e.children){var r,i,o,a=r.length,u=t(e)*n||0;if(u)for(i=0;i<a;++i)r[i].r+=u;if(o=Nl(r),u)for(i=0;i<a;++i)r[i].r-=u;e.r=o+u}}}function Rl(t){return function(n){var e=n.parent;n.r*=t,e&&(n.x=e.x+t*n.x,n.y=e.y+t*n.y)}}function Ll(t){t.x0=Math.round(t.x0),t.y0=Math.round(t.y0),t.x1=Math.round(t.x1),t.y1=Math.round(t.y1)}function Dl(t,n,e,r,i){for(var o,a=t.children,u=-1,f=a.length,c=t.value&&(r-n)/t.value;++u<f;)(o=a[u]).y0=e,o.y1=i,o.x0=n,o.x1=n+=o.value*c}var Ul="$",ql={depth:-1},Ol={};function Yl(t){return t.id}function Bl(t){return t.parentId}function Fl(t,n){return t.parent===n.parent?1:2}function Il(t){var n=t.children;return n?n[0]:t.t}function Hl(t){var n=t.children;return n?n[n.length-1]:t.t}function jl(t,n,e){var r=e/(n.i-t.i);n.c-=r,n.s+=e,t.c+=r,n.z+=e,n.m+=e}function Xl(t,n,e){return t.a.parent===n.parent?t.a:e}function Gl(t,n){this._=t,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=n}function Vl(t,n,e,r,i){for(var o,a=t.children,u=-1,f=a.length,c=t.value&&(i-e)/t.value;++u<f;)(o=a[u]).x0=n,o.x1=r,o.y0=e,o.y1=e+=o.value*c}Gl.prototype=Object.create(hl.prototype);var $l=(1+Math.sqrt(5))/2;function Wl(t,n,e,r,i,o){for(var a,u,f,c,s,l,h,d,p,v,g,y=[],_=n.children,b=0,m=0,x=_.length,w=n.value;b<x;){f=i-e,c=o-r;do{s=_[m++].value}while(!s&&m<x);for(l=h=s,g=s*s*(v=Math.max(c/f,f/c)/(w*t)),p=Math.max(h/g,g/l);m<x;++m){if(s+=u=_[m].value,u<l&&(l=u),u>h&&(h=u),g=s*s*v,(d=Math.max(h/g,g/l))>p){s-=u;break}p=d}y.push(a={value:s,dice:f<c,children:_.slice(b,m)}),a.dice?Dl(a,e,r,i,w?r+=c*s/w:o):Vl(a,e,r,w?e+=f*s/w:i,o),w-=s,b=m}return y}var Zl=function t(n){function e(t,e,r,i,o){Wl(n,t,e,r,i,o)}return e.ratio=function(n){return t((n=+n)>1?n:1)},e}($l);var Ql=function t(n){function e(t,e,r,i,o){if((a=t._squarify)&&a.ratio===n)for(var a,u,f,c,s,l=-1,h=a.length,d=t.value;++l<h;){for(f=(u=a[l]).children,c=u.value=0,s=f.length;c<s;++c)u.value+=f[c].value;u.dice?Dl(u,e,r,i,r+=(o-r)*u.value/d):Vl(u,e,r,e+=(i-e)*u.value/d,o),d-=u.value}else t._squarify=a=Wl(n,t,e,r,i,o),a.ratio=n}return e.ratio=function(n){return t((n=+n)>1?n:1)},e}($l);function Jl(t,n){return t[0]-n[0]||t[1]-n[1]}function Kl(t){for(var n,e,r,i=t.length,o=[0,1],a=2,u=2;u<i;++u){for(;a>1&&(n=t[o[a-2]],e=t[o[a-1]],r=t[u],(e[0]-n[0])*(r[1]-n[1])-(e[1]-n[1])*(r[0]-n[0])<=0);)--a;o[a++]=u}return o.slice(0,a)}function th(){return Math.random()}var nh=function t(n){function e(t,e){return t=null==t?0:+t,e=null==e?1:+e,1===arguments.length?(e=t,t=0):e-=t,function(){return n()*e+t}}return e.source=t,e}(th),eh=function t(n){function e(t,e){var r,i;return t=null==t?0:+t,e=null==e?1:+e,function(){var o;if(null!=r)o=r,r=null;else do{r=2*n()-1,o=2*n()-1,i=r*r+o*o}while(!i||i>1);return t+e*o*Math.sqrt(-2*Math.log(i)/i)}}return e.source=t,e}(th),rh=function t(n){function e(){var t=eh.source(n).apply(this,arguments);return function(){return Math.exp(t())}}return e.source=t,e}(th),ih=function t(n){function e(t){return function(){for(var e=0,r=0;r<t;++r)e+=n();return e}}return e.source=t,e}(th),oh=function t(n){function e(t){var e=ih.source(n)(t);return function(){return e()/t}}return e.source=t,e}(th),ah=function t(n){function e(t){return function(){return-Math.log(1-n())/t}}return e.source=t,e}(th),uh=Array.prototype,fh=uh.map,ch=uh.slice,sh={name:"implicit"};function lh(t){var n=Ki(),e=[],r=sh;function i(i){var o=i+"",a=n.get(o);if(!a){if(r!==sh)return r;n.set(o,a=e.push(i))}return t[(a-1)%t.length]}return t=null==t?[]:ch.call(t),i.domain=function(t){if(!arguments.length)return e.slice();e=[],n=Ki();for(var r,o,a=-1,u=t.length;++a<u;)n.has(o=(r=t[a])+"")||n.set(o,e.push(r));return i},i.range=function(n){return arguments.length?(t=ch.call(n),i):t.slice()},i.unknown=function(t){return arguments.length?(r=t,i):r},i.copy=function(){return lh().domain(e).range(t).unknown(r)},i}function hh(){var t,n,e=lh().unknown(void 0),r=e.domain,i=e.range,o=[0,1],a=!1,u=0,f=0,c=.5;function s(){var e=r().length,s=o[1]<o[0],l=o[s-0],h=o[1-s];t=(h-l)/Math.max(1,e-u+2*f),a&&(t=Math.floor(t)),l+=(h-l-t*(e-u))*c,n=t*(1-u),a&&(l=Math.round(l),n=Math.round(n));var d=g(e).map(function(n){return l+t*n});return i(s?d.reverse():d)}return delete e.unknown,e.domain=function(t){return arguments.length?(r(t),s()):r()},e.range=function(t){return arguments.length?(o=[+t[0],+t[1]],s()):o.slice()},e.rangeRound=function(t){return o=[+t[0],+t[1]],a=!0,s()},e.bandwidth=function(){return n},e.step=function(){return t},e.round=function(t){return arguments.length?(a=!!t,s()):a},e.padding=function(t){return arguments.length?(u=f=Math.max(0,Math.min(1,t)),s()):u},e.paddingInner=function(t){return arguments.length?(u=Math.max(0,Math.min(1,t)),s()):u},e.paddingOuter=function(t){return arguments.length?(f=Math.max(0,Math.min(1,t)),s()):f},e.align=function(t){return arguments.length?(c=Math.max(0,Math.min(1,t)),s()):c},e.copy=function(){return hh().domain(r()).range(o).round(a).paddingInner(u).paddingOuter(f).align(c)},s()}function dh(t){return function(){return t}}function ph(t){return+t}var vh=[0,1];function gh(t,n){return(n-=t=+t)?function(e){return(e-t)/n}:dh(n)}function yh(t,n,e,r){var i=t[0],o=t[1],a=n[0],u=n[1];return o<i?(i=e(o,i),a=r(u,a)):(i=e(i,o),a=r(a,u)),function(t){return a(i(t))}}function _h(t,n,e,r){var o=Math.min(t.length,n.length)-1,a=new Array(o),u=new Array(o),f=-1;for(t[o]<t[0]&&(t=t.slice().reverse(),n=n.slice().reverse());++f<o;)a[f]=e(t[f],t[f+1]),u[f]=r(n[f],n[f+1]);return function(n){var e=i(t,n,1,o)-1;return u[e](a[e](n))}}function bh(t,n){return n.domain(t.domain()).range(t.range()).interpolate(t.interpolate()).clamp(t.clamp())}function mh(t,n){var e,r,i,o=vh,a=vh,u=me,f=!1;function c(){return e=Math.min(o.length,a.length)>2?_h:yh,r=i=null,s}function s(n){return(r||(r=e(o,a,f?function(t){return function(n,e){var r=t(n=+n,e=+e);return function(t){return t<=n?0:t>=e?1:r(t)}}}(t):t,u)))(+n)}return s.invert=function(t){return(i||(i=e(a,o,gh,f?function(t){return function(n,e){var r=t(n=+n,e=+e);return function(t){return t<=0?n:t>=1?e:r(t)}}}(n):n)))(+t)},s.domain=function(t){return arguments.length?(o=fh.call(t,ph),c()):o.slice()},s.range=function(t){return arguments.length?(a=ch.call(t),c()):a.slice()},s.rangeRound=function(t){return a=ch.call(t),u=xe,c()},s.clamp=function(t){return arguments.length?(f=!!t,c()):f},s.interpolate=function(t){return arguments.length?(u=t,c()):u},c()}function xh(n){var e=n.domain;return n.ticks=function(t){var n=e();return m(n[0],n[n.length-1],null==t?10:t)},n.tickFormat=function(n,r){return function(n,e,r){var i,o=n[0],a=n[n.length-1],u=w(o,a,null==e?10:e);switch((r=ba(null==r?",f":r)).type){case"s":var f=Math.max(Math.abs(o),Math.abs(a));return null!=r.precision||isNaN(i=ka(u,f))||(r.precision=i),t.formatPrefix(r,f);case"":case"e":case"g":case"p":case"r":null!=r.precision||isNaN(i=Ca(u,Math.max(Math.abs(o),Math.abs(a))))||(r.precision=i-("e"===r.type));break;case"f":case"%":null!=r.precision||isNaN(i=Ea(u))||(r.precision=i-2*("%"===r.type))}return t.format(r)}(e(),n,r)},n.nice=function(t){null==t&&(t=10);var r,i=e(),o=0,a=i.length-1,u=i[o],f=i[a];return f<u&&(r=u,u=f,f=r,r=o,o=a,a=r),(r=x(u,f,t))>0?r=x(u=Math.floor(u/r)*r,f=Math.ceil(f/r)*r,t):r<0&&(r=x(u=Math.ceil(u*r)/r,f=Math.floor(f*r)/r,t)),r>0?(i[o]=Math.floor(u/r)*r,i[a]=Math.ceil(f/r)*r,e(i)):r<0&&(i[o]=Math.ceil(u*r)/r,i[a]=Math.floor(f*r)/r,e(i)),n},n}function wh(t,n){var e,r=0,i=(t=t.slice()).length-1,o=t[r],a=t[i];return a<o&&(e=r,r=i,i=e,e=o,o=a,a=e),t[r]=n.floor(o),t[i]=n.ceil(a),t}function Mh(t,n){return(n=Math.log(n/t))?function(e){return Math.log(e/t)/n}:dh(n)}function Ah(t,n){return t<0?function(e){return-Math.pow(-n,e)*Math.pow(-t,1-e)}:function(e){return Math.pow(n,e)*Math.pow(t,1-e)}}function Th(t){return isFinite(t)?+("1e"+t):t<0?0:t}function Nh(t){return 10===t?Th:t===Math.E?Math.exp:function(n){return Math.pow(t,n)}}function Sh(t){return t===Math.E?Math.log:10===t&&Math.log10||2===t&&Math.log2||(t=Math.log(t),function(n){return Math.log(n)/t})}function Eh(t){return function(n){return-t(-n)}}function kh(t,n){return t<0?-Math.pow(-t,n):Math.pow(t,n)}function Ch(){var t=1,n=mh(function(n,e){return(e=kh(e,t)-(n=kh(n,t)))?function(r){return(kh(r,t)-n)/e}:dh(e)},function(n,e){return e=kh(e,t)-(n=kh(n,t)),function(r){return kh(n+e*r,1/t)}}),e=n.domain;return n.exponent=function(n){return arguments.length?(t=+n,e(e())):t},n.copy=function(){return bh(n,Ch().exponent(t))},xh(n)}var Ph=new Date,zh=new Date;function Rh(t,n,e,r){function i(n){return t(n=new Date(+n)),n}return i.floor=i,i.ceil=function(e){return t(e=new Date(e-1)),n(e,1),t(e),e},i.round=function(t){var n=i(t),e=i.ceil(t);return t-n<e-t?n:e},i.offset=function(t,e){return n(t=new Date(+t),null==e?1:Math.floor(e)),t},i.range=function(e,r,o){var a,u=[];if(e=i.ceil(e),o=null==o?1:Math.floor(o),!(e<r&&o>0))return u;do{u.push(a=new Date(+e)),n(e,o),t(e)}while(a<e&&e<r);return u},i.filter=function(e){return Rh(function(n){if(n>=n)for(;t(n),!e(n);)n.setTime(n-1)},function(t,r){if(t>=t)if(r<0)for(;++r<=0;)for(;n(t,-1),!e(t););else for(;--r>=0;)for(;n(t,1),!e(t););})},e&&(i.count=function(n,r){return Ph.setTime(+n),zh.setTime(+r),t(Ph),t(zh),Math.floor(e(Ph,zh))},i.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?i.filter(r?function(n){return r(n)%t==0}:function(n){return i.count(0,n)%t==0}):i:null}),i}var Lh=Rh(function(){},function(t,n){t.setTime(+t+n)},function(t,n){return n-t});Lh.every=function(t){return t=Math.floor(t),isFinite(t)&&t>0?t>1?Rh(function(n){n.setTime(Math.floor(n/t)*t)},function(n,e){n.setTime(+n+e*t)},function(n,e){return(e-n)/t}):Lh:null};var Dh=Lh.range,Uh=6e4,qh=6048e5,Oh=Rh(function(t){t.setTime(1e3*Math.floor(t/1e3))},function(t,n){t.setTime(+t+1e3*n)},function(t,n){return(n-t)/1e3},function(t){return t.getUTCSeconds()}),Yh=Oh.range,Bh=Rh(function(t){t.setTime(Math.floor(t/Uh)*Uh)},function(t,n){t.setTime(+t+n*Uh)},function(t,n){return(n-t)/Uh},function(t){return t.getMinutes()}),Fh=Bh.range,Ih=Rh(function(t){var n=t.getTimezoneOffset()*Uh%36e5;n<0&&(n+=36e5),t.setTime(36e5*Math.floor((+t-n)/36e5)+n)},function(t,n){t.setTime(+t+36e5*n)},function(t,n){return(n-t)/36e5},function(t){return t.getHours()}),Hh=Ih.range,jh=Rh(function(t){t.setHours(0,0,0,0)},function(t,n){t.setDate(t.getDate()+n)},function(t,n){return(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*Uh)/864e5},function(t){return t.getDate()-1}),Xh=jh.range;function Gh(t){return Rh(function(n){n.setDate(n.getDate()-(n.getDay()+7-t)%7),n.setHours(0,0,0,0)},function(t,n){t.setDate(t.getDate()+7*n)},function(t,n){return(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*Uh)/qh})}var Vh=Gh(0),$h=Gh(1),Wh=Gh(2),Zh=Gh(3),Qh=Gh(4),Jh=Gh(5),Kh=Gh(6),td=Vh.range,nd=$h.range,ed=Wh.range,rd=Zh.range,id=Qh.range,od=Jh.range,ad=Kh.range,ud=Rh(function(t){t.setDate(1),t.setHours(0,0,0,0)},function(t,n){t.setMonth(t.getMonth()+n)},function(t,n){return n.getMonth()-t.getMonth()+12*(n.getFullYear()-t.getFullYear())},function(t){return t.getMonth()}),fd=ud.range,cd=Rh(function(t){t.setMonth(0,1),t.setHours(0,0,0,0)},function(t,n){t.setFullYear(t.getFullYear()+n)},function(t,n){return n.getFullYear()-t.getFullYear()},function(t){return t.getFullYear()});cd.every=function(t){return isFinite(t=Math.floor(t))&&t>0?Rh(function(n){n.setFullYear(Math.floor(n.getFullYear()/t)*t),n.setMonth(0,1),n.setHours(0,0,0,0)},function(n,e){n.setFullYear(n.getFullYear()+e*t)}):null};var sd=cd.range,ld=Rh(function(t){t.setUTCSeconds(0,0)},function(t,n){t.setTime(+t+n*Uh)},function(t,n){return(n-t)/Uh},function(t){return t.getUTCMinutes()}),hd=ld.range,dd=Rh(function(t){t.setUTCMinutes(0,0,0)},function(t,n){t.setTime(+t+36e5*n)},function(t,n){return(n-t)/36e5},function(t){return t.getUTCHours()}),pd=dd.range,vd=Rh(function(t){t.setUTCHours(0,0,0,0)},function(t,n){t.setUTCDate(t.getUTCDate()+n)},function(t,n){return(n-t)/864e5},function(t){return t.getUTCDate()-1}),gd=vd.range;function yd(t){return Rh(function(n){n.setUTCDate(n.getUTCDate()-(n.getUTCDay()+7-t)%7),n.setUTCHours(0,0,0,0)},function(t,n){t.setUTCDate(t.getUTCDate()+7*n)},function(t,n){return(n-t)/qh})}var _d=yd(0),bd=yd(1),md=yd(2),xd=yd(3),wd=yd(4),Md=yd(5),Ad=yd(6),Td=_d.range,Nd=bd.range,Sd=md.range,Ed=xd.range,kd=wd.range,Cd=Md.range,Pd=Ad.range,zd=Rh(function(t){t.setUTCDate(1),t.setUTCHours(0,0,0,0)},function(t,n){t.setUTCMonth(t.getUTCMonth()+n)},function(t,n){return n.getUTCMonth()-t.getUTCMonth()+12*(n.getUTCFullYear()-t.getUTCFullYear())},function(t){return t.getUTCMonth()}),Rd=zd.range,Ld=Rh(function(t){t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)},function(t,n){t.setUTCFullYear(t.getUTCFullYear()+n)},function(t,n){return n.getUTCFullYear()-t.getUTCFullYear()},function(t){return t.getUTCFullYear()});Ld.every=function(t){return isFinite(t=Math.floor(t))&&t>0?Rh(function(n){n.setUTCFullYear(Math.floor(n.getUTCFullYear()/t)*t),n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)},function(n,e){n.setUTCFullYear(n.getUTCFullYear()+e*t)}):null};var Dd=Ld.range;function Ud(t){if(0<=t.y&&t.y<100){var n=new Date(-1,t.m,t.d,t.H,t.M,t.S,t.L);return n.setFullYear(t.y),n}return new Date(t.y,t.m,t.d,t.H,t.M,t.S,t.L)}function qd(t){if(0<=t.y&&t.y<100){var n=new Date(Date.UTC(-1,t.m,t.d,t.H,t.M,t.S,t.L));return n.setUTCFullYear(t.y),n}return new Date(Date.UTC(t.y,t.m,t.d,t.H,t.M,t.S,t.L))}function Od(t){return{y:t,m:0,d:1,H:0,M:0,S:0,L:0}}function Yd(t){var n=t.dateTime,e=t.date,r=t.time,i=t.periods,o=t.days,a=t.shortDays,u=t.months,f=t.shortMonths,c=Vd(i),s=$d(i),l=Vd(o),h=$d(o),d=Vd(a),p=$d(a),v=Vd(u),g=$d(u),y=Vd(f),_=$d(f),b={a:function(t){return a[t.getDay()]},A:function(t){return o[t.getDay()]},b:function(t){return f[t.getMonth()]},B:function(t){return u[t.getMonth()]},c:null,d:pp,e:pp,f:bp,H:vp,I:gp,j:yp,L:_p,m:mp,M:xp,p:function(t){return i[+(t.getHours()>=12)]},Q:Wp,s:Zp,S:wp,u:Mp,U:Ap,V:Tp,w:Np,W:Sp,x:null,X:null,y:Ep,Y:kp,Z:Cp,"%":$p},m={a:function(t){return a[t.getUTCDay()]},A:function(t){return o[t.getUTCDay()]},b:function(t){return f[t.getUTCMonth()]},B:function(t){return u[t.getUTCMonth()]},c:null,d:Pp,e:Pp,f:Up,H:zp,I:Rp,j:Lp,L:Dp,m:qp,M:Op,p:function(t){return i[+(t.getUTCHours()>=12)]},Q:Wp,s:Zp,S:Yp,u:Bp,U:Fp,V:Ip,w:Hp,W:jp,x:null,X:null,y:Xp,Y:Gp,Z:Vp,"%":$p},x={a:function(t,n,e){var r=d.exec(n.slice(e));return r?(t.w=p[r[0].toLowerCase()],e+r[0].length):-1},A:function(t,n,e){var r=l.exec(n.slice(e));return r?(t.w=h[r[0].toLowerCase()],e+r[0].length):-1},b:function(t,n,e){var r=y.exec(n.slice(e));return r?(t.m=_[r[0].toLowerCase()],e+r[0].length):-1},B:function(t,n,e){var r=v.exec(n.slice(e));return r?(t.m=g[r[0].toLowerCase()],e+r[0].length):-1},c:function(t,e,r){return A(t,n,e,r)},d:ip,e:ip,f:sp,H:ap,I:ap,j:op,L:cp,m:rp,M:up,p:function(t,n,e){var r=c.exec(n.slice(e));return r?(t.p=s[r[0].toLowerCase()],e+r[0].length):-1},Q:hp,s:dp,S:fp,u:Zd,U:Qd,V:Jd,w:Wd,W:Kd,x:function(t,n,r){return A(t,e,n,r)},X:function(t,n,e){return A(t,r,n,e)},y:np,Y:tp,Z:ep,"%":lp};function w(t,n){return function(e){var r,i,o,a=[],u=-1,f=0,c=t.length;for(e instanceof Date||(e=new Date(+e));++u<c;)37===t.charCodeAt(u)&&(a.push(t.slice(f,u)),null!=(i=Fd[r=t.charAt(++u)])?r=t.charAt(++u):i="e"===r?" ":"0",(o=n[r])&&(r=o(e,i)),a.push(r),f=u+1);return a.push(t.slice(f,u)),a.join("")}}function M(t,n){return function(e){var r,i,o=Od(1900);if(A(o,t,e+="",0)!=e.length)return null;if("Q"in o)return new Date(o.Q);if("p"in o&&(o.H=o.H%12+12*o.p),"V"in o){if(o.V<1||o.V>53)return null;"w"in o||(o.w=1),"Z"in o?(i=(r=qd(Od(o.y))).getUTCDay(),r=i>4||0===i?bd.ceil(r):bd(r),r=vd.offset(r,7*(o.V-1)),o.y=r.getUTCFullYear(),o.m=r.getUTCMonth(),o.d=r.getUTCDate()+(o.w+6)%7):(i=(r=n(Od(o.y))).getDay(),r=i>4||0===i?$h.ceil(r):$h(r),r=jh.offset(r,7*(o.V-1)),o.y=r.getFullYear(),o.m=r.getMonth(),o.d=r.getDate()+(o.w+6)%7)}else("W"in o||"U"in o)&&("w"in o||(o.w="u"in o?o.u%7:"W"in o?1:0),i="Z"in o?qd(Od(o.y)).getUTCDay():n(Od(o.y)).getDay(),o.m=0,o.d="W"in o?(o.w+6)%7+7*o.W-(i+5)%7:o.w+7*o.U-(i+6)%7);return"Z"in o?(o.H+=o.Z/100|0,o.M+=o.Z%100,qd(o)):n(o)}}function A(t,n,e,r){for(var i,o,a=0,u=n.length,f=e.length;a<u;){if(r>=f)return-1;if(37===(i=n.charCodeAt(a++))){if(i=n.charAt(a++),!(o=x[i in Fd?n.charAt(a++):i])||(r=o(t,e,r))<0)return-1}else if(i!=e.charCodeAt(r++))return-1}return r}return b.x=w(e,b),b.X=w(r,b),b.c=w(n,b),m.x=w(e,m),m.X=w(r,m),m.c=w(n,m),{format:function(t){var n=w(t+="",b);return n.toString=function(){return t},n},parse:function(t){var n=M(t+="",Ud);return n.toString=function(){return t},n},utcFormat:function(t){var n=w(t+="",m);return n.toString=function(){return t},n},utcParse:function(t){var n=M(t,qd);return n.toString=function(){return t},n}}}var Bd,Fd={"-":"",_:" ",0:"0"},Id=/^\s*\d+/,Hd=/^%/,jd=/[\\^$*+?|[\]().{}]/g;function Xd(t,n,e){var r=t<0?"-":"",i=(r?-t:t)+"",o=i.length;return r+(o<e?new Array(e-o+1).join(n)+i:i)}function Gd(t){return t.replace(jd,"\\$&")}function Vd(t){return new RegExp("^(?:"+t.map(Gd).join("|")+")","i")}function $d(t){for(var n={},e=-1,r=t.length;++e<r;)n[t[e].toLowerCase()]=e;return n}function Wd(t,n,e){var r=Id.exec(n.slice(e,e+1));return r?(t.w=+r[0],e+r[0].length):-1}function Zd(t,n,e){var r=Id.exec(n.slice(e,e+1));return r?(t.u=+r[0],e+r[0].length):-1}function Qd(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.U=+r[0],e+r[0].length):-1}function Jd(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.V=+r[0],e+r[0].length):-1}function Kd(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.W=+r[0],e+r[0].length):-1}function tp(t,n,e){var r=Id.exec(n.slice(e,e+4));return r?(t.y=+r[0],e+r[0].length):-1}function np(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.y=+r[0]+(+r[0]>68?1900:2e3),e+r[0].length):-1}function ep(t,n,e){var r=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(n.slice(e,e+6));return r?(t.Z=r[1]?0:-(r[2]+(r[3]||"00")),e+r[0].length):-1}function rp(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.m=r[0]-1,e+r[0].length):-1}function ip(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.d=+r[0],e+r[0].length):-1}function op(t,n,e){var r=Id.exec(n.slice(e,e+3));return r?(t.m=0,t.d=+r[0],e+r[0].length):-1}function ap(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.H=+r[0],e+r[0].length):-1}function up(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.M=+r[0],e+r[0].length):-1}function fp(t,n,e){var r=Id.exec(n.slice(e,e+2));return r?(t.S=+r[0],e+r[0].length):-1}function cp(t,n,e){var r=Id.exec(n.slice(e,e+3));return r?(t.L=+r[0],e+r[0].length):-1}function sp(t,n,e){var r=Id.exec(n.slice(e,e+6));return r?(t.L=Math.floor(r[0]/1e3),e+r[0].length):-1}function lp(t,n,e){var r=Hd.exec(n.slice(e,e+1));return r?e+r[0].length:-1}function hp(t,n,e){var r=Id.exec(n.slice(e));return r?(t.Q=+r[0],e+r[0].length):-1}function dp(t,n,e){var r=Id.exec(n.slice(e));return r?(t.Q=1e3*+r[0],e+r[0].length):-1}function pp(t,n){return Xd(t.getDate(),n,2)}function vp(t,n){return Xd(t.getHours(),n,2)}function gp(t,n){return Xd(t.getHours()%12||12,n,2)}function yp(t,n){return Xd(1+jh.count(cd(t),t),n,3)}function _p(t,n){return Xd(t.getMilliseconds(),n,3)}function bp(t,n){return _p(t,n)+"000"}function mp(t,n){return Xd(t.getMonth()+1,n,2)}function xp(t,n){return Xd(t.getMinutes(),n,2)}function wp(t,n){return Xd(t.getSeconds(),n,2)}function Mp(t){var n=t.getDay();return 0===n?7:n}function Ap(t,n){return Xd(Vh.count(cd(t),t),n,2)}function Tp(t,n){var e=t.getDay();return t=e>=4||0===e?Qh(t):Qh.ceil(t),Xd(Qh.count(cd(t),t)+(4===cd(t).getDay()),n,2)}function Np(t){return t.getDay()}function Sp(t,n){return Xd($h.count(cd(t),t),n,2)}function Ep(t,n){return Xd(t.getFullYear()%100,n,2)}function kp(t,n){return Xd(t.getFullYear()%1e4,n,4)}function Cp(t){var n=t.getTimezoneOffset();return(n>0?"-":(n*=-1,"+"))+Xd(n/60|0,"0",2)+Xd(n%60,"0",2)}function Pp(t,n){return Xd(t.getUTCDate(),n,2)}function zp(t,n){return Xd(t.getUTCHours(),n,2)}function Rp(t,n){return Xd(t.getUTCHours()%12||12,n,2)}function Lp(t,n){return Xd(1+vd.count(Ld(t),t),n,3)}function Dp(t,n){return Xd(t.getUTCMilliseconds(),n,3)}function Up(t,n){return Dp(t,n)+"000"}function qp(t,n){return Xd(t.getUTCMonth()+1,n,2)}function Op(t,n){return Xd(t.getUTCMinutes(),n,2)}function Yp(t,n){return Xd(t.getUTCSeconds(),n,2)}function Bp(t){var n=t.getUTCDay();return 0===n?7:n}function Fp(t,n){return Xd(_d.count(Ld(t),t),n,2)}function Ip(t,n){var e=t.getUTCDay();return t=e>=4||0===e?wd(t):wd.ceil(t),Xd(wd.count(Ld(t),t)+(4===Ld(t).getUTCDay()),n,2)}function Hp(t){return t.getUTCDay()}function jp(t,n){return Xd(bd.count(Ld(t),t),n,2)}function Xp(t,n){return Xd(t.getUTCFullYear()%100,n,2)}function Gp(t,n){return Xd(t.getUTCFullYear()%1e4,n,4)}function Vp(){return"+0000"}function $p(){return"%"}function Wp(t){return+t}function Zp(t){return Math.floor(+t/1e3)}function Qp(n){return Bd=Yd(n),t.timeFormat=Bd.format,t.timeParse=Bd.parse,t.utcFormat=Bd.utcFormat,t.utcParse=Bd.utcParse,Bd}Qp({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 Jp=Date.prototype.toISOString?function(t){return t.toISOString()}:t.utcFormat("%Y-%m-%dT%H:%M:%S.%LZ");var Kp=+new Date("2000-01-01T00:00:00.000Z")?function(t){var n=new Date(t);return isNaN(n)?null:n}:t.utcParse("%Y-%m-%dT%H:%M:%S.%LZ"),tv=1e3,nv=60*tv,ev=60*nv,rv=24*ev,iv=7*rv,ov=30*rv,av=365*rv;function uv(t){return new Date(t)}function fv(t){return t instanceof Date?+t:+new Date(+t)}function cv(t,n,r,i,o,a,u,f,c){var s=mh(gh,ve),l=s.invert,h=s.domain,d=c(".%L"),p=c(":%S"),v=c("%I:%M"),g=c("%I %p"),y=c("%a %d"),_=c("%b %d"),b=c("%B"),m=c("%Y"),x=[[u,1,tv],[u,5,5*tv],[u,15,15*tv],[u,30,30*tv],[a,1,nv],[a,5,5*nv],[a,15,15*nv],[a,30,30*nv],[o,1,ev],[o,3,3*ev],[o,6,6*ev],[o,12,12*ev],[i,1,rv],[i,2,2*rv],[r,1,iv],[n,1,ov],[n,3,3*ov],[t,1,av]];function M(e){return(u(e)<e?d:a(e)<e?p:o(e)<e?v:i(e)<e?g:n(e)<e?r(e)<e?y:_:t(e)<e?b:m)(e)}function A(n,r,i,o){if(null==n&&(n=10),"number"==typeof n){var a=Math.abs(i-r)/n,u=e(function(t){return t[2]}).right(x,a);u===x.length?(o=w(r/av,i/av,n),n=t):u?(o=(u=x[a/x[u-1][2]<x[u][2]/a?u-1:u])[1],n=u[0]):(o=Math.max(w(r,i,n),1),n=f)}return null==o?n:n.every(o)}return s.invert=function(t){return new Date(l(t))},s.domain=function(t){return arguments.length?h(fh.call(t,fv)):h().map(uv)},s.ticks=function(t,n){var e,r=h(),i=r[0],o=r[r.length-1],a=o<i;return a&&(e=i,i=o,o=e),e=(e=A(t,i,o,n))?e.range(i,o+1):[],a?e.reverse():e},s.tickFormat=function(t,n){return null==n?M:c(n)},s.nice=function(t,n){var e=h();return(t=A(t,e[0],e[e.length-1],n))?h(wh(e,t)):s},s.copy=function(){return bh(s,cv(t,n,r,i,o,a,u,f,c))},s}function sv(t){for(var n=t.length/6|0,e=new Array(n),r=0;r<n;)e[r]="#"+t.slice(6*r,6*++r);return e}var lv=sv("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"),hv=sv("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666"),dv=sv("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666"),pv=sv("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928"),vv=sv("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2"),gv=sv("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc"),yv=sv("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999"),_v=sv("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3"),bv=sv("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f");function mv(t){return le(t[t.length-1])}var xv=new Array(3).concat("d8b365f5f5f55ab4ac","a6611adfc27d80cdc1018571","a6611adfc27df5f5f580cdc1018571","8c510ad8b365f6e8c3c7eae55ab4ac01665e","8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e","8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e","8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e","5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30","5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(sv),wv=mv(xv),Mv=new Array(3).concat("af8dc3f7f7f77fbf7b","7b3294c2a5cfa6dba0008837","7b3294c2a5cff7f7f7a6dba0008837","762a83af8dc3e7d4e8d9f0d37fbf7b1b7837","762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837","762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837","762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837","40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b","40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(sv),Av=mv(Mv),Tv=new Array(3).concat("e9a3c9f7f7f7a1d76a","d01c8bf1b6dab8e1864dac26","d01c8bf1b6daf7f7f7b8e1864dac26","c51b7de9a3c9fde0efe6f5d0a1d76a4d9221","c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221","c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221","c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221","8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419","8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(sv),Nv=mv(Tv),Sv=new Array(3).concat("998ec3f7f7f7f1a340","5e3c99b2abd2fdb863e66101","5e3c99b2abd2f7f7f7fdb863e66101","542788998ec3d8daebfee0b6f1a340b35806","542788998ec3d8daebf7f7f7fee0b6f1a340b35806","5427888073acb2abd2d8daebfee0b6fdb863e08214b35806","5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806","2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08","2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(sv),Ev=mv(Sv),kv=new Array(3).concat("ef8a62f7f7f767a9cf","ca0020f4a58292c5de0571b0","ca0020f4a582f7f7f792c5de0571b0","b2182bef8a62fddbc7d1e5f067a9cf2166ac","b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac","b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac","b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac","67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061","67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(sv),Cv=mv(kv),Pv=new Array(3).concat("ef8a62ffffff999999","ca0020f4a582bababa404040","ca0020f4a582ffffffbababa404040","b2182bef8a62fddbc7e0e0e09999994d4d4d","b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d","b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d","b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d","67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a","67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(sv),zv=mv(Pv),Rv=new Array(3).concat("fc8d59ffffbf91bfdb","d7191cfdae61abd9e92c7bb6","d7191cfdae61ffffbfabd9e92c7bb6","d73027fc8d59fee090e0f3f891bfdb4575b4","d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4","d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4","d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4","a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695","a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(sv),Lv=mv(Rv),Dv=new Array(3).concat("fc8d59ffffbf91cf60","d7191cfdae61a6d96a1a9641","d7191cfdae61ffffbfa6d96a1a9641","d73027fc8d59fee08bd9ef8b91cf601a9850","d73027fc8d59fee08bffffbfd9ef8b91cf601a9850","d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850","d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850","a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837","a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(sv),Uv=mv(Dv),qv=new Array(3).concat("fc8d59ffffbf99d594","d7191cfdae61abdda42b83ba","d7191cfdae61ffffbfabdda42b83ba","d53e4ffc8d59fee08be6f59899d5943288bd","d53e4ffc8d59fee08bffffbfe6f59899d5943288bd","d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd","d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd","9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2","9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(sv),Ov=mv(qv),Yv=new Array(3).concat("e5f5f999d8c92ca25f","edf8fbb2e2e266c2a4238b45","edf8fbb2e2e266c2a42ca25f006d2c","edf8fbccece699d8c966c2a42ca25f006d2c","edf8fbccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(sv),Bv=mv(Yv),Fv=new Array(3).concat("e0ecf49ebcda8856a7","edf8fbb3cde38c96c688419d","edf8fbb3cde38c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(sv),Iv=mv(Fv),Hv=new Array(3).concat("e0f3dba8ddb543a2ca","f0f9e8bae4bc7bccc42b8cbe","f0f9e8bae4bc7bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(sv),jv=mv(Hv),Xv=new Array(3).concat("fee8c8fdbb84e34a33","fef0d9fdcc8afc8d59d7301f","fef0d9fdcc8afc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(sv),Gv=mv(Xv),Vv=new Array(3).concat("ece2f0a6bddb1c9099","f6eff7bdc9e167a9cf02818a","f6eff7bdc9e167a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(sv),$v=mv(Vv),Wv=new Array(3).concat("ece7f2a6bddb2b8cbe","f1eef6bdc9e174a9cf0570b0","f1eef6bdc9e174a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(sv),Zv=mv(Wv),Qv=new Array(3).concat("e7e1efc994c7dd1c77","f1eef6d7b5d8df65b0ce1256","f1eef6d7b5d8df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(sv),Jv=mv(Qv),Kv=new Array(3).concat("fde0ddfa9fb5c51b8a","feebe2fbb4b9f768a1ae017e","feebe2fbb4b9f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(sv),tg=mv(Kv),ng=new Array(3).concat("edf8b17fcdbb2c7fb8","ffffcca1dab441b6c4225ea8","ffffcca1dab441b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(sv),eg=mv(ng),rg=new Array(3).concat("f7fcb9addd8e31a354","ffffccc2e69978c679238443","ffffccc2e69978c67931a354006837","ffffccd9f0a3addd8e78c67931a354006837","ffffccd9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(sv),ig=mv(rg),og=new Array(3).concat("fff7bcfec44fd95f0e","ffffd4fed98efe9929cc4c02","ffffd4fed98efe9929d95f0e993404","ffffd4fee391fec44ffe9929d95f0e993404","ffffd4fee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(sv),ag=mv(og),ug=new Array(3).concat("ffeda0feb24cf03b20","ffffb2fecc5cfd8d3ce31a1c","ffffb2fecc5cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(sv),fg=mv(ug),cg=new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(sv),sg=mv(cg),lg=new Array(3).concat("e5f5e0a1d99b31a354","edf8e9bae4b374c476238b45","edf8e9bae4b374c47631a354006d2c","edf8e9c7e9c0a1d99b74c47631a354006d2c","edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(sv),hg=mv(lg),dg=new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(sv),pg=mv(dg),vg=new Array(3).concat("efedf5bcbddc756bb1","f2f0f7cbc9e29e9ac86a51a3","f2f0f7cbc9e29e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(sv),gg=mv(vg),yg=new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(sv),_g=mv(yg),bg=new Array(3).concat("fee6cefdae6be6550d","feeddefdbe85fd8d3cd94701","feeddefdbe85fd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(sv),mg=mv(bg),xg=Ge(Kn(300,.5,0),Kn(-240,.5,1)),wg=Ge(Kn(-100,.75,.35),Kn(80,1.5,.8)),Mg=Ge(Kn(260,.75,.35),Kn(80,1.5,.8)),Ag=Kn();var Tg=bn(),Ng=Math.PI/3,Sg=2*Math.PI/3;function Eg(t){var n=t.length;return function(e){return t[Math.max(0,Math.min(n-1,Math.floor(e*n)))]}}var kg=Eg(sv("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),Cg=Eg(sv("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),Pg=Eg(sv("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),zg=Eg(sv("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"));function Rg(t){return function(){return t}}var Lg=Math.abs,Dg=Math.atan2,Ug=Math.cos,qg=Math.max,Og=Math.min,Yg=Math.sin,Bg=Math.sqrt,Fg=1e-12,Ig=Math.PI,Hg=Ig/2,jg=2*Ig;function Xg(t){return t>=1?Hg:t<=-1?-Hg:Math.asin(t)}function Gg(t){return t.innerRadius}function Vg(t){return t.outerRadius}function $g(t){return t.startAngle}function Wg(t){return t.endAngle}function Zg(t){return t&&t.padAngle}function Qg(t,n,e,r,i,o,a){var u=t-e,f=n-r,c=(a?o:-o)/Bg(u*u+f*f),s=c*f,l=-c*u,h=t+s,d=n+l,p=e+s,v=r+l,g=(h+p)/2,y=(d+v)/2,_=p-h,b=v-d,m=_*_+b*b,x=i-o,w=h*v-p*d,M=(b<0?-1:1)*Bg(qg(0,x*x*m-w*w)),A=(w*b-_*M)/m,T=(-w*_-b*M)/m,N=(w*b+_*M)/m,S=(-w*_+b*M)/m,E=A-g,k=T-y,C=N-g,P=S-y;return E*E+k*k>C*C+P*P&&(A=N,T=S),{cx:A,cy:T,x01:-s,y01:-l,x11:A*(i/x-1),y11:T*(i/x-1)}}function Jg(t){this._context=t}function Kg(t){return new Jg(t)}function ty(t){return t[0]}function ny(t){return t[1]}function ey(){var t=ty,n=ny,e=Rg(!0),r=null,i=Kg,o=null;function a(a){var u,f,c,s=a.length,l=!1;for(null==r&&(o=i(c=Gi())),u=0;u<=s;++u)!(u<s&&e(f=a[u],u,a))===l&&((l=!l)?o.lineStart():o.lineEnd()),l&&o.point(+t(f,u,a),+n(f,u,a));if(c)return o=null,c+""||null}return a.x=function(n){return arguments.length?(t="function"==typeof n?n:Rg(+n),a):t},a.y=function(t){return arguments.length?(n="function"==typeof t?t:Rg(+t),a):n},a.defined=function(t){return arguments.length?(e="function"==typeof t?t:Rg(!!t),a):e},a.curve=function(t){return arguments.length?(i=t,null!=r&&(o=i(r)),a):i},a.context=function(t){return arguments.length?(null==t?r=o=null:o=i(r=t),a):r},a}function ry(){var t=ty,n=null,e=Rg(0),r=ny,i=Rg(!0),o=null,a=Kg,u=null;function f(f){var c,s,l,h,d,p=f.length,v=!1,g=new Array(p),y=new Array(p);for(null==o&&(u=a(d=Gi())),c=0;c<=p;++c){if(!(c<p&&i(h=f[c],c,f))===v)if(v=!v)s=c,u.areaStart(),u.lineStart();else{for(u.lineEnd(),u.lineStart(),l=c-1;l>=s;--l)u.point(g[l],y[l]);u.lineEnd(),u.areaEnd()}v&&(g[c]=+t(h,c,f),y[c]=+e(h,c,f),u.point(n?+n(h,c,f):g[c],r?+r(h,c,f):y[c]))}if(d)return u=null,d+""||null}function c(){return ey().defined(i).curve(a).context(o)}return f.x=function(e){return arguments.length?(t="function"==typeof e?e:Rg(+e),n=null,f):t},f.x0=function(n){return arguments.length?(t="function"==typeof n?n:Rg(+n),f):t},f.x1=function(t){return arguments.length?(n=null==t?null:"function"==typeof t?t:Rg(+t),f):n},f.y=function(t){return arguments.length?(e="function"==typeof t?t:Rg(+t),r=null,f):e},f.y0=function(t){return arguments.length?(e="function"==typeof t?t:Rg(+t),f):e},f.y1=function(t){return arguments.length?(r=null==t?null:"function"==typeof t?t:Rg(+t),f):r},f.lineX0=f.lineY0=function(){return c().x(t).y(e)},f.lineY1=function(){return c().x(t).y(r)},f.lineX1=function(){return c().x(n).y(e)},f.defined=function(t){return arguments.length?(i="function"==typeof t?t:Rg(!!t),f):i},f.curve=function(t){return arguments.length?(a=t,null!=o&&(u=a(o)),f):a},f.context=function(t){return arguments.length?(null==t?o=u=null:u=a(o=t),f):o},f}function iy(t,n){return n<t?-1:n>t?1:n>=t?0:NaN}function oy(t){return t}Jg.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:this._context.lineTo(t,n)}}};var ay=fy(Kg);function uy(t){this._curve=t}function fy(t){function n(n){return new uy(t(n))}return n._curve=t,n}function cy(t){var n=t.curve;return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t.curve=function(t){return arguments.length?n(fy(t)):n()._curve},t}function sy(){return cy(ey().curve(ay))}function ly(){var t=ry().curve(ay),n=t.curve,e=t.lineX0,r=t.lineX1,i=t.lineY0,o=t.lineY1;return t.angle=t.x,delete t.x,t.startAngle=t.x0,delete t.x0,t.endAngle=t.x1,delete t.x1,t.radius=t.y,delete t.y,t.innerRadius=t.y0,delete t.y0,t.outerRadius=t.y1,delete t.y1,t.lineStartAngle=function(){return cy(e())},delete t.lineX0,t.lineEndAngle=function(){return cy(r())},delete t.lineX1,t.lineInnerRadius=function(){return cy(i())},delete t.lineY0,t.lineOuterRadius=function(){return cy(o())},delete t.lineY1,t.curve=function(t){return arguments.length?n(fy(t)):n()._curve},t}function hy(t,n){return[(n=+n)*Math.cos(t-=Math.PI/2),n*Math.sin(t)]}uy.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(t,n){this._curve.point(n*Math.sin(t),n*-Math.cos(t))}};var dy=Array.prototype.slice;function py(t){return t.source}function vy(t){return t.target}function gy(t){var n=py,e=vy,r=ty,i=ny,o=null;function a(){var a,u=dy.call(arguments),f=n.apply(this,u),c=e.apply(this,u);if(o||(o=a=Gi()),t(o,+r.apply(this,(u[0]=f,u)),+i.apply(this,u),+r.apply(this,(u[0]=c,u)),+i.apply(this,u)),a)return o=null,a+""||null}return a.source=function(t){return arguments.length?(n=t,a):n},a.target=function(t){return arguments.length?(e=t,a):e},a.x=function(t){return arguments.length?(r="function"==typeof t?t:Rg(+t),a):r},a.y=function(t){return arguments.length?(i="function"==typeof t?t:Rg(+t),a):i},a.context=function(t){return arguments.length?(o=null==t?null:t,a):o},a}function yy(t,n,e,r,i){t.moveTo(n,e),t.bezierCurveTo(n=(n+r)/2,e,n,i,r,i)}function _y(t,n,e,r,i){t.moveTo(n,e),t.bezierCurveTo(n,e=(e+i)/2,r,e,r,i)}function by(t,n,e,r,i){var o=hy(n,e),a=hy(n,e=(e+i)/2),u=hy(r,e),f=hy(r,i);t.moveTo(o[0],o[1]),t.bezierCurveTo(a[0],a[1],u[0],u[1],f[0],f[1])}var my={draw:function(t,n){var e=Math.sqrt(n/Ig);t.moveTo(e,0),t.arc(0,0,e,0,jg)}},xy={draw:function(t,n){var e=Math.sqrt(n/5)/2;t.moveTo(-3*e,-e),t.lineTo(-e,-e),t.lineTo(-e,-3*e),t.lineTo(e,-3*e),t.lineTo(e,-e),t.lineTo(3*e,-e),t.lineTo(3*e,e),t.lineTo(e,e),t.lineTo(e,3*e),t.lineTo(-e,3*e),t.lineTo(-e,e),t.lineTo(-3*e,e),t.closePath()}},wy=Math.sqrt(1/3),My=2*wy,Ay={draw:function(t,n){var e=Math.sqrt(n/My),r=e*wy;t.moveTo(0,-e),t.lineTo(r,0),t.lineTo(0,e),t.lineTo(-r,0),t.closePath()}},Ty=Math.sin(Ig/10)/Math.sin(7*Ig/10),Ny=Math.sin(jg/10)*Ty,Sy=-Math.cos(jg/10)*Ty,Ey={draw:function(t,n){var e=Math.sqrt(.8908130915292852*n),r=Ny*e,i=Sy*e;t.moveTo(0,-e),t.lineTo(r,i);for(var o=1;o<5;++o){var a=jg*o/5,u=Math.cos(a),f=Math.sin(a);t.lineTo(f*e,-u*e),t.lineTo(u*r-f*i,f*r+u*i)}t.closePath()}},ky={draw:function(t,n){var e=Math.sqrt(n),r=-e/2;t.rect(r,r,e,e)}},Cy=Math.sqrt(3),Py={draw:function(t,n){var e=-Math.sqrt(n/(3*Cy));t.moveTo(0,2*e),t.lineTo(-Cy*e,-e),t.lineTo(Cy*e,-e),t.closePath()}},zy=Math.sqrt(3)/2,Ry=1/Math.sqrt(12),Ly=3*(Ry/2+1),Dy={draw:function(t,n){var e=Math.sqrt(n/Ly),r=e/2,i=e*Ry,o=r,a=e*Ry+e,u=-o,f=a;t.moveTo(r,i),t.lineTo(o,a),t.lineTo(u,f),t.lineTo(-.5*r-zy*i,zy*r+-.5*i),t.lineTo(-.5*o-zy*a,zy*o+-.5*a),t.lineTo(-.5*u-zy*f,zy*u+-.5*f),t.lineTo(-.5*r+zy*i,-.5*i-zy*r),t.lineTo(-.5*o+zy*a,-.5*a-zy*o),t.lineTo(-.5*u+zy*f,-.5*f-zy*u),t.closePath()}},Uy=[my,xy,Ay,ky,Ey,Py,Dy];function qy(){}function Oy(t,n,e){t._context.bezierCurveTo((2*t._x0+t._x1)/3,(2*t._y0+t._y1)/3,(t._x0+2*t._x1)/3,(t._y0+2*t._y1)/3,(t._x0+4*t._x1+n)/6,(t._y0+4*t._y1+e)/6)}function Yy(t){this._context=t}function By(t){this._context=t}function Fy(t){this._context=t}function Iy(t,n){this._basis=new Yy(t),this._beta=n}Yy.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:Oy(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);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:Oy(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},By.prototype={areaStart:qy,areaEnd:qy,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)}},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._x2=t,this._y2=n;break;case 1:this._point=2,this._x3=t,this._y3=n;break;case 2:this._point=3,this._x4=t,this._y4=n,this._context.moveTo((this._x0+4*this._x1+t)/6,(this._y0+4*this._y1+n)/6);break;default:Oy(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},Fy.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||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var e=(this._x0+4*this._x1+t)/6,r=(this._y0+4*this._y1+n)/6;this._line?this._context.lineTo(e,r):this._context.moveTo(e,r);break;case 3:this._point=4;default:Oy(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},Iy.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var t=this._x,n=this._y,e=t.length-1;if(e>0)for(var r,i=t[0],o=n[0],a=t[e]-i,u=n[e]-o,f=-1;++f<=e;)r=f/e,this._basis.point(this._beta*t[f]+(1-this._beta)*(i+r*a),this._beta*n[f]+(1-this._beta)*(o+r*u));this._x=this._y=null,this._basis.lineEnd()},point:function(t,n){this._x.push(+t),this._y.push(+n)}};var Hy=function t(n){function e(t){return 1===n?new Yy(t):new Iy(t,n)}return e.beta=function(n){return t(+n)},e}(.85);function jy(t,n,e){t._context.bezierCurveTo(t._x1+t._k*(t._x2-t._x0),t._y1+t._k*(t._y2-t._y0),t._x2+t._k*(t._x1-n),t._y2+t._k*(t._y1-e),t._x2,t._y2)}function Xy(t,n){this._context=t,this._k=(1-n)/6}Xy.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:jy(this,this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2,this._x1=t,this._y1=n;break;case 2:this._point=3;default:jy(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Gy=function t(n){function e(t){return new Xy(t,n)}return e.tension=function(n){return t(+n)},e}(0);function Vy(t,n){this._context=t,this._k=(1-n)/6}Vy.prototype={areaStart:qy,areaEnd:qy,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)}},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._x3=t,this._y3=n;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=n);break;case 2:this._point=3,this._x5=t,this._y5=n;break;default:jy(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var $y=function t(n){function e(t){return new Vy(t,n)}return e.tension=function(n){return t(+n)},e}(0);function Wy(t,n){this._context=t,this._k=(1-n)/6}Wy.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||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,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:jy(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Zy=function t(n){function e(t){return new Wy(t,n)}return e.tension=function(n){return t(+n)},e}(0);function Qy(t,n,e){var r=t._x1,i=t._y1,o=t._x2,a=t._y2;if(t._l01_a>Fg){var u=2*t._l01_2a+3*t._l01_a*t._l12_a+t._l12_2a,f=3*t._l01_a*(t._l01_a+t._l12_a);r=(r*u-t._x0*t._l12_2a+t._x2*t._l01_2a)/f,i=(i*u-t._y0*t._l12_2a+t._y2*t._l01_2a)/f}if(t._l23_a>Fg){var c=2*t._l23_2a+3*t._l23_a*t._l12_a+t._l12_2a,s=3*t._l23_a*(t._l23_a+t._l12_a);o=(o*c+t._x1*t._l23_2a-n*t._l12_2a)/s,a=(a*c+t._y1*t._l23_2a-e*t._l12_2a)/s}t._context.bezierCurveTo(r,i,o,a,t._x2,t._y2)}function Jy(t,n){this._context=t,this._alpha=n}Jy.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)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3;default:Qy(this,t,n)}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=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Ky=function t(n){function e(t){return n?new Jy(t,n):new Xy(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function t_(t,n){this._context=t,this._alpha=n}t_.prototype={areaStart:qy,areaEnd:qy,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)}},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=t,this._y3=n;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=n);break;case 2:this._point=3,this._x5=t,this._y5=n;break;default:Qy(this,t,n)}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=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var n_=function t(n){function e(t){return n?new t_(t,n):new Vy(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function e_(t,n){this._context=t,this._alpha=n}e_.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||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,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:Qy(this,t,n)}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=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var r_=function t(n){function e(t){return n?new e_(t,n):new Wy(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function i_(t){this._context=t}function o_(t){return t<0?-1:1}function a_(t,n,e){var r=t._x1-t._x0,i=n-t._x1,o=(t._y1-t._y0)/(r||i<0&&-0),a=(e-t._y1)/(i||r<0&&-0),u=(o*i+a*r)/(r+i);return(o_(o)+o_(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(u))||0}function u_(t,n){var e=t._x1-t._x0;return e?(3*(t._y1-t._y0)/e-n)/2:n}function f_(t,n,e){var r=t._x0,i=t._y0,o=t._x1,a=t._y1,u=(o-r)/3;t._context.bezierCurveTo(r+u,i+u*n,o-u,a-u*e,o,a)}function c_(t){this._context=t}function s_(t){this._context=new l_(t)}function l_(t){this._context=t}function h_(t){this._context=t}function d_(t){var n,e,r=t.length-1,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=t[0]+2*t[1],n=1;n<r-1;++n)i[n]=1,o[n]=4,a[n]=4*t[n]+2*t[n+1];for(i[r-1]=2,o[r-1]=7,a[r-1]=8*t[r-1]+t[r],n=1;n<r;++n)e=i[n]/o[n-1],o[n]-=e,a[n]-=e*a[n-1];for(i[r-1]=a[r-1]/o[r-1],n=r-2;n>=0;--n)i[n]=(a[n]-i[n+1])/o[n];for(o[r-1]=(t[r]+i[r-1])/2,n=0;n<r-1;++n)o[n]=2*t[n+1]-i[n+1];return[i,o]}function p_(t,n){this._context=t,this._t=n}function v_(t,n){if((i=t.length)>1)for(var e,r,i,o=1,a=t[n[0]],u=a.length;o<i;++o)for(r=a,a=t[n[o]],e=0;e<u;++e)a[e][1]+=a[e][0]=isNaN(r[e][1])?r[e][0]:r[e][1]}function g_(t){for(var n=t.length,e=new Array(n);--n>=0;)e[n]=n;return e}function y_(t,n){return t[n]}function __(t){var n=t.map(b_);return g_(t).sort(function(t,e){return n[t]-n[e]})}function b_(t){for(var n,e=0,r=-1,i=t.length;++r<i;)(n=+t[r][1])&&(e+=n);return e}function m_(t){return function(){return t}}function x_(t){return t[0]}function w_(t){return t[1]}function M_(){this._=null}function A_(t){t.U=t.C=t.L=t.R=t.P=t.N=null}function T_(t,n){var e=n,r=n.R,i=e.U;i?i.L===e?i.L=r:i.R=r:t._=r,r.U=i,e.U=r,e.R=r.L,e.R&&(e.R.U=e),r.L=e}function N_(t,n){var e=n,r=n.L,i=e.U;i?i.L===e?i.L=r:i.R=r:t._=r,r.U=i,e.U=r,e.L=r.R,e.L&&(e.L.U=e),r.R=e}function S_(t){for(;t.L;)t=t.L;return t}function E_(t,n,e,r){var i=[null,null],o=J_.push(i)-1;return i.left=t,i.right=n,e&&C_(i,t,n,e),r&&C_(i,n,t,r),Z_[t.index].halfedges.push(o),Z_[n.index].halfedges.push(o),i}function k_(t,n,e){var r=[n,e];return r.left=t,r}function C_(t,n,e,r){t[0]||t[1]?t.left===e?t[1]=r:t[0]=r:(t[0]=r,t.left=n,t.right=e)}function P_(t,n,e,r,i){var o,a=t[0],u=t[1],f=a[0],c=a[1],s=0,l=1,h=u[0]-f,d=u[1]-c;if(o=n-f,h||!(o>0)){if(o/=h,h<0){if(o<s)return;o<l&&(l=o)}else if(h>0){if(o>l)return;o>s&&(s=o)}if(o=r-f,h||!(o<0)){if(o/=h,h<0){if(o>l)return;o>s&&(s=o)}else if(h>0){if(o<s)return;o<l&&(l=o)}if(o=e-c,d||!(o>0)){if(o/=d,d<0){if(o<s)return;o<l&&(l=o)}else if(d>0){if(o>l)return;o>s&&(s=o)}if(o=i-c,d||!(o<0)){if(o/=d,d<0){if(o>l)return;o>s&&(s=o)}else if(d>0){if(o<s)return;o<l&&(l=o)}return!(s>0||l<1)||(s>0&&(t[0]=[f+s*h,c+s*d]),l<1&&(t[1]=[f+l*h,c+l*d]),!0)}}}}}function z_(t,n,e,r,i){var o=t[1];if(o)return!0;var a,u,f=t[0],c=t.left,s=t.right,l=c[0],h=c[1],d=s[0],p=s[1],v=(l+d)/2,g=(h+p)/2;if(p===h){if(v<n||v>=r)return;if(l>d){if(f){if(f[1]>=i)return}else f=[v,e];o=[v,i]}else{if(f){if(f[1]<e)return}else f=[v,i];o=[v,e]}}else if(u=g-(a=(l-d)/(p-h))*v,a<-1||a>1)if(l>d){if(f){if(f[1]>=i)return}else f=[(e-u)/a,e];o=[(i-u)/a,i]}else{if(f){if(f[1]<e)return}else f=[(i-u)/a,i];o=[(e-u)/a,e]}else if(h<p){if(f){if(f[0]>=r)return}else f=[n,a*n+u];o=[r,a*r+u]}else{if(f){if(f[0]<n)return}else f=[r,a*r+u];o=[n,a*n+u]}return t[0]=f,t[1]=o,!0}function R_(t,n){var e=t.site,r=n.left,i=n.right;return e===i&&(i=r,r=e),i?Math.atan2(i[1]-r[1],i[0]-r[0]):(e===r?(r=n[1],i=n[0]):(r=n[0],i=n[1]),Math.atan2(r[0]-i[0],i[1]-r[1]))}function L_(t,n){return n[+(n.left!==t.site)]}function D_(t,n){return n[+(n.left===t.site)]}i_.prototype={areaStart:qy,areaEnd:qy,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(t,n){t=+t,n=+n,this._point?this._context.lineTo(t,n):(this._point=1,this._context.moveTo(t,n))}},c_.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:f_(this,this._t0,u_(this,this._t0))}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){var e=NaN;if(n=+n,(t=+t)!==this._x1||n!==this._y1){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3,f_(this,u_(this,e=a_(this,t,n)),e);break;default:f_(this,this._t0,e=a_(this,t,n))}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n,this._t0=e}}},(s_.prototype=Object.create(c_.prototype)).point=function(t,n){c_.prototype.point.call(this,n,t)},l_.prototype={moveTo:function(t,n){this._context.moveTo(n,t)},closePath:function(){this._context.closePath()},lineTo:function(t,n){this._context.lineTo(n,t)},bezierCurveTo:function(t,n,e,r,i,o){this._context.bezierCurveTo(n,t,r,e,o,i)}},h_.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var t=this._x,n=this._y,e=t.length;if(e)if(this._line?this._context.lineTo(t[0],n[0]):this._context.moveTo(t[0],n[0]),2===e)this._context.lineTo(t[1],n[1]);else for(var r=d_(t),i=d_(n),o=0,a=1;a<e;++o,++a)this._context.bezierCurveTo(r[0][o],i[0][o],r[1][o],i[1][o],t[a],n[a]);(this._line||0!==this._line&&1===e)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(t,n){this._x.push(+t),this._y.push(+n)}},p_.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&&2===this._point&&this._context.lineTo(this._x,this._y),(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:if(this._t<=0)this._context.lineTo(this._x,n),this._context.lineTo(t,n);else{var e=this._x*(1-this._t)+t*this._t;this._context.lineTo(e,this._y),this._context.lineTo(e,n)}}this._x=t,this._y=n}},M_.prototype={constructor:M_,insert:function(t,n){var e,r,i;if(t){if(n.P=t,n.N=t.N,t.N&&(t.N.P=n),t.N=n,t.R){for(t=t.R;t.L;)t=t.L;t.L=n}else t.R=n;e=t}else this._?(t=S_(this._),n.P=null,n.N=t,t.P=t.L=n,e=t):(n.P=n.N=null,this._=n,e=null);for(n.L=n.R=null,n.U=e,n.C=!0,t=n;e&&e.C;)e===(r=e.U).L?(i=r.R)&&i.C?(e.C=i.C=!1,r.C=!0,t=r):(t===e.R&&(T_(this,e),e=(t=e).U),e.C=!1,r.C=!0,N_(this,r)):(i=r.L)&&i.C?(e.C=i.C=!1,r.C=!0,t=r):(t===e.L&&(N_(this,e),e=(t=e).U),e.C=!1,r.C=!0,T_(this,r)),e=t.U;this._.C=!1},remove:function(t){t.N&&(t.N.P=t.P),t.P&&(t.P.N=t.N),t.N=t.P=null;var n,e,r,i=t.U,o=t.L,a=t.R;if(e=o?a?S_(a):o:a,i?i.L===t?i.L=e:i.R=e:this._=e,o&&a?(r=e.C,e.C=t.C,e.L=o,o.U=e,e!==a?(i=e.U,e.U=t.U,t=e.R,i.L=t,e.R=a,a.U=e):(e.U=i,i=e,t=e.R)):(r=t.C,t=e),t&&(t.U=i),!r)if(t&&t.C)t.C=!1;else{do{if(t===this._)break;if(t===i.L){if((n=i.R).C&&(n.C=!1,i.C=!0,T_(this,i),n=i.R),n.L&&n.L.C||n.R&&n.R.C){n.R&&n.R.C||(n.L.C=!1,n.C=!0,N_(this,n),n=i.R),n.C=i.C,i.C=n.R.C=!1,T_(this,i),t=this._;break}}else if((n=i.L).C&&(n.C=!1,i.C=!0,N_(this,i),n=i.L),n.L&&n.L.C||n.R&&n.R.C){n.L&&n.L.C||(n.R.C=!1,n.C=!0,T_(this,n),n=i.L),n.C=i.C,i.C=n.L.C=!1,N_(this,i),t=this._;break}n.C=!0,t=i,i=i.U}while(!t.C);t&&(t.C=!1)}}};var U_,q_=[];function O_(){A_(this),this.x=this.y=this.arc=this.site=this.cy=null}function Y_(t){var n=t.P,e=t.N;if(n&&e){var r=n.site,i=t.site,o=e.site;if(r!==o){var a=i[0],u=i[1],f=r[0]-a,c=r[1]-u,s=o[0]-a,l=o[1]-u,h=2*(f*l-c*s);if(!(h>=-tb)){var d=f*f+c*c,p=s*s+l*l,v=(l*d-c*p)/h,g=(f*p-s*d)/h,y=q_.pop()||new O_;y.arc=t,y.site=i,y.x=v+a,y.y=(y.cy=g+u)+Math.sqrt(v*v+g*g),t.circle=y;for(var _=null,b=Q_._;b;)if(y.y<b.y||y.y===b.y&&y.x<=b.x){if(!b.L){_=b.P;break}b=b.L}else{if(!b.R){_=b;break}b=b.R}Q_.insert(_,y),_||(U_=y)}}}}function B_(t){var n=t.circle;n&&(n.P||(U_=n.N),Q_.remove(n),q_.push(n),A_(n),t.circle=null)}var F_=[];function I_(){A_(this),this.edge=this.site=this.circle=null}function H_(t){var n=F_.pop()||new I_;return n.site=t,n}function j_(t){B_(t),W_.remove(t),F_.push(t),A_(t)}function X_(t){var n=t.circle,e=n.x,r=n.cy,i=[e,r],o=t.P,a=t.N,u=[t];j_(t);for(var f=o;f.circle&&Math.abs(e-f.circle.x)<K_&&Math.abs(r-f.circle.cy)<K_;)o=f.P,u.unshift(f),j_(f),f=o;u.unshift(f),B_(f);for(var c=a;c.circle&&Math.abs(e-c.circle.x)<K_&&Math.abs(r-c.circle.cy)<K_;)a=c.N,u.push(c),j_(c),c=a;u.push(c),B_(c);var s,l=u.length;for(s=1;s<l;++s)c=u[s],f=u[s-1],C_(c.edge,f.site,c.site,i);f=u[0],(c=u[l-1]).edge=E_(f.site,c.site,null,i),Y_(f),Y_(c)}function G_(t){for(var n,e,r,i,o=t[0],a=t[1],u=W_._;u;)if((r=V_(u,a)-o)>K_)u=u.L;else{if(!((i=o-$_(u,a))>K_)){r>-K_?(n=u.P,e=u):i>-K_?(n=u,e=u.N):n=e=u;break}if(!u.R){n=u;break}u=u.R}!function(t){Z_[t.index]={site:t,halfedges:[]}}(t);var f=H_(t);if(W_.insert(n,f),n||e){if(n===e)return B_(n),e=H_(n.site),W_.insert(f,e),f.edge=e.edge=E_(n.site,f.site),Y_(n),void Y_(e);if(e){B_(n),B_(e);var c=n.site,s=c[0],l=c[1],h=t[0]-s,d=t[1]-l,p=e.site,v=p[0]-s,g=p[1]-l,y=2*(h*g-d*v),_=h*h+d*d,b=v*v+g*g,m=[(g*_-d*b)/y+s,(h*b-v*_)/y+l];C_(e.edge,c,p,m),f.edge=E_(c,t,null,m),e.edge=E_(t,p,null,m),Y_(n),Y_(e)}else f.edge=E_(n.site,f.site)}}function V_(t,n){var e=t.site,r=e[0],i=e[1],o=i-n;if(!o)return r;var a=t.P;if(!a)return-1/0;var u=(e=a.site)[0],f=e[1],c=f-n;if(!c)return u;var s=u-r,l=1/o-1/c,h=s/c;return l?(-h+Math.sqrt(h*h-2*l*(s*s/(-2*c)-f+c/2+i-o/2)))/l+r:(r+u)/2}function $_(t,n){var e=t.N;if(e)return V_(e,n);var r=t.site;return r[1]===n?r[0]:1/0}var W_,Z_,Q_,J_,K_=1e-6,tb=1e-12;function nb(t,n){return n[1]-t[1]||n[0]-t[0]}function eb(t,n){var e,r,i,o=t.sort(nb).pop();for(J_=[],Z_=new Array(t.length),W_=new M_,Q_=new M_;;)if(i=U_,o&&(!i||o[1]<i.y||o[1]===i.y&&o[0]<i.x))o[0]===e&&o[1]===r||(G_(o),e=o[0],r=o[1]),o=t.pop();else{if(!i)break;X_(i.arc)}if(function(){for(var t,n,e,r,i=0,o=Z_.length;i<o;++i)if((t=Z_[i])&&(r=(n=t.halfedges).length)){var a=new Array(r),u=new Array(r);for(e=0;e<r;++e)a[e]=e,u[e]=R_(t,J_[n[e]]);for(a.sort(function(t,n){return u[n]-u[t]}),e=0;e<r;++e)u[e]=n[a[e]];for(e=0;e<r;++e)n[e]=u[e]}}(),n){var a=+n[0][0],u=+n[0][1],f=+n[1][0],c=+n[1][1];!function(t,n,e,r){for(var i,o=J_.length;o--;)z_(i=J_[o],t,n,e,r)&&P_(i,t,n,e,r)&&(Math.abs(i[0][0]-i[1][0])>K_||Math.abs(i[0][1]-i[1][1])>K_)||delete J_[o]}(a,u,f,c),function(t,n,e,r){var i,o,a,u,f,c,s,l,h,d,p,v,g=Z_.length,y=!0;for(i=0;i<g;++i)if(o=Z_[i]){for(a=o.site,u=(f=o.halfedges).length;u--;)J_[f[u]]||f.splice(u,1);for(u=0,c=f.length;u<c;)p=(d=D_(o,J_[f[u]]))[0],v=d[1],l=(s=L_(o,J_[f[++u%c]]))[0],h=s[1],(Math.abs(p-l)>K_||Math.abs(v-h)>K_)&&(f.splice(u,0,J_.push(k_(a,d,Math.abs(p-t)<K_&&r-v>K_?[t,Math.abs(l-t)<K_?h:r]:Math.abs(v-r)<K_&&e-p>K_?[Math.abs(h-r)<K_?l:e,r]:Math.abs(p-e)<K_&&v-n>K_?[e,Math.abs(l-e)<K_?h:n]:Math.abs(v-n)<K_&&p-t>K_?[Math.abs(h-n)<K_?l:t,n]:null))-1),++c);c&&(y=!1)}if(y){var _,b,m,x=1/0;for(i=0,y=null;i<g;++i)(o=Z_[i])&&(m=(_=(a=o.site)[0]-t)*_+(b=a[1]-n)*b)<x&&(x=m,y=o);if(y){var w=[t,n],M=[t,r],A=[e,r],T=[e,n];y.halfedges.push(J_.push(k_(a=y.site,w,M))-1,J_.push(k_(a,M,A))-1,J_.push(k_(a,A,T))-1,J_.push(k_(a,T,w))-1)}}for(i=0;i<g;++i)(o=Z_[i])&&(o.halfedges.length||delete Z_[i])}(a,u,f,c)}this.edges=J_,this.cells=Z_,W_=Q_=J_=Z_=null}function rb(t){return function(){return t}}function ib(t,n,e){this.target=t,this.type=n,this.transform=e}function ob(t,n,e){this.k=t,this.x=n,this.y=e}eb.prototype={constructor:eb,polygons:function(){var t=this.edges;return this.cells.map(function(n){var e=n.halfedges.map(function(e){return L_(n,t[e])});return e.data=n.site.data,e})},triangles:function(){var t=[],n=this.edges;return this.cells.forEach(function(e,r){if(o=(i=e.halfedges).length)for(var i,o,a,u,f,c,s=e.site,l=-1,h=n[i[o-1]],d=h.left===s?h.right:h.left;++l<o;)a=d,d=(h=n[i[l]]).left===s?h.right:h.left,a&&d&&r<a.index&&r<d.index&&(f=a,c=d,((u=s)[0]-c[0])*(f[1]-u[1])-(u[0]-f[0])*(c[1]-u[1])<0)&&t.push([s.data,a.data,d.data])}),t},links:function(){return this.edges.filter(function(t){return t.right}).map(function(t){return{source:t.left.data,target:t.right.data}})},find:function(t,n,e){for(var r,i,o=this,a=o._found||0,u=o.cells.length;!(i=o.cells[a]);)if(++a>=u)return null;var f=t-i.site[0],c=n-i.site[1],s=f*f+c*c;do{i=o.cells[r=a],a=null,i.halfedges.forEach(function(e){var r=o.edges[e],u=r.left;if(u!==i.site&&u||(u=r.right)){var f=t-u[0],c=n-u[1],l=f*f+c*c;l<s&&(s=l,a=u.index)}})}while(null!==a);return o._found=r,null==e||s<=e*e?i.site:null}},ob.prototype={constructor:ob,scale:function(t){return 1===t?this:new ob(this.k*t,this.x,this.y)},translate:function(t,n){return 0===t&0===n?this:new ob(this.k,this.x+this.k*t,this.y+this.k*n)},apply:function(t){return[t[0]*this.k+this.x,t[1]*this.k+this.y]},applyX:function(t){return t*this.k+this.x},applyY:function(t){return t*this.k+this.y},invert:function(t){return[(t[0]-this.x)/this.k,(t[1]-this.y)/this.k]},invertX:function(t){return(t-this.x)/this.k},invertY:function(t){return(t-this.y)/this.k},rescaleX:function(t){return t.copy().domain(t.range().map(this.invertX,this).map(t.invert,t))},rescaleY:function(t){return t.copy().domain(t.range().map(this.invertY,this).map(t.invert,t))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var ab=new ob(1,0,0);function ub(t){return t.__zoom||ab}function fb(){t.event.stopImmediatePropagation()}function cb(){t.event.preventDefault(),t.event.stopImmediatePropagation()}function sb(){return!t.event.button}function lb(){var t,n,e=this;return e instanceof SVGElement?(t=(e=e.ownerSVGElement||e).width.baseVal.value,n=e.height.baseVal.value):(t=e.clientWidth,n=e.clientHeight),[[0,0],[t,n]]}function hb(){return this.__zoom||ab}function db(){return-t.event.deltaY*(t.event.deltaMode?120:1)/500}function pb(){return"ontouchstart"in this}function vb(t,n,e){var r=t.invertX(n[0][0])-e[0][0],i=t.invertX(n[1][0])-e[1][0],o=t.invertY(n[0][1])-e[0][1],a=t.invertY(n[1][1])-e[1][1];return t.translate(i>r?(r+i)/2:Math.min(0,r)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}ub.prototype=ob.prototype,t.version="5.7.0",t.bisect=i,t.bisectRight=i,t.bisectLeft=o,t.ascending=n,t.bisector=e,t.cross=function(t,n,e){var r,i,o,u,f=t.length,c=n.length,s=new Array(f*c);for(null==e&&(e=a),r=o=0;r<f;++r)for(u=t[r],i=0;i<c;++i,++o)s[o]=e(u,n[i]);return s},t.descending=function(t,n){return n<t?-1:n>t?1:n>=t?0:NaN},t.deviation=c,t.extent=s,t.histogram=function(){var t=v,n=s,e=M;function r(r){var o,a,u=r.length,f=new Array(u);for(o=0;o<u;++o)f[o]=t(r[o],o,r);var c=n(f),s=c[0],l=c[1],h=e(f,s,l);Array.isArray(h)||(h=w(s,l,h),h=g(Math.ceil(s/h)*h,l,h));for(var d=h.length;h[0]<=s;)h.shift(),--d;for(;h[d-1]>l;)h.pop(),--d;var p,v=new Array(d+1);for(o=0;o<=d;++o)(p=v[o]=[]).x0=o>0?h[o-1]:s,p.x1=o<d?h[o]:l;for(o=0;o<u;++o)s<=(a=f[o])&&a<=l&&v[i(h,a,0,d)].push(r[o]);return v}return r.value=function(n){return arguments.length?(t="function"==typeof n?n:p(n),r):t},r.domain=function(t){return arguments.length?(n="function"==typeof t?t:p([t[0],t[1]]),r):n},r.thresholds=function(t){return arguments.length?(e="function"==typeof t?t:Array.isArray(t)?p(h.call(t)):p(t),r):e},r},t.thresholdFreedmanDiaconis=function(t,e,r){return t=d.call(t,u).sort(n),Math.ceil((r-e)/(2*(A(t,.75)-A(t,.25))*Math.pow(t.length,-1/3)))},t.thresholdScott=function(t,n,e){return Math.ceil((e-n)/(3.5*c(t)*Math.pow(t.length,-1/3)))},t.thresholdSturges=M,t.max=T,t.mean=function(t,n){var e,r=t.length,i=r,o=-1,a=0;if(null==n)for(;++o<r;)isNaN(e=u(t[o]))?--i:a+=e;else for(;++o<r;)isNaN(e=u(n(t[o],o,t)))?--i:a+=e;if(i)return a/i},t.median=function(t,e){var r,i=t.length,o=-1,a=[];if(null==e)for(;++o<i;)isNaN(r=u(t[o]))||a.push(r);else for(;++o<i;)isNaN(r=u(e(t[o],o,t)))||a.push(r);return A(a.sort(n),.5)},t.merge=N,t.min=S,t.pairs=function(t,n){null==n&&(n=a);for(var e=0,r=t.length-1,i=t[0],o=new Array(r<0?0:r);e<r;)o[e]=n(i,i=t[++e]);return o},t.permute=function(t,n){for(var e=n.length,r=new Array(e);e--;)r[e]=t[n[e]];return r},t.quantile=A,t.range=g,t.scan=function(t,e){if(r=t.length){var r,i,o=0,a=0,u=t[a];for(null==e&&(e=n);++o<r;)(e(i=t[o],u)<0||0!==e(u,u))&&(u=i,a=o);return 0===e(u,u)?a:void 0}},t.shuffle=function(t,n,e){for(var r,i,o=(null==e?t.length:e)-(n=null==n?0:+n);o;)i=Math.random()*o--|0,r=t[o+n],t[o+n]=t[i+n],t[i+n]=r;return t},t.sum=function(t,n){var e,r=t.length,i=-1,o=0;if(null==n)for(;++i<r;)(e=+t[i])&&(o+=e);else for(;++i<r;)(e=+n(t[i],i,t))&&(o+=e);return o},t.ticks=m,t.tickIncrement=x,t.tickStep=w,t.transpose=E,t.variance=f,t.zip=function(){return E(arguments)},t.axisTop=function(t){return B(z,t)},t.axisRight=function(t){return B(R,t)},t.axisBottom=function(t){return B(L,t)},t.axisLeft=function(t){return B(D,t)},t.brush=function(){return Ri(wi)},t.brushX=function(){return Ri(mi)},t.brushY=function(){return Ri(xi)},t.brushSelection=function(t){var n=t.__brush;return n?n.dim.output(n.selection):null},t.chord=function(){var t=0,n=null,e=null,r=null;function i(i){var o,a,u,f,c,s,l=i.length,h=[],d=g(l),p=[],v=[],y=v.groups=new Array(l),_=new Array(l*l);for(o=0,c=-1;++c<l;){for(a=0,s=-1;++s<l;)a+=i[c][s];h.push(a),p.push(g(l)),o+=a}for(n&&d.sort(function(t,e){return n(h[t],h[e])}),e&&p.forEach(function(t,n){t.sort(function(t,r){return e(i[n][t],i[n][r])})}),f=(o=Yi(0,Oi-t*l)/o)?t:Oi/l,a=0,c=-1;++c<l;){for(u=a,s=-1;++s<l;){var b=d[c],m=p[b][s],x=i[b][m],w=a,M=a+=x*o;_[m*l+b]={index:b,subindex:m,startAngle:w,endAngle:M,value:x}}y[b]={index:b,startAngle:u,endAngle:a,value:h[b]},a+=f}for(c=-1;++c<l;)for(s=c-1;++s<l;){var A=_[s*l+c],T=_[c*l+s];(A.value||T.value)&&v.push(A.value<T.value?{source:T,target:A}:{source:A,target:T})}return r?v.sort(r):v}return i.padAngle=function(n){return arguments.length?(t=Yi(0,n),i):t},i.sortGroups=function(t){return arguments.length?(n=t,i):n},i.sortSubgroups=function(t){return arguments.length?(e=t,i):e},i.sortChords=function(t){return arguments.length?(null==t?r=null:(n=t,r=function(t,e){return n(t.source.value+t.target.value,e.source.value+e.target.value)})._=t,i):r&&r._;var n},i},t.ribbon=function(){var t=Vi,n=$i,e=Wi,r=Zi,i=Qi,o=null;function a(){var a,u=Bi.call(arguments),f=t.apply(this,u),c=n.apply(this,u),s=+e.apply(this,(u[0]=f,u)),l=r.apply(this,u)-qi,h=i.apply(this,u)-qi,d=s*Li(l),p=s*Di(l),v=+e.apply(this,(u[0]=c,u)),g=r.apply(this,u)-qi,y=i.apply(this,u)-qi;if(o||(o=a=Gi()),o.moveTo(d,p),o.arc(0,0,s,l,h),l===g&&h===y||(o.quadraticCurveTo(0,0,v*Li(g),v*Di(g)),o.arc(0,0,v,g,y)),o.quadraticCurveTo(0,0,d,p),o.closePath(),a)return o=null,a+""||null}return a.radius=function(t){return arguments.length?(e="function"==typeof t?t:Fi(+t),a):e},a.startAngle=function(t){return arguments.length?(r="function"==typeof t?t:Fi(+t),a):r},a.endAngle=function(t){return arguments.length?(i="function"==typeof t?t:Fi(+t),a):i},a.source=function(n){return arguments.length?(t=n,a):t},a.target=function(t){return arguments.length?(n=t,a):n},a.context=function(t){return arguments.length?(o=null==t?null:t,a):o},a},t.nest=function(){var t,n,e,r=[],i=[];function o(e,i,a,u){if(i>=r.length)return null!=t&&e.sort(t),null!=n?n(e):e;for(var f,c,s,l=-1,h=e.length,d=r[i++],p=Ki(),v=a();++l<h;)(s=p.get(f=d(c=e[l])+""))?s.push(c):p.set(f,[c]);return p.each(function(t,n){u(v,n,o(t,i,a,u))}),v}return e={object:function(t){return o(t,0,to,no)},map:function(t){return o(t,0,eo,ro)},entries:function(t){return function t(e,o){if(++o>r.length)return e;var a,u=i[o-1];return null!=n&&o>=r.length?a=e.entries():(a=[],e.each(function(n,e){a.push({key:e,values:t(n,o)})})),null!=u?a.sort(function(t,n){return u(t.key,n.key)}):a}(o(t,0,eo,ro),0)},key:function(t){return r.push(t),e},sortKeys:function(t){return i[r.length-1]=t,e},sortValues:function(n){return t=n,e},rollup:function(t){return n=t,e}}},t.set=ao,t.map=Ki,t.keys=function(t){var n=[];for(var e in t)n.push(e);return n},t.values=function(t){var n=[];for(var e in t)n.push(t[e]);return n},t.entries=function(t){var n=[];for(var e in t)n.push({key:e,value:t[e]});return n},t.color=vn,t.rgb=bn,t.hsl=Mn,t.lab=Un,t.hcl=Hn,t.lch=function(t,n,e,r){return 1===arguments.length?In(t):new jn(e,n,t,null==r?1:r)},t.gray=function(t,n){return new qn(t,0,0,null==n?1:n)},t.cubehelix=Kn,t.contours=go,t.contourDensity=function(){var t=bo,n=mo,e=xo,r=960,i=500,o=20,a=2,u=3*o,f=r+2*u>>a,c=i+2*u>>a,s=co(20);function l(r){var i=new Float32Array(f*c),l=new Float32Array(f*c);r.forEach(function(r,o,s){var l=+t(r,o,s)+u>>a,h=+n(r,o,s)+u>>a,d=+e(r,o,s);l>=0&&l<f&&h>=0&&h<c&&(i[l+h*f]+=d)}),yo({width:f,height:c,data:i},{width:f,height:c,data:l},o>>a),_o({width:f,height:c,data:l},{width:f,height:c,data:i},o>>a),yo({width:f,height:c,data:i},{width:f,height:c,data:l},o>>a),_o({width:f,height:c,data:l},{width:f,height:c,data:i},o>>a),yo({width:f,height:c,data:i},{width:f,height:c,data:l},o>>a),_o({width:f,height:c,data:l},{width:f,height:c,data:i},o>>a);var d=s(i);if(!Array.isArray(d)){var p=T(i);d=w(0,p,d),(d=g(0,Math.floor(p/d)*d,d)).shift()}return go().thresholds(d).size([f,c])(i).map(h)}function h(t){return t.value*=Math.pow(2,-2*a),t.coordinates.forEach(d),t}function d(t){t.forEach(p)}function p(t){t.forEach(v)}function v(t){t[0]=t[0]*Math.pow(2,a)-u,t[1]=t[1]*Math.pow(2,a)-u}function y(){return f=r+2*(u=3*o)>>a,c=i+2*u>>a,l}return l.x=function(n){return arguments.length?(t="function"==typeof n?n:co(+n),l):t},l.y=function(t){return arguments.length?(n="function"==typeof t?t:co(+t),l):n},l.weight=function(t){return arguments.length?(e="function"==typeof t?t:co(+t),l):e},l.size=function(t){if(!arguments.length)return[r,i];var n=Math.ceil(t[0]),e=Math.ceil(t[1]);if(!(n>=0||n>=0))throw new Error("invalid size");return r=n,i=e,y()},l.cellSize=function(t){if(!arguments.length)return 1<<a;if(!((t=+t)>=1))throw new Error("invalid cell size");return a=Math.floor(Math.log(t)/Math.LN2),y()},l.thresholds=function(t){return arguments.length?(s="function"==typeof t?t:Array.isArray(t)?co(uo.call(t)):co(t),l):s},l.bandwidth=function(t){if(!arguments.length)return Math.sqrt(o*(o+1));if(!((t=+t)>=0))throw new Error("invalid bandwidth");return o=Math.round((Math.sqrt(4*t*t+1)-1)/2),y()},l},t.dispatch=I,t.drag=function(){var n,e,r,i,o=Wt,a=Zt,u=Qt,f=Jt,c={},s=I("start","drag","end"),l=0,h=0;function d(t){t.on("mousedown.drag",p).filter(f).on("touchstart.drag",y).on("touchmove.drag",_).on("touchend.drag touchcancel.drag",b).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function p(){if(!i&&o.apply(this,arguments)){var u=m("mouse",a.apply(this,arguments),Ft,this,arguments);u&&(Dt(t.event.view).on("mousemove.drag",v,!0).on("mouseup.drag",g,!0),Xt(t.event.view),Ht(),r=!1,n=t.event.clientX,e=t.event.clientY,u("start"))}}function v(){if(jt(),!r){var i=t.event.clientX-n,o=t.event.clientY-e;r=i*i+o*o>h}c.mouse("drag")}function g(){Dt(t.event.view).on("mousemove.drag mouseup.drag",null),Gt(t.event.view,r),jt(),c.mouse("end")}function y(){if(o.apply(this,arguments)){var n,e,r=t.event.changedTouches,i=a.apply(this,arguments),u=r.length;for(n=0;n<u;++n)(e=m(r[n].identifier,i,It,this,arguments))&&(Ht(),e("start"))}}function _(){var n,e,r=t.event.changedTouches,i=r.length;for(n=0;n<i;++n)(e=c[r[n].identifier])&&(jt(),e("drag"))}function b(){var n,e,r=t.event.changedTouches,o=r.length;for(i&&clearTimeout(i),i=setTimeout(function(){i=null},500),n=0;n<o;++n)(e=c[r[n].identifier])&&(Ht(),e("end"))}function m(n,e,r,i,o){var a,f,h,p=r(e,n),v=s.copy();if(Ct(new $t(d,"beforestart",a,n,l,p[0],p[1],0,0,v),function(){return null!=(t.event.subject=a=u.apply(i,o))&&(f=a.x-p[0]||0,h=a.y-p[1]||0,!0)}))return function t(u){var s,g=p;switch(u){case"start":c[n]=t,s=l++;break;case"end":delete c[n],--l;case"drag":p=r(e,n),s=l}Ct(new $t(d,u,a,n,s,p[0]+f,p[1]+h,p[0]-g[0],p[1]-g[1],v),v.apply,v,[u,i,o])}}return d.filter=function(t){return arguments.length?(o="function"==typeof t?t:Vt(!!t),d):o},d.container=function(t){return arguments.length?(a="function"==typeof t?t:Vt(t),d):a},d.subject=function(t){return arguments.length?(u="function"==typeof t?t:Vt(t),d):u},d.touchable=function(t){return arguments.length?(f="function"==typeof t?t:Vt(!!t),d):f},d.on=function(){var t=s.on.apply(s,arguments);return t===s?d:t},d.clickDistance=function(t){return arguments.length?(h=(t=+t)*t,d):Math.sqrt(h)},d},t.dragDisable=Xt,t.dragEnable=Gt,t.dsvFormat=Eo,t.csvParse=Co,t.csvParseRows=Po,t.csvFormat=zo,t.csvFormatRows=Ro,t.tsvParse=Do,t.tsvParseRows=Uo,t.tsvFormat=qo,t.tsvFormatRows=Oo,t.easeLinear=function(t){return+t},t.easeQuad=Dr,t.easeQuadIn=function(t){return t*t},t.easeQuadOut=function(t){return t*(2-t)},t.easeQuadInOut=Dr,t.easeCubic=Ur,t.easeCubicIn=function(t){return t*t*t},t.easeCubicOut=function(t){return--t*t*t+1},t.easeCubicInOut=Ur,t.easePoly=Yr,t.easePolyIn=qr,t.easePolyOut=Or,t.easePolyInOut=Yr,t.easeSin=Ir,t.easeSinIn=function(t){return 1-Math.cos(t*Fr)},t.easeSinOut=function(t){return Math.sin(t*Fr)},t.easeSinInOut=Ir,t.easeExp=Hr,t.easeExpIn=function(t){return Math.pow(2,10*t-10)},t.easeExpOut=function(t){return 1-Math.pow(2,-10*t)},t.easeExpInOut=Hr,t.easeCircle=jr,t.easeCircleIn=function(t){return 1-Math.sqrt(1-t*t)},t.easeCircleOut=function(t){return Math.sqrt(1- --t*t)},t.easeCircleInOut=jr,t.easeBounce=ni,t.easeBounceIn=function(t){return 1-ni(1-t)},t.easeBounceOut=ni,t.easeBounceInOut=function(t){return((t*=2)<=1?1-ni(1-t):ni(t-1)+1)/2},t.easeBack=ii,t.easeBackIn=ei,t.easeBackOut=ri,t.easeBackInOut=ii,t.easeElastic=ui,t.easeElasticIn=ai,t.easeElasticOut=ui,t.easeElasticInOut=fi,t.blob=function(t,n){return fetch(t,n).then(Yo)},t.buffer=function(t,n){return fetch(t,n).then(Bo)},t.dsv=function(t,n,e,r){3===arguments.length&&"function"==typeof e&&(r=e,e=void 0);var i=Eo(t);return Io(n,e).then(function(t){return i.parse(t,r)})},t.csv=jo,t.tsv=Xo,t.image=function(t,n){return new Promise(function(e,r){var i=new Image;for(var o in n)i[o]=n[o];i.onerror=r,i.onload=function(){e(i)},i.src=t})},t.json=function(t,n){return fetch(t,n).then(Go)},t.text=Io,t.xml=$o,t.html=Wo,t.svg=Zo,t.forceCenter=function(t,n){var e;function r(){var r,i,o=e.length,a=0,u=0;for(r=0;r<o;++r)a+=(i=e[r]).x,u+=i.y;for(a=a/o-t,u=u/o-n,r=0;r<o;++r)(i=e[r]).x-=a,i.y-=u}return null==t&&(t=0),null==n&&(n=0),r.initialize=function(t){e=t},r.x=function(n){return arguments.length?(t=+n,r):t},r.y=function(t){return arguments.length?(n=+t,r):n},r},t.forceCollide=function(t){var n,e,r=1,i=1;function o(){for(var t,o,u,f,c,s,l,h=n.length,d=0;d<i;++d)for(o=ra(n,ua,fa).visitAfter(a),t=0;t<h;++t)u=n[t],s=e[u.index],l=s*s,f=u.x+u.vx,c=u.y+u.vy,o.visit(p);function p(t,n,e,i,o){var a=t.data,h=t.r,d=s+h;if(!a)return n>f+d||i<f-d||e>c+d||o<c-d;if(a.index>u.index){var p=f-a.x-a.vx,v=c-a.y-a.vy,g=p*p+v*v;g<d*d&&(0===p&&(g+=(p=Jo())*p),0===v&&(g+=(v=Jo())*v),g=(d-(g=Math.sqrt(g)))/g*r,u.vx+=(p*=g)*(d=(h*=h)/(l+h)),u.vy+=(v*=g)*d,a.vx-=p*(d=1-d),a.vy-=v*d)}}}function a(t){if(t.data)return t.r=e[t.data.index];for(var n=t.r=0;n<4;++n)t[n]&&t[n].r>t.r&&(t.r=t[n].r)}function u(){if(n){var r,i,o=n.length;for(e=new Array(o),r=0;r<o;++r)i=n[r],e[i.index]=+t(i,r,n)}}return"function"!=typeof t&&(t=Qo(null==t?1:+t)),o.initialize=function(t){n=t,u()},o.iterations=function(t){return arguments.length?(i=+t,o):i},o.strength=function(t){return arguments.length?(r=+t,o):r},o.radius=function(n){return arguments.length?(t="function"==typeof n?n:Qo(+n),u(),o):t},o},t.forceLink=function(t){var n,e,r,i,o,a=ca,u=function(t){return 1/Math.min(i[t.source.index],i[t.target.index])},f=Qo(30),c=1;function s(r){for(var i=0,a=t.length;i<c;++i)for(var u,f,s,l,h,d,p,v=0;v<a;++v)f=(u=t[v]).source,l=(s=u.target).x+s.vx-f.x-f.vx||Jo(),h=s.y+s.vy-f.y-f.vy||Jo(),l*=d=((d=Math.sqrt(l*l+h*h))-e[v])/d*r*n[v],h*=d,s.vx-=l*(p=o[v]),s.vy-=h*p,f.vx+=l*(p=1-p),f.vy+=h*p}function l(){if(r){var u,f,c=r.length,s=t.length,l=Ki(r,a);for(u=0,i=new Array(c);u<s;++u)(f=t[u]).index=u,"object"!=typeof f.source&&(f.source=sa(l,f.source)),"object"!=typeof f.target&&(f.target=sa(l,f.target)),i[f.source.index]=(i[f.source.index]||0)+1,i[f.target.index]=(i[f.target.index]||0)+1;for(u=0,o=new Array(s);u<s;++u)f=t[u],o[u]=i[f.source.index]/(i[f.source.index]+i[f.target.index]);n=new Array(s),h(),e=new Array(s),d()}}function h(){if(r)for(var e=0,i=t.length;e<i;++e)n[e]=+u(t[e],e,t)}function d(){if(r)for(var n=0,i=t.length;n<i;++n)e[n]=+f(t[n],n,t)}return null==t&&(t=[]),s.initialize=function(t){r=t,l()},s.links=function(n){return arguments.length?(t=n,l(),s):t},s.id=function(t){return arguments.length?(a=t,s):a},s.iterations=function(t){return arguments.length?(c=+t,s):c},s.strength=function(t){return arguments.length?(u="function"==typeof t?t:Qo(+t),h(),s):u},s.distance=function(t){return arguments.length?(f="function"==typeof t?t:Qo(+t),d(),s):f},s},t.forceManyBody=function(){var t,n,e,r,i=Qo(-30),o=1,a=1/0,u=.81;function f(r){var i,o=t.length,a=ra(t,la,ha).visitAfter(s);for(e=r,i=0;i<o;++i)n=t[i],a.visit(l)}function c(){if(t){var n,e,o=t.length;for(r=new Array(o),n=0;n<o;++n)e=t[n],r[e.index]=+i(e,n,t)}}function s(t){var n,e,i,o,a,u=0,f=0;if(t.length){for(i=o=a=0;a<4;++a)(n=t[a])&&(e=Math.abs(n.value))&&(u+=n.value,f+=e,i+=e*n.x,o+=e*n.y);t.x=i/f,t.y=o/f}else{(n=t).x=n.data.x,n.y=n.data.y;do{u+=r[n.data.index]}while(n=n.next)}t.value=u}function l(t,i,f,c){if(!t.value)return!0;var s=t.x-n.x,l=t.y-n.y,h=c-i,d=s*s+l*l;if(h*h/u<d)return d<a&&(0===s&&(d+=(s=Jo())*s),0===l&&(d+=(l=Jo())*l),d<o&&(d=Math.sqrt(o*d)),n.vx+=s*t.value*e/d,n.vy+=l*t.value*e/d),!0;if(!(t.length||d>=a)){(t.data!==n||t.next)&&(0===s&&(d+=(s=Jo())*s),0===l&&(d+=(l=Jo())*l),d<o&&(d=Math.sqrt(o*d)));do{t.data!==n&&(h=r[t.data.index]*e/d,n.vx+=s*h,n.vy+=l*h)}while(t=t.next)}}return f.initialize=function(n){t=n,c()},f.strength=function(t){return arguments.length?(i="function"==typeof t?t:Qo(+t),c(),f):i},f.distanceMin=function(t){return arguments.length?(o=t*t,f):Math.sqrt(o)},f.distanceMax=function(t){return arguments.length?(a=t*t,f):Math.sqrt(a)},f.theta=function(t){return arguments.length?(u=t*t,f):Math.sqrt(u)},f},t.forceRadial=function(t,n,e){var r,i,o,a=Qo(.1);function u(t){for(var a=0,u=r.length;a<u;++a){var f=r[a],c=f.x-n||1e-6,s=f.y-e||1e-6,l=Math.sqrt(c*c+s*s),h=(o[a]-l)*i[a]*t/l;f.vx+=c*h,f.vy+=s*h}}function f(){if(r){var n,e=r.length;for(i=new Array(e),o=new Array(e),n=0;n<e;++n)o[n]=+t(r[n],n,r),i[n]=isNaN(o[n])?0:+a(r[n],n,r)}}return"function"!=typeof t&&(t=Qo(+t)),null==n&&(n=0),null==e&&(e=0),u.initialize=function(t){r=t,f()},u.strength=function(t){return arguments.length?(a="function"==typeof t?t:Qo(+t),f(),u):a},u.radius=function(n){return arguments.length?(t="function"==typeof n?n:Qo(+n),f(),u):t},u.x=function(t){return arguments.length?(n=+t,u):n},u.y=function(t){return arguments.length?(e=+t,u):e},u},t.forceSimulation=function(t){var n,e=1,r=.001,i=1-Math.pow(r,1/300),o=0,a=.6,u=Ki(),f=ur(s),c=I("tick","end");function s(){l(),c.call("tick",n),e<r&&(f.stop(),c.call("end",n))}function l(){var n,r,f=t.length;for(e+=(o-e)*i,u.each(function(t){t(e)}),n=0;n<f;++n)null==(r=t[n]).fx?r.x+=r.vx*=a:(r.x=r.fx,r.vx=0),null==r.fy?r.y+=r.vy*=a:(r.y=r.fy,r.vy=0)}function h(){for(var n,e=0,r=t.length;e<r;++e){if((n=t[e]).index=e,isNaN(n.x)||isNaN(n.y)){var i=da*Math.sqrt(e),o=e*pa;n.x=i*Math.cos(o),n.y=i*Math.sin(o)}(isNaN(n.vx)||isNaN(n.vy))&&(n.vx=n.vy=0)}}function d(n){return n.initialize&&n.initialize(t),n}return null==t&&(t=[]),h(),n={tick:l,restart:function(){return f.restart(s),n},stop:function(){return f.stop(),n},nodes:function(e){return arguments.length?(t=e,h(),u.each(d),n):t},alpha:function(t){return arguments.length?(e=+t,n):e},alphaMin:function(t){return arguments.length?(r=+t,n):r},alphaDecay:function(t){return arguments.length?(i=+t,n):+i},alphaTarget:function(t){return arguments.length?(o=+t,n):o},velocityDecay:function(t){return arguments.length?(a=1-t,n):1-a},force:function(t,e){return arguments.length>1?(null==e?u.remove(t):u.set(t,d(e)),n):u.get(t)},find:function(n,e,r){var i,o,a,u,f,c=0,s=t.length;for(null==r?r=1/0:r*=r,c=0;c<s;++c)(a=(i=n-(u=t[c]).x)*i+(o=e-u.y)*o)<r&&(f=u,r=a);return f},on:function(t,e){return arguments.length>1?(c.on(t,e),n):c.on(t)}}},t.forceX=function(t){var n,e,r,i=Qo(.1);function o(t){for(var i,o=0,a=n.length;o<a;++o)(i=n[o]).vx+=(r[o]-i.x)*e[o]*t}function a(){if(n){var o,a=n.length;for(e=new Array(a),r=new Array(a),o=0;o<a;++o)e[o]=isNaN(r[o]=+t(n[o],o,n))?0:+i(n[o],o,n)}}return"function"!=typeof t&&(t=Qo(null==t?0:+t)),o.initialize=function(t){n=t,a()},o.strength=function(t){return arguments.length?(i="function"==typeof t?t:Qo(+t),a(),o):i},o.x=function(n){return arguments.length?(t="function"==typeof n?n:Qo(+n),a(),o):t},o},t.forceY=function(t){var n,e,r,i=Qo(.1);function o(t){for(var i,o=0,a=n.length;o<a;++o)(i=n[o]).vy+=(r[o]-i.y)*e[o]*t}function a(){if(n){var o,a=n.length;for(e=new Array(a),r=new Array(a),o=0;o<a;++o)e[o]=isNaN(r[o]=+t(n[o],o,n))?0:+i(n[o],o,n)}}return"function"!=typeof t&&(t=Qo(null==t?0:+t)),o.initialize=function(t){n=t,a()},o.strength=function(t){return arguments.length?(i="function"==typeof t?t:Qo(+t),a(),o):i},o.y=function(n){return arguments.length?(t="function"==typeof n?n:Qo(+n),a(),o):t},o},t.formatDefaultLocale=Sa,t.formatLocale=Na,t.formatSpecifier=ba,t.precisionFixed=Ea,t.precisionPrefix=ka,t.precisionRound=Ca,t.geoArea=function(t){return yu.reset(),su(t,_u),2*yu},t.geoBounds=function(t){var n,e,r,i,o,a,u;if(Ru=zu=-(Cu=Pu=1/0),Ou=[],su(t,rf),e=Ou.length){for(Ou.sort(df),n=1,o=[r=Ou[0]];n<e;++n)pf(r,(i=Ou[n])[0])||pf(r,i[1])?(hf(r[0],i[1])>hf(r[0],r[1])&&(r[1]=i[1]),hf(i[0],r[1])>hf(r[0],r[1])&&(r[0]=i[0])):o.push(r=i);for(a=-1/0,n=0,r=o[e=o.length-1];n<=e;r=i,++n)i=o[n],(u=hf(r[1],i[0]))>a&&(a=u,Cu=i[0],zu=r[1])}return Ou=Yu=null,Cu===1/0||Pu===1/0?[[NaN,NaN],[NaN,NaN]]:[[Cu,Pu],[zu,Ru]]},t.geoCentroid=function(t){Bu=Fu=Iu=Hu=ju=Xu=Gu=Vu=$u=Wu=Zu=0,su(t,vf);var n=$u,e=Wu,r=Zu,i=n*n+e*e+r*r;return i<Ua&&(n=Xu,e=Gu,r=Vu,Fu<Da&&(n=Iu,e=Hu,r=ju),(i=n*n+e*e+r*r)<Ua)?[NaN,NaN]:[Xa(e,n)*Fa,eu(r/Ka(i))*Fa]},t.geoCircle=function(){var t,n,e=Nf([0,0]),r=Nf(90),i=Nf(6),o={point:function(e,r){t.push(e=n(e,r)),e[0]*=Fa,e[1]*=Fa}};function a(){var a=e.apply(this,arguments),u=r.apply(this,arguments)*Ia,f=i.apply(this,arguments)*Ia;return t=[],n=kf(-a[0]*Ia,-a[1]*Ia,0).invert,Lf(o,u,f,1),a={type:"Polygon",coordinates:[t]},t=n=null,a}return a.center=function(t){return arguments.length?(e="function"==typeof t?t:Nf([+t[0],+t[1]]),a):e},a.radius=function(t){return arguments.length?(r="function"==typeof t?t:Nf(+t),a):r},a.precision=function(t){return arguments.length?(i="function"==typeof t?t:Nf(+t),a):i},a},t.geoClipAntimeridian=Gf,t.geoClipCircle=Vf,t.geoClipExtent=function(){var t,n,e,r=0,i=0,o=960,a=500;return e={stream:function(e){return t&&n===e?t:t=Zf(r,i,o,a)(n=e)},extent:function(u){return arguments.length?(r=+u[0][0],i=+u[0][1],o=+u[1][0],a=+u[1][1],t=n=null,e):[[r,i],[o,a]]}}},t.geoClipRectangle=Zf,t.geoContains=function(t,n){return(t&&cc.hasOwnProperty(t.type)?cc[t.type]:lc)(t,n)},t.geoDistance=fc,t.geoGraticule=bc,t.geoGraticule10=function(){return bc()()},t.geoInterpolate=function(t,n){var e=t[0]*Ia,r=t[1]*Ia,i=n[0]*Ia,o=n[1]*Ia,a=Ga(r),u=Qa(r),f=Ga(o),c=Qa(o),s=a*Ga(e),l=a*Qa(e),h=f*Ga(i),d=f*Qa(i),p=2*eu(Ka(ru(o-r)+a*f*ru(i-e))),v=Qa(p),g=p?function(t){var n=Qa(t*=p)/v,e=Qa(p-t)/v,r=e*s+n*h,i=e*l+n*d,o=e*u+n*c;return[Xa(i,r)*Fa,Xa(o,Ka(r*r+i*i))*Fa]}:function(){return[e*Fa,r*Fa]};return g.distance=p,g},t.geoLength=oc,t.geoPath=function(t,n){var e,r,i=4.5;function o(t){return t&&("function"==typeof i&&r.pointRadius(+i.apply(this,arguments)),su(t,e(r))),r.result()}return o.area=function(t){return su(t,e(Sc)),Sc.result()},o.measure=function(t){return su(t,e(ds)),ds.result()},o.bounds=function(t){return su(t,e(Uc)),Uc.result()},o.centroid=function(t){return su(t,e(Zc)),Zc.result()},o.projection=function(n){return arguments.length?(e=null==n?(t=null,mc):(t=n).stream,o):t},o.context=function(t){return arguments.length?(r=null==t?(n=null,new gs):new as(n=t),"function"!=typeof i&&r.pointRadius(i),o):n},o.pointRadius=function(t){return arguments.length?(i="function"==typeof t?t:(r.pointRadius(+t),+t),o):i},o.projection(t).context(n)},t.geoAlbers=Ds,t.geoAlbersUsa=function(){var t,n,e,r,i,o,a=Ds(),u=Ls().rotate([154,0]).center([-2,58.5]).parallels([55,65]),f=Ls().rotate([157,0]).center([-3,19.9]).parallels([8,18]),c={point:function(t,n){o=[t,n]}};function s(t){var n=t[0],a=t[1];return o=null,e.point(n,a),o||(r.point(n,a),o)||(i.point(n,a),o)}function l(){return t=n=null,s}return s.invert=function(t){var n=a.scale(),e=a.translate(),r=(t[0]-e[0])/n,i=(t[1]-e[1])/n;return(i>=.12&&i<.234&&r>=-.425&&r<-.214?u:i>=.166&&i<.234&&r>=-.214&&r<-.115?f:a).invert(t)},s.stream=function(e){return t&&n===e?t:(r=[a.stream(n=e),u.stream(e),f.stream(e)],i=r.length,t={point:function(t,n){for(var e=-1;++e<i;)r[e].point(t,n)},sphere:function(){for(var t=-1;++t<i;)r[t].sphere()},lineStart:function(){for(var t=-1;++t<i;)r[t].lineStart()},lineEnd:function(){for(var t=-1;++t<i;)r[t].lineEnd()},polygonStart:function(){for(var t=-1;++t<i;)r[t].polygonStart()},polygonEnd:function(){for(var t=-1;++t<i;)r[t].polygonEnd()}});var r,i},s.precision=function(t){return arguments.length?(a.precision(t),u.precision(t),f.precision(t),l()):a.precision()},s.scale=function(t){return arguments.length?(a.scale(t),u.scale(.35*t),f.scale(t),s.translate(a.translate())):a.scale()},s.translate=function(t){if(!arguments.length)return a.translate();var n=a.scale(),o=+t[0],s=+t[1];return e=a.translate(t).clipExtent([[o-.455*n,s-.238*n],[o+.455*n,s+.238*n]]).stream(c),r=u.translate([o-.307*n,s+.201*n]).clipExtent([[o-.425*n+Da,s+.12*n+Da],[o-.214*n-Da,s+.234*n-Da]]).stream(c),i=f.translate([o-.205*n,s+.212*n]).clipExtent([[o-.214*n+Da,s+.166*n+Da],[o-.115*n-Da,s+.234*n-Da]]).stream(c),l()},s.fitExtent=function(t,n){return xs(s,t,n)},s.fitSize=function(t,n){return ws(s,t,n)},s.fitWidth=function(t,n){return Ms(s,t,n)},s.fitHeight=function(t,n){return As(s,t,n)},s.scale(1070)},t.geoAzimuthalEqualArea=function(){return Cs(Os).scale(124.75).clipAngle(179.999)},t.geoAzimuthalEqualAreaRaw=Os,t.geoAzimuthalEquidistant=function(){return Cs(Ys).scale(79.4188).clipAngle(179.999)},t.geoAzimuthalEquidistantRaw=Ys,t.geoConicConformal=function(){return zs(Hs).scale(109.5).parallels([30,30])},t.geoConicConformalRaw=Hs,t.geoConicEqualArea=Ls,t.geoConicEqualAreaRaw=Rs,t.geoConicEquidistant=function(){return zs(Xs).scale(131.154).center([0,13.9389])},t.geoConicEquidistantRaw=Xs,t.geoEqualEarth=function(){return Cs(Qs).scale(177.158)},t.geoEqualEarthRaw=Qs,t.geoEquirectangular=function(){return Cs(js).scale(152.63)},t.geoEquirectangularRaw=js,t.geoGnomonic=function(){return Cs(Js).scale(144.049).clipAngle(60)},t.geoGnomonicRaw=Js,t.geoIdentity=function(){var t,n,e,r,i,o,a=1,u=0,f=0,c=1,s=1,l=mc,h=null,d=mc;function p(){return r=i=null,o}return o={stream:function(t){return r&&i===t?r:r=l(d(i=t))},postclip:function(r){return arguments.length?(d=r,h=t=n=e=null,p()):d},clipExtent:function(r){return arguments.length?(d=null==r?(h=t=n=e=null,mc):Zf(h=+r[0][0],t=+r[0][1],n=+r[1][0],e=+r[1][1]),p()):null==h?null:[[h,t],[n,e]]},scale:function(t){return arguments.length?(l=Ks((a=+t)*c,a*s,u,f),p()):a},translate:function(t){return arguments.length?(l=Ks(a*c,a*s,u=+t[0],f=+t[1]),p()):[u,f]},reflectX:function(t){return arguments.length?(l=Ks(a*(c=t?-1:1),a*s,u,f),p()):c<0},reflectY:function(t){return arguments.length?(l=Ks(a*c,a*(s=t?-1:1),u,f),p()):s<0},fitExtent:function(t,n){return xs(o,t,n)},fitSize:function(t,n){return ws(o,t,n)},fitWidth:function(t,n){return Ms(o,t,n)},fitHeight:function(t,n){return As(o,t,n)}}},t.geoProjection=Cs,t.geoProjectionMutator=Ps,t.geoMercator=function(){return Fs(Bs).scale(961/Ba)},t.geoMercatorRaw=Bs,t.geoNaturalEarth1=function(){return Cs(tl).scale(175.295)},t.geoNaturalEarth1Raw=tl,t.geoOrthographic=function(){return Cs(nl).scale(249.5).clipAngle(90+Da)},t.geoOrthographicRaw=nl,t.geoStereographic=function(){return Cs(el).scale(250).clipAngle(142)},t.geoStereographicRaw=el,t.geoTransverseMercator=function(){var t=Fs(rl),n=t.center,e=t.rotate;return t.center=function(t){return arguments.length?n([-t[1],t[0]]):[(t=n())[1],-t[0]]},t.rotate=function(t){return arguments.length?e([t[0],t[1],t.length>2?t[2]+90:90]):[(t=e())[0],t[1],t[2]-90]},e([0,0,90]).scale(159.155)},t.geoTransverseMercatorRaw=rl,t.geoRotation=Rf,t.geoStream=su,t.geoTransform=function(t){return{stream:_s(t)}},t.cluster=function(){var t=il,n=1,e=1,r=!1;function i(i){var o,a=0;i.eachAfter(function(n){var e=n.children;e?(n.x=function(t){return t.reduce(ol,0)/t.length}(e),n.y=function(t){return 1+t.reduce(al,0)}(e)):(n.x=o?a+=t(n,o):0,n.y=0,o=n)});var u=function(t){for(var n;n=t.children;)t=n[0];return t}(i),f=function(t){for(var n;n=t.children;)t=n[n.length-1];return t}(i),c=u.x-t(u,f)/2,s=f.x+t(f,u)/2;return i.eachAfter(r?function(t){t.x=(t.x-i.x)*n,t.y=(i.y-t.y)*e}:function(t){t.x=(t.x-c)/(s-c)*n,t.y=(1-(i.y?t.y/i.y:1))*e})}return i.separation=function(n){return arguments.length?(t=n,i):t},i.size=function(t){return arguments.length?(r=!1,n=+t[0],e=+t[1],i):r?null:[n,e]},i.nodeSize=function(t){return arguments.length?(r=!0,n=+t[0],e=+t[1],i):r?[n,e]:null},i},t.hierarchy=fl,t.pack=function(){var t=null,n=1,e=1,r=El;function i(i){return i.x=n/2,i.y=e/2,t?i.eachBefore(Pl(t)).eachAfter(zl(r,.5)).eachBefore(Rl(1)):i.eachBefore(Pl(Cl)).eachAfter(zl(El,1)).eachAfter(zl(r,i.r/Math.min(n,e))).eachBefore(Rl(Math.min(n,e)/(2*i.r))),i}return i.radius=function(n){return arguments.length?(t=null==(e=n)?null:Sl(e),i):t;var e},i.size=function(t){return arguments.length?(n=+t[0],e=+t[1],i):[n,e]},i.padding=function(t){return arguments.length?(r="function"==typeof t?t:kl(+t),i):r},i},t.packSiblings=function(t){return Nl(t),t},t.packEnclose=pl,t.partition=function(){var t=1,n=1,e=0,r=!1;function i(i){var o=i.height+1;return i.x0=i.y0=e,i.x1=t,i.y1=n/o,i.eachBefore(function(t,n){return function(r){r.children&&Dl(r,r.x0,t*(r.depth+1)/n,r.x1,t*(r.depth+2)/n);var i=r.x0,o=r.y0,a=r.x1-e,u=r.y1-e;a<i&&(i=a=(i+a)/2),u<o&&(o=u=(o+u)/2),r.x0=i,r.y0=o,r.x1=a,r.y1=u}}(n,o)),r&&i.eachBefore(Ll),i}return i.round=function(t){return arguments.length?(r=!!t,i):r},i.size=function(e){return arguments.length?(t=+e[0],n=+e[1],i):[t,n]},i.padding=function(t){return arguments.length?(e=+t,i):e},i},t.stratify=function(){var t=Yl,n=Bl;function e(e){var r,i,o,a,u,f,c,s=e.length,l=new Array(s),h={};for(i=0;i<s;++i)r=e[i],u=l[i]=new hl(r),null!=(f=t(r,i,e))&&(f+="")&&(h[c=Ul+(u.id=f)]=c in h?Ol:u);for(i=0;i<s;++i)if(u=l[i],null!=(f=n(e[i],i,e))&&(f+="")){if(!(a=h[Ul+f]))throw new Error("missing: "+f);if(a===Ol)throw new Error("ambiguous: "+f);a.children?a.children.push(u):a.children=[u],u.parent=a}else{if(o)throw new Error("multiple roots");o=u}if(!o)throw new Error("no root");if(o.parent=ql,o.eachBefore(function(t){t.depth=t.parent.depth+1,--s}).eachBefore(ll),o.parent=null,s>0)throw new Error("cycle");return o}return e.id=function(n){return arguments.length?(t=Sl(n),e):t},e.parentId=function(t){return arguments.length?(n=Sl(t),e):n},e},t.tree=function(){var t=Fl,n=1,e=1,r=null;function i(i){var f=function(t){for(var n,e,r,i,o,a=new Gl(t,0),u=[a];n=u.pop();)if(r=n._.children)for(n.children=new Array(o=r.length),i=o-1;i>=0;--i)u.push(e=n.children[i]=new Gl(r[i],i)),e.parent=n;return(a.parent=new Gl(null,0)).children=[a],a}(i);if(f.eachAfter(o),f.parent.m=-f.z,f.eachBefore(a),r)i.eachBefore(u);else{var c=i,s=i,l=i;i.eachBefore(function(t){t.x<c.x&&(c=t),t.x>s.x&&(s=t),t.depth>l.depth&&(l=t)});var h=c===s?1:t(c,s)/2,d=h-c.x,p=n/(s.x+h+d),v=e/(l.depth||1);i.eachBefore(function(t){t.x=(t.x+d)*p,t.y=t.depth*v})}return i}function o(n){var e=n.children,r=n.parent.children,i=n.i?r[n.i-1]:null;if(e){!function(t){for(var n,e=0,r=0,i=t.children,o=i.length;--o>=0;)(n=i[o]).z+=e,n.m+=e,e+=n.s+(r+=n.c)}(n);var o=(e[0].z+e[e.length-1].z)/2;i?(n.z=i.z+t(n._,i._),n.m=n.z-o):n.z=o}else i&&(n.z=i.z+t(n._,i._));n.parent.A=function(n,e,r){if(e){for(var i,o=n,a=n,u=e,f=o.parent.children[0],c=o.m,s=a.m,l=u.m,h=f.m;u=Hl(u),o=Il(o),u&&o;)f=Il(f),(a=Hl(a)).a=n,(i=u.z+l-o.z-c+t(u._,o._))>0&&(jl(Xl(u,n,r),n,i),c+=i,s+=i),l+=u.m,c+=o.m,h+=f.m,s+=a.m;u&&!Hl(a)&&(a.t=u,a.m+=l-s),o&&!Il(f)&&(f.t=o,f.m+=c-h,r=n)}return r}(n,i,n.parent.A||r[0])}function a(t){t._.x=t.z+t.parent.m,t.m+=t.parent.m}function u(t){t.x*=n,t.y=t.depth*e}return i.separation=function(n){return arguments.length?(t=n,i):t},i.size=function(t){return arguments.length?(r=!1,n=+t[0],e=+t[1],i):r?null:[n,e]},i.nodeSize=function(t){return arguments.length?(r=!0,n=+t[0],e=+t[1],i):r?[n,e]:null},i},t.treemap=function(){var t=Zl,n=!1,e=1,r=1,i=[0],o=El,a=El,u=El,f=El,c=El;function s(t){return t.x0=t.y0=0,t.x1=e,t.y1=r,t.eachBefore(l),i=[0],n&&t.eachBefore(Ll),t}function l(n){var e=i[n.depth],r=n.x0+e,s=n.y0+e,l=n.x1-e,h=n.y1-e;l<r&&(r=l=(r+l)/2),h<s&&(s=h=(s+h)/2),n.x0=r,n.y0=s,n.x1=l,n.y1=h,n.children&&(e=i[n.depth+1]=o(n)/2,r+=c(n)-e,s+=a(n)-e,(l-=u(n)-e)<r&&(r=l=(r+l)/2),(h-=f(n)-e)<s&&(s=h=(s+h)/2),t(n,r,s,l,h))}return s.round=function(t){return arguments.length?(n=!!t,s):n},s.size=function(t){return arguments.length?(e=+t[0],r=+t[1],s):[e,r]},s.tile=function(n){return arguments.length?(t=Sl(n),s):t},s.padding=function(t){return arguments.length?s.paddingInner(t).paddingOuter(t):s.paddingInner()},s.paddingInner=function(t){return arguments.length?(o="function"==typeof t?t:kl(+t),s):o},s.paddingOuter=function(t){return arguments.length?s.paddingTop(t).paddingRight(t).paddingBottom(t).paddingLeft(t):s.paddingTop()},s.paddingTop=function(t){return arguments.length?(a="function"==typeof t?t:kl(+t),s):a},s.paddingRight=function(t){return arguments.length?(u="function"==typeof t?t:kl(+t),s):u},s.paddingBottom=function(t){return arguments.length?(f="function"==typeof t?t:kl(+t),s):f},s.paddingLeft=function(t){return arguments.length?(c="function"==typeof t?t:kl(+t),s):c},s},t.treemapBinary=function(t,n,e,r,i){var o,a,u=t.children,f=u.length,c=new Array(f+1);for(c[0]=a=o=0;o<f;++o)c[o+1]=a+=u[o].value;!function t(n,e,r,i,o,a,f){if(n>=e-1){var s=u[n];return s.x0=i,s.y0=o,s.x1=a,void(s.y1=f)}for(var l=c[n],h=r/2+l,d=n+1,p=e-1;d<p;){var v=d+p>>>1;c[v]<h?d=v+1:p=v}h-c[d-1]<c[d]-h&&n+1<d&&--d;var g=c[d]-l,y=r-g;if(a-i>f-o){var _=(i*y+a*g)/r;t(n,d,g,i,o,_,f),t(d,e,y,_,o,a,f)}else{var b=(o*y+f*g)/r;t(n,d,g,i,o,a,b),t(d,e,y,i,b,a,f)}}(0,f,t.value,n,e,r,i)},t.treemapDice=Dl,t.treemapSlice=Vl,t.treemapSliceDice=function(t,n,e,r,i){(1&t.depth?Vl:Dl)(t,n,e,r,i)},t.treemapSquarify=Zl,t.treemapResquarify=Ql,t.interpolate=me,t.interpolateArray=de,t.interpolateBasis=ee,t.interpolateBasisClosed=re,t.interpolateDate=pe,t.interpolateDiscrete=function(t){var n=t.length;return function(e){return t[Math.max(0,Math.min(n-1,Math.floor(e*n)))]}},t.interpolateHue=function(t,n){var e=ae(+t,+n);return function(t){var n=e(t);return n-360*Math.floor(n/360)}},t.interpolateNumber=ve,t.interpolateObject=ge,t.interpolateRound=xe,t.interpolateString=be,t.interpolateTransformCss=Ce,t.interpolateTransformSvg=Pe,t.interpolateZoom=qe,t.interpolateRgb=ce,t.interpolateRgbBasis=le,t.interpolateRgbBasisClosed=he,t.interpolateHsl=Ye,t.interpolateHslLong=Be,t.interpolateLab=function(t,n){var e=fe((t=Un(t)).l,(n=Un(n)).l),r=fe(t.a,n.a),i=fe(t.b,n.b),o=fe(t.opacity,n.opacity);return function(n){return t.l=e(n),t.a=r(n),t.b=i(n),t.opacity=o(n),t+""}},t.interpolateHcl=Ie,t.interpolateHclLong=He,t.interpolateCubehelix=Xe,t.interpolateCubehelixLong=Ge,t.piecewise=function(t,n){for(var e=0,r=n.length-1,i=n[0],o=new Array(r<0?0:r);e<r;)o[e]=t(i,i=n[++e]);return function(t){var n=Math.max(0,Math.min(r-1,Math.floor(t*=r)));return o[n](t-n)}},t.quantize=function(t,n){for(var e=new Array(n),r=0;r<n;++r)e[r]=t(r/(n-1));return e},t.path=Gi,t.polygonArea=function(t){for(var n,e=-1,r=t.length,i=t[r-1],o=0;++e<r;)n=i,i=t[e],o+=n[1]*i[0]-n[0]*i[1];return o/2},t.polygonCentroid=function(t){for(var n,e,r=-1,i=t.length,o=0,a=0,u=t[i-1],f=0;++r<i;)n=u,u=t[r],f+=e=n[0]*u[1]-u[0]*n[1],o+=(n[0]+u[0])*e,a+=(n[1]+u[1])*e;return[o/(f*=3),a/f]},t.polygonHull=function(t){if((e=t.length)<3)return null;var n,e,r=new Array(e),i=new Array(e);for(n=0;n<e;++n)r[n]=[+t[n][0],+t[n][1],n];for(r.sort(Jl),n=0;n<e;++n)i[n]=[r[n][0],-r[n][1]];var o=Kl(r),a=Kl(i),u=a[0]===o[0],f=a[a.length-1]===o[o.length-1],c=[];for(n=o.length-1;n>=0;--n)c.push(t[r[o[n]][2]]);for(n=+u;n<a.length-f;++n)c.push(t[r[a[n]][2]]);return c},t.polygonContains=function(t,n){for(var e,r,i=t.length,o=t[i-1],a=n[0],u=n[1],f=o[0],c=o[1],s=!1,l=0;l<i;++l)e=(o=t[l])[0],(r=o[1])>u!=c>u&&a<(f-e)*(u-r)/(c-r)+e&&(s=!s),f=e,c=r;return s},t.polygonLength=function(t){for(var n,e,r=-1,i=t.length,o=t[i-1],a=o[0],u=o[1],f=0;++r<i;)n=a,e=u,n-=a=(o=t[r])[0],e-=u=o[1],f+=Math.sqrt(n*n+e*e);return f},t.quadtree=ra,t.randomUniform=nh,t.randomNormal=eh,t.randomLogNormal=rh,t.randomBates=oh,t.randomIrwinHall=ih,t.randomExponential=ah,t.scaleBand=hh,t.scalePoint=function(){return function t(n){var e=n.copy;return n.padding=n.paddingOuter,delete n.paddingInner,delete n.paddingOuter,n.copy=function(){return t(e())},n}(hh().paddingInner(1))},t.scaleIdentity=function t(){var n=[0,1];function e(t){return+t}return e.invert=e,e.domain=e.range=function(t){return arguments.length?(n=fh.call(t,ph),e):n.slice()},e.copy=function(){return t().domain(n)},xh(e)},t.scaleLinear=function t(){var n=mh(gh,ve);return n.copy=function(){return bh(n,t())},xh(n)},t.scaleLog=function n(){var e=mh(Mh,Ah).domain([1,10]),r=e.domain,i=10,o=Sh(10),a=Nh(10);function u(){return o=Sh(i),a=Nh(i),r()[0]<0&&(o=Eh(o),a=Eh(a)),e}return e.base=function(t){return arguments.length?(i=+t,u()):i},e.domain=function(t){return arguments.length?(r(t),u()):r()},e.ticks=function(t){var n,e=r(),u=e[0],f=e[e.length-1];(n=f<u)&&(h=u,u=f,f=h);var c,s,l,h=o(u),d=o(f),p=null==t?10:+t,v=[];if(!(i%1)&&d-h<p){if(h=Math.round(h)-1,d=Math.round(d)+1,u>0){for(;h<d;++h)for(s=1,c=a(h);s<i;++s)if(!((l=c*s)<u)){if(l>f)break;v.push(l)}}else for(;h<d;++h)for(s=i-1,c=a(h);s>=1;--s)if(!((l=c*s)<u)){if(l>f)break;v.push(l)}}else v=m(h,d,Math.min(d-h,p)).map(a);return n?v.reverse():v},e.tickFormat=function(n,r){if(null==r&&(r=10===i?".0e":","),"function"!=typeof r&&(r=t.format(r)),n===1/0)return r;null==n&&(n=10);var u=Math.max(1,i*n/e.ticks().length);return function(t){var n=t/a(Math.round(o(t)));return n*i<i-.5&&(n*=i),n<=u?r(t):""}},e.nice=function(){return r(wh(r(),{floor:function(t){return a(Math.floor(o(t)))},ceil:function(t){return a(Math.ceil(o(t)))}}))},e.copy=function(){return bh(e,n().base(i))},e},t.scaleOrdinal=lh,t.scaleImplicit=sh,t.scalePow=Ch,t.scaleSqrt=function(){return Ch().exponent(.5)},t.scaleQuantile=function t(){var e=[],r=[],o=[];function a(){var t=0,n=Math.max(1,r.length);for(o=new Array(n-1);++t<n;)o[t-1]=A(e,t/n);return u}function u(t){if(!isNaN(t=+t))return r[i(o,t)]}return u.invertExtent=function(t){var n=r.indexOf(t);return n<0?[NaN,NaN]:[n>0?o[n-1]:e[0],n<o.length?o[n]:e[e.length-1]]},u.domain=function(t){if(!arguments.length)return e.slice();e=[];for(var r,i=0,o=t.length;i<o;++i)null==(r=t[i])||isNaN(r=+r)||e.push(r);return e.sort(n),a()},u.range=function(t){return arguments.length?(r=ch.call(t),a()):r.slice()},u.quantiles=function(){return o.slice()},u.copy=function(){return t().domain(e).range(r)},u},t.scaleQuantize=function t(){var n=0,e=1,r=1,o=[.5],a=[0,1];function u(t){if(t<=t)return a[i(o,t,0,r)]}function f(){var t=-1;for(o=new Array(r);++t<r;)o[t]=((t+1)*e-(t-r)*n)/(r+1);return u}return u.domain=function(t){return arguments.length?(n=+t[0],e=+t[1],f()):[n,e]},u.range=function(t){return arguments.length?(r=(a=ch.call(t)).length-1,f()):a.slice()},u.invertExtent=function(t){var i=a.indexOf(t);return i<0?[NaN,NaN]:i<1?[n,o[0]]:i>=r?[o[r-1],e]:[o[i-1],o[i]]},u.copy=function(){return t().domain([n,e]).range(a)},xh(u)},t.scaleThreshold=function t(){var n=[.5],e=[0,1],r=1;function o(t){if(t<=t)return e[i(n,t,0,r)]}return o.domain=function(t){return arguments.length?(n=ch.call(t),r=Math.min(n.length,e.length-1),o):n.slice()},o.range=function(t){return arguments.length?(e=ch.call(t),r=Math.min(n.length,e.length-1),o):e.slice()},o.invertExtent=function(t){var r=e.indexOf(t);return[n[r-1],n[r]]},o.copy=function(){return t().domain(n).range(e)},o},t.scaleTime=function(){return cv(cd,ud,Vh,jh,Ih,Bh,Oh,Lh,t.timeFormat).domain([new Date(2e3,0,1),new Date(2e3,0,2)])},t.scaleUtc=function(){return cv(Ld,zd,_d,vd,dd,ld,Oh,Lh,t.utcFormat).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)])},t.scaleSequential=function t(n){var e=0,r=1,i=1,o=!1;function a(t){var r=(t-e)*i;return n(o?Math.max(0,Math.min(1,r)):r)}return a.domain=function(t){return arguments.length?(e=+t[0],r=+t[1],i=e===r?0:1/(r-e),a):[e,r]},a.clamp=function(t){return arguments.length?(o=!!t,a):o},a.interpolator=function(t){return arguments.length?(n=t,a):n},a.copy=function(){return t(n).domain([e,r]).clamp(o)},xh(a)},t.scaleDiverging=function t(n){var e=0,r=.5,i=1,o=1,a=1,u=!1;function f(t){var e=.5+((t=+t)-r)*(t<r?o:a);return n(u?Math.max(0,Math.min(1,e)):e)}return f.domain=function(t){return arguments.length?(e=+t[0],r=+t[1],i=+t[2],o=e===r?0:.5/(r-e),a=r===i?0:.5/(i-r),f):[e,r,i]},f.clamp=function(t){return arguments.length?(u=!!t,f):u},f.interpolator=function(t){return arguments.length?(n=t,f):n},f.copy=function(){return t(n).domain([e,r,i]).clamp(u)},xh(f)},t.schemeCategory10=lv,t.schemeAccent=hv,t.schemeDark2=dv,t.schemePaired=pv,t.schemePastel1=vv,t.schemePastel2=gv,t.schemeSet1=yv,t.schemeSet2=_v,t.schemeSet3=bv,t.interpolateBrBG=wv,t.schemeBrBG=xv,t.interpolatePRGn=Av,t.schemePRGn=Mv,t.interpolatePiYG=Nv,t.schemePiYG=Tv,t.interpolatePuOr=Ev,t.schemePuOr=Sv,t.interpolateRdBu=Cv,t.schemeRdBu=kv,t.interpolateRdGy=zv,t.schemeRdGy=Pv,t.interpolateRdYlBu=Lv,t.schemeRdYlBu=Rv,t.interpolateRdYlGn=Uv,t.schemeRdYlGn=Dv,t.interpolateSpectral=Ov,t.schemeSpectral=qv,t.interpolateBuGn=Bv,t.schemeBuGn=Yv,t.interpolateBuPu=Iv,t.schemeBuPu=Fv,t.interpolateGnBu=jv,t.schemeGnBu=Hv,t.interpolateOrRd=Gv,t.schemeOrRd=Xv,t.interpolatePuBuGn=$v,t.schemePuBuGn=Vv,t.interpolatePuBu=Zv,t.schemePuBu=Wv,t.interpolatePuRd=Jv,t.schemePuRd=Qv,t.interpolateRdPu=tg,t.schemeRdPu=Kv,t.interpolateYlGnBu=eg,t.schemeYlGnBu=ng,t.interpolateYlGn=ig,t.schemeYlGn=rg,t.interpolateYlOrBr=ag,t.schemeYlOrBr=og,t.interpolateYlOrRd=fg,t.schemeYlOrRd=ug,t.interpolateBlues=sg,t.schemeBlues=cg,t.interpolateGreens=hg,t.schemeGreens=lg,t.interpolateGreys=pg,t.schemeGreys=dg,t.interpolatePurples=gg,t.schemePurples=vg,t.interpolateReds=_g,t.schemeReds=yg,t.interpolateOranges=mg,t.schemeOranges=bg,t.interpolateCubehelixDefault=xg,t.interpolateRainbow=function(t){(t<0||t>1)&&(t-=Math.floor(t));var n=Math.abs(t-.5);return Ag.h=360*t-100,Ag.s=1.5-1.5*n,Ag.l=.8-.9*n,Ag+""},t.interpolateWarm=wg,t.interpolateCool=Mg,t.interpolateSinebow=function(t){var n;return t=(.5-t)*Math.PI,Tg.r=255*(n=Math.sin(t))*n,Tg.g=255*(n=Math.sin(t+Ng))*n,Tg.b=255*(n=Math.sin(t+Sg))*n,Tg+""},t.interpolateViridis=kg,t.interpolateMagma=Cg,t.interpolateInferno=Pg,t.interpolatePlasma=zg,t.create=function(t){return Dt(W(t).call(document.documentElement))},t.creator=W,t.local=qt,t.matcher=rt,t.mouse=Ft,t.namespace=$,t.namespaces=V,t.clientPoint=Bt,t.select=Dt,t.selectAll=function(t){return"string"==typeof t?new Rt([document.querySelectorAll(t)],[document.documentElement]):new Rt([null==t?[]:t],zt)},t.selection=Lt,t.selector=Q,t.selectorAll=K,t.style=lt,t.touch=It,t.touches=function(t,n){null==n&&(n=Yt().touches);for(var e=0,r=n?n.length:0,i=new Array(r);e<r;++e)i[e]=Bt(t,n[e]);return i},t.window=st,t.customEvent=Ct,t.arc=function(){var t=Gg,n=Vg,e=Rg(0),r=null,i=$g,o=Wg,a=Zg,u=null;function f(){var f,c,s,l=+t.apply(this,arguments),h=+n.apply(this,arguments),d=i.apply(this,arguments)-Hg,p=o.apply(this,arguments)-Hg,v=Lg(p-d),g=p>d;if(u||(u=f=Gi()),h<l&&(c=h,h=l,l=c),h>Fg)if(v>jg-Fg)u.moveTo(h*Ug(d),h*Yg(d)),u.arc(0,0,h,d,p,!g),l>Fg&&(u.moveTo(l*Ug(p),l*Yg(p)),u.arc(0,0,l,p,d,g));else{var y,_,b=d,m=p,x=d,w=p,M=v,A=v,T=a.apply(this,arguments)/2,N=T>Fg&&(r?+r.apply(this,arguments):Bg(l*l+h*h)),S=Og(Lg(h-l)/2,+e.apply(this,arguments)),E=S,k=S;if(N>Fg){var C=Xg(N/l*Yg(T)),P=Xg(N/h*Yg(T));(M-=2*C)>Fg?(x+=C*=g?1:-1,w-=C):(M=0,x=w=(d+p)/2),(A-=2*P)>Fg?(b+=P*=g?1:-1,m-=P):(A=0,b=m=(d+p)/2)}var z=h*Ug(b),R=h*Yg(b),L=l*Ug(w),D=l*Yg(w);if(S>Fg){var U=h*Ug(m),q=h*Yg(m),O=l*Ug(x),Y=l*Yg(x);if(v<Ig){var B=M>Fg?function(t,n,e,r,i,o,a,u){var f=e-t,c=r-n,s=a-i,l=u-o,h=(s*(n-o)-l*(t-i))/(l*f-s*c);return[t+h*f,n+h*c]}(z,R,O,Y,U,q,L,D):[L,D],F=z-B[0],I=R-B[1],H=U-B[0],j=q-B[1],X=1/Yg(((s=(F*H+I*j)/(Bg(F*F+I*I)*Bg(H*H+j*j)))>1?0:s<-1?Ig:Math.acos(s))/2),G=Bg(B[0]*B[0]+B[1]*B[1]);E=Og(S,(l-G)/(X-1)),k=Og(S,(h-G)/(X+1))}}A>Fg?k>Fg?(y=Qg(O,Y,z,R,h,k,g),_=Qg(U,q,L,D,h,k,g),u.moveTo(y.cx+y.x01,y.cy+y.y01),k<S?u.arc(y.cx,y.cy,k,Dg(y.y01,y.x01),Dg(_.y01,_.x01),!g):(u.arc(y.cx,y.cy,k,Dg(y.y01,y.x01),Dg(y.y11,y.x11),!g),u.arc(0,0,h,Dg(y.cy+y.y11,y.cx+y.x11),Dg(_.cy+_.y11,_.cx+_.x11),!g),u.arc(_.cx,_.cy,k,Dg(_.y11,_.x11),Dg(_.y01,_.x01),!g))):(u.moveTo(z,R),u.arc(0,0,h,b,m,!g)):u.moveTo(z,R),l>Fg&&M>Fg?E>Fg?(y=Qg(L,D,U,q,l,-E,g),_=Qg(z,R,O,Y,l,-E,g),u.lineTo(y.cx+y.x01,y.cy+y.y01),E<S?u.arc(y.cx,y.cy,E,Dg(y.y01,y.x01),Dg(_.y01,_.x01),!g):(u.arc(y.cx,y.cy,E,Dg(y.y01,y.x01),Dg(y.y11,y.x11),!g),u.arc(0,0,l,Dg(y.cy+y.y11,y.cx+y.x11),Dg(_.cy+_.y11,_.cx+_.x11),g),u.arc(_.cx,_.cy,E,Dg(_.y11,_.x11),Dg(_.y01,_.x01),!g))):u.arc(0,0,l,w,x,g):u.lineTo(L,D)}else u.moveTo(0,0);if(u.closePath(),f)return u=null,f+""||null}return f.centroid=function(){var e=(+t.apply(this,arguments)+ +n.apply(this,arguments))/2,r=(+i.apply(this,arguments)+ +o.apply(this,arguments))/2-Ig/2;return[Ug(r)*e,Yg(r)*e]},f.innerRadius=function(n){return arguments.length?(t="function"==typeof n?n:Rg(+n),f):t},f.outerRadius=function(t){return arguments.length?(n="function"==typeof t?t:Rg(+t),f):n},f.cornerRadius=function(t){return arguments.length?(e="function"==typeof t?t:Rg(+t),f):e},f.padRadius=function(t){return arguments.length?(r=null==t?null:"function"==typeof t?t:Rg(+t),f):r},f.startAngle=function(t){return arguments.length?(i="function"==typeof t?t:Rg(+t),f):i},f.endAngle=function(t){return arguments.length?(o="function"==typeof t?t:Rg(+t),f):o},f.padAngle=function(t){return arguments.length?(a="function"==typeof t?t:Rg(+t),f):a},f.context=function(t){return arguments.length?(u=null==t?null:t,f):u},f},t.area=ry,t.line=ey,t.pie=function(){var t=oy,n=iy,e=null,r=Rg(0),i=Rg(jg),o=Rg(0);function a(a){var u,f,c,s,l,h=a.length,d=0,p=new Array(h),v=new Array(h),g=+r.apply(this,arguments),y=Math.min(jg,Math.max(-jg,i.apply(this,arguments)-g)),_=Math.min(Math.abs(y)/h,o.apply(this,arguments)),b=_*(y<0?-1:1);for(u=0;u<h;++u)(l=v[p[u]=u]=+t(a[u],u,a))>0&&(d+=l);for(null!=n?p.sort(function(t,e){return n(v[t],v[e])}):null!=e&&p.sort(function(t,n){return e(a[t],a[n])}),u=0,c=d?(y-h*b)/d:0;u<h;++u,g=s)f=p[u],s=g+((l=v[f])>0?l*c:0)+b,v[f]={data:a[f],index:u,value:l,startAngle:g,endAngle:s,padAngle:_};return v}return a.value=function(n){return arguments.length?(t="function"==typeof n?n:Rg(+n),a):t},a.sortValues=function(t){return arguments.length?(n=t,e=null,a):n},a.sort=function(t){return arguments.length?(e=t,n=null,a):e},a.startAngle=function(t){return arguments.length?(r="function"==typeof t?t:Rg(+t),a):r},a.endAngle=function(t){return arguments.length?(i="function"==typeof t?t:Rg(+t),a):i},a.padAngle=function(t){return arguments.length?(o="function"==typeof t?t:Rg(+t),a):o},a},t.areaRadial=ly,t.radialArea=ly,t.lineRadial=sy,t.radialLine=sy,t.pointRadial=hy,t.linkHorizontal=function(){return gy(yy)},t.linkVertical=function(){return gy(_y)},t.linkRadial=function(){var t=gy(by);return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t},t.symbol=function(){var t=Rg(my),n=Rg(64),e=null;function r(){var r;if(e||(e=r=Gi()),t.apply(this,arguments).draw(e,+n.apply(this,arguments)),r)return e=null,r+""||null}return r.type=function(n){return arguments.length?(t="function"==typeof n?n:Rg(n),r):t},r.size=function(t){return arguments.length?(n="function"==typeof t?t:Rg(+t),r):n},r.context=function(t){return arguments.length?(e=null==t?null:t,r):e},r},t.symbols=Uy,t.symbolCircle=my,t.symbolCross=xy,t.symbolDiamond=Ay,t.symbolSquare=ky,t.symbolStar=Ey,t.symbolTriangle=Py,t.symbolWye=Dy,t.curveBasisClosed=function(t){return new By(t)},t.curveBasisOpen=function(t){return new Fy(t)},t.curveBasis=function(t){return new Yy(t)},t.curveBundle=Hy,t.curveCardinalClosed=$y,t.curveCardinalOpen=Zy,t.curveCardinal=Gy,t.curveCatmullRomClosed=n_,t.curveCatmullRomOpen=r_,t.curveCatmullRom=Ky,t.curveLinearClosed=function(t){return new i_(t)},t.curveLinear=Kg,t.curveMonotoneX=function(t){return new c_(t)},t.curveMonotoneY=function(t){return new s_(t)},t.curveNatural=function(t){return new h_(t)},t.curveStep=function(t){return new p_(t,.5)},t.curveStepAfter=function(t){return new p_(t,1)},t.curveStepBefore=function(t){return new p_(t,0)},t.stack=function(){var t=Rg([]),n=g_,e=v_,r=y_;function i(i){var o,a,u=t.apply(this,arguments),f=i.length,c=u.length,s=new Array(c);for(o=0;o<c;++o){for(var l,h=u[o],d=s[o]=new Array(f),p=0;p<f;++p)d[p]=l=[0,+r(i[p],h,p,i)],l.data=i[p];d.key=h}for(o=0,a=n(s);o<c;++o)s[a[o]].index=o;return e(s,a),s}return i.keys=function(n){return arguments.length?(t="function"==typeof n?n:Rg(dy.call(n)),i):t},i.value=function(t){return arguments.length?(r="function"==typeof t?t:Rg(+t),i):r},i.order=function(t){return arguments.length?(n=null==t?g_:"function"==typeof t?t:Rg(dy.call(t)),i):n},i.offset=function(t){return arguments.length?(e=null==t?v_:t,i):e},i},t.stackOffsetExpand=function(t,n){if((r=t.length)>0){for(var e,r,i,o=0,a=t[0].length;o<a;++o){for(i=e=0;e<r;++e)i+=t[e][o][1]||0;if(i)for(e=0;e<r;++e)t[e][o][1]/=i}v_(t,n)}},t.stackOffsetDiverging=function(t,n){if((u=t.length)>1)for(var e,r,i,o,a,u,f=0,c=t[n[0]].length;f<c;++f)for(o=a=0,e=0;e<u;++e)(i=(r=t[n[e]][f])[1]-r[0])>=0?(r[0]=o,r[1]=o+=i):i<0?(r[1]=a,r[0]=a+=i):r[0]=o},t.stackOffsetNone=v_,t.stackOffsetSilhouette=function(t,n){if((e=t.length)>0){for(var e,r=0,i=t[n[0]],o=i.length;r<o;++r){for(var a=0,u=0;a<e;++a)u+=t[a][r][1]||0;i[r][1]+=i[r][0]=-u/2}v_(t,n)}},t.stackOffsetWiggle=function(t,n){if((i=t.length)>0&&(r=(e=t[n[0]]).length)>0){for(var e,r,i,o=0,a=1;a<r;++a){for(var u=0,f=0,c=0;u<i;++u){for(var s=t[n[u]],l=s[a][1]||0,h=(l-(s[a-1][1]||0))/2,d=0;d<u;++d){var p=t[n[d]];h+=(p[a][1]||0)-(p[a-1][1]||0)}f+=l,c+=h*l}e[a-1][1]+=e[a-1][0]=o,f&&(o-=c/f)}e[a-1][1]+=e[a-1][0]=o,v_(t,n)}},t.stackOrderAscending=__,t.stackOrderDescending=function(t){return __(t).reverse()},t.stackOrderInsideOut=function(t){var n,e,r=t.length,i=t.map(b_),o=g_(t).sort(function(t,n){return i[n]-i[t]}),a=0,u=0,f=[],c=[];for(n=0;n<r;++n)e=o[n],a<u?(a+=i[e],f.push(e)):(u+=i[e],c.push(e));return c.reverse().concat(f)},t.stackOrderNone=g_,t.stackOrderReverse=function(t){return g_(t).reverse()},t.timeInterval=Rh,t.timeMillisecond=Lh,t.timeMilliseconds=Dh,t.utcMillisecond=Lh,t.utcMilliseconds=Dh,t.timeSecond=Oh,t.timeSeconds=Yh,t.utcSecond=Oh,t.utcSeconds=Yh,t.timeMinute=Bh,t.timeMinutes=Fh,t.timeHour=Ih,t.timeHours=Hh,t.timeDay=jh,t.timeDays=Xh,t.timeWeek=Vh,t.timeWeeks=td,t.timeSunday=Vh,t.timeSundays=td,t.timeMonday=$h,t.timeMondays=nd,t.timeTuesday=Wh,t.timeTuesdays=ed,t.timeWednesday=Zh,t.timeWednesdays=rd,t.timeThursday=Qh,t.timeThursdays=id,t.timeFriday=Jh,t.timeFridays=od,t.timeSaturday=Kh,t.timeSaturdays=ad,t.timeMonth=ud,t.timeMonths=fd,t.timeYear=cd,t.timeYears=sd,t.utcMinute=ld,t.utcMinutes=hd,t.utcHour=dd,t.utcHours=pd,t.utcDay=vd,t.utcDays=gd,t.utcWeek=_d,t.utcWeeks=Td,t.utcSunday=_d,t.utcSundays=Td,t.utcMonday=bd,t.utcMondays=Nd,t.utcTuesday=md,t.utcTuesdays=Sd,t.utcWednesday=xd,t.utcWednesdays=Ed,t.utcThursday=wd,t.utcThursdays=kd,t.utcFriday=Md,t.utcFridays=Cd,t.utcSaturday=Ad,t.utcSaturdays=Pd,t.utcMonth=zd,t.utcMonths=Rd,t.utcYear=Ld,t.utcYears=Dd,t.timeFormatDefaultLocale=Qp,t.timeFormatLocale=Yd,t.isoFormat=Jp,t.isoParse=Kp,t.now=ir,t.timer=ur,t.timerFlush=fr,t.timeout=hr,t.interval=function(t,n,e){var r=new ar,i=n;return null==n?(r.restart(t,n,e),r):(n=+n,e=null==e?ir():+e,r.restart(function o(a){a+=i,r.restart(o,i+=n,e),t(a)},n,e),r)},t.transition=zr,t.active=function(t,n){var e,r,i=t.__transition;if(i)for(r in n=null==n?null:n+"",i)if((e=i[r]).state>gr&&e.name===n)return new Pr([[t]],li,n,+r);return null},t.interrupt=Nr,t.voronoi=function(){var t=x_,n=w_,e=null;function r(r){return new eb(r.map(function(e,i){var o=[Math.round(t(e,i,r)/K_)*K_,Math.round(n(e,i,r)/K_)*K_];return o.index=i,o.data=e,o}),e)}return r.polygons=function(t){return r(t).polygons()},r.links=function(t){return r(t).links()},r.triangles=function(t){return r(t).triangles()},r.x=function(n){return arguments.length?(t="function"==typeof n?n:m_(+n),r):t},r.y=function(t){return arguments.length?(n="function"==typeof t?t:m_(+t),r):n},r.extent=function(t){return arguments.length?(e=null==t?null:[[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]],r):e&&[[e[0][0],e[0][1]],[e[1][0],e[1][1]]]},r.size=function(t){return arguments.length?(e=null==t?null:[[0,0],[+t[0],+t[1]]],r):e&&[e[1][0]-e[0][0],e[1][1]-e[0][1]]},r},t.zoom=function(){var n,e,r=sb,i=lb,o=vb,a=db,u=pb,f=[0,1/0],c=[[-1/0,-1/0],[1/0,1/0]],s=250,l=qe,h=[],d=I("start","zoom","end"),p=500,v=150,g=0;function y(t){t.property("__zoom",hb).on("wheel.zoom",A).on("mousedown.zoom",T).on("dblclick.zoom",N).filter(u).on("touchstart.zoom",S).on("touchmove.zoom",E).on("touchend.zoom touchcancel.zoom",k).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function _(t,n){return(n=Math.max(f[0],Math.min(f[1],n)))===t.k?t:new ob(n,t.x,t.y)}function b(t,n,e){var r=n[0]-e[0]*t.k,i=n[1]-e[1]*t.k;return r===t.x&&i===t.y?t:new ob(t.k,r,i)}function m(t){return[(+t[0][0]+ +t[1][0])/2,(+t[0][1]+ +t[1][1])/2]}function x(t,n,e){t.on("start.zoom",function(){w(this,arguments).start()}).on("interrupt.zoom end.zoom",function(){w(this,arguments).end()}).tween("zoom",function(){var t=arguments,r=w(this,t),o=i.apply(this,t),a=e||m(o),u=Math.max(o[1][0]-o[0][0],o[1][1]-o[0][1]),f=this.__zoom,c="function"==typeof n?n.apply(this,t):n,s=l(f.invert(a).concat(u/f.k),c.invert(a).concat(u/c.k));return function(t){if(1===t)t=c;else{var n=s(t),e=u/n[2];t=new ob(e,a[0]-n[0]*e,a[1]-n[1]*e)}r.zoom(null,t)}})}function w(t,n){for(var e,r=0,i=h.length;r<i;++r)if((e=h[r]).that===t)return e;return new M(t,n)}function M(t,n){this.that=t,this.args=n,this.index=-1,this.active=0,this.extent=i.apply(t,n)}function A(){if(r.apply(this,arguments)){var t=w(this,arguments),n=this.__zoom,e=Math.max(f[0],Math.min(f[1],n.k*Math.pow(2,a.apply(this,arguments)))),i=Ft(this);if(t.wheel)t.mouse[0][0]===i[0]&&t.mouse[0][1]===i[1]||(t.mouse[1]=n.invert(t.mouse[0]=i)),clearTimeout(t.wheel);else{if(n.k===e)return;t.mouse=[i,n.invert(i)],Nr(this),t.start()}cb(),t.wheel=setTimeout(function(){t.wheel=null,t.end()},v),t.zoom("mouse",o(b(_(n,e),t.mouse[0],t.mouse[1]),t.extent,c))}}function T(){if(!e&&r.apply(this,arguments)){var n=w(this,arguments),i=Dt(t.event.view).on("mousemove.zoom",function(){if(cb(),!n.moved){var e=t.event.clientX-u,r=t.event.clientY-f;n.moved=e*e+r*r>g}n.zoom("mouse",o(b(n.that.__zoom,n.mouse[0]=Ft(n.that),n.mouse[1]),n.extent,c))},!0).on("mouseup.zoom",function(){i.on("mousemove.zoom mouseup.zoom",null),Gt(t.event.view,n.moved),cb(),n.end()},!0),a=Ft(this),u=t.event.clientX,f=t.event.clientY;Xt(t.event.view),fb(),n.mouse=[a,this.__zoom.invert(a)],Nr(this),n.start()}}function N(){if(r.apply(this,arguments)){var n=this.__zoom,e=Ft(this),a=n.invert(e),u=n.k*(t.event.shiftKey?.5:2),f=o(b(_(n,u),e,a),i.apply(this,arguments),c);cb(),s>0?Dt(this).transition().duration(s).call(x,f,e):Dt(this).call(y.transform,f)}}function S(){if(r.apply(this,arguments)){var e,i,o,a,u=w(this,arguments),f=t.event.changedTouches,c=f.length;for(fb(),i=0;i<c;++i)a=[a=It(this,f,(o=f[i]).identifier),this.__zoom.invert(a),o.identifier],u.touch0?u.touch1||(u.touch1=a):(u.touch0=a,e=!0);if(n&&(n=clearTimeout(n),!u.touch1))return u.end(),void((a=Dt(this).on("dblclick.zoom"))&&a.apply(this,arguments));e&&(n=setTimeout(function(){n=null},p),Nr(this),u.start())}}function E(){var e,r,i,a,u=w(this,arguments),f=t.event.changedTouches,s=f.length;for(cb(),n&&(n=clearTimeout(n)),e=0;e<s;++e)i=It(this,f,(r=f[e]).identifier),u.touch0&&u.touch0[2]===r.identifier?u.touch0[0]=i:u.touch1&&u.touch1[2]===r.identifier&&(u.touch1[0]=i);if(r=u.that.__zoom,u.touch1){var l=u.touch0[0],h=u.touch0[1],d=u.touch1[0],p=u.touch1[1],v=(v=d[0]-l[0])*v+(v=d[1]-l[1])*v,g=(g=p[0]-h[0])*g+(g=p[1]-h[1])*g;r=_(r,Math.sqrt(v/g)),i=[(l[0]+d[0])/2,(l[1]+d[1])/2],a=[(h[0]+p[0])/2,(h[1]+p[1])/2]}else{if(!u.touch0)return;i=u.touch0[0],a=u.touch0[1]}u.zoom("touch",o(b(r,i,a),u.extent,c))}function k(){var n,r,i=w(this,arguments),o=t.event.changedTouches,a=o.length;for(fb(),e&&clearTimeout(e),e=setTimeout(function(){e=null},p),n=0;n<a;++n)r=o[n],i.touch0&&i.touch0[2]===r.identifier?delete i.touch0:i.touch1&&i.touch1[2]===r.identifier&&delete i.touch1;i.touch1&&!i.touch0&&(i.touch0=i.touch1,delete i.touch1),i.touch0?i.touch0[1]=this.__zoom.invert(i.touch0[0]):i.end()}return y.transform=function(t,n){var e=t.selection?t.selection():t;e.property("__zoom",hb),t!==e?x(t,n):e.interrupt().each(function(){w(this,arguments).start().zoom(null,"function"==typeof n?n.apply(this,arguments):n).end()})},y.scaleBy=function(t,n){y.scaleTo(t,function(){return this.__zoom.k*("function"==typeof n?n.apply(this,arguments):n)})},y.scaleTo=function(t,n){y.transform(t,function(){var t=i.apply(this,arguments),e=this.__zoom,r=m(t),a=e.invert(r),u="function"==typeof n?n.apply(this,arguments):n;return o(b(_(e,u),r,a),t,c)})},y.translateBy=function(t,n,e){y.transform(t,function(){return o(this.__zoom.translate("function"==typeof n?n.apply(this,arguments):n,"function"==typeof e?e.apply(this,arguments):e),i.apply(this,arguments),c)})},y.translateTo=function(t,n,e){y.transform(t,function(){var t=i.apply(this,arguments),r=this.__zoom,a=m(t);return o(ab.translate(a[0],a[1]).scale(r.k).translate("function"==typeof n?-n.apply(this,arguments):-n,"function"==typeof e?-e.apply(this,arguments):-e),t,c)})},M.prototype={start:function(){return 1==++this.active&&(this.index=h.push(this)-1,this.emit("start")),this},zoom:function(t,n){return this.mouse&&"mouse"!==t&&(this.mouse[1]=n.invert(this.mouse[0])),this.touch0&&"touch"!==t&&(this.touch0[1]=n.invert(this.touch0[0])),this.touch1&&"touch"!==t&&(this.touch1[1]=n.invert(this.touch1[0])),this.that.__zoom=n,this.emit("zoom"),this},end:function(){return 0==--this.active&&(h.splice(this.index,1),this.index=-1,this.emit("end")),this},emit:function(t){Ct(new ib(y,t,this.that.__zoom),d.apply,d,[t,this.that,this.args])}},y.wheelDelta=function(t){return arguments.length?(a="function"==typeof t?t:rb(+t),y):a},y.filter=function(t){return arguments.length?(r="function"==typeof t?t:rb(!!t),y):r},y.touchable=function(t){return arguments.length?(u="function"==typeof t?t:rb(!!t),y):u},y.extent=function(t){return arguments.length?(i="function"==typeof t?t:rb([[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]]),y):i},y.scaleExtent=function(t){return arguments.length?(f[0]=+t[0],f[1]=+t[1],y):[f[0],f[1]]},y.translateExtent=function(t){return arguments.length?(c[0][0]=+t[0][0],c[1][0]=+t[1][0],c[0][1]=+t[0][1],c[1][1]=+t[1][1],y):[[c[0][0],c[0][1]],[c[1][0],c[1][1]]]},y.constrain=function(t){return arguments.length?(o=t,y):o},y.duration=function(t){return arguments.length?(s=+t,y):s},y.interpolate=function(t){return arguments.length?(l=t,y):l},y.on=function(){var t=d.on.apply(d,arguments);return t===d?y:t},y.clickDistance=function(t){return arguments.length?(g=(t=+t)*t,y):Math.sqrt(g)},y},t.zoomTransform=ub,t.zoomIdentity=ab,Object.defineProperty(t,"__esModule",{value:!0})});

//# sourceURL=build://tf-color-scale/palettes.js
var pf;
(function(b){b.palettes={googleStandard:"#db4437 #ff7043 #f4b400 #0f9d58 #00796b #00acc1 #4285f4 #5c6bc0 #ab47bc".split(" "),googleCool:"#9e9d24 #0f9d58 #00796b #00acc1 #4285f4 #5c6bc0 #607d8b".split(" "),googleWarm:"#795548 #ab47bc #f06292 #c2185b #db4437 #ff7043 #f4b400".split(" "),googleColorBlindAssist:"#ff7043 #00ACC1 #AB47BC #2A56C6 #0b8043 #F7CB4D #c0ca33 #5e35b1 #A52714".split(" "),tensorboardColorBlindAssist:"#ff7043 #0077bb #cc3311 #33bbee #ee3377 #009988 #bbbbbb".split(" "),colorBlindAssist1:"#4477aa #44aaaa #aaaa44 #aa7744 #aa4455 #aa4488".split(" "),colorBlindAssist2:"#88ccee #44aa99 #117733 #999933 #ddcc77 #cc6677 #882255 #aa4499".split(" "),
colorBlindAssist3:"#332288 #6699cc #88ccee #44aa99 #117733 #999933 #ddcc77 #cc6677 #aa4466 #882255 #661100 #aa4499".split(" "),colorBlindAssist4:"#4477aa #66ccee #228833 #ccbb44 #ee6677 #aa3377 #bbbbbb".split(" "),colorBlindAssist5:"#FF6DB6 #920000 #924900 #DBD100 #24FF24 #006DDB #490092".split(" "),mldash:"#E47EAD #F4640D #FAA300 #F5E636 #00A077 #0077B8 #00B7ED".split(" ")};b.standard=b.palettes.tensorboardColorBlindAssist})(pf||(pf={}));

//# sourceURL=build://tf-color-scale/colorScale.js
(function(b){function d(h,k){function t(){l.setDomain(k())}const l=new f;h.addListener(t);t();return p=>l.getColor(p)}class f{constructor(h=b.standard){this.palette=h;this.identifiers=d3.map()}setDomain(h){this.identifiers=d3.map();h.forEach((k,t)=>{this.identifiers.set(k,this.palette[t%this.palette.length])})}getColor(h){if(!this.identifiers.has(h))throw Error(`String ${h} was not in the domain.`);return this.identifiers.get(h)}}b.ColorScale=f;b.runsColorScale=d(vc.runsStore,()=>vc.runsStore.getRuns());
b.experimentsColorScale=d(vc.experimentsStore,()=>vc.experimentsStore.getExperiments().map(({name:h})=>h))})(pf||(pf={}));

//# sourceURL=build://paper-icon-button/paper-icon-button.html.js
Polymer({is:"paper-icon-button",hostAttributes:{role:"button",tabindex:"0"},behaviors:[Polymer.PaperInkyFocusBehavior],properties:{src:{type:String},icon:{type:String},alt:{type:String,observer:"_altChanged"}},_altChanged:function(b,d){var f=this.getAttribute("aria-label");f&&d!=f||this.setAttribute("aria-label",b)}});

//# sourceURL=build://tf-dashboard-common/tf-multi-checkbox.js
(function(){Polymer({is:"tf-multi-checkbox",properties:{names:{type:Array,value:()=>[]},coloring:{type:Object,value:{getColor:()=>""}},regex:{type:String,notify:!0,value:""},_regex:{type:Object,computed:"_makeRegex(regex)"},namesMatchingRegex:{type:Array,computed:"computeNamesMatchingRegex(names.*, _regex)"},selectionState:{type:Object,notify:!0,value:()=>({})},outSelected:{type:Array,notify:!0,computed:"computeOutSelected(namesMatchingRegex.*, selectionState.*)"},maxNamesToEnableByDefault:{type:Number,
value:40},_debouncedRegexChange:{type:Object,value:function(){var b=_.debounce(d=>{this.regex=d},150,{leading:!1});return function(){var d=this.$$("#names-regex").value;""==d?this.async(()=>{this.regex=d},30):b(d)}}}},observers:["_setIsolatorIcon(selectionState, names)"],_makeRegex:function(b){try{return new RegExp(b)}catch(d){return null}},_setIsolatorIcon:function(){var b=this.selectionState,d=_.filter(_.values(b)).length;Array.prototype.slice.call(this.root.querySelectorAll(".isolator")).forEach(function(f){f.icon=
1===d&&b[f.name]?"radio-button-checked":"radio-button-unchecked"})},computeNamesMatchingRegex:function(){const b=this._regex;return b?this.names.filter(d=>b.test(d)):this.names},computeOutSelected:function(){var b=this.selectionState,d=this.namesMatchingRegex.length<=this.maxNamesToEnableByDefault;return this.namesMatchingRegex.filter(f=>null==b[f]?d:b[f])},synchronizeColors:function(){this._setIsolatorIcon();this.root.querySelectorAll("paper-checkbox").forEach(b=>{const d=this.coloring.getColor(b.name);
b.updateStyles({"--paper-checkbox-checked-color":d,"--paper-checkbox-checked-ink-color":d,"--paper-checkbox-unchecked-color":d,"--paper-checkbox-unchecked-ink-color":d})});this.root.querySelectorAll(".isolator").forEach(b=>{const d=this.coloring.getColor(b.name);b.style.color=d});window.requestAnimationFrame(()=>{this.updateStyles()})},_isolateName:function(b){var d=Polymer.dom(b).localTarget.name,f={};this.names.forEach(function(h){f[h]=h==d});this.selectionState=f},_checkboxChange:function(b){b=
Polymer.dom(b).localTarget;const d=_.clone(this.selectionState);d[b.name]=b.checked;this.selectionState=d},_isChecked:function(b){return-1!=this.outSelected.indexOf(b)},toggleAll:function(){const b=this.namesMatchingRegex.some(f=>this.outSelected.includes(f)),d={};this.names.forEach(f=>{d[f]=!b});this.selectionState=d}})})(qd||(qd={}));

//# sourceURL=build://tf-runs-selector/tf-wbr-string.html.js
Polymer({is:"tf-wbr-string",properties:{value:String,_parts:{type:Array,computed:"_computeParts(value)"}},_computeParts(b){const d=[],f=/[/=_,-]/;for(null==b&&(b="");;){const h=b.search(f);if(-1===h){d.push(b);break}else d.push(b.slice(0,h+1)),b=b.slice(h+1)}return d}});

//# sourceURL=build://tf-runs-selector/tf-runs-selector.html.js
Polymer({is:"tf-runs-selector",properties:{runSelectionState:{type:Object,observer:"_storeRunSelectionState",value:pd.getObjectInitializer("runSelectionState",{defaultValue:{}})},regexInput:{type:String,value:pd.getStringInitializer("regexInput",{defaultValue:""}),observer:"_regexObserver"},selectedRuns:{type:Array,notify:!0},runs:Array,dataLocation:{type:String,notify:!0},_clippedDataLocation:{type:String,computed:"_getClippedDataLocation(dataLocation, _dataLocationClipLength)"},_dataLocationClipLength:{type:Number,
value:250,readOnly:!0},coloring:{type:Object,value:{getColor:pf.runsColorScale}}},attached(){this._runStoreListener=vc.runsStore.addListener(()=>{this.set("runs",vc.runsStore.getRuns())});this.set("runs",vc.runsStore.getRuns());this._envStoreListener=vc.environmentStore.addListener(()=>{this.set("dataLocation",vc.environmentStore.getDataLocation())});this.set("dataLocation",vc.environmentStore.getDataLocation())},detached(){vc.runsStore.removeListenerByKey(this._runStoreListener);vc.environmentStore.removeListenerByKey(this._envStoreListener)},
_toggleAll:function(){this.$.multiCheckbox.toggleAll()},_getClippedDataLocation:function(b,d){if(void 0!==b&&!(b.length>d))return b},_openDataLocationDialog:function(b){b.preventDefault();this.$$("#data-location-dialog").open()},_shouldShowExpandDataLocationButton(b,d){return b&&b.length>d},_storeRunSelectionState:pd.getObjectObserver("runSelectionState",{defaultValue:{}}),_regexObserver:pd.getStringObserver("regexInput",{defaultValue:""})});

//# sourceURL=build://tf-tensorboard/registry.js
var qf;
(function(b){(function(d){d.NOT_LOADED="NOT_LOADED";d.LOADED="LOADED";d.FAILED="FAILED"})(b.ActiveDashboardsLoadState||(b.ActiveDashboardsLoadState={}));b.dashboardRegistry={};b.registerDashboard=function(){var d={plugin:"beholder",elementName:"tf-beholder-dashboard",shouldRemoveDom:!0};if(!d.plugin)throw Error("Dashboard.plugin must be present");if(!d.elementName)throw Error("Dashboard.elementName must be present");if(d.plugin in b.dashboardRegistry)throw Error(`Plugin already registered: ${d.plugin}`);d.tabName||
(d.tabName=d.plugin);b.dashboardRegistry[d.plugin]=d}})(qf||(qf={}));

//# sourceURL=build://tf-utils/utils.js
var rf;
(function(b){function d(f,h,k){return 1===f?h:k}b.aggregateTagInfo=function(f,h){let k=void 0;const t={};Object.keys(f).forEach(p=>{const m=f[p];void 0===k&&(k=m.displayName);k!==m.displayName&&(k=null);void 0===t[m.description]&&(t[m.description]=[]);t[m.description].push(p)});h=null!=k?k:h;const l=(()=>{const p=Object.keys(t);return 0===p.length?"":1===p.length?p[0]:`${"\x3cp\x3e\x3cstrong\x3eMultiple descriptions:\x3c/strong\x3e\x3c/p\x3e"}<ul>${p.map(m=>{const n=t[m].map(u=>`<code>${u.replace(/</g,"\x26lt;").replace(/>/g,
"\x26gt;").replace(/&/g,"\x26amp;")}</code>`),q=2<n.length?n.slice(0,n.length-1).join(", ")+", and "+n[n.length-1]:n.join(" and ");return`<li><p>For ${d(n.length,"run","runs")} ${q}:</p>${m}</li>`}).join("")}</ul>`})();return{displayName:h,description:l}}})(rf||(rf={}));

//# sourceURL=build://paper-spinner/paper-spinner-behavior.html.js
Polymer.PaperSpinnerBehavior={properties:{active:{type:Boolean,value:!1,reflectToAttribute:!0,observer:"__activeChanged"},alt:{type:String,value:"loading",observer:"__altChanged"},__coolingDown:{type:Boolean,value:!1}},__computeContainerClasses:function(b,d){return[b||d?"active":"",d?"cooldown":""].join(" ")},__activeChanged:function(b,d){this.__setAriaHidden(!b);this.__coolingDown=!b&&d},__altChanged:function(b){"loading"===b?this.alt=this.getAttribute("aria-label")||b:(this.__setAriaHidden(""===
b),this.setAttribute("aria-label",b))},__setAriaHidden:function(b){b?this.setAttribute("aria-hidden","true"):this.removeAttribute("aria-hidden")},__reset:function(){this.__coolingDown=this.active=!1}};

//# sourceURL=build://paper-spinner/paper-spinner-lite.html.js
Polymer({is:"paper-spinner-lite",behaviors:[Polymer.PaperSpinnerBehavior]});

//# sourceURL=build://tf-dashboard-common/data-loader-behavior.js
(function(b){let d;(function(f){f[f.LOADING=0]="LOADING";f[f.LOADED=1]="LOADED"})(d||(d={}));b.DataLoaderBehavior={properties:{active:{type:Boolean,observer:"_loadDataIfActive"},loadKey:{type:String,value:""},dataToLoad:{type:Array,value:()=>[]},getDataLoadName:{type:Function,value:()=>f=>String(f)},loadDataCallback:Function,requestData:{type:Function,value:function(){return f=>this.requestManager.request(this.getDataLoadUrl(f))}},getDataLoadUrl:Function,dataLoading:{type:Boolean,readOnly:!0,reflectToAttribute:!0,
value:!1},_dataLoadState:{type:Object,value:()=>new Map},_canceller:{type:Object,value:()=>new vc.Canceller},_loadDataAsync:{type:Number,value:null}},observers:["_dataToLoadChanged(isAttached, dataToLoad.*)"],onLoadFinish(){},reload(){this._dataLoadState.clear();this._loadData()},reset(){null!=this._loadDataAsync&&(this.cancelAsync(this._loadDataAsync),this._loadDataAsync=null);this._canceller&&this._canceller.cancelAll();this._dataLoadState&&this._dataLoadState.clear();this.isAttached&&this._loadData()},
_dataToLoadChanged(){this.isAttached&&this._loadData()},created(){this._loadData=_.throttle(this._loadDataImpl,100,{leading:!0,trailing:!0})},detached(){null!=this._loadDataAsync&&(this.cancelAsync(this._loadDataAsync),this._loadDataAsync=null)},_loadDataIfActive(){this.active&&this._loadData()},_loadDataImpl(){this.active&&(this.cancelAsync(this._loadDataAsync),this._loadDataAsync=this.async(this._canceller.cancellable(f=>{if(!f.cancelled)return this._setDataLoading(!0),f=this.dataToLoad.filter(h=>
{h=this.getDataLoadName(h);return!this._dataLoadState.has(h)}).map(h=>{const k=this.getDataLoadName(h);this._dataLoadState.set(k,d.LOADING);return this.requestData(h).then(this._canceller.cancellable(t=>{t.cancelled||(this._dataLoadState.set(k,d.LOADED),this.loadDataCallback(this,h,t.value));return k}))}),Promise.all(f).then(this._canceller.cancellable(h=>{if(!h.cancelled){const k=new Set(h.value);if(this.dataToLoad.some(t=>k.has(this.getDataLoadName(t))))this.onLoadFinish()}Array.from(this._dataLoadState.values()).some(k=>
k===d.LOADING)||this._setDataLoading(!1)}),()=>{}).then(this._canceller.cancellable(({cancelled:h})=>{h||(this._loadDataAsync=null)}))})))}}})(qd||(qd={}));

//# sourceURL=build://tf-imports/plottable.js
/*
 MIT
 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.
 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
 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.
 MIT
 @fileoverview Implements a function memoizer using the Signature API.
 Plottable 3.7.0 (https://github.com/palantir/plottable)
 Copyright 2014-2017 Palantir Technologies
 Licensed under MIT (https://github.com/palantir/plottable/blob/master/LICENSE)
 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.
*/
(function(b,d){"object"===typeof exports&&"object"===typeof module?module.exports=d(require("d3")):"function"===typeof define&&define.amd?define(["d3"],d):"object"===typeof exports?exports.Plottable=d(require("d3")):b.Plottable=d(b.d3)})(this,function(b){return function(d){function f(k){if(h[k])return h[k].exports;var t=h[k]={i:k,l:!1,exports:{}};d[k].call(t.exports,t,t.exports,f);t.l=!0;return t.exports}var h={};f.m=d;f.c=h;f.i=function(k){return k};f.d=function(k,t,l){f.o(k,t)||Object.defineProperty(k,
t,{configurable:!1,enumerable:!0,get:l})};f.n=function(k){var t=k&&k.__esModule?function(){return k["default"]}:function(){return k};f.d(t,"a",t);return t};f.o=function(k,t){return Object.prototype.hasOwnProperty.call(k,t)};f.p="";return f(f.s=140)}([function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}d=h(107);f.Array=d;d=h(110);f.Color=d;d=h(55);f.DOM=d;d=h(56);f.Math=d;d=h(113);f.Object=d;d=h(57);f.RTree=d;d=h(115);f.Stacking=d;d=h(35);f.Window=d;k(h(108));k(h(109));k(h(12));
k(h(111));k(h(112));k(h(58));k(h(116))},function(d){d.exports=b},function(d,f,h){function k(G,D,B){var I=D.accessor;D=D.scale;if(null==D)return[];var N=G.data();null!=B&&(N=N.filter(function(O,H){return B(O,H,G)}));N=N.map(function(O,H){return I(O,H,G)});return D.extentOfValues(N)}var t=this&&this.__extends||function(G,D){function B(){this.constructor=G}for(var I in D)D.hasOwnProperty(I)&&(G[I]=D[I]);G.prototype=null===D?Object.create(D):(B.prototype=D.prototype,new B)},l=h(1),p=h(7);d=h(4);var m=
h(18),n=h(6),q=h(9),u=h(20),x=h(0),A=h(12),y=h(10),w=h(51),C=h(52);f.Renderer=y.makeEnum(["svg","canvas"]);h=function(G){function D(){var B=G.call(this)||this;B._dataChanged=!1;B._attrExtents={};B._animate=!1;B._animators={};B._propertyExtents={};B._resetEntityStore=function(){B._cachedEntityStore=void 0};B._overflowHidden=!0;B.addClass("plot");B._datasetToDrawer=new x.Map;B._attrBindings=l.map();B._includedValuesProvider=function(N,O){return B._includedValuesForScale(N,O)};B._renderCallback=function(){return B.render()};
B._onDatasetUpdateCallback=function(){return B._onDatasetUpdate()};B._propertyBindings=l.map();var I=(new p.Easing).maxTotalDuration(D._ANIMATION_MAX_DURATION);B.animator(w.Animator.MAIN,I);B.animator(w.Animator.RESET,new p.Null);B._deferredResetEntityStore=x.Window.debounce(C.DeferredRenderer.DEFERRED_RENDERING_DELAY,B._resetEntityStore);return B}t(D,G);D.getTotalDrawTime=function(B,I){return I.reduce(function(N,O){return N+O.animator.totalTime(B.length)},0)};D.applyDrawSteps=function(B,I){return B.map(function(N){var O=
N.attrToProjector,H={};Object.keys(O).forEach(function(K){H[K]=function(M,L){return O[K](M,L,I)}});return{attrToAppliedProjector:H,animator:N.animator}})};D.prototype.anchor=function(B){B=A.coerceExternalD3(B);G.prototype.anchor.call(this,B);this._dataChanged=!0;this._resetEntityStore();this._updateExtents();return this};D.prototype._setup=function(){var B=this;this._isSetup||(G.prototype._setup.call(this),null!=this._canvas&&this._appendCanvasNode(),this._renderArea=this.content().append("g").classed("render-area",
!0),this.datasets().forEach(function(I){return B._createNodesForDataset(I)}))};D.prototype._appendCanvasNode=function(){var B=this.element().select(".plot-canvas-container");B.empty()&&(B=this.element().append("div").classed("plot-canvas-container",!0),B.node().appendChild(this._canvas.node()))};D.prototype.setBounds=function(B,I,N,O){G.prototype.setBounds.call(this,B,I,N,O);this._resetEntityStore();null!=this._canvas&&(this._bufferCanvas&&!this._bufferCanvasValid&&(this._bufferCanvas.attr("width",
this._canvas.attr("width")),this._bufferCanvas.attr("height",this._canvas.attr("height")),(N=this._bufferCanvas.node().getContext("2d"))&&N.drawImage(this._canvas.node(),0,0),this._bufferCanvasValid=!0),N=null!=window.devicePixelRatio?window.devicePixelRatio:1,this._canvas.attr("width",B*N),this._canvas.attr("height",I*N),O=this._canvas.node().getContext("2d"))&&(O.setTransform(N,0,0,N,0,0),this._bufferCanvas&&O.drawImage(this._bufferCanvas.node(),0,0,B,I))};D.prototype.destroy=function(){var B=this;
G.prototype.destroy.call(this);this._scales().forEach(function(I){return I.offUpdate(B._renderCallback)});this.datasets([])};D.prototype._createNodesForDataset=function(B){B=this._datasetToDrawer.get(B);"svg"===this.renderer()?B.useSVG(this._renderArea):B.useCanvas(this._canvas);return B};D.prototype._createDrawer=function(){return new n.ProxyDrawer(function(){return new q.SVGDrawer("path","")},function(B){return new m.CanvasDrawer(B,function(){})})};D.prototype._getAnimator=function(B){return this._animateOnNextRender()?
this._animators[B]||new p.Null:new p.Null};D.prototype._onDatasetUpdate=function(){this._updateExtents();this._dataChanged=!0;this._resetEntityStore();this.renderLowPriority()};D.prototype.attr=function(B,I,N){if(null==I)return this._attrBindings.get(B);this._bindAttr(B,I,N);this.render();return this};D.prototype._bindProperty=function(B,I,N,O){var H=this._propertyBindings.get(B);H=null!=H?H.scale:null;this._propertyBindings.set(B,{accessor:"function"===typeof I?I:function(){return I},scale:N,postScale:O});
null!=H&&this._uninstallScaleForKey(H,B);null!=N&&this._installScaleForKey(N,B);this._clearAttrToProjectorCache()};D.prototype._bindAttr=function(B,I,N){var O=this._attrBindings.get(B);O=null!=O?O.scale:null;this._attrBindings.set(B,{accessor:"function"===typeof I?I:function(){return I},scale:N});null!=O&&this._uninstallScaleForKey(O,B);null!=N&&this._installScaleForKey(N,B);this._clearAttrToProjectorCache()};D.prototype._clearAttrToProjectorCache=function(){delete this._cachedAttrToProjector};D.prototype._getAttrToProjector=
function(){null==this._cachedAttrToProjector&&(this._cachedAttrToProjector=this._generateAttrToProjector());return x.Object.assign({},this._cachedAttrToProjector)};D.prototype._generateAttrToProjector=function(){var B={};this._attrBindings.each(function(N,O){B[O]=D._scaledAccessor(N)});var I=this._propertyProjectors();Object.keys(I).forEach(function(N){null==B[N]&&(B[N]=I[N])});return B};D.prototype.renderImmediately=function(){G.prototype.renderImmediately.call(this);this._isAnchored&&(this._paint(),
this._dataChanged=!1);return this};D.prototype.renderLowPriority=function(){this._renderCallback()};D.prototype.animated=function(B){if(null==B)return this._animate;this._animate=B;return this};D.prototype.detach=function(){G.prototype.detach.call(this);this._updateExtents();return this};D.prototype._scales=function(){var B=[];this._attrBindings.each(function(I){I=I.scale;null!=I&&-1===B.indexOf(I)&&B.push(I)});this._propertyBindings.each(function(I){I=I.scale;null!=I&&-1===B.indexOf(I)&&B.push(I)});
return B};D.prototype._updateExtents=function(){var B=this;this._resetEntityStore();this._scales().forEach(function(I){return I.addIncludedValuesProvider(B._includedValuesProvider)})};D.prototype._filterForProperty=function(){return null};D.prototype.getExtentsForAttr=function(B){var I=this;null==this._attrExtents[B]&&(this._attrExtents[B]=u.memThunk(function(){return I.datasets()},function(){return I._attrBindings.get(B)},function(N,O){return null==O||null==O.accessor?null:N.map(function(H){return k(H,
O,null)})}));return this._attrExtents[B]()};D.prototype.getExtentsForProperty=function(B){var I=this;null==this._propertyExtents[B]&&(this._propertyExtents[B]=u.memThunk(function(){return I.datasets()},function(){return I._propertyBindings.get(B)},function(){return I._filterForProperty(B)},function(N,O,H){return null==O||null==O.accessor?null:N.map(function(K){return k(K,O,H)})}));return this._propertyExtents[B]()};D.prototype._includedValuesForScale=function(B,I){var N=this;if(!this._isAnchored&&
!I)return[];var O=[];this._attrBindings.each(function(H,K){H.scale===B&&(H=N.getExtentsForAttr(K),null!=H&&(O=O.concat(l.merge(H))))});this._propertyBindings.each(function(H,K){H.scale===B&&(H=N.getExtentsForProperty(K),null!=H&&(O=O.concat(l.merge(H))))});return O};D.prototype.animator=function(B,I){if(void 0===I)return this._animators[B];this._animators[B]=I;return this};D.prototype.renderer=function(){return null==this._canvas?"svg":"canvas"};D.prototype.addDataset=function(B){this._addDataset(B);
this._onDatasetUpdate()};D.prototype._addDataset=function(B){this._removeDataset(B);var I=this._createDrawer(B);this._datasetToDrawer.set(B,I);this._isSetup&&this._createNodesForDataset(B);B.onUpdate(this._onDatasetUpdateCallback);return this};D.prototype.removeDataset=function(B){this._removeDataset(B);this._onDatasetUpdate()};D.prototype._removeDataset=function(B){if(-1===this.datasets().indexOf(B))return this;this._removeDatasetNodes(B);B.offUpdate(this._onDatasetUpdateCallback);this._datasetToDrawer.delete(B);
return this};D.prototype._removeDatasetNodes=function(B){this._datasetToDrawer.get(B).remove()};D.prototype.datasets=function(B){var I=this,N=[];this._datasetToDrawer.forEach(function(O,H){return N.push(H)});if(null==B)return N;N.forEach(function(O){return I._removeDataset(O)});B.forEach(function(O){return I._addDataset(O)});this._onDatasetUpdate();return this};D.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new p.Null}]};D.prototype._additionalPaint=
function(){};D.prototype._buildLightweightPlotEntities=function(B){var I=this,N=[];B.forEach(function(O,H){var K=I._datasetToDrawer.get(O),M=0;O.data().forEach(function(L,Q){var T=I._pixelPoint(L,Q,O);x.Math.isNaN(T.x)||x.Math.isNaN(T.y)||(N.push({datum:L,get position(){return I._pixelPoint.call(I,L,Q,O)},index:Q,dataset:O,datasetIndex:H,component:I,drawer:K,validDatumIndex:M}),M++)})});return N};D.prototype._getDataToDraw=function(){var B=new x.Map;this.datasets().forEach(function(I){return B.set(I,
I.data())});return B};D.prototype._paint=function(){var B=this;delete this._cachedAttrToProjector;var I=this._generateDrawSteps(),N=this._getDataToDraw(),O=this.datasets().map(function(K){return B._datasetToDrawer.get(K)});if("canvas"===this.renderer()){var H=this._canvas.node();H.getContext("2d").clearRect(0,0,H.clientWidth,H.clientHeight);this._bufferCanvasValid=!1}this.datasets().forEach(function(K,M){var L=D.applyDrawSteps(I,K);O[M].draw(N.get(K),L)});H=this.datasets().map(function(K){return D.getTotalDrawTime(N.get(K),
I)});H=x.Math.max(H,0);this._additionalPaint(H)};D.prototype.selections=function(B){var I=this;void 0===B&&(B=this.datasets());if("canvas"===this.renderer())return l.selectAll();var N=[];B.forEach(function(O){O=I._datasetToDrawer.get(O);null!=O&&(O=O.getVisualPrimitives(),N.push.apply(N,O))});return l.selectAll(N)};D.prototype.entities=function(B){var I=this;return this._getEntityStore(B).entities().map(function(N){return I._lightweightPlotEntityToPlotEntity(N)})};D.prototype._getEntityStore=function(B){function I(H){return N._entityBounds(H)}
var N=this;if(void 0!==B){var O=new x.EntityStore;O.addAll(this._buildLightweightPlotEntities(B),I,this._localOriginBounds());return O}void 0===this._cachedEntityStore&&(O=new x.EntityStore,O.addAll(this._buildLightweightPlotEntities(this.datasets()),I,this._localOriginBounds()),this._cachedEntityStore=O);return this._cachedEntityStore};D.prototype._localOriginBounds=function(){return{topLeft:{x:0,y:0},bottomRight:{x:this.width(),y:this.height()}}};D.prototype._entityBounds=function(B){B=this._pixelPoint(B.datum,
B.index,B.dataset);return{x:B.x,y:B.y,width:0,height:0}};D.prototype._lightweightPlotEntityToPlotEntity=function(B){return{bounds:this._entityBounds(B),component:B.component,dataset:B.dataset,datasetIndex:B.datasetIndex,datum:B.datum,index:B.index,position:B.position,selection:l.select(B.drawer.getVisualPrimitives()[B.validDatumIndex])}};D.prototype.entitiesAt=function(){throw Error("plots must implement entitiesAt");};D.prototype.entityNearest=function(B){B=this._getEntityStore().entityNearest(B);
return void 0===B?void 0:this._lightweightPlotEntityToPlotEntity(B)};D.prototype.entitiesIn=function(B,I){return this.entitiesInBounds(null==I?{x:B.topLeft.x,y:B.topLeft.y,width:B.bottomRight.x-B.topLeft.x,height:B.bottomRight.y-B.topLeft.y}:{x:B.min,y:I.min,width:B.max-B.min,height:I.max-I.min})};D.prototype.entitiesInBounds=function(B){var I=this;if(B=this._getEntityStore().entitiesInBounds(B))return B.map(function(N){return I._lightweightPlotEntityToPlotEntity(N)})};D.prototype.entitiesInXBounds=
function(B){var I=this;if(B=this._getEntityStore().entitiesInXBounds(B))return B.map(function(N){return I._lightweightPlotEntityToPlotEntity(N)})};D.prototype.entitiesInYBounds=function(B){var I=this;if(B=this._getEntityStore().entitiesInYBounds(B))return B.map(function(N){return I._lightweightPlotEntityToPlotEntity(N)})};D.prototype._uninstallScaleForKey=function(B){B.offUpdate(this._renderCallback);B.offUpdate(this._deferredResetEntityStore);B.removeIncludedValuesProvider(this._includedValuesProvider)};
D.prototype._installScaleForKey=function(B){B.onUpdate(this._renderCallback);B.onUpdate(this._deferredResetEntityStore);B.addIncludedValuesProvider(this._includedValuesProvider)};D.prototype._propertyProjectors=function(){return{}};D._scaledAccessor=function(B){var I=B.scale,N=B.accessor,O=B.postScale,H=null==I?N:function(K,M,L){return I.scale(N(K,M,L))};return null==O?H:function(K,M,L){return O(H(K,M,L),K,M,L)}};D.prototype._pixelPoint=function(){return{x:0,y:0}};D.prototype._animateOnNextRender=
function(){return this._animate&&this._dataChanged};return D}(d.Component);h._ANIMATION_MAX_DURATION=600;f.Plot=h},function(d,f,h){function k(p){for(var m in p)f.hasOwnProperty(m)||(f[m]=p[m])}d=h(105);f.TickGenerators=d;k(h(54));k(h(101));k(h(102));k(h(103));k(h(104));k(h(106));var t=h(54),l=h(11);f.isTransformable=function(p){return p instanceof l.QuantitativeScale||p instanceof t.Category}},function(d,f,h){var k=h(1),t=h(30),l=h(0),p=h(12);d=h(10);f.XAlignment=d.makeEnum(["left","center","right"]);
f.YAlignment=d.makeEnum(["top","center","bottom"]);d=function(){function m(){this._overflowHidden=!1;this._origin={x:0,y:0};this._xAlignment="left";this._yAlignment="top";this._isAnchored=this._isSetup=!1;this._cssClasses=new l.Set;this._destroyed=!1;this._onAnchorCallbacks=new l.CallbackSet;this._onDetachCallbacks=new l.CallbackSet;this._cssClasses.add("component")}m.prototype.anchor=function(n){n=p.coerceExternalD3(n);if(this._destroyed)throw Error("Can't reuse destroy()-ed Components!");this.isRoot()&&
(this._rootElement=n,this._rootElement.classed("plottable",!0));null!=this._element?n.node().appendChild(this._element.node()):(this._element=n.append("div"),this._setup());this._isAnchored=!0;this._onAnchorCallbacks.callCallbacks(this);return this};m.prototype.onAnchor=function(n){this._isAnchored&&n(this);this._onAnchorCallbacks.add(n)};m.prototype.offAnchor=function(n){this._onAnchorCallbacks.delete(n)};m.prototype._setup=function(){var n=this;this._isSetup||(this._cssClasses.forEach(function(q){n._element.classed(q,
!0)}),this._cssClasses=new l.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)};m.prototype.requestedSpace=function(){return{minWidth:0,minHeight:0}};m.prototype.computeLayout=
function(n,q,u){if(null==n||null==q||null==u){if(null==this._element)throw Error("anchor() must be called before computeLayout()");if(null!=this._rootElement)n={x:0,y:0},u=this._rootElement.node(),q=l.DOM.elementWidth(u),u=l.DOM.elementHeight(u);else throw Error("null arguments cannot be passed to computeLayout() on a non-root, unanchored node");}var x=this._sizeFromOffer(q,u),A=x.height;x=x.width;this.setBounds(x,A,n.x+(q-x)*m._xAlignToProportion[this._xAlignment],n.y+(u-A)*m._yAlignToProportion[this._yAlignment]);
return this};m.prototype.setBounds=function(n,q,u,x){void 0===u&&(u=0);void 0===x&&(x=0);this._width=n;this._height=q;this._origin={x:u,y:x};null!=this._element&&this._element.styles({left:u+"px",height:q+"px",top:x+"px",width:n+"px"});null!=this._resizeHandler&&this._resizeHandler({width:n,height:q})};m.prototype._sizeFromOffer=function(n,q){var u=this.requestedSpace(n,q);return{width:this.fixedWidth()?Math.min(n,u.minWidth):n,height:this.fixedHeight()?Math.min(q,u.minHeight):q}};m.prototype.render=
function(){this._isAnchored&&this._isSetup&&0<=this.width()&&0<=this.height()&&t.registerToRender(this);return this};m.prototype.renderLowPriority=function(){this.render()};m.prototype._scheduleComputeLayout=function(){this._isAnchored&&this._isSetup&&t.registerToComputeLayoutAndRender(this)};m.prototype.onResize=function(n){this._resizeHandler=n;return this};m.prototype.renderImmediately=function(){return this};m.prototype.redraw=function(){this._isAnchored&&this._isSetup&&(this.isRoot()?this._scheduleComputeLayout():
this.parent().redraw());return this};m.prototype.invalidateCache=function(){};m.prototype.renderTo=function(n){this.detach();if(null!=n){n="string"===typeof n?k.select(n):n instanceof Element?k.select(n):p.coerceExternalD3(n);if(!n.node()||null==n.node().nodeName)throw Error("Plottable requires a valid Element to renderTo");if("svg"===n.node().nodeName)throw Error("Plottable 3.x and later can only renderTo an HTML component; pass a div instead!");this.anchor(n)}if(null==this._element)throw 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");
t.registerToComputeLayoutAndRender(this);t.flush()};m.prototype.xAlignment=function(n){if(null==n)return this._xAlignment;n=n.toLowerCase();if(null==m._xAlignToProportion[n])throw Error("Unsupported alignment: "+n);this._xAlignment=n;this.redraw();return this};m.prototype.yAlignment=function(n){if(null==n)return this._yAlignment;n=n.toLowerCase();if(null==m._yAlignToProportion[n])throw Error("Unsupported alignment: "+n);this._yAlignment=n;this.redraw();return this};m.prototype.hasClass=function(n){return null==
n?!1:null==this._element?this._cssClasses.has(n):this._element.classed(n)};m.prototype.addClass=function(n){null!=n&&(null==this._element?this._cssClasses.add(n):this._element.classed(n,!0))};m.prototype.removeClass=function(n){null!=n&&(null==this._element?this._cssClasses.delete(n):this._element.classed(n,!1))};m.prototype.fixedWidth=function(){return!1};m.prototype.fixedHeight=function(){return!1};m.prototype.detach=function(){this.parent(null);this._isAnchored&&this._element.remove();this._isAnchored=
!1;this._onDetachCallbacks.callCallbacks(this);return this};m.prototype.onDetach=function(n){this._onDetachCallbacks.add(n)};m.prototype.offDetach=function(n){this._onDetachCallbacks.delete(n)};m.prototype.parent=function(n){if(void 0===n)return this._parent;if(null!==n&&!n.has(this))throw Error("Passed invalid parent");this._parent=n;return this};m.prototype.bounds=function(){var n=this.origin();return{topLeft:n,bottomRight:{x:n.x+this.width(),y:n.y+this.height()}}};m.prototype.destroy=function(){this._destroyed=
!0;this.detach()};m.prototype.width=function(){return this._width};m.prototype.height=function(){return this._height};m.prototype.origin=function(){return{x:this._origin.x,y:this._origin.y}};m.prototype.originToRoot=function(){for(var n=this.origin(),q=this.parent();null!=q;){var u=q.origin();n.x+=u.x;n.y+=u.y;q=q.parent()}return n};m.prototype.root=function(){for(var n=this;!n.isRoot();)n=n.parent();return n};m.prototype.isRoot=function(){return null==this.parent()};m.prototype.foreground=function(){return this._foregroundContainer};
m.prototype.content=function(){return this._content};m.prototype.element=function(){return this._element};m.prototype.rootElement=function(){return this.root()._rootElement};m.prototype.background=function(){return this._backgroundContainer};return m}();d._xAlignToProportion={left:0,center:.5,right:1};d._yAlignToProportion={top:0,center:.5,bottom:1};f.Component=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(59));k(h(62));k(h(133));k(h(21));k(h(64));k(h(66))},
function(d,f){d=function(){function h(k,t){this._svgDrawerFactory=k;this._canvasDrawerFactory=t}h.prototype.useSVG=function(k){null!=this._currentDrawer&&this._currentDrawer.remove();var t=this._svgDrawerFactory();t.attachTo(k);this._currentDrawer=t};h.prototype.useCanvas=function(k){null!=this._currentDrawer&&this._currentDrawer.remove();this._currentDrawer=this._canvasDrawerFactory(k.node().getContext("2d"))};h.prototype.getDrawer=function(){return this._currentDrawer};h.prototype.remove=function(){null!=
this._currentDrawer&&this._currentDrawer.remove()};h.prototype.draw=function(k,t){this._currentDrawer.draw(k,t)};h.prototype.getVisualPrimitives=function(){return this._currentDrawer.getVisualPrimitives()};h.prototype.getVisualPrimitiveAtIndex=function(k){return this._currentDrawer.getVisualPrimitiveAtIndex(k)};return h}();f.ProxyDrawer=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(70));k(h(71))},function(d,f,h){function k(p){void 0===p&&(p=3);t(p);return function(m){return m.toFixed(p)}}
function t(p){if(0>p||20<p)throw new RangeError("Formatter precision must be between 0 and 20");if(p!==Math.floor(p))throw new RangeError("Formatter precision must be an integer");}var l=h(1);f.currency=function(p,m,n){void 0===p&&(p=2);void 0===m&&(m="$");void 0===n&&(n=!0);var q=k(p);return function(u){var x=q(Math.abs(u));""!==x&&(x=n?m+x:x+m,0>u&&(x="-"+x));return x}};f.fixed=k;f.general=function(){var p;void 0===p&&(p=3);t(p);return function(m){if("number"===typeof m){var n=Math.pow(10,p);return String(Math.round(m*
n)/n)}return String(m)}};f.identity=function(){return function(p){return String(p)}};f.percentage=function(p){void 0===p&&(p=0);var m=k(p);return function(n){var q=n.toString();q=Math.pow(10,q.length-(q.indexOf(".")+1));return m(parseInt((100*n*q).toString(),10)/q)+"%"}};f.siSuffix=function(p){void 0===p&&(p=3);t(p);return function(m){return l.format("."+p+"s")(m)}};f.shortScale=function(p){void 0===p&&(p=3);t(p);var m=l.format("."+p+"e"),n=l.format("."+p+"f"),q=Math.pow(10,18),u=Math.pow(10,-p);
return function(x){var A=Math.abs(x);if((A<u||A>=q)&&0!==A)return m(x);for(var y=-1;A>=Math.pow(1E3,y+2)&&4>y;)y++;A=-1===y?n(x):n(x/Math.pow(1E3,y+1))+"KMBTQ"[y];if(0<x&&"1000"===A.substr(0,4)||0>x&&"-1000"===A.substr(0,5))4>y?(y++,A=n(x/Math.pow(1E3,y+1))+"KMBTQ"[y]):A=m(x);return A}};f.multiTime=function(){var p=[{specifier:".%L",predicate:function(m){return 0!==m.getMilliseconds()}},{specifier:":%S",predicate:function(m){return 0!==m.getSeconds()}},{specifier:"%I:%M",predicate:function(m){return 0!==
m.getMinutes()}},{specifier:"%I %p",predicate:function(m){return 0!==m.getHours()}},{specifier:"%a %d",predicate:function(m){return 0!==m.getDay()&&1!==m.getDate()}},{specifier:"%b %d",predicate:function(m){return 1!==m.getDate()}},{specifier:"%b",predicate:function(m){return 0!==m.getMonth()}}];return function(m){var n=p.filter(function(q){return q.predicate(m)});return l.timeFormat(0<n.length?n[0].specifier:"%Y")(m)}};f.time=function(p){return l.timeFormat(p)}},function(d,f,h){var k=h(1),t=h(0);
d=function(){function l(p,m){this._root=k.select(document.createElementNS("http://www.w3.org/2000/svg","g"));this._className=m;this._svgElementName=p}l.prototype.draw=function(p,m){var n=this;this._createAndDestroyDOMElements(p);var q=0;m.forEach(function(u){t.Window.setTimeout(function(){return n._drawStep(u)},q);q+=u.animator.totalTime(p.length)})};l.prototype.getVisualPrimitives=function(){null==this._cachedVisualPrimitivesNodes&&(this._cachedVisualPrimitivesNodes=this._selection.nodes());return this._cachedVisualPrimitivesNodes};
l.prototype.getVisualPrimitiveAtIndex=function(p){return this.getVisualPrimitives()[p]};l.prototype.remove=function(){this._root.remove()};l.prototype.attachTo=function(p){p.node().appendChild(this._root.node())};l.prototype.getRoot=function(){return this._root};l.prototype.selector=function(){return this._svgElementName};l.prototype._applyDefaultAttributes=function(){};l.prototype._createAndDestroyDOMElements=function(p){p=p.filter(function(m){return null!=m});p=this._root.selectAll(this.selector()).data(p);
this._selection=p.enter().append(this._svgElementName).merge(p);p.exit().remove();this._cachedVisualPrimitivesNodes=null;null!=this._className&&this._selection.classed(this._className,!0);this._applyDefaultAttributes(this._selection)};l.prototype._drawStep=function(p){var m=this;["fill","stroke"].forEach(function(n){null!=p.attrToAppliedProjector[n]&&m._selection.attr(n,p.attrToAppliedProjector[n])});p.animator.animate(this._selection,p.attrToAppliedProjector);null!=this._className&&this._selection.classed(this._className,
!0)};return l}();f.SVGDrawer=d},function(d,f){f.makeEnum=function(h){return h.reduce(function(k,t){k[t]=t;return k},{})}},function(d,f,h){var k=this&&this.__extends||function(m,n){function q(){this.constructor=m}for(var u in n)n.hasOwnProperty(u)&&(m[u]=n[u]);m.prototype=null===n?Object.create(n):(q.prototype=n.prototype,new q)},t=h(1),l=h(26),p=h(0);d=function(m){function n(){var q=m.call(this)||this;q._tickGenerator=function(u){return u.defaultTicks()};q._padProportion=.05;q._snappingDomainEnabled=
!0;q._paddingExceptionsProviders=new p.Set;return q}k(n,m);n.prototype.autoDomain=function(){this._domainMax=this._domainMin=null;m.prototype.autoDomain.call(this)};n.prototype._autoDomainIfAutomaticMode=function(){if(null!=this._domainMin&&null!=this._domainMax)this._setDomain([this._domainMin,this._domainMax]);else{var q=this._getExtent();null!=this._domainMin?(q=q[1],this._domainMin>=q&&(q=this._expandSingleValueDomain([this._domainMin,this._domainMin])[1]),this._setDomain([this._domainMin,q])):
null!=this._domainMax?(q=q[0],this._domainMax<=q&&(q=this._expandSingleValueDomain([this._domainMax,this._domainMax])[0]),this._setDomain([q,this._domainMax])):m.prototype._autoDomainIfAutomaticMode.call(this)}};n.prototype._getUnboundedExtent=function(q){void 0===q&&(q=!1);q=this._getAllIncludedValues(q);var u=this._defaultExtent();0!==q.length&&(q=[p.Math.min(q,u[0]),p.Math.max(q,u[1])],u=this._padDomain(q));return u};n.prototype._getExtent=function(){var q=this._getUnboundedExtent();null!=this._domainMin&&
(q[0]=this._domainMin);null!=this._domainMax&&(q[1]=this._domainMax);return q};n.prototype.addPaddingExceptionsProvider=function(q){this._paddingExceptionsProviders.add(q);this._autoDomainIfAutomaticMode()};n.prototype.removePaddingExceptionsProvider=function(q){this._paddingExceptionsProviders.delete(q);this._autoDomainIfAutomaticMode()};n.prototype.padProportion=function(q){if(null==q)return this._padProportion;if(0>q)throw Error("padProportion must be non-negative");this._padProportion=q;this._autoDomainIfAutomaticMode();
return this};n.prototype._padDomain=function(q){var u=this;if(q[0].valueOf()===q[1].valueOf())return this._expandSingleValueDomain(q);if(0===this._padProportion)return q;var x=this._padProportion/2,A=q[0],y=q[1],w=!1,C=!1;this._paddingExceptionsProviders.forEach(function(D){D(u).forEach(function(B){B.valueOf()===A.valueOf()&&(w=!0);B.valueOf()===y.valueOf()&&(C=!0)})});var G=this._backingScaleDomain();this._backingScaleDomain(q);q=w?A:this.invert(this.scale(A)-(this.scale(y)-this.scale(A))*x);x=C?
y:this.invert(this.scale(y)+(this.scale(y)-this.scale(A))*x);this._backingScaleDomain(G);return this._snappingDomainEnabled?this._niceDomain([q,x]):[q,x]};n.prototype.snappingDomainEnabled=function(q){null!=q&&(this._snappingDomainEnabled=q,this._autoDomainIfAutomaticMode())};n.prototype._expandSingleValueDomain=function(q){return q};n.prototype.invert=function(){throw Error("Subclasses should override invert");};n.prototype.domain=function(q){null!=q&&(this._domainMin=q[0],this._domainMax=q[1]);
return m.prototype.domain.call(this,q)};n.prototype.domainMin=function(q){if(null==q)return this.domain()[0];this._domainMin=q;this._autoDomainIfAutomaticMode();return this};n.prototype.domainMax=function(q){if(null==q)return this.domain()[1];this._domainMax=q;this._autoDomainIfAutomaticMode();return this};n.prototype.extentOfValues=function(q){q=t.extent(q.filter(function(u){return p.Math.isValidNumber(+u)}));return null==q[0]||null==q[1]?[]:q};n.prototype.zoom=function(q,u){var x=this;this.domain(this.range().map(function(A){return x.invert(l.zoomOut(A,
q,u))}))};n.prototype.pan=function(q){var u=this;this.domain(this.range().map(function(x){return u.invert(x+q)}))};n.prototype.scaleTransformation=function(){throw Error("Subclasses should override scaleTransformation");};n.prototype.invertedTransformation=function(){throw Error("Subclasses should override invertedTransformation");};n.prototype.getTransformationExtent=function(){throw Error("Subclasses should override getTransformationExtent");};n.prototype.getTransformationDomain=function(){throw Error("Subclasses should override getTransformationDomain");
};n.prototype.setTransformationDomain=function(){throw Error("Subclasses should override setTransformationDomain");};n.prototype._setDomain=function(q){function u(x){return p.Math.isNaN(x)||Infinity===x||-Infinity===x}u(q[0])||u(q[1])?p.Window.warn("Warning: QuantitativeScales cannot take NaN or Infinity as a domain value. Ignoring."):m.prototype._setDomain.call(this,q)};n.prototype.defaultTicks=function(){throw Error("Subclasses should override _getDefaultTicks");};n.prototype.ticks=function(){return this._tickGenerator(this)};
n.prototype._niceDomain=function(){throw Error("Subclasses should override _niceDomain");};n.prototype._defaultExtent=function(){throw Error("Subclasses should override _defaultExtent");};n.prototype.tickGenerator=function(){var q=Plottable.Scales.TickGenerators.integerTickGenerator();null!=q&&(this._tickGenerator=q)};return n}(h(17).Scale);d._DEFAULT_NUM_TICKS=10;f.QuantitativeScale=d},function(d,f,h){var k=h(1);f.coerceExternalD3=function(t){if(null==t.attrs){if(null==t.nodes){var l=[];t.each(function(){l.push(this)});
return k.selectAll(l)}return k.selectAll(t.nodes())}return t}},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(83));k(h(84));k(h(85))},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(44));k(h(45));k(h(46));k(h(18));k(h(6));k(h(33));k(h(34));k(h(47));k(h(9));k(h(48))},function(d,f){d=function(){function h(){var k=this;this._anchorCallback=function(t){return k._anchor(t)};this._enabled=!0}h.prototype.attachTo=function(k){this._disconnect();
this._componentAttachedTo=k;this._connect();return this};h.prototype.detachFrom=function(){this.detach()};h.prototype.detach=function(){this._disconnect();this._componentAttachedTo=null;return this};h.prototype.enabled=function(k){if(null==k)return this._enabled;(this._enabled=k)?this._connect():this._disconnect();return this};h.prototype._anchor=function(){this._isAnchored=!0};h.prototype._unanchor=function(){this._isAnchored=!1};h.prototype._translateToComponentSpace=function(k){var t=this._componentAttachedTo.originToRoot();
return{x:k.x-t.x,y:k.y-t.y}};h.prototype._isInsideComponent=function(k){return 0<=k.x&&0<=k.y&&k.x<=this._componentAttachedTo.width()&&k.y<=this._componentAttachedTo.height()};h.prototype._connect=function(){if(this.enabled()&&null!=this._componentAttachedTo&&!this._isAnchored)this._componentAttachedTo.onAnchor(this._anchorCallback)};h.prototype._disconnect=function(){this._isAnchored&&this._unanchor();null!=this._componentAttachedTo&&this._componentAttachedTo.offAnchor(this._anchorCallback)};return h}();
f.Interaction=d},function(d,f,h){var k=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&(n[x]=q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},t=h(3),l=h(0),p=h(52),m=h(2);d=function(n){function q(){var u=n.call(this)||this;u._autoAdjustXScaleDomain=!1;u._autoAdjustYScaleDomain=!1;u._deferredRendering=!1;u._applyDeferredRenderingTransform=function(x,A,y,w){u._isAnchored&&(null!=u._renderArea&&u._renderArea.attr("transform",
"translate("+x+", "+A+") scale("+y+", "+w+")"),null!=u._canvas&&u._canvas.style("transform","translate("+x+"px, "+A+"px) scale("+y+", "+w+")"))};u.addClass("xy-plot");u._adjustYDomainOnChangeFromXCallback=function(){return u._adjustYDomainOnChangeFromX()};u._adjustXDomainOnChangeFromYCallback=function(){return u._adjustXDomainOnChangeFromY()};u._renderCallback=function(){if(u.deferredRendering()){var x=u.x()&&u.x().scale,A=u.y()&&u.y().scale;u._deferredRenderer.updateDomains(x,A)}else u.render()};
u._deferredRenderer=new p.DeferredRenderer(function(){return u.render()},u._applyDeferredRenderingTransform);return u}k(q,n);q.prototype.render=function(){this.deferredRendering()&&this._deferredRenderer.resetTransforms();return n.prototype.render.call(this)};q.prototype.deferredRendering=function(){return this._deferredRendering};q.prototype.x=function(u,x,A){if(null==u)return this._propertyBindings.get(q._X_KEY);this._bindProperty(q._X_KEY,u,x,A);u=this.width();null!=x&&null!=u&&x.range([0,u]);
this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain();this.render();return this};q.prototype.y=function(u,x,A){if(null==u)return this._propertyBindings.get(q._Y_KEY);this._bindProperty(q._Y_KEY,u,x,A);u=this.height();null!=x&&null!=u&&(x instanceof t.Category?x.range([0,u]):x.range([u,0]));this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain();this.render();return this};q.prototype._filterForProperty=function(u){return"x"===u&&this._autoAdjustXScaleDomain?this._makeFilterByProperty("y"):
"y"===u&&this._autoAdjustYScaleDomain?this._makeFilterByProperty("x"):null};q.prototype._makeFilterByProperty=function(u){u=this._propertyBindings.get(u);if(null!=u){var x=u.accessor,A=u.scale;if(null!=A)return function(y,w,C){var G=A.range();return l.Math.inRange(A.scale(x(y,w,C)),G[0],G[1])}}return null};q.prototype._uninstallScaleForKey=function(u,x){n.prototype._uninstallScaleForKey.call(this,u,x);u.offUpdate(x===q._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback)};
q.prototype._installScaleForKey=function(u,x){n.prototype._installScaleForKey.call(this,u,x);u.onUpdate(x===q._X_KEY?this._adjustYDomainOnChangeFromXCallback:this._adjustXDomainOnChangeFromYCallback)};q.prototype.destroy=function(){n.prototype.destroy.call(this);this.x().scale&&this.x().scale.offUpdate(this._adjustYDomainOnChangeFromXCallback);this.y().scale&&this.y().scale.offUpdate(this._adjustXDomainOnChangeFromYCallback);return this};q.prototype.autorangeMode=function(u){if(null==u)return this._autoAdjustXScaleDomain?
"x":this._autoAdjustYScaleDomain?"y":"none";switch(u){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._autoAdjustYScaleDomain=this._autoAdjustXScaleDomain=!1;break;default:throw Error("Invalid scale name '"+u+"', must be 'x', 'y' or 'none'");}return this};q.prototype.computeLayout=function(u,x,A){n.prototype.computeLayout.call(this,
u,x,A);u=(u=this.x())&&u.scale;null!=u&&u.range([0,this.width()]);u=(u=this.y())&&u.scale;null!=u&&(u instanceof t.Category?u.range([0,this.height()]):u.range([this.height(),0]));return this};q.prototype._updateXExtentsAndAutodomain=function(){var u=this.x().scale;null!=u&&u.autoDomain()};q.prototype._updateYExtentsAndAutodomain=function(){var u=this.y().scale;null!=u&&u.autoDomain()};q.prototype.showAllData=function(){this._updateXExtentsAndAutodomain();this._updateYExtentsAndAutodomain();return this};
q.prototype._adjustYDomainOnChangeFromX=function(){this._projectorsReady()&&this._autoAdjustYScaleDomain&&this._updateYExtentsAndAutodomain()};q.prototype._adjustXDomainOnChangeFromY=function(){this._projectorsReady()&&this._autoAdjustXScaleDomain&&this._updateXExtentsAndAutodomain()};q.prototype._projectorsReady=function(){var u=this.x(),x=this.y();return null!=u&&null!=u.accessor&&null!=x&&null!=x.accessor};q.prototype._pixelPoint=function(u,x,A){var y=m.Plot._scaledAccessor(this.x()),w=m.Plot._scaledAccessor(this.y());
return{x:y(u,x,A),y:w(u,x,A)}};q.prototype._getDataToDraw=function(){function u(y,w,C){var G=m.Plot._scaledAccessor(x.x())(y,w,C);y=m.Plot._scaledAccessor(x.y())(y,w,C);return l.Math.isValidNumber(G)&&l.Math.isValidNumber(y)}var x=this,A=n.prototype._getDataToDraw.call(this);this.datasets().forEach(function(y){A.set(y,A.get(y).filter(function(w,C){return u(w,C,y)}))});return A};return q}(m.Plot);d._X_KEY="x";d._Y_KEY="y";f.XYPlot=d},function(d,f,h){var k=h(0);d=function(){function t(){this._autoDomainAutomatically=
!0;this._domainModificationInProgress=!1;this._updateId=0;this._callbacks=new k.CallbackSet;this._includedValuesProviders=new k.Set}t.prototype.extentOfValues=function(){return[]};t.prototype._getAllIncludedValues=function(l){var p=this;void 0===l&&(l=!1);var m=[];this._includedValuesProviders.forEach(function(n){n=n(p,l);m=m.concat(n)});return m};t.prototype._getExtent=function(){return[]};t.prototype.onUpdate=function(l){this._callbacks.add(l);return this};t.prototype.offUpdate=function(l){this._callbacks.delete(l);
return this};t.prototype._dispatchUpdate=function(){this._updateId++;this._callbacks.callCallbacks(this)};t.prototype.autoDomain=function(){this._autoDomainAutomatically=!0;this._setDomain(this._getExtent())};t.prototype._autoDomainIfAutomaticMode=function(){this._autoDomainAutomatically&&this.autoDomain()};t.prototype.scale=function(){throw Error("Subclasses should override scale");};t.prototype.ticks=function(){return this.domain()};t.prototype.domain=function(l){if(null==l)return this._getDomain();
this._autoDomainAutomatically=!1;this._setDomain(l);return this};t.prototype._getDomain=function(){throw Error("Subclasses should override _getDomain");};t.prototype._setDomain=function(l){this._domainModificationInProgress||(this._domainModificationInProgress=!0,this._backingScaleDomain(l),this._dispatchUpdate(),this._domainModificationInProgress=!1)};t.prototype._backingScaleDomain=function(){throw Error("Subclasses should override _backingDomain");};t.prototype.range=function(l){if(null==l)return this._getRange();
this._setRange(l);return this};t.prototype._getRange=function(){throw Error("Subclasses should override _getRange");};t.prototype._setRange=function(){throw Error("Subclasses should override _setRange");};t.prototype.addIncludedValuesProvider=function(l){this._includedValuesProviders.add(l);this._autoDomainIfAutomaticMode();return this};t.prototype.removeIncludedValuesProvider=function(l){this._includedValuesProviders.delete(l);this._autoDomainIfAutomaticMode()};t.prototype.updateId=function(){return this._updateId};
return t}();f.Scale=d},function(d,f,h){function k(q,u,x,A){for(var y={},w=0;w<u.length;w++){var C=u[w];q.hasOwnProperty(C)&&(y[C]=q[C](x,A))}return y}function t(q){return(null!=q["stroke-opacity"]?parseFloat(q["stroke-opacity"]):1)*(null!=q.opacity?parseFloat(q.opacity):1)}function l(q){return(null!=q["fill-opacity"]?parseFloat(q["fill-opacity"]):1)*(null!=q.opacity?parseFloat(q.opacity):1)}function p(q){return null!=q["stroke-width"]?parseFloat(q["stroke-width"]):1}function m(q,u){if(u.stroke){q.lineWidth=
p(u);var x=n.color(u.stroke);x.opacity*=t(u);q.strokeStyle=x.toString();q.stroke()}u.fill&&(x=n.color(u.fill),x.opacity*=l(u),q.fillStyle=x.toString(),q.fill())}var n=h(1);d=function(){function q(u,x){this._context=u;this._drawStep=x}q.prototype.getDrawStep=function(){return this._drawStep};q.prototype.draw=function(u,x){x=x[x.length-1].attrToAppliedProjector;this._context.save();this._drawStep(this._context,u,x);this._context.restore()};q.prototype.getVisualPrimitives=function(){return[]};q.prototype.getVisualPrimitiveAtIndex=
function(){return null};q.prototype.remove=function(){};return q}();f.CanvasDrawer=d;f.ContextStyleAttrs="fill-opacity fill opacity stroke-opacity stroke-width stroke".split(" ");f.resolveAttributesSubsetWithStyles=function(q,u,x,A){return k(q,f.ContextStyleAttrs.concat(u),x,A)};f.resolveAttributes=k;f.getStrokeWidth=p;f.renderArea=function(q,u,x,A){q.save();q.beginPath();u.context(q);u(x);q.lineJoin="round";m(q,A);q.restore()};f.renderLine=function(q,u,x,A){q.save();q.beginPath();u.context(q);u(x);
q.lineJoin="round";m(q,A);q.restore()};f.renderPathWithStyle=m},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(50));k(h(27));k(h(51));k(h(93));k(h(53));k(h(94));k(h(95));k(h(96));k(h(97));k(h(98));k(h(99));k(h(100))},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(92));k(h(91));d=h(49);f.sign=d.sign},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(134));k(h(135));k(h(136));k(h(137))},function(d,
f,h){var k=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&(n[x]=q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},t=h(1),l=h(5);d=h(4);var p=h(8),m=h(0);h=h(10);f.AxisOrientation=h.makeEnum(["bottom","left","right","top"]);h=function(n){function q(u,x){var A=n.call(this)||this;A._endTickLength=5;A._innerTickLength=5;A._tickLabelPadding=10;A._margin=15;A._showEndTickLabels=!1;A._annotationsEnabled=!1;A._annotationTierCount=
1;if(null==u||null==x)throw Error("Axis requires a scale and orientation");A._scale=u;A.orientation(x);A._setDefaultAlignment();A.addClass("axis");A.isHorizontal()?A.addClass("x-axis"):A.addClass("y-axis");A.formatter(p.identity());A._rescaleCallback=function(){return A._rescale()};A._scale.onUpdate(A._rescaleCallback);A._annotatedTicks=[];A._annotationFormatter=p.identity();return A}k(q,n);q.prototype.destroy=function(){n.prototype.destroy.call(this);this._scale.offUpdate(this._rescaleCallback)};
q.prototype.tickLabelDataOnElement=function(u){if(null!=u){for(var x;null!=u&&u.classList&&void 0===x;)u.classList.contains(q.TICK_LABEL_CLASS)?x=u:u=u.parentNode;return void 0===u?void 0:t.select(u).datum()}};q.prototype._computeWidth=function(){return this._maxLabelTickLength()};q.prototype._computeHeight=function(){return this._maxLabelTickLength()};q.prototype.requestedSpace=function(){var u=0,x=0;if(this.isHorizontal()){if(x=this._computeHeight()+this._margin,this.annotationsEnabled()){var A=
this._annotationMeasurer.measure().height+2*q._ANNOTATION_LABEL_PADDING;x+=A*this.annotationTierCount()}}else u=this._computeWidth()+this._margin,this.annotationsEnabled()&&(A=this._annotationMeasurer.measure().height+2*q._ANNOTATION_LABEL_PADDING,u+=A*this.annotationTierCount());return{minWidth:u,minHeight:x}};q.prototype.fixedHeight=function(){return this.isHorizontal()};q.prototype.fixedWidth=function(){return!this.isHorizontal()};q.prototype._rescale=function(){this.render()};q.prototype.computeLayout=
function(u,x,A){n.prototype.computeLayout.call(this,u,x,A);this.isHorizontal()?this._scale.range([0,this.width()]):this._scale.range([this.height(),0]);return this};q.prototype._sizeFromOffer=function(u,x){var A=this.requestedSpace(u,x);return this.isHorizontal()?{width:u,height:A.minHeight}:{height:x,width:A.minWidth}};q.prototype._setup=function(){n.prototype._setup.call(this);this._tickMarkContainer=this.content().append("g").classed(q.TICK_MARK_CLASS+"-container",!0);this._tickLabelContainer=
this.content().append("g").classed(q.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 u=this._annotationContainer.append("g").classed("annotation-label-container",
!0);u=new l.SvgContext(u.node());this._annotationMeasurer=new l.CacheMeasurer(u);this._annotationWriter=new l.Writer(this._annotationMeasurer,u)};q.prototype._getTickValues=function(){return[]};q.prototype.renderImmediately=function(){var u=this._getTickValues(),x=this._tickMarkContainer.selectAll("."+q.TICK_MARK_CLASS).data(u),A=x.enter().append("line").classed(q.TICK_MARK_CLASS,!0).merge(x);A.attrs(this._generateTickMarkAttrHash());t.select(A.nodes()[0]).classed(q.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0));
t.select(A.nodes()[u.length-1]).classed(q.END_TICK_MARK_CLASS,!0).attrs(this._generateTickMarkAttrHash(!0));x.exit().remove();this._baseline.attrs(this._generateBaselineAttrHash());this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations();return this};q.prototype.annotatedTicks=function(){return this._annotatedTicks};q.prototype.annotationFormatter=function(u){if(null==u)return this._annotationFormatter;this._annotationFormatter=u;this.render();return this};q.prototype.annotationsEnabled=
function(){return this._annotationsEnabled};q.prototype.annotationTierCount=function(){return this._annotationTierCount};q.prototype._drawAnnotations=function(){function u(aa){switch(C.orientation()){case "bottom":case "right":return y(aa);case "top":case "left":return y(aa)-D.get(aa).height}}function x(aa){return O.has(aa)?"hidden":"visible"}function A(aa){return C._scale.scale(aa)}function y(aa){switch(C.orientation()){case "bottom":case "right":return N.get(aa)*I+K;case "top":case "left":return H-
K-N.get(aa)*I}}function w(aa,la,Z){aa=aa.selectAll("."+Z).data(B);la=aa.enter().append(la).classed(Z,!0).merge(aa);aa.exit().remove();return la}var C=this,G=q._ANNOTATION_LABEL_PADDING,D=new m.Map,B=this._annotatedTicksToRender();B.forEach(function(aa){var la=C._annotationMeasurer.measure(C.annotationFormatter()(aa));D.set(aa,{width:la.width+2*G,height:la.height+2*G})});var I=this._annotationMeasurer.measure().height+2*G,N=this._annotationToTier(D),O=new m.Set,H=this.isHorizontal()?this.height():
this.width(),K=this._coreSize(),M=Math.min(this.annotationTierCount(),Math.floor((H-K)/I));N.forEach(function(aa,la){(-1===aa||aa>=M)&&O.add(la)});switch(this.orientation()){case "bottom":case "right":var L=0;break;case "top":L=this.height();break;case "left":L=this.width()}var Q=this.isHorizontal();w(this._annotationContainer.select(".annotation-line-container"),"line",q.ANNOTATION_LINE_CLASS).attrs({x1:Q?A:L,x2:Q?A:y,y1:Q?L:A,y2:Q?y:A,visibility:x});w(this._annotationContainer.select(".annotation-circle-container"),
"circle",q.ANNOTATION_CIRCLE_CLASS).attrs({cx:Q?A:L,cy:Q?L:A,r:3});w(this._annotationContainer.select(".annotation-rect-container"),"rect",q.ANNOTATION_RECT_CLASS).attrs({x:Q?A:u,y:Q?u:A,width:Q?function(aa){return D.get(aa).width}:function(aa){return D.get(aa).height},height:Q?function(aa){return D.get(aa).height}:function(aa){return D.get(aa).width},visibility:x});var T=this._annotationWriter,X=this.annotationFormatter();L=w(this._annotationContainer.select(".annotation-label-container"),"g",q.ANNOTATION_LABEL_CLASS);
L.selectAll(".text-container").remove();L.attrs({transform:function(aa){var la=Q?A(aa):u(aa);aa=Q?u(aa):A(aa);return"translate("+la+","+aa+")"},visibility:x}).each(function(aa){T.write(X(aa),Q?D.get(aa).width:D.get(aa).height,Q?D.get(aa).height:D.get(aa).width,{xAlign:"center",yAlign:"center",textRotation:Q?0:90},t.select(this).node())})};q.prototype._annotatedTicksToRender=function(){var u=this,x=this._scale.range();return m.Array.uniq(this.annotatedTicks().filter(function(A){return null==A?!1:m.Math.inRange(u._scale.scale(A),
x[0],x[1])}))};q.prototype._coreSize=function(){var u=this.isHorizontal()?this.height():this.width(),x=this.isHorizontal()?this._computeHeight():this._computeWidth();return Math.min(x,u)};q.prototype._annotationTierHeight=function(){return this._annotationMeasurer.measure().height+2*q._ANNOTATION_LABEL_PADDING};q.prototype._annotationToTier=function(u){var x=this,A=[[]],y=new m.Map,w=this.isHorizontal()?this.width():this.height();this._annotatedTicksToRender().forEach(function(C){var G=x._scale.scale(C),
D=u.get(C).width;if(0>G||G+D>w)y.set(C,-1);else{for(var B=function(N){return A[N].some(function(O){var H=x._scale.scale(O);O=u.get(O).width;return G+D>=H&&G<=H+O})},I=0;B(I);)I++,A.length===I&&A.push([]);A[I].push(C);y.set(C,I)}});return y};q.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()};
q.prototype._generateBaselineAttrHash=function(){var u={x1:0,y1:0,x2:0,y2:0};switch(this._orientation){case "bottom":u.x2=this.width();break;case "top":u.x2=this.width();u.y1=this.height();u.y2=this.height();break;case "left":u.x1=this.width();u.x2=this.width();u.y2=this.height();break;case "right":u.y2=this.height()}return u};q.prototype._generateTickMarkAttrHash=function(u){function x(w){return A._scale.scale(w)}var A=this;void 0===u&&(u=!1);var y={x1:0,y1:0,x2:0,y2:0};this.isHorizontal()?(y.x1=
x,y.x2=x):(y.y1=x,y.y2=x);u=u?this._endTickLength:this._innerTickLength;switch(this._orientation){case "bottom":y.y2=u;break;case "top":y.y1=this.height();y.y2=this.height()-u;break;case "left":y.x1=this.width();y.x2=this.width()-u;break;case "right":y.x2=u}return y};q.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")}};
q.prototype.isHorizontal=function(){return"top"===this._orientation||"bottom"===this._orientation};q.prototype.getScale=function(){return this._scale};q.prototype.formatter=function(u){if(null==u)return this._formatter;this._formatter=u;this.redraw();return this};q.prototype.innerTickLength=function(){return this._innerTickLength};q.prototype.endTickLength=function(){return this._endTickLength};q.prototype._maxLabelTickLength=function(){return this.showEndTickLabels()?Math.max(this.innerTickLength(),
this.endTickLength()):this.innerTickLength()};q.prototype.tickLabelPadding=function(u){if(null==u)return this._tickLabelPadding;if(0>u)throw Error("tick label padding must be positive");this._tickLabelPadding=u;this.redraw();return this};q.prototype.margin=function(u){if(null==u)return this._margin;if(0>u)throw Error("margin size must be positive");this._margin=u;this.redraw();return this};q.prototype.orientation=function(u){if(null==u)return this._orientation;u=u.toLowerCase();if("top"!==u&&"bottom"!==
u&&"left"!==u&&"right"!==u)throw Error("unsupported orientation");this._orientation=u;this.redraw();return this};q.prototype.showEndTickLabels=function(){return this._showEndTickLabels};q.prototype._showAllTickMarks=function(){this._tickMarkContainer.selectAll("."+q.TICK_MARK_CLASS).each(function(){t.select(this).style("visibility","inherit")})};q.prototype._showAllTickLabels=function(){this._tickLabelContainer.selectAll("."+q.TICK_LABEL_CLASS).each(function(){t.select(this).style("visibility","inherit")})};
q.prototype._hideOverflowingTickLabels=function(){var u=this.element().node().getBoundingClientRect(),x=this._tickLabelContainer.selectAll("."+q.TICK_LABEL_CLASS);x.empty()||x.each(function(){m.DOM.clientRectInside(this.getBoundingClientRect(),u)||t.select(this).style("visibility","hidden")})};q.prototype._hideTickMarksWithoutLabel=function(){var u=this._tickMarkContainer.selectAll("."+q.TICK_MARK_CLASS),x=this._tickLabelContainer.selectAll("."+q.TICK_LABEL_CLASS).filter(function(){var A=t.select(this).style("visibility");
return"inherit"===A||"visible"===A}).data();u.each(function(A){-1===x.indexOf(A)&&t.select(this).style("visibility","hidden")})};q.prototype.invalidateCache=function(){n.prototype.invalidateCache.call(this);this._annotationMeasurer.reset()};return q}(d.Component);h.END_TICK_MARK_CLASS="end-tick-mark";h.TICK_MARK_CLASS="tick-mark";h.TICK_LABEL_CLASS="tick-label";h.ANNOTATION_LINE_CLASS="annotation-line";h.ANNOTATION_RECT_CLASS="annotation-rect";h.ANNOTATION_CIRCLE_CLASS="annotation-circle";h.ANNOTATION_LABEL_CLASS=
"annotation-label";h._ANNOTATION_LABEL_PADDING=4;f.Axis=h},function(d,f){f.SHOW_WARNINGS=!0;f.ADD_TITLE_ELEMENTS=!0},function(d,f,h){var k=h(0);d=function(){function t(){this._eventToProcessingFunction={};this._eventTarget=document;this._eventNameToCallbackSet={};this._connected=!1}t.prototype._hasNoCallbacks=function(){for(var l=Object.keys(this._eventNameToCallbackSet),p=0;p<l.length;p++)if(0!==this._eventNameToCallbackSet[l[p]].size)return!1;return!0};t.prototype._connect=function(){var l=this;
this._connected||(Object.keys(this._eventToProcessingFunction).forEach(function(p){l._eventTarget.addEventListener(p,l._eventToProcessingFunction[p])}),this._connected=!0)};t.prototype._disconnect=function(){var l=this;this._connected&&this._hasNoCallbacks()&&(Object.keys(this._eventToProcessingFunction).forEach(function(p){l._eventTarget.removeEventListener(p,l._eventToProcessingFunction[p])}),this._connected=!1)};t.prototype._addCallbackForEvent=function(l,p){null==this._eventNameToCallbackSet[l]&&
(this._eventNameToCallbackSet[l]=new k.CallbackSet);this._eventNameToCallbackSet[l].add(p);this._connect()};t.prototype._removeCallbackForEvent=function(l,p){null!=this._eventNameToCallbackSet[l]&&this._eventNameToCallbackSet[l].delete(p);this._disconnect()};t.prototype._callCallbacksForEvent=function(l){for(var p=[],m=1;m<arguments.length;m++)p[m-1]=arguments[m];m=this._eventNameToCallbackSet[l];null!=m&&m.callCallbacks.apply(m,p)};return t}();f.Dispatcher=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||
(f[l]=t[l])}k(h(87));k(h(88));k(h(40));k(h(89));k(h(90));d=h(26);f.zoomOut=d.zoomOut},function(d,f){function h(n,q,u){return u-(u-n)*q}function k(n,q,u){return(n*q-u)/(q-1)}function t(n,q,u,x){var A=1<q;u=A?x:u;if(null==u)return q;n=n.getTransformationDomain();return(A?Math.min:Math.max)(q,u/Math.abs(n[1]-n[0]))}function l(n,q,u,x,A){if(1>=q)return{centerPoint:u,zoomAmount:q};if(null==x&&null==A)return{centerPoint:u,zoomAmount:q};var y=p(n),w=m(n),C=w?Infinity:-Infinity;w=w?-Infinity:Infinity;x=null==
x?C:x;A=null==A?w:A;w=n.getTransformationDomain();C=w[0];w=w[1];A=n.scaleTransformation(A);w=n.scaleTransformation(w);var G=h(w,q,u);x=n.scaleTransformation(x);n=n.scaleTransformation(C);C=h(n,q,u);return Math.abs(G-C)>Math.abs(A-x)?(q=(A-x)/(w-n),1!==q?{centerPoint:k(w,q,A),zoomAmount:q}:{centerPoint:u,zoomAmount:q}):G>A!=y?{centerPoint:k(w,q,A),zoomAmount:q}:C<x!=y?{centerPoint:k(n,q,x),zoomAmount:q}:{centerPoint:u,zoomAmount:q}}function p(n){n=n.range();return n[1]<n[0]}function m(n){n=n.getTransformationDomain();
return n[1]<n[0]}f.zoomOut=h;f.constrainedZoom=function(n,q,u,x,A,y,w){q=t(n,q,x,A);return l(n,q,u,y,w)};f.constrainZoomExtents=t;f.constrainZoomValues=l;f.constrainedTranslation=function(n,q,u,x){var A=n.getTransformationDomain(),y=A[0],w=A[1];A=p(n);0<q!==A?(u=x,null!=u&&(y=n.scaleTransformation(w),n=n.scaleTransformation(u),q=(A?Math.max:Math.min)(y+q,n)-y)):null!=u&&(y=n.scaleTransformation(y),n=n.scaleTransformation(u),q=(A?Math.min:Math.max)(y+q,n)-y);return q}},function(d,f,h){function k(I,
N,O){var H=I.scale;if(H instanceof y.Category)O=H.rangeBand();else{var K=I.accessor;I=l.set(C.Array.flatten(N.map(function(M){return M.data().map(function(L,Q){return K(L,Q,M)}).filter(function(L){return null!=L}).map(function(L){return L.valueOf()})}))).values().map(function(M){return+M});I.sort(function(M,L){return M-L});I=I.map(function(M){return H.scale(M)});I=l.pairs(I);O=C.Math.min(I,function(M){return Math.abs(M[1]-M[0])},O*B._SINGLE_BAR_DIMENSION_RATIO);O*=B._BAR_THICKNESS_RATIO}return O}
var t=this&&this.__extends||function(I,N){function O(){this.constructor=I}for(var H in N)N.hasOwnProperty(H)&&(I[H]=N[H]);I.prototype=null===N?Object.create(N):(O.prototype=N.prototype,new O)},l=h(1),p=h(5),m=h(7),n=h(8),q=h(14),u=h(6),x=h(34),A=h(20),y=h(3),w=h(11),C=h(0);d=h(10);var G=h(19),D=h(2);h=h(16);f.BarOrientation=d.makeEnum(["vertical","horizontal"]);f.LabelsPosition=d.makeEnum(["start","middle","end","outside"]);f.BarAlignment=d.makeEnum(["start","middle","end"]);var B=function(I){function N(O){void 0===
O&&(O="vertical");var H=I.call(this)||this;H._labelFormatter=n.identity();H._labelsEnabled=!1;H._labelsPosition=f.LabelsPosition.end;H._hideBarsIfAnyAreTooWide=!0;H._barAlignment="middle";H._computeBarPixelThickness=A.memoize(k);H._fixedBarPixelThickness=!0;H.addClass("bar-plot");if("vertical"!==O&&"horizontal"!==O)throw Error(O+" is not a valid orientation for Plots.Bar");H._isVertical="vertical"===O;H.animator("baseline",new m.Null);H.attr("fill",(new y.Color).range()[0]);H.attr(N._BAR_THICKNESS_KEY,
function(){return H._barPixelThickness()});H._labelConfig=new C.Map;H._baselineValueProvider=function(){return[H.baselineValue()]};return H}t(N,I);N.prototype.computeLayout=function(O,H,K){I.prototype.computeLayout.call(this,O,H,K);this._updateExtents();return this};N.prototype.x=function(O,H){if(null==O)return I.prototype.x.call(this);null==H?I.prototype.x.call(this,O):I.prototype.x.call(this,O,H);this._updateThicknessAttr();this._updateLengthScale();return this};N.prototype.y=function(O,H){if(null==
O)return I.prototype.y.call(this);null==H?I.prototype.y.call(this,O):I.prototype.y.call(this,O,H);this._updateLengthScale();return this};N.prototype.length=function(){return this._isVertical?this.y():this.x()};N.prototype.position=function(){return this._isVertical?this.x():this.y()};N.prototype.barEnd=function(){return this._propertyBindings.get(N._BAR_END_KEY)};N.prototype.barAlignment=function(O){if(null==O)return this._barAlignment;this._barAlignment=O;this._clearAttrToProjectorCache();this.render();
return this};N.prototype.orientation=function(){return this._isVertical?"vertical":"horizontal"};N.prototype._createDrawer=function(){return new u.ProxyDrawer(function(){return new x.RectangleSVGDrawer(N._BAR_AREA_CLASS)},function(O){return new q.RectangleCanvasDrawer(O)})};N.prototype._setup=function(){I.prototype._setup.call(this);this._baseline=this._renderArea.append("line").classed("baseline",!0)};N.prototype.baselineValue=function(){if(null!=this._baselineValue)return this._baselineValue;if(!this._projectorsReady())return 0;
var O=this.length().scale;return O?O instanceof y.Time?new Date(0):0:0};N.prototype.addDataset=function(O){I.prototype.addDataset.call(this,O)};N.prototype._addDataset=function(O){I.prototype._addDataset.call(this,O);return this};N.prototype.removeDataset=function(O){I.prototype.removeDataset.call(this,O)};N.prototype._removeDataset=function(O){I.prototype._removeDataset.call(this,O);return this};N.prototype.datasets=function(O){if(null==O)return I.prototype.datasets.call(this);I.prototype.datasets.call(this,
O);return this};N.prototype.labelsEnabled=function(O,H){if(null==O)return this._labelsEnabled;this._labelsEnabled=O;null!=H&&(this._labelsPosition=H);this._clearAttrToProjectorCache();this.render();return this};N.prototype.labelFormatter=function(O){if(null==O)return this._labelFormatter;this._labelFormatter=O;this._clearAttrToProjectorCache();this.render();return this};N.prototype._createNodesForDataset=function(O){var H=I.prototype._createNodesForDataset.call(this,O),K=this._renderArea.append("g").classed(N._LABEL_AREA_CLASS,
!0),M=new p.SvgContext(K.node()),L=new p.CacheMeasurer(M);M=new p.Writer(L,M);this._labelConfig.set(O,{labelArea:K,measurer:L,writer:M});return H};N.prototype._removeDatasetNodes=function(O){I.prototype._removeDatasetNodes.call(this,O);var H=this._labelConfig.get(O);null!=H&&(H.labelArea.remove(),this._labelConfig.delete(O))};N.prototype.entityNearest=function(O){var H=this;return this._computeBarPixelThickness.doLocked(function(){function K(ca,ka,Y,Ea){return H._pixelPointBar(aa(ca,ka,Y),la,Ea)}
var M=H._isVertical?O.x:O.y,L=H._isVertical?O.y:O.x,Q=H.bounds(),T={min:0,max:Q.bottomRight.x-Q.topLeft.x},X={min:0,max:Q.bottomRight.y-Q.topLeft.y},aa=D.Plot._scaledAccessor(H.length()),la=H.length().scale.scale(H.baselineValue()),Z=Infinity,ba=Infinity,ea;H._getEntityStore().entities().forEach(function(ca){var ka=H._entityBounds(ca);if(C.DOM.intersectsBBox(T,X,ka)){var Y=0,Ea=0;if(!C.DOM.intersectsBBox(O.x,O.y,ka,.5)){Ea=K(ca.datum,ca.index,ca.dataset,ka);Y=Math.abs(M-(H._isVertical?Ea.x:Ea.y));
var va=H._isVertical?ka.y:ka.x;ka=va+(H._isVertical?ka.height:ka.width);Ea=L>=va-.5&&L<=ka+.5?0:Math.abs(L-(H._isVertical?Ea.y:Ea.x))}if(Y<Z||Y===Z&&Ea<ba)ea=ca,Z=Y,ba=Ea}});if(void 0!==ea)return H._lightweightPlotEntityToPlotEntity(ea)})};N.prototype.entitiesAt=function(O){return this._entitiesIntersecting(O.x,O.y)};N.prototype._entitiesIntersecting=function(O,H){var K=this,M=[];this._getEntityStore().entities().forEach(function(L){C.DOM.intersectsBBox(O,H,K._entityBounds(L))&&M.push(K._lightweightPlotEntityToPlotEntity(L))});
return M};N.prototype._updateLengthScale=function(){if(this._projectorsReady()){var O=this.length().scale;O instanceof w.QuantitativeScale&&(O.addPaddingExceptionsProvider(this._baselineValueProvider),O.addIncludedValuesProvider(this._baselineValueProvider))}};N.prototype.renderImmediately=function(){var O=this;this._barPixelThickness();return this._computeBarPixelThickness.doLocked(function(){return I.prototype.renderImmediately.call(O)})};N.prototype._additionalPaint=function(O){var H=this,K=this.length().scale.scale(this.baselineValue());
K={x1:this._isVertical?0:K,y1:this._isVertical?K:0,x2:this._isVertical?this.width():K,y2:this._isVertical?K:this.height()};this._getAnimator("baseline").animate(this._baseline,K);this.datasets().forEach(function(M){return H._labelConfig.get(M).labelArea.selectAll("g").remove()});this._labelsEnabled&&C.Window.setTimeout(function(){return H._drawLabels()},O)};N.prototype.getExtentsForProperty=function(O){var H=this,K=I.prototype.getExtentsForProperty.call(this,O);if("x"===O&&this._isVertical)O=this.x();
else{if("y"!==O||this._isVertical)return K;O=this.y()}if(!(O&&O.scale&&O.scale instanceof w.QuantitativeScale))return K;var M=O.scale,L=this._barPixelThickness();return K=K.map(function(Q){return l.extent([M.invert(H._getPositionAttr(M.scale(Q[0]),L)),M.invert(H._getPositionAttr(M.scale(Q[0]),L)+L),M.invert(H._getPositionAttr(M.scale(Q[1]),L)),M.invert(H._getPositionAttr(M.scale(Q[1]),L)+L)])})};N.prototype._getPositionAttr=function(O,H){this._isVertical||(O-=H,H*=-1);switch(this._barAlignment){case "start":return O;
case "end":return O-H;default:return O-H/2}};N.prototype._drawLabels=function(){var O=this,H=this._getDataToDraw(),K=this._getAttrToProjector(),M=this.datasets().some(function(L){return H.get(L).some(function(Q,T){return null==Q?!1:O._drawLabel(Q,T,L,K)})});this._hideBarsIfAnyAreTooWide&&M&&this.datasets().forEach(function(L){return O._labelConfig.get(L).labelArea.selectAll("g").remove()})};N.prototype._drawLabel=function(O,H,K,M){var L=this._labelConfig.get(K),Q=L.labelArea,T=L.measurer;L=L.writer;
var X=this.length().accessor,aa=X(O,H,K);X=this.length().scale;var la=null!=X?X.scale(aa):aa,Z=null!=X?X.scale(this.baselineValue()):this.baselineValue(),ba={x:M.x(O,H,K),y:M.y(O,H,K)};X={width:M.width(O,H,K),height:M.height(O,H,K)};aa=this._labelFormatter(aa,O,H,K);T=T.measure(aa);var ea=this._shouldShowLabelOnBar(ba,X,T);ba=this._calculateLabelProperties(ba,X,T,ea,this._isVertical?la<=Z:la<Z);la=ba.containerDimensions;Z=ba.labelContainerOrigin;ba=ba.alignment;O=M.fill(O,H,K);Q=this._createLabelContainer(Q,
Z,ea,O);L.write(aa,la.width,la.height,{xAlign:ba.x,yAlign:ba.y},Q.node());return this._isVertical?X.width<T.width:X.height<T.height};N.prototype._shouldShowLabelOnBar=function(O,H,K){if(this._labelsPosition===f.LabelsPosition.outside)return!1;O=this._isVertical?O.y:O.x;var M=this._isVertical?H.height:H.width;H=this._isVertical?this.height():this.width();K=this._isVertical?K.height:K.width;var L=O+M;L>H?M=H-O:0>O&&(M=L);return K+N._LABEL_MARGIN_INSIDE_BAR<=M};N.prototype._calculateLabelProperties=
function(O,H,K,M,L){function Q(ka){switch(ka){case "topLeft":Z=T._isVertical?"top":"left";ea+=N._LABEL_MARGIN_INSIDE_BAR;ca+=N._LABEL_MARGIN_INSIDE_BAR;break;case "center":ca+=(aa+la)/2;break;case "bottomRight":Z=T._isVertical?"bottom":"right",ea-=N._LABEL_MARGIN_INSIDE_BAR,ca+=ba-N._LABEL_MARGIN_INSIDE_BAR-la}}var T=this,X=this._isVertical?O.y:O.x,aa=this._isVertical?H.height:H.width,la=this._isVertical?K.height:K.width,Z="center",ba=aa,ea=X,ca=X;if(M)switch(this._labelsPosition){case f.LabelsPosition.start:L?
Q("bottomRight"):Q("topLeft");break;case f.LabelsPosition.middle:Q("center");break;case f.LabelsPosition.end:L?Q("topLeft"):Q("bottomRight")}else L?(Z=this._isVertical?"top":"left",ba=aa+N._LABEL_MARGIN_INSIDE_BAR+la,ea-=N._LABEL_MARGIN_INSIDE_BAR+la,ca-=N._LABEL_MARGIN_INSIDE_BAR+la):(Z=this._isVertical?"bottom":"right",ba=aa+N._LABEL_MARGIN_INSIDE_BAR+la,ca+=aa+N._LABEL_MARGIN_INSIDE_BAR);return{containerDimensions:{width:this._isVertical?H.width:ba,height:this._isVertical?ba:H.height},labelContainerOrigin:{x:this._isVertical?
O.x:ea,y:this._isVertical?ea:O.y},labelOrigin:{x:this._isVertical?O.x+H.width/2-K.width/2:ca,y:this._isVertical?ca:O.y+H.height/2-K.height/2},alignment:{x:this._isVertical?"center":Z,y:this._isVertical?Z:"center"}}};N.prototype._createLabelContainer=function(O,H,K,M){O=O.append("g").attr("transform","translate("+H.x+", "+H.y+")");K?(O.classed("on-bar-label",!0),K=1.6*C.Color.contrast("white",M)<C.Color.contrast("black",M),O.classed(K?"dark-label":"light-label",!0)):O.classed("off-bar-label",!0);return O};
N.prototype._generateDrawSteps=function(){var O=[];if(this._animateOnNextRender()){var H=this._getAttrToProjector(),K=this.length().scale.scale(this.baselineValue()),M=this._isVertical?"height":"width";H[this._isVertical?"y":"x"]=function(){return K};H[M]=function(){return 0};O.push({attrToProjector:H,animator:this._getAnimator(G.Animator.RESET)})}O.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(G.Animator.MAIN)});return O};N.prototype._generateAttrToProjector=function(){function O(ba,
ea,ca){return Math.abs(M-X(ba,ea,ca))}var H=this,K=I.prototype._generateAttrToProjector.call(this),M=this.length().scale.scale(this.baselineValue()),L=this._isVertical?"y":"x",Q=this._isVertical?"x":"y",T=D.Plot._scaledAccessor(this.position()),X=D.Plot._scaledAccessor(this.length()),aa=K[N._BAR_THICKNESS_KEY],la=K.gap,Z=null==la?aa:function(ba,ea,ca){return aa(ba,ea,ca)-la(ba,ea,ca)};K.width=this._isVertical?Z:O;K.height=this._isVertical?O:Z;K[L]=function(ba,ea,ca){ba=X(ba,ea,ca);return ba>M?M:ba};
K[Q]=function(ba,ea,ca){return H._getPositionAttr(T(ba,ea,ca),aa(ba,ea,ca))};return K};N.prototype._updateThicknessAttr=function(){var O=this,H=this.position(),K=this.barEnd();null!=H&&null!=K?(this._fixedBarPixelThickness=!1,this.attr(N._BAR_THICKNESS_KEY,function(M,L,Q){var T=H.accessor(M,L,Q);M=K.accessor(M,L,Q);T=H.scale?H.scale.scale(T):T;M=K.scale?K.scale.scale(M):M;return Math.abs(M-T)})):(this._fixedBarPixelThickness=!0,this.attr(N._BAR_THICKNESS_KEY,function(){return O._barPixelThickness()}))};
N.prototype._barPixelThickness=function(){return this._fixedBarPixelThickness?this._projectorsReady()?this._computeBarPixelThickness(this.position(),this.datasets(),this._isVertical?this.width():this.height()):0:0};N.prototype.entities=function(O){void 0===O&&(O=this.datasets());return this._projectorsReady()?I.prototype.entities.call(this,O):[]};N.prototype._entityBounds=function(O){return this._pixelBounds(O.datum,O.index,O.dataset)};N.prototype._pixelBounds=function(O,H,K){var M=this._getAttrToProjector();
return{x:M.x(O,H,K),y:M.y(O,H,K),width:M.width(O,H,K),height:M.height(O,H,K)}};N.prototype._pixelPoint=function(O,H,K){var M=this._pixelBounds(O,H,K);O=(this._isVertical?D.Plot._scaledAccessor(this.y()):D.Plot._scaledAccessor(this.x()))(O,H,K);H=(this._isVertical?this.y().scale:this.x().scale).scale(this.baselineValue());return this._pixelPointBar(O,H,M)};N.prototype._pixelPointBar=function(O,H,K){if(this._isVertical){var M=K.x+K.width/2;O=O<=H?K.y:K.y+K.height}else M=O>=H?K.x+K.width:K.x,O=K.y+K.height/
2;return{x:M,y:O}};N.prototype._uninstallScaleForKey=function(O,H){I.prototype._uninstallScaleForKey.call(this,O,H)};N.prototype._getDataToDraw=function(){var O=this,H=new C.Map,K=this._getAttrToProjector(),M=this.width(),L=this.height();this.datasets().forEach(function(Q){var T=Q.data().map(function(X,aa){return O._isDatumOnScreen(K,M,L,X,aa,Q)?X:null});H.set(Q,T)});return H};N.prototype._isDatumOnScreen=function(O,H,K,M,L,Q){var T=O.x(M,L,Q),X=O.y(M,L,Q),aa=O.width(M,L,Q);O=O.height(M,L,Q);return C.Math.isValidNumber(T)&&
C.Math.isValidNumber(X)&&C.Math.isValidNumber(aa)&&C.Math.isValidNumber(O)?C.Math.boundsIntersects(T,X,aa,O,H,K):!1};return N}(h.XYPlot);B._BAR_THICKNESS_RATIO=.95;B._SINGLE_BAR_DIMENSION_RATIO=.4;B._BAR_AREA_CLASS="bar-area";B._BAR_END_KEY="barEnd";B._BAR_THICKNESS_KEY="width";B._LABEL_AREA_CLASS="bar-label-text-area";B._LABEL_MARGIN_INSIDE_BAR=10;f.Bar=B},function(d,f,h){var k=this&&this.__extends||function(x,A){function y(){this.constructor=x}for(var w in A)A.hasOwnProperty(w)&&(x[w]=A[w]);x.prototype=
null===A?Object.create(A):(y.prototype=A.prototype,new y)},t=h(1),l=h(5),p=h(8),m=h(3),n=h(0);d=h(10);var q=h(22);f.TimeInterval=d.makeEnum("second minute hour day week month year".split(" "));f.TimeAxisOrientation=d.makeEnum(["top","bottom"]);f.TierLabelPosition=d.makeEnum(["between","center"]);h=function(x){function A(y,w){y=x.call(this,y,w)||this;y._maxTimeIntervalPrecision=null;y._tierLabelPositions=[];y.addClass("time-axis");y.tickLabelPadding(5);y.axisConfigurations(A._DEFAULT_TIME_AXIS_CONFIGURATIONS);
y.annotationFormatter(p.time("%a %b %d, %Y"));return y}k(A,x);A.prototype.tierLabelPositions=function(y){if(null==y)return this._tierLabelPositions;if(!y.every(function(w){return"between"===w.toLowerCase()||"center"===w.toLowerCase()}))throw Error("Unsupported position for tier labels");this._tierLabelPositions=y;this.redraw();return this};A.prototype.maxTimeIntervalPrecision=function(y){if(null==y)return this._maxTimeIntervalPrecision;this._maxTimeIntervalPrecision=y;this.redraw();return this};A.prototype.currentAxisConfiguration=
function(){return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex]};A.prototype.axisConfigurations=function(y){if(null!=y){this._possibleTimeAxisConfigurations=y;this._numTiers=n.Math.max(this._possibleTimeAxisConfigurations.map(function(G){return G.length}),0);this._isAnchored&&this._setupDomElements();y=this.tierLabelPositions();for(var w=[],C=0;C<this._numTiers;C++)w.push(y[C]||"between");this.tierLabelPositions(w);this.redraw()}};A.prototype._getMostPreciseConfigurationIndex=
function(){var y=this,w=this._possibleTimeAxisConfigurations.length;this._possibleTimeAxisConfigurations.forEach(function(C,G){G<w&&C.every(function(D){return y._checkTimeAxisTierConfiguration(D)})&&(w=G)});w===this._possibleTimeAxisConfigurations.length&&(n.Window.warn("zoomed out too far: could not find suitable interval to display labels"),--w);return w};A.prototype.orientation=function(y){if(y&&("right"===y.toLowerCase()||"left"===y.toLowerCase()))throw Error(y+" is not a supported orientation for TimeAxis - only horizontal orientations are supported");
return x.prototype.orientation.call(this,y)};A.prototype._computeHeight=function(){var y=this._measurer.measure().height;this._tierHeights=[];for(var w=0;w<this._numTiers;w++)this._tierHeights.push(y+this.tickLabelPadding()+("between"===this._tierLabelPositions[w]?0:this._maxLabelTickLength()));return t.sum(this._tierHeights)};A.prototype._getIntervalLength=function(y){var w=this._scale.domain()[0];y=m.Time.timeIntervalToD3Time(y.interval).offset(w,y.step);return y>this._scale.domain()[1]?this.width():
Math.abs(this._scale.scale(y)-this._scale.scale(w))};A.prototype._maxWidthForInterval=function(y){return this._measurer.measure(y.formatter(A._LONG_DATE)).width};A.prototype._checkTimeAxisTierConfiguration=function(y){if(null!=this._maxTimeIntervalPrecision){var w=A._SORTED_TIME_INTERVAL_INDEX[this._maxTimeIntervalPrecision],C=A._SORTED_TIME_INTERVAL_INDEX[y.interval];if(null!=w&&null!=C&&C<w)return!1}w=this._maxWidthForInterval(y)+2*this.tickLabelPadding();return Math.min(this._getIntervalLength(y),
this.width())>=w};A.prototype._sizeFromOffer=function(y,w){var C=x.prototype._sizeFromOffer.call(this,y,w);y=this._tierHeights.reduce(function(G,D){return G+D>C.height?G:G+D});w=this.margin()+(this.annotationsEnabled()?this.annotationTierCount()*this._annotationTierHeight():0);C.height=Math.min(C.height,y+w);return C};A.prototype._setup=function(){x.prototype._setup.call(this);this._setupDomElements()};A.prototype._setupDomElements=function(){this.content().selectAll("."+A.TIME_AXIS_TIER_CLASS).remove();
this._tierLabelContainers=[];this._tierMarkContainers=[];this._tierBaselines=[];this._tickLabelContainer.remove();this._baseline.remove();for(var y=0;y<this._numTiers;++y){var w=this.content().append("g").classed(A.TIME_AXIS_TIER_CLASS,!0);this._tierLabelContainers.push(w.append("g").classed(q.Axis.TICK_LABEL_CLASS+"-container",!0));this._tierMarkContainers.push(w.append("g").classed(q.Axis.TICK_MARK_CLASS+"-container",!0));this._tierBaselines.push(w.append("line").classed("baseline",!0))}y=new l.SvgContext(this._tierLabelContainers[0].node());
this._measurer=new l.CacheMeasurer(y)};A.prototype._getTickIntervalValues=function(y){return this._scale.tickInterval(y.interval,y.step)};A.prototype._getTickValues=function(){var y=this;return this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex].reduce(function(w,C){return w.concat(y._getTickIntervalValues(C))},[])};A.prototype._cleanTiers=function(){for(var y=0;y<this._tierLabelContainers.length;y++)this._tierLabelContainers[y].selectAll("."+q.Axis.TICK_LABEL_CLASS).remove(),this._tierMarkContainers[y].selectAll("."+
q.Axis.TICK_MARK_CLASS).remove(),this._tierBaselines[y].style("visibility","hidden")};A.prototype._getTickValuesForConfiguration=function(y){y=this._scale.tickInterval(y.interval,y.step);var w=this._scale.domain(),C=y.map(function(G){return G.valueOf()});-1===C.indexOf(w[0].valueOf())&&y.unshift(w[0]);-1===C.indexOf(w[1].valueOf())&&y.push(w[1]);return y};A.prototype._renderTierLabels=function(y,w,C){var G=this,D=this._getTickValuesForConfiguration(w),B=[];"between"===this._tierLabelPositions[C]&&
1===w.step?D.map(function(K,M){M+1>=D.length||B.push(new Date((D[M+1].valueOf()-D[M].valueOf())/2+D[M].valueOf()))}):B=D;y=y.selectAll("."+q.Axis.TICK_LABEL_CLASS).data(B,function(K){return String(K.valueOf())});var I=y.enter().append("g").classed(q.Axis.TICK_LABEL_CLASS,!0);I.append("text");var N="center"===this._tierLabelPositions[C]||1===w.step?0:this.tickLabelPadding();var O="bottom"===this.orientation()?t.sum(this._tierHeights.slice(0,C+1))-this.tickLabelPadding():"center"===this._tierLabelPositions[C]?
this.height()-t.sum(this._tierHeights.slice(0,C))-this.tickLabelPadding()-this._maxLabelTickLength():this.height()-t.sum(this._tierHeights.slice(0,C))-this.tickLabelPadding();I=y.merge(I);var H=I.selectAll("text");0<H.size()&&H.attr("transform","translate("+N+","+O+")");y.exit().remove();I.attr("transform",function(K){return"translate("+G._scale.scale(K)+",0)"});C="center"===this._tierLabelPositions[C]||1===w.step?"middle":"start";I.selectAll("text").text(w.formatter).style("text-anchor",C)};A.prototype._renderTickMarks=
function(y,w){y=this._tierMarkContainers[w].selectAll("."+q.Axis.TICK_MARK_CLASS).data(y);var C=y.enter().append("line").classed(q.Axis.TICK_MARK_CLASS,!0).merge(y),G=this._generateTickMarkAttrHash(),D=this._tierHeights.slice(0,w).reduce(function(B,I){return B+I},0);"bottom"===this.orientation()?(G.y1=D,G.y2=D+("center"===this._tierLabelPositions[w]?this.innerTickLength():this._tierHeights[w])):(G.y1=this.height()-D,G.y2=this.height()-(D+("center"===this._tierLabelPositions[w]?this.innerTickLength():
this._tierHeights[w])));C.attrs(G);"bottom"===this.orientation()?(G.y1=D,G.y2=D+("center"===this._tierLabelPositions[w]?this.endTickLength():this._tierHeights[w])):(G.y1=this.height()-D,G.y2=this.height()-(D+("center"===this._tierLabelPositions[w]?this.endTickLength():this._tierHeights[w])));t.select(C.nodes()[0]).attrs(G);t.select(C.nodes()[C.size()-1]).attrs(G);t.select(C.nodes()[0]).classed(q.Axis.END_TICK_MARK_CLASS,!0);t.select(C.nodes()[C.size()-1]).classed(q.Axis.END_TICK_MARK_CLASS,!0);y.exit().remove()};
A.prototype._renderLabellessTickMarks=function(y){y=this._tickMarkContainer.selectAll("."+q.Axis.TICK_MARK_CLASS).data(y);var w=y.enter().append("line").classed(q.Axis.TICK_MARK_CLASS,!0).merge(y),C=this._generateTickMarkAttrHash();C.y2="bottom"===this.orientation()?this.tickLabelPadding():this.height()-this.tickLabelPadding();w.attrs(C);y.exit().remove()};A.prototype._generateLabellessTicks=function(){return 1>this._mostPreciseConfigIndex?[]:this._getTickIntervalValues(this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex-
1][0])};A.prototype.renderImmediately=function(){var y=this;this._mostPreciseConfigIndex=this._getMostPreciseConfigurationIndex();var w=this._possibleTimeAxisConfigurations[this._mostPreciseConfigIndex];this._cleanTiers();w.forEach(function(I,N){return y._renderTierLabels(y._tierLabelContainers[N],I,N)});for(var C=w.map(function(I){return y._getTickValuesForConfiguration(I)}),G=0,D=0;D<Math.max(w.length,1);++D){var B=this._generateBaselineAttrHash();B.y1+="bottom"===this.orientation()?G:-G;B.y2=B.y1;
this._tierBaselines[D].attrs(B).style("visibility","inherit");G+=this._tierHeights[D]}G=[];D=this._scale.domain();D=this._scale.scale(D[1])-this._scale.scale(D[0]);1.5*this._getIntervalLength(w[0])>=D&&(G=this._generateLabellessTicks());this._renderLabellessTickMarks(G);this._hideOverflowingTiers();for(D=0;D<w.length;++D)this._renderTickMarks(C[D],D),this._hideOverlappingAndCutOffLabels(D);this.annotationsEnabled()?this._drawAnnotations():this._removeAnnotations();return this};A.prototype._hideOverflowingTiers=
function(){var y=this,w=this.height(),C=0;this.content().selectAll("."+A.TIME_AXIS_TIER_CLASS).attr("visibility",function(G,D){C+=y._tierHeights[D];return C<=w?"inherit":"hidden"})};A.prototype._hideOverlappingAndCutOffLabels=function(y){function w(I){return Math.floor(G.left)<=Math.ceil(I.left)&&Math.floor(G.top)<=Math.ceil(I.top)&&Math.floor(I.right)<=Math.ceil(G.left+C.width())&&Math.floor(I.bottom)<=Math.ceil(G.top+C.height())}var C=this,G=this.element().node().getBoundingClientRect(),D=this._tierMarkContainers[y].selectAll("."+
q.Axis.TICK_MARK_CLASS).filter(function(){var I=t.select(this).style("visibility");return"visible"===I||"inherit"===I}).nodes().map(function(I){return I.getBoundingClientRect()}),B;this._tierLabelContainers[y].selectAll("."+q.Axis.TICK_LABEL_CLASS).filter(function(){var I=t.select(this).style("visibility");return"visible"===I||"inherit"===I}).each(function(I,N){I=this.getBoundingClientRect();var O=t.select(this),H=D[N],K=D[N+1];N=null!=B&&n.DOM.clientRectsOverlap(I,B);H=null!=H&&n.DOM.clientRectsOverlap(I,
H);K=null!=K&&n.DOM.clientRectsOverlap(I,K);!w(I)||N||H||K?O.style("visibility","hidden"):(B=I,O.style("visibility","inherit"))})};A.prototype.invalidateCache=function(){x.prototype.invalidateCache.call(this);this._measurer.reset()};return A}(q.Axis);h.TIME_AXIS_TIER_CLASS="time-axis-tier";h._SORTED_TIME_INTERVAL_INDEX=(u={},u[f.TimeInterval.second]=0,u[f.TimeInterval.minute]=1,u[f.TimeInterval.hour]=2,u[f.TimeInterval.day]=3,u[f.TimeInterval.week]=4,u[f.TimeInterval.month]=5,u[f.TimeInterval.year]=
6,u);h._DEFAULT_TIME_AXIS_CONFIGURATIONS=[[{interval:f.TimeInterval.second,step:1,formatter:p.time("%I:%M:%S %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.second,step:5,formatter:p.time("%I:%M:%S %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.second,step:10,formatter:p.time("%I:%M:%S %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.second,step:15,
formatter:p.time("%I:%M:%S %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.second,step:30,formatter:p.time("%I:%M:%S %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.minute,step:1,formatter:p.time("%I:%M %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.minute,step:5,formatter:p.time("%I:%M %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],
[{interval:f.TimeInterval.minute,step:10,formatter:p.time("%I:%M %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.minute,step:15,formatter:p.time("%I:%M %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.minute,step:30,formatter:p.time("%I:%M %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.hour,step:1,formatter:p.time("%I %p")},{interval:f.TimeInterval.day,
step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.hour,step:3,formatter:p.time("%I %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.hour,step:6,formatter:p.time("%I %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.hour,step:12,formatter:p.time("%I %p")},{interval:f.TimeInterval.day,step:1,formatter:p.time("%B %e, %Y")}],[{interval:f.TimeInterval.day,step:1,formatter:p.time("%a %e")},
{interval:f.TimeInterval.month,step:1,formatter:p.time("%B %Y")}],[{interval:f.TimeInterval.day,step:1,formatter:p.time("%e")},{interval:f.TimeInterval.month,step:1,formatter:p.time("%B %Y")}],[{interval:f.TimeInterval.month,step:1,formatter:p.time("%B")},{interval:f.TimeInterval.year,step:1,formatter:p.time("%Y")}],[{interval:f.TimeInterval.month,step:1,formatter:p.time("%b")},{interval:f.TimeInterval.year,step:1,formatter:p.time("%Y")}],[{interval:f.TimeInterval.month,step:3,formatter:p.time("%b")},
{interval:f.TimeInterval.year,step:1,formatter:p.time("%Y")}],[{interval:f.TimeInterval.month,step:6,formatter:p.time("%b")},{interval:f.TimeInterval.year,step:1,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:1,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:1,formatter:p.time("%y")}],[{interval:f.TimeInterval.year,step:5,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:25,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:50,formatter:p.time("%Y")}],
[{interval:f.TimeInterval.year,step:100,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:200,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:500,formatter:p.time("%Y")}],[{interval:f.TimeInterval.year,step:1E3,formatter:p.time("%Y")}]];h._LONG_DATE=new Date(9999,8,29,12,59,9999);f.Time=h;var u},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=
p.prototype,new m)},t=h(12);d=function(l){function p(){var m=l.call(this)||this;m._detachCallback=function(n){return m.remove(n)};return m}k(p,l);p.prototype.anchor=function(m){var n=this;m=t.coerceExternalD3(m);l.prototype.anchor.call(this,m);this._forEach(function(q){return q.anchor(n.element())});return this};p.prototype.render=function(){this._forEach(function(m){return m.render()});return this};p.prototype.has=function(){throw Error("has() is not implemented on ComponentContainer");};p.prototype._adoptAndAnchor=
function(m){m.parent(this);m.onDetach(this._detachCallback);this._isAnchored&&m.anchor(this.element())};p.prototype.remove=function(m){this.has(m)&&(m.offDetach(this._detachCallback),this._remove(m),m.detach(),this.redraw());return this};p.prototype._remove=function(){};p.prototype._forEach=function(){throw Error("_forEach() is not implemented on ComponentContainer");};p.prototype.destroy=function(){l.prototype.destroy.call(this);this._forEach(function(m){return m.destroy()})};p.prototype.invalidateCache=
function(){this._forEach(function(m){return m.invalidateCache()})};return p}(h(4).Component);f.ComponentContainer=d},function(d,f,h){function k(A){n.add(A);m.add(A);t()}function t(){q||(q=!0,x.render())}var l=h(0);d=h(10);var p=h(39),m=new l.Set,n=new l.Set,q=!1,u=!1;f.Policy=d.makeEnum(["immediate","animationFrame","timeout"]);var x=new p.AnimationFrame;f.renderPolicy=function(A){if(null==A)return x;switch(A){case f.Policy.immediate:x=new p.Immediate;break;case f.Policy.animationFrame:x=new p.AnimationFrame;
break;case f.Policy.timeout:x=new p.Timeout;break;default:l.Window.warn("Unrecognized renderPolicy: "+A)}};f.registerToRender=function(A){u&&l.Window.warn("Registered to render while other components are flushing: request may be ignored");m.add(A);t()};f.registerToComputeLayoutAndRender=k;f.registerToComputeLayout=function(A){k(A)};f.flush=function(){if(q){n.forEach(function(y){return y.computeLayout()});m.forEach(function(y){return y.render()});u=!0;var A=new l.Set;m.forEach(function(y){try{y.renderImmediately()}catch(w){window.setTimeout(function(){throw w;
},0),A.add(y)}});n=new l.Set;m=A;u=q=!1}}},function(d,f,h){var k=h(1);f.circle=function(){return function(l){return k.symbol().type(k.symbolCircle).size(Math.PI*Math.pow(l/2,2))}};f.square=function(){return function(l){return k.symbol().type(k.symbolSquare).size(Math.pow(l,2))}};f.cross=function(){return function(l){return k.symbol().type(k.symbolCross).size(5/9*Math.pow(l,2))}};f.diamond=function(){return function(l){return k.symbol().type(k.symbolDiamond).size(Math.tan(Math.PI/6)*Math.pow(l,2)/
2)}};f.triangle=function(){return function(l){return k.symbol().type(k.symbolTriangle).size(Math.sqrt(3)*Math.pow(l/2,2))}};f.star=function(){return function(l){return k.symbol().type(k.symbolStar).size(.8908130915292852*Math.pow(l/2,2))}};var t=3*(1/Math.sqrt(12)/2+1);f.wye=function(){return function(l){return k.symbol().type(k.symbolWye).size(t*Math.pow(l/2.4,2))}}},function(d,f,h){var k=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&(n[x]=
q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},t=h(25),l=h(0),p=h(12),m=h(37);d=function(n){function q(){var u=n.call(this)||this;u._detectionRadius=3;u._resizable=!1;u._movable=!1;u._hasCorners=!0;u.addClass("drag-box-layer");u._dragInteraction=new t.Drag;u._setUpCallbacks();u._dragInteraction.attachTo(u);u._dragStartCallbacks=new l.CallbackSet;u._dragCallbacks=new l.CallbackSet;u._dragEndCallbacks=new l.CallbackSet;return u}k(q,n);q.prototype._setUpCallbacks=function(){function u(I,
N){0===B&&I.x===N.x&&I.y===N.y&&y.boxVisible(!1);y._dragEndCallbacks.callCallbacks(y.bounds())}function x(I,N){switch(B){case 0:G.x=N.x;G.y=N.y;break;case 1:w.bottom?G.y=N.y:w.top&&(C.y=N.y);w.right?G.x=N.x:w.left&&(C.x=N.x);break;case 2:I=N.x-D.x;var O=N.y-D.y;C.x+=I;C.y+=O;G.x+=I;G.y+=O;D=N}y._setBounds({topLeft:C,bottomRight:G});y._xBoundsMode===m.PropertyMode.VALUE&&null!=y.xScale()&&y._setXExtent([y.xScale().invert(C.x),y.xScale().invert(G.x)]);y._yBoundsMode===m.PropertyMode.VALUE&&null!=y.yScale()&&
y._setYExtent([y.yScale().invert(C.y),y.yScale().invert(G.y)]);y.render();y._dragCallbacks.callCallbacks(y.bounds())}function A(I){w=y._getResizingEdges(I);var N=y.bounds();N=N.topLeft.x<=I.x&&I.x<=N.bottomRight.x&&N.topLeft.y<=I.y&&I.y<=N.bottomRight.y;y.boxVisible()&&(w.top||w.bottom||w.left||w.right)?B=1:y.boxVisible()&&y.movable()&&N?B=2:(B=0,y._setBounds({topLeft:I,bottomRight:I}),y._xBoundsMode===m.PropertyMode.VALUE&&null!=y.xScale()&&y._setXExtent([y.xScale().invert(I.x),y.xScale().invert(I.x)]),
y._yBoundsMode===m.PropertyMode.VALUE&&null!=y.yScale()&&y._setYExtent([y.yScale().invert(I.y),y.yScale().invert(I.y)]),y.render());y.boxVisible(!0);N=y.bounds();C={x:N.topLeft.x,y:N.topLeft.y};G={x:N.bottomRight.x,y:N.bottomRight.y};D=I;y._dragStartCallbacks.callCallbacks(N)}var y=this,w,C,G,D,B=0;this._dragInteraction.onDragStart(A);this._dragInteraction.onDrag(x);this._dragInteraction.onDragEnd(u);this._disconnectInteraction=function(){y._dragInteraction.offDragStart(A);y._dragInteraction.offDrag(x);
y._dragInteraction.offDragEnd(u);y._dragInteraction.detach()}};q.prototype._setup=function(){function u(){return x._box.append("line").styles({opacity:0,stroke:"pink","pointer-events":"visibleStroke"})}var x=this;n.prototype._setup.call(this);this._detectionEdgeT=u().classed("drag-edge-tb",!0);this._detectionEdgeB=u().classed("drag-edge-tb",!0);this._detectionEdgeL=u().classed("drag-edge-lr",!0);this._detectionEdgeR=u().classed("drag-edge-lr",!0);if(this._hasCorners){var A=function(){return x._box.append("circle").styles({opacity:0,
fill:"pink","pointer-events":"visibleFill"})};this._detectionCornerTL=A().classed("drag-corner-tl",!0);this._detectionCornerTR=A().classed("drag-corner-tr",!0);this._detectionCornerBL=A().classed("drag-corner-bl",!0);this._detectionCornerBR=A().classed("drag-corner-br",!0)}};q.prototype._getResizingEdges=function(u){var x={top:!1,bottom:!1,left:!1,right:!1};if(!this.resizable())return x;var A=this.bounds(),y=A.topLeft.y,w=A.bottomRight.y,C=A.topLeft.x;A=A.bottomRight.x;var G=this._detectionRadius;
C-G<=u.x&&u.x<=A+G&&(x.top=y-G<=u.y&&u.y<=y+G,x.bottom=w-G<=u.y&&u.y<=w+G);y-G<=u.y&&u.y<=w+G&&(x.left=C-G<=u.x&&u.x<=C+G,x.right=A-G<=u.x&&u.x<=A+G);return x};q.prototype.renderImmediately=function(){n.prototype.renderImmediately.call(this);if(this.boxVisible()){var u=this.bounds(),x=u.topLeft.y,A=u.bottomRight.y,y=u.topLeft.x;u=u.bottomRight.x;this._detectionEdgeT.attrs({x1:y,y1:x,x2:u,y2:x,"stroke-width":2*this._detectionRadius});this._detectionEdgeB.attrs({x1:y,y1:A,x2:u,y2:A,"stroke-width":2*
this._detectionRadius});this._detectionEdgeL.attrs({x1:y,y1:x,x2:y,y2:A,"stroke-width":2*this._detectionRadius});this._detectionEdgeR.attrs({x1:u,y1:x,x2:u,y2:A,"stroke-width":2*this._detectionRadius});this._hasCorners&&(this._detectionCornerTL.attrs({cx:y,cy:x,r:this._detectionRadius}),this._detectionCornerTR.attrs({cx:u,cy:x,r:this._detectionRadius}),this._detectionCornerBL.attrs({cx:y,cy:A,r:this._detectionRadius}),this._detectionCornerBR.attrs({cx:u,cy:A,r:this._detectionRadius}))}return this};
q.prototype.detectionRadius=function(){return this._detectionRadius};q.prototype.resizable=function(u){if(null==u)return this._resizable;this._resizable=u;this._setResizableClasses(u);return this};q.prototype._setResizableClasses=function(u){u&&this.enabled()?(this.addClass("x-resizable"),this.addClass("y-resizable")):(this.removeClass("x-resizable"),this.removeClass("y-resizable"))};q.prototype.movable=function(){return this._movable};q.prototype._setMovableClass=function(){this.movable()&&this.enabled()?
this.addClass("movable"):this.removeClass("movable")};q.prototype.onDragStart=function(u){this._dragStartCallbacks.add(u)};q.prototype.offDragStart=function(u){this._dragStartCallbacks.delete(u)};q.prototype.onDrag=function(u){this._dragCallbacks.add(u);return this};q.prototype.offDrag=function(u){this._dragCallbacks.delete(u)};q.prototype.onDragEnd=function(u){this._dragEndCallbacks.add(u)};q.prototype.offDragEnd=function(u){this._dragEndCallbacks.delete(u)};q.prototype.dragInteraction=function(){return this._dragInteraction};
q.prototype.enabled=function(u){if(null==u)return this._dragInteraction.enabled();this._dragInteraction.enabled(u);this._setResizableClasses(this.resizable());this._setMovableClass();return this};q.prototype.destroy=function(){var u=this;n.prototype.destroy.call(this);this._dragStartCallbacks.forEach(function(x){return u._dragCallbacks.delete(x)});this._dragCallbacks.forEach(function(x){return u._dragCallbacks.delete(x)});this._dragEndCallbacks.forEach(function(x){return u._dragEndCallbacks.delete(x)});
this._disconnectInteraction()};q.prototype.detach=function(){this._resetState();this._dragInteraction.detach();n.prototype.detach.call(this);return this};q.prototype.anchor=function(u){u=p.coerceExternalD3(u);this._dragInteraction.attachTo(this);n.prototype.anchor.call(this,u);return this};q.prototype._resetState=function(){this.bounds({topLeft:{x:0,y:0},bottomRight:{x:0,y:0}})};return q}(h(43).SelectionBoxLayer);f.DragBoxLayer=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=
p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(18);d=function(p){function m(){return p.call(this,"path","line")||this}k(m,p);m.prototype._applyDefaultAttributes=function(n){n.style("fill","none")};m.prototype.getVisualPrimitiveAtIndex=function(){return p.prototype.getVisualPrimitiveAtIndex.call(this,0)};return m}(h(9).SVGDrawer);f.LineSVGDrawer=d;var l=["opacity","stroke-opacity","stroke-width","stroke"];f.makeLineCanvasDrawStep=
function(p){return function(m,n,q){q=t.resolveAttributes(q,l,n[0],0);t.renderLine(m,p(),n[0],q)}}},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(18);d=function(p){function m(n){void 0===n&&(n="");var q=p.call(this,"rect","")||this;q._rootClassName=n;q._root.classed(q._rootClassName,!0);return q}k(m,p);return m}(h(9).SVGDrawer);f.RectangleSVGDrawer=
d;var l=["x","y","width","height"];f.RectangleCanvasDrawStep=function(p,m,n){p.save();m.forEach(function(q,u){null!=q&&(q=t.resolveAttributesSubsetWithStyles(n,l,q,u),p.beginPath(),p.rect(q.x,q.y,q.width,q.height),t.renderPathWithStyle(p,q))});p.restore()};d=function(p){function m(n){return p.call(this,n,f.RectangleCanvasDrawStep)||this}k(m,p);return m}(t.CanvasDrawer);f.RectangleCanvasDrawer=d},function(d,f,h){function k(p){l.SHOW_WARNINGS&&console.warn(p)}function t(p,m){for(var n=[],q=2;q<arguments.length;q++)n[q-
2]=arguments[q];return 0===m?(p(n),-1):window.setTimeout(p,m,n)}var l=h(23);f.warn=k;f.setTimeout=t;f.debounce=function(p,m,n){function q(){m.apply(n,x)}var u=null,x=[];return function(){x=Array.prototype.slice.call(arguments);clearTimeout(u);u=t(q,p)}};f.deprecated=function(p,m,n){void 0===n&&(n="");k("Method "+p+" has been deprecated in version "+m+". Please refer to the release notes. "+n)}},function(d,f){d=function(){function h(k){this.ruler=null!=k.createRuler?k.createRuler():k}h.prototype.measure=
function(k){void 0===k&&(k=h.HEIGHT_TEXT);return this.ruler(k)};return h}();d.HEIGHT_TEXT="bdpql";f.AbstractMeasurer=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(32));k(h(74));k(h(75));k(h(41));k(h(42));k(h(76));k(h(77));k(h(78));k(h(79));k(h(43));k(h(80));k(h(81));k(h(82))},function(d,f,h){var k=h(0);d=function(){function t(l,p){void 0===l&&(l=[]);void 0===p&&(p={});this._updateId=0;this._data=l;this._metadata=p;this._callbacks=new k.CallbackSet}t.prototype.onUpdate=
function(l){this._callbacks.add(l);return this};t.prototype.offUpdate=function(l){this._callbacks.delete(l);return this};t.prototype.data=function(l){if(null==l)return this._data;this._data=l;this._dispatchUpdate();return this};t.prototype.metadata=function(l){if(null==l)return this._metadata;this._metadata=l;this._dispatchUpdate();return this};t.prototype.updateId=function(){return this._updateId};t.prototype._dispatchUpdate=function(){this._updateId++;this._callbacks.callCallbacks(this)};return t}();
f.Dataset=d},function(d,f,h){var k=h(0),t=h(30);d=function(){function l(){}l.prototype.render=function(){t.flush()};return l}();f.Immediate=d;d=function(){function l(){}l.prototype.render=function(){k.DOM.requestAnimationFramePolyfill(t.flush)};return l}();f.AnimationFrame=d;d=function(){function l(){this._timeoutMsec=k.DOM.SCREEN_REFRESH_RATE_MILLISECONDS}l.prototype.render=function(){setTimeout(t.flush,this._timeoutMsec)};return l}();f.Timeout=d},function(d,f,h){var k=this&&this.__extends||function(p,
m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(13),l=h(0);d=function(p){function m(){var n=null!==p&&p.apply(this,arguments)||this;n._keyPressCallbacks={};n._keyReleaseCallbacks={};n._mouseMoveCallback=function(){return!1};n._downedKeys=new l.Set;n._keyDownCallback=function(q,u){return n._handleKeyDownEvent(q,u)};n._keyUpCallback=function(q){return n._handleKeyUpEvent(q)};return n}k(m,p);
m.prototype._anchor=function(n){p.prototype._anchor.call(this,n);this._positionDispatcher=t.Mouse.getDispatcher(this._componentAttachedTo);this._positionDispatcher.onMouseMove(this._mouseMoveCallback);this._keyDispatcher=t.Key.getDispatcher();this._keyDispatcher.onKeyDown(this._keyDownCallback);this._keyDispatcher.onKeyUp(this._keyUpCallback)};m.prototype._unanchor=function(){p.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};m.prototype._handleKeyDownEvent=function(n,q){var u=this._translateToComponentSpace(this._positionDispatcher.lastMousePosition());this._isInsideComponent(u)&&!q.repeat&&(this._keyPressCallbacks[n]&&this._keyPressCallbacks[n].callCallbacks(n),this._downedKeys.add(n))};m.prototype._handleKeyUpEvent=function(n){this._downedKeys.has(n)&&this._keyReleaseCallbacks[n]&&this._keyReleaseCallbacks[n].callCallbacks(n);
this._downedKeys.delete(n)};m.prototype.onKeyPress=function(n,q){this._keyPressCallbacks[n]||(this._keyPressCallbacks[n]=new l.CallbackSet);this._keyPressCallbacks[n].add(q);return this};m.prototype.offKeyPress=function(n,q){this._keyPressCallbacks[n].delete(q);0===this._keyPressCallbacks[n].size&&delete this._keyPressCallbacks[n];return this};m.prototype.onKeyRelease=function(n,q){this._keyReleaseCallbacks[n]||(this._keyReleaseCallbacks[n]=new l.CallbackSet);this._keyReleaseCallbacks[n].add(q);return this};
m.prototype.offKeyRelease=function(n,q){this._keyReleaseCallbacks[n].delete(q);0===this._keyReleaseCallbacks[n].size&&delete this._keyReleaseCallbacks[n];return this};return m}(h(15).Interaction);f.Key=d},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(0);d=function(l){function p(m){void 0===m&&(m=[]);var n=l.call(this)||this;n._components=
[];n.addClass("component-group");m.forEach(function(q){return n.append(q)});return n}k(p,l);p.prototype._forEach=function(m){this.components().forEach(m)};p.prototype.has=function(m){return 0<=this._components.indexOf(m)};p.prototype.requestedSpace=function(m,n){var q=this._components.map(function(u){return u.requestedSpace(m,n)});return{minWidth:t.Math.max(q,function(u){return u.minWidth},0),minHeight:t.Math.max(q,function(u){return u.minHeight},0)}};p.prototype.computeLayout=function(m,n,q){var u=
this;l.prototype.computeLayout.call(this,m,n,q);this._forEach(function(x){x.computeLayout({x:0,y:0},u.width(),u.height())});return this};p.prototype._sizeFromOffer=function(m,n){return{width:m,height:n}};p.prototype.fixedWidth=function(){return this._components.every(function(m){return m.fixedWidth()})};p.prototype.fixedHeight=function(){return this._components.every(function(m){return m.fixedHeight()})};p.prototype.components=function(){return this._components.slice()};p.prototype.append=function(m){null==
m||this.has(m)||(m.detach(),this._components.push(m),this._adoptAndAnchor(m),this.redraw());return this};p.prototype._remove=function(m){m=this._components.indexOf(m);0<=m&&this._components.splice(m,1)};return p}(h(29).ComponentContainer);f.Group=d},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)};h(0);d=h(4);var t;(function(l){l[l.VALUE=0]=
"VALUE";l[l.PIXEL=1]="PIXEL"})(t||(t={}));d=function(l){function p(m){var n=l.call(this)||this;n._mode=t.VALUE;if(m!==p.ORIENTATION_VERTICAL&&m!==p.ORIENTATION_HORIZONTAL)throw Error(m+" is not a valid orientation for GuideLineLayer");n._orientation=m;n._overflowHidden=!0;n.addClass("guide-line-layer");n._isVertical()?n.addClass("vertical"):n.addClass("horizontal");n._scaleUpdateCallback=function(){n._syncPixelPositionAndValue();n.render()};return n}k(p,l);p.prototype._setup=function(){l.prototype._setup.call(this);
this._guideLine=this.content().append("line").classed("guide-line",!0)};p.prototype._sizeFromOffer=function(m,n){return{width:m,height:n}};p.prototype._isVertical=function(){return this._orientation===p.ORIENTATION_VERTICAL};p.prototype.fixedWidth=function(){return!0};p.prototype.fixedHeight=function(){return!0};p.prototype.computeLayout=function(m,n,q){l.prototype.computeLayout.call(this,m,n,q);null!=this.scale()&&(this._isVertical()?this.scale().range([0,this.width()]):this.scale().range([this.height(),
0]));return this};p.prototype.renderImmediately=function(){l.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()});return this};p.prototype._syncPixelPositionAndValue=function(){null!=this.scale()&&(this._mode===t.VALUE&&null!=this.value()?this._pixelPosition=
this.scale().scale(this.value()):this._mode===t.PIXEL&&null!=this.pixelPosition()&&(this._value=this.scale().invert(this.pixelPosition())))};p.prototype._setPixelPositionWithoutChangingMode=function(m){this._pixelPosition=m;null!=this.scale()&&(this._value=this.scale().invert(this.pixelPosition()));this.render()};p.prototype.scale=function(m){if(null==m)return this._scale;var n=this._scale;null!=n&&n.offUpdate(this._scaleUpdateCallback);this._scale=m;this._scale.onUpdate(this._scaleUpdateCallback);
this._syncPixelPositionAndValue();this.redraw();return this};p.prototype.value=function(m){if(null==m)return this._value;this._value=m;this._mode=t.VALUE;this._syncPixelPositionAndValue();this.render();return this};p.prototype.pixelPosition=function(){return this._pixelPosition};p.prototype.destroy=function(){l.prototype.destroy.call(this);null!=this.scale()&&this.scale().offUpdate(this._scaleUpdateCallback)};return p}(d.Component);d.ORIENTATION_VERTICAL="vertical";d.ORIENTATION_HORIZONTAL="horizontal";
f.GuideLineLayer=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(0);d=h(4);var l;(function(p){p[p.VALUE=0]="VALUE";p[p.PIXEL=1]="PIXEL"})(l=f.PropertyMode||(f.PropertyMode={}));d=function(p){function m(){var n=p.call(this)||this;n._boxVisible=!1;n._boxBounds={topLeft:{x:0,y:0},bottomRight:{x:0,y:0}};n._xBoundsMode=l.PIXEL;n._yBoundsMode=
l.PIXEL;n.addClass("selection-box-layer");n._adjustBoundsCallback=function(){n.render()};n._overflowHidden=!0;n._xExtent=[void 0,void 0];n._yExtent=[void 0,void 0];return n}k(m,p);m.prototype._setup=function(){p.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)};m.prototype._sizeFromOffer=function(n,q){return{width:n,height:q}};m.prototype.bounds=function(n){if(null==n)return this._getBounds();
this._setBounds(n);this._yBoundsMode=this._xBoundsMode=l.PIXEL;this.render();return this};m.prototype._setBounds=function(n){this._boxBounds={topLeft:{x:Math.min(n.topLeft.x,n.bottomRight.x),y:Math.min(n.topLeft.y,n.bottomRight.y)},bottomRight:{x:Math.max(n.topLeft.x,n.bottomRight.x),y:Math.max(n.topLeft.y,n.bottomRight.y)}}};m.prototype._getBounds=function(){return{topLeft:{x:this._xBoundsMode===l.PIXEL?this._boxBounds.topLeft.x:null==this._xScale?0:Math.min(this.xScale().scale(this.xExtent()[0]),
this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===l.PIXEL?this._boxBounds.topLeft.y:null==this._yScale?0:Math.min(this.yScale().scale(this.yExtent()[0]),this.yScale().scale(this.yExtent()[1]))},bottomRight:{x:this._xBoundsMode===l.PIXEL?this._boxBounds.bottomRight.x:null==this._xScale?0:Math.max(this.xScale().scale(this.xExtent()[0]),this.xScale().scale(this.xExtent()[1])),y:this._yBoundsMode===l.PIXEL?this._boxBounds.bottomRight.y:null==this._yScale?0:Math.max(this.yScale().scale(this.yExtent()[0]),
this.yScale().scale(this.yExtent()[1]))}}};m.prototype.renderImmediately=function(){p.prototype.renderImmediately.call(this);if(this._boxVisible){var n=this.bounds(),q=n.topLeft.y,u=n.bottomRight.y,x=n.topLeft.x;n=n.bottomRight.x;if(!(t.Math.isValidNumber(q)&&t.Math.isValidNumber(u)&&t.Math.isValidNumber(x)&&t.Math.isValidNumber(n)))throw Error("bounds have not been properly set");this._boxArea.attrs({x,y:q,width:n-x,height:u-q});this.content().node().appendChild(this._box.node())}else this._box.remove();
return this};m.prototype.boxVisible=function(n){if(null==n)return this._boxVisible;this._boxVisible=n;this.render();return this};m.prototype.fixedWidth=function(){return!0};m.prototype.fixedHeight=function(){return!0};m.prototype.xScale=function(n){if(null==n)return this._xScale;null!=this._xScale&&this._xScale.offUpdate(this._adjustBoundsCallback);this._xScale=n;this._xBoundsMode=l.VALUE;this._xScale.onUpdate(this._adjustBoundsCallback);this.render();return this};m.prototype.yScale=function(n){if(null==
n)return this._yScale;null!=this._yScale&&this._yScale.offUpdate(this._adjustBoundsCallback);this._yScale=n;this._yBoundsMode=l.VALUE;this._yScale.onUpdate(this._adjustBoundsCallback);this.render();return this};m.prototype.xExtent=function(){return this._getXExtent()};m.prototype._getXExtent=function(){return this._xBoundsMode===l.VALUE?this._xExtent:null==this._xScale?[void 0,void 0]:[this._xScale.invert(this._boxBounds.topLeft.x),this._xScale.invert(this._boxBounds.bottomRight.x)]};m.prototype._setXExtent=
function(n){this._xExtent=n};m.prototype.yExtent=function(){return this._getYExtent()};m.prototype._getYExtent=function(){return this._yBoundsMode===l.VALUE?this._yExtent:null==this._yScale?[void 0,void 0]:[this._yScale.invert(this._boxBounds.topLeft.y),this._yScale.invert(this._boxBounds.bottomRight.y)]};m.prototype._setYExtent=function(n){this._yExtent=n};m.prototype.destroy=function(){p.prototype.destroy.call(this);null!=this._xScale&&this.xScale().offUpdate(this._adjustBoundsCallback);null!=this._yScale&&
this.yScale().offUpdate(this._adjustBoundsCallback)};return m}(d.Component);f.SelectionBoxLayer=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){return t.call(this,"path","arc fill")||this}k(l,t);l.prototype._applyDefaultAttributes=function(p){p.style("stroke","none")};return l}(h(9).SVGDrawer);f.ArcSVGDrawer=
d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){return t.call(this,"path","arc outline")||this}k(l,t);l.prototype._applyDefaultAttributes=function(p){p.style("fill","none")};return l}(h(9).SVGDrawer);f.ArcOutlineSVGDrawer=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=
p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(18);d=function(p){function m(){return p.call(this,"path","area")||this}k(m,p);m.prototype._applyDefaultAttributes=function(n){n.style("stroke","none")};m.prototype.getVisualPrimitiveAtIndex=function(){return p.prototype.getVisualPrimitiveAtIndex.call(this,0)};return m}(h(9).SVGDrawer);f.AreaSVGDrawer=d;var l=["fill","opacity","fill-opacity"];f.makeAreaCanvasDrawStep=function(p){return function(m,
n,q){q=t.resolveAttributes(q,l,n[0],0);t.renderArea(m,p(),n[0],q)}}},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){return t.call(this,"line","")||this}k(l,t);return l}(h(9).SVGDrawer);f.SegmentSVGDrawer=d},function(d,f,h){function k(n,q,u,x,A){return 0<=u+A&&u-A<=n&&0<=x+A&&x-A<=q}function t(n,q,u){if(null==n)return!1;
for(var x=0;x<u.length;x++){var A=u[x];if(n[A]!=q[A])return!1}return!0}var l=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&(n[x]=q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},p=h(86),m=h(18);d=function(n){function q(){return n.call(this,"path","symbol")||this}l(q,n);return q}(h(9).SVGDrawer);f.SymbolSVGDrawer=d;f.makeSymbolCanvasDrawStep=function(n,q,u){var x=this;return function(A,y,w){var C=A.canvas,G=C.clientWidth;
C=C.clientHeight;for(var D=new p.CanvasBuffer(0,0),B=q(),I=u(),N=null,O=null,H=null,K=0;K<y.length;K++){var M=y[K];if(null!=M){var L=m.resolveAttributesSubsetWithStyles(w,["x","y"],M,K),Q=I(M,K,n);if(k(G,C,L.x,L.y,Q)){var T=t(N,L,m.ContextStyleAttrs);M=B(M,K,x._dataset);T&&H==Q&&O==M||(N=m.getStrokeWidth(L),N=Q+N+1,(N>D.screenWidth||N>D.screenHeight)&&D.resize(N,N,!0),D.clear(),N=D.ctx,N.beginPath(),M(Q).context(N)(null),N.closePath(),m.renderPathWithStyle(N,L),O=M,H=Q,N=L);D.blitCenter(A,L.x,L.y)}}}}}},
function(d,f,h){function k(D){return D instanceof y?D:D instanceof Date?p(D.valueOf()):D instanceof A.Scale?t(D):D instanceof x.Dataset?l(D):u(D)?n(D):Array.isArray(D)?m(D):p(D)}function t(D){D={domain:D.domain(),range:D.range(),updateId:D.updateId(),ref:p(D)};return n(D)}function l(D){D={ref:p(D),updateId:D.updateId()};return n(D)}function p(D){return new C(D)}function m(D){return new w(D.map(function(B){return k(B)}))}function n(D){var B={},I;for(I in D)D.hasOwnProperty(I)&&(B[I]=k(D[I]));return new G(B)}
var q=this&&this.__extends||function(D,B){function I(){this.constructor=D}for(var N in B)B.hasOwnProperty(N)&&(D[N]=B[N]);D.prototype=null===B?Object.create(B):(I.prototype=B.prototype,new I)},u=h(128),x=h(38),A=h(17);f.sign=k;f.signScale=t;f.signDataset=l;f.signRef=p;f.signArray=m;f.signObj=n;var y=function(){function D(){}D.prototype.isDifferent=function(B){return B instanceof this.constructor?this.isSignatureDifferent(B):!0};return D}();f.Signature=y;var w=function(D){function B(I){var N=D.call(this)||
this;N.array=I;return N}q(B,D);B.prototype.isSignatureDifferent=function(I){if(I.array.length!==this.array.length)return!0;for(var N=0;N<this.array.length;N++)if(this.array[N].isDifferent(I.array[N]))return!0;return!1};return B}(y);f.ArraySignature=w;var C=function(D){function B(I){var N=D.call(this)||this;N.ref=I;return N}q(B,D);B.prototype.isSignatureDifferent=function(I){return this.ref!==I.ref};return B}(y);f.ReferenceSignature=C;var G=function(D){function B(I){var N=D.call(this)||this;N.obj=
I;return N}q(B,D);B.prototype.isSignatureDifferent=function(I){var N=Object.keys(this.obj),O=Object.keys(I.obj);if(N.length!==O.length)return!0;for(O=0;O<N.length;O++){var H=N[O];if(!I.obj.hasOwnProperty(H)||this.obj[H].isDifferent(I.obj[H]))return!0}return!1};return B}(y);f.ObjectSignature=G},function(d,f,h){var k=this&&this.__extends||function(y,w){function C(){this.constructor=y}for(var G in w)w.hasOwnProperty(G)&&(y[G]=w[G]);y.prototype=null===w?Object.create(w):(C.prototype=w.prototype,new C)},
t=h(1),l=h(3),p=h(0),m=h(14),n=h(46),q=h(6),u=h(33),x=h(19);d=h(53);var A=h(2);h=function(y){function w(){var C=y.call(this)||this;C.addClass("area-plot");C.y0(0);C.attr("fill-opacity",.25);C.attr("fill",(new l.Color).range()[0]);C._lineDrawers=new p.Map;return C}k(w,y);w.prototype.y=function(C,G){if(null==C)return y.prototype.y.call(this);null==G?y.prototype.y.call(this,C):y.prototype.y.call(this,C,G);null!=G&&(C=this.y0().accessor,null!=C&&this._bindProperty(w._Y0_KEY,C,G),this._updateYScale());
return this};w.prototype.y0=function(C){if(null==C)return this._propertyBindings.get(w._Y0_KEY);var G=this.y();this._bindProperty(w._Y0_KEY,C,G&&G.scale);this._updateYScale();this.render();return this};w.prototype._onDatasetUpdate=function(){y.prototype._onDatasetUpdate.call(this);this._updateYScale()};w.prototype._addDataset=function(C){var G=this;this._lineDrawers.set(C,new m.ProxyDrawer(function(){return new u.LineSVGDrawer},function(D){return new m.CanvasDrawer(D,u.makeLineCanvasDrawStep(function(){var B=
A.Plot._scaledAccessor(G.x()),I=A.Plot._scaledAccessor(G.y());return G._d3LineFactory(C,B,I)}))}));y.prototype._addDataset.call(this,C);return this};w.prototype._createNodesForDataset=function(C){y.prototype._createNodesForDataset.call(this,C);C=this._lineDrawers.get(C);"svg"===this.renderer()?C.useSVG(this._renderArea):C.useCanvas(this._canvas);return C};w.prototype._removeDatasetNodes=function(C){y.prototype._removeDatasetNodes.call(this,C);this._lineDrawers.get(C).remove()};w.prototype._additionalPaint=
function(){var C=this,G=this._generateLineDrawSteps(),D=this._getDataToDraw();this.datasets().forEach(function(B){var I=A.Plot.applyDrawSteps(G,B);C._lineDrawers.get(B).draw(D.get(B),I)})};w.prototype._generateLineDrawSteps=function(){var C=[];if(this._animateOnNextRender()){var G=this._generateLineAttrToProjector();G.d=this._constructLineProjector(A.Plot._scaledAccessor(this.x()),this._getResetYFunction());C.push({attrToProjector:G,animator:this._getAnimator(x.Animator.RESET)})}C.push({attrToProjector:this._generateLineAttrToProjector(),
animator:this._getAnimator(x.Animator.MAIN)});return C};w.prototype._generateLineAttrToProjector=function(){var C=this._getAttrToProjector();C.d=this._constructLineProjector(A.Plot._scaledAccessor(this.x()),A.Plot._scaledAccessor(this.y()));return C};w.prototype._createDrawer=function(C){var G=this;return new q.ProxyDrawer(function(){return new n.AreaSVGDrawer},function(D){return new m.CanvasDrawer(D,n.makeAreaCanvasDrawStep(function(){var B=A.Plot._scaledAccessor(G.x()),I=A.Plot._scaledAccessor(G.y()),
N=A.Plot._scaledAccessor(G.y0());return G._createAreaGenerator(B,I,N,G._createDefinedProjector(B,I),C)}))})};w.prototype._generateDrawSteps=function(){var C=[];if(this._animateOnNextRender()){var G=this._getAttrToProjector();G.d=this._constructAreaProjector(A.Plot._scaledAccessor(this.x()),this._getResetYFunction(),A.Plot._scaledAccessor(this.y0()));C.push({attrToProjector:G,animator:this._getAnimator(x.Animator.RESET)})}C.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(x.Animator.MAIN)});
return C};w.prototype._updateYScale=function(){var C=this.getExtentsForProperty("y0");C=p.Array.uniq(p.Array.flatten(C));var G=1===C.length?C[0]:null;C=(C=this.y())&&C.scale;null!=C&&(null!=this._constantBaselineValueProvider&&(C.removePaddingExceptionsProvider(this._constantBaselineValueProvider),this._constantBaselineValueProvider=null),null!=G&&(this._constantBaselineValueProvider=function(){return[G]},C.addPaddingExceptionsProvider(this._constantBaselineValueProvider)))};w.prototype._getResetYFunction=
function(){return A.Plot._scaledAccessor(this.y0())};w.prototype._propertyProjectors=function(){var C=y.prototype._propertyProjectors.call(this);C.d=this._constructAreaProjector(A.Plot._scaledAccessor(this.x()),A.Plot._scaledAccessor(this.y()),A.Plot._scaledAccessor(this.y0()));return C};w.prototype.selections=function(C){var G=this;void 0===C&&(C=this.datasets());if("canvas"===this.renderer())return t.selectAll();var D=y.prototype.selections.call(this,C).nodes();C.map(function(B){return G._lineDrawers.get(B)}).filter(function(B){return null!=
B}).forEach(function(B){return D.push.apply(D,B.getVisualPrimitives())});return t.selectAll(D)};w.prototype._constructAreaProjector=function(C,G,D){var B=this,I=this._createDefinedProjector(A.Plot._scaledAccessor(this.x()),A.Plot._scaledAccessor(this.y()));return function(N,O,H){return B._createAreaGenerator(C,G,D,I,H)(N)}};w.prototype._createDefinedProjector=function(C,G){return function(D,B,I){var N=C(D,B,I);D=G(D,B,I);return p.Math.isValidNumber(N)&&p.Math.isValidNumber(D)}};w.prototype._createAreaGenerator=
function(C,G,D,B,I){var N=this._getCurveFactory();return t.area().x(function(O,H){return C(O,H,I)}).y1(function(O,H){return G(O,H,I)}).y0(function(O,H){return D(O,H,I)}).curve(N).defined(function(O,H){return B(O,H,I)})};return w}(d.Line);h._Y0_KEY="y0";f.Area=h},function(d,f){(function(h){h.MAIN="main";h.RESET="reset"})(f.Animator||(f.Animator={}))},function(d,f){var h=function(){function k(){var t=this;this.translate=this.scale=0;this.cachedDomain=[null,null];this.lastSeenDomain=[null,null];this.updateDomain=
function(l){t.lastSeenDomain=l.getTransformationDomain();var p=l.scaleTransformation(t.cachedDomain[1])-l.scaleTransformation(t.cachedDomain[0]),m=l.scaleTransformation(t.lastSeenDomain[1])-l.scaleTransformation(t.lastSeenDomain[0]);t.scale=p/m||1;t.translate=l.scaleTransformation(t.cachedDomain[0])-l.scaleTransformation(t.lastSeenDomain[0])*t.scale||0}}k.prototype.reset=function(){this.scale=1;this.translate=0;this.cachedDomain=this.lastSeenDomain};k.prototype.setDomain=function(t){this.cachedDomain=
t.getTransformationDomain()};return k}();d=function(){function k(t,l){var p=this;this.renderCallback=t;this.applyTransformCallback=l;this.domainTransformX=new h;this.domainTransformY=new h;this.renderDeferred=function(){p.applyTransform();clearTimeout(p.timeoutToken);p.timeoutToken=setTimeout(function(){p.renderCallback()},k.DEFERRED_RENDERING_DELAY)}}k.prototype.setDomains=function(t,l){t&&this.domainTransformX.setDomain(t);l&&this.domainTransformY.setDomain(l);this.renderDeferred()};k.prototype.updateDomains=
function(t,l){t&&this.domainTransformX.updateDomain(t);l&&this.domainTransformY.updateDomain(l);this.renderDeferred()};k.prototype.resetTransforms=function(){this.domainTransformX.reset();this.domainTransformY.reset();this.applyTransform()};k.prototype.applyTransform=function(){this.applyTransformCallback(this.domainTransformX.translate,this.domainTransformY.translate,this.domainTransformX.scale,this.domainTransformY.scale)};return k}();d.DEFERRED_RENDERING_DELAY=200;f.DeferredRenderer=d},function(d,
f,h){var k=this&&this.__extends||function(C,G){function D(){this.constructor=C}for(var B in G)G.hasOwnProperty(B)&&(C[B]=G[B]);C.prototype=null===G?Object.create(G):(D.prototype=G.prototype,new D)},t=h(1),l=h(7),p=h(14),m=h(6),n=h(33),q=h(3),u=h(11),x=h(0);d=h(10);var A=h(19),y=h(2);h=h(16);var w={linear:t.curveLinear,linearClosed:t.curveLinearClosed,step:t.curveStep,stepBefore:t.curveStepBefore,stepAfter:t.curveStepAfter,basis:t.curveBasis,basisOpen:t.curveBasisOpen,basisClosed:t.curveBasisClosed,
bundle:t.curveBundle,cardinal:t.curveCardinal,cardinalOpen:t.curveCardinalOpen,cardinalClosed:t.curveCardinalClosed,monotone:t.curveMonotoneX};f.CurveName=d.makeEnum("linear linearClosed step stepBefore stepAfter basis basisOpen basisClosed bundle cardinal cardinalOpen cardinalClosed monotone".split(" "));h=function(C){function G(){var D=C.call(this)||this;D._curve="linear";D._autorangeSmooth=!1;D._croppedRenderingEnabled=!0;D._collapseDenseVerticalLinesEnabled=!1;D._downsamplingEnabled=!1;D.addClass("line-plot");
var B=new l.Easing;B.stepDuration(y.Plot._ANIMATION_MAX_DURATION);B.easingMode("expInOut");B.maxTotalDuration(y.Plot._ANIMATION_MAX_DURATION);D.animator(A.Animator.MAIN,B);D.attr("stroke",(new q.Color).range()[0]);D.attr("stroke-width","2px");return D}k(G,C);G.prototype.x=function(D,B,I){if(null==D)return C.prototype.x.call(this);C.prototype.x.call(this,D,B,I);this._setScaleSnapping();return this};G.prototype.y=function(D,B,I){if(null==D)return C.prototype.y.call(this);C.prototype.y.call(this,D,B,
I);this._setScaleSnapping();return this};G.prototype.autorangeMode=function(D){if(null==D)return C.prototype.autorangeMode.call(this);C.prototype.autorangeMode.call(this,D);this._setScaleSnapping();return this};G.prototype.autorangeSmooth=function(){return this._autorangeSmooth};G.prototype._setScaleSnapping=function(){"x"===this.autorangeMode()&&this.x()&&this.x().scale&&this.x().scale instanceof u.QuantitativeScale&&this.x().scale.snappingDomainEnabled(!this.autorangeSmooth());"y"===this.autorangeMode()&&
this.y()&&this.y().scale&&this.y().scale instanceof u.QuantitativeScale&&this.y().scale.snappingDomainEnabled(!this.autorangeSmooth())};G.prototype.curve=function(D){if(null==D)return this._curve;this._curve=D;this.render();return this};G.prototype.downsamplingEnabled=function(){return this._downsamplingEnabled};G.prototype.croppedRenderingEnabled=function(D){if(null==D)return this._croppedRenderingEnabled;this._croppedRenderingEnabled=D;this.render();return this};G.prototype.collapseDenseLinesEnabled=
function(D){if(null==D)return this._collapseDenseVerticalLinesEnabled;this._collapseDenseVerticalLinesEnabled=D;this.render();return this};G.prototype._createDrawer=function(D){var B=this;return new m.ProxyDrawer(function(){return new n.LineSVGDrawer},function(I){return new p.CanvasDrawer(I,n.makeLineCanvasDrawStep(function(){return B._d3LineFactory(D)}))})};G.prototype.getExtentsForProperty=function(D){var B=C.prototype.getExtentsForProperty.call(this,D);if(!this._autorangeSmooth||this.autorangeMode()!==
D||"x"!==this.autorangeMode()&&"y"!==this.autorangeMode())return B;D=this._getEdgeIntersectionPoints();var I="y"===this.autorangeMode()?D.left.concat(D.right).map(function(N){return N.y}):D.top.concat(D.bottom).map(function(N){return N.x});return B.map(function(N){return t.extent(t.merge([N,I]))})};G.prototype._getEdgeIntersectionPoints=function(){var D=this;if(!(this.y().scale instanceof u.QuantitativeScale&&this.x().scale instanceof u.QuantitativeScale))return{left:[],right:[],top:[],bottom:[]};
var B=this.y().scale,I=this.x().scale,N={left:[],right:[],top:[],bottom:[]},O=I.scale(I.domain()[0]),H=I.scale(I.domain()[1]),K=B.scale(B.domain()[0]),M=B.scale(B.domain()[1]);this.datasets().forEach(function(L){for(var Q=L.data(),T,X,aa,la,Z,ba,ea,ca=1;ca<Q.length;ca++)la=ba||I.scale(D.x().accessor(Q[ca-1],ca-1,L)),Z=ea||B.scale(D.y().accessor(Q[ca-1],ca-1,L)),ba=I.scale(D.x().accessor(Q[ca],ca,L)),ea=B.scale(D.y().accessor(Q[ca],ca,L)),la<O===O<=ba&&(T=O-la,X=ba-la,aa=ea-Z,T=T*aa/X,N.left.push({x:O,
y:B.invert(Z+T)})),la<H===H<=ba&&(T=H-la,X=ba-la,aa=ea-Z,T=T*aa/X,N.right.push({x:H,y:B.invert(Z+T)})),Z<M===M<=ea&&(X=ba-la,T=M-Z,aa=ea-Z,T=T*X/aa,N.top.push({x:I.invert(la+T),y:M})),Z<K===K<=ea&&(X=ba-la,T=K-Z,aa=ea-Z,T=T*X/aa,N.bottom.push({x:I.invert(la+T),y:K}))});return N};G.prototype._getResetYFunction=function(){var D=this.y().scale.domain(),B=Math.max(D[0],D[1]);D=Math.min(D[0],D[1]);B=0>B&&B||0<D&&D||0;var I=this.y().scale.scale(B);return function(){return I}};G.prototype._generateDrawSteps=
function(){var D=[];if(this._animateOnNextRender()){var B=this._getAttrToProjector();B.d=this._constructLineProjector(y.Plot._scaledAccessor(this.x()),this._getResetYFunction());D.push({attrToProjector:B,animator:this._getAnimator(A.Animator.RESET)})}D.push({attrToProjector:this._getAttrToProjector(),animator:this._getAnimator(A.Animator.MAIN)});return D};G.prototype._generateAttrToProjector=function(){var D=C.prototype._generateAttrToProjector.call(this);Object.keys(D).forEach(function(B){if("d"!==
B){var I=D[B];D[B]=function(N,O,H){return 0<N.length?I(N[0],O,H):null}}});return D};G.prototype.entitiesAt=function(D){D=this.entityNearestByXThenY(D);return null!=D?[D]:[]};G.prototype.entityNearestByXThenY=function(D){var B=Infinity,I=Infinity,N,O=this.bounds();this.entities().forEach(function(H){if(x.Math.within(H.position,O)){var K=Math.abs(D.x-H.position.x),M=Math.abs(D.y-H.position.y);if(K<B||K===B&&M<I)N=H,B=K,I=M}});return N};G.prototype._propertyProjectors=function(){var D=C.prototype._propertyProjectors.call(this);
D.d=this._constructLineProjector(y.Plot._scaledAccessor(this.x()),y.Plot._scaledAccessor(this.y()));return D};G.prototype._constructLineProjector=function(D,B){var I=this;return function(N,O,H){return I._d3LineFactory(H,D,B)(N)}};G.prototype._d3LineFactory=function(D,B,I){function N(O,H,K){var M=B(O,H,K);O=I(O,H,K);return x.Math.isValidNumber(M)&&x.Math.isValidNumber(O)}void 0===B&&(B=y.Plot._scaledAccessor(this.x()));void 0===I&&(I=y.Plot._scaledAccessor(this.y()));return t.line().x(function(O,H){return B(O,
H,D)}).y(function(O,H){return I(O,H,D)}).curve(this._getCurveFactory()).defined(function(O,H){return N(O,H,D)})};G.prototype._getCurveFactory=function(){var D=this.curve();return"string"===typeof D?(D=w[D],null==D?w.linear:D):D};G.prototype._getDataToDraw=function(){var D=this,B=new x.Map;this.datasets().forEach(function(I){var N=I.data();if(D._croppedRenderingEnabled||D._downsamplingEnabled){var O=N.map(function(H,K){return K});D._croppedRenderingEnabled&&(O=D._filterCroppedRendering(I,O));D._downsamplingEnabled&&
(O=D._filterDownsampling(I,O));D._collapseDenseVerticalLinesEnabled&&(O=D._filterDenseLines(I,O));B.set(I,[O.map(function(H){return N[H]})])}else B.set(I,[N])});return B};G.prototype._filterCroppedRendering=function(D,B){function I(aa,la){return x.Math.inRange(aa,0,N.width())&&x.Math.inRange(la,0,N.height())}for(var N=this,O=y.Plot._scaledAccessor(this.x()),H=y.Plot._scaledAccessor(this.y()),K=D.data(),M=[],L=0;L<B.length;L++){var Q=O(K[B[L]],B[L],D),T=H(K[B[L]],B[L],D);Q=I(Q,T);if(!Q&&null!=B[L-
1]&&null!=K[B[L-1]]){T=O(K[B[L-1]],B[L-1],D);var X=H(K[B[L-1]],B[L-1],D);Q=Q||I(T,X)}Q||null==B[L+1]||null==K[B[L+1]]||(T=O(K[B[L+1]],B[L+1],D),X=H(K[B[L+1]],B[L+1],D),Q=Q||I(T,X));Q&&M.push(B[L])}return M};G.prototype._filterDownsampling=function(D,B){function I(ea,ca){var ka=O(N[B[ea]],B[ea],D),Y=H(N[B[ea]],B[ea],D),Ea=O(N[B[ea+1]],B[ea+1],D);ea=H(N[B[ea+1]],B[ea+1],D);return Infinity===ca?Math.floor(ka)===Math.floor(Ea):Math.floor(ea)===Math.floor(Y+(Ea-ka)*ca)}if(0===B.length)return[];for(var N=
D.data(),O=y.Plot._scaledAccessor(this.x()),H=y.Plot._scaledAccessor(this.y()),K=[B[0]],M=0;M<B.length-1;){var L=B[M],Q=O(N[B[M]],B[M],D),T=H(N[B[M]],B[M],D),X=O(N[B[M+1]],B[M+1],D),aa=H(N[B[M+1]],B[M+1],D);aa=Math.floor(Q)===Math.floor(X)?Infinity:(aa-T)/(X-Q);X=B[M];T=Infinity===aa?T:Q;Q=X;for(var la=T,Z=!0;M<B.length-1&&(Z||I(M,aa));){M++;Z=!1;var ba=Infinity===aa?H(N[B[M]],B[M],D):O(N[B[M]],B[M],D);ba>la&&(la=ba,Q=B[M]);ba<T&&(T=ba,X=B[M])}aa=B[M];X!==L&&K.push(X);Q!==X&&Q!==L&&K.push(Q);aa!==
L&&aa!==X&&aa!==Q&&K.push(aa)}return K};G.prototype._filterDenseLines=function(D,B){if(0===B.length)return[];var I=D.data(),N=y.Plot._scaledAccessor(this.x()),O=y.Plot._scaledAccessor(this.y());return this._bucketByX(D,B,function(H){return N(I[H],H,D)},function(H){return O(I[H],H,D)})};G.prototype._bucketByX=function(D,B,I,N){var O=[];D=D.data();for(var H=null,K=0;K<=B.length;++K){var M=B[K];if(null!=D[M]){var L=Math.floor(I(M)),Q=N(M);null==H?H=new x.Bucket(M,L,Q):H.isInBucket(L)?H.addToBucket(Q,
M):(O.push.apply(O,H.getUniqueIndices()),H=new x.Bucket(M,L,Q))}}null!=H&&O.push.apply(O,H.getUniqueIndices());return O};return G}(h.XYPlot);f.Line=h},function(d,f,h){var k=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&(n[x]=q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},t=h(1),l=h(26),p=h(0),m=[0,1];d=function(n){function q(){var u=n.call(this)||this;u._range=[0,1];u._d3Scale=t.scaleBand();u._d3Scale.range(m);
u._d3TransformationScale=t.scaleLinear();u._d3TransformationScale.domain(m);u._innerPadding=q._convertToPlottableInnerPadding();u._outerPadding=q._convertToPlottableOuterPadding();return u}k(q,n);q.prototype.cloneWithoutProviders=function(){var u=(new q).domain(this.domain()).range(this.range()).innerPadding(this.innerPadding()).outerPadding(this.outerPadding());u._d3TransformationScale.domain(this._d3TransformationScale.domain());return u};q.prototype.extentOfValues=function(u){return p.Array.uniq(u)};
q.prototype._getExtent=function(){return p.Array.uniq(this._getAllIncludedValues())};q.prototype.domain=function(u){return n.prototype.domain.call(this,u)};q.prototype.invertRange=function(){var u,x=this;void 0===u&&(u=this.range());var A=this._d3Scale.bandwidth(),y=this.invertedTransformation(u[0]),w=this.invertedTransformation(u[1]);u=this._d3Scale.domain();var C=u.map(function(G){return x._d3Scale(G)+A/2});y=t.bisect(C,y);w=t.bisect(C,w);return u.slice(y,w)};q.prototype.range=function(u){return n.prototype.range.call(this,
u)};q._convertToPlottableInnerPadding=function(){return 1/.7-1};q._convertToPlottableOuterPadding=function(){return.5/.7};q.prototype._setBands=function(){var u=1-1/(1+this.innerPadding()),x=this.outerPadding()/(1+this.innerPadding());this._d3Scale.paddingInner(u);this._d3Scale.paddingOuter(x)};q.prototype.rangeBand=function(){return this._rescaleBand(this._d3Scale.bandwidth())};q.prototype.stepWidth=function(){return this._rescaleBand(this._d3Scale.bandwidth()*(1+this.innerPadding()))};q.prototype.ticks=
function(){return this.domain()};q.prototype.innerPadding=function(u){if(null==u)return this._innerPadding;this._innerPadding=u;this.range(this.range());this._dispatchUpdate();return this};q.prototype.outerPadding=function(u){if(null==u)return this._outerPadding;this._outerPadding=u;this.range(this.range());this._dispatchUpdate();return this};q.prototype.scale=function(u){u=this._d3Scale(u)+this._d3Scale.bandwidth()/2;return this._d3TransformationScale(u)};q.prototype.zoom=function(u,x){var A=this;
this._d3TransformationScale.domain(this._d3TransformationScale.range().map(function(y){return A._d3TransformationScale.invert(l.zoomOut(y,u,x))}));this._dispatchUpdate()};q.prototype.pan=function(u){var x=this;this._d3TransformationScale.domain(this._d3TransformationScale.range().map(function(A){return x._d3TransformationScale.invert(A+u)}));this._dispatchUpdate()};q.prototype.scaleTransformation=function(u){return this._d3TransformationScale(u)};q.prototype.invertedTransformation=function(u){return this._d3TransformationScale.invert(u)};
q.prototype.getTransformationExtent=function(){return m};q.prototype.getTransformationDomain=function(){return this._d3TransformationScale.domain()};q.prototype.setTransformationDomain=function(u){this._d3TransformationScale.domain(u);this._dispatchUpdate()};q.prototype._getDomain=function(){return this._backingScaleDomain()};q.prototype._backingScaleDomain=function(u){if(null==u)return this._d3Scale.domain();this._d3Scale.domain(u);this._setBands();return this};q.prototype._getRange=function(){return this._range};
q.prototype._setRange=function(u){this._range=u;this._d3TransformationScale.range(u);this._setBands()};q.prototype._rescaleBand=function(u){return Math.abs(this._d3TransformationScale(u)-this._d3TransformationScale(0))};return q}(h(17).Scale);f.Category=d},function(d,f,h){function k(w){try{var C=w.node().getBBox()}catch(G){C={x:0,y:0,width:0,height:0}}return C}function t(w){if("number"===typeof w)return{min:w,max:w};if(w instanceof Object&&"min"in w&&"max"in w)return w;throw Error("input '"+w+"' can't be parsed as an Range");
}function l(w,C){w=w.getPropertyValue(C);return parseFloat(w)||0}function p(w){if(null==w||"none"===w)return null;w=w.match(A);if(null==w||2>w.length)return null;w=w[1].split(y).map(function(C){return parseFloat(C)});return 6!=w.length?null:w}var m=h(1),n=Math;f.contains=function(w,C){for(;null!=C&&C!==w;)C=C.parentNode;return C===w};f.elementBBox=k;f.entityBounds=function(w){return w instanceof SVGElement?k(m.select(w)):w instanceof HTMLElement?(w=w.getBoundingClientRect(),{x:w.left,y:w.top,width:w.width,
height:w.height}):{x:0,y:0,width:0,height:0}};f.SCREEN_REFRESH_RATE_MILLISECONDS=1E3/60;f.requestAnimationFramePolyfill=function(w){null!=window.requestAnimationFrame?window.requestAnimationFrame(w):setTimeout(w,f.SCREEN_REFRESH_RATE_MILLISECONDS)};f.elementWidth=function(w){w=w instanceof m.selection?w.node():w;w=window.getComputedStyle(w);return l(w,"width")+l(w,"padding-left")+l(w,"padding-right")+l(w,"border-left-width")+l(w,"border-right-width")};f.elementHeight=function(w){w=w instanceof m.selection?
w.node():w;w=window.getComputedStyle(w);return l(w,"height")+l(w,"padding-top")+l(w,"padding-bottom")+l(w,"border-top-width")+l(w,"border-bottom-width")};var q=/translate\s*\(\s*((?:[-+]?[0-9]*\.?[0-9]+))(?:(?:(?:\s+,?\s*)|(?:,\s*))((?:[-+]?[0-9]*\.?[0-9]+)))?\s*\)/,u=/rotate\s*\(\s*((?:[-+]?[0-9]*\.?[0-9]+))\s*\)/,x=/scale\s*\(\s*((?:[-+]?[0-9]*\.?[0-9]+))(?:(?:(?:\s+,?\s*)|(?:,\s*))((?:[-+]?[0-9]*\.?[0-9]+)))?\s*\)/;f.getTranslateValues=function(w){w=q.exec(w.attr("transform"));if(null!=w){var C=
w[2];return[+w[1],+(void 0===C?0:C)]}return[0,0]};f.getRotate=function(w){w=u.exec(w.attr("transform"));return null!=w?+w[1]:0};f.getScaleValues=function(w){var C=x.exec(w.attr("transform"));return null!=C?(w=C[1],C=C[2],[+w,null==C?+w:+C]):[0,0]};f.clientRectsOverlap=function(w,C){return n.floor(w.right)<=n.ceil(C.left)||n.ceil(w.left)>=n.floor(C.right)||n.floor(w.bottom)<=n.ceil(C.top)||n.ceil(w.top)>=n.floor(C.bottom)?!1:!0};f.expandRect=function(w,C){return{left:w.left-C,top:w.top-C,right:w.right+
C,bottom:w.bottom+C,width:w.width+2*C,height:w.height+2*C}};f.clientRectInside=function(w,C){return n.floor(C.left)<=n.ceil(w.left)&&n.floor(C.top)<=n.ceil(w.top)&&n.floor(w.right)<=n.ceil(C.right)&&n.floor(w.bottom)<=n.ceil(C.bottom)};f.intersectsBBox=function(w,C,G,D){void 0===D&&(D=.5);w=t(w);C=t(C);return G.x+G.width>=w.min-D&&G.x<=w.max+D&&G.y+G.height>=C.min-D&&G.y<=C.max+D};f.getHtmlElementAncestors=function(w){for(var C=[];w&&w instanceof HTMLElement;)C.push(w),w=w.parentElement;return C};
f.getElementTransform=function(w){w=window.getComputedStyle(w,null);w=w.getPropertyValue("-webkit-transform")||w.getPropertyValue("-moz-transform")||w.getPropertyValue("-ms-transform")||w.getPropertyValue("-o-transform")||w.getPropertyValue("transform");return p(w)};var A=/^matrix\(([^)]+)\)$/,y=/[, ]+/},function(d,f,h){function k(u,x){return[u[0]*x[0]+u[2]*x[1],u[1]*x[0]+u[3]*x[1],u[0]*x[2]+u[2]*x[3],u[1]*x[2]+u[3]*x[3],u[0]*x[4]+u[2]*x[5]+u[4],u[1]*x[4]+u[3]*x[5]+u[5]]}function t(u,x){return[u[0],
u[1],u[2],u[3],u[0]*x[0]+u[2]*x[1]+u[4],u[1]*x[0]+u[3]*x[1]+u[5]]}function l(u){var x=u[0]*u[3]-u[1]*u[2];if(0===x)throw Error("singular matrix");x=1/x;return[x*u[3],x*-u[1],x*-u[2],x*u[0],x*(-u[3]*u[4]+u[2]*u[5]),x*(u[1]*u[4]+-u[0]*u[5])]}var p=h(1),m=h(55),n=Math,q=[1,0,0,1,0,0];f.inRange=function(u,x,A){return n.min(x,A)<=u&&u<=n.max(x,A)};f.clamp=function(u,x,A){return n.min(n.max(x,u),A)};f.max=function(u,x,A){var y="function"===typeof x?x:null;x=null==y?x:A;u=null==y?p.max(u):p.max(u,y);return void 0!==
u?u:x};f.min=function(u,x,A){var y="function"===typeof x?x:null;x=null==y?x:A;u=null==y?p.min(u):p.min(u,y);return void 0!==u?u:x};f.isNaN=function(u){return u!==u};f.isValidNumber=function(u){return"number"===typeof u&&1>u-u};f.range=function(u,x,A){void 0===A&&(A=1);if(0===A)throw Error("step cannot be 0");x=n.max(n.ceil((x-u)/A),0);for(var y=[],w=0;w<x;++w)y[w]=u+A*w;return y};f.distanceSquared=function(u,x){return n.pow(x.y-u.y,2)+n.pow(x.x-u.x,2)};f.degreesToRadians=function(u){return u/360*
n.PI*2};f.within=function(u,x){return x.topLeft.x<=u.x&&x.bottomRight.x>=u.x&&x.topLeft.y<=u.y&&x.bottomRight.y>=u.y};f.boundsIntersects=function(u,x,A,y,w,C){return u<=0+w&&0<=u+A&&x<=0+C&&0<=x+y};f.getCumulativeTransform=function(u){u=m.getHtmlElementAncestors(u);for(var x=q,A=null,y=0;y<u.length;y++){var w=u[y],C=m.getElementTransform(w);if(null!=C){var G=w.clientWidth/2,D=w.clientHeight/2;x=t(x,[G,D]);x=k(x,l(C));x=t(x,[-G,-D])}C=w.scrollLeft;G=w.scrollTop;if(null===A||w===A)C-=w.offsetLeft+w.clientLeft,
G-=w.offsetTop+w.clientTop,A=w.offsetParent;x=t(x,[C,G])}return x};f.multiplyMatrix=k;f.premultiplyTranslate=function(u,x){return[x[0],x[1],x[2],x[3],x[4]+u[0],x[5]+u[1]]};f.multiplyTranslate=t;f.invertMatrix=l;f.applyTransform=function(u,x){return{x:u[0]*x.x+u[2]*x.y+u[4],y:u[1]*x.x+u[3]*x.y+u[5]}}},function(d,f,h){var k=new (h(114).SplitStrategyLinear);d=function(){function p(m,n){void 0===m&&(m=5);void 0===n&&(n=k);this.maxNodeChildren=m;this.splitStrategy=n;this.root=new t(!0);this.size=0}p.prototype.getRoot=
function(){return this.root};p.prototype.clear=function(){this.root=new t(!0);this.size=0};p.prototype.insert=function(m,n){for(var q=this.root;!q.leaf;)q=q.subtree(m);m=t.valueNode(m,n);q.insert(m);for(this.size+=1;q.overflow(this.maxNodeChildren);)q=q.split(this.splitStrategy),null==q.parent&&(this.root=q)};p.prototype.locate=function(m){return this.query(function(n){return n.contains(m)})};p.prototype.intersect=function(m){return this.query(function(n){return l.isBoundsOverlapBounds(n,m)})};p.prototype.intersectX=
function(m){return this.query(function(n){return l.isBoundsOverlapX(n,m)})};p.prototype.intersectY=function(m){return this.query(function(n){return l.isBoundsOverlapY(n,m)})};p.prototype.query=function(m){var n=[];if(null!=this.root.bounds&&!m(this.root.bounds))return n;for(var q=[this.root];0<q.length;)for(var u=q.shift(),x=0;x<u.entries.length;x++){var A=u.entries[x];m(A.bounds)&&(u.leaf?n.push(A.value):q.push(A))}return n};return p}();f.RTree=d;var t=function(){function p(m){this.leaf=m;this.bounds=
null;this.entries=[];this.value=this.parent=null}p.valueNode=function(m,n){var q=new p(!0);q.bounds=m;q.value=n;return q};p.prototype.overflow=function(m){return this.entries.length>m};p.prototype.insert=function(m){this.entries.push(m);m.parent=this;for(var n=this;null!=n;)n.bounds=l.unionAll([n.bounds,m.bounds]),n=n.parent};p.prototype.remove=function(m){m=this.entries.indexOf(m);if(0<=m)for(this.entries.splice(m,1),m=this;null!=m;)m.bounds=l.unionAll(m.entries.map(function(n){return n.bounds})),
m=m.parent;return this};p.prototype.subtree=function(m){for(var n=null,q=0;q<this.entries.length;q++){var u=this.entries[q],x=u.unionAreaDifference(m);if(Infinity>x||Infinity===x&&null!=n&&u.entries.length<n.entries.length)n=u}return n};p.prototype.split=function(m){null!=this.parent&&this.parent.remove(this);var n=[new p(this.leaf),new p(this.leaf)];m.split(this.entries,n);m=null!=this.parent?this.parent:new p(!1);m.insert(n[0]);m.insert(n[1]);return m};p.prototype.unionAreaDifference=function(m){return Math.abs(l.union(this.bounds,
m).area()-this.bounds.area())};p.prototype.maxDepth=function(){return this.leaf?1:1+this.entries.map(function(m){return m.maxDepth()}).reduce(function(m,n){return Math.max(m,n)})};return p}();f.RTreeNode=t;var l=function(){function p(m,n,q,u){this.xl=m;this.yl=n;this.xh=q;this.yh=u;this.width=this.xh-this.xl;this.height=this.yh-this.yl}p.xywh=function(m,n,q,u){return new p(m,n,m+q,n+u)};p.entityBounds=function(m){return new p(m.x,m.y,m.x+m.width,m.y+m.height)};p.bounds=function(m){return p.pointPair(m.topLeft,
m.bottomRight)};p.pointPair=function(m,n){return new p(Math.min(m.x,n.x),Math.min(m.y,n.y),Math.max(m.x,n.x),Math.max(m.y,n.y))};p.points=function(m){if(2>m.length)throw Error("need at least 2 points to create bounds");var n=m.map(function(q){return q.x});m=m.map(function(q){return q.y});return new p(n.reduce(function(q,u){return Math.min(q,u)}),m.reduce(function(q,u){return Math.min(q,u)}),n.reduce(function(q,u){return Math.max(q,u)}),m.reduce(function(q,u){return Math.max(q,u)}))};p.union=function(m,
n){return new p(Math.min(m.xl,n.xl),Math.min(m.yl,n.yl),Math.max(m.xh,n.xh),Math.max(m.yh,n.yh))};p.unionAll=function(m){m=m.filter(function(n){return null!=n});return 0===m.length?null:m.reduce(function(n,q){return p.union(n,q)})};p.isBoundsOverlapBounds=function(m,n){return p.isBoundsOverlapX(m,n)&&p.isBoundsOverlapY(m,n)};p.isBoundsOverlapX=function(m,n){return!(m.xh<n.xl)&&!(m.xl>n.xh)};p.isBoundsOverlapY=function(m,n){return!(m.yh<n.yl)&&!(m.yl>n.yh)};p.prototype.area=function(){null==this.areaCached&&
(this.areaCached=(this.xh-this.xl)*(this.yh-this.yl));return this.areaCached};p.prototype.contains=function(m){return this.xl<=m.x&&this.xh>=m.x&&this.yl<=m.y&&this.yh>=m.y};return p}();f.RTreeBounds=l},function(d,f){d=function(){function h(){"function"===typeof window.Set?this._es6Set=new window.Set:this._values=[];this.size=0}h.prototype.add=function(k){if(null!=this._es6Set)return this._es6Set.add(k),this.size=this._es6Set.size,this;this.has(k)||(this._values.push(k),this.size=this._values.length);
return this};h.prototype.delete=function(k){if(null!=this._es6Set)return k=this._es6Set.delete(k),this.size=this._es6Set.size,k;k=this._values.indexOf(k);return-1!==k?(this._values.splice(k,1),this.size=this._values.length,!0):!1};h.prototype.has=function(k){return null!=this._es6Set?this._es6Set.has(k):-1!==this._values.indexOf(k)};h.prototype.forEach=function(k,t){var l=this;null!=this._es6Set?this._es6Set.forEach(function(p,m){return k.call(t,p,m,l)},t):this._values.forEach(function(p){k.call(t,
p,p,l)})};return h}();f.Set=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(131));k(h(130))},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(21);d=function(l){function p(m,n){var q=l.call(this,m,n)||this;q.cache=new t.Cache(function(u){return q._measureCharacterNotFromCache(u)});return q}k(p,l);p.prototype._measureCharacterNotFromCache=
function(m){return l.prototype._measureCharacter.call(this,m)};p.prototype._measureCharacter=function(m){return this.cache.get(m)};p.prototype.reset=function(){this.cache.clear()};return p}(h(61).CharacterMeasurer);f.CacheCharacterMeasurer=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){return t.apply(this,arguments)||
this}k(l,t);l.prototype._measureCharacter=function(p){return t.prototype._measureLine.call(this,p)};l.prototype._measureLine=function(p){var m=this;p=p.split("").map(function(n){return m._measureCharacter(n)});return{height:p.reduce(function(n,q){return Math.max(n,q.height)},0),width:p.reduce(function(n,q){return n+q.width},0)}};return l}(h(63).Measurer);f.CharacterMeasurer=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(36));k(h(60));k(h(132));k(h(61));k(h(63))},
function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(36);d=function(l){function p(m,n){void 0===n&&(n=!1);m=l.call(this,m)||this;m.useGuards=n;return m}k(p,l);p.prototype._addGuards=function(m){return t.AbstractMeasurer.HEIGHT_TEXT+m+t.AbstractMeasurer.HEIGHT_TEXT};p.prototype._measureLine=function(m){var n;void 0===n&&(n=!1);n=this.useGuards||
n||/^[\t ]$/.test(m);m=l.prototype.measure.call(this,n?this._addGuards(m):m);m.width-=n?2*this.getGuardWidth():0;return m};p.prototype.measure=function(m){var n=this;void 0===m&&(m=t.AbstractMeasurer.HEIGHT_TEXT);if(""===m.trim())return{width:0,height:0};m=m.trim().split("\n").map(function(q){return n._measureLine(q)});return{height:m.reduce(function(q,u){return q+u.height},0),width:m.reduce(function(q,u){return Math.max(q,u.width)},0)}};p.prototype.getGuardWidth=function(){null==this.guardWidth&&
(this.guardWidth=l.prototype.measure.call(this).width);return this.guardWidth};return p}(t.AbstractMeasurer);f.Measurer=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(138));k(h(65))},function(d,f,h){var k=h(21);d=function(){function t(){this.maxLines(Infinity);this.textTrimming();this.allowBreakingWords();this._tokenizer=new k.Tokenizer;this._breakingCharacter="-"}t.prototype.maxLines=function(l){if(null==l)return this._maxLines;this._maxLines=l;return this};
t.prototype.textTrimming=function(){this._textTrimming="ellipsis"};t.prototype.allowBreakingWords=function(){this._allowBreakingWords=!0};t.prototype.wrap=function(l,p,m,n){var q=this;void 0===n&&(n=Infinity);var u={noBrokeWords:0,noLines:0,originalText:l,truncatedText:"",wrappedText:""};m={availableLines:Math.min(Math.floor(n/p.measure().height),this._maxLines),availableWidth:m,canFitText:!0,currentLine:"",wrapping:u};var x=l.split("\n");return x.reduce(function(A,y,w){return q.breakLineToFitWidth(A,
y,w!==x.length-1,p)},m).wrapping};t.prototype.breakLineToFitWidth=function(l,p,m,n){var q=this;l.canFitText||""===l.wrapping.truncatedText||(l.wrapping.truncatedText+="\n");l=this._tokenizer.tokenize(p).reduce(function(u,x){return q.wrapNextToken(x,u,n)},l);p=k.StringMethods.trimEnd(l.currentLine);l.wrapping.noLines+=+(""!==p);l.wrapping.noLines===l.availableLines&&"none"!==this._textTrimming&&m?l.canFitText=!1:l.wrapping.wrappedText+=p;l.currentLine="\n";return l};t.prototype.canFitToken=function(l,
p,m){var n=this,q=this._allowBreakingWords?l.split("").map(function(u,x){return x!==l.length-1?u+n._breakingCharacter:u}):[l];return m.measure(l).width<=p||q.every(function(u){return m.measure(u).width<=p})};t.prototype.addEllipsis=function(l,p,m){if("none"===this._textTrimming)return{remainingToken:"",wrappedToken:l};var n=l.substring(0).trim(),q=m.measure(n).width,u=m.measure("...").width,x=0<l.length&&"\n"===l[0]?"\n":"";if(p<=u)return{remainingToken:l,wrappedToken:x+"...".substr(0,Math.floor(p/
(u/3)))};for(;q+u>p;)n=k.StringMethods.trimEnd(n.substr(0,n.length-1)),q=m.measure(n).width;return{remainingToken:k.StringMethods.trimEnd(l.substring(n.length),"-").trim(),wrappedToken:x+n+"..."}};t.prototype.wrapNextToken=function(l,p,m){if(!p.canFitText||p.availableLines===p.wrapping.noLines||!this.canFitToken(l,p.availableWidth,m))return this.finishWrapping(l,p,m);for(;l;){var n=this.breakTokenToFitInWidth(l,p.currentLine,p.availableWidth,m);p.currentLine=n.line;l=n.remainingToken;if(null!=l)if(p.wrapping.noBrokeWords+=
+n.breakWord,++p.wrapping.noLines,p.availableLines===p.wrapping.noLines){m=this.addEllipsis(p.currentLine,p.availableWidth,m);p.wrapping.wrappedText+=m.wrappedToken;p.wrapping.truncatedText+=m.remainingToken+l;p.currentLine="\n";break}else p.wrapping.wrappedText+=k.StringMethods.trimEnd(p.currentLine),p.currentLine="\n"}return p};t.prototype.finishWrapping=function(l,p,m){p.canFitText&&p.availableLines!==p.wrapping.noLines&&this._allowBreakingWords&&"none"!==this._textTrimming?(m=this.addEllipsis(p.currentLine+
l,p.availableWidth,m),p.wrapping.wrappedText+=m.wrappedToken,p.wrapping.truncatedText+=m.remainingToken,p.wrapping.noBrokeWords+=+(m.remainingToken.length<l.length),p.wrapping.noLines+=+(0<m.wrappedToken.length),p.currentLine=""):p.wrapping.truncatedText+=l;p.canFitText=!1;return p};t.prototype.breakTokenToFitInWidth=function(l,p,m,n){if(void 0===q)var q=this._breakingCharacter;if(n.measure(p+l).width<=m)return{breakWord:!1,line:p+l,remainingToken:null};if(""===l.trim())return{breakWord:!1,line:p,
remainingToken:""};if(!this._allowBreakingWords)return{breakWord:!1,line:p,remainingToken:l};for(var u=0;u<l.length;)if(n.measure(p+l.substring(0,u+1)+q).width<=m)++u;else break;m="";0<u&&(m=q);return{breakWord:0<u,line:p+l.substring(0,u)+m,remainingToken:l.substring(u)}};return t}();f.Wrapper=d},function(d,f,h){(function(k){for(var t in k)f.hasOwnProperty(t)||(f[t]=k[t])})(h(139))},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}k(h(72));k(h(73));k(h(28))},function(d,
f){f.version="3.7.0"},function(d,f,h){function k(w,C){return w.each(function(){var G=C.apply(this,arguments),D=y.select(this),B;for(B in G)D.attr(B,G[B])})}function t(w,C){for(var G in C)w.attr(G,C[G]);return w}function l(w,C,G){return w.each(function(){var D=C.apply(this,arguments),B=y.select(this),I;for(I in D)B.style(I,D[I],G)})}function p(w,C,G){for(var D in C)w.style(D,C[D],G);return w}function m(w,C){return w.each(function(){var G=C.apply(this,arguments),D=y.select(this),B;for(B in G)D.property(B,
G[B])})}function n(w,C){for(var G in C)w.property(G,C[G]);return w}function q(w,C){return w.each(function(){var G=C.apply(this,arguments),D=y.select(this).transition(w),B;for(B in G)D.attr(B,G[B])})}function u(w,C){for(var G in C)w.attr(G,C[G]);return w}function x(w,C,G){return w.each(function(){var D=C.apply(this,arguments),B=y.select(this).transition(w),I;for(I in D)B.style(I,D[I],G)})}function A(w,C,G){for(var D in C)w.style(D,C[D],G);return w}var y=d=h(1);y.selection.prototype.attrs=function(w){return("function"===
typeof w?k:t)(this,w)};y.selection.prototype.styles=function(w){return("function"===typeof w?l:p)(this,w,"")};y.selection.prototype.properties=function(w){return("function"===typeof w?m:n)(this,w)};d.transition.prototype.attrs=function(w){return("function"===typeof w?q:u)(this,w)};d.transition.prototype.styles=function(w){return("function"===typeof w?x:A)(this,w,"")}},function(d,f,h){d=h(117);var k=h(12);h=h(10);var t={linear:d.easeLinear,quad:d.easeQuad,quadIn:d.easeQuadIn,quadOut:d.easeQuadOut,
quadInOut:d.easeQuadInOut,cubic:d.easeCubic,cubicIn:d.easeCubicIn,cubicOut:d.easeCubicOut,cubicInOut:d.easeCubicInOut,poly:d.easePoly,polyIn:d.easePolyIn,polyOut:d.easePolyOut,polyInOut:d.easePolyInOut,sin:d.easeSin,sinIn:d.easeSinIn,sinOut:d.easeSinOut,sinInOut:d.easeSinInOut,exp:d.easeExp,expIn:d.easeExpIn,expOut:d.easeExpOut,expInOut:d.easeExpInOut,circle:d.easeCircle,circleIn:d.easeCircleIn,circleOut:d.easeCircleOut,circleInOut:d.easeCircleInOut,bounce:d.easeBounce,bounceIn:d.easeBounceIn,bounceOut:d.easeBounceOut,
bounceInOut:d.easeBounceInOut,back:d.easeBack,backIn:d.easeBackIn,backOut:d.easeBackOut,backInOut:d.easeBackInOut,elastic:d.easeElastic,elasticIn:d.easeElasticIn,elasticOut:d.easeElasticOut,elasticInOut:d.easeElasticInOut};f.EaseName=h.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".split(" "));
h=function(){function l(){this._startDelay=l._DEFAULT_START_DELAY_MILLISECONDS;this._stepDuration=l._DEFAULT_STEP_DURATION_MILLISECONDS;this._stepDelay=l._DEFAULT_ITERATIVE_DELAY_MILLISECONDS;this._maxTotalDuration=l._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS;this._easingMode=l._DEFAULT_EASING_MODE}l.prototype.totalTime=function(p){var m=this._getAdjustedIterativeDelay(p);return this.startDelay()+m*Math.max(p-1,0)+this.stepDuration()};l.prototype.animate=function(p,m){var n=this;p=k.coerceExternalD3(p);
var q=p.size(),u=this._getAdjustedIterativeDelay(q);return p.transition().ease(this._getEaseFactory()).duration(this.stepDuration()).delay(function(x,A){return n.startDelay()+u*A}).attrs(m)};l.prototype.startDelay=function(p){if(null==p)return this._startDelay;this._startDelay=p;return this};l.prototype.stepDuration=function(p){if(null==p)return Math.min(this._stepDuration,this._maxTotalDuration);this._stepDuration=p;return this};l.prototype.stepDelay=function(){return this._stepDelay};l.prototype.maxTotalDuration=
function(p){if(null==p)return this._maxTotalDuration;this._maxTotalDuration=p;return this};l.prototype.easingMode=function(p){if(null==p)return this._easingMode;this._easingMode=p;return this};l.prototype._getEaseFactory=function(){var p=this.easingMode();return"string"===typeof p?(p=t[p],null==p?t.linear:p):p};l.prototype._getAdjustedIterativeDelay=function(p){var m=this.maxTotalDuration()-this.stepDuration();m=Math.max(m,0);p=m/Math.max(p-1,1);return Math.min(this.stepDelay(),p)};return l}();h._DEFAULT_START_DELAY_MILLISECONDS=
0;h._DEFAULT_STEP_DURATION_MILLISECONDS=300;h._DEFAULT_ITERATIVE_DELAY_MILLISECONDS=15;h._DEFAULT_MAX_TOTAL_DURATION_MILLISECONDS=Infinity;h._DEFAULT_EASING_MODE="expOut";f.Easing=h},function(d,f,h){var k=h(12);d=function(){function t(){}t.prototype.totalTime=function(){return 0};t.prototype.animate=function(l,p){l=k.coerceExternalD3(l);return l.attrs(p)};return t}();f.Null=d},function(d,f,h){var k=this&&this.__extends||function(q,u){function x(){this.constructor=q}for(var A in u)u.hasOwnProperty(A)&&
(q[A]=u[A]);q.prototype=null===u?Object.create(u):(x.prototype=u.prototype,new x)},t=h(1),l=h(5),p=h(4),m=h(0),n=h(22);d=function(q){function u(x,A){void 0===A&&(A="bottom");x=q.call(this,x,A)||this;x._tickLabelAngle=0;x._tickLabelShearAngle=0;x.addClass("category-axis");return x}k(u,q);Object.defineProperty(u.prototype,"_wrapper",{get:function(){var x=new l.Wrapper;null!=this._tickLabelMaxLines&&x.maxLines(this._tickLabelMaxLines);return x},enumerable:!0,configurable:!0});Object.defineProperty(u.prototype,
"_writer",{get:function(){return new l.Writer(this._measurer,this._typesetterContext,this._wrapper)},enumerable:!0,configurable:!0});u.prototype._setup=function(){q.prototype._setup.call(this);this._typesetterContext=new l.SvgContext(this._tickLabelContainer.node());this._measurer=new l.CacheMeasurer(this._typesetterContext)};u.prototype._rescale=function(){return this.redraw()};u.prototype.requestedSpace=function(x,A){var y=this.isHorizontal()?0:this._tickSpaceRequired()+this.margin(),w=this.isHorizontal()?
this._tickSpaceRequired()+this.margin():0;if(0===this._scale.domain().length)return{minWidth:0,minHeight:0};if(this.annotationsEnabled()){var C=this._annotationTierHeight()*this.annotationTierCount();this.isHorizontal()?w+=C:y+=C}x=this._measureTickLabels(x,A);return{minWidth:x.usedWidth+y,minHeight:x.usedHeight+w}};u.prototype._coreSize=function(){var x=this.isHorizontal()?this.height():this.width(),A=this.isHorizontal()?this.requestedSpace(this.width(),this.height()).minHeight:this.requestedSpace(this.width(),
this.height()).minWidth,y=this.margin()+this._annotationTierHeight();return Math.min(A-y,x)};u.prototype._getTickValues=function(){return this.getDownsampleInfo().domain};u.prototype._sizeFromOffer=function(x,A){return p.Component.prototype._sizeFromOffer.call(this,x,A)};u.prototype.getDownsampleInfo=function(x){var A;void 0===x&&(x=this._scale);void 0===A&&(A=x.invertRange());var y=Math.ceil(u._MINIMUM_WIDTH_PER_LABEL_PX*(0===this._tickLabelAngle?1:1/Math.cos(this._tickLabelShearAngle/180*Math.PI))/
x.stepWidth());return{domain:A.filter(function(w,C){return 0===C%y}),stepWidth:y*x.stepWidth()}};u.prototype.tickLabelAngle=function(){return this._tickLabelAngle;throw Error("Angle undefined not supported; only 0, 90, and -90 are valid values");};u.prototype.tickLabelShearAngle=function(){return this._tickLabelShearAngle};u.prototype.tickLabelMaxWidth=function(x){if(0===arguments.length)return this._tickLabelMaxWidth;this._tickLabelMaxWidth=x;this.redraw();return this};u.prototype.tickLabelMaxLines=
function(x){if(0===arguments.length)return this._tickLabelMaxLines;this._tickLabelMaxLines=x;this.redraw();return this};u.prototype._tickSpaceRequired=function(){return this._maxLabelTickLength()+this.tickLabelPadding()};u.prototype._drawTicks=function(x,A){var y=this;switch(this.tickLabelAngle()){case 0:var w={left:"right",right:"left",top:"center",bottom:"center"};var C={left:"center",right:"center",top:"bottom",bottom:"top"};break;case 90:w={left:"center",right:"center",top:"right",bottom:"left"};
C={left:"top",right:"bottom",top:"center",bottom:"center"};break;case -90:w={left:"center",right:"center",top:"left",bottom:"right"},C={left:"bottom",right:"top",top:"center",bottom:"center"}}A.each(function(G){var D=t.select(this),B=y.isHorizontal()?x:y.width()-y._tickSpaceRequired(),I=y.isHorizontal()?y.height()-y._tickSpaceRequired():x,N={xAlign:w[y.orientation()],yAlign:C[y.orientation()],textRotation:y.tickLabelAngle(),textShear:y.tickLabelShearAngle()};if(null!=y._tickLabelMaxWidth){if("left"===
y.orientation()&&B>y._tickLabelMaxWidth){var O=B-y._tickLabelMaxWidth;O=D.attr("transform")+" translate("+O+", 0)";D.attr("transform",O)}B=Math.min(B,y._tickLabelMaxWidth)}y._writer.write(y.formatter()(G),B,I,N,D.node())})};u.prototype._measureTickLabels=function(x,A){var y=this,w=this._scale.cloneWithoutProviders().range([0,this.isHorizontal()?x:A]),C=this.getDownsampleInfo(w);w=C.domain;C=C.stepWidth;var G=x-this._tickSpaceRequired();this.isHorizontal()&&(G=C,0!==this._tickLabelAngle&&(G=A-this._tickSpaceRequired()),
G=Math.max(G,0));var D=C;this.isHorizontal()&&(D=A-this._tickSpaceRequired(),0!==this._tickLabelAngle&&(D=x-this._tickSpaceRequired()),D=Math.max(D,0));null!=this._tickLabelMaxWidth&&(G=Math.min(G,this._tickLabelMaxWidth));A=w.map(function(B){return y._wrapper.wrap(y.formatter()(B),y._measurer,G,D)});x=this.isHorizontal()&&0===this._tickLabelAngle?t.sum:m.Math.max;w=this.isHorizontal()&&0===this._tickLabelAngle?m.Math.max:t.sum;x=x(A,function(B){return y._measurer.measure(B.wrappedText).width},0);
A=w(A,function(B){return y._measurer.measure(B.wrappedText).height},0);0!==this._tickLabelAngle&&(A=[A,x],x=A[0],A=A[1]);return{usedWidth:x,usedHeight:A}};u.prototype.renderImmediately=function(){var x=this;q.prototype.renderImmediately.call(this);var A=this._scale,y=this.getDownsampleInfo(A),w=y.domain,C=y=y.stepWidth;this.isHorizontal()&&null!=this._tickLabelMaxWidth&&(C=Math.min(C,this._tickLabelMaxWidth));w=this._tickLabelContainer.selectAll("."+n.Axis.TICK_LABEL_CLASS).data(w);var G=w.enter().append("g").classed(n.Axis.TICK_LABEL_CLASS,
!0).merge(w);w.exit().remove();G.attr("transform",function(D){var B=A.scale(D)-C/2;D=x.isHorizontal()?B:0;B=x.isHorizontal()?0:B;return"translate("+D+","+B+")"});G.text("");this._drawTicks(y,G);y="right"===this.orientation()?this._tickSpaceRequired():0;w="bottom"===this.orientation()?this._tickSpaceRequired():0;this._tickLabelContainer.attr("transform","translate("+y+","+w+")");this._showAllTickMarks();this._showAllTickLabels();this._hideTickMarksWithoutLabel();return this};u.prototype.computeLayout=
function(x,A,y){q.prototype.computeLayout.call(this,x,A,y);this.isHorizontal()||this._scale.range([0,this.height()]);return this};u.prototype.invalidateCache=function(){q.prototype.invalidateCache.call(this);this._measurer.reset()};return u}(n.Axis);d._MINIMUM_WIDTH_PER_LABEL_PX=15;f.Category=d},function(d,f,h){var k=this&&this.__extends||function(q,u){function x(){this.constructor=q}for(var A in u)u.hasOwnProperty(A)&&(q[A]=u[A]);q.prototype=null===u?Object.create(u):(x.prototype=u.prototype,new x)},
t=h(1),l=h(5),p=h(8),m=h(0),n=h(22);d=function(q){function u(x,A){x=q.call(this,x,A)||this;x._tickLabelPositioning="center";x._usesTextWidthApproximation=!1;x.formatter(p.general());return x}k(u,q);u.prototype._setup=function(){q.prototype._setup.call(this);var x=new l.SvgContext(this._tickLabelContainer.node(),n.Axis.TICK_LABEL_CLASS);this._measurer=new l.CacheMeasurer(x);this._wrapper=(new l.Wrapper).maxLines(1)};u.prototype._computeWidth=function(){var x=this._usesTextWidthApproximation?this._computeApproximateTextWidth():
this._computeExactTextWidth();return"center"===this._tickLabelPositioning?this._maxLabelTickLength()+this.tickLabelPadding()+x:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+x)};u.prototype._computeExactTextWidth=function(){var x=this,A=this._getTickValues().map(function(y){y=x.formatter()(y);return x._measurer.measure(y).width});return m.Math.max(A,0)};u.prototype._computeApproximateTextWidth=function(){var x=this,A=this._getTickValues(),y=this._measurer.measure("M").width;A=A.map(function(w){return x.formatter()(w).length*
y});return m.Math.max(A,0)};u.prototype._computeHeight=function(){var x=this._measurer.measure().height;return"center"===this._tickLabelPositioning?this._maxLabelTickLength()+this.tickLabelPadding()+x:Math.max(this._maxLabelTickLength(),this.tickLabelPadding()+x)};u.prototype._getTickValues=function(){var x=this._scale,A=x.domain(),y=A[0]<=A[1]?A[0]:A[1],w=A[0]>=A[1]?A[0]:A[1];return x.ticks().filter(function(C){return C>=y&&C<=w})};u.prototype._rescale=function(){if(this._isSetup){if(!this.isHorizontal()){var x=
this._computeWidth();if(x>this.width()||x<this.width()-this.margin()){this.redraw();return}}this.render()}};u.prototype.renderImmediately=function(){var x=this;q.prototype.renderImmediately.call(this);var A={x:0,y:0,dx:"0em",dy:"0.3em"},y=this._maxLabelTickLength(),w=this.tickLabelPadding(),C="middle",G=0,D=0,B=0,I=0;if(this.isHorizontal())switch(this._tickLabelPositioning){case "left":C="end";G=-w;I=w;break;case "center":I=y+w;break;case "right":C="start",I=G=w}else switch(this._tickLabelPositioning){case "top":A.dy=
"-0.3em";B=w;D=-w;break;case "center":B=y+w;break;case "bottom":A.dy="1em",D=B=w}y=this._generateTickMarkAttrHash();switch(this.orientation()){case "bottom":A.x=y.x1;A.dy="0.95em";D=y.y1+I;break;case "top":A.x=y.x1;A.dy="-.25em";D=y.y1-I;break;case "left":C="end";G=y.x1-B;A.y=y.y1;break;case "right":C="start",G=y.x1+B,A.y=y.y1}B=this._getTickValues();B=this._tickLabelContainer.selectAll("."+n.Axis.TICK_LABEL_CLASS).data(B);B.exit().remove();B.enter().append("text").classed(n.Axis.TICK_LABEL_CLASS,
!0).merge(B).style("text-anchor",C).style("visibility","inherit").attrs(A).text(function(N){return x.formatter()(N)});this._tickLabelContainer.attr("transform","translate("+G+", "+D+")");this._showAllTickMarks();this.showEndTickLabels()||this._hideEndTickLabels();this._hideOverflowingTickLabels();this._hideOverlappingTickLabels();"center"!==this._tickLabelPositioning&&this._hideTickMarksWithoutLabel();return this};u.prototype.tickLabelPosition=function(x){if(null==x)return this._tickLabelPositioning;
x=x.toLowerCase();if(this.isHorizontal()){if("left"!==x&&"center"!==x&&"right"!==x)throw Error(x+" is not a valid tick label position for a horizontal NumericAxis");}else if("top"!==x&&"center"!==x&&"bottom"!==x)throw Error(x+" is not a valid tick label position for a vertical NumericAxis");this._tickLabelPositioning=x;this.redraw();return this};u.prototype.usesTextWidthApproximation=function(){this._usesTextWidthApproximation=!0};u.prototype._hideEndTickLabels=function(){var x=this.element().node().getBoundingClientRect(),
A=this._tickLabelContainer.selectAll("."+n.Axis.TICK_LABEL_CLASS);if(0!==A.size()){var y=A.nodes()[0];m.DOM.clientRectInside(y.getBoundingClientRect(),x)||t.select(y).style("visibility","hidden");A=A.nodes()[A.size()-1];m.DOM.clientRectInside(A.getBoundingClientRect(),x)||t.select(A).style("visibility","hidden")}};u.prototype._hideOverlappingTickLabels=function(){for(var x=this._tickLabelContainer.selectAll("."+n.Axis.TICK_LABEL_CLASS).filter(function(){var w=t.select(this).style("visibility");return"inherit"===
w||"visible"===w}),A=x.nodes().map(function(w){return w.getBoundingClientRect()}),y=1;!this._hasOverlapWithInterval(y,A)&&y<A.length;)y+=1;x.each(function(w,C){w=t.select(this);0!==C%y&&w.style("visibility","hidden")})};u.prototype._hasOverlapWithInterval=function(x,A){var y="center"===this._tickLabelPositioning?this.tickLabelPadding():3*this.tickLabelPadding();A=A.map(function(C){return m.DOM.expandRect(C,y)});for(var w=0;w<A.length-x;w+=x)if(m.DOM.clientRectsOverlap(A[w],A[w+x]))return!1;return!0};
u.prototype.invalidateCache=function(){q.prototype.invalidateCache.call(this);this._measurer.reset()};return u}(n.Axis);f.Numeric=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)};d=h(42);var t=h(25),l=h(0);h=function(p){function m(n){function q(){w&&(w=!1,y._dragEndCallbacks.callCallbacks(y))}function u(C,G){w&&(y._setPixelPositionWithoutChangingMode(y._isVertical()?
G.x:G.y),y._dragCallbacks.callCallbacks(y))}function x(C){A(C)&&(w=!0,y._dragStartCallbacks.callCallbacks(y))}function A(C){return y._isVertical()&&y.pixelPosition()-y.detectionRadius()<=C.x&&C.x<=y.pixelPosition()+y.detectionRadius()||!y._isVertical()&&y.pixelPosition()-y.detectionRadius()<=C.y&&C.y<=y.pixelPosition()+y.detectionRadius()}var y=p.call(this,n)||this;y._detectionRadius=3;y._enabled=!0;y.addClass("drag-line-layer");y.addClass("enabled");y._dragInteraction=new t.Drag;y._dragInteraction.attachTo(y);
var w=!1;y._dragInteraction.onDragStart(x);y._dragInteraction.onDrag(u);y._dragInteraction.onDragEnd(q);y._disconnectInteraction=function(){y._dragInteraction.offDragStart(x);y._dragInteraction.offDrag(u);y._dragInteraction.offDragEnd(q);y._dragInteraction.detach()};y._dragStartCallbacks=new l.CallbackSet;y._dragCallbacks=new l.CallbackSet;y._dragEndCallbacks=new l.CallbackSet;return y}k(m,p);m.prototype._setup=function(){p.prototype._setup.call(this);this._detectionEdge=this.content().append("line").styles({opacity:0,
stroke:"pink","pointer-events":"visibleStroke"}).classed("drag-edge",!0)};m.prototype.renderImmediately=function(){p.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":2*this._detectionRadius});return this};m.prototype.detectionRadius=function(){return this._detectionRadius};
m.prototype.enabled=function(n){if(null==n)return this._enabled;(this._enabled=n)?this.addClass("enabled"):this.removeClass("enabled");this._dragInteraction.enabled(n);return this};m.prototype.onDragStart=function(n){this._dragStartCallbacks.add(n)};m.prototype.offDragStart=function(n){this._dragStartCallbacks.delete(n)};m.prototype.onDrag=function(n){this._dragCallbacks.add(n);return this};m.prototype.offDrag=function(n){this._dragCallbacks.delete(n)};m.prototype.onDragEnd=function(n){this._dragEndCallbacks.add(n)};
m.prototype.offDragEnd=function(n){this._dragEndCallbacks.delete(n)};m.prototype.destroy=function(){var n=this;p.prototype.destroy.call(this);this._dragStartCallbacks.forEach(function(q){return n._dragStartCallbacks.delete(q)});this._dragCallbacks.forEach(function(q){return n._dragCallbacks.delete(q)});this._dragEndCallbacks.forEach(function(q){return n._dragEndCallbacks.delete(q)});this._disconnectInteraction()};return m}(d.GuideLineLayer);f.DragLineLayer=h},function(d,f,h){function k(l,p,m){var n=
{};if(void 0!==m)for(var q=0;q<m.length;q++)n[m[q]]=m[q-1];return function(u){var x=l.scale(u);if(!p)return x;var A;u=void 0===n[u]?void 0:l.scale(n[u]);void 0!==u&&(A=u+(x-u)/2);return A}}var t=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)};d=function(l){function p(m,n){var q=l.call(this)||this;q.addClass("gridlines");q._xScale=m;q._yScale=n;q._renderCallback=
function(){return q.render()};if(q._xScale)q._xScale.onUpdate(q._renderCallback);if(q._yScale)q._yScale.onUpdate(q._renderCallback);return q}t(p,l);p.prototype.betweenX=function(){return this._betweenX};p.prototype.betweenY=function(){return this._betweenY};p.prototype.destroy=function(){l.prototype.destroy.call(this);this._xScale&&this._xScale.offUpdate(this._renderCallback);this._yScale&&this._yScale.offUpdate(this._renderCallback);return this};p.prototype._setup=function(){l.prototype._setup.call(this);
this._xLinesContainer=this.content().append("g").classed("x-gridlines",!0);this._yLinesContainer=this.content().append("g").classed("y-gridlines",!0)};p.prototype.renderImmediately=function(){l.prototype.renderImmediately.call(this);this._redrawXLines();this._redrawYLines();return this};p.prototype.computeLayout=function(m,n,q){l.prototype.computeLayout.call(this,m,n,q);null!=this._xScale&&this._xScale.range([0,this.width()]);null!=this._yScale&&this._yScale.range([this.height(),0]);return this};
p.prototype._redrawXLines=function(){if(this._xScale){var m=this.betweenX(),n=this._xScale.ticks().slice(m?1:0);n=this._xLinesContainer.selectAll("line").data(n);n.enter().append("line").merge(n).attr("x1",k(this._xScale,m,this._xScale.ticks())).attr("y1",0).attr("x2",k(this._xScale,m,this._xScale.ticks())).attr("y2",this.height()).classed("betweenline",m).classed("zeroline",function(q){return 0===q});n.exit().remove()}};p.prototype._redrawYLines=function(){if(this._yScale){var m=this.betweenY(),
n=this._yScale.ticks().slice(m?1:0);n=this._yLinesContainer.selectAll("line").data(n);n.enter().append("line").merge(n).attr("x1",0).attr("y1",k(this._yScale,m,this._yScale.ticks())).attr("x2",this.width()).attr("y2",k(this._yScale,m,this._yScale.ticks())).classed("betweenline",m).classed("zeroline",function(q){return 0===q});n.exit().remove()}};return p}(h(4).Component);f.Gridlines=d},function(d,f,h){var k=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&
(n[x]=q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},t=h(5),l=h(23),p=h(8),m=h(0);d=function(n){function q(u){var x=n.call(this)||this;x._textPadding=5;if(null==u)throw Error("InterpolatedColorLegend requires a interpolatedColorScale");x._scale=u;x._redrawCallback=function(){return x.redraw()};x._scale.onUpdate(x._redrawCallback);x._formatter=p.general();x._orientation="horizontal";x._expands=!1;x.addClass("legend");x.addClass("interpolated-color-legend");return x}k(q,
n);q.prototype.destroy=function(){n.prototype.destroy.call(this);this._scale.offUpdate(this._redrawCallback)};q.prototype.formatter=function(u){if(void 0===u)return this._formatter;this._formatter=u;this.redraw();return this};q.prototype.expands=function(){return this._expands};q._ensureOrientation=function(u){u=u.toLowerCase();if("horizontal"===u||"left"===u||"right"===u)return u;throw Error('"'+u+'" is not a valid orientation for InterpolatedColorLegend');};q.prototype.orientation=function(u){if(null==
u)return this._orientation;this._orientation=q._ensureOrientation(u);this.redraw();return this};q.prototype.fixedWidth=function(){return!this.expands()||this._isVertical()};q.prototype.fixedHeight=function(){return!this.expands()||!this._isVertical()};q.prototype._generateTicks=function(u){void 0===u&&(u=q._DEFAULT_NUM_SWATCHES);var x=this._scale.domain();if(1===u)return[x[0]];for(var A=(x[1]-x[0])/(u-1),y=[],w=0;w<u;w++)y.push(x[0]+A*w);return y};q.prototype._setup=function(){n.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(q.LEGEND_LABEL_CLASS,!0);this._upperLabel=this.content().append("g").classed(q.LEGEND_LABEL_CLASS,!0);var u=new t.SvgContext(this.content().node());this._measurer=new t.Measurer(u);this._wrapper=new t.Wrapper;this._writer=new t.Writer(this._measurer,u,this._wrapper)};q.prototype.requestedSpace=
function(){var u=this,x=this._measurer.measure().height,A=this._scale.domain().map(function(C){return u._measurer.measure(u._formatter(C)).width}),y=q._DEFAULT_NUM_SWATCHES;if(this._isVertical()){var w=m.Math.max(A,0);A=x+x+this._textPadding+w+this._textPadding;w=y*x}else w=x+x+x,A=this._textPadding+A[0]+y*x+A[1]+this._textPadding;return{minWidth:A,minHeight:w}};q.prototype._isVertical=function(){return"horizontal"!==this._orientation};q.prototype.renderImmediately=function(){var u=this;n.prototype.renderImmediately.call(this);
var x=this._scale.domain(),A=this._formatter(x[0]),y=this._measurer.measure(A).width,w=this._formatter(x[1]);x=this._measurer.measure(w).width;var C=this._measurer.measure().height,G=this._textPadding,D=0,B=0,I=0,N=0,O={xAlign:"center",yAlign:"center",textRotation:0},H={xAlign:"center",yAlign:"center",textRotation:0},K={x:0,y:0,width:0,height:0};if(this._isVertical()){var M=Math.floor(this.height());var L=Math.max(y,x);var Q=(this.width()-L-2*this._textPadding)/2;x=Math.max(this.width()-Q-2*G-L,0);
C=1;var T=function(aa,la){return u.height()-(la+1)};H.yAlign="top";B=0;O.yAlign="bottom";N=0;if("left"===this._orientation){var X=function(){return G+L+G};H.xAlign="right";D=-(Q+x+G);O.xAlign="right";I=-(Q+x+G)}else X=function(){return Q},H.xAlign="left",D=Q+x+G,O.xAlign="left",I=Q+x+G;K.width=x;K.height=M*C}else Q=Math.max(G,(this.height()-C)/2),M=Math.max(Math.floor(this.width()-4*G-y-x),0),x=1,C=Math.max(this.height()-2*Q,0),X=function(aa,la){return Math.floor(y+2*G)+la},T=function(){return Q},
H.xAlign="right",D=-G,O.xAlign="left",I=G,K.y=Q,K.width=M*x,K.height=C;K.x=X(null,0);this._upperLabel.text("");this._writer.write(w,this.width(),this.height(),H,this._upperLabel.node());this._upperLabel.attr("transform","translate("+D+", "+B+")");this._lowerLabel.text("");this._writer.write(A,this.width(),this.height(),O,this._lowerLabel.node());this._lowerLabel.attr("transform","translate("+I+", "+N+")");this._swatchBoundingBox.attrs(K);A=this._generateTicks(M);A=this._swatchContainer.selectAll("rect.swatch").data(A);
w=A.enter().append("rect").classed("swatch",!0);D=A.merge(w);A.exit().remove();D.attrs({fill:function(aa){return u._scale.scale(aa)},width:x,height:C,x:X,y:T,"shape-rendering":"crispEdges"});l.ADD_TITLE_ELEMENTS&&w.append("title").text(function(aa){return u._formatter(aa)});return this};return q}(h(4).Component);d._DEFAULT_NUM_SWATCHES=11;d.LEGEND_LABEL_CLASS="legend-label";f.InterpolatedColorLegend=d},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&
(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(5);d=function(l){function p(m,n){void 0===m&&(m="");void 0===n&&(n=0);var q=l.call(this)||this;q.addClass("label");q.text(m);q.angle(n);q.xAlignment("center").yAlignment("center");q._padding=0;return q}k(p,l);p.prototype.requestedSpace=function(){var m=this._measurer.measure(this._text),n=(0===this.angle()?m.width:m.height)+2*this.padding();m=(0===this.angle()?m.height:m.width)+2*this.padding();return{minWidth:n,
minHeight:m}};p.prototype._setup=function(){l.prototype._setup.call(this);this._textContainer=this.content().append("g");var m=new t.SvgContext(this._textContainer.node());this._measurer=new t.CacheMeasurer(m);this._wrapper=new t.Wrapper;this._writer=new t.Writer(this._measurer,m,this._wrapper);this.text(this._text)};p.prototype.text=function(m){if(null==m)return this._text;if("string"!==typeof m)throw Error("Label.text() only takes strings as input");this._text=m;this.redraw();return this};p.prototype.angle=
function(m){if(null==m)return this._angle;m%=360;180<m?m-=360:-180>m&&(m+=360);if(-90===m||0===m||90===m)this._angle=m;else throw Error(m+" is not a valid angle for Label");this.redraw();return this};p.prototype.padding=function(m){if(null==m)return this._padding;m=+m;if(0>m)throw Error(m+" is not a valid padding value. Cannot be less than 0.");this._padding=m;this.redraw();return this};p.prototype.fixedWidth=function(){return!0};p.prototype.fixedHeight=function(){return!0};p.prototype.renderImmediately=
function(){l.prototype.renderImmediately.call(this);this._textContainer.selectAll("g").remove();var m=this._measurer.measure(this._text),n=Math.max(Math.min((this.height()-m.height)/2,this.padding()),0);m=Math.max(Math.min((this.width()-m.width)/2,this.padding()),0);this._textContainer.attr("transform","translate("+m+","+n+")");m=this.width()-2*m;n=this.height()-2*n;var q={xAlign:this.xAlignment(),yAlign:this.yAlignment(),textRotation:this.angle()};this._writer.write(this._text,m,n,q);return this};
p.prototype.invalidateCache=function(){l.prototype.invalidateCache.call(this);this._measurer.reset()};return p}(h(4).Component);f.Label=d;h=function(l){function p(m,n){m=l.call(this,m,n)||this;m.addClass(p.TITLE_LABEL_CLASS);return m}k(p,l);return p}(d);h.TITLE_LABEL_CLASS="title-label";f.TitleLabel=h;d=function(l){function p(m,n){m=l.call(this,m,n)||this;m.addClass(p.AXIS_LABEL_CLASS);return m}k(p,l);return p}(d);d.AXIS_LABEL_CLASS="axis-label";f.AxisLabel=d},function(d,f,h){var k=this&&this.__extends||
function(A,y){function w(){this.constructor=A}for(var C in y)y.hasOwnProperty(C)&&(A[C]=y[C]);A.prototype=null===y?Object.create(y):(w.prototype=y.prototype,new w)},t=h(1),l=h(5),p=h(23),m=h(8),n=h(31),q=h(0);d=h(4);var u=function(){function A(y,w,C){void 0===y&&(y=[]);void 0===w&&(w=0);void 0===C&&(C=Infinity);this.columns=y;this.bottomPadding=w;this.maxWidth=C}A.prototype.addColumn=function(y){var w=y.width,C=this.getWidthAvailable();y.width=Math.min(C,w);this.columns.push(y)};A.prototype.getBounds=
function(y){for(var w=this.columns[y],C=0,G=0;G<y;G++)C+=this.columns[G].width;return{topLeft:{x:C,y:0},bottomRight:{x:C+w.width,y:w.height}}};A.prototype.getHeight=function(){return q.Math.max(this.columns.map(function(y){return y.height}),0)+this.bottomPadding};A.prototype.getWidth=function(){return Math.min(this.columns.reduce(function(y,w){return y+w.width},0),this.maxWidth)};A.prototype.getWidthAvailable=function(){var y=this.getWidth();return Math.max(this.maxWidth-y,0)};return A}(),x=function(){function A(y,
w,C,G){void 0===y&&(y=Infinity);void 0===w&&(w=Infinity);void 0===C&&(C=0);void 0===G&&(G=[]);this.maxWidth=y;this.maxHeight=w;this.padding=C;this.rows=G}A.prototype.addRow=function(y){y.maxWidth=this.maxWidth-2*this.padding;this.rows.push(y)};A.prototype.getColumnBounds=function(y,w){var C=this.getRowBounds(y);y=this.rows[y].getBounds(w);y.topLeft.x+=C.topLeft.x;y.bottomRight.x+=C.topLeft.x;y.topLeft.y+=C.topLeft.y;y.bottomRight.y+=C.topLeft.y;return y};A.prototype.getRowBounds=function(y){for(var w=
this.padding,C=this.padding,G=0;G<y;G++)C+=this.rows[G].getHeight();return{topLeft:{x:w,y:C},bottomRight:{x:w+this.rows[y].getWidth(),y:C+this.rows[y].getHeight()}}};A.prototype.getHeight=function(){return Math.min(this.rows.reduce(function(y,w){return y+w.getHeight()},0)+2*this.padding,this.maxHeight)};A.prototype.getWidth=function(){return Math.min(q.Math.max(this.rows.map(function(y){return y.getWidth()}),0)+2*this.padding,this.maxWidth)};return A}();d=function(A){function y(w){var C=A.call(this)||
this;C._padding=5;C._rowBottomPadding=3;C.addClass("legend");C.maxEntriesPerRow(1);if(null==w)throw Error("Legend requires a colorScale");C._colorScale=w;C._redrawCallback=function(){return C.redraw()};C._colorScale.onUpdate(C._redrawCallback);C._formatter=m.identity();C.maxLinesPerEntry(1);C.xAlignment("right").yAlignment("top");C.comparator(function(G,D){var B=C._colorScale.domain().slice().map(function(I){return C._formatter(I)});return B.indexOf(G)-B.indexOf(D)});C._symbolFactoryAccessor=function(){return n.circle()};
C._symbolOpacityAccessor=function(){return 1};return C}k(y,A);y.prototype._setup=function(){A.prototype._setup.call(this);var w=this.content().append("g").classed(y.LEGEND_ROW_CLASS,!0);w.append("g").classed(y.LEGEND_ENTRY_CLASS,!0).append("text");w=new l.SvgContext(w.node(),null,p.ADD_TITLE_ELEMENTS);this._measurer=new l.CacheMeasurer(w);this._wrapper=(new l.Wrapper).maxLines(this.maxLinesPerEntry());this._writer=new l.Writer(this._measurer,w,this._wrapper)};y.prototype.formatter=function(w){if(null==
w)return this._formatter;this._formatter=w;this.redraw();return this};y.prototype.maxEntriesPerRow=function(w){if(null==w)return this._maxEntriesPerRow;this._maxEntriesPerRow=w;this.redraw();return this};y.prototype.maxLinesPerEntry=function(w){if(null==w)return this._maxLinesPerEntry;this._maxLinesPerEntry=w;this.redraw();return this};y.prototype.maxWidth=function(w){if(null==w)return this._maxWidth;this._maxWidth=w;this.redraw();return this};y.prototype.comparator=function(w){null!=w&&(this._comparator=
w,this.redraw())};y.prototype.colorScale=function(w){return null!=w?(this._colorScale.offUpdate(this._redrawCallback),this._colorScale=w,this._colorScale.onUpdate(this._redrawCallback),this.redraw(),this):this._colorScale};y.prototype.destroy=function(){A.prototype.destroy.call(this);this._colorScale.offUpdate(this._redrawCallback)};y.prototype._buildLegendTable=function(w,C){var G=this,D=this._measurer.measure().height,B=new x(w,C,this._padding);w=this._colorScale.domain().slice().sort(function(N,
O){return G._comparator(G._formatter(N),G._formatter(O))});var I=new u;B.addRow(I);I.bottomPadding=this._rowBottomPadding;w.forEach(function(N){I.columns.length/2===G.maxEntriesPerRow()&&(I=new u,I.bottomPadding=G._rowBottomPadding,B.addRow(I));var O=I.getWidthAvailable(),H=G._formatter(N),K=G._measurer.measure(H).width;0>O-D-K&&1<I.columns.length&&(I=new u,I.bottomPadding=G._rowBottomPadding,B.addRow(I));I.addColumn({width:D,height:D,data:{name:N,type:"symbol"}});O=I.getWidthAvailable();O=Math.min(O,
K);G._wrapper.maxLines(G.maxLinesPerEntry());H=G._wrapper.wrap(H,G._measurer,O).noLines*D;I.addColumn({width:O,height:H,data:{name:N,type:"text"}})});return B};y.prototype.requestedSpace=function(w,C){w=this._buildLegendTable(q.Math.min([this.maxWidth(),w],w),C);return{minHeight:w.getHeight(),minWidth:w.getWidth()}};y.prototype.entitiesAt=function(w){var C=this;if(!this._isSetup)return[];var G=this._buildLegendTable(this.width(),this.height());return G.rows.reduce(function(D,B,I){if(0!==D.length)return D;
var N=G.getRowBounds(I);return q.Math.within(w,N)?B.columns.reduce(function(O,H,K){var M=G.getColumnBounds(I,K);if(q.Math.within(w,M)){O=C.content().selectAll("."+y.LEGEND_ROW_CLASS).nodes()[I];K=t.select(O).selectAll("."+y.LEGEND_ENTRY_CLASS).nodes()[Math.floor(K/2)];var L=t.select(K).select("."+y.LEGEND_SYMBOL_CLASS);M=q.DOM.getTranslateValues(t.select(O));L=q.DOM.getTranslateValues(L);return[{bounds:q.DOM.elementBBox(t.select(O)),datum:H.data.name,position:{x:M[0]+L[0],y:M[1]+L[1]},selection:t.select(K),
component:C}]}return O},D):D},[])};y.prototype.renderImmediately=function(){A.prototype.renderImmediately.call(this);var w=this._buildLegendTable(this.width(),this.height());this.content().selectAll("*").remove();var C=this.content().selectAll("g."+y.LEGEND_ROW_CLASS).data(w.rows),G=C.enter().append("g").classed(y.LEGEND_ROW_CLASS,!0).merge(C);C.exit().remove();G.attr("transform",function(B,I){B=w.getRowBounds(I);return"translate("+B.topLeft.x+", "+B.topLeft.y+")"});var D=this;G.each(function(B,I){for(var N=
[],O=0;O<B.columns.length;O+=2)N.push([B.columns[O],B.columns[O+1]]);B=t.select(this).selectAll("g."+y.LEGEND_ENTRY_CLASS).data(N);N=B.enter().append("g").classed(y.LEGEND_ENTRY_CLASS,!0).merge(B);N.append("path").attr("d",function(H){H=H[0];return D.symbol()(H.data.name,I)(.6*H.height)(null)}).attr("transform",function(H){H=H[0];return"translate("+(w.getColumnBounds(I,w.rows[I].columns.indexOf(H)).topLeft.x+H.width/2)+", "+H.height/2+")"}).attr("fill",function(H){return D._colorScale.scale(H[0].data.name)}).attr("opacity",
function(H){return D.symbolOpacity()(H[0].data.name,I)}).classed(y.LEGEND_SYMBOL_CLASS,!0);N.append("g").classed("text-container",!0).attr("transform",function(H){return"translate("+w.getColumnBounds(I,w.rows[I].columns.indexOf(H[1])).topLeft.x+", 0)"}).each(function(H){var K=t.select(this);H=H[1];D._writer.write(D._formatter(H.data.name),H.width,D.height(),{xAlign:"left",yAlign:"top",textRotation:0},K.node())});B.exit().remove()});return this};y.prototype.symbol=function(w){if(null==w)return this._symbolFactoryAccessor;
this._symbolFactoryAccessor=w;this.render();return this};y.prototype.symbolOpacity=function(){return this._symbolOpacityAccessor};y.prototype.fixedWidth=function(){return!0};y.prototype.fixedHeight=function(){return!0};y.prototype.invalidateCache=function(){this._measurer.reset()};return y}(d.Component);d.LEGEND_ROW_CLASS="legend-row";d.LEGEND_ENTRY_CLASS="legend-entry";d.LEGEND_SYMBOL_CLASS="legend-symbol";f.Legend=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=
p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(2),l=h(0);d=function(p){function m(){return null!==p&&p.apply(this,arguments)||this}k(m,p);m.prototype.entityNearest=function(n){var q,u=Infinity;this.components().forEach(function(x){x=x.entityNearest(n);if(null!=x){var A=l.Math.distanceSquared(x.position,n);A<=u&&(u=A,q=x)}});return q};m.prototype.append=function(n){if(null!=n&&!(n instanceof t.Plot))throw Error("Plot Group only accepts plots");
p.prototype.append.call(this,n);return this};return m}(h(41).Group);f.PlotGroup=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(1),l=h(0);d=function(p){function m(n){void 0===n&&(n=[]);var q=p.call(this)||this;q._rowPadding=0;q._columnPadding=0;q._rows=[];q._rowWeights=[];q._columnWeights=[];q._nRows=0;q._nCols=0;q._calculatedLayout=
null;q.addClass("table");n.forEach(function(u,x){u.forEach(function(A,y){null!=A&&q.add(A,x,y)})});return q}k(m,p);m.prototype._forEach=function(n){for(var q=0;q<this._nRows;q++)for(var u=0;u<this._nCols;u++)null!=this._rows[q][u]&&n(this._rows[q][u])};m.prototype.has=function(n){for(var q=0;q<this._nRows;q++)for(var u=0;u<this._nCols;u++)if(this._rows[q][u]===n)return!0;return!1};m.prototype.componentAt=function(n,q){return 0>n||n>=this._nRows||0>q||q>=this._nCols?null:this._rows[n][q]};m.prototype.add=
function(n,q,u){if(null==n)throw Error("Cannot add null to a table cell");if(!this.has(n)){if(null!=(this._rows[q]&&this._rows[q][u]))throw Error("cell is occupied");n.detach();this._nRows=Math.max(q+1,this._nRows);this._nCols=Math.max(u+1,this._nCols);this._padTableToSize(this._nRows,this._nCols);this._rows[q][u]=n;this._adoptAndAnchor(n);this.redraw()}return this};m.prototype._remove=function(n){for(var q=0;q<this._nRows;q++)for(var u=0;u<this._nCols;u++)if(this._rows[q][u]===n){this._rows[q][u]=
null;return}};m.prototype._iterateLayout=function(n,q,u){void 0===u&&(u=!1);var x=this._rows,A=t.transpose(this._rows);n-=this._columnPadding*(this._nCols-1);q-=this._rowPadding*(this._nRows-1);x=m._calcComponentWeights(this._rowWeights,x,function(L){return null==L||L.fixedHeight()});A=m._calcComponentWeights(this._columnWeights,A,function(L){return null==L||L.fixedWidth()});var y=A.map(function(L){return 0===L?.5:L}),w=x.map(function(L){return 0===L?.5:L});y=m._calcProportionalSpace(y,n);var C=m._calcProportionalSpace(w,
q),G=l.Array.createFilledArray(0,this._nCols),D=l.Array.createFilledArray(0,this._nRows);w=0;for(var B,I,N;;){D=l.Array.add(D,C);y=l.Array.add(G,y);B=this._determineGuarantees(y,D,u);G=B.guaranteedWidths;D=B.guaranteedHeights;I=B.wantsWidthArr.some(function(L){return L});N=B.wantsHeightArr.some(function(L){return L});var O=K,H=M;var K=n-t.sum(B.guaranteedWidths);var M=q-t.sum(B.guaranteedHeights);y=void 0;I?(y=B.wantsWidthArr.map(function(L){return L?.1:0}),y=l.Array.add(y,A)):y=A;C=void 0;N?(C=B.wantsHeightArr.map(function(L){return L?
.1:0}),C=l.Array.add(C,x)):C=x;y=m._calcProportionalSpace(y,K);C=m._calcProportionalSpace(C,M);w++;H=0<M&&M!==H;if(!(0<K&&K!==O||H))break;if(5<w)break}K=n-t.sum(B.guaranteedWidths);M=q-t.sum(B.guaranteedHeights);y=m._calcProportionalSpace(A,K);C=m._calcProportionalSpace(x,M);return{colProportionalSpace:y,rowProportionalSpace:C,guaranteedWidths:B.guaranteedWidths,guaranteedHeights:B.guaranteedHeights,wantsWidth:I,wantsHeight:N}};m.prototype._determineGuarantees=function(n,q,u){void 0===u&&(u=!1);var x=
l.Array.createFilledArray(0,this._nCols),A=l.Array.createFilledArray(0,this._nRows),y=l.Array.createFilledArray(!1,this._nCols),w=l.Array.createFilledArray(!1,this._nRows);this._rows.forEach(function(C,G){C.forEach(function(D,B){D=null!=D?D.requestedSpace(n[B],q[G]):{minWidth:0,minHeight:0};x[B]=Math.max(x[B],u?Math.min(D.minWidth,n[B]):D.minWidth);A[G]=Math.max(A[G],u?Math.min(D.minHeight,q[G]):D.minHeight);var I=D.minWidth>n[B];y[B]=y[B]||I;B=D.minHeight>q[G];w[G]=w[G]||B})});return{guaranteedWidths:x,
guaranteedHeights:A,wantsWidthArr:y,wantsHeightArr:w}};m.prototype.requestedSpace=function(n,q){this._calculatedLayout=this._iterateLayout(n,q);return{minWidth:t.sum(this._calculatedLayout.guaranteedWidths),minHeight:t.sum(this._calculatedLayout.guaranteedHeights)}};m.prototype.computeLayout=function(n,q,u){var x=this;p.prototype.computeLayout.call(this,n,q,u);n=t.sum(this._calculatedLayout.guaranteedWidths);q=t.sum(this._calculatedLayout.guaranteedHeights);u=this._calculatedLayout;if(n>this.width()||
q>this.height())u=this._iterateLayout(this.width(),this.height(),!0);var A=0,y=l.Array.add(u.rowProportionalSpace,u.guaranteedHeights),w=l.Array.add(u.colProportionalSpace,u.guaranteedWidths);this._rows.forEach(function(C,G){var D=0;C.forEach(function(B,I){null!=B&&B.computeLayout({x:D,y:A},w[I],y[G]);D+=w[I]+x._columnPadding});A+=y[G]+x._rowPadding});return this};m.prototype.rowPadding=function(n){if(null==n)return this._rowPadding;if(!l.Math.isValidNumber(n)||0>n)throw Error("rowPadding must be a non-negative finite value");
this._rowPadding=n;this.redraw();return this};m.prototype.columnPadding=function(n){if(null==n)return this._columnPadding;if(!l.Math.isValidNumber(n)||0>n)throw Error("columnPadding must be a non-negative finite value");this._columnPadding=n;this.redraw();return this};m.prototype.rowWeight=function(n,q){if(null==q)return this._rowWeights[n];if(!l.Math.isValidNumber(q)||0>q)throw Error("rowWeight must be a non-negative finite value");this._rowWeights[n]=q;this.redraw();return this};m.prototype.columnWeight=
function(n,q){if(null==q)return this._columnWeights[n];if(!l.Math.isValidNumber(q)||0>q)throw Error("columnWeight must be a non-negative finite value");this._columnWeights[n]=q;this.redraw();return this};m.prototype.fixedWidth=function(){var n=t.transpose(this._rows);return m._fixedSpace(n,function(q){return null==q||q.fixedWidth()})};m.prototype.fixedHeight=function(){return m._fixedSpace(this._rows,function(n){return null==n||n.fixedHeight()})};m.prototype._padTableToSize=function(n,q){for(var u=
0;u<n;u++){void 0===this._rows[u]&&(this._rows[u]=[],this._rowWeights[u]=null);for(var x=0;x<q;x++)void 0===this._rows[u][x]&&(this._rows[u][x]=null)}for(x=0;x<q;x++)void 0===this._columnWeights[x]&&(this._columnWeights[x]=null)};m._calcComponentWeights=function(n,q,u){return n.map(function(x,A){return null!=x?x:q[A].map(u).reduce(function(y,w){return y&&w},!0)?0:1})};m._calcProportionalSpace=function(n,q){var u=t.sum(n);return 0===u?l.Array.createFilledArray(0,n.length):n.map(function(x){return q*
x/u})};m._fixedSpace=function(n,q){function u(x){return x.reduce(function(A,y){return A&&y},!0)}return u(n.map(function(x){return u(x.map(q))}))};return m}(h(29).ComponentContainer);f.Table=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){var p=t.call(this)||this;p.addClass("x-drag-box-layer");p._hasCorners=!1;
return p}k(l,t);l.prototype.computeLayout=function(p,m,n){t.prototype.computeLayout.call(this,p,m,n);this._setBounds(this.bounds());return this};l.prototype._setBounds=function(p){t.prototype._setBounds.call(this,{topLeft:{x:p.topLeft.x,y:0},bottomRight:{x:p.bottomRight.x,y:this.height()}})};l.prototype._setResizableClasses=function(p){p&&this.enabled()?this.addClass("x-resizable"):this.removeClass("x-resizable")};l.prototype.yScale=function(p){if(null==p)return t.prototype.yScale.call(this);throw Error("yScales cannot be set on an XDragBoxLayer");
};l.prototype.yExtent=function(){return t.prototype.yExtent.call(this);throw Error("XDragBoxLayer has no yExtent");};return l}(h(32).DragBoxLayer);f.XDragBoxLayer=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){var p=t.call(this)||this;p.addClass("y-drag-box-layer");p._hasCorners=!1;return p}k(l,t);l.prototype.computeLayout=
function(p,m,n){t.prototype.computeLayout.call(this,p,m,n);this._setBounds(this.bounds());return this};l.prototype._setBounds=function(p){t.prototype._setBounds.call(this,{topLeft:{x:0,y:p.topLeft.y},bottomRight:{x:this.width(),y:p.bottomRight.y}})};l.prototype._setResizableClasses=function(p){p&&this.enabled()?this.addClass("y-resizable"):this.removeClass("y-resizable")};l.prototype.xScale=function(p){if(null==p)return t.prototype.xScale.call(this);throw Error("xScales cannot be set on an YDragBoxLayer");
};l.prototype.xExtent=function(){return t.prototype.xExtent.call(this);throw Error("YDragBoxLayer has no xExtent");};return l}(h(32).DragBoxLayer);f.YDragBoxLayer=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){var p=t.call(this)||this;p._eventToProcessingFunction[l._KEYDOWN_EVENT_NAME]=function(m){return p._processKeydown(m)};
p._eventToProcessingFunction[l._KEYUP_EVENT_NAME]=function(m){return p._processKeyup(m)};return p}k(l,t);l.getDispatcher=function(){var p=document[l._DISPATCHER_KEY];null==p&&(p=new l,document[l._DISPATCHER_KEY]=p);return p};l.prototype._processKeydown=function(p){this._callCallbacksForEvent(l._KEYDOWN_EVENT_NAME,p.keyCode,p)};l.prototype._processKeyup=function(p){this._callCallbacksForEvent(l._KEYUP_EVENT_NAME,p.keyCode,p)};l.prototype.onKeyDown=function(p){this._addCallbackForEvent(l._KEYDOWN_EVENT_NAME,
p)};l.prototype.offKeyDown=function(p){this._removeCallbackForEvent(l._KEYDOWN_EVENT_NAME,p)};l.prototype.onKeyUp=function(p){this._addCallbackForEvent(l._KEYUP_EVENT_NAME,p)};l.prototype.offKeyUp=function(p){this._removeCallbackForEvent(l._KEYUP_EVENT_NAME,p)};return l}(h(24).Dispatcher);d._DISPATCHER_KEY="__Plottable_Dispatcher_Key";d._KEYDOWN_EVENT_NAME="keydown";d._KEYUP_EVENT_NAME="keyup";f.Key=d},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&
(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(0);d=function(l){function p(m){function n(u){return q._measureAndDispatch(m,u,p._MOUSEMOVE_EVENT_NAME,"page")}var q=l.call(this)||this;q._lastMousePosition={x:-1,y:-1};q._translator=t.getTranslator(m);q._eventToProcessingFunction[p._MOUSEOVER_EVENT_NAME]=n;q._eventToProcessingFunction[p._MOUSEMOVE_EVENT_NAME]=n;q._eventToProcessingFunction[p._MOUSEOUT_EVENT_NAME]=n;q._eventToProcessingFunction[p._MOUSEDOWN_EVENT_NAME]=
function(u){return q._measureAndDispatch(m,u,p._MOUSEDOWN_EVENT_NAME)};q._eventToProcessingFunction[p._MOUSEUP_EVENT_NAME]=function(u){return q._measureAndDispatch(m,u,p._MOUSEUP_EVENT_NAME,"page")};q._eventToProcessingFunction[p._WHEEL_EVENT_NAME]=function(u){return q._measureAndDispatch(m,u,p._WHEEL_EVENT_NAME)};q._eventToProcessingFunction[p._DBLCLICK_EVENT_NAME]=function(u){return q._measureAndDispatch(m,u,p._DBLCLICK_EVENT_NAME)};return q}k(p,l);p.getDispatcher=function(m){var n=m.root().rootElement(),
q=n[p._DISPATCHER_KEY];null==q&&(q=new p(m),n[p._DISPATCHER_KEY]=q);return q};p.prototype.onMouseMove=function(m){this._addCallbackForEvent(p._MOUSEMOVE_EVENT_NAME,m)};p.prototype.offMouseMove=function(m){this._removeCallbackForEvent(p._MOUSEMOVE_EVENT_NAME,m)};p.prototype.onMouseDown=function(m){this._addCallbackForEvent(p._MOUSEDOWN_EVENT_NAME,m)};p.prototype.offMouseDown=function(m){this._removeCallbackForEvent(p._MOUSEDOWN_EVENT_NAME,m)};p.prototype.onMouseUp=function(m){this._addCallbackForEvent(p._MOUSEUP_EVENT_NAME,
m)};p.prototype.offMouseUp=function(m){this._removeCallbackForEvent(p._MOUSEUP_EVENT_NAME,m)};p.prototype.onWheel=function(m){this._addCallbackForEvent(p._WHEEL_EVENT_NAME,m);return this};p.prototype.offWheel=function(m){this._removeCallbackForEvent(p._WHEEL_EVENT_NAME,m)};p.prototype.onDblClick=function(m){this._addCallbackForEvent(p._DBLCLICK_EVENT_NAME,m)};p.prototype.offDblClick=function(m){this._removeCallbackForEvent(p._DBLCLICK_EVENT_NAME,m)};p.prototype._measureAndDispatch=function(m,n,q,
u){void 0===u&&(u="element");if("page"!==u&&"element"!==u)throw Error("Invalid scope '"+u+"', must be 'element' or 'page'");if("page"===u||this.eventInside(m,n))this._lastMousePosition=this._translator.computePosition(n.clientX,n.clientY),this._callCallbacksForEvent(q,this.lastMousePosition(),n)};p.prototype.eventInside=function(m,n){return t.Translator.isEventInside(m,n)};p.prototype.lastMousePosition=function(){return this._lastMousePosition};return p}(h(24).Dispatcher);d._DISPATCHER_KEY="__Plottable_Dispatcher_Mouse";
d._MOUSEOVER_EVENT_NAME="mouseover";d._MOUSEMOVE_EVENT_NAME="mousemove";d._MOUSEOUT_EVENT_NAME="mouseout";d._MOUSEDOWN_EVENT_NAME="mousedown";d._MOUSEUP_EVENT_NAME="mouseup";d._WHEEL_EVENT_NAME="wheel";d._DBLCLICK_EVENT_NAME="dblclick";f.Mouse=d},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(0);d=function(l){function p(m){var n=l.call(this)||
this;n._translator=t.getTranslator(m);n._eventToProcessingFunction[p._TOUCHSTART_EVENT_NAME]=function(q){return n._measureAndDispatch(m,q,p._TOUCHSTART_EVENT_NAME,"page")};n._eventToProcessingFunction[p._TOUCHMOVE_EVENT_NAME]=function(q){return n._measureAndDispatch(m,q,p._TOUCHMOVE_EVENT_NAME,"page")};n._eventToProcessingFunction[p._TOUCHEND_EVENT_NAME]=function(q){return n._measureAndDispatch(m,q,p._TOUCHEND_EVENT_NAME,"page")};n._eventToProcessingFunction[p._TOUCHCANCEL_EVENT_NAME]=function(q){return n._measureAndDispatch(m,
q,p._TOUCHCANCEL_EVENT_NAME,"page")};return n}k(p,l);p.getDispatcher=function(m){var n=m.root().rootElement(),q=n[p._DISPATCHER_KEY];null==q&&(q=new p(m),n[p._DISPATCHER_KEY]=q);return q};p.prototype.onTouchStart=function(m){this._addCallbackForEvent(p._TOUCHSTART_EVENT_NAME,m)};p.prototype.offTouchStart=function(m){this._removeCallbackForEvent(p._TOUCHSTART_EVENT_NAME,m)};p.prototype.onTouchMove=function(m){this._addCallbackForEvent(p._TOUCHMOVE_EVENT_NAME,m)};p.prototype.offTouchMove=function(m){this._removeCallbackForEvent(p._TOUCHMOVE_EVENT_NAME,
m)};p.prototype.onTouchEnd=function(m){this._addCallbackForEvent(p._TOUCHEND_EVENT_NAME,m)};p.prototype.offTouchEnd=function(m){this._removeCallbackForEvent(p._TOUCHEND_EVENT_NAME,m)};p.prototype.onTouchCancel=function(m){this._addCallbackForEvent(p._TOUCHCANCEL_EVENT_NAME,m)};p.prototype.offTouchCancel=function(m){this._removeCallbackForEvent(p._TOUCHCANCEL_EVENT_NAME,m)};p.prototype._measureAndDispatch=function(m,n,q,u){void 0===u&&(u="element");if("page"!==u&&"element"!==u)throw Error("Invalid scope '"+
u+"', must be 'element' or 'page'");if("element"!==u||this.eventInside(m,n)){m=n.changedTouches;u={};for(var x=[],A=0;A<m.length;A++){var y=m[A],w=y.identifier;y=this._translator.computePosition(y.clientX,y.clientY);null!=y&&(u[w]=y,x.push(w))}0<x.length&&this._callCallbacksForEvent(q,x,u,n)}};p.prototype.eventInside=function(m,n){return t.Translator.isEventInside(m,n)};return p}(h(24).Dispatcher);d._DISPATCHER_KEY="__Plottable_Dispatcher_Touch";d._TOUCHSTART_EVENT_NAME="touchstart";d._TOUCHMOVE_EVENT_NAME=
"touchmove";d._TOUCHEND_EVENT_NAME="touchend";d._TOUCHCANCEL_EVENT_NAME="touchcancel";f.Touch=d},function(d,f){d=function(){function h(k,t,l){void 0===l&&(l=window.devicePixelRatio);this.screenWidth=k;this.screenHeight=t;this.devicePixelRatio=l;this.pixelWidth=k*l;this.pixelHeight=t*l;this.canvas=document.createElement("canvas");this.ctx=this.canvas.getContext("2d");h.sizePixels(this.ctx,k,t,l)}h.sizePixels=function(k,t,l,p){var m=k.canvas;m.width=t*p;m.height=l*p;m.style.width=t+"px";m.style.height=
l+"px";k.setTransform(1,0,0,1,0,0);k.scale(p,p)};h.prototype.blit=function(k,t,l){void 0===t&&(t=0);void 0===l&&(l=0);k.drawImage(this.canvas,t,l,this.screenWidth,this.screenHeight)};h.prototype.blitCenter=function(k,t,l){void 0===t&&(t=0);void 0===l&&(l=0);this.blit(k,Math.floor(t-this.screenWidth/2),Math.floor(l-this.screenHeight/2))};h.prototype.resize=function(k,t,l){void 0===l&&(l=!1);var p=this.devicePixelRatio;this.screenWidth=k;this.screenHeight=t;this.pixelWidth=k*p;this.pixelHeight=t*p;
h.sizePixels(this.ctx,k,t,p);l&&this.ctx.translate(k/2,k/2);return this};h.prototype.clear=function(k){var t=this.pixelWidth,l=this.pixelHeight,p=this.ctx;p.save();p.setTransform(1,0,0,1,0,0);null==k?p.clearRect(0,0,t,l):(p.fillStyle=k,p.fillRect(0,0,t,l));p.restore();return this};h.prototype.getImageData=function(){return this.ctx.getImageData(0,0,this.pixelWidth,this.pixelHeight)};return h}();f.CanvasBuffer=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=
p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(13),l=h(0);d=function(p){function m(){var n=null!==p&&p.apply(this,arguments)||this;n._clickedDown=!1;n._doubleClicking=!1;n._onClickCallbacks=new l.CallbackSet;n._onDoubleClickCallbacks=new l.CallbackSet;n._mouseDownCallback=function(q){return n._handleClickDown(q)};n._mouseUpCallback=function(q,u){return n._handleClickUp(q,u)};n._dblClickCallback=function(q,u){return n._handleDblClick(q,
u)};n._touchStartCallback=function(q,u){return n._handleClickDown(u[q[0]])};n._touchEndCallback=function(q,u,x){return n._handleClickUp(u[q[0]],x)};n._touchCancelCallback=function(){return n._clickedDown=!1};return n}k(m,p);m.prototype._anchor=function(n){p.prototype._anchor.call(this,n);this._mouseDispatcher=t.Mouse.getDispatcher(n);this._mouseDispatcher.onMouseDown(this._mouseDownCallback);this._mouseDispatcher.onMouseUp(this._mouseUpCallback);this._mouseDispatcher.onDblClick(this._dblClickCallback);
this._touchDispatcher=t.Touch.getDispatcher(n);this._touchDispatcher.onTouchStart(this._touchStartCallback);this._touchDispatcher.onTouchEnd(this._touchEndCallback);this._touchDispatcher.onTouchCancel(this._touchCancelCallback)};m.prototype._unanchor=function(){p.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};m.prototype._handleClickDown=function(n){n=this._translateToComponentSpace(n);this._isInsideComponent(n)&&(this._clickedDown=!0,this._clickedPoint=n)};m.prototype._handleClickUp=function(n,q){var u=this,x=this._translateToComponentSpace(n);this._clickedDown&&m._pointsEqual(x,this._clickedPoint)&&setTimeout(function(){u._doubleClicking||u._onClickCallbacks.callCallbacks(x,
q)},0);this._clickedDown=!1};m.prototype._handleDblClick=function(n,q){var u=this;n=this._translateToComponentSpace(n);this._doubleClicking=!0;this._onDoubleClickCallbacks.callCallbacks(n,q);setTimeout(function(){return u._doubleClicking=!1},0)};m._pointsEqual=function(n,q){return n.x===q.x&&n.y===q.y};m.prototype.onClick=function(n){this._onClickCallbacks.add(n);return this};m.prototype.offClick=function(n){this._onClickCallbacks.delete(n);return this};m.prototype.onDoubleClick=function(n){this._onDoubleClickCallbacks.add(n)};
m.prototype.offDoubleClick=function(n){this._onDoubleClickCallbacks.delete(n);return this};return m}(h(15).Interaction);f.Click=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(13),l=h(0);d=function(p){function m(){var n=null!==p&&p.apply(this,arguments)||this;n._dragging=!1;n._constrainedToComponent=!0;n._mouseFilter=m._DEFAULT_MOUSE_FILTER;
n._dragStartCallbacks=new l.CallbackSet;n._dragCallbacks=new l.CallbackSet;n._dragEndCallbacks=new l.CallbackSet;n._mouseDownCallback=function(q,u){return n._startDrag(q,u)};n._mouseMoveCallback=function(q){return n._doDrag(q)};n._mouseUpCallback=function(q,u){return n._endDrag(q,u)};n._touchStartCallback=function(q,u,x){return n._startDrag(u[q[0]],x)};n._touchMoveCallback=function(q,u){return n._doDrag(u[q[0]])};n._touchEndCallback=function(q,u,x){return n._endDrag(u[q[0]],x)};return n}k(m,p);m.prototype._anchor=
function(n){p.prototype._anchor.call(this,n);this._mouseDispatcher=t.Mouse.getDispatcher(this._componentAttachedTo);this._mouseDispatcher.onMouseDown(this._mouseDownCallback);this._mouseDispatcher.onMouseMove(this._mouseMoveCallback);this._mouseDispatcher.onMouseUp(this._mouseUpCallback);this._touchDispatcher=t.Touch.getDispatcher(this._componentAttachedTo);this._touchDispatcher.onTouchStart(this._touchStartCallback);this._touchDispatcher.onTouchMove(this._touchMoveCallback);this._touchDispatcher.onTouchEnd(this._touchEndCallback)};
m.prototype._unanchor=function(){p.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};m.prototype._translateAndConstrain=
function(n){n=this._translateToComponentSpace(n);return this._constrainedToComponent?{x:l.Math.clamp(n.x,0,this._componentAttachedTo.width()),y:l.Math.clamp(n.y,0,this._componentAttachedTo.height())}:n};m.prototype._startDrag=function(n,q){q instanceof MouseEvent&&!this._mouseFilter(q)||(n=this._translateToComponentSpace(n),this._isInsideComponent(n)&&(q.preventDefault(),this._dragging=!0,this._dragOrigin=n,this._dragStartCallbacks.callCallbacks(this._dragOrigin)))};m.prototype._doDrag=function(n){this._dragging&&
this._dragCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(n))};m.prototype._endDrag=function(n,q){q instanceof MouseEvent&&0!==q.button||!this._dragging||(this._dragging=!1,this._dragEndCallbacks.callCallbacks(this._dragOrigin,this._translateAndConstrain(n)))};m.prototype.constrainedToComponent=function(){this._constrainedToComponent=!1};m.prototype.mouseFilter=function(n){0!==arguments.length&&(this._mouseFilter=n)};m.prototype.onDragStart=function(n){this._dragStartCallbacks.add(n)};
m.prototype.offDragStart=function(n){this._dragStartCallbacks.delete(n)};m.prototype.onDrag=function(n){this._dragCallbacks.add(n);return this};m.prototype.offDrag=function(n){this._dragCallbacks.delete(n)};m.prototype.onDragEnd=function(n){this._dragEndCallbacks.add(n)};m.prototype.offDragEnd=function(n){this._dragEndCallbacks.delete(n)};return m}(h(15).Interaction);d._DEFAULT_MOUSE_FILTER=function(p){return 0===p.button};f.Drag=d},function(d,f,h){var k=this&&this.__extends||function(u,x){function A(){this.constructor=
u}for(var y in x)x.hasOwnProperty(y)&&(u[y]=x[y]);u.prototype=null===x?Object.create(x):(A.prototype=x.prototype,new A)},t=h(1),l=h(13),p=h(3),m=h(0),n=h(25);d=h(15);var q=h(26);h=function(u){function x(A,y){var w=u.call(this)||this;w._wheelFilter=function(){return!0};w._wheelCallback=function(C,G){return w._handleWheelEvent(C,G)};w._touchStartCallback=function(C,G){return w._handleTouchStart(C,G)};w._touchMoveCallback=function(C,G){return w._handlePinch(C,G)};w._touchEndCallback=function(C){return w._handleTouchEnd(C)};
w._touchCancelCallback=function(C){return w._handleTouchEnd(C)};w._panEndCallbacks=new m.CallbackSet;w._zoomEndCallbacks=new m.CallbackSet;w._panZoomUpdateCallbacks=new m.CallbackSet;w._xScales=new m.Set;w._yScales=new m.Set;w._dragInteraction=new n.Drag;w._setupDragInteraction();w._touchIds=t.map();w._minDomainExtents=new m.Map;w._maxDomainExtents=new m.Map;w._minDomainValues=new m.Map;w._maxDomainValues=new m.Map;null!=A&&w.addXScale(A);null!=y&&w.addYScale(y);return w}k(x,u);x.prototype.dragInteraction=
function(){return this._dragInteraction};x.prototype.wheelFilter=function(A){0!==arguments.length&&(this._wheelFilter=A)};x.prototype.pan=function(A){var y=this;this.xScales().forEach(function(w){w.pan(y._constrainedTranslation(w,A.x))});this.yScales().forEach(function(w){w.pan(y._constrainedTranslation(w,A.y))});this._panZoomUpdateCallbacks.callCallbacks()};x.prototype.zoom=function(A,y,w){var C=this;void 0===w&&(w=!0);if(null!=y){var G=y.x;var D=y.y;w&&(this.xScales().forEach(function(B){B=C._constrainedZoom(B,
A,G);G=B.centerPoint;A=B.zoomAmount}),this.yScales().forEach(function(B){B=C._constrainedZoom(B,A,D);D=B.centerPoint;A=B.zoomAmount}))}this.xScales().forEach(function(B){var I=B.range();B.zoom(A,null==G?(I[1]+I[0])/2:G)});this.yScales().forEach(function(B){var I=B.range();B.zoom(A,null==D?(I[1]+I[0])/2:D)});this._panZoomUpdateCallbacks.callCallbacks();return{zoomAmount:A,centerValue:{centerX:G,centerY:D}}};x.prototype._anchor=function(A){u.prototype._anchor.call(this,A);this._dragInteraction.attachTo(A);
this._mouseDispatcher=l.Mouse.getDispatcher(this._componentAttachedTo);this._mouseDispatcher.onWheel(this._wheelCallback);this._touchDispatcher=l.Touch.getDispatcher(this._componentAttachedTo);this._touchDispatcher.onTouchStart(this._touchStartCallback);this._touchDispatcher.onTouchMove(this._touchMoveCallback);this._touchDispatcher.onTouchEnd(this._touchEndCallback);this._touchDispatcher.onTouchCancel(this._touchCancelCallback)};x.prototype._unanchor=function(){u.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()};x.prototype._handleTouchStart=function(A,y){for(var w=0;w<A.length&&2>this._touchIds.size();w++){var C=A[w];this._touchIds.set(C.toString(),this._translateToComponentSpace(y[C]))}};
x.prototype._handlePinch=function(A,y){var w=this;if(!(2>this._touchIds.size())){var C=this._touchIds.values();if(this._isInsideComponent(this._translateToComponentSpace(C[0]))&&this._isInsideComponent(this._translateToComponentSpace(C[1]))){var G=x._pointDistance(C[0],C[1]);if(0!==G){A.forEach(function(O){w._touchIds.has(O.toString())&&w._touchIds.set(O.toString(),w._translateToComponentSpace(y[O]))});A=this._touchIds.values();var D=x._pointDistance(A[0],A[1]);if(0!==D){var B=G/D,I=A.map(function(O,
H){return{x:(O.x-C[H].x)/B,y:(O.y-C[H].y)/B}});G=x.centerPoint(C[0],C[1]);G=this.zoom(B,G);A=G.centerValue;var N=G.zoomAmount;G=A.centerX;A=A.centerY;D=C.map(function(O,H){return{x:I[H].x*N+O.x,y:I[H].y*N+O.y}});this.pan({x:G-(D[0].x+D[1].x)/2,y:A-(D[0].y+D[1].y)/2})}}}}};x.centerPoint=function(A,y){return{x:(Math.min(A.x,y.x)+Math.max(A.x,y.x))/2,y:(Math.max(A.y,y.y)+Math.min(A.y,y.y))/2}};x._pointDistance=function(A,y){return Math.sqrt(Math.pow(Math.max(A.x,y.x)-Math.min(A.x,y.x),2)+Math.pow(Math.max(A.y,
y.y)-Math.min(A.y,y.y),2))};x.prototype._handleTouchEnd=function(A){var y=this;A.forEach(function(w){y._touchIds.remove(w.toString())});0<this._touchIds.size()&&this._zoomEndCallbacks.callCallbacks()};x.prototype._handleWheelEvent=function(A,y){this._wheelFilter(y)&&(A=this._translateToComponentSpace(A),this._isInsideComponent(A)&&(y.preventDefault(),this.zoom(Math.pow(2,(0!==y.deltaY?y.deltaY:y.deltaX)*(y.deltaMode?x._PIXELS_PER_LINE:1)*.002),A),this._zoomEndCallbacks.callCallbacks()))};x.prototype._constrainedZoom=
function(A,y,w){return q.constrainedZoom(A,y,w,this.minDomainExtent(A),this.maxDomainExtent(A),this.minDomainValue(A),this.maxDomainValue(A))};x.prototype._constrainedTranslation=function(A,y){return q.constrainedTranslation(A,y,this.minDomainValue(A),this.maxDomainValue(A))};x.prototype._setupDragInteraction=function(){var A=this;this._dragInteraction.constrainedToComponent();var y;this._dragInteraction.onDragStart(function(){return y=null});this._dragInteraction.onDrag(function(w,C){2<=A._touchIds.size()||
(A.pan({x:(null==y?w.x:y.x)-C.x,y:(null==y?w.y:y.y)-C.y}),y=C)});this._dragInteraction.onDragEnd(function(){return A._panEndCallbacks.callCallbacks()})};x.prototype._nonLinearScaleWithExtents=function(A){return null!=this.minDomainExtent(A)&&null!=this.maxDomainExtent(A)&&!(A instanceof p.Linear)&&!(A instanceof p.Time)};x.prototype.xScales=function(){var A=[];this._xScales.forEach(function(y){A.push(y)});return A};x.prototype.yScales=function(){var A=[];this._yScales.forEach(function(y){A.push(y)});
return A};x.prototype.addXScale=function(A){this._xScales.add(A)};x.prototype.removeXScale=function(A){this._xScales.delete(A);this._minDomainExtents.delete(A);this._maxDomainExtents.delete(A);this._minDomainValues.delete(A);this._maxDomainValues.delete(A);return this};x.prototype.addYScale=function(A){this._yScales.add(A)};x.prototype.removeYScale=function(A){this._yScales.delete(A);this._minDomainExtents.delete(A);this._maxDomainExtents.delete(A);this._minDomainValues.delete(A);this._maxDomainValues.delete(A);
return this};x.prototype.minDomainExtent=function(A){return this._minDomainExtents.get(A)};x.prototype.maxDomainExtent=function(A){return this._maxDomainExtents.get(A)};x.prototype.minDomainValue=function(A,y){if(null==y)return this._minDomainValues.get(A);this._minDomainValues.set(A,y);return this};x.prototype.maxDomainValue=function(A,y){if(null==y)return this._maxDomainValues.get(A);this._maxDomainValues.set(A,y);return this};x.prototype.setMinMaxDomainValuesTo=function(A){this._minDomainValues.delete(A);
this._maxDomainValues.delete(A);var y=A.getTransformationDomain(),w=y[1];this.minDomainValue(A,y[0]);this.maxDomainValue(A,w);return this};x.prototype.onPanEnd=function(A){this._panEndCallbacks.add(A)};x.prototype.offPanEnd=function(A){this._panEndCallbacks.delete(A);return this};x.prototype.onZoomEnd=function(A){this._zoomEndCallbacks.add(A)};x.prototype.offZoomEnd=function(A){this._zoomEndCallbacks.delete(A);return this};x.prototype.onPanZoomUpdate=function(A){this._panZoomUpdateCallbacks.add(A);
return this};x.prototype.offPanZoomUpdate=function(A){this._panZoomUpdateCallbacks.delete(A);return this};return x}(d.Interaction);h._PIXELS_PER_LINE=120;f.PanZoom=h},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(13),l=h(0);d=function(p){function m(){var n=null!==p&&p.apply(this,arguments)||this;n._overComponent=!1;n._pointerEnterCallbacks=
new l.CallbackSet;n._pointerMoveCallbacks=new l.CallbackSet;n._pointerExitCallbacks=new l.CallbackSet;n._mouseMoveCallback=function(q,u){return n._handleMouseEvent(q,u)};n._touchStartCallback=function(q,u,x){return n._handleTouchEvent(u[q[0]],x)};return n}k(m,p);m.prototype._anchor=function(n){p.prototype._anchor.call(this,n);this._mouseDispatcher=t.Mouse.getDispatcher(this._componentAttachedTo);this._mouseDispatcher.onMouseMove(this._mouseMoveCallback);this._touchDispatcher=t.Touch.getDispatcher(this._componentAttachedTo);
this._touchDispatcher.onTouchStart(this._touchStartCallback)};m.prototype._unanchor=function(){p.prototype._unanchor.call(this);this._mouseDispatcher.offMouseMove(this._mouseMoveCallback);this._mouseDispatcher=null;this._touchDispatcher.offTouchStart(this._touchStartCallback);this._touchDispatcher=null};m.prototype._handleMouseEvent=function(n,q){q=this._mouseDispatcher.eventInside(this._componentAttachedTo,q);this._handlePointerEvent(n,q)};m.prototype._handleTouchEvent=function(n,q){q=this._touchDispatcher.eventInside(this._componentAttachedTo,
q);this._handlePointerEvent(n,q)};m.prototype._handlePointerEvent=function(n,q){n=this._translateToComponentSpace(n);var u=this._isInsideComponent(n);u&&q?(this._overComponent||this._pointerEnterCallbacks.callCallbacks(n),this._pointerMoveCallbacks.callCallbacks(n)):this._overComponent&&this._pointerExitCallbacks.callCallbacks(n);this._overComponent=u&&q};m.prototype.onPointerEnter=function(n){this._pointerEnterCallbacks.add(n);return this};m.prototype.offPointerEnter=function(n){this._pointerEnterCallbacks.delete(n);
return this};m.prototype.onPointerMove=function(n){this._pointerMoveCallbacks.add(n)};m.prototype.offPointerMove=function(n){this._pointerMoveCallbacks.delete(n);return this};m.prototype.onPointerExit=function(n){this._pointerExitCallbacks.add(n)};m.prototype.offPointerExit=function(n){this._pointerExitCallbacks.delete(n);return this};return m}(h(15).Interaction);f.Pointer=d},function(d,f,h){var k=h(20);f.memThunk=function(){for(var t=[],l=0;l<arguments.length;l++)t[l]=arguments[l];var p=t.slice(0,
-1),m=k.memoize(t[t.length-1]);return function(){var n=this,q=p.map(function(u){return u.apply(n)});return m.apply(void 0,q)}}},function(d,f,h){var k=h(49);f.memoize=function(t){function l(){for(var u=[],x=0;x<arguments.length;x++)u[x]=arguments[x];if(n)return m;x=k.signArray(u);void 0===p||p.isDifferent(x)?(q&&console.log("cache miss! computing"),p=x,m=t.apply(this,u)):q&&console.log("cache hit!");return m}var p=void 0,m,n=!1,q=!1;l.doLocked=function(u){if(n)throw Error("Locking an already locked memoize function!");
n=!0;u=u.apply(this);n=!1;return u};l.logPerformance=function(u){void 0===u&&(u=!0);q=u;return this};return l}},function(d,f,h){var k=this&&this.__extends||function(n,q){function u(){this.constructor=n}for(var x in q)q.hasOwnProperty(x)&&(n[x]=q[x]);n.prototype=null===q?Object.create(q):(u.prototype=q.prototype,new u)},t=h(3),l=h(0),p=h(27),m=h(2);d=function(n){function q(u){void 0===u&&(u="vertical");u=n.call(this,u)||this;u._clusterOffsets=new l.Map;return u}k(q,n);q.prototype._generateAttrToProjector=
function(){function u(){return y.rangeBand()}var x=this,A=n.prototype._generateAttrToProjector.call(this),y=this._makeInnerScale();A.width=this._isVertical?u:A.width;A.height=this._isVertical?A.height:u;var w=A.x,C=A.y;A.x=this._isVertical?function(G,D,B){return w(G,D,B)+x._clusterOffsets.get(B)}:function(G,D,B){return w(G,D,B)};A.y=this._isVertical?function(G,D,B){return C(G,D,B)}:function(G,D,B){return C(G,D,B)+x._clusterOffsets.get(B)};return A};q.prototype._updateClusterPosition=function(){var u=
this,x=this._makeInnerScale();this.datasets().forEach(function(A,y){return u._clusterOffsets.set(A,x.scale(String(y))-x.rangeBand()/2)})};q.prototype._makeInnerScale=function(){var u=new t.Category;u.domain(this.datasets().map(function(A,y){return String(y)}));var x=m.Plot._scaledAccessor(this.attr(p.Bar._BAR_THICKNESS_KEY));u.range([0,x(null,0,null)]);return u};q.prototype._getDataToDraw=function(){this._updateClusterPosition();return n.prototype._getDataToDraw.call(this)};return q}(p.Bar);f.ClusteredBar=
d},function(d,f,h){var k=this&&this.__extends||function(C,G){function D(){this.constructor=C}for(var B in G)G.hasOwnProperty(B)&&(C[B]=G[B]);C.prototype=null===G?Object.create(G):(D.prototype=G.prototype,new D)},t=h(1),l=h(5),p=h(7),m=h(8),n=h(3),q=h(0),u=h(44),x=h(45),A=h(6),y=h(35),w=h(2);d=function(C){function G(){var D=C.call(this)||this;D._startAngle=0;D._endAngle=2*Math.PI;D._labelFormatter=m.identity();D._labelsEnabled=!1;D.innerRadius(0);D.outerRadius(function(){var B=D._pieCenter();return Math.min(Math.max(D.width()-
B.x,B.x),Math.max(D.height()-B.y,B.y))});D.addClass("pie-plot");D.attr("fill",function(B,I){return String(I)},new n.Color);D._strokeDrawers=new q.Map;return D}k(G,C);G.prototype._setup=function(){var D=this;C.prototype._setup.call(this);this._strokeDrawers.forEach(function(B){return B.attachTo(D._renderArea)})};G.prototype.computeLayout=function(D,B,I){C.prototype.computeLayout.call(this,D,B,I);D=this._pieCenter();this._renderArea.attr("transform","translate("+D.x+","+D.y+")");D=Math.min(Math.max(this.width()-
D.x,D.x),Math.max(this.height()-D.y,D.y));null!=this.innerRadius().scale&&this.innerRadius().scale.range([0,D]);null!=this.outerRadius().scale&&this.outerRadius().scale.range([0,D]);return this};G.prototype.addDataset=function(D){C.prototype.addDataset.call(this,D)};G.prototype._addDataset=function(D){if(1===this.datasets().length)return q.Window.warn("Only one dataset is supported in Pie plots"),this;this._updatePieAngles();var B=new x.ArcOutlineSVGDrawer;this._isSetup&&B.attachTo(this._renderArea);
this._strokeDrawers.set(D,B);C.prototype._addDataset.call(this,D);return this};G.prototype.removeDataset=function(D){C.prototype.removeDataset.call(this,D)};G.prototype._removeDatasetNodes=function(D){C.prototype._removeDatasetNodes.call(this,D);this._strokeDrawers.get(D).remove()};G.prototype._removeDataset=function(D){C.prototype._removeDataset.call(this,D);this._startAngles=[];this._endAngles=[];return this};G.prototype.selections=function(D){var B=this;void 0===D&&(D=this.datasets());var I=C.prototype.selections.call(this,
D).nodes();D.forEach(function(N){N=B._strokeDrawers.get(N);null!=N&&I.push.apply(I,N.getVisualPrimitives())});return t.selectAll(I)};G.prototype._onDatasetUpdate=function(){C.prototype._onDatasetUpdate.call(this);this._updatePieAngles();this.render()};G.prototype._createDrawer=function(){return new A.ProxyDrawer(function(){return new u.ArcSVGDrawer},function(){y.warn("canvas renderer is not supported on Pie Plot!");return null})};G.prototype.entities=function(D){var B=this;void 0===D&&(D=this.datasets());
return C.prototype.entities.call(this,D).map(function(I){I.position.x+=B.width()/2;I.position.y+=B.height()/2;var N=t.select(B._strokeDrawers.get(I.dataset).getVisualPrimitiveAtIndex(I.index));I.strokeSelection=N;return I})};G.prototype.sectorValue=function(){return this._propertyBindings.get(G._SECTOR_VALUE_KEY)};G.prototype.innerRadius=function(D,B){if(null==D)return this._propertyBindings.get(G._INNER_RADIUS_KEY);this._bindProperty(G._INNER_RADIUS_KEY,D,B);this.render();return this};G.prototype.outerRadius=
function(D,B){if(null==D)return this._propertyBindings.get(G._OUTER_RADIUS_KEY);this._bindProperty(G._OUTER_RADIUS_KEY,D,B);this.render();return this};G.prototype.startAngle=function(D){if(null==D)return this._startAngle;this._startAngle=D;this._updatePieAngles();this.render();return this};G.prototype.endAngle=function(D){if(null==D)return this._endAngle;this._endAngle=D;this._updatePieAngles();this.render();return this};G.prototype.labelsEnabled=function(D){if(null==D)return this._labelsEnabled;
this._labelsEnabled=D;this.render();return this};G.prototype.labelFormatter=function(D){if(null==D)return this._labelFormatter;this._labelFormatter=D;this.render();return this};G.prototype.entitiesAt=function(D){var B=this.width()/2,I=this.height()/2;D=this._sliceIndexForPoint({x:D.x-B,y:D.y-I});return null==D?[]:[this.entities()[D]]};G.prototype._propertyProjectors=function(){var D=this,B=C.prototype._propertyProjectors.call(this),I=w.Plot._scaledAccessor(this.innerRadius()),N=w.Plot._scaledAccessor(this.outerRadius());
B.d=function(O,H,K){return t.arc().innerRadius(I(O,H,K)).outerRadius(N(O,H,K)).startAngle(D._startAngles[H]).endAngle(D._endAngles[H])(O,H)};return B};G.prototype._updatePieAngles=function(){if(null!=this.sectorValue()&&0!==this.datasets().length){var D=w.Plot._scaledAccessor(this.sectorValue()),B=this.datasets()[0],I=this._getDataToDraw().get(B);I=t.pie().sort(null).startAngle(this._startAngle).endAngle(this._endAngle).value(function(N,O){return D(N,O,B)})(I);this._startAngles=I.map(function(N){return N.startAngle});
this._endAngles=I.map(function(N){return N.endAngle})}};G.prototype._pieCenter=function(){var D=this._startAngle<this._endAngle?this._startAngle:this._endAngle,B=this._startAngle<this._endAngle?this._endAngle:this._startAngle,I=Math.sin(D);D=Math.cos(D);var N=Math.sin(B);B=Math.cos(B);var O;if(0<=I&&0<=N)if(0<=D&&0<=B){var H=D;var K=O=0;var M=N}else 0>D&&0>B?(H=0,O=-B,K=0,M=I):0<=D&&0>B?(H=D,O=-B,K=0,M=I):0>D&&0<=B&&(K=O=H=1,M=Math.max(I,N));else 0<=I&&0>N?0<=D&&0<=B?(H=Math.max(D,B),M=K=O=1):0>D&&
0>B?(H=0,O=1,K=-N,M=I):0<=D&&0>B?(H=D,O=1,K=-N,M=1):0>D&&0<=B&&(H=B,K=O=1,M=I):0>I&&0<=N?0<=D&&0<=B?(H=1,O=0,K=-I,M=N):0>D&&0>B?(H=1,O=Math.max(-D,-B),M=K=1):0<=D&&0>B?(H=1,O=-B,K=-I,M=1):0>D&&0<=B&&(H=1,O=-D,K=1,M=N):0>I&&0>N&&(0<=D&&0<=B?(H=B,O=0,K=-I,M=0):0>D&&0>B?(H=0,O=-D,K=-N,M=0):0<=D&&0>B?(O=H=1,K=Math.max(D,-B),M=1):0>D&&0<=B&&(H=B,O=-D,K=1,M=0));return{x:0==K+M?0:K/(K+M)*this.width(),y:0==H+O?0:H/(H+O)*this.height()}};G.prototype._getDataToDraw=function(){var D=C.prototype._getDataToDraw.call(this);
if(0===this.datasets().length)return D;var B=w.Plot._scaledAccessor(this.sectorValue()),I=this.datasets()[0],N=D.get(I).filter(function(O,H){return G._isValidData(B(O,H,I))});D.set(I,N);return D};G._isValidData=function(D){return q.Math.isValidNumber(D)&&0<=D};G.prototype._pixelPoint=function(D,B,I){var N=w.Plot._scaledAccessor(this.sectorValue());if(!G._isValidData(N(D,B,I)))return{x:NaN,y:NaN};var O=w.Plot._scaledAccessor(this.innerRadius())(D,B,I);D=w.Plot._scaledAccessor(this.outerRadius())(D,
B,I);O=(O+D)/2;D=t.pie().sort(null).value(function(H,K){H=N(H,K,I);return G._isValidData(H)?H:0}).startAngle(this._startAngle).endAngle(this._endAngle)(I.data());B=(D[B].startAngle+D[B].endAngle)/2;return{x:O*Math.sin(B),y:-O*Math.cos(B)}};G.prototype._additionalPaint=function(D){var B=this;this._renderArea.select(".label-area").remove();this._labelsEnabled&&q.Window.setTimeout(function(){return B._drawLabels()},D);var I=this._generateStrokeDrawSteps(),N=this._getDataToDraw();this.datasets().forEach(function(O){var H=
w.Plot.applyDrawSteps(I,O);B._strokeDrawers.get(O).draw(N.get(O),H)})};G.prototype._generateStrokeDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new p.Null}]};G.prototype._sliceIndexForPoint=function(D){var B=Math.sqrt(Math.pow(D.x,2)+Math.pow(D.y,2)),I=Math.acos(-D.y/B);0>D.x&&(I=2*Math.PI-I);for(D=0;D<this._startAngles.length;D++)if(this._startAngles[D]<I&&this._endAngles[D]>I){var N=D;break}if(void 0!==N){D=this.datasets()[0];var O=D.data()[N];I=this.innerRadius().accessor(O,
N,D);D=this.outerRadius().accessor(O,N,D);if(B>I&&B<D)return N}return null};G.prototype._drawLabels=function(){var D=this,B=this._getAttrToProjector(),I=this._renderArea.append("g").classed("label-area",!0),N=new l.SvgContext(I.node()),O=new l.CacheMeasurer(N),H=new l.Writer(O,N),K=this.datasets()[0];this._getDataToDraw().get(K).forEach(function(M,L){var Q=D.sectorValue().accessor(M,L,K);if(q.Math.isValidNumber(Q)){Q=D._labelFormatter(Q,M,L,K);var T=O.measure(Q),X=(D._endAngles[L]+D._startAngles[L])/
2,aa=D.outerRadius().accessor(M,L,K);D.outerRadius().scale&&(aa=D.outerRadius().scale.scale(aa));var la=D.innerRadius().accessor(M,L,K);D.innerRadius().scale&&(la=D.innerRadius().scale.scale(la));la=(aa+la)/2;aa=Math.sin(X)*la-T.width/2;la=-Math.cos(X)*la-T.height/2;var Z=[{x:aa,y:la},{x:aa,y:la+T.height},{x:aa+T.width,y:la},{x:aa+T.width,y:la+T.height}];(X=Z.every(function(ba){return Math.abs(ba.x)<=D.width()/2&&Math.abs(ba.y)<=D.height()/2}))&&(X=Z.map(function(ba){return D._sliceIndexForPoint(ba)}).every(function(ba){return ba===
L}));M=B.fill(M,L,K);M=1.6*q.Color.contrast("white",M)<q.Color.contrast("black",M);aa=I.append("g").attr("transform","translate("+aa+","+la+")");aa.classed(M?"dark-label":"light-label",!0);aa.style("visibility",X?"inherit":"hidden");H.write(Q,T.width,T.height,{xAlign:"center",yAlign:"center"},aa.node())}})};return G}(w.Plot);d._INNER_RADIUS_KEY="inner-radius";d._OUTER_RADIUS_KEY="outer-radius";d._SECTOR_VALUE_KEY="sector-value";f.Pie=d},function(d,f,h){var k=this&&this.__extends||function(y,w){function C(){this.constructor=
y}for(var G in w)w.hasOwnProperty(G)&&(y[G]=w[G]);y.prototype=null===w?Object.create(w):(C.prototype=w.prototype,new C)},t=h(1),l=h(5),p=h(7),m=h(14),n=h(6),q=h(34),u=h(3),x=h(0),A=h(2);d=function(y){function w(){var C=y.call(this)||this;C._labelsEnabled=!1;C._label=null;C.animator("rectangles",new p.Null);C.addClass("rectangle-plot");C.attr("fill",(new u.Color).range()[0]);return C}k(w,y);w.prototype._createDrawer=function(){return new n.ProxyDrawer(function(){return new q.RectangleSVGDrawer},function(C){return new m.RectangleCanvasDrawer(C)})};
w.prototype._generateAttrToProjector=function(){var C=this,G=y.prototype._generateAttrToProjector.call(this),D=A.Plot._scaledAccessor(this.x()),B=G[w._X2_KEY],I=A.Plot._scaledAccessor(this.y()),N=G[w._Y2_KEY],O=this.x().scale,H=this.y().scale;null!=B?(G.width=function(K,M,L){return Math.abs(B(K,M,L)-D(K,M,L))},G.x=function(K,M,L){return Math.min(B(K,M,L),D(K,M,L))}):(G.width=function(){return C._rectangleWidth(O)},G.x=function(K,M,L){return D(K,M,L)-.5*G.width(K,M,L)});null!=N?(G.height=function(K,
M,L){return Math.abs(N(K,M,L)-I(K,M,L))},G.y=function(K,M,L){return Math.max(N(K,M,L),I(K,M,L))-G.height(K,M,L)}):(G.height=function(){return C._rectangleWidth(H)},G.y=function(K,M,L){return I(K,M,L)-.5*G.height(K,M,L)});delete G[w._X2_KEY];delete G[w._Y2_KEY];return G};w.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:this._getAnimator("rectangles")}]};w.prototype._filterForProperty=function(C){return"x2"===C?y.prototype._filterForProperty.call(this,
"x"):"y2"===C?y.prototype._filterForProperty.call(this,"y"):y.prototype._filterForProperty.call(this,C)};w.prototype.x=function(C,G,D){if(null==C)return y.prototype.x.call(this);null==G?y.prototype.x.call(this,C):y.prototype.x.call(this,C,G,D);null!=G&&(D=(C=this.x2())&&C.accessor,null!=D&&this._bindProperty(w._X2_KEY,D,G,C.postScale));G instanceof u.Category&&G.innerPadding(0).outerPadding(0);return this};w.prototype.x2=function(){return this._propertyBindings.get(w._X2_KEY)};w.prototype.y=function(C,
G,D){if(null==C)return y.prototype.y.call(this);null==G?y.prototype.y.call(this,C):y.prototype.y.call(this,C,G,D);null!=G&&(D=(C=this.y2())&&C.accessor,null!=D&&this._bindProperty(w._Y2_KEY,D,G,C.postScale));G instanceof u.Category&&G.innerPadding(0).outerPadding(0);return this};w.prototype.y2=function(){return this._propertyBindings.get(w._Y2_KEY)};w.prototype.entitiesAt=function(C){var G=this._getAttrToProjector();return this.entities().filter(function(D){var B=D.datum,I=D.index,N=D.dataset;D=G.x(B,
I,N);var O=G.y(B,I,N),H=G.width(B,I,N);B=G.height(B,I,N);return D<=C.x&&C.x<=D+H&&O<=C.y&&C.y<=O+B})};w.prototype._entityBounds=function(C){return this._entityBBox(C.datum,C.index,C.dataset,this._getAttrToProjector())};w.prototype._entityBBox=function(C,G,D,B){return{x:B.x(C,G,D),y:B.y(C,G,D),width:B.width(C,G,D),height:B.height(C,G,D)}};w.prototype.label=function(C){if(null==C)return this._label;this._label=C;this.render();return this};w.prototype.labelsEnabled=function(C){if(null==C)return this._labelsEnabled;
this._labelsEnabled=C;this.render();return this};w.prototype._propertyProjectors=function(){var C=y.prototype._propertyProjectors.call(this);null!=this.x2()&&(C.x2=A.Plot._scaledAccessor(this.x2()));null!=this.y2()&&(C.y2=A.Plot._scaledAccessor(this.y2()));return C};w.prototype._pixelPoint=function(C,G,D){var B=this._getAttrToProjector(),I=B.x(C,G,D),N=B.y(C,G,D),O=B.width(C,G,D);C=B.height(C,G,D);return{x:I+O/2,y:N+C/2}};w.prototype._rectangleWidth=function(C){if(C instanceof u.Category)return C.rangeBand();
var G=C===this.x().scale?this.x().accessor:this.y().accessor,D=t.set(x.Array.flatten(this.datasets().map(function(N){return N.data().map(function(O,H){return G(O,H,N).valueOf()})}))).values().map(function(N){return+N}),B=x.Math.min(D,0);D=x.Math.max(D,0);var I=C.scale(B);return(C.scale(D)-I)/Math.abs(D-B)};w.prototype._getDataToDraw=function(){var C=new x.Map,G=this._getAttrToProjector();this.datasets().forEach(function(D){var B=D.data().map(function(I,N){return x.Math.isValidNumber(G.x(I,N,D))&&
x.Math.isValidNumber(G.y(I,N,D))&&x.Math.isValidNumber(G.width(I,N,D))&&x.Math.isValidNumber(G.height(I,N,D))?I:null});C.set(D,B)});return C};w.prototype._additionalPaint=function(C){var G=this;this._renderArea.selectAll(".label-area").remove();this._labelsEnabled&&null!=this.label()&&x.Window.setTimeout(function(){return G._drawLabels()},C)};w.prototype._drawLabels=function(){var C=this,G=this._getDataToDraw();this.datasets().forEach(function(D,B){return C._drawLabel(G,D,B)})};w.prototype._drawLabel=
function(C,G,D){var B=this,I=this._getAttrToProjector(),N=this._renderArea.append("g").classed("label-area",!0),O=new l.SvgContext(N.node()),H=new l.CacheMeasurer(O),K=new l.Writer(H,O);O=this.x().scale.range();var M=this.y().scale.range(),L=Math.min.apply(null,O),Q=Math.max.apply(null,O),T=Math.min.apply(null,M),X=Math.max.apply(null,M);C.get(G).forEach(function(aa,la){if(null!=aa){var Z=""+B.label()(aa,la,G),ba=H.measure(Z),ea=I.x(aa,la,G),ca=I.y(aa,la,G),ka=I.width(aa,la,G),Y=I.height(aa,la,G);
ba.height<=Y&&ba.width<=ka&&(Y=(Y-ba.height)/2,ea+=(ka-ba.width)/2,ca+=Y,ka={min:ea,max:ea+ba.width},Y={min:ca,max:ca+ba.height},ka.min<L||ka.max>Q||Y.min<T||Y.max>X||B._overlayLabel(ka,Y,la,D,C)||(aa=I.fill(aa,la,G),aa=1.6*x.Color.contrast("white",aa)<x.Color.contrast("black",aa),ea=N.append("g").attr("transform","translate("+ea+","+ca+")"),ea.classed(aa?"dark-label":"light-label",!0),K.write(Z,ba.width,ba.height,{xAlign:"center",yAlign:"center"},ea.node())))}})};w.prototype._overlayLabel=function(C,
G,D,B,I){for(var N=this._getAttrToProjector(),O=this.datasets(),H=B;H<O.length;H++)for(var K=O[H],M=I.get(K),L=H===B?D+1:0;L<M.length;L++)if(x.DOM.intersectsBBox(C,G,this._entityBBox(M[L],L,K,N)))return!0;return!1};return w}(h(16).XYPlot);d._X2_KEY="x2";d._Y2_KEY="y2";f.Rectangle=d},function(d,f,h){var k=this&&this.__extends||function(y,w){function C(){this.constructor=y}for(var G in w)w.hasOwnProperty(G)&&(y[G]=w[G]);y.prototype=null===w?Object.create(w):(C.prototype=w.prototype,new C)},t=h(31),
l=h(6),p=h(48),m=h(7),n=h(14),q=h(3),u=h(0),x=h(19),A=h(2);d=function(y){function w(){var C=y.call(this)||this;C.addClass("scatter-plot");var G=new m.Easing;G.startDelay(5);G.stepDuration(250);G.maxTotalDuration(A.Plot._ANIMATION_MAX_DURATION);C.animator(x.Animator.MAIN,G);C.attr("opacity",.6);C.attr("fill",(new q.Color).range()[0]);C.size(6);var D=t.circle();C.symbol(function(){return D});return C}k(w,y);w.prototype._buildLightweightPlotEntities=function(C){var G=this;return y.prototype._buildLightweightPlotEntities.call(this,
C).map(function(D){var B=A.Plot._scaledAccessor(G.size())(D.datum,D.index,D.dataset);D.diameter=B;return D})};w.prototype._createDrawer=function(C){var G=this;return new l.ProxyDrawer(function(){return new p.SymbolSVGDrawer},function(D){return new n.CanvasDrawer(D,p.makeSymbolCanvasDrawStep(C,function(){return A.Plot._scaledAccessor(G.symbol())},function(){return A.Plot._scaledAccessor(G.size())}))})};w.prototype.size=function(C,G){if(null==C)return this._propertyBindings.get(w._SIZE_KEY);this._bindProperty(w._SIZE_KEY,
C,G);this.render();return this};w.prototype.symbol=function(C){if(null==C)return this._propertyBindings.get(w._SYMBOL_KEY);this._propertyBindings.set(w._SYMBOL_KEY,{accessor:C});this.render();return this};w.prototype._generateDrawSteps=function(){var C=[];if(this._animateOnNextRender()){var G=this._getAttrToProjector(),D=A.Plot._scaledAccessor(this.symbol());G.d=function(B,I,N){return D(B,I,N)(0)(null)};C.push({attrToProjector:G,animator:this._getAnimator(x.Animator.RESET)})}C.push({attrToProjector:this._getAttrToProjector(),
animator:this._getAnimator(x.Animator.MAIN)});return C};w.prototype._propertyProjectors=function(){var C=y.prototype._propertyProjectors.call(this),G=A.Plot._scaledAccessor(this.x()),D=A.Plot._scaledAccessor(this.y());C.x=G;C.y=D;C.transform=function(B,I,N){return"translate("+G(B,I,N)+","+D(B,I,N)+")"};C.d=this._constructSymbolGenerator();return C};w.prototype._constructSymbolGenerator=function(){var C=A.Plot._scaledAccessor(this.symbol()),G=A.Plot._scaledAccessor(this.size());return function(D,B,
I){return C(D,B,I)(G(D,B,I))(null)}};w.prototype._entityBounds=function(C){return{x:C.position.x-C.diameter/2,y:C.position.y-C.diameter/2,width:C.diameter,height:C.diameter}};w.prototype._entityVisibleOnPlot=function(C,G){var D={min:G.topLeft.x,max:G.bottomRight.x};G={min:G.topLeft.y,max:G.bottomRight.y};C=this._entityBounds(C);return u.DOM.intersectsBBox(D,G,C)};w.prototype.entitiesAt=function(C){var G=A.Plot._scaledAccessor(this.x()),D=A.Plot._scaledAccessor(this.y()),B=A.Plot._scaledAccessor(this.size());
return this.entities().filter(function(I){var N=I.datum,O=I.index,H=I.dataset;I=G(N,O,H);var K=D(N,O,H);N=B(N,O,H);return I-N/2<=C.x&&C.x<=I+N/2&&K-N/2<=C.y&&C.y<=K+N/2})};return w}(h(16).XYPlot);d._SIZE_KEY="size";d._SYMBOL_KEY="symbol";f.Scatter=d},function(d,f,h){var k=this&&this.__extends||function(u,x){function A(){this.constructor=u}for(var y in x)x.hasOwnProperty(y)&&(u[y]=x[y]);u.prototype=null===x?Object.create(x):(A.prototype=x.prototype,new A)},t=h(7),l=h(6),p=h(47),m=h(3),n=h(35),q=h(2);
d=function(u){function x(){var A=u.call(this)||this;A.addClass("segment-plot");A.attr("stroke",(new m.Color).range()[0]);A.attr("stroke-width","2px");return A}k(x,u);x.prototype._createDrawer=function(){return new l.ProxyDrawer(function(){return new p.SegmentSVGDrawer},function(){n.warn("canvas renderer is not supported on Segment Plot!");return null})};x.prototype._generateDrawSteps=function(){return[{attrToProjector:this._getAttrToProjector(),animator:new t.Null}]};x.prototype._filterForProperty=
function(A){return"x2"===A?u.prototype._filterForProperty.call(this,"x"):"y2"===A?u.prototype._filterForProperty.call(this,"y"):u.prototype._filterForProperty.call(this,A)};x.prototype.x=function(A,y){if(null==A)return u.prototype.x.call(this);null==y?u.prototype.x.call(this,A):(u.prototype.x.call(this,A,y),A=(A=this.x2())&&A.accessor,null!=A&&this._bindProperty(x._X2_KEY,A,y));return this};x.prototype.x2=function(){return this._propertyBindings.get(x._X2_KEY)};x.prototype.y=function(A,y){if(null==
A)return u.prototype.y.call(this);null==y?u.prototype.y.call(this,A):(u.prototype.y.call(this,A,y),A=(A=this.y2())&&A.accessor,null!=A&&this._bindProperty(x._Y2_KEY,A,y));return this};x.prototype.y2=function(){return this._propertyBindings.get(x._Y2_KEY)};x.prototype._propertyProjectors=function(){var A=u.prototype._propertyProjectors.call(this);A.x1=q.Plot._scaledAccessor(this.x());A.x2=null==this.x2()?q.Plot._scaledAccessor(this.x()):q.Plot._scaledAccessor(this.x2());A.y1=q.Plot._scaledAccessor(this.y());
A.y2=null==this.y2()?q.Plot._scaledAccessor(this.y()):q.Plot._scaledAccessor(this.y2());return A};x.prototype.entitiesAt=function(A){A=this.entityNearest(A);return null!=A?[A]:[]};x.prototype.entitiesIn=function(A,y){if(null==y){var w={min:A.topLeft.x,max:A.bottomRight.x};A={min:A.topLeft.y,max:A.bottomRight.y}}else w=A,A=y;return this._entitiesIntersecting(w,A)};x.prototype._entitiesIntersecting=function(A,y){var w=this,C=[],G=this._getAttrToProjector();this.entities().forEach(function(D){w._lineIntersectsBox(D,
A,y,G)&&C.push(D)});return C};x.prototype._lineIntersectsBox=function(A,y,w,C){var G=this,D=C.x1(A.datum,A.index,A.dataset),B=C.x2(A.datum,A.index,A.dataset),I=C.y1(A.datum,A.index,A.dataset);A=C.y2(A.datum,A.index,A.dataset);if(y.min<=D&&D<=y.max&&w.min<=I&&I<=w.max||y.min<=B&&B<=y.max&&w.min<=A&&A<=w.max)return!0;var N={x:D,y:I},O={x:B,y:A},H=[{x:y.min,y:w.min},{x:y.min,y:w.max},{x:y.max,y:w.max},{x:y.max,y:w.min}];return 0<H.filter(function(K,M){return 0!==M?G._lineIntersectsSegment(N,O,K,H[M-
1])&&G._lineIntersectsSegment(K,H[M-1],N,O):!1}).length};x.prototype._lineIntersectsSegment=function(A,y,w,C){function G(D,B,I){return(B.x-D.x)*(I.y-B.y)-(B.y-D.y)*(I.x-B.x)}return 0>G(A,y,w)*G(A,y,C)};return x}(h(16).XYPlot);d._X2_KEY="x2";d._Y2_KEY="y2";f.Segment=d},function(d,f,h){var k=this&&this.__extends||function(q,u){function x(){this.constructor=q}for(var A in u)u.hasOwnProperty(A)&&(q[A]=u[A]);q.prototype=null===u?Object.create(u):(x.prototype=u.prototype,new x)},t=h(1),l=h(7),p=h(20),m=
h(0);d=h(50);var n=h(2);h=function(q){function u(){var x=q.call(this)||this;x._stackingResult=p.memThunk(function(){return x.datasets()},function(){return x.x().accessor},function(){return x.y().accessor},function(){return x._stackingOrder},function(A,y,w,C){return m.Stacking.stack(A,y,w,C)});x._stackedExtent=p.memThunk(x._stackingResult,function(){return x.x().accessor},function(){return x._filterForProperty("y")},function(A,y,w){return m.Stacking.stackedExtent(A,y,w)});x._baselineValue=0;x._stackingOrder=
"bottomup";x.addClass("stacked-area-plot");x.attr("fill-opacity",1);x._baselineValueProvider=function(){return[x._baselineValue]};x.croppedRenderingEnabled(!1);return x}k(u,q);u.prototype.croppedRenderingEnabled=function(x){return null==x?q.prototype.croppedRenderingEnabled.call(this):x?(m.Window.warn("Warning: Stacked Area Plot does not support cropped rendering."),this):q.prototype.croppedRenderingEnabled.call(this,x)};u.prototype._getAnimator=function(){return new l.Null};u.prototype._setup=function(){q.prototype._setup.call(this);
this._baseline=this._renderArea.append("line").classed("baseline",!0)};u.prototype.x=function(x,A){if(null==x)return q.prototype.x.call(this);null==A?q.prototype.x.call(this,x):q.prototype.x.call(this,x,A);this._checkSameDomain();return this};u.prototype.y=function(x,A){if(null==x)return q.prototype.y.call(this);null==A?q.prototype.y.call(this,x):q.prototype.y.call(this,x,A);this._checkSameDomain();return this};u.prototype.stackingOrder=function(x){if(null==x)return this._stackingOrder;this._stackingOrder=
x;this._onDatasetUpdate();return this};u.prototype.downsamplingEnabled=function(){return q.prototype.downsamplingEnabled.call(this)};u.prototype._additionalPaint=function(){var x=this.y().scale.scale(this._baselineValue);x={x1:0,y1:x,x2:this.width(),y2:x};this._getAnimator("baseline").animate(this._baseline,x)};u.prototype._updateYScale=function(){var x=this.y();x=x&&x.scale;null!=x&&(x.addPaddingExceptionsProvider(this._baselineValueProvider),x.addIncludedValuesProvider(this._baselineValueProvider))};
u.prototype._onDatasetUpdate=function(){this._checkSameDomain();q.prototype._onDatasetUpdate.call(this);return this};u.prototype.getExtentsForProperty=function(x){return"y"===x?[this._stackedExtent()]:q.prototype.getExtentsForProperty.call(this,x)};u.prototype._checkSameDomain=function(){if(this._projectorsReady()){var x=this.datasets(),A=this.x().accessor,y=x.map(function(C){return t.set(C.data().map(function(G,D){return A(G,D,C).toString()})).values()}),w=u._domainKeys(x,A);y.some(function(C){return C.length!==
w.length})&&m.Window.warn("the domains across the datasets are not the same. Plot may produce unintended behavior.")}};u._domainKeys=function(x,A){var y=t.set();x.forEach(function(w){w.data().forEach(function(C,G){y.add(A(C,G,w))})});return y.values()};u.prototype._propertyProjectors=function(){function x(D,B,I){return m.Stacking.normalizeKey(C(D,B,I))}var A=this,y=q.prototype._propertyProjectors.call(this),w=this.y().accessor,C=this.x().accessor,G=this._stackingResult();y.d=this._constructAreaProjector(n.Plot._scaledAccessor(this.x()),
function(D,B,I){return A.y().scale.scale(+w(D,B,I)+G.get(I).get(x(D,B,I)).offset)},function(D,B,I){return A.y().scale.scale(G.get(I).get(x(D,B,I)).offset)});return y};u.prototype._pixelPoint=function(x,A,y){var w=q.prototype._pixelPoint.call(this,x,A,y),C=this.x().accessor(x,A,y);x=this.y().accessor(x,A,y);y=this.y().scale.scale(+x+this._stackingResult().get(y).get(m.Stacking.normalizeKey(C)).offset);return{x:w.x,y}};return u}(d.Area);f.StackedArea=h},function(d,f,h){var k=this&&this.__extends||function(u,
x){function A(){this.constructor=u}for(var y in x)x.hasOwnProperty(y)&&(u[y]=x[y]);u.prototype=null===x?Object.create(x):(A.prototype=x.prototype,new A)},t=h(5),l=h(8),p=h(20),m=h(0),n=h(27),q=h(2);d=function(u){function x(A){void 0===A&&(A="vertical");var y=u.call(this,A)||this;y._extremaFormatter=l.identity();y._stackingResult=p.memThunk(function(){return y.datasets()},function(){return y.position().accessor},function(){return y.length().accessor},function(){return y._stackingOrder},function(w,
C,G,D){return m.Stacking.stack(w,C,G,D)});y._stackedExtent=p.memThunk(y._stackingResult,function(){return y.position().accessor},function(){return y._filterForProperty(y._isVertical?"y":"x")},function(w,C,G){return m.Stacking.stackedExtent(w,C,G)});y.addClass("stacked-bar-plot");y._stackingOrder="bottomup";return y}k(x,u);x.prototype.stackingOrder=function(A){if(null==A)return this._stackingOrder;this._stackingOrder=A;this._onDatasetUpdate();return this};x.prototype.extremaFormatter=function(A){if(0===
arguments.length)return this._extremaFormatter;this._extremaFormatter=A;this.render();return this};x.prototype._setup=function(){u.prototype._setup.call(this);this._labelArea=this._renderArea.append("g").classed(n.Bar._LABEL_AREA_CLASS,!0);var A=new t.SvgContext(this._labelArea.node());this._measurer=new t.CacheMeasurer(A);this._writer=new t.Writer(this._measurer,A)};x.prototype._drawLabels=function(){function A(O,H){var K=w._generateAttrToProjector(),M=w.width(),L=w.height();O.forEach(function(Q){if(Q.extent!==
C){var T=w.extremaFormatter()(Q.extent),X=w._measurer.measure(T),aa=Q.stackedDatum,la=aa.originalDatum,Z=aa.originalIndex;aa=aa.originalDataset;w._isDatumOnScreen(K,M,L,la,Z,aa)&&(la=q.Plot._scaledAccessor(w.attr(n.Bar._BAR_THICKNESS_KEY))(la,Z,aa),Z=D.scale(Q.extent),Q=w._getPositionAttr(G.scale(Q.axisValue),la)+la/2,Q=H(w._isVertical?{x:Q,y:Z}:{x:Z,y:Q},X,la),T=y(T,{topLeft:Q,bottomRight:{x:Q.x+X.width,y:Q.y+X.height}},la),N.push(T))}})}function y(O,H,K){var M=H.topLeft,L=M.x,Q=M.y;M=H.bottomRight.x-
H.topLeft.x;H=H.bottomRight.y-H.topLeft.y;K=w._isVertical?M>K:H>K;K||(L=w._labelArea.append("g").attr("transform","translate("+L+", "+Q+")"),L.classed("stacked-bar-label",!0),w._writer.write(O,M,H,{xAlign:"center",yAlign:"center"},L.node()));return K}var w=this;u.prototype._drawLabels.call(this);this._labelArea.selectAll("g").remove();var C=+this.baselineValue(),G=this.position().scale,D=this.length().scale,B=m.Stacking.stackedExtents(this._stackingResult()),I=B.minimumExtents,N=[];A(B.maximumExtents,
function(O,H){var K=w._isVertical?H.width:H.height;H=w._isVertical?H.height:H.width;return{x:w._isVertical?O.x-K/2:O.x+x._EXTREMA_LABEL_MARGIN_FROM_BAR,y:w._isVertical?O.y-H:O.y-K/2}});A(I,function(O,H){var K=w._isVertical?H.width:H.height;H=w._isVertical?H.height:H.width;return{x:w._isVertical?O.x-K/2:O.x-H,y:w._isVertical?O.y+x._EXTREMA_LABEL_MARGIN_FROM_BAR:O.y-K/2}});N.some(function(O){return O})&&this._labelArea.selectAll("g").remove()};x.prototype._generateAttrToProjector=function(){function A(M,
L,Q){return 0>+O(M,L,Q)?C(M,L,Q):w(M,L,Q)}function y(M,L,Q){return Math.abs(w(M,L,Q)-C(M,L,Q))}function w(M,L,Q){return N.scale(+O(M,L,Q)+K.get(Q).get(G(M,L,Q)).offset)}function C(M,L,Q){return N.scale(K.get(Q).get(G(M,L,Q)).offset)}function G(M,L,Q){return m.Stacking.normalizeKey(H(M,L,Q))}var D=this,B=u.prototype._generateAttrToProjector.call(this),I=this._isVertical?"y":"x",N=this.length().scale,O=this.length().accessor,H=this.position().accessor,K=this._stackingResult();B[this._isVertical?"height":
"width"]=y;B[I]=function(M,L,Q){return D._isVertical?A(M,L,Q):A(M,L,Q)-y(M,L,Q)};return B};x.prototype.getExtentsForProperty=function(A){return A===(this._isVertical?"y":"x")?[this._stackedExtent()]:u.prototype.getExtentsForProperty.call(this,A)};x.prototype.invalidateCache=function(){u.prototype.invalidateCache.call(this);this._measurer.reset()};return x}(n.Bar);d._EXTREMA_LABEL_MARGIN_FROM_BAR=5;f.StackedBar=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=
p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(0);d=h(27);var l=h(2);h=function(p){function m(){var n=p.call(this)||this;n._connectorsEnabled=!1;n.addClass("waterfall-plot");return n}k(m,p);m.prototype.connectorsEnabled=function(n){if(null==n)return this._connectorsEnabled;this._connectorsEnabled=n;return this};m.prototype.total=function(n){if(null==n)return this._propertyBindings.get(m._TOTAL_KEY);this._bindProperty(m._TOTAL_KEY,
n,null);return this};m.prototype._additionalPaint=function(n){var q=this;this._connectorArea.selectAll("line").remove();this._connectorsEnabled&&t.Window.setTimeout(function(){return q._drawConnectors()},n)};m.prototype._createNodesForDataset=function(n){n=p.prototype._createNodesForDataset.call(this,n);this._connectorArea=this._renderArea.append("g").classed(m._CONNECTOR_AREA_CLASS,!0);return n};m.prototype.getExtentsForProperty=function(n){return"y"===n?[this._extent]:p.prototype.getExtentsForProperty.call(this,
n)};m.prototype._generateAttrToProjector=function(){var n=this,q=p.prototype._generateAttrToProjector.call(this),u=this.y().scale,x=l.Plot._scaledAccessor(this.total());null==this.attr("y")&&(q.y=function(A,y,w){var C=n.y().accessor(A,y,w);if(x(A,y,w))return Math.min(u.scale(C),u.scale(0));A=n._subtotals[y];if(0===y)return 0>C?u.scale(A-C):u.scale(A);y=n._subtotals[y-1];return A>y?u.scale(A):u.scale(y)});null==this.attr("height")&&(q.height=function(A,y,w){var C=x(A,y,w);A=n.y().accessor(A,y,w);if(C)return Math.abs(u.scale(A)-
u.scale(0));C=n._subtotals[y];if(0===y)return Math.abs(u.scale(C)-u.scale(C-A));y=n._subtotals[y-1];return Math.abs(u.scale(C)-u.scale(y))});q["class"]=function(A,y,w){var C="";null!=n.attr("class")&&(C=n.attr("class").accessor(A,y,w)+" ");if(x(A,y,w))return C+m._BAR_TOTAL_CLASS;A=n.y().accessor(A,y,w);return C+(0<A?m._BAR_GROWTH_CLASS:m._BAR_DECLINE_CLASS)};return q};m.prototype._onDatasetUpdate=function(){this._updateSubtotals();p.prototype._onDatasetUpdate.call(this);return this};m.prototype._calculateSubtotalsAndExtent=
function(n){var q=this,u=Number.MAX_VALUE,x=Number.MIN_VALUE,A=0,y=!1;n.data().forEach(function(w,C){var G=q.y().accessor(w,C,n);(w=q.total().accessor(w,C,n))&&0!==C||(A+=G);q._subtotals.push(A);A<u&&(u=A);A>x&&(x=A);w&&(G<u&&(u=G),G>x&&(x=G));if(!y&&w){C=G-A;for(G=0;G<q._subtotals.length;G++)q._subtotals[G]+=C;y=!0;A+=C;u+=C;x+=C}});this._extent=[u,x]};m.prototype._drawConnectors=function(){for(var n=this._getAttrToProjector(),q=this.datasets()[0],u=1;u<q.data().length;u++){var x=u-1,A=q.data()[u],
y=q.data()[x];y=n.x(y,x,q);var w=n.x(A,u,q)+n.width(A,u,q),C=n.y(A,u,q);if(0<this._subtotals[u]&&this._subtotals[u]>this._subtotals[x]||0>this._subtotals[u]&&this._subtotals[u]>=this._subtotals[x])C=n.y(A,u,q)+n.height(A,u,q);this._connectorArea.append("line").classed(m._CONNECTOR_CLASS,!0).attr("x1",y).attr("x2",w).attr("y1",C).attr("y2",C)}};m.prototype._updateSubtotals=function(){var n=this.datasets();0<n.length&&(n=n[n.length-1],this._subtotals=[],this._calculateSubtotalsAndExtent(n))};return m}(d.Bar);
h._BAR_DECLINE_CLASS="waterfall-decline";h._BAR_GROWTH_CLASS="waterfall-growth";h._BAR_TOTAL_CLASS="waterfall-total";h._CONNECTOR_CLASS="connector";h._CONNECTOR_AREA_CLASS="connector-area";h._TOTAL_KEY="total";f.Waterfall=h},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(1),l=h(0);d=function(p){function m(n){var q=p.call(this)||this;
switch(n){case null:case void 0:null==m._plottableColorCache&&(m._plottableColorCache=m._getPlottableColors());n=t.scaleOrdinal().range(m._plottableColorCache);break;case "Category10":case "category10":case "10":n=t.scaleOrdinal(t.schemeCategory10);break;case "Category20":case "category20":case "20":n=t.scaleOrdinal(t.schemeCategory20);break;case "Category20b":case "category20b":case "20b":n=t.scaleOrdinal(t.schemeCategory20b);break;case "Category20c":case "category20c":case "20c":n=t.scaleOrdinal(t.schemeCategory20c);
break;default:throw Error("Unsupported ColorScale type");}q._d3Scale=n;return q}k(m,p);m.prototype.extentOfValues=function(n){return l.Array.uniq(n)};m.prototype._getExtent=function(){return l.Array.uniq(this._getAllIncludedValues())};m.invalidateColorCache=function(){m._plottableColorCache=null};m._getPlottableColors=function(){for(var n=[],q=t.select("body").append("plottable-color-tester"),u=l.Color.colorTest(q,""),x=0,A=l.Color.colorTest(q,"plottable-colors-0");null!=A&&x<this._MAXIMUM_COLORS_FROM_CSS&&
(A!==u||A!==n[n.length-1]);)n.push(A),x++,A=l.Color.colorTest(q,"plottable-colors-"+x);q.remove();return n};m.prototype.scale=function(n){var q=this._d3Scale(n);n=this.domain().indexOf(n);n=Math.floor(n/this.range().length);return l.Color.lightenColor(q,Math.log(n*m._LOOP_LIGHTEN_FACTOR+1))};m.prototype._getDomain=function(){return this._backingScaleDomain()};m.prototype._backingScaleDomain=function(n){if(null==n)return this._d3Scale.domain();this._d3Scale.domain(n);return this};m.prototype._getRange=
function(){return this._d3Scale.range()};m.prototype._setRange=function(n){this._d3Scale.range(n)};return m}(h(17).Scale);d._LOOP_LIGHTEN_FACTOR=1.6;d._MAXIMUM_COLORS_FROM_CSS=256;f.Color=d},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(1),l=h(0);d=function(p){function m(n){void 0===n&&(n="linear");var q=p.call(this)||this;switch(n){case "linear":q._colorScale=
t.scaleLinear();break;case "log":q._colorScale=t.scaleLog();break;case "sqrt":q._colorScale=t.scaleSqrt();break;case "pow":q._colorScale=t.scalePow()}if(null==q._colorScale)throw Error("unknown QuantitativeScale scale type "+n);q.range(m.REDS);return q}k(m,p);m.prototype.extentOfValues=function(n){n=t.extent(n);return null==n[0]||null==n[1]?[]:n};m.prototype._d3InterpolatedScale=function(){return this._colorScale.range([0,1]).interpolate(this._interpolateColors())};m.prototype._interpolateColors=
function(){var n=this._colorRange;if(2>n.length)throw Error("Color scale arrays must have at least two elements.");return function(){return function(q){q=Math.max(0,Math.min(1,q));q*=n.length-1;var u=Math.floor(q),x=q-u;return t.interpolateLab(n[u],n[Math.ceil(q)])(x)}}};m.prototype._resetScale=function(){this._d3Scale=this._d3InterpolatedScale();this._autoDomainIfAutomaticMode();this._dispatchUpdate()};m.prototype.autoDomain=function(){var n=this._getAllIncludedValues();0<n.length&&this._setDomain([l.Math.min(n,
0),l.Math.max(n,0)])};m.prototype.scale=function(n){return this._d3Scale(n)};m.prototype._getDomain=function(){return this._backingScaleDomain()};m.prototype._backingScaleDomain=function(n){if(null==n)return this._d3Scale.domain();this._d3Scale.domain(n);return this};m.prototype._getRange=function(){return this._colorRange};m.prototype._setRange=function(n){this._colorRange=n;this._resetScale()};return m}(h(17).Scale);d.REDS="#FFFFFF #FFF6E1 #FEF4C0 #FED976 #FEB24C #FD8D3C #FC4E2A #E31A1C #B10026".split(" ");
d.BLUES="#FFFFFF #CCFFFF #A5FFFD #85F7FB #6ED3EF #55A7E0 #417FD0 #2545D3 #0B02E1".split(" ");d.POSNEG="#0B02E1 #2545D3 #417FD0 #55A7E0 #6ED3EF #85F7FB #A5FFFD #CCFFFF #FFFFFF #FFF6E1 #FEF4C0 #FED976 #FEB24C #FD8D3C #FC4E2A #E31A1C #B10026".split(" ");f.InterpolatedColor=d},function(d,f,h){var k=this&&this.__extends||function(l,p){function m(){this.constructor=l}for(var n in p)p.hasOwnProperty(n)&&(l[n]=p[n]);l.prototype=null===p?Object.create(p):(m.prototype=p.prototype,new m)},t=h(1);d=function(l){function p(){var m=
l.call(this)||this;m._d3Scale=t.scaleLinear();return m}k(p,l);p.prototype._defaultExtent=function(){return[0,1]};p.prototype._expandSingleValueDomain=function(m){return m[0]===m[1]?[m[0]-1,m[1]+1]:m};p.prototype.scale=function(m){return this._d3Scale(m)};p.prototype.scaleTransformation=function(m){return this.scale(m)};p.prototype.invertedTransformation=function(m){return this.invert(m)};p.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)};p.prototype.getTransformationDomain=
function(){return this.domain()};p.prototype.setTransformationDomain=function(m){this.domain(m)};p.prototype._getDomain=function(){return this._backingScaleDomain()};p.prototype._backingScaleDomain=function(m){if(null==m)return this._d3Scale.domain();this._d3Scale.domain(m);return this};p.prototype._getRange=function(){return this._d3Scale.range()};p.prototype._setRange=function(m){this._d3Scale.range(m)};p.prototype.invert=function(m){return this._d3Scale.invert(m)};p.prototype.defaultTicks=function(){return this._d3Scale.ticks()};
p.prototype._niceDomain=function(m,n){return this._d3Scale.copy().domain(m).nice(n).domain()};return p}(h(11).QuantitativeScale);f.Linear=d},function(d,f,h){var k=this&&this.__extends||function(m,n){function q(){this.constructor=m}for(var u in n)n.hasOwnProperty(u)&&(m[u]=n[u]);m.prototype=null===n?Object.create(n):(q.prototype=n.prototype,new q)},t=h(1),l=h(0),p=h(3);d=function(m){function n(q){void 0===q&&(q=10);var u=m.call(this)||this;u._d3Scale=t.scaleLinear();u._base=q;u._pivot=u._base;u._setDomain(u._defaultExtent());
if(1>=q)throw Error("ModifiedLogScale: The base must be \x3e 1");return u}k(n,m);n.prototype._adjustedLog=function(q){var u=0>q?-1:1;q*=u;q<this._pivot&&(q+=(this._pivot-q)/this._pivot);q=Math.log(q)/Math.log(this._base);return q*u};n.prototype._invertedAdjustedLog=function(q){var u=0>q?-1:1;q=Math.pow(this._base,q*u);q<this._pivot&&(q=this._pivot*(q-1)/(this._pivot-1));return q*u};n.prototype.scale=function(q){return this._d3Scale(this._adjustedLog(q))};n.prototype.invert=function(q){return this._invertedAdjustedLog(this._d3Scale.invert(q))};
n.prototype.scaleTransformation=function(q){return this.scale(q)};n.prototype.invertedTransformation=function(q){return this.invert(q)};n.prototype.getTransformationExtent=function(){return this._getUnboundedExtent(!0)};n.prototype.getTransformationDomain=function(){return this.domain()};n.prototype.setTransformationDomain=function(q){this.domain(q)};n.prototype._getDomain=function(){return this._untransformedDomain};n.prototype._setDomain=function(q){this._untransformedDomain=q;m.prototype._setDomain.call(this,
[this._adjustedLog(q[0]),this._adjustedLog(q[1])])};n.prototype._backingScaleDomain=function(q){if(null==q)return this._d3Scale.domain();this._d3Scale.domain(q);return this};n.prototype.ticks=function(){function q(G,D,B){return[G,D,B].sort(function(I,N){return I-N})[1]}var u=l.Math.min(this._untransformedDomain,0),x=l.Math.max(this._untransformedDomain,0),A=q(u,x,-this._pivot),y=q(u,x,this._pivot);A=this._logTicks(-A,-u).map(function(G){return-G}).reverse();y=this._logTicks(y,x);var w=Math.max(u,
-this._pivot),C=Math.min(x,this._pivot);w=t.scaleLinear().domain([w,C]).ticks(this._howManyTicks(w,C));A=A.concat(w).concat(y);1>=A.length&&(A=t.scaleLinear().domain([u,x]).ticks());return A};n.prototype._logTicks=function(q,u){var x=this,A=this._howManyTicks(q,u);if(0===A)return[];var y=Math.floor(Math.log(q)/Math.log(this._base)),w=Math.ceil(Math.log(u)/Math.log(this._base));A=t.range(w,y,-Math.ceil((w-y)/A));y=t.range(this._base,1,-(this._base-1)).map(Math.floor);var C=l.Array.uniq(y);A=A.map(function(G){return C.map(function(D){return Math.pow(x._base,
G-1)*D})});return l.Array.flatten(A).filter(function(G){return q<=G&&G<=u}).sort(function(G,D){return G-D})};n.prototype._howManyTicks=function(q,u){var x=this._adjustedLog(l.Math.min(this._untransformedDomain,0)),A=this._adjustedLog(l.Math.max(this._untransformedDomain,0));return Math.ceil((this._adjustedLog(u)-this._adjustedLog(q))/(A-x)*p.ModifiedLog._DEFAULT_NUM_TICKS)};n.prototype._niceDomain=function(q){return q};n.prototype._defaultExtent=function(){return[0,this._base]};n.prototype._expandSingleValueDomain=
function(q){return q[0]===q[1]?(q=q[0],0<q?[q/this._base,q*this._base]:0===q?[-this._base,this._base]:[q*this._base,q/this._base]):q};n.prototype._getRange=function(){return this._d3Scale.range()};n.prototype._setRange=function(q){this._d3Scale.range(q)};n.prototype.defaultTicks=function(){return this._d3Scale.ticks()};return n}(h(11).QuantitativeScale);f.ModifiedLog=d},function(d,f,h){var k=h(0);f.intervalTickGenerator=function(t){if(0>=t)throw Error("interval must be positive number");return function(l){l=
l.domain();var p=Math.min(l[0],l[1]);l=Math.max(l[0],l[1]);var m=Math.ceil(p/t)*t;p=0===p%t?[]:[p];var n=k.Math.range(0,Math.floor((l-m)/t)+1).map(function(q){return m+q*t});return p.concat(n).concat(0===l%t?[]:[l])}};f.integerTickGenerator=function(){return function(t){var l=t.defaultTicks();return l.filter(function(p,m){return 0===p%1||0===m||m===l.length-1})}}},function(d,f,h){var k=this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);
p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(1),l=h(28);d=function(p){function m(){var n=p.call(this)||this;n._d3Scale=t.scaleTime();n.autoDomain();return n}k(m,p);m.prototype.tickInterval=function(n,q){void 0===q&&(q=1);var u=t.scaleTime();m.timeIntervalToD3Time(n).every(q);u.domain(this.domain());u.range(this.range());return u.ticks()};m.prototype._setDomain=function(n){if(n[1]<n[0])throw Error("Scale.Time domain values must be in chronological order");return p.prototype._setDomain.call(this,
n)};m.prototype._defaultExtent=function(){return[new Date("1970-01-01"),new Date("1970-01-02")]};m.prototype._expandSingleValueDomain=function(n){var q=n[0].getTime(),u=n[1].getTime();return q===u?(n=new Date(q),n.setDate(n.getDate()-1),u=new Date(u),u.setDate(u.getDate()+1),[n,u]):n};m.prototype.scale=function(n){return this._d3Scale(n)};m.prototype.scaleTransformation=function(n){return this.scale(new Date(n))};m.prototype.invertedTransformation=function(n){return this.invert(n).getTime()};m.prototype.getTransformationExtent=
function(){var n=this._getUnboundedExtent(!0);return[n[0].valueOf(),n[1].valueOf()]};m.prototype.getTransformationDomain=function(){var n=this.domain();return[n[0].valueOf(),n[1].valueOf()]};m.prototype.setTransformationDomain=function(n){this.domain([new Date(n[0]),new Date(n[1])])};m.prototype._getDomain=function(){return this._backingScaleDomain()};m.prototype._backingScaleDomain=function(n){if(null==n)return this._d3Scale.domain();this._d3Scale.domain(n);return this};m.prototype._getRange=function(){return this._d3Scale.range()};
m.prototype._setRange=function(n){this._d3Scale.range(n)};m.prototype.invert=function(n){return this._d3Scale.invert(n)};m.prototype.defaultTicks=function(){return this._d3Scale.ticks()};m.prototype._niceDomain=function(n){return this._d3Scale.copy().domain(n).nice().domain()};m.timeIntervalToD3Time=function(n){switch(n){case l.TimeInterval.second:return t.timeSecond;case l.TimeInterval.minute:return t.timeMinute;case l.TimeInterval.hour:return t.timeHour;case l.TimeInterval.day:return t.timeDay;
case l.TimeInterval.week:return t.timeWeek;case l.TimeInterval.month:return t.timeMonth;case l.TimeInterval.year:return t.timeYear;default:throw Error("TimeInterval specified does not exist: "+n);}};return m}(h(11).QuantitativeScale);f.Time=d},function(d,f,h){var k=h(1),t=Array;f.add=function(l,p){if(l.length!==p.length)throw Error("attempted to add arrays of unequal length");return l.map(function(m,n){return l[n]+p[n]})};f.uniq=function(l){var p=k.set(),m=[];l.forEach(function(n){p.has(String(n))||
(p.add(String(n)),m.push(n))});return m};f.flatten=function(l){return t.prototype.concat.apply([],l)};f.createFilledArray=function(l,p){for(var m=[],n=0;n<p;n++)m[n]="function"===typeof l?l(n):l;return m}},function(d,f){d=function(){function h(k,t,l){this.maxIndex=this.minIndex=this.exitIndex=this.entryIndex=k;this.bucketValue=t;this.maxValue=this.minValue=l}h.prototype.isInBucket=function(k){return k==this.bucketValue};h.prototype.addToBucket=function(k,t){k<this.minValue&&(this.minValue=k,this.minIndex=
t);k>this.maxValue&&(this.maxValue=k,this.maxIndex=t);this.exitIndex=t};h.prototype.getUniqueIndices=function(){var k=[this.entryIndex,this.maxIndex,this.minIndex,this.exitIndex];return k.filter(function(t,l){return 0==l||t!=k[l-1]})};return h}();f.Bucket=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){return null!==
t&&t.apply(this,arguments)||this}k(l,t);l.prototype.callCallbacks=function(){for(var p=this,m=[],n=0;n<arguments.length;n++)m[n]=arguments[n];this.forEach(function(q){q.apply(p,m)});return this};return l}(h(58).Set);f.CallbackSet=d},function(d,f,h){function k(p){function m(u){u/=255;return.03928>=u?u/12.92:l.pow((u+.055)/1.055,2.4)}var n=t.rgb(p);p=m(n.r);var q=m(n.g);n=m(n.b);return.2126*p+.7152*q+.0722*n}var t=h(1),l=Math;f.contrast=function(p,m){p=k(p)+.05;m=k(m)+.05;return p>m?p/m:m/p};f.lightenColor=
function(p,m){return t.color(p).brighter(m).rgb().toString()};f.colorTest=function(p,m){p.classed(m,!0);var n=p.style("background-color");if("transparent"===n)return null;n=/\((.+)\)/.exec(n);if(!n)return null;n=n[1].split(",").map(function(q){q=+q;var u=q.toString(16);return 16>q?"0"+u:u});if(4===n.length&&"00"===n[3])return null;n="#"+n.join("");p.classed(m,!1);return n}},function(d,f,h){var k=h(1),t=h(57);d=function(){function l(){this._entities=[];this._rtree=new t.RTree;this._tree=k.quadtree().x(function(p){return Math.floor(p.position.x)}).y(function(p){return Math.floor(p.position.y)})}
l.prototype.addAll=function(p,m,n){(x=this._entities).push.apply(x,p);if(void 0!==n)for(n=t.RTreeBounds.bounds(n),x=0;x<p.length;x++){var q=p[x],u=t.RTreeBounds.entityBounds(m(q));t.RTreeBounds.isBoundsOverlapBounds(n,u)&&(this._tree.add(q),this._rtree.insert(u,q))}else for(this._tree.addAll(p),x=0;x<p.length;x++)q=p[x],u=t.RTreeBounds.entityBounds(m(q)),this._rtree.insert(u,q);var x};l.prototype.entityNearest=function(p){return this._tree.find(p.x,p.y)};l.prototype.entitiesInBounds=function(p){return this._rtree.intersect(t.RTreeBounds.entityBounds(p))};
l.prototype.entitiesInXBounds=function(p){return this._rtree.intersectX(t.RTreeBounds.entityBounds(p))};l.prototype.entitiesInYBounds=function(p){return this._rtree.intersectY(t.RTreeBounds.entityBounds(p))};l.prototype.entities=function(){return this._entities};return l}();f.EntityStore=d},function(d,f,h){var k=h(56);d=function(){function t(){"function"===typeof window.Map?this._es6Map=new window.Map:this._keyValuePairs=[]}t.prototype.set=function(l,p){if(k.isNaN(l))throw Error("NaN may not be used as a key to the Map");
if(null!=this._es6Map)return this._es6Map.set(l,p),this;for(var m=0;m<this._keyValuePairs.length;m++)if(this._keyValuePairs[m].key===l)return this._keyValuePairs[m].value=p,this;this._keyValuePairs.push({key:l,value:p});return this};t.prototype.get=function(l){if(null!=this._es6Map)return this._es6Map.get(l);for(var p=0;p<this._keyValuePairs.length;p++)if(this._keyValuePairs[p].key===l)return this._keyValuePairs[p].value};t.prototype.has=function(l){if(null!=this._es6Map)return this._es6Map.has(l);
for(var p=0;p<this._keyValuePairs.length;p++)if(this._keyValuePairs[p].key===l)return!0;return!1};t.prototype.forEach=function(l,p){var m=this;null!=this._es6Map?this._es6Map.forEach(function(n,q){return l.call(p,n,q,m)},p):this._keyValuePairs.forEach(function(n){l.call(p,n.value,n.key,m)})};t.prototype.delete=function(l){if(null!=this._es6Map)return this._es6Map.delete(l);for(var p=0;p<this._keyValuePairs.length;p++)if(this._keyValuePairs[p].key===l)return this._keyValuePairs.splice(p,1),!0;return!1};
return t}();f.Map=d},function(d,f){f.assign=function(){for(var h=[],k=0;k<arguments.length;k++)h[k]=arguments[k];k={};for(var t=0;t<h.length;t++)for(var l=h[t],p=0,m=Object.keys(l);p<m.length;p++){var n=m[p];k[n]=l[n]}return k}},function(d,f){d=function(){function h(){}h.prototype.split=function(k,t){for(var l=Math.ceil(k.length/2),p=0;p<l;p++)t[0].insert(k[p]);for(p=l;p<k.length;p++)t[1].insert(k[p])};return h}();f.SplitStrategyTrivial=d;d=function(){function h(){}h.prototype.split=function(k,t){k=
k.slice();for(this.chooseFirstSplit(k,t);0<k.length;)this.addNext(k,t)};h.prototype.chooseFirstSplit=function(k,t){for(var l=0,p=0,m=k.length-1,n=k.length-1,q=1;q<k.length-1;q++){var u=k[q];u.bounds.xl>k[m].bounds.xl?m=q:u.bounds.xh<k[l].bounds.xh&&(l=q);u.bounds.yl>k[n].bounds.yl?n=q:u.bounds.yh<k[p].bounds.yh&&(p=q)}p=Math.abs(k[l].bounds.xh-k[m].bounds.xl)>Math.abs(k[p].bounds.yh-k[n].bounds.yl)?[l,m]:[p,n];l=p[0];p=p[1];l===p&&(l=0,p=k.length-1);t[0].insert(k.splice(Math.max(l,p),1)[0]);t[1].insert(k.splice(Math.min(l,
p),1)[0])};h.prototype.addNext=function(k,t){for(var l=null,p=null,m=null,n=0;n<k.length;n++){var q=k[n],u=t[0].unionAreaDifference(q.bounds);q=t[1].unionAreaDifference(q.bounds);if(u<p||null==l)l=n,p=u,m=t[0];q<p&&(l=n,p=q,m=t[1])}m.insert(k.splice(l,1)[0])};return h}();f.SplitStrategyLinear=d},function(d,f,h){function k(m){return String(m)}var t=h(1),l=h(0);d=h(10);f.IStackingOrder=d.makeEnum(["topdown","bottomup"]);var p=Math;f.stack=function(m,n,q,u){void 0===u&&(u="bottomup");var x=t.map(),A=
t.map(),y=new l.Map;"topdown"===u&&(m=m.slice(),m.reverse());m.forEach(function(w){var C=new l.Map;w.data().forEach(function(G,D){var B=k(n(G,D,w)),I=+q(G,D,w),N=0<=I?x:A;if(N.has(B)){var O=N.get(B);N.set(B,O+I)}else O=0,N.set(B,I);C.set(B,{offset:O,value:I,axisValue:n(G,D,w),originalDatum:G,originalDataset:w,originalIndex:D})});y.set(w,C)});return y};f.stackedExtents=function(m){var n=new l.Map,q=new l.Map;m.forEach(function(u){u.forEach(function(x,A){var y=l.Math.max([x.offset+x.value,x.offset],
x.offset),w=l.Math.min([x.offset+x.value,x.offset],x.offset),C=x.axisValue;n.has(A)?n.get(A).extent<y&&n.set(A,{extent:y,axisValue:C,stackedDatum:x}):n.set(A,{extent:y,axisValue:C,stackedDatum:x});q.has(A)?q.get(A).extent>w&&q.set(A,{extent:w,axisValue:C,stackedDatum:x}):q.set(A,{extent:w,axisValue:C,stackedDatum:x})})});return{maximumExtents:n,minimumExtents:q}};f.stackedExtent=function(m,n,q){var u=[];m.forEach(function(A,y){y.data().forEach(function(w,C){if(null==q||q(w,C,y))w=A.get(k(n(w,C,y))),
u.push(w.value+w.offset)})});m=l.Math.max(u,0);var x=l.Math.min(u,0);return[p.min(x,0),p.max(0,m)]};f.normalizeKey=k},function(d,f,h){var k=h(0);f.getTranslator=function(l){l=l.root().rootElement().node();var p=l.__Plottable_ClientTranslator;null==p&&(p=new t(l),l.__Plottable_ClientTranslator=p);return p};var t=function(){function l(p){this._rootElement=p}l.prototype.computePosition=function(p,m){p={x:p,y:m};m=k.Math.getCumulativeTransform(this._rootElement);return null==m?p:k.Math.applyTransform(m,
p)};l.isEventInside=function(p,m){return k.DOM.contains(p.root().rootElement().node(),m.target)};return l}();f.Translator=t},function(d,f,h){Object.defineProperty(f,"__esModule",{value:!0});var k=h(124);h.d(f,"easeLinear",function(){return k.a});var t=h(126);h.d(f,"easeQuad",function(){return t.a});h.d(f,"easeQuadIn",function(){return t.b});h.d(f,"easeQuadOut",function(){return t.c});h.d(f,"easeQuadInOut",function(){return t.a});var l=h(121);h.d(f,"easeCubic",function(){return l.a});h.d(f,"easeCubicIn",
function(){return l.b});h.d(f,"easeCubicOut",function(){return l.c});h.d(f,"easeCubicInOut",function(){return l.a});var p=h(125);h.d(f,"easePoly",function(){return p.a});h.d(f,"easePolyIn",function(){return p.b});h.d(f,"easePolyOut",function(){return p.c});h.d(f,"easePolyInOut",function(){return p.a});var m=h(127);h.d(f,"easeSin",function(){return m.a});h.d(f,"easeSinIn",function(){return m.b});h.d(f,"easeSinOut",function(){return m.c});h.d(f,"easeSinInOut",function(){return m.a});var n=h(123);h.d(f,
"easeExp",function(){return n.a});h.d(f,"easeExpIn",function(){return n.b});h.d(f,"easeExpOut",function(){return n.c});h.d(f,"easeExpInOut",function(){return n.a});var q=h(120);h.d(f,"easeCircle",function(){return q.a});h.d(f,"easeCircleIn",function(){return q.b});h.d(f,"easeCircleOut",function(){return q.c});h.d(f,"easeCircleInOut",function(){return q.a});var u=h(119);h.d(f,"easeBounce",function(){return u.a});h.d(f,"easeBounceIn",function(){return u.b});h.d(f,"easeBounceOut",function(){return u.a});
h.d(f,"easeBounceInOut",function(){return u.c});var x=h(118);h.d(f,"easeBack",function(){return x.a});h.d(f,"easeBackIn",function(){return x.b});h.d(f,"easeBackOut",function(){return x.c});h.d(f,"easeBackInOut",function(){return x.a});var A=h(122);h.d(f,"easeElastic",function(){return A.a});h.d(f,"easeElasticIn",function(){return A.b});h.d(f,"easeElasticOut",function(){return A.a});h.d(f,"easeElasticInOut",function(){return A.c})},function(d,f,h){h.d(f,"b",function(){return k});h.d(f,"c",function(){return t});
h.d(f,"a",function(){return l});var k=function n(m){function q(u){return u*u*((m+1)*u-m)}m=+m;q.overshoot=n;return q}(1.70158),t=function q(n){function u(x){return--x*x*((n+1)*x+n)+1}n=+n;u.overshoot=q;return u}(1.70158),l=function u(q){function x(A){return(1>(A*=2)?A*A*((q+1)*A-q):(A-=2)*A*((q+1)*A+q)+2)/2}q=+q;x.overshoot=u;return x}(1.70158)},function(d,f){function h(y){return(y=+y)<k?A*y*y:y<l?A*(y-=t)*y+p:y<n?A*(y-=m)*y+q:A*(y-=u)*y+x}f.b=function(y){return 1-h(1-y)};f.a=h;f.c=function(y){return(1>=
(y*=2)?1-h(1-y):h(y-1)+1)/2};var k=4/11,t=6/11,l=8/11,p=.75,m=9/11,n=10/11,q=.9375,u=21/22,x=.984375,A=1/k/k},function(d,f){f.b=function(h){return 1-Math.sqrt(1-h*h)};f.c=function(h){return Math.sqrt(1- --h*h)};f.a=function(h){return(1>=(h*=2)?1-Math.sqrt(1-h*h):Math.sqrt(1-(h-=2)*h)+1)/2}},function(d,f){f.b=function(h){return h*h*h};f.c=function(h){return--h*h*h+1};f.a=function(h){return(1>=(h*=2)?h*h*h:(h-=2)*h*h+2)/2}},function(d,f,h){h.d(f,"b",function(){return t});h.d(f,"a",function(){return l});
h.d(f,"c",function(){return p});var k=2*Math.PI,t=function u(n,q){function x(y){return n*Math.pow(2,10*--y)*Math.sin((A-y)/q)}var A=Math.asin(1/(n=Math.max(1,n)))*(q/=k);x.amplitude=function(y){return u(y,q*k)};x.period=function(y){return u(n,y)};return x}(1,.3),l=function x(q,u){function A(w){return 1-q*Math.pow(2,-10*(w=+w))*Math.sin((w+y)/u)}var y=Math.asin(1/(q=Math.max(1,q)))*(u/=k);A.amplitude=function(w){return x(w,u*k)};A.period=function(w){return x(q,w)};return A}(1,.3),p=function A(u,x){function y(C){return(0>
(C=2*C-1)?u*Math.pow(2,10*C)*Math.sin((w-C)/x):2-u*Math.pow(2,-10*C)*Math.sin((w+C)/x))/2}var w=Math.asin(1/(u=Math.max(1,u)))*(x/=k);y.amplitude=function(C){return A(C,x*k)};y.period=function(C){return A(u,C)};return y}(1,.3)},function(d,f){f.b=function(h){return Math.pow(2,10*h-10)};f.c=function(h){return 1-Math.pow(2,-10*h)};f.a=function(h){return(1>=(h*=2)?Math.pow(2,10*h-10):2-Math.pow(2,10-10*h))/2}},function(d,f){f.a=function(h){return+h}},function(d,f,h){h.d(f,"b",function(){return k});h.d(f,
"c",function(){return t});h.d(f,"a",function(){return l});var k=function n(m){function q(u){return Math.pow(u,m)}m=+m;q.exponent=n;return q}(3),t=function q(n){function u(x){return 1-Math.pow(1-x,n)}n=+n;u.exponent=q;return u}(3),l=function u(q){function x(A){return(1>=(A*=2)?Math.pow(A,q):2-Math.pow(2-A,q))/2}q=+q;x.exponent=u;return x}(3)},function(d,f){f.b=function(h){return h*h};f.c=function(h){return h*(2-h)};f.a=function(h){return(1>=(h*=2)?h*h:--h*(2-h)+1)/2}},function(d,f){f.b=function(t){return 1-
Math.cos(t*k)};f.c=function(t){return Math.sin(t*k)};f.a=function(t){return(1-Math.cos(h*t))/2};var h=Math.PI,k=h/2},function(d,f,h){function k(l){return!0===t(l)&&"[object Object]"===Object.prototype.toString.call(l)}var t=h(129);d.exports=function(l){if(!1===k(l))return!1;l=l.constructor;if("function"!==typeof l)return!1;l=l.prototype;return!1===k(l)||!1===l.hasOwnProperty("isPrototypeOf")?!1:!0}},function(d){d.exports=function(f){return null!=f&&"object"===typeof f&&!1===Array.isArray(f)}},function(d,
f){d=function(){function h(k,t,l){void 0===t&&(t=10);void 0===l&&(l={});var p=this;this.ctx=k;this.lineHeight=t;this.style=l;this.createRuler=function(){return function(m){p.ctx.font=p.style.font;return{width:p.ctx.measureText(m).width,height:p.lineHeight}}};this.createPen=function(m,n,q){null==q&&(q=p.ctx);q.save();q.translate(n.translate[0],n.translate[1]);q.rotate(n.rotate*Math.PI/180);return p.createCanvasPen(q)};void 0===this.style.fill&&(this.style.fill="#444")}h.prototype.createCanvasPen=function(k){var t=
this;return{destroy:function(){k.restore()},write:function(l,p,m,n){k.textAlign=p;null!=t.style.font&&(k.font=t.style.font);null!=t.style.fill&&(k.fillStyle=t.style.fill,k.fillText(l,m,n));null!=t.style.stroke&&(k.strokeStyle=t.style.fill,k.strokeText(l,m,n))}}};return h}();f.CanvasContext=d},function(d,f){var h=function(){function k(){}k.append=function(t,l){for(var p=[],m=2;m<arguments.length;m++)p[m-2]=arguments[m];p=k.create.apply(k,[l].concat(p));t.appendChild(p);return p};k.create=function(t){for(var l=
[],p=1;p<arguments.length;p++)l[p-1]=arguments[p];p=document.createElementNS(k.SVG_NS,t);k.addClasses.apply(k,[p].concat(l));return p};k.addClasses=function(t){for(var l=[],p=1;p<arguments.length;p++)l[p-1]=arguments[p];l=l.filter(function(m){return null!=m});null!=t.classList?l.forEach(function(m){t.classList.add(m)}):t.setAttribute("class",l.join(" "))};k.getDimensions=function(t){if(t.getBBox)try{var l=t.getBBox();return{width:l.width,height:l.height}}catch(p){}return{height:0,width:0}};return k}();
h.SVG_NS="http://www.w3.org/2000/svg";f.SvgUtils=h;d=function(){function k(t,l,p){void 0===p&&(p=!1);var m=this;this.element=t;this.className=l;this.addTitleElement=p;this.createRuler=function(){var n=m.getTextElements(m.element),q=n.parentElement,u=n.containerElement,x=n.textElement;return function(A){q.appendChild(u);x.textContent=A;A=h.getDimensions(x);q.removeChild(u);return A}};this.createPen=function(n,q,u){null==u&&(u=m.element);u=h.append(u,"g","text-container",m.className);m.addTitleElement&&
(h.append(u,"title").textContent=n,u.setAttribute("title",n));n=h.append(u,"g","text-area");n.setAttribute("transform","translate("+q.translate[0]+","+q.translate[1]+")rotate("+(q.rotate+")"));return m.createSvgLinePen(n)}}k.prototype.setAddTitleElement=function(t){this.addTitleElement=t};k.prototype.createSvgLinePen=function(t){return{write:function(l,p,m,n){var q=h.append(t,"text","text-line");q.textContent=l;q.setAttribute("text-anchor",p);q.setAttribute("transform","translate("+m+","+n+")");q.setAttribute("y",
"-0.25em")}}};k.prototype.getTextElements=function(t){if("text"===t.tagName){var l=t.parentElement;null==l&&(l=t.parentNode);l.removeChild(t);return{containerElement:t,parentElement:l,textElement:t}}var p=t.querySelector("text");if(null!=p)return l=t.parentElement,null==l&&(l=t.parentNode),l.removeChild(t),{containerElement:t,parentElement:l,textElement:p};l=h.create("text",this.className);return{containerElement:l,parentElement:t,textElement:l}};return k}();f.SvgContext=d},function(d,f,h){var k=
this&&this.__extends||function(p,m){function n(){this.constructor=p}for(var q in m)m.hasOwnProperty(q)&&(p[q]=m[q]);p.prototype=null===m?Object.create(m):(n.prototype=m.prototype,new n)},t=h(21),l=h(36);d=function(p){function m(n){var q=p.call(this,n)||this;q.dimCache=new t.Cache(function(u){return q._measureNotFromCache(u)});return q}k(m,p);m.prototype._measureNotFromCache=function(n){return p.prototype.measure.call(this,n)};m.prototype.measure=function(n){void 0===n&&(n=l.AbstractMeasurer.HEIGHT_TEXT);
return this.dimCache.get(n)};m.prototype.reset=function(){this.dimCache.clear();p.prototype.reset.call(this)};return m}(h(60).CacheCharacterMeasurer);f.CacheMeasurer=d},function(d,f,h){var k=h(59),t=h(62),l=h(64),p=h(66);d=function(){function m(n){this.context=n;this.measurer=new t.CacheMeasurer(this.context);this.wrapper=new l.Wrapper;this.writer=new p.Writer(this.measurer,this.context,this.wrapper)}m.svg=function(n,q,u){return new m(new k.SvgContext(n,q,u))};m.canvas=function(n,q,u){return new m(new k.CanvasContext(n,
q,u))};m.prototype.write=function(n,q,u,x,A){this.writer.write(n,q,u,x,A)};m.prototype.clearMeasurerCache=function(){this.measurer.reset()};return m}();f.Typesetter=d},function(d,f){d=function(){function h(k){this.cache={};this.compute=k}h.prototype.get=function(k){this.cache.hasOwnProperty(k)||(this.cache[k]=this.compute(k));return this.cache[k]};h.prototype.clear=function(){this.cache={};return this};return h}();f.Cache=d},function(d,f){f.Methods=function(){function h(){}h.arrayEq=function(k,t){if(null==
k||null==t)return k===t;if(k.length!==t.length)return!1;for(var l=0;l<k.length;l++)if(k[l]!==t[l])return!1;return!0};h.objEq=function(k,t){if(null==k||null==t)return k===t;var l=Object.keys(k).sort(),p=Object.keys(t).sort(),m=l.map(function(q){return k[q]}),n=p.map(function(q){return t[q]});return h.arrayEq(l,p)&&h.arrayEq(m,n)};h.strictEq=function(k,t){return k===t};h.defaults=function(k){for(var t=[],l=1;l<arguments.length;l++)t[l-1]=arguments[l];if(null==k)throw new TypeError("Cannot convert undefined or null to object");
var p=Object(k);t.forEach(function(m){if(null!=m)for(var n in m)Object.prototype.hasOwnProperty.call(m,n)&&(p[n]=m[n])});return p};return h}()},function(d,f){f.StringMethods=function(){function h(){}h.combineWhitespace=function(k){return k.replace(/[ \t]+/g," ")};h.isNotEmptyString=function(k){return k&&""!==k.trim()};h.trimStart=function(k,t){if(!k)return k;k=k.split("");var l=t?function(p){return p.split(t).some(h.isNotEmptyString)}:h.isNotEmptyString;return k.reduce(function(p,m){return l(p+m)?
p+m:p},"")};h.trimEnd=function(k,t){if(!k)return k;k=k.split("");k.reverse();k=h.trimStart(k.join(""),t).split("");k.reverse();return k.join("")};return h}()},function(d,f){d=function(){function h(){this.WordDividerRegExp=/\W/;this.WhitespaceRegExp=/\s/}h.prototype.tokenize=function(k){var t=this;return k.split("").reduce(function(l,p){return l.slice(0,-1).concat(t.shouldCreateNewToken(l[l.length-1],p))},[""])};h.prototype.shouldCreateNewToken=function(k,t){if(!k)return[t];var l=k[k.length-1];return this.WhitespaceRegExp.test(l)&&
this.WhitespaceRegExp.test(t)?[k+t]:this.WhitespaceRegExp.test(l)||this.WhitespaceRegExp.test(t)?[k,t]:this.WordDividerRegExp.test(l)||this.WordDividerRegExp.test(t)?l===t?[k+t]:[k,t]:[k+t]};return h}();f.Tokenizer=d},function(d,f,h){var k=this&&this.__extends||function(t,l){function p(){this.constructor=t}for(var m in l)l.hasOwnProperty(m)&&(t[m]=l[m]);t.prototype=null===l?Object.create(l):(p.prototype=l.prototype,new p)};d=function(t){function l(){return t.apply(this,arguments)||this}k(l,t);l.prototype.wrap=
function(p,m,n,q){function u(D){return t.prototype.wrap.call(x,p,m,D,q)}var x=this;void 0===q&&(q=Infinity);if(1<p.split("\n").length)throw Error("SingleLineWrapper is designed to work only on single line");var A=u(n);if(2>A.noLines)return A;for(var y=0,w=0;w<l.NO_WRAP_ITERATIONS&&n>y;++w){var C=(n+y)/2,G=u(C);this.areSameResults(A,G)?(n=C,A=G):y=C}return A};l.prototype.areSameResults=function(p,m){return p.noLines===m.noLines&&p.truncatedText===m.truncatedText};return l}(h(65).Wrapper);d.NO_WRAP_ITERATIONS=
5;f.SingleLineWrapper=d},function(d,f,h){var k=h(21),t={textRotation:0,textShear:0,xAlign:"left",yAlign:"top"};d=function(){function l(p,m,n){this._measurer=p;this._penFactory=m;this._wrapper=n}l.prototype.measurer=function(p){this._measurer=p;return this};l.prototype.wrapper=function(p){this._wrapper=p;return this};l.prototype.penFactory=function(p){this._penFactory=p;return this};l.prototype.write=function(p,m,n,q,u){void 0===q&&(q={});q=k.Methods.defaults({},t,q);if(-1===l.SupportedRotation.indexOf(q.textRotation))throw Error("unsupported rotation - "+
q.textRotation+". Supported rotations are "+l.SupportedRotation.join(", "));if(null!=q.textShear&&-80>q.textShear||80<q.textShear)throw Error("unsupported shear angle - "+q.textShear+". Must be between -80 and 80");var x=45<Math.abs(Math.abs(q.textRotation)-90),A=x?m:n,y=x?n:m,w=q.textShear,C=w*Math.PI/180;x=this._measurer.measure().height;var G=x*Math.tan(C);A=A/Math.cos(C)-Math.abs(G);var D=y*Math.cos(C);y=k.StringMethods.combineWhitespace(p);y=(this._wrapper?this._wrapper.wrap(y,this._measurer,
A,D).wrappedText:y).split("\n");C=l.XOffsetFactor[q.xAlign]*A*Math.sin(C)-l.YOffsetFactor[q.yAlign]*(D-y.length*x);w=q.textRotation+w;switch(q.textRotation){case 90:m=[m+C,0];break;case -90:m=[-C,n];break;case 180:m=[m,n+C];break;default:m=[0,-C]}p=this._penFactory.createPen(p,{translate:m,rotate:w},u);this.writeLines(y,p,A,x,G,q.xAlign);null!=p.destroy&&p.destroy()};l.prototype.writeLines=function(p,m,n,q,u,x){p.forEach(function(A,y){m.write(A,l.AnchorConverter[x],(0<u?(y+1)*u:y*u)+n*l.XOffsetFactor[x],
(y+1)*q)})};return l}();d.SupportedRotation=[-90,0,180,90];d.AnchorConverter={center:"middle",left:"start",right:"end"};d.XOffsetFactor={center:.5,left:0,right:1};d.YOffsetFactor={bottom:1,center:.5,top:0};f.Writer=d},function(d,f,h){function k(t){for(var l in t)f.hasOwnProperty(l)||(f[l]=t[l])}h(69);d=h(7);f.Animators=d;d=h(67);f.Axes=d;d=h(37);f.Components=d;d=h(23);f.Configs=d;d=h(8);f.Formatters=d;d=h(30);f.RenderController=d;d=h(39);f.RenderPolicies=d;d=h(31);f.SymbolFactories=d;d=h(13);f.Dispatchers=
d;d=h(14);f.Drawers=d;d=h(25);f.Interactions=d;d=h(19);f.Plots=d;d=h(3);f.Scales=d;d=h(0);f.Utils=d;k(h(22));d=h(28);f.TimeInterval=d.TimeInterval;k(h(4));k(h(29));k(h(38));d=h(68);f.version=d.version;k(h(24));k(h(6));k(h(15));k(h(40));k(h(16));k(h(2));k(h(11));k(h(17))}])});

//# sourceURL=build://vz-chart-helpers/plottable-interactions.js
var rg;
(function(b){function d(m){const n=[];for(;m&&m instanceof HTMLElement;)if(n.push(m),m.assignedSlot)m=m.assignedSlot;else if(m.parentElement)m=m.parentElement;else{const q=m.parentNode;m=q instanceof DocumentFragment?q.host:q!==m?q:null}return n}function f(m){var n=d(m);m=h;let q=null;for(const x of n){n=Plottable.Utils.DOM.getElementTransform(x);if(null!=n){var u=x.clientWidth/2;const A=x.clientHeight/2;m=Plottable.Utils.Math.multiplyTranslate(m,[u,A]);m=Plottable.Utils.Math.multiplyMatrix(m,Plottable.Utils.Math.invertMatrix(n));
m=Plottable.Utils.Math.multiplyTranslate(m,[-u,-A])}n=x.scrollLeft;u=x.scrollTop;if(null===q||x===q)n-=x.offsetLeft+x.clientLeft,u-=x.offsetTop+x.clientTop,q=x.offsetParent;m=Plottable.Utils.Math.multiplyTranslate(m,[n,u])}return m}const h=[1,0,0,1,0,0];class k extends Plottable.Utils.Translator{computePosition(m,n){m={x:m,y:n};n=f(this._rootElement);return null==n?m:Plottable.Utils.Math.applyTransform(n,m)}}class t extends Plottable.Dispatchers.Mouse{constructor(m){super(m);this._eventTarget=m.root().rootElement().node();
this._translator=new k(m.root().rootElement().node())}static getDispatcher(m){const n=m.root().rootElement();let q=n[t._DISPATCHER_KEY];q||(q=new t(m),n[t._DISPATCHER_KEY]=q);return q}}class l extends Plottable.Dispatchers.Touch{constructor(m){super(m);this._eventTarget=m.root().rootElement().node();this._translator=new k(m.root().rootElement().node())}static getDispatcher(m){const n=m.root().rootElement();let q=n[l._DISPATCHER_KEY];q||(q=new l(m),n[l._DISPATCHER_KEY]=q);return q}}Plottable.Interaction.prototype._isInsideComponent=
function(m){return 0<=m.x&&0<=m.y&&m.x<this._componentAttachedTo.width()&&m.y<this._componentAttachedTo.height()};class p extends Plottable.Interactions.Pointer{_anchor(){this._isAnchored=!0;this._mouseDispatcher=t.getDispatcher(this._componentAttachedTo);this._mouseDispatcher.onMouseMove(this._mouseMoveCallback);this._touchDispatcher=l.getDispatcher(this._componentAttachedTo);this._touchDispatcher.onTouchStart(this._touchStartCallback)}}b.PointerInteraction=p})(rg||(rg={}));

//# sourceURL=build://vz-chart-helpers/vz-chart-helpers.js
(function(b){function d(){let t=new Plottable.Scales.Linear;t.tickGenerator();let l=new Plottable.Axes.Numeric(t,"bottom");l.formatter(b.stepFormatter);return{scale:t,axis:l,accessor:p=>p.step}}function f(){let t=new Plottable.Scales.Time;return{scale:t,axis:new Plottable.Axes.Time(t,"bottom"),accessor:l=>l.wall_time}}function h(){let t=new Plottable.Scales.Linear;return{scale:t,axis:new Plottable.Axes.Numeric(t,"bottom"),accessor:b.relativeAccessor}}b.SYMBOLS_LIST=[{character:"\u25fc",method:Plottable.SymbolFactories.square},
{character:"\u25c6",method:Plottable.SymbolFactories.diamond},{character:"\u25b2",method:Plottable.SymbolFactories.triangle},{character:"\u2605",method:Plottable.SymbolFactories.star},{character:"\u271a",method:Plottable.SymbolFactories.cross}];let k;(function(t){t.STEP="step";t.RELATIVE="relative";t.WALL_TIME="wall_time"})(k=b.XType||(b.XType={}));b.Y_TOOLTIP_FORMATTER_PRECISION=4;b.STEP_FORMATTER_PRECISION=4;b.Y_AXIS_FORMATTER_PRECISION=3;b.TOOLTIP_Y_PIXEL_OFFSET=20;b.TOOLTIP_CIRCLE_SIZE=4;b.NAN_SYMBOL_SIZE=
6;b.multiscaleFormatter=function(t){return l=>{let p=Math.abs(l);1E-15>p&&(p=0);return(1E4<=p?d3.format("."+t+"~e"):0<p&&.01>p?d3.format("."+t+"~e"):d3.format("."+t+"~g"))(l)}};b.computeDomain=function(t,l){t=t.filter(n=>isFinite(n));if(0===t.length)return[-.1,1.1];l?(t=_.sortBy(t),l=d3.quantile(t,.05),t=d3.quantile(t,.95)):(l=d3.min(t),t=d3.max(t));let p,m=t-l;p=0===m?1.1*Math.abs(l)+1.1:.2*m;l=[0<=l&&l<m?-.1*t:l-p,t+p];return l=d3.scaleLinear().domain(l).nice().domain()};b.accessorize=function(t){return l=>
l[t]};b.stepFormatter=d3.format(`.${b.STEP_FORMATTER_PRECISION}~s`);b.stepX=d;b.timeFormatter=Plottable.Formatters.time("%a %b %e, %H:%M:%S");b.wallX=f;b.relativeAccessor=(t,l,p)=>{if(null!=t.relative)return t.relative;l=p.data();return(+t.wall_time-(0<l.length?+l[0].wall_time:0))/36E5};b.relativeFormatter=t=>{let l="",p=Math.floor(t/24);t-=24*p;p&&(l+=p+"d ");let m=Math.floor(t);t=60*(t-m);if(m||p)l+=m+"h ";let n=Math.floor(t);t=60*(t-n);if(n||m||p)l+=n+"m ";return l+Math.floor(t)+"s"};b.relativeX=
h;b.getXComponents=function(t){switch(t){case k.STEP:return d();case k.WALL_TIME:return f();case k.RELATIVE:return h();default:throw Error("invalid xType: "+t);}}})(rg||(rg={}));

//# sourceURL=build://vz-chart-helpers/vz-chart-tooltip.js
var Eh;
(function(b){let d;(function(h){h.AUTO="auto";h.BOTTOM="bottom";h.RIGHT="right"})(d=b.TooltipPosition||(b.TooltipPosition={}));const f={boxShadow:"0 1px 4px rgba(0, 0, 0, .3)",opacity:0,position:"fixed",willChange:"transform",zIndex:5};Polymer({is:"vz-chart-tooltip",_template:null,properties:{contentComponentName:String,position:{type:String,value:d.AUTO},minDistFromEdge:{type:Number,value:15}},ready(){this._tunnel=this._raf=this._styleCache=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(){window.cancelAnimationFrame(this._raf);this._styleCache=null;this._tunnel.style.opacity=0},updateAndPosition(h){window.cancelAnimationFrame(this._raf);this._raf=window.requestAnimationFrame(()=>{this.isAttached&&this._repositionImpl(h)})},
_repositionImpl(h){const k=this._tunnel;h=h.getBoundingClientRect();const t=k.getBoundingClientRect(),l=window.innerHeight,p=document.body.clientWidth,m=h.top,n=m+h.height,q=t.height+rg.TOOLTIP_Y_PIXEL_OFFSET;let u=null,x=Math.max(this.minDistFromEdge,h.left),A=null,y=m;this.position==d.RIGHT?x=h.right:(y=n+rg.TOOLTIP_Y_PIXEL_OFFSET,p<x+t.width+this.minDistFromEdge&&(x=null,A=this.minDistFromEdge));this.position==d.AUTO&&0<h.top-q&&l<h.top+h.height+q&&(y=null,u=l-m+rg.TOOLTIP_Y_PIXEL_OFFSET);h={opacity:1,
left:x?`${x}px`:null,right:A?`${A}px`:null,top:y?`${y}px`:null,bottom:u?`${u}px`:null};_.isEqual(this._styleCache,h)||(Object.assign(k.style,h),this._styleCache=h)},_createTunnel(){if(!this.contentComponentName)throw new RangeError("Require `contentComponentName` to be a name of a Polymer component");const h=document.createElement(this.contentComponentName);Object.assign(h.style,f);document.body.appendChild(h);return h},_removeTunnel(h){document.body.removeChild(h)}})})(Eh||(Eh={}));

//# sourceURL=build://vz-line-chart/dragZoomInteraction.js
var Fh;
(function(b){class d extends Plottable.Components.SelectionBoxLayer{constructor(f,h,k){super();this.easeFn=d3.easeCubicInOut;this._animationTime=750;this.xScale(f);this.yScale(h);this._dragInteraction=new Plottable.Interactions.Drag;this._doubleClickInteraction=new Plottable.Interactions.Click;this.setupCallbacks();this.unzoomMethod=k;this.onDetach(()=>{this._doubleClickInteraction.detachFrom();this._dragInteraction.detachFrom()});this.onAnchor(()=>{this._doubleClickInteraction.attachTo(this);this._dragInteraction.attachTo(this)})}interactionStart(f){this.onStart=
f}interactionEnd(f){this.onEnd=f}dragInteraction(){return this._dragInteraction}setupCallbacks(){let f=!1;this._dragInteraction.onDragStart(h=>{this.bounds({topLeft:h,bottomRight:h});this.onStart()});this._dragInteraction.onDrag((h,k)=>{this.bounds({topLeft:h,bottomRight:k});this.boxVisible(!0);f=!0});this._dragInteraction.onDragEnd((h,k)=>{this.boxVisible(!1);this.bounds({topLeft:h,bottomRight:k});if(f)this.zoom();else this.onEnd();f=!1});this._doubleClickInteraction.onDoubleClick(this.unzoom.bind(this))}animationTime(f){if(null==
f)return this._animationTime;if(0>f)throw Error("animationTime cannot be negative");this._animationTime=f;return this}ease(f){if("function"!==typeof f)throw Error("ease function must be a function");0===f(0)&&1===f(1)||Plottable.Utils.Window.warn("Easing function does not maintain invariant f(0)\x3d\x3d0 \x26\x26 f(1)\x3d\x3d1. Bad behavior may result.");this.easeFn=f;return this}zoom(){let f=this.xExtent()[0].valueOf(),h=this.xExtent()[1].valueOf(),k=this.yExtent()[1].valueOf(),t=this.yExtent()[0].valueOf();
f!==h&&k!==t&&this.interpolateZoom(f,h,k,t)}unzoom(){var f=this.xScale();f._domainMin=null;f._domainMax=null;f=f._getExtent();this.xScale().domain(f);this.unzoomMethod()}isZooming(f){this._dragInteraction.enabled(!f);this._doubleClickInteraction.enabled(!f)}interpolateZoom(f,h,k,t){let l=this.xScale().domain()[0].valueOf(),p=this.xScale().domain()[1].valueOf(),m=this.yScale().domain()[0].valueOf(),n=this.yScale().domain()[1].valueOf(),q=this.easeFn,u=(y,w,C)=>d3.interpolateNumber(y,w)(q(C));this.isZooming(!0);
let x=Date.now(),A=()=>{var y=Date.now()-x;y=0===this._animationTime?1:Math.min(1,y/this._animationTime);let w=u(l,f,y),C=u(p,h,y),G=u(m,k,y),D=u(n,t,y);this.xScale().domain([w,C]);this.yScale().domain([G,D]);1>y?Plottable.Utils.DOM.requestAnimationFramePolyfill(A):(this.onEnd(),this.isZooming(!1))};A()}}b.DragZoomLayer=d})(Fh||(Fh={}));

//# sourceURL=build://vz-line-chart2/panZoomDragLayer.js
var Gh;
(function(b){let d;(function(h){h[h.NONE=0]="NONE";h[h.DRAG_ZOOMING=1]="DRAG_ZOOMING";h[h.PANNING=2]="PANNING"})(d||(d={}));class f extends Plottable.Components.Group{constructor(h,k,t){super();this.state=d.NONE;this.panStartCallback=new Plottable.Utils.CallbackSet;this.panEndCallback=new Plottable.Utils.CallbackSet;this.panZoom=new Plottable.Interactions.PanZoom(h,k);this.panZoom.dragInteraction().mouseFilter(p=>f.isPanKey(p)&&0===p.button);this.panZoom.wheelFilter(this.canScrollZoom);this.dragZoomLayer=new Fh.DragZoomLayer(h,
k,t);this.dragZoomLayer.dragInteraction().mouseFilter(p=>!f.isPanKey(p)&&0===p.button);this.append(this.dragZoomLayer);const l=this.onWheel.bind(this);this.onAnchor(()=>{this._mouseDispatcher=Plottable.Dispatchers.Mouse.getDispatcher(this);this._mouseDispatcher.onWheel(l);this.panZoom.attachTo(this)});this.onDetach(()=>{this.panZoom.detachFrom();this._mouseDispatcher&&(this._mouseDispatcher.offWheel(l),this._mouseDispatcher=null)});this.panZoom.dragInteraction().onDragStart(()=>{this.state==d.NONE&&
this.setState(d.PANNING)});this.panZoom.dragInteraction().onDragEnd(()=>{this.state==d.PANNING&&this.setState(d.NONE)});this.dragZoomLayer.dragInteraction().onDragStart(()=>{this.state==d.NONE&&this.setState(d.DRAG_ZOOMING)});this.dragZoomLayer.dragInteraction().onDragEnd(()=>{this.state==d.DRAG_ZOOMING&&this.setState(d.NONE)})}onWheel(h,k){if(!this.canScrollZoom(k)&&(h=this.element(),h.select(".help").empty())){var t=h.append("div").classed("help",!0);t.append("span").text("Alt + Scroll to Zoom");
t.on("animationend",()=>void t.remove())}}static isPanKey(h){return!!h.altKey||!!h.shiftKey}canScrollZoom(h){return h.altKey}setState(h){if(this.state!=h){var k=this.state;this.state=h;this.root().removeClass(this.stateClassName(k));this.root().addClass(this.stateClassName(h));k==d.PANNING&&this.panEndCallback.callCallbacks();h==d.PANNING&&this.panStartCallback.callCallbacks()}}stateClassName(h){switch(h){case d.PANNING:return"panning";case d.DRAG_ZOOMING:return"drag-zooming";default:return""}}onPanStart(h){this.panStartCallback.add(h)}onPanEnd(h){this.panEndCallback.add(h)}onScrollZoom(h){this.panZoom.onZoomEnd(h)}onDragZoomStart(h){this.dragZoomLayer.interactionStart(h)}onDragZoomEnd(h){this.dragZoomLayer.interactionEnd(h)}}
b.PanZoomDragLayer=f})(Gh||(Gh={}));

//# sourceURL=build://vz-line-chart2/tf-scale.js
(function(b){class d extends Plottable.QuantitativeScale{constructor(){super(...arguments);this._ignoreOutlier=!1}setValueProviderForDomain(f){this._valueProviderForDomain=f}ignoreOutlier(f){return"boolean"==typeof f?(this._ignoreOutlier=f,this):this._ignoreOutlier}_getAllIncludedValues(){const f=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(f)}}b.TfScale=d})(Gh||(Gh={}));

//# sourceURL=build://vz-line-chart2/linear-scale.js
(function(b){class d extends Plottable.Scales.Linear{constructor(){super();this._ignoreOutlier=!1;this.padProportion(.2)}setValueProviderForDomain(f){this._valueProviderForDomain=f}_niceDomain(f,h){const [k,t]=f,l=t-k;f=0===l?1.1*Math.abs(k)+1.1:l*this.padProportion();return super._niceDomain([0<=k&&k<l?-.1*t:k-f,t+f],h)}_getUnboundedExtent(f){f=this._getAllIncludedValues(f);let h=this._defaultExtent();0!==f.length&&(f=[Plottable.Utils.Math.min(f,h[0]),Plottable.Utils.Math.max(f,h[1])],h=this._niceDomain(f));
return h}_getAllIncludedValues(){const f=this._valueProviderForDomain?this._valueProviderForDomain():[];return this.extentOfValues(f)}extentOfValues(f){var h=f=f.filter(k=>Plottable.Utils.Math.isValidNumber(k));if(this.ignoreOutlier()){h=f.sort((l,p)=>l-p);const k=d3.quantile(h,.05),t=d3.quantile(h,.95);h=f.filter(l=>l>=k&&l<=t)}f=d3.extent(h);return null==f[0]||null==f[1]?[]:f}ignoreOutlier(f){return"boolean"==typeof f?(this._ignoreOutlier=f,this):this._ignoreOutlier}}b.LinearScale=d})(Gh||(Gh={}));

//# sourceURL=build://vz-line-chart2/log-scale.js
(function(b){function d(k){return Math.log10(k)}function f(k){return Math.pow(10,k)}b.MIN_POSITIVE_VALUE=Math.pow(2,-1074);class h extends b.TfScale{constructor(){super();this._d3LogScale=d3.scaleLog();this.padProportion(.2)}scale(k){return 0>=k?NaN:this._d3LogScale(k)}invert(k){return this._d3LogScale.invert(k)}scaleTransformation(k){return this.scale(k)}invertedTransformation(k){return this.invert(k)}getTransformationDomain(){return this.domain()}_getDomain(){return this._untransformedDomain}_setDomain(k){this._untransformedDomain=
k;const [t,l]=k;super._setDomain([Math.max(b.MIN_POSITIVE_VALUE,t),l])}_niceDomain(k){const [t,l]=k;k=Math.max(d(b.MIN_POSITIVE_VALUE),d(t));const p=d(l);var m=p-k;m=m?m*this.padProportion():1;return[f(Math.max(d(b.MIN_POSITIVE_VALUE),k-m)),f(p+m)]}_getUnboundedExtent(k){k=this._getAllIncludedValues(k);let t=this._defaultExtent();0!==k.length&&(k=[Plottable.Utils.Math.min(k,t[0]),Plottable.Utils.Math.max(k,t[1])],t=this._niceDomain(k));return t}_getAllIncludedValues(){return super._getAllIncludedValues().map(k=>
0<k?k:b.MIN_POSITIVE_VALUE)}_defaultExtent(){return[1,10]}_backingScaleDomain(k){if(null==k)return this._d3LogScale.domain();this._d3LogScale.domain(k);return this}_getRange(){return this._d3LogScale.range()}_setRange(k){this._d3LogScale.range(k)}defaultTicks(){return this._d3LogScale.ticks()}ticks(){return this._d3LogScale.ticks()}extentOfValues(k){let t=k=k.filter(l=>Plottable.Utils.Math.isValidNumber(l)&&0<l);if(this.ignoreOutlier()){k=k.map(d).sort((m,n)=>m-n);const l=d3.quantile(k,.05),p=d3.quantile(k,
.95);t=k.filter(m=>m>=l&&m<=p).map(f)}k=d3.extent(t);return null==k[0]||null==k[1]?[]:k}}b.LogScale=h})(Gh||(Gh={}));

//# sourceURL=build://vz-line-chart2/line-chart.js
(function(b){let d;(function(k){k[k.TEXT=0]="TEXT";k[k.DOM=1]="DOM"})(d||(d={}));let f;(function(k){k.LOG="log";k.LINEAR="linear"})(f||(f={}));class h{constructor(k,t,l,p,m,n,q,u,x,A,y){this.seriesNames=[];this.name2datasets={};this.colorScale=p;this.tooltip=m;this.datasets=[];this._ignoreYOutliers=!1;this.lastPointsDataset=new Plottable.Dataset;this.nanDataset=new Plottable.Dataset;this.yValueAccessor=t;this.symbolFunction=A;this.onDatasetChanged=this._onDatasetChanged.bind(this);this._defaultXRange=
u;this._defaultYRange=x;this.tooltipColumns=n;this.buildChart(k,l,q,y)}buildChart(k,t,l,p){this.destroy();k=k();this.xAccessor=k.accessor;this.xScale=k.scale;this.xAxis=k.axis;this.xAxis.margin(0).tickLabelPadding(3);p&&this.xAxis.formatter(p);this.yScale=h.getYScaleFromType(t);this.yScale.setValueProviderForDomain(()=>this.getValuesForYAxisDomainCompute());this.yAxis=new Plottable.Axes.Numeric(this.yScale,"left");p=rg.multiscaleFormatter(rg.Y_AXIS_FORMATTER_PRECISION);this.yAxis.margin(0).tickLabelPadding(5).formatter(p);
this.yAxis.usesTextWidthApproximation();this.fillArea=l;p=new b.PanZoomDragLayer(this.xScale,this.yScale,()=>this.resetDomain());this.tooltipInteraction=this.createTooltipInteraction(p);this.tooltipPointsComponent=new Plottable.Component;l=this.buildPlot(this.xScale,this.yScale,l);this.gridlines=new Plottable.Components.Gridlines(this.xScale,this.yScale);k=null;t!==f.LOG&&(k=new Plottable.Components.GuideLineLayer("horizontal"),k.scale(this.yScale).value(0));t=new Plottable.Components.GuideLineLayer("vertical");
t.scale(this.xScale).value(0);this.center=new Plottable.Components.Group([this.gridlines,k,t,l,this.tooltipPointsComponent,p]);this.center.addClass("main");this.outer=new Plottable.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(k,t,l){l&&(this.marginAreaPlot=new Plottable.Plots.Area,this.marginAreaPlot.x(this.xAccessor,k),this.marginAreaPlot.y(l.higherAccessor,t),this.marginAreaPlot.y0(l.lowerAccessor),this.marginAreaPlot.attr("fill",(q,u,x)=>this.colorScale.scale(x.metadata().name)),
this.marginAreaPlot.attr("fill-opacity",.3),this.marginAreaPlot.attr("stroke-width",0));this.smoothedAccessor=q=>q.smoothed;l=new Plottable.Plots.Line;l.x(this.xAccessor,k);l.y(this.yValueAccessor,t);l.attr("stroke",(q,u,x)=>this.colorScale.scale(x.metadata().name));this.linePlot=l;this.setupTooltips(l);let p=new Plottable.Plots.Line;p.x(this.xAccessor,k);p.y(this.smoothedAccessor,t);p.attr("stroke",(q,u,x)=>this.colorScale.scale(x.metadata().name));this.smoothLinePlot=p;if(this.symbolFunction){var m=
new Plottable.Plots.Scatter;m.x(this.xAccessor,k);m.y(this.yValueAccessor,t);m.attr("fill",(q,u,x)=>this.colorScale.scale(x.metadata().name));m.attr("opacity",1);m.size(2*rg.TOOLTIP_CIRCLE_SIZE);m.symbol((q,u,x)=>this.symbolFunction(x.metadata().name));this.markersScatterPlot=m}m=new Plottable.Plots.Scatter;m.x(this.xAccessor,k);m.y(this.yValueAccessor,t);m.attr("fill",q=>this.colorScale.scale(q.name));m.attr("opacity",1);m.size(2*rg.TOOLTIP_CIRCLE_SIZE);m.datasets([this.lastPointsDataset]);this.scatterPlot=
m;let n=new Plottable.Plots.Scatter;n.x(this.xAccessor,k);n.y(q=>q.displayY,t);n.attr("fill",q=>this.colorScale.scale(q.name));n.attr("opacity",1);n.size(2*rg.NAN_SYMBOL_SIZE);n.datasets([this.nanDataset]);n.symbol(Plottable.SymbolFactories.triangle);this.nanDisplay=n;k=[n,m,p,l];this.marginAreaPlot&&k.push(this.marginAreaPlot);this.markersScatterPlot&&k.push(this.markersScatterPlot);return new Plottable.Components.Group(k)}_onDatasetChanged(k){this.smoothingEnabled&&this.resmoothDataset(k);this.updateSpecialDatasets()}ignoreYOutliers(k){k!==
this._ignoreYOutliers&&(this._ignoreYOutliers=k,this.updateSpecialDatasets(),this.yScale.ignoreOutlier(k),this.resetYDomain())}getValuesForYAxisDomainCompute(){const k=this.getAccessorsForComputingYRange();return _.flattenDeep(this.datasets.map(t=>k.map(l=>t.data().map(p=>l(p,-1,t))))).filter(isFinite)}updateSpecialDatasets(){const k=this.getYAxisAccessor();var t=this.datasets.map(l=>{let p=null,m=l.data().filter(n=>!isNaN(k(n,-1,l)));0<m.length&&(p=m[m.length-1],p.name=l.metadata().name,p.relative=
rg.relativeAccessor(p,-1,l));return p}).filter(l=>null!=l);this.lastPointsDataset.data(t);this.markersScatterPlot&&this.markersScatterPlot.datasets(this.datasets.map(this.createSampledDatasetForMarkers));t=_.flatten(this.datasets.map(l=>{let p=null,m=l.data(),n=0;for(;n<m.length&&null==p;)isNaN(k(m[n],-1,l))||(p=k(m[n],-1,l)),n++;null==p&&(p=0);let q=[];for(n=0;n<m.length;n++)isNaN(k(m[n],-1,l))?(m[n].name=l.metadata().name,m[n].displayY=p,m[n].relative=rg.relativeAccessor(m[n],-1,l),q.push(m[n])):
p=k(m[n],-1,l);return q}));this.nanDataset.data(t)}resetDomain(){this.resetXDomain();this.resetYDomain()}resetXDomain(){if(null!=this._defaultXRange)var k=this._defaultXRange;else k=this.xScale,k._domainMin=null,k._domainMax=null,k=k._getExtent();this.xScale.domain(k)}resetYDomain(){null!=this._defaultYRange?this.yScale.domain(this._defaultYRange):(this.yScale.autoDomain(),this.yScale.domain(this.yScale.domain()))}getAccessorsForComputingYRange(){const k=[this.getYAxisAccessor()];this.fillArea&&k.push(this.fillArea.lowerAccessor,
this.fillArea.higherAccessor);return k}getYAxisAccessor(){return this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor}createTooltipInteraction(k){const t=new rg.PointerInteraction,l=()=>{t.enabled(!1);this.hideTooltips()},p=()=>t.enabled(!0);k.onPanStart(l);k.onDragZoomStart(l);k.onPanEnd(p);k.onDragZoomEnd(p);k.onScrollZoom(()=>this.updateTooltipContent(this._lastMousePosition));t.onPointerMove(m=>{this._lastMousePosition=m;this.updateTooltipContent(m)});t.onPointerExit(()=>this.hideTooltips());
return t}updateTooltipContent(k){this.linePlot&&(window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame),this._tooltipUpdateAnimationFrame=window.requestAnimationFrame(()=>{let t={x:k.x,y:k.y,datum:null,dataset:null},l=this.gridlines.content().node().getBBox();var p=this.linePlot.datasets().map(u=>this.findClosestPoint(t,u)).filter(Boolean);let m=Plottable.Utils.DOM.intersectsBBox,n=p.filter(u=>m(u.x,u.y,l)||isNaN(this.yValueAccessor(u.datum,0,u.dataset))),q=n.filter(u=>!isNaN(this.yValueAccessor(u.datum,
0,u.dataset)));0!==p.length?(this.scatterPlot.attr("display","none"),p=this.tooltipPointsComponent.content().selectAll(".point").data(q,u=>u.dataset.metadata().name),p.enter().append("circle").classed("point",!0),p.attr("r",rg.TOOLTIP_CIRCLE_SIZE).attr("cx",u=>u.x).attr("cy",u=>u.y).style("stroke","none").attr("fill",u=>this.colorScale.scale(u.dataset.metadata().name)),p.exit().remove(),this.drawTooltips(n,t,this.tooltipColumns)):this.hideTooltips()}))}hideTooltips(){window.cancelAnimationFrame(this._tooltipUpdateAnimationFrame);
this.tooltip.hide();this.scatterPlot.attr("display","block");this.tooltipPointsComponent.content().selectAll(".point").remove()}setupTooltips(k){k.onDetach(()=>{this.tooltipInteraction.detachFrom();this.tooltipInteraction.enabled(!1)});k.onAnchor(()=>{this.tooltipInteraction.attachTo(k);this.tooltipInteraction.enabled(!0)})}drawTooltips(k,t,l){if(k.length){var p=this.colorScale;l=[{title:"",static:!1,evalType:d.DOM,evaluate(y){d3.select(this).select("span").style("background-color",()=>p.scale(y.dataset.metadata().name));
return""},enter(y){d3.select(this).append("span").classed("swatch",!0).style("background-color",()=>p.scale(y.dataset.metadata().name))}},...l];var m=y=>Math.pow(y.x-t.x,2)+Math.pow(y.y-t.y,2),n=_.min(k.map(m)),q=this.smoothingEnabled?this.smoothedAccessor:this.yValueAccessor;k="ascending"===this.tooltipSortingMethod?_.sortBy(k,y=>q(y.datum,-1,y.dataset)):"descending"===this.tooltipSortingMethod?_.sortBy(k,y=>q(y.datum,-1,y.dataset)).reverse():"nearest"===this.tooltipSortingMethod?_.sortBy(k,m):k.slice(0).reverse();
var u=this,x=d3.select(this.tooltip.content()).select("table"),A=x.select("thead").selectAll("th").data(l,y=>y.title);A.enter().append("th").text(y=>y.title).nodes();A.exit().remove();k=x.select("tbody").selectAll("tr").data(k,y=>y.dataset.metadata().name);k.classed("distant",y=>{var w=y.dataset.data()[0],C=_.last(y.dataset.data());w=this.xScale.scale(this.xAccessor(w,0,y.dataset));C=this.xScale.scale(this.xAccessor(C,0,y.dataset));y=this.smoothingEnabled?y.datum.smoothed:this.yValueAccessor(y.datum,
0,y.dataset);return t.x<w||t.x>C||isNaN(y)}).classed("closest",y=>m(y)===n).each(function(y){u.drawTooltipRow(this,l,y)}).order();k.exit().remove();k.enter().append("tr").each(function(y){u.drawTooltipRow(this,l,y)}).nodes();this.tooltip.updateAndPosition(this.targetSVG.node())}else this.tooltip.hide()}drawTooltipRow(k,t,l){const p=this;k=d3.select(k).selectAll("td").data(t);k.each(function(m){m.static||p.drawTooltipColumn.call(p,this,m,l)});k.enter().append("td").each(function(m){m.enter&&m.enter.call(this,
l);p.drawTooltipColumn.call(p,this,m,l)})}drawTooltipColumn(k,t,l){const p=this.smoothingEnabled;t.evalType==d.DOM?t.evaluate.call(k,l,{smoothingEnabled:p}):d3.select(k).text(t.evaluate.call(k,l,{smoothingEnabled:p}))}findClosestPoint(k,t){const l=t.data().map((n,q)=>this.xScale.scale(this.xAccessor(n,q,t)));let p=_.sortedIndex(l,k.x);if(0==l.length)return null;p===l.length?--p:0!==p&&(p=Math.abs(l[p-1]-k.x)<Math.abs(l[p]-k.x)?p-1:p);k=t.data()[p];const m=this.smoothingEnabled?this.smoothedAccessor(k,
p,t):this.yValueAccessor(k,p,t);return{x:l[p],y:this.yScale.scale(m),datum:k,dataset:t}}resmoothDataset(k){let t=k.data();const l=this.smoothingWeight;let p=0<t.length?0:NaN,m=0;const n=t.map((u,x)=>this.yValueAccessor(u,x,k)),q=n.every(u=>u==n[0]);t.forEach((u,x)=>{x=n[x];q||!Number.isFinite(x)?u.smoothed=x:(p=p*l+(1-l)*x,m++,x=1,1!==l&&(x=1-Math.pow(l,m)),u.smoothed=p/x)})}getDataset(k){void 0===this.name2datasets[k]&&(this.name2datasets[k]=new Plottable.Dataset([],{name:k,meta:null}));return this.name2datasets[k]}static getYScaleFromType(k){if(k===
f.LOG)return new b.LogScale;if(k===f.LINEAR)return new b.LinearScale;throw Error("Unrecognized yScale type "+k);}setVisibleSeries(k){this.seriesNames=k=k.sort();k.reverse();this.datasets.forEach(t=>t.offUpdate(this.onDatasetChanged));this.datasets=k.map(t=>this.getDataset(t));this.datasets.forEach(t=>t.onUpdate(this.onDatasetChanged));this.linePlot.datasets(this.datasets);this.smoothingEnabled&&this.smoothLinePlot.datasets(this.datasets);this.marginAreaPlot&&this.marginAreaPlot.datasets(this.datasets);
this.updateSpecialDatasets()}createSampledDatasetForMarkers(k){const t=k.data();if(20>=t.length)return k;const l=Math.ceil(t.length/20),p=Array(Math.floor(t.length/l));for(let m=0,n=0;m<p.length;m++,n+=l)p[m]=t[n];return new Plottable.Dataset(p,k.metadata())}setSeriesData(k,t){this.getDataset(k).data(t);this.measureBBoxAndMaybeInvalidateLayoutInRaf()}setSeriesMetadata(k,t){t=Object.assign({},this.getDataset(k).metadata(),{meta:t});this.getDataset(k).metadata(t)}smoothingUpdate(k){this.smoothingWeight=
k;this.datasets.forEach(t=>this.resmoothDataset(t));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)}setTooltipSortingMethod(k){this.tooltipSortingMethod=k}renderTo(k){this.targetSVG=k;this.outer.renderTo(k);null!=this._defaultXRange&&this.resetXDomain();null!=this._defaultYRange&&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){const k=this._lastDrawBBox.width,{width:t}=this.targetSVG.node().getBoundingClientRect();0==k&&k<t&&this.outer.invalidateCache()}this._lastDrawBBox=this.targetSVG.node().getBoundingClientRect()}destroy(){window.cancelAnimationFrame(this._redrawRaf);
window.cancelAnimationFrame(this._invalidateLayoutRaf);this.outer&&this.outer.destroy()}onAnchor(k){if(this.outer)this.outer.onAnchor(k)}}b.LineChart=h})(Gh||(Gh={}));

//# sourceURL=build://vz-line-chart2/vz-line-chart2.js
(function(b){const d=rg.multiscaleFormatter(rg.Y_TOOLTIP_FORMATTER_PRECISION),f=h=>isNaN(h)?"NaN":d(h);b.DEFAULT_TOOLTIP_COLUMNS=[{title:"Name",evaluate:h=>h.dataset.metadata().name},{title:"Smoothed",evaluate(h,k){return f(k.smoothingEnabled?h.datum.smoothed:h.datum.scalar)}},{title:"Value",evaluate:h=>f(h.datum.scalar)},{title:"Step",evaluate:h=>rg.stepFormatter(h.datum.step)},{title:"Time",evaluate:h=>rg.timeFormatter(h.datum.wall_time)},{title:"Relative",evaluate:h=>rg.relativeFormatter(rg.relativeAccessor(h.datum,
-1,h.dataset))}];Polymer({is:"vz-line-chart2",properties:{colorScale:{type:Object,value:function(){return(new Plottable.Scales.Color).range(d3.schemeCategory10)}},symbolFunction:Object,smoothingEnabled:{type:Boolean,notify:!0,value:!1},smoothingWeight:{type:Number,value:.6},xType:{type:String,value:""},xComponentsCreationMethod:{type:Object,value:""},xAxisFormatter:Object,yValueAccessor:{type:Object,value:()=>h=>h.scalar},tooltipColumns:{type:Array,value:()=>b.DEFAULT_TOOLTIP_COLUMNS},fillArea:Object,
defaultXRange:Array,defaultYRange:Array,yScaleType:{type:String,value:"linear"},ignoreYOutliers:{type:Boolean,value:!1},tooltipSortingMethod:{type:String,value:"default"},tooltipPosition:{type:String,value:Eh.TooltipPosition.BOTTOM},_chart:Object,_visibleSeriesCache:{type:Array,value:()=>[]},_seriesDataCache:{type:Object,value:()=>({})},_seriesMetadataCache:{type:Object,value:()=>({})},_makeChartAsyncCallbackId:{type:Number,value:null}},observers:["_makeChart(xComponentsCreationMethod, xType, yValueAccessor, yScaleType, tooltipColumns, colorScale, isAttached)",
"_reloadFromCache(_chart, _visibleSeriesCache)","_smoothingChanged(smoothingEnabled, smoothingWeight, _chart)","_tooltipSortingMethodChanged(tooltipSortingMethod, _chart)","_outliersChanged(ignoreYOutliers, _chart)"],ready(){this.scopeSubtree(this.$.chartdiv,!0)},attached(){const h={capture:!0,passive:!0};this._listen(this,"mousedown",this._onMouseDown.bind(this),h);this._listen(this,"mouseup",this._onMouseUp.bind(this),h);this._listen(window,"keydown",this._onKeyDown.bind(this),h);this._listen(window,
"keyup",this._onKeyUp.bind(this),h)},detached(){this.cancelAsync(this._makeChartAsyncCallbackId);this._chart&&this._chart.destroy();this._listeners&&(this._listeners.forEach(({node:h,eventName:k,func:t,option:l})=>{h.removeEventListener(k,t,l)}),this._listeners.clear())},_listen(h,k,t,l={}){this._listeners||(this._listeners=new Set);this._listeners.add({node:h,eventName:k,func:t,option:l});h.addEventListener(k,t,l)},_onKeyDown(h){this.toggleClass("pankey",b.PanZoomDragLayer.isPanKey(h))},_onKeyUp(h){this.toggleClass("pankey",
b.PanZoomDragLayer.isPanKey(h))},_onMouseDown(){this.toggleClass("mousedown",!0)},_onMouseUp(){this.toggleClass("mousedown",!1)},setVisibleSeries:function(h){_.isEqual(this._visibleSeriesCache,h)||(this._visibleSeriesCache=h)},setSeriesData:function(h,k){this._seriesDataCache[h]=k;this._chart&&this._chart.setSeriesData(h,k)},setSeriesMetadata(h,k){this._seriesMetadataCache[h]=k;this._chart&&this._chart.setSeriesMetadata(h,k)},resetDomain:function(){this._chart&&this._chart.resetDomain()},redraw:function(){this._chart&&
this._chart.redraw()},_makeChart:function(h,k,t,l,p,m){k||h?k&&(h=()=>rg.getXComponents(k)):h=rg.stepX;null!==this._makeChartAsyncCallbackId&&(this.cancelAsync(this._makeChartAsyncCallbackId),this._makeChartAsyncCallbackId=null);this._makeChartAsyncCallbackId=this.async(function(){this._makeChartAsyncCallbackId=null;if(h&&this.yValueAccessor&&this.tooltipColumns){var n=new b.LineChart(h,this.yValueAccessor,l,m,this.$.tooltip,this.tooltipColumns,this.fillArea,this.defaultXRange,this.defaultYRange,
this.symbolFunction,this.xAxisFormatter),q=d3.select(this.$.chartdiv);n.renderTo(q);this._chart&&this._chart.destroy();this._chart=n;this._chart.onAnchor(()=>this.fire("chart-attached"))}},350)},_reloadFromCache:function(){this._chart&&(this._visibleSeriesCache.forEach(h=>{this._chart.setSeriesData(h,this._seriesDataCache[h]||[])}),this._visibleSeriesCache.filter(h=>this._seriesMetadataCache[h]).forEach(h=>{this._chart.setSeriesMetadata(h,this._seriesMetadataCache[h])}),this._chart.setVisibleSeries(this._visibleSeriesCache))},
_smoothingChanged:function(){this._chart&&(this.smoothingEnabled?this._chart.smoothingUpdate(this.smoothingWeight):this._chart.smoothingDisable())},_outliersChanged:function(){this._chart&&this._chart.ignoreYOutliers(this.ignoreYOutliers)},_tooltipSortingMethodChanged:function(){this._chart&&this._chart.setTooltipSortingMethod(this.tooltipSortingMethod)},getExporter(){return new b.LineChartExporter(this.$.chartdiv)}})})(Gh||(Gh={}));

//# sourceURL=build://vz-line-chart2/vz-line-chart2.html.js
Polymer({is:"vz-line-chart-tooltip"});

//# sourceURL=build://vz-line-chart2/line-chart-exporter.js
(function(b){let d;(function(k){k.GROUP="G";k.DIV="DIV";k.SVG="SVG";k.TEXT="TEXT"})(d||(d={}));class f{constructor(k){this.uniqueId=0;this.root=k}exportAsString(){const k=this.convert(this.root);if(!k)return"";const t=this.createRootSvg();t.appendChild(k);return t.outerHTML}createUniqueId(){return`${"clip"}_${this.uniqueId++}`}getSize(){return this.root.getBoundingClientRect()}createRootSvg(){const k=document.createElement("svg"),t=this.getSize();k.setAttributeNS("svg","viewBox",`0 0 ${t.width} ${t.height}`);
k.setAttribute("xmlns","http://www.w3.org/2000/svg");return k}convert(k){let t=null;var l=k.nodeName.toUpperCase();if(k.nodeType!=Node.ELEMENT_NODE||l!=d.DIV&&l!=d.SVG)t=k.cloneNode();else{t=document.createElement(d.GROUP);var p=window.getComputedStyle(k),m=parseInt(p.left,10),n=parseInt(p.top,10);if(m||n)l=this.createUniqueId(),t.setAttribute("transform",`translate(${m}, ${n})`),t.setAttribute("clip-path",`url(#${l})`),n=parseInt(p.height,10),m=document.createElement("rect"),m.setAttribute("width",
String(parseInt(p.width,10))),m.setAttribute("height",String(n)),p=document.createElementNS("svg","clipPath"),p.id=l,p.appendChild(m),t.appendChild(p)}Array.from(k.childNodes).map(q=>this.convert(q)).filter(Boolean).forEach(q=>t.appendChild(q));return t.nodeName.toUpperCase()==d.GROUP&&!t.hasChildNodes()||this.shouldOmitNode(k)?null:this.stripClass(this.transferStyle(k,t))}stripClass(k){k.nodeType==Node.ELEMENT_NODE&&k.removeAttribute("class");return k}transferStyle(k,t){if(t.nodeType!=Node.ELEMENT_NODE)return t;
const l=t.nodeName.toUpperCase();k=window.getComputedStyle(k);l==d.TEXT&&Object.assign(t.style,{fontFamily:k.fontFamily,fontSize:k.fontSize,fontWeight:k.fontWeight});l!=d.GROUP&&(t.setAttribute("fill",k.fill),t.setAttribute("stroke",k.stroke),t.setAttribute("stroke-width",k.strokeWidth));"1"!=k.opacity&&t.setAttribute("opacity",k.opacity);return t}shouldOmitNode(){return!1}}b.PlottableExporter=f;class h extends f{shouldOmitNode(k){return k.nodeType==Node.ELEMENT_NODE?k.classList.contains("scatter-plot"):
!1}}b.LineChartExporter=h})(Gh||(Gh={}));

//# sourceURL=build://tf-line-chart-data-loader/tf-line-chart-data-loader.html.js
(function(){const b=[],d=function(){return _.throttle(function h(){if(0!=b.length){var k=b.shift();k.active&&(k.redraw(),k._maybeRenderedInBadState=!1);window.cancelAnimationFrame(0);window.requestAnimationFrame(h)}},100)}();Polymer({is:"tf-line-chart-data-loader",properties:{active:{type:Boolean,observer:"_fixBadStateWhenActive"},dataSeries:Array,requestManager:Object,logScaleActive:{type:Boolean,observer:"_logScaleChanged"},xComponentsCreationMethod:Object,xType:String,yValueAccessor:Object,fillArea:Object,
smoothingEnabled:Boolean,smoothingWeight:Number,tooltipColumns:Array,tooltipSortingMethod:String,tooltipPosition:String,ignoreYOutliers:Boolean,defaultXRange:Array,defaultYRange:Array,symbolFunction:Object,colorScale:{type:Object,value:()=>({scale:pf.runsColorScale})},_resetDomainOnNextLoad:{type:Boolean,value:!0},_maybeRenderedInBadState:{type:Boolean,value:!1,reflectToAttribute:!0}},behaviors:[qd.DataLoaderBehavior],observers:["_dataSeriesChanged(dataSeries.*)","_loadKeyChanged(loadKey)"],onLoadFinish(){0<
this.dataToLoad.length&&this._resetDomainOnNextLoad&&(this._resetDomainOnNextLoad=!1,this.$.chart.resetDomain());this.redraw()},detached(){cancelAnimationFrame(this._redrawRaf)},exportAsSvgString(){return this.$.chart.getExporter().exportAsString()},resetDomain(){this.$.chart.resetDomain()},setSeriesData(f,h){this.$.chart.setSeriesData(f,h)},setSeriesMetadata(f,h){this.$.chart.setSeriesMetadata(f,h)},redraw(){cancelAnimationFrame(this._redrawRaf);this._redrawRaf=window.requestAnimationFrame(()=>{this.active?
this.$.chart.redraw():this._maybeRenderedInBadState=!0})},_loadKeyChanged(){this.reset();this._resetDomainOnNextLoad=!0},_dataSeriesChanged(){this.$.chart.setVisibleSeries(this.dataSeries)},_logScaleChanged(f){this.$.chart.yScaleType=f?"log":"linear";this.redraw()},_fixBadStateWhenActive(){this.active&&this._maybeRenderedInBadState&&(b.push(this),d())},_onChartAttached(){this.active||(this._maybeRenderedInBadState=!0)}})})();

//# sourceURL=build://paper-dialog-scrollable/paper-dialog-scrollable.html.js
Polymer({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",0<this.scrollTarget.scrollTop);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.behaviors&&0<=this.dialogElement.behaviors.indexOf(Polymer.PaperDialogBehaviorImpl)?(this.dialogElement.sizingTarget=this.scrollTarget,this.scrollTarget.classList.remove("fit")):this.dialogElement&&this.scrollTarget.classList.add("fit")}});

//# sourceURL=build://tf-markdown-view/tf-markdown-view.html.js
Polymer({is:"tf-markdown-view",properties:{html:{type:String,value:""}},attached(){window.requestAnimationFrame(()=>{this.scopeSubtree(this.$.markdown,!0)})}});

//# sourceURL=build://tf-card-heading/util.js
var Hh;(function(b){function d(f){if(!f)return null;let h=f.match(/^#([0-9a-f]{1,2})([0-9a-f]{1,2})([0-9a-f]{1,2})$/);if(!h)return null;if(4==f.length)for(f=1;3>=f;f++)h[f]+=h[f];return[parseInt(h[1],16),parseInt(h[2],16),parseInt(h[3],16)]}b.formatDate=function(f){return f?f.toString().replace(/GMT-\d+ \(([^)]+)\)/,"$1"):""};b.pickTextColor=function(f){return(f=d(f))?125<Math.round((299*f[0]+587*f[1]+114*f[2])/1E3)?"inherit":"#eee":"inherit"}})(Hh||(Hh={}));

//# sourceURL=build://tf-card-heading/tf-card-heading.html.js
Polymer({is:"tf-card-heading",properties:{displayName:{type:String,value:null},tag:{type:String,value:null},run:{type:String,value:null},description:{type:String,value:null},color:{type:String,value:null},_runBackground:{type:String,computed:"_computeRunBackground(color)",readOnly:!0,observer:"_updateHeadingStyle"},_runColor:{type:String,computed:"_computeRunColor(color)",readOnly:!0,observer:"_updateHeadingStyle"},_nameLabel:{type:String,computed:"_computeNameLabel(displayName, tag)"},_tagLabel:{type:String,
computed:"_computeTagLabel(displayName, tag)"}},_updateHeadingStyle(){this.updateStyles({"--tf-card-heading-background-color":this._runBackground,"--tf-card-heading-color":this._runColor})},_computeRunBackground(b){return b||"none"},_computeRunColor(b){return Hh.pickTextColor(b)},_computeNameLabel(b,d){return b||d||""},_computeTagLabel(b,d){return d&&d!==b?d:""},_toggleDescriptionDialog(b){this.$.descriptionDialog.positionTarget=b.target;this.$.descriptionDialog.toggle()}});

//# sourceURL=build://tf-dashboard-common/tf-downloader.html.js
Polymer({is:"tf-downloader",properties:{_run:{type:String,value:""},runs:Array,tag:String,urlFn:Function},_csvUrl(b,d,f){return d?vc.addParams(f(b,d),{format:"csv"}):""},_jsonUrl(b,d,f){return d?f(b,d):""},_csvName(b,d){return d?`run-${d}-tag-${b}.csv`:""},_jsonName(b,d){return d?`run-${d}-tag-${b}.json`:""}});

//# sourceURL=build://tf-scalar-dashboard/tf-scalar-card.html.js
Polymer({is:"tf-scalar-card",properties:{tag:String,dataToLoad:Array,xType:String,active:Boolean,ignoreYOutliers:Boolean,requestManager:Object,showDownLinks:Boolean,smoothingEnabled:Boolean,smoothingWeight:Number,tagMetadata:Object,colorScale:{type:Object,value:null},tooltipSortingMethod:String,_loadDataCallback:{type:Object,value:function(){return(b,d,f)=>{f=f.map(k=>({wall_time:new Date(1E3*k[0]),step:k[1],scalar:k[2]}));const h=this._getSeriesNameFromDatum(d);b.setSeriesMetadata(h,d);b.setSeriesData(h,
f)}},readOnly:!0},getDataLoadUrl:{type:Function,value:function(){return({tag:b,run:d})=>vc.getRouter().pluginRoute("scalars","/scalars",new URLSearchParams({tag:b,run:d}))}},_downloadUrlFn:{type:Function,value:function(){return(b,d)=>this.getDataLoadUrl({tag:b,run:d})}},requestData:Function,_getDataLoadName:{type:Function,value:function(){return b=>this._getSeriesNameFromDatum(b)}},_expanded:{type:Boolean,value:!1,reflectToAttribute:!0},_logScaleActive:Boolean,_tooltipColumns:{type:Array,value:function(){const b=
Gh.DEFAULT_TOOLTIP_COLUMNS.slice(),d=b.findIndex(f=>"Name"==f.title);b.splice(d,1,{title:"Name",evaluate:f=>{f=f.dataset.metadata().meta;return this._getSeriesDisplayNameFromDatum(f)}});return b}}},reload(){this.$$("tf-line-chart-data-loader").reload()},redraw(){this.$$("tf-line-chart-data-loader").redraw()},_toggleExpanded(){this.set("_expanded",!this._expanded);this.redraw()},_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)},_resetDomain(){const b=this.$$("tf-line-chart-data-loader");
b&&b.resetDomain()},_updateDownloadLink(){const b=this.$$("tf-line-chart-data-loader").exportAsSvgString();this.$$("#svgLink").href=`data:image/svg+xml;base64,${btoa(b)}`},_runsFromData(b){return b.map(d=>d.run)},_getDataSeries(){return this.dataToLoad.map(b=>this._getSeriesNameFromDatum(b))},_getSeriesNameFromDatum({run:b,experiment:d={name:"_default"}}){return JSON.stringify([d.name,b])},_getSeriesDisplayNameFromDatum(b){return b.run},_getColorScale(){return null!==this.colorScale?this.colorScale:
{scale:b=>{[,b]=JSON.parse(b);return pf.runsColorScale(b)}}}});

//# sourceURL=build://iron-range-behavior/iron-range-behavior.html.js
Polymer.IronRangeBehavior={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(b){return(this._clampValue(b)-this.min)/(this.max-this.min)},_clampValue:function(b){return Math.min(this.max,Math.max(this.min,this._calcStep(b)))},_calcStep:function(b){b=parseFloat(b);
if(!this.step)return b;b=Math.round((b-this.min)/this.step);return 1>this.step?b/(1/this.step)+this.min:b*this.step+this.min},_validateValue:function(){var b=this._clampValue(this.value);this.value=this.oldValue=isNaN(b)?this.oldValue:b;return this.value!==b},_update:function(){this._validateValue();this._setRatio(100*this._calcRatio(this.value))}};

//# sourceURL=build://paper-progress/paper-progress.html.js
Polymer({is:"paper-progress",behaviors:[Polymer.IronRangeBehavior],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(b){this.toggleClass("indeterminate",
b,this.$.primaryProgress)},_transformProgress:function(b,d){b.style.transform=b.style.webkitTransform="scaleX("+d/100+")"},_mainRatioChanged:function(b){this._transformProgress(this.$.primaryProgress,b)},_progressChanged:function(b,d,f,h,k){b=this._clampValue(b);d=this._clampValue(d);var t=100*this._calcRatio(b),l=100*this._calcRatio(d);this._setSecondaryRatio(t);this._transformProgress(this.$.secondaryProgress,t);this._transformProgress(this.$.primaryProgress,l);this.secondaryProgress=b;k?this.removeAttribute("aria-valuenow"):
this.setAttribute("aria-valuenow",d);this.setAttribute("aria-valuemin",f);this.setAttribute("aria-valuemax",h)},_disabledChanged:function(b){this.setAttribute("aria-disabled",b?"true":"false")},_hideSecondaryProgress:function(b){return 0===b}});

//# sourceURL=build://paper-slider/paper-slider.html.js
Polymer({is:"paper-slider",behaviors:[Polymer.IronA11yKeysBehavior,Polymer.IronFormElementBehavior,Polymer.PaperInkyFocusBehavior,Polymer.IronRangeBehavior],properties:{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&&Polymer.Gestures.setTouchAction(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(b,d,f){this.setAttribute("aria-valuemin",d);this.setAttribute("aria-valuemax",f);this.setAttribute("aria-valuenow",b);this._positionKnob(100*this._calcRatio(b))},_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(b){this._setImmediateValue(this._calcStep(this._calcKnobPosition(b)));this._setRatio(100*this._calcRatio(this.immediateValue));this.$.sliderKnob.style.left=this.ratio+"%";this.dragging&&
(this._knobstartx=this.ratio*this._w/100,this.translate3d(0,0,0,this.$.sliderKnob))},_calcKnobPosition:function(b){return(this.max-this.min)*b/100+this.min},_onTrack:function(b){b.stopPropagation();switch(b.detail.state){case "start":this._trackStart(b);break;case "track":this._trackX(b);break;case "end":this._trackEnd()}},_trackStart:function(){this._setTransiting(!1);this._w=this.$.sliderBar.offsetWidth;this._knobstartx=this._startx=this._x=this.ratio*this._w/100;this._minx=-this._startx;this._maxx=
this._w-this._startx;this.$.sliderKnob.classList.add("dragging");this._setDragging(!0)},_trackX:function(b){this.dragging||this._trackStart(b);this._x=this._startx+Math.min(this._maxx,Math.max(this._minx,b.detail.dx*(this._isRTL?-1:1)));this._setImmediateValue(this._calcStep(this._calcKnobPosition(this._x/this._w*100)));this.translate3d(this._calcRatio(this.immediateValue)*this._w-this._knobstartx+"px",0,0,this.$.sliderKnob)},_trackEnd:function(){var b=this.$.sliderKnob.style;this.$.sliderKnob.classList.remove("dragging");
this._setDragging(!1);this._resetKnob();this.value=this.immediateValue;b.transform=b.webkitTransform="";this.fire("change",{composed:!0})},_knobdown:function(b){this._expandKnob();b.preventDefault();this.focus()},_bartrack:function(b){this._allowBarEvent(b)&&this._onTrack(b)},_barclick:function(b){this._w=this.$.sliderBar.offsetWidth;var d=this.$.sliderBar.getBoundingClientRect();d=(b.detail.x-d.left)/this._w*100;this._isRTL&&(d=100-d);var f=this.ratio;this._setTransiting(!0);this._positionKnob(d);
f===this.ratio&&this._setTransiting(!1);this.async(function(){this.fire("change",{composed:!0})});b.preventDefault();this.focus()},_bardown:function(b){this._allowBarEvent(b)&&(this.debounce("expandKnob",this._expandKnob,60),this._barclick(b))},_knobTransitionEnd:function(b){b.target===this.$.sliderKnob&&this._setTransiting(!1)},_updateMarkers:function(b,d,f,h){h||this._setMarkers([]);d=Math.round((f-d)/this.step);d>b&&(d=b);if(0>d||!isFinite(d))d=0;this._setMarkers(Array(d))},_mergeClasses:function(b){return Object.keys(b).filter(function(d){return b[d]}).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(b){return!this.ignoreBarTouch||b.detail.sourceEvent instanceof MouseEvent},get _isRTL(){void 0===this.__isRTL&&(this.__isRTL="rtl"===window.getComputedStyle(this).direction);return this.__isRTL},_leftKey:function(b){this._isRTL?this._incrementKey(b):
this._decrementKey(b)},_rightKey:function(b){this._isRTL?this._decrementKey(b):this._incrementKey(b)},_incrementKey:function(b){this.disabled||("end"===b.detail.key?this.value=this.max:this.increment(),this.fire("change"),b.preventDefault())},_decrementKey:function(b){this.disabled||("home"===b.detail.key?this.value=this.min:this.decrement(),this.fire("change"),b.preventDefault())},_changeValue:function(b){this.value=b.target.value;this.fire("change",{composed:!0})},_inputKeyDown:function(b){b.stopPropagation()},
_createRipple:function(){this._rippleContainer=this.$.sliderKnob;return Polymer.PaperInkyFocusBehaviorImpl._createRipple.call(this)},_focusedChanged:function(b){b&&this.ensureRipple();this.hasRipple()&&(this._ripple.style.display=b?"":"none",this._ripple.holdDown=b)}});

//# sourceURL=build://tf-scalar-dashboard/tf-smoothing-input.html.js
Polymer({is:"tf-smoothing-input",properties:{step:Number,max:Number,min:Number,weight:{type:Number,value:.6,notify:!0},_immediateWeightNumberForPaperSlider:{type:Number,notify:!0,observer:"_immediateWeightNumberForPaperSliderChanged"},_inputWeightStringForPaperInput:{type:String,notify:!0,observer:"_inputWeightStringForPaperInputChanged"}},_updateWeight:_.debounce(function(b){this.weight=b},250),_immediateWeightNumberForPaperSliderChanged:function(){this._inputWeightStringForPaperInput=this._immediateWeightNumberForPaperSlider.toString();
this._updateWeight.call(this,this._immediateWeightNumberForPaperSlider)},_inputWeightStringForPaperInputChanged:function(){0>+this._inputWeightStringForPaperInput?this._inputWeightStringForPaperInput="0":1<+this._inputWeightStringForPaperInput&&(this._inputWeightStringForPaperInput="1");var b=+this._inputWeightStringForPaperInput;isNaN(b)||this._updateWeight.call(this,b)}});

//# sourceURL=build://tf-scalar-dashboard/tf-scalar-dashboard.html.js
Polymer({is:"tf-scalar-dashboard",properties:{_showDownloadLinks:{type:Boolean,notify:!0,value:pd.getBooleanInitializer("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),observer:"_showDownloadLinksObserver"},_smoothingWeight:{type:Number,notify:!0,value:pd.getNumberInitializer("_smoothingWeight",{defaultValue:.6}),observer:"_smoothingWeightObserver"},_smoothingEnabled:{type:Boolean,computed:"_computeSmoothingEnabled(_smoothingWeight)"},_ignoreYOutliers:{type:Boolean,value:pd.getBooleanInitializer("_ignoreYOutliers",
{defaultValue:!0,useLocalStorage:!0}),observer:"_ignoreYOutliersObserver"},_xType:{type:String,value:rg.XType.STEP},_selectedRuns:{type:Array,value:()=>[]},_runToTagInfo:Object,_dataNotFound:Boolean,_tagFilter:{type:String,value:""},_categoriesDomReady:Boolean,_categories:{type:Array,value:()=>[]},_getCategoryItemKey:{type:Function,value:()=>b=>b.tag},_requestManager:{type:Object,value:()=>new vc.RequestManager(50)}},behaviors:[qd.ArrayUpdateHelper],observers:["_updateCategories(_runToTagInfo, _selectedRuns, _tagFilter, _categoriesDomReady)"],
_showDownloadLinksObserver:pd.getBooleanObserver("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),_smoothingWeightObserver:pd.getNumberObserver("_smoothingWeight",{defaultValue:.6}),_ignoreYOutliersObserver:pd.getBooleanObserver("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}),_computeSmoothingEnabled(b){return 0<b},_getCategoryKey(b){return b.metadata.type==$c.CategoryType.SEARCH_RESULTS?"":b.name},_shouldOpen(b){return 2>=b},ready(){this.reload()},reload(){this._fetchTags().then(()=>
{this._reloadCharts()})},_fetchTags(){const b=vc.getRouter().pluginRoute("scalars","/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,this._runToTagInfo)){var f=_.mapValues(d,h=>Object.keys(h));f=vc.getTags(f);this.set("_dataNotFound",0===f.length);this.set("_runToTagInfo",d);this.async(()=>{this.set("_categoriesDomReady",!0)})}})},_reloadCharts(){this.root.querySelectorAll("tf-scalar-card").forEach(b=>{b.reload()})},_updateCategories(b,d,f){b=_.mapValues(b,h=>Object.keys(h));
d=$c.categorizeTags(b,d,f);d.forEach(h=>{h.items=h.items.map(k=>({tag:k.tag,series:k.runs.map(t=>({run:t,tag:k.tag}))}))});this.updateArrayProp("_categories",d,this._getCategoryKey)},_tagMetadata(b,d,f){const h=f.tag,k={};f.series.forEach(({run:p})=>{k[p]=d[p][h]});f=h.replace(/\/scalar_summary$/,"");let {description:t,displayName:l}=rf.aggregateTagInfo(k,f);b.metadata.type==$c.CategoryType.PREFIX_GROUP&&l.startsWith(b.name+"/")&&(l=l.slice(b.name.length+1));return{description:t,displayName:l}}});

//# sourceURL=build://tf-custom-scalar-dashboard/tf-custom-scalar-helpers.js
var Ti;
(function(b){class d{constructor(h,k,t,l,p){this.run=h;this.tag=k;this.name=t;this.scalarData=l;this.symbol=p}getName(){return this.name}setData(h){this.scalarData=h}getData(){return this.scalarData}getRun(){return this.run}getTag(){return this.tag}getSymbol(){return this.symbol}}b.DataSeries=d;b.generateDataSeriesName=function(h,k){return`${k} (${h})`};class f{constructor(h){this.runBasedColorScale=h}scale(h){return this.runBasedColorScale.scale(this.parseRunName(h))}parseRunName(h){return(h=h.match(/\((.*)\)$/))?
h[1]:""}}b.DataSeriesColorScale=f})(Ti||(Ti={}));

//# sourceURL=build://tf-custom-scalar-dashboard/tf-custom-scalar-margin-chart-card.html.js
Polymer({is:"tf-custom-scalar-margin-chart-card",properties:{runs:Array,xType:String,active:{type:Boolean,value:!0,readOnly:!0},title:String,marginChartSeries:Array,ignoreYOutliers:Boolean,requestManager:Object,showDownloadLinks:Boolean,tagMetadata:Object,tooltipSortingMethod:String,_colorScale:{type:Object,value:new Ti.DataSeriesColorScale({scale:pf.runsColorScale}),readOnly:!0},_tagFilter:{type:String,computed:"_computeTagFilter(marginChartSeries)"},_tagFilterInvalid:Boolean,_nameToDataSeries:{type:Object,
value:()=>({})},_seriesNames:{type:Object,computed:"_computeSeriesNames(_nameToDataSeries, runs)"},_expanded:{type:Boolean,value:!1,reflectToAttribute:!0},_logScaleActive:Boolean,_dataUrl:{type:Function,value:function(){return b=>{const d=this._tagFilter;return vc.addParams(vc.getRouter().pluginRoute("custom_scalars","/scalars"),{tag:d,run:b})}}},_runToNextAvailableSymbolIndex:{type:Object,value:{}},_matchesListOpened:{type:Boolean,value:!1},_titleDisplayString:{type:String,computed:"_computeTitleDisplayString(title)"},
_fillArea:{type:Object,readOnly:!0,value:{lowerAccessor:b=>b.lower,higherAccessor:b=>b.upper}},_tooltipColumns:{type:Array,value:function(){const b=rg.multiscaleFormatter(rg.Y_TOOLTIP_FORMATTER_PRECISION),d=f=>isNaN(f)?"NaN":b(f);return[{title:"Name",evaluate:f=>f.dataset.metadata().name},{title:"Value",evaluate:f=>d(f.datum.scalar)},{title:"Lower Margin",evaluate:f=>d(f.datum.lower)},{title:"Upper Margin",evaluate:f=>d(f.datum.upper)},{title:"Step",evaluate:f=>rg.stepFormatter(f.datum.step)},{title:"Time",
evaluate:f=>rg.timeFormatter(f.datum.wall_time)},{title:"Relative",evaluate:f=>rg.relativeFormatter(rg.relativeAccessor(f.datum,-1,f.dataset))}]}},_missingTags:{type:Array,value:[]},_missingTagsCollapsibleOpened:{type:Boolean,value:!1},_stepsMismatch:Object},observers:["_updateChart(_nameToDataSeries)","_refreshDataSeries(_tagFilter)"],reload(){this.$.loader.reload()},redraw(){this.$.loader.redraw()},_toggleExpanded(){this.set("_expanded",!this._expanded);this.redraw()},_toggleLogScale(){this.set("_logScaleActive",
!this._logScaleActive)},_resetDomain(){const b=this.$.loader;b&&b.resetDomain()},_csvUrl(b,d){if(!d)return"";b=this._downloadDataUrl(b,d);return vc.addParams(b,{format:"csv"})},_jsonUrl(b,d){if(!d)return"";b=this._downloadDataUrl(b,d);return vc.addParams(b,{format:"json"})},_downloadDataUrl(b,d){b=b[d];b={tag:b.getTag(),run:b.getRun()};return vc.addParams(vc.getRouter().pluginRoute("custom_scalars","/download_data"),b)},_createProcessDataFunction(b){return(d,f,h)=>{if(h.regex_valid){var k=_.clone(this._nameToDataSeries),
t=[];_.forEach(b,l=>{var p=!1,m=h.tag_to_events[l.value];const n=h.tag_to_events[l.lower],q=h.tag_to_events[l.upper];_.isUndefined(m)&&(t.push(l.value),p=!0);_.isUndefined(n)&&(t.push(l.lower),p=!0);_.isUndefined(q)&&(t.push(l.upper),p=!0);if(!p){var u=y=>y[1];if(p=this._findStepMismatch(l,m.map(u),n.map(u),q.map(u)))this.set("_stepsMismatch",p);else{var x=y=>y[2];p=m.map((y,w)=>({wall_time:new Date(1E3*y[0]),step:u(y),scalar:x(y),lower:x(n[w]),upper:x(q[w])}));m=Ti.generateDataSeriesName(f,l.value);
var A=k[m];A?A.setData(p):(l=this._createNewDataSeries(f,l.value,m,p),k[m]=l)}}});this.set("_nameToDataSeries",k);d=_.findIndex(this._missingTags,l=>l.run===f);if(t.length&&3!=t.length){const l={run:f,tags:t};0<=d?this.splice("_missingTags",d,1,l):this.push("_missingTags",l)}else 0<=d&&this.splice("_missingTags",d,1)}else this.set("_tagFilterInvalid",!0)}},_findStepMismatch(b,d,f,h){return _.isEqual(f,d)&&_.isEqual(h,d)?null:{seriesObject:b,valueSteps:d,lowerSteps:f,upperSteps:h}},_createNewDataSeries(b,
d,f,h){this._runToNextAvailableSymbolIndex[b]|=0;d=new Ti.DataSeries(b,d,f,h,rg.SYMBOLS_LIST[this._runToNextAvailableSymbolIndex[b]]);this._runToNextAvailableSymbolIndex[b]=(this._runToNextAvailableSymbolIndex[b]+1)%rg.SYMBOLS_LIST.length;return d},_updateChart(b){_.forOwn(b,d=>{this.$.loader.setSeriesData(d.getName(),d.getData())})},_computeSeriesNames(){const b=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter(([,d])=>b.has(d.run)).map(([d])=>d)},_determineColor(b,d){return b.scale(d)},
_refreshDataSeries(){this.set("_nameToDataSeries",{})},_createSymbolFunction(){return b=>this._nameToDataSeries[b].getSymbol().method()},_determineSymbol(b,d){return b[d].getSymbol().character},_computeTagFilter(b){return _.flatten(b.map(d=>[d.value,d.lower,d.upper])).map(d=>"("+this._escapeRegexCharacters(d)+")").join("|")},_escapeRegexCharacters(b){return b.replace(/[.*+?^${}()|[\]\\]/g,"\\$\x26")},_getToggleCollapsibleIcon(b){return b?"expand-less":"expand-more"},_toggleMatchesOpen(){this.set("_matchesListOpened",
!this._matchesListOpened)},_computeTitleDisplayString(b){return b||"untitled"},_separateWithCommas(b){return b.join(", ")},_toggleMissingTagsCollapsibleOpen(){this.set("_missingTagsCollapsibleOpened",!this._missingTagsCollapsibleOpened)},_matchListEntryColorUpdated(){const b=this.$$("#match-list-repeat");b&&this.root.querySelectorAll(".match-list-entry").forEach(d=>{const f=b.itemForElement(d);d.style.color=this._determineColor(this._colorScale,f)})}});

//# sourceURL=build://tf-custom-scalar-dashboard/tf-custom-scalar-multi-line-chart-card.html.js
Polymer({is:"tf-custom-scalar-multi-line-chart-card",properties:{runs:Array,xType:String,active:{type:Boolean,value:!0,readOnly:!0},title:String,tagRegexes:Array,ignoreYOutliers:Boolean,requestManager:Object,showDownloadLinks:Boolean,smoothingEnabled:Boolean,smoothingWeight:Number,tagMetadata:Object,tooltipSortingMethod:String,_colorScale:{type:Object,value:new Ti.DataSeriesColorScale({scale:pf.runsColorScale}),readOnly:!0},_tagFilter:{type:String,computed:"_computeTagFilter(tagRegexes)"},_nameToDataSeries:{type:Object,
value:()=>({})},_seriesNames:{type:Object,computed:"_computeSeriesNames(_nameToDataSeries, runs)"},_expanded:{type:Boolean,value:!1,reflectToAttribute:!0},_logScaleActive:Boolean,_dataUrl:{type:Function,value:function(){return b=>{const d=this._tagFilter;return vc.addParams(vc.getRouter().pluginRoute("custom_scalars","/scalars"),{tag:d,run:b})}}},_runToNextAvailableSymbolIndex:{type:Object,value:{}},_matchesListOpened:{type:Boolean,value:!1},_titleDisplayString:{type:String,computed:"_computeTitleDisplayString(title)"}},
observers:["_updateChart(_nameToDataSeries)","_refreshDataSeries(_tagFilter)"],reload(){this.$.loader.reload()},redraw(){this.$.loader.redraw()},_toggleExpanded(){this.set("_expanded",!this._expanded);this.redraw()},_toggleLogScale(){this.set("_logScaleActive",!this._logScaleActive)},_resetDomain(){const b=this.$.loader;b&&b.resetDomain()},_csvUrl(b,d){if(!d)return"";b=this._downloadDataUrl(b,d);return vc.addParams(b,{format:"csv"})},_jsonUrl(b,d){if(!d)return"";b=this._downloadDataUrl(b,d);return vc.addParams(b,
{format:"json"})},_downloadDataUrl(b,d){b=b[d];b={tag:b.getTag(),run:b.getRun()};return vc.addParams(vc.getRouter().pluginRoute("custom_scalars","/download_data"),b)},_createProcessDataFunction(){return(b,d,f)=>{if(f.regex_valid){const h=_.clone(this._nameToDataSeries);_.forOwn(f.tag_to_events,(k,t)=>{const l=k.map(m=>({wall_time:new Date(1E3*m[0]),step:m[1],scalar:m[2]}));k=Ti.generateDataSeriesName(d,t);const p=h[k];p?p.setData(l):(_.isUndefined(this._runToNextAvailableSymbolIndex[d])&&(this._runToNextAvailableSymbolIndex[d]=
0),t=new Ti.DataSeries(d,t,k,l,rg.SYMBOLS_LIST[this._runToNextAvailableSymbolIndex[d]]),h[k]=t,this._runToNextAvailableSymbolIndex[d]=(this._runToNextAvailableSymbolIndex[d]+1)%rg.SYMBOLS_LIST.length)});this.set("_nameToDataSeries",h)}}},_updateChart(b){Object.entries(b).forEach(([d,f])=>{this.$.loader.setSeriesData(d,f.getData())})},_computeSelectedRunsSet(b){const d={};_.forEach(b,f=>{d[f]=1});return d},_computeSeriesNames(){const b=new Set(this.runs);return Object.entries(this._nameToDataSeries).filter(([,
d])=>b.has(d.run)).map(([d])=>d)},_determineColor(b,d){return b.scale(d)},_refreshDataSeries(){this.set("_nameToDataSeries",{})},_createSymbolFunction(){return b=>this._nameToDataSeries[b].getSymbol().method()},_determineSymbol(b,d){return b[d].getSymbol().character},_computeTagFilter(b){return 1===b.length?b[0]:b.map(d=>"("+d+")").join("|")},_getToggleMatchesIcon(b){return b?"expand-less":"expand-more"},_toggleMatchesOpen(){this.set("_matchesListOpened",!this._matchesListOpened)},_computeTitleDisplayString(b){return b||
"untitled"},_matchListEntryColorUpdated(){const b=this.$$("#match-list-repeat");b&&this.root.querySelectorAll(".match-list-entry").forEach(d=>{const f=b.itemForElement(d);d.style.color=this._determineColor(this._colorScale,f)})}});

//# sourceURL=build://tf-custom-scalar-dashboard/tf-custom-scalar-dashboard.html.js
Polymer({is:"tf-custom-scalar-dashboard",properties:{_requestManager:{type:Object,value:()=>new vc.RequestManager(50)},_canceller:{type:Object,value:()=>new vc.Canceller},_selectedRuns:Array,_showDownloadLinks:{type:Boolean,notify:!0,value:pd.getBooleanInitializer("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),observer:"_showDownloadLinksObserver"},_smoothingEnabled:{type:Boolean,computed:"_computeSmoothingEnabled(_smoothingWeight)"},_smoothingWeight:{type:Number,notify:!0,value:pd.getNumberInitializer("_smoothingWeight",
{defaultValue:.6}),observer:"_smoothingWeightObserver"},_ignoreYOutliers:{type:Boolean,value:pd.getBooleanInitializer("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}),observer:"_ignoreYOutliersObserver"},_xType:{type:String,value:"step"},_layout:Object,_dataNotFound:Boolean,_categories:{type:Array,computed:"_makeCategories(_layout)"},_openedCategories:{type:Object},_active:{type:Boolean,value:!0,readOnly:!0}},ready(){this.reload()},reload(){const b=vc.getRouter().pluginsListing(),d=this._canceller.cancellable(f=>
{f.cancelled||(this.set("_dataNotFound",!f.value.custom_scalars),this._dataNotFound||this._retrieveLayoutAndData())});this._requestManager.request(b).then(d)},_reloadCharts(){this.root.querySelectorAll("tf-custom-scalar-margin-chart-card, tf-custom-scalar-multi-line-chart-card").forEach(b=>{b.reload()})},_retrieveLayoutAndData(){const b=vc.getRouter().pluginRoute("custom_scalars","/layout"),d=this._canceller.cancellable(f=>{f.cancelled||(this.set("_layout",f.value),this._dataNotFound||this._reloadCharts())});
this._requestManager.request(b).then(d)},_showDownloadLinksObserver:pd.getBooleanObserver("_showDownloadLinks",{defaultValue:!1,useLocalStorage:!0}),_smoothingWeightObserver:pd.getNumberObserver("_smoothingWeight",{defaultValue:.6}),_ignoreYOutliersObserver:pd.getBooleanObserver("_ignoreYOutliers",{defaultValue:!0,useLocalStorage:!0}),_computeSmoothingEnabled(b){return 0<b},_makeCategories(b){if(!b.category)return[];let d=!1;this._openedCategories||(d=!0,this._openedCategories={});return b.category.map(f=>
{d&&!f.closed&&(this._openedCategories[f.title]=!0);return{name:f.title,items:f.chart,metadata:{opened:!!this._openedCategories[f.title]}}})},_categoryOpenedToggled(b){b=b.target;b.opened?this._openedCategories[b.category.name]=!0:delete this._openedCategories[b.category.name]}});

//# sourceURL=build://tf-image-dashboard/tf-image-loader.html.js
Polymer({is:"tf-image-loader",properties:{run:String,tag:String,sample:Number,ofSamples:Number,tagMetadata:Object,_runColor:{type:String,computed:"_computeRunColor(run)"},actualSize:{type:Boolean,value:!1,reflectToAttribute:!0},brightnessAdjustment:{type:Number,value:.5},contrastPercentage:{type:Number,value:0},requestManager:Object,_metadataCanceller:{type:Object,value:()=>new vc.Canceller},_imageCanceller:{type:Object,value:()=>new vc.Canceller},_steps:{type:Array,value:[],notify:!0},_stepIndex:{type:Number,
notify:!0},_currentStep:{type:Object,computed:"_computeCurrentStep(_steps, _stepIndex)"},_hasAtLeastOneStep:{type:Boolean,computed:"_computeHasAtLeastOneStep(_steps)"},_hasMultipleSteps:{type:Boolean,computed:"_computeHasMultipleSteps(_steps)"},_stepValue:{type:Number,computed:"_computeStepValue(_currentStep)"},_currentWallTime:{type:String,computed:"_computeCurrentWallTime(_currentStep)"},_maxStepIndex:{type:Number,computed:"_computeMaxStepIndex(_steps)"},_sampleText:{type:String,computed:"_computeSampleText(sample)"},
_hasMultipleSamples:{type:Boolean,computed:"_computeHasMultipleSamples(ofSamples)"},_isImageLoading:{type:Boolean,value:!1}},observers:["reload(run, tag)","_updateImageUrl(_currentStep, brightnessAdjustment, contrastPercentage)"],_computeRunColor(b){return pf.runsColorScale(b)},_computeHasAtLeastOneStep(b){return!!b&&0<b.length},_computeHasMultipleSteps(b){return!!b&&1<b.length},_computeCurrentStep(b,d){return b[d]||null},_computeStepValue(b){return b?b.step:0},_computeCurrentWallTime(b){return b?
Hh.formatDate(b.wall_time):""},_computeMaxStepIndex(b){return b.length-1},_computeSampleText(b){return`${b+1}`},_computeHasMultipleSamples(b){return 1<b},_getAriaExpanded(){return this.actualSize?"true":"false"},attached(){this._attached=!0;this.reload()},reload(){if(this._attached){this._metadataCanceller.cancelAll();var b=vc.addParams(vc.getRouter().pluginRoute("images","/images"),{tag:this.tag,run:this.run,sample:this.sample}),d=this._metadataCanceller.cancellable(f=>{f.cancelled||(f=f.value.map(this._createStepDatum.bind(this)),
this.set("_steps",f),this.set("_stepIndex",f.length-1))});this.requestManager.request(b).then(d)}},_createStepDatum(b){let d=vc.getRouter().pluginRoute("images","/individualImage");d=vc.addParams(d,{ts:b.wall_time});d+="\x26"+b.query;return{wall_time:new Date(1E3*b.wall_time),step:b.step,url:d}},_updateImageUrl(b,d,f){if(b){var h=new Image;this._imageCanceller.cancelAll();h.onload=h.onerror=this._imageCanceller.cancellable(k=>{k.cancelled||(k=this.$$("#main-image-container"),k.innerHTML="",Polymer.dom(k).appendChild(h),
this.set("_isImageLoading",!1))}).bind(this);h.style.filter=`contrast(${f}%) `;h.style.filter+=`brightness(${d})`;this.set("_isImageLoading",!0);h.src=b.url}},_handleTap(){this.set("actualSize",!this.actualSize)},_toLocaleString(b){return b.toLocaleString()}});

//# sourceURL=build://tf-image-dashboard/tf-image-dashboard.html.js
Polymer({is:"tf-image-dashboard",properties:{_selectedRuns:Array,_runToTagInfo:Object,_dataNotFound:Boolean,_actualSize:Boolean,_defaultBrightnessAdjustment:{type:Number,value:1,readOnly:!0},_defaultContrastPercentage:{type:Number,value:100,readOnly:!0},_brightnessAdjustment:{type:Number,value:1},_contrastPercentage:{type:Number,value:100},_tagFilter:String,_brightnessIsDefault:{type:Boolean,computed:"_computeBrightnessIsDefault(_brightnessAdjustment)"},_contrastIsDefault:{type:Boolean,computed:"_computeContrastIsDefault(_contrastPercentage)"},
_categoriesDomReady:Boolean,_categories:{type:Array,computed:"_makeCategories(_runToTagInfo, _selectedRuns, _tagFilter, _categoriesDomReady)"},_requestManager:{type:Object,value:()=>new vc.RequestManager}},ready(){this.reload()},reload(){this._fetchTags().then(()=>{this._reloadImages()})},_fetchTags(){const b=vc.getRouter().pluginRoute("images","/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,this._runToTagInfo)){var f=_.mapValues(d,h=>Object.keys(h));f=vc.getTags(f);this.set("_dataNotFound",
0===f.length);this.set("_runToTagInfo",d);this.async(()=>{this.set("_categoriesDomReady",!0)})}})},_reloadImages(){this.root.querySelectorAll("tf-image-loader").forEach(b=>{b.reload()})},_shouldOpen(b){return 2>=b},_resetBrightness(){this._brightnessAdjustment=this._defaultBrightnessAdjustment},_resetContrast(){this._contrastPercentage=this._defaultContrastPercentage},_computeBrightnessIsDefault(b){return b===this._defaultBrightnessAdjustment},_computeContrastIsDefault(b){return b===this._defaultContrastPercentage},
_makeCategories(b,d,f){function h(t){const l=b[t.run][t.tag].samples;return _.range(l).map(p=>Object.assign({},t,{sample:p,ofSamples:l}))}const k=_.mapValues(b,t=>Object.keys(t));return $c.categorizeRunTagCombinations(k,d,f).map(t=>Object.assign({},t,{items:[].concat.apply([],t.items.map(h))}))},_tagMetadata(b,d,f){return b[d][f]}});

//# sourceURL=build://tf-audio-dashboard/tf-audio-loader.html.js
Polymer({is:"tf-audio-loader",properties:{run:String,tag:String,sample:Number,totalSamples:Number,tagMetadata:Object,_runColor:{type:String,computed:"_computeRunColor(run)"},requestManager:Object,_metadataCanceller:{type:Object,value:()=>new vc.Canceller},_steps:{type:Array,value:()=>[]},_stepIndex:Number,_hasAtLeastOneStep:{type:Boolean,computed:"_computeHasAtLeastOneStep(_steps)"},_hasMultipleSteps:{type:Boolean,computed:"_computeHasMultipleSteps(_steps)"},_currentDatum:{type:Object,computed:"_computeCurrentDatum(_steps, _stepIndex)"},
_maxStepIndex:{type:Number,computed:"_computeMaxStepIndex(_steps)"},_sampleText:{type:String,computed:"_computeSampleText(sample)"},_hasMultipleSamples:{type:Boolean,computed:"_computeHasMultipleSamples(totalSamples)"}},observers:["reload(run, tag)"],_computeRunColor(b){return pf.runsColorScale(b)},_computeHasAtLeastOneStep(b){return!!b&&0<b.length},_computeHasMultipleSteps(b){return!!b&&1<b.length},_computeMaxStepIndex(b){return b.length-1},_computeCurrentDatum(b,d){return b[d]},_computeSampleText(b){return`${b+
1}`},_computeHasMultipleSamples(b){return 1<b},attached(){this._attached=!0;this.reload()},reload(){if(this._attached){this._metadataCanceller.cancelAll();var b=vc.getRouter().pluginRoute("audio","/audio",new URLSearchParams({tag:this.tag,run:this.run,sample:this.sample})),d=this._metadataCanceller.cancellable(f=>{f.cancelled||(f=f.value.map(this._createStepDatum.bind(this)),this.set("_steps",f),this.set("_stepIndex",f.length-1))});this.requestManager.request(b).then(d)}},_createStepDatum(b){var d=
new URLSearchParams(b.query);d.append("ts",b.wall_time);d=vc.getRouter().pluginRoute("audio","/individualAudio",d);return{wall_time:Hh.formatDate(new Date(1E3*b.wall_time)),step:b.step,label:b.label,contentType:b.contentType,url:d}}});

//# sourceURL=build://tf-audio-dashboard/tf-audio-dashboard.html.js
Polymer({is:"tf-audio-dashboard",properties:{_selectedRuns:Array,_runToTagInfo:Object,_dataNotFound:Boolean,_tagFilter:{type:String,value:""},_categories:{type:Array,computed:"_makeCategories(_runToTagInfo, _selectedRuns, _tagFilter)"},_requestManager:{type:Object,value:()=>new vc.RequestManager}},ready(){this.reload()},reload(){this._fetchTags().then(()=>{this._reloadAudio()})},_fetchTags(){const b=vc.getRouter().pluginRoute("audio","/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,
this._runToTagInfo)){var f=_.mapValues(d,h=>Object.keys(h));f=vc.getTags(f);this.set("_dataNotFound",0===f.length);this.set("_runToTagInfo",d)}})},_reloadAudio(){this.root.querySelectorAll("tf-audio-loader").forEach(b=>{b.reload()})},_shouldOpen(b){return 2>=b},_makeCategories(b,d,f){function h(t){const l=b[t.run][t.tag].samples;return _.range(l).map(p=>Object.assign({},t,{sample:p,totalSamples:l}))}const k=_.mapValues(b,t=>Object.keys(t));return $c.categorizeRunTagCombinations(k,d,f).map(t=>Object.assign({},
t,{items:[].concat.apply([],t.items.map(h))}))},_tagMetadata(b,d,f){return b[d][f]}});

//# sourceURL=build://iron-autogrow-textarea/iron-autogrow-textarea.html.js
Polymer({is:"iron-autogrow-textarea",behaviors:[Polymer.IronValidatableBehavior,Polymer.IronControlState],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},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(b){this.$.textarea.selectionStart=b},set selectionEnd(b){this.$.textarea.selectionEnd=b},attached:function(){navigator.userAgent.match(/iP(?:[oa]d|hone)/)&&(this.$.textarea.style.marginLeft="-3px")},validate:function(){var b=this.$.textarea.validity.valid;
b&&(this.required&&""===this.value?b=!1:this.hasValidator()&&(b=Polymer.IronValidatableBehavior.validate.call(this,this.value)));this.invalid=!b;this.fire("iron-input-validate");return b},_bindValueChanged:function(b){this.value=b},_valueChanged:function(b){var d=this.textarea;d&&(d.value!==b&&(d.value=b||0===b?b:""),this.bindValue=b,this.$.mirror.innerHTML=this._valueForMirror(),this.fire("bind-value-changed",{value:this.bindValue}))},_onInput:function(b){var d=Polymer.dom(b).path;this.value=d?d[0].value:
b.target.value},_constrain:function(b){b=b||[""];for(b=0<this.maxRows&&b.length>this.maxRows?b.slice(0,this.maxRows):b.slice(0);0<this.rows&&b.length<this.rows;)b.push("");return b.join("\x3cbr/\x3e")+"\x26#160;"},_valueForMirror:function(){var b=this.textarea;if(b)return this.tokens=b&&b.value?b.value.replace(/&/gm,"\x26amp;").replace(/"/gm,"\x26quot;").replace(/'/gm,"\x26#39;").replace(/</gm,"\x26lt;").replace(/>/gm,"\x26gt;").split("\n"):[""],this._constrain(this.tokens)},_updateCached:function(){this.$.mirror.innerHTML=
this._constrain(this.tokens)}});

//# sourceURL=build://paper-input/paper-textarea.html.js
Polymer({is:"paper-textarea",behaviors:[Polymer.PaperInputBehavior,Polymer.IronFormElementBehavior],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(b){this.$.input.textarea.selectionStart=b},get selectionEnd(){return this.$.input.textarea.selectionEnd},
set selectionEnd(b){this.$.input.textarea.selectionEnd=b},_ariaLabelledByChanged:function(b){this._focusableElement.setAttribute("aria-labelledby",b)},_ariaDescribedByChanged:function(b){this._focusableElement.setAttribute("aria-describedby",b)},get _focusableElement(){return this.inputElement.textarea}});

//# sourceURL=build://paper-toast/paper-toast.html.js
(function(){var b=null;Polymer({is:"paper-toast",behaviors:[Polymer.IronOverlayBehavior],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(){Polymer.Base._warn("`visible` is deprecated, use `opened` instead");
return this.opened},get _canAutoClose(){return 0<this.duration&&Infinity!==this.duration},created:function(){this._autoClose=null;Polymer.IronA11yAnnouncer.requestAvailability()},show:function(d){"string"==typeof d&&(d={text:d});for(var f in d)0===f.indexOf("_")?Polymer.Base._warn('The property "'+f+'" is private and was not set.'):f in this?this[f]=d[f]:Polymer.Base._warn('The property "'+f+'" is not valid.');this.open()},hide:function(){this.close()},__onTransitionEnd:function(d){d&&d.target===
this&&"opacity"===d.propertyName&&(this.opened?this._finishRenderOpened():this._finishRenderClosed())},_openedChanged:function(){null!==this._autoClose&&(this.cancelAsync(this._autoClose),this._autoClose=null);this.opened?(b&&b!==this&&b.close(),b=this,this.fire("iron-announce",{text:this.text}),this._canAutoClose&&(this._autoClose=this.async(this.close,this.duration))):b===this&&(b=null);Polymer.IronOverlayBehaviorImpl._openedChanged.apply(this,arguments)},_renderOpened:function(){this.classList.add("paper-toast-open")},
_renderClosed:function(){this.classList.remove("paper-toast-open")},_onFitIntoChanged:function(d){this.positionTarget=d}})})();

//# sourceURL=build://paper-toggle-button/paper-toggle-button.html.js
Polymer({is:"paper-toggle-button",behaviors:[Polymer.PaperCheckedElementBehavior],hostAttributes:{role:"button","aria-pressed":"false",tabindex:0},properties:{},listeners:{track:"_ontrack"},attached:function(){Polymer.RenderStatus.afterNextRender(this,function(){Polymer.Gestures.setTouchAction(this,"pan-y")})},_ontrack:function(b){b=b.detail;"start"===b.state?this._trackStart(b):"track"===b.state?this._trackMove(b):"end"===b.state&&this._trackEnd(b)},_trackStart:function(){this._width=this.$.toggleBar.offsetWidth/
2;this._trackChecked=this.checked;this.$.toggleButton.classList.add("dragging")},_trackMove:function(b){b=b.dx;this._x=Math.min(this._width,Math.max(0,this._trackChecked?this._width+b:b));this.translate3d(this._x+"px",0,0,this.$.toggleButton);this._userActivate(this._x>this._width/2)},_trackEnd:function(){this.$.toggleButton.classList.remove("dragging");this.transform("",this.$.toggleButton)},_createRipple:function(){this._rippleContainer=this.$.toggleButton;var b=Polymer.PaperRippleBehavior._createRipple();
b.id="ink";b.setAttribute("recenters","");b.classList.add("circle","toggle-ink");return b}});

(function(f){if(typeof exports==="object"&&typeof module!=="undefined")module.exports=f();else if(typeof define==="function"&&define.amd)define([],f);else{var g;if(typeof window!=="undefined")g=window;else if(typeof global!=="undefined")g=global;else if(typeof self!=="undefined")g=self;else g=this;g.graphlib=f()}})(function(){var define,module,exports;return function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);
var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f;}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s}({1:[function(require,module,exports){var lib=require("./lib");module.exports={Graph:lib.Graph,json:require("./lib/json"),alg:require("./lib/alg"),version:lib.version}},{"./lib":17,"./lib/alg":8,"./lib/json":18}],
2:[function(require,module,exports){var _=require("../lodash");module.exports=components;function components(g){var visited={},cmpts=[],cmpt;function dfs(v){if(_.has(visited,v))return;visited[v]=true;cmpt.push(v);_.each(g.successors(v),dfs);_.each(g.predecessors(v),dfs)}_.each(g.nodes(),function(v){cmpt=[];dfs(v);if(cmpt.length)cmpts.push(cmpt)});return cmpts}},{"../lodash":19}],3:[function(require,module,exports){var _=require("../lodash");module.exports=dfs;function dfs(g,vs,order){if(!_.isArray(vs))vs=
[vs];var navigation=(g.isDirected()?g.successors:g.neighbors).bind(g);var acc=[],visited={};_.each(vs,function(v){if(!g.hasNode(v))throw new Error("Graph does not have node: "+v);doDfs(g,v,order==="post",visited,navigation,acc)});return acc}function doDfs(g,v,postorder,visited,navigation,acc){if(!_.has(visited,v)){visited[v]=true;if(!postorder)acc.push(v);_.each(navigation(v),function(w){doDfs(g,w,postorder,visited,navigation,acc)});if(postorder)acc.push(v)}}},{"../lodash":19}],4:[function(require,
module,exports){var dijkstra=require("./dijkstra"),_=require("../lodash");module.exports=dijkstraAll;function dijkstraAll(g,weightFunc,edgeFunc){return _.transform(g.nodes(),function(acc,v){acc[v]=dijkstra(g,v,weightFunc,edgeFunc)},{})}},{"../lodash":19,"./dijkstra":5}],5:[function(require,module,exports){var _=require("../lodash"),PriorityQueue=require("../data/priority-queue");module.exports=dijkstra;var DEFAULT_WEIGHT_FUNC=_.constant(1);function dijkstra(g,source,weightFn,edgeFn){return runDijkstra(g,
String(source),weightFn||DEFAULT_WEIGHT_FUNC,edgeFn||function(v){return g.outEdges(v)})}function runDijkstra(g,source,weightFn,edgeFn){var results={},pq=new PriorityQueue,v,vEntry;var updateNeighbors=function(edge){var w=edge.v!==v?edge.v:edge.w,wEntry=results[w],weight=weightFn(edge),distance=vEntry.distance+weight;if(weight<0)throw new Error("dijkstra does not allow negative edge weights. "+"Bad edge: "+edge+" Weight: "+weight);if(distance<wEntry.distance){wEntry.distance=distance;wEntry.predecessor=
v;pq.decrease(w,distance)}};g.nodes().forEach(function(v){var distance=v===source?0:Number.POSITIVE_INFINITY;results[v]={distance:distance};pq.add(v,distance)});while(pq.size()>0){v=pq.removeMin();vEntry=results[v];if(vEntry.distance===Number.POSITIVE_INFINITY)break;edgeFn(v).forEach(updateNeighbors)}return results}},{"../data/priority-queue":15,"../lodash":19}],6:[function(require,module,exports){var _=require("../lodash"),tarjan=require("./tarjan");module.exports=findCycles;function findCycles(g){return _.filter(tarjan(g),
function(cmpt){return cmpt.length>1||cmpt.length===1&&g.hasEdge(cmpt[0],cmpt[0])})}},{"../lodash":19,"./tarjan":13}],7:[function(require,module,exports){var _=require("../lodash");module.exports=floydWarshall;var DEFAULT_WEIGHT_FUNC=_.constant(1);function floydWarshall(g,weightFn,edgeFn){return runFloydWarshall(g,weightFn||DEFAULT_WEIGHT_FUNC,edgeFn||function(v){return g.outEdges(v)})}function runFloydWarshall(g,weightFn,edgeFn){var results={},nodes=g.nodes();nodes.forEach(function(v){results[v]=
{};results[v][v]={distance:0};nodes.forEach(function(w){if(v!==w)results[v][w]={distance:Number.POSITIVE_INFINITY}});edgeFn(v).forEach(function(edge){var w=edge.v===v?edge.w:edge.v,d=weightFn(edge);results[v][w]={distance:d,predecessor:v}})});nodes.forEach(function(k){var rowK=results[k];nodes.forEach(function(i){var rowI=results[i];nodes.forEach(function(j){var ik=rowI[k];var kj=rowK[j];var ij=rowI[j];var altDistance=ik.distance+kj.distance;if(altDistance<ij.distance){ij.distance=altDistance;ij.predecessor=
kj.predecessor}})})});return results}},{"../lodash":19}],8:[function(require,module,exports){module.exports={components:require("./components"),dijkstra:require("./dijkstra"),dijkstraAll:require("./dijkstra-all"),findCycles:require("./find-cycles"),floydWarshall:require("./floyd-warshall"),isAcyclic:require("./is-acyclic"),postorder:require("./postorder"),preorder:require("./preorder"),prim:require("./prim"),tarjan:require("./tarjan"),topsort:require("./topsort")}},{"./components":2,"./dijkstra":5,
"./dijkstra-all":4,"./find-cycles":6,"./floyd-warshall":7,"./is-acyclic":9,"./postorder":10,"./preorder":11,"./prim":12,"./tarjan":13,"./topsort":14}],9:[function(require,module,exports){var topsort=require("./topsort");module.exports=isAcyclic;function isAcyclic(g){try{topsort(g)}catch(e){if(e instanceof topsort.CycleException)return false;throw e;}return true}},{"./topsort":14}],10:[function(require,module,exports){var dfs=require("./dfs");module.exports=postorder;function postorder(g,vs){return dfs(g,
vs,"post")}},{"./dfs":3}],11:[function(require,module,exports){var dfs=require("./dfs");module.exports=preorder;function preorder(g,vs){return dfs(g,vs,"pre")}},{"./dfs":3}],12:[function(require,module,exports){var _=require("../lodash"),Graph=require("../graph"),PriorityQueue=require("../data/priority-queue");module.exports=prim;function prim(g,weightFunc){var result=new Graph,parents={},pq=new PriorityQueue,v;function updateNeighbors(edge){var w=edge.v===v?edge.w:edge.v,pri=pq.priority(w);if(pri!==
undefined){var edgeWeight=weightFunc(edge);if(edgeWeight<pri){parents[w]=v;pq.decrease(w,edgeWeight)}}}if(g.nodeCount()===0)return result;_.each(g.nodes(),function(v){pq.add(v,Number.POSITIVE_INFINITY);result.setNode(v)});pq.decrease(g.nodes()[0],0);var init=false;while(pq.size()>0){v=pq.removeMin();if(_.has(parents,v))result.setEdge(v,parents[v]);else if(init)throw new Error("Input graph is not connected: "+g);else init=true;g.nodeEdges(v).forEach(updateNeighbors)}return result}},{"../data/priority-queue":15,
"../graph":16,"../lodash":19}],13:[function(require,module,exports){var _=require("../lodash");module.exports=tarjan;function tarjan(g){var index=0,stack=[],visited={},results=[];function dfs(v){var entry=visited[v]={onStack:true,lowlink:index,index:index++};stack.push(v);g.successors(v).forEach(function(w){if(!_.has(visited,w)){dfs(w);entry.lowlink=Math.min(entry.lowlink,visited[w].lowlink)}else if(visited[w].onStack)entry.lowlink=Math.min(entry.lowlink,visited[w].index)});if(entry.lowlink===entry.index){var cmpt=
[],w;do{w=stack.pop();visited[w].onStack=false;cmpt.push(w)}while(v!==w);results.push(cmpt)}}g.nodes().forEach(function(v){if(!_.has(visited,v))dfs(v)});return results}},{"../lodash":19}],14:[function(require,module,exports){var _=require("../lodash");module.exports=topsort;topsort.CycleException=CycleException;function topsort(g){var visited={},stack={},results=[];function visit(node){if(_.has(stack,node))throw new CycleException;if(!_.has(visited,node)){stack[node]=true;visited[node]=true;_.each(g.predecessors(node),
visit);delete stack[node];results.push(node)}}_.each(g.sinks(),visit);if(_.size(visited)!==g.nodeCount())throw new CycleException;return results}function CycleException(){}},{"../lodash":19}],15:[function(require,module,exports){var _=require("../lodash");module.exports=PriorityQueue;function PriorityQueue(){this._arr=[];this._keyIndices={}}PriorityQueue.prototype.size=function(){return this._arr.length};PriorityQueue.prototype.keys=function(){return this._arr.map(function(x){return x.key})};PriorityQueue.prototype.has=
function(key){return _.has(this._keyIndices,key)};PriorityQueue.prototype.priority=function(key){var index=this._keyIndices[key];if(index!==undefined)return this._arr[index].priority};PriorityQueue.prototype.min=function(){if(this.size()===0)throw new Error("Queue underflow");return this._arr[0].key};PriorityQueue.prototype.add=function(key,priority){var keyIndices=this._keyIndices;key=String(key);if(!_.has(keyIndices,key)){var arr=this._arr;var index=arr.length;keyIndices[key]=index;arr.push({key:key,
priority:priority});this._decrease(index);return true}return false};PriorityQueue.prototype.removeMin=function(){this._swap(0,this._arr.length-1);var min=this._arr.pop();delete this._keyIndices[min.key];this._heapify(0);return min.key};PriorityQueue.prototype.decrease=function(key,priority){var index=this._keyIndices[key];if(priority>this._arr[index].priority)throw new Error("New priority is greater than current priority. "+"Key: "+key+" Old: "+this._arr[index].priority+" New: "+priority);this._arr[index].priority=
priority;this._decrease(index)};PriorityQueue.prototype._heapify=function(i){var arr=this._arr;var l=2*i,r=l+1,largest=i;if(l<arr.length){largest=arr[l].priority<arr[largest].priority?l:largest;if(r<arr.length)largest=arr[r].priority<arr[largest].priority?r:largest;if(largest!==i){this._swap(i,largest);this._heapify(largest)}}};PriorityQueue.prototype._decrease=function(index){var arr=this._arr;var priority=arr[index].priority;var parent;while(index!==0){parent=index>>1;if(arr[parent].priority<priority)break;
this._swap(index,parent);index=parent}};PriorityQueue.prototype._swap=function(i,j){var arr=this._arr;var keyIndices=this._keyIndices;var origArrI=arr[i];var origArrJ=arr[j];arr[i]=origArrJ;arr[j]=origArrI;keyIndices[origArrJ.key]=i;keyIndices[origArrI.key]=j}},{"../lodash":19}],16:[function(require,module,exports){var _=require("./lodash");module.exports=Graph;var DEFAULT_EDGE_NAME="\x00",GRAPH_NODE="\x00",EDGE_KEY_DELIM="\u0001";function Graph(opts){this._isDirected=_.has(opts,"directed")?opts.directed:
true;this._isMultigraph=_.has(opts,"multigraph")?opts.multigraph:false;this._isCompound=_.has(opts,"compound")?opts.compound:false;this._label=undefined;this._defaultNodeLabelFn=_.constant(undefined);this._defaultEdgeLabelFn=_.constant(undefined);this._nodes={};if(this._isCompound){this._parent={};this._children={};this._children[GRAPH_NODE]={}}this._in={};this._preds={};this._out={};this._sucs={};this._edgeObjs={};this._edgeLabels={}}Graph.prototype._nodeCount=0;Graph.prototype._edgeCount=0;Graph.prototype.isDirected=
function(){return this._isDirected};Graph.prototype.isMultigraph=function(){return this._isMultigraph};Graph.prototype.isCompound=function(){return this._isCompound};Graph.prototype.setGraph=function(label){this._label=label;return this};Graph.prototype.graph=function(){return this._label};Graph.prototype.setDefaultNodeLabel=function(newDefault){if(!_.isFunction(newDefault))newDefault=_.constant(newDefault);this._defaultNodeLabelFn=newDefault;return this};Graph.prototype.nodeCount=function(){return this._nodeCount};
Graph.prototype.nodes=function(){return _.keys(this._nodes)};Graph.prototype.sources=function(){var self=this;return _.filter(this.nodes(),function(v){return _.isEmpty(self._in[v])})};Graph.prototype.sinks=function(){var self=this;return _.filter(this.nodes(),function(v){return _.isEmpty(self._out[v])})};Graph.prototype.setNodes=function(vs,value){var args=arguments;var self=this;_.each(vs,function(v){if(args.length>1)self.setNode(v,value);else self.setNode(v)});return this};Graph.prototype.setNode=
function(v,value){if(_.has(this._nodes,v)){if(arguments.length>1)this._nodes[v]=value;return this}this._nodes[v]=arguments.length>1?value:this._defaultNodeLabelFn(v);if(this._isCompound){this._parent[v]=GRAPH_NODE;this._children[v]={};this._children[GRAPH_NODE][v]=true}this._in[v]={};this._preds[v]={};this._out[v]={};this._sucs[v]={};++this._nodeCount;return this};Graph.prototype.node=function(v){return this._nodes[v]};Graph.prototype.hasNode=function(v){return _.has(this._nodes,v)};Graph.prototype.removeNode=
function(v){var self=this;if(_.has(this._nodes,v)){var removeEdge=function(e){self.removeEdge(self._edgeObjs[e])};delete this._nodes[v];if(this._isCompound){this._removeFromParentsChildList(v);delete this._parent[v];_.each(this.children(v),function(child){self.setParent(child)});delete this._children[v]}_.each(_.keys(this._in[v]),removeEdge);delete this._in[v];delete this._preds[v];_.each(_.keys(this._out[v]),removeEdge);delete this._out[v];delete this._sucs[v];--this._nodeCount}return this};Graph.prototype.setParent=
function(v,parent){if(!this._isCompound)throw new Error("Cannot set parent in a non-compound graph");if(_.isUndefined(parent))parent=GRAPH_NODE;else{parent+="";for(var ancestor=parent;!_.isUndefined(ancestor);ancestor=this.parent(ancestor))if(ancestor===v)throw new Error("Setting "+parent+" as parent of "+v+" would create a cycle");this.setNode(parent)}this.setNode(v);this._removeFromParentsChildList(v);this._parent[v]=parent;this._children[parent][v]=true;return this};Graph.prototype._removeFromParentsChildList=
function(v){delete this._children[this._parent[v]][v]};Graph.prototype.parent=function(v){if(this._isCompound){var parent=this._parent[v];if(parent!==GRAPH_NODE)return parent}};Graph.prototype.children=function(v){if(_.isUndefined(v))v=GRAPH_NODE;if(this._isCompound){var children=this._children[v];if(children)return _.keys(children)}else if(v===GRAPH_NODE)return this.nodes();else if(this.hasNode(v))return[]};Graph.prototype.predecessors=function(v){var predsV=this._preds[v];if(predsV)return _.keys(predsV)};
Graph.prototype.successors=function(v){var sucsV=this._sucs[v];if(sucsV)return _.keys(sucsV)};Graph.prototype.neighbors=function(v){var preds=this.predecessors(v);if(preds)return _.union(preds,this.successors(v))};Graph.prototype.isLeaf=function(v){var neighbors;if(this.isDirected())neighbors=this.successors(v);else neighbors=this.neighbors(v);return neighbors.length===0};Graph.prototype.filterNodes=function(filter){var copy=new this.constructor({directed:this._isDirected,multigraph:this._isMultigraph,
compound:this._isCompound});copy.setGraph(this.graph());var self=this;_.each(this._nodes,function(value,v){if(filter(v))copy.setNode(v,value)});_.each(this._edgeObjs,function(e){if(copy.hasNode(e.v)&&copy.hasNode(e.w))copy.setEdge(e,self.edge(e))});var parents={};function findParent(v){var parent=self.parent(v);if(parent===undefined||copy.hasNode(parent)){parents[v]=parent;return parent}else if(parent in parents)return parents[parent];else return findParent(parent)}if(this._isCompound)_.each(copy.nodes(),
function(v){copy.setParent(v,findParent(v))});return copy};Graph.prototype.setDefaultEdgeLabel=function(newDefault){if(!_.isFunction(newDefault))newDefault=_.constant(newDefault);this._defaultEdgeLabelFn=newDefault;return this};Graph.prototype.edgeCount=function(){return this._edgeCount};Graph.prototype.edges=function(){return _.values(this._edgeObjs)};Graph.prototype.setPath=function(vs,value){var self=this,args=arguments;_.reduce(vs,function(v,w){if(args.length>1)self.setEdge(v,w,value);else self.setEdge(v,
w);return w});return this};Graph.prototype.setEdge=function(){var v,w,name,value,valueSpecified=false,arg0=arguments[0];if(typeof arg0==="object"&&arg0!==null&&"v"in arg0){v=arg0.v;w=arg0.w;name=arg0.name;if(arguments.length===2){value=arguments[1];valueSpecified=true}}else{v=arg0;w=arguments[1];name=arguments[3];if(arguments.length>2){value=arguments[2];valueSpecified=true}}v=""+v;w=""+w;if(!_.isUndefined(name))name=""+name;var e=edgeArgsToId(this._isDirected,v,w,name);if(_.has(this._edgeLabels,
e)){if(valueSpecified)this._edgeLabels[e]=value;return this}if(!_.isUndefined(name)&&!this._isMultigraph)throw new Error("Cannot set a named edge when isMultigraph \x3d false");this.setNode(v);this.setNode(w);this._edgeLabels[e]=valueSpecified?value:this._defaultEdgeLabelFn(v,w,name);var edgeObj=edgeArgsToObj(this._isDirected,v,w,name);v=edgeObj.v;w=edgeObj.w;Object.freeze(edgeObj);this._edgeObjs[e]=edgeObj;incrementOrInitEntry(this._preds[w],v);incrementOrInitEntry(this._sucs[v],w);this._in[w][e]=
edgeObj;this._out[v][e]=edgeObj;this._edgeCount++;return this};Graph.prototype.edge=function(v,w,name){var e=arguments.length===1?edgeObjToId(this._isDirected,arguments[0]):edgeArgsToId(this._isDirected,v,w,name);return this._edgeLabels[e]};Graph.prototype.hasEdge=function(v,w,name){var e=arguments.length===1?edgeObjToId(this._isDirected,arguments[0]):edgeArgsToId(this._isDirected,v,w,name);return _.has(this._edgeLabels,e)};Graph.prototype.removeEdge=function(v,w,name){var e=arguments.length===1?
edgeObjToId(this._isDirected,arguments[0]):edgeArgsToId(this._isDirected,v,w,name),edge=this._edgeObjs[e];if(edge){v=edge.v;w=edge.w;delete this._edgeLabels[e];delete this._edgeObjs[e];decrementOrRemoveEntry(this._preds[w],v);decrementOrRemoveEntry(this._sucs[v],w);delete this._in[w][e];delete this._out[v][e];this._edgeCount--}return this};Graph.prototype.inEdges=function(v,u){var inV=this._in[v];if(inV){var edges=_.values(inV);if(!u)return edges;return _.filter(edges,function(edge){return edge.v===
u})}};Graph.prototype.outEdges=function(v,w){var outV=this._out[v];if(outV){var edges=_.values(outV);if(!w)return edges;return _.filter(edges,function(edge){return edge.w===w})}};Graph.prototype.nodeEdges=function(v,w){var inEdges=this.inEdges(v,w);if(inEdges)return inEdges.concat(this.outEdges(v,w))};function incrementOrInitEntry(map,k){if(map[k])map[k]++;else map[k]=1}function decrementOrRemoveEntry(map,k){if(!--map[k])delete map[k]}function edgeArgsToId(isDirected,v_,w_,name){var v=""+v_;var w=
""+w_;if(!isDirected&&v>w){var tmp=v;v=w;w=tmp}return v+EDGE_KEY_DELIM+w+EDGE_KEY_DELIM+(_.isUndefined(name)?DEFAULT_EDGE_NAME:name)}function edgeArgsToObj(isDirected,v_,w_,name){var v=""+v_;var w=""+w_;if(!isDirected&&v>w){var tmp=v;v=w;w=tmp}var edgeObj={v:v,w:w};if(name)edgeObj.name=name;return edgeObj}function edgeObjToId(isDirected,edgeObj){return edgeArgsToId(isDirected,edgeObj.v,edgeObj.w,edgeObj.name)}},{"./lodash":19}],17:[function(require,module,exports){module.exports={Graph:require("./graph"),
version:require("./version")}},{"./graph":16,"./version":20}],18:[function(require,module,exports){var _=require("./lodash"),Graph=require("./graph");module.exports={write:write,read:read};function write(g){var json={options:{directed:g.isDirected(),multigraph:g.isMultigraph(),compound:g.isCompound()},nodes:writeNodes(g),edges:writeEdges(g)};if(!_.isUndefined(g.graph()))json.value=_.clone(g.graph());return json}function writeNodes(g){return _.map(g.nodes(),function(v){var nodeValue=g.node(v),parent=
g.parent(v),node={v:v};if(!_.isUndefined(nodeValue))node.value=nodeValue;if(!_.isUndefined(parent))node.parent=parent;return node})}function writeEdges(g){return _.map(g.edges(),function(e){var edgeValue=g.edge(e),edge={v:e.v,w:e.w};if(!_.isUndefined(e.name))edge.name=e.name;if(!_.isUndefined(edgeValue))edge.value=edgeValue;return edge})}function read(json){var g=(new Graph(json.options)).setGraph(json.value);_.each(json.nodes,function(entry){g.setNode(entry.v,entry.value);if(entry.parent)g.setParent(entry.v,
entry.parent)});_.each(json.edges,function(entry){g.setEdge({v:entry.v,w:entry.w,name:entry.name},entry.value)});return g}},{"./graph":16,"./lodash":19}],19:[function(require,module,exports){var lodash;if(typeof require==="function")try{lodash=require("lodash")}catch(e){}if(!lodash)lodash=window._;module.exports=lodash},{"lodash":undefined}],20:[function(require,module,exports){module.exports="2.1.5"},{}]},{},[1])(1)});
(function(f){if(typeof exports==="object"&&typeof module!=="undefined")module.exports=f();else if(typeof define==="function"&&define.amd)define([],f);else{var g;if(typeof window!=="undefined")g=window;else if(typeof global!=="undefined")g=global;else if(typeof self!=="undefined")g=self;else g=this;g.dagre=f()}})(function(){var define,module,exports;return function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=
new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f;}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s}({1:[function(require,module,exports){module.exports={graphlib:require("./lib/graphlib"),layout:require("./lib/layout"),debug:require("./lib/debug"),util:{time:require("./lib/util").time,notime:require("./lib/util").notime},
version:require("./lib/version")}},{"./lib/debug":6,"./lib/graphlib":7,"./lib/layout":9,"./lib/util":29,"./lib/version":30}],2:[function(require,module,exports){var _=require("./lodash"),greedyFAS=require("./greedy-fas");module.exports={run:run,undo:undo};function run(g){var fas=g.graph().acyclicer==="greedy"?greedyFAS(g,weightFn(g)):dfsFAS(g);_.forEach(fas,function(e){var label=g.edge(e);g.removeEdge(e);label.forwardName=e.name;label.reversed=true;g.setEdge(e.w,e.v,label,_.uniqueId("rev"))});function weightFn(g){return function(e){return g.edge(e).weight}}
}function dfsFAS(g){var fas=[],stack={},visited={};function dfs(v){if(_.has(visited,v))return;visited[v]=true;stack[v]=true;_.forEach(g.outEdges(v),function(e){if(_.has(stack,e.w))fas.push(e);else dfs(e.w)});delete stack[v]}_.forEach(g.nodes(),dfs);return fas}function undo(g){_.forEach(g.edges(),function(e){var label=g.edge(e);if(label.reversed){g.removeEdge(e);var forwardName=label.forwardName;delete label.reversed;delete label.forwardName;g.setEdge(e.w,e.v,label,forwardName)}})}},{"./greedy-fas":8,
"./lodash":10}],3:[function(require,module,exports){var _=require("./lodash"),util=require("./util");module.exports=addBorderSegments;function addBorderSegments(g){function dfs(v){var children=g.children(v),node=g.node(v);if(children.length)_.forEach(children,dfs);if(_.has(node,"minRank")){node.borderLeft=[];node.borderRight=[];for(var rank=node.minRank,maxRank=node.maxRank+1;rank<maxRank;++rank){addBorderNode(g,"borderLeft","_bl",v,node,rank);addBorderNode(g,"borderRight","_br",v,node,rank)}}}_.forEach(g.children(),
dfs)}function addBorderNode(g,prop,prefix,sg,sgNode,rank){var label={width:0,height:0,rank:rank,borderType:prop},prev=sgNode[prop][rank-1],curr=util.addDummyNode(g,"border",label,prefix);sgNode[prop][rank]=curr;g.setParent(curr,sg);if(prev)g.setEdge(prev,curr,{weight:1})}},{"./lodash":10,"./util":29}],4:[function(require,module,exports){var _=require("./lodash");module.exports={adjust:adjust,undo:undo};function adjust(g){var rankDir=g.graph().rankdir.toLowerCase();if(rankDir==="lr"||rankDir==="rl")swapWidthHeight(g)}
function undo(g){var rankDir=g.graph().rankdir.toLowerCase();if(rankDir==="bt"||rankDir==="rl")reverseY(g);if(rankDir==="lr"||rankDir==="rl"){swapXY(g);swapWidthHeight(g)}}function swapWidthHeight(g){_.forEach(g.nodes(),function(v){swapWidthHeightOne(g.node(v))});_.forEach(g.edges(),function(e){swapWidthHeightOne(g.edge(e))})}function swapWidthHeightOne(attrs){var w=attrs.width;attrs.width=attrs.height;attrs.height=w}function reverseY(g){_.forEach(g.nodes(),function(v){reverseYOne(g.node(v))});_.forEach(g.edges(),
function(e){var edge=g.edge(e);_.forEach(edge.points,reverseYOne);if(_.has(edge,"y"))reverseYOne(edge)})}function reverseYOne(attrs){attrs.y=-attrs.y}function swapXY(g){_.forEach(g.nodes(),function(v){swapXYOne(g.node(v))});_.forEach(g.edges(),function(e){var edge=g.edge(e);_.forEach(edge.points,swapXYOne);if(_.has(edge,"x"))swapXYOne(edge)})}function swapXYOne(attrs){var x=attrs.x;attrs.x=attrs.y;attrs.y=x}},{"./lodash":10}],5:[function(require,module,exports){module.exports=List;function List(){var sentinel=
{};sentinel._next=sentinel._prev=sentinel;this._sentinel=sentinel}List.prototype.dequeue=function(){var sentinel=this._sentinel,entry=sentinel._prev;if(entry!==sentinel){unlink(entry);return entry}};List.prototype.enqueue=function(entry){var sentinel=this._sentinel;if(entry._prev&&entry._next)unlink(entry);entry._next=sentinel._next;sentinel._next._prev=entry;sentinel._next=entry;entry._prev=sentinel};List.prototype.toString=function(){var strs=[],sentinel=this._sentinel,curr=sentinel._prev;while(curr!==
sentinel){strs.push(JSON.stringify(curr,filterOutLinks));curr=curr._prev}return"["+strs.join(", ")+"]"};function unlink(entry){entry._prev._next=entry._next;entry._next._prev=entry._prev;delete entry._next;delete entry._prev}function filterOutLinks(k,v){if(k!=="_next"&&k!=="_prev")return v}},{}],6:[function(require,module,exports){var _=require("./lodash"),util=require("./util"),Graph=require("./graphlib").Graph;module.exports={debugOrdering:debugOrdering};function debugOrdering(g){var layerMatrix=
util.buildLayerMatrix(g);var h=(new Graph({compound:true,multigraph:true})).setGraph({});_.forEach(g.nodes(),function(v){h.setNode(v,{label:v});h.setParent(v,"layer"+g.node(v).rank)});_.forEach(g.edges(),function(e){h.setEdge(e.v,e.w,{},e.name)});_.forEach(layerMatrix,function(layer,i){var layerV="layer"+i;h.setNode(layerV,{rank:"same"});_.reduce(layer,function(u,v){h.setEdge(u,v,{style:"invis"});return v})});return h}},{"./graphlib":7,"./lodash":10,"./util":29}],7:[function(require,module,exports){var graphlib;
if(typeof require==="function")try{graphlib=require("graphlib")}catch(e){}if(!graphlib)graphlib=window.graphlib;module.exports=graphlib},{"graphlib":undefined}],8:[function(require,module,exports){var _=require("./lodash"),Graph=require("./graphlib").Graph,List=require("./data/list");module.exports=greedyFAS;var DEFAULT_WEIGHT_FN=_.constant(1);function greedyFAS(g,weightFn){if(g.nodeCount()<=1)return[];var state=buildState(g,weightFn||DEFAULT_WEIGHT_FN);var results=doGreedyFAS(state.graph,state.buckets,
state.zeroIdx);return _.flatten(_.map(results,function(e){return g.outEdges(e.v,e.w)}),true)}function doGreedyFAS(g,buckets,zeroIdx){var results=[],sources=buckets[buckets.length-1],sinks=buckets[0];var entry;while(g.nodeCount()){while(entry=sinks.dequeue())removeNode(g,buckets,zeroIdx,entry);while(entry=sources.dequeue())removeNode(g,buckets,zeroIdx,entry);if(g.nodeCount())for(var i=buckets.length-2;i>0;--i){entry=buckets[i].dequeue();if(entry){results=results.concat(removeNode(g,buckets,zeroIdx,
entry,true));break}}}return results}function removeNode(g,buckets,zeroIdx,entry,collectPredecessors){var results=collectPredecessors?[]:undefined;_.forEach(g.inEdges(entry.v),function(edge){var weight=g.edge(edge),uEntry=g.node(edge.v);if(collectPredecessors)results.push({v:edge.v,w:edge.w});uEntry.out-=weight;assignBucket(buckets,zeroIdx,uEntry)});_.forEach(g.outEdges(entry.v),function(edge){var weight=g.edge(edge),w=edge.w,wEntry=g.node(w);wEntry["in"]-=weight;assignBucket(buckets,zeroIdx,wEntry)});
g.removeNode(entry.v);return results}function buildState(g,weightFn){var fasGraph=new Graph,maxIn=0,maxOut=0;_.forEach(g.nodes(),function(v){fasGraph.setNode(v,{v:v,"in":0,out:0})});_.forEach(g.edges(),function(e){var prevWeight=fasGraph.edge(e.v,e.w)||0,weight=weightFn(e),edgeWeight=prevWeight+weight;fasGraph.setEdge(e.v,e.w,edgeWeight);maxOut=Math.max(maxOut,fasGraph.node(e.v).out+=weight);maxIn=Math.max(maxIn,fasGraph.node(e.w)["in"]+=weight)});var buckets=_.range(maxOut+maxIn+3).map(function(){return new List});
var zeroIdx=maxIn+1;_.forEach(fasGraph.nodes(),function(v){assignBucket(buckets,zeroIdx,fasGraph.node(v))});return{graph:fasGraph,buckets:buckets,zeroIdx:zeroIdx}}function assignBucket(buckets,zeroIdx,entry){if(!entry.out)buckets[0].enqueue(entry);else if(!entry["in"])buckets[buckets.length-1].enqueue(entry);else buckets[entry.out-entry["in"]+zeroIdx].enqueue(entry)}},{"./data/list":5,"./graphlib":7,"./lodash":10}],9:[function(require,module,exports){var _=require("./lodash"),acyclic=require("./acyclic"),
normalize=require("./normalize"),rank=require("./rank"),normalizeRanks=require("./util").normalizeRanks,parentDummyChains=require("./parent-dummy-chains"),removeEmptyRanks=require("./util").removeEmptyRanks,nestingGraph=require("./nesting-graph"),addBorderSegments=require("./add-border-segments"),coordinateSystem=require("./coordinate-system"),order=require("./order"),position=require("./position"),util=require("./util"),Graph=require("./graphlib").Graph;module.exports=layout;function layout(g,opts){var time=
opts&&opts.debugTiming?util.time:util.notime;time("layout",function(){var layoutGraph=time("  buildLayoutGraph",function(){return buildLayoutGraph(g)});time("  runLayout",function(){runLayout(layoutGraph,time)});time("  updateInputGraph",function(){updateInputGraph(g,layoutGraph)})})}function runLayout(g,time){time("    makeSpaceForEdgeLabels",function(){makeSpaceForEdgeLabels(g)});time("    removeSelfEdges",function(){removeSelfEdges(g)});time("    acyclic",function(){acyclic.run(g)});time("    nestingGraph.run",
function(){nestingGraph.run(g)});time("    rank",function(){rank(util.asNonCompoundGraph(g))});time("    injectEdgeLabelProxies",function(){injectEdgeLabelProxies(g)});time("    removeEmptyRanks",function(){removeEmptyRanks(g)});time("    nestingGraph.cleanup",function(){nestingGraph.cleanup(g)});time("    normalizeRanks",function(){normalizeRanks(g)});time("    assignRankMinMax",function(){assignRankMinMax(g)});time("    removeEdgeLabelProxies",function(){removeEdgeLabelProxies(g)});time("    normalize.run",
function(){normalize.run(g)});time("    parentDummyChains",function(){parentDummyChains(g)});time("    addBorderSegments",function(){addBorderSegments(g)});time("    order",function(){order(g)});time("    insertSelfEdges",function(){insertSelfEdges(g)});time("    adjustCoordinateSystem",function(){coordinateSystem.adjust(g)});time("    position",function(){position(g)});time("    positionSelfEdges",function(){positionSelfEdges(g)});time("    removeBorderNodes",function(){removeBorderNodes(g)});time("    normalize.undo",
function(){normalize.undo(g)});time("    fixupEdgeLabelCoords",function(){fixupEdgeLabelCoords(g)});time("    undoCoordinateSystem",function(){coordinateSystem.undo(g)});time("    translateGraph",function(){translateGraph(g)});time("    assignNodeIntersects",function(){assignNodeIntersects(g)});time("    reversePoints",function(){reversePointsForReversedEdges(g)});time("    acyclic.undo",function(){acyclic.undo(g)})}function updateInputGraph(inputGraph,layoutGraph){_.forEach(inputGraph.nodes(),function(v){var inputLabel=
inputGraph.node(v),layoutLabel=layoutGraph.node(v);if(inputLabel){inputLabel.x=layoutLabel.x;inputLabel.y=layoutLabel.y;if(layoutGraph.children(v).length){inputLabel.width=layoutLabel.width;inputLabel.height=layoutLabel.height}}});_.forEach(inputGraph.edges(),function(e){var inputLabel=inputGraph.edge(e),layoutLabel=layoutGraph.edge(e);inputLabel.points=layoutLabel.points;if(_.has(layoutLabel,"x")){inputLabel.x=layoutLabel.x;inputLabel.y=layoutLabel.y}});inputGraph.graph().width=layoutGraph.graph().width;
inputGraph.graph().height=layoutGraph.graph().height}var graphNumAttrs=["nodesep","edgesep","ranksep","marginx","marginy"],graphDefaults={ranksep:50,edgesep:20,nodesep:50,rankdir:"tb"},graphAttrs=["acyclicer","ranker","rankdir","align"],nodeNumAttrs=["width","height"],nodeDefaults={width:0,height:0},edgeNumAttrs=["minlen","weight","width","height","labeloffset"],edgeDefaults={minlen:1,weight:1,width:0,height:0,labeloffset:10,labelpos:"r"},edgeAttrs=["labelpos"];function buildLayoutGraph(inputGraph){var g=
new Graph({multigraph:true,compound:true}),graph=canonicalize(inputGraph.graph());g.setGraph(_.merge({},graphDefaults,selectNumberAttrs(graph,graphNumAttrs),_.pick(graph,graphAttrs)));_.forEach(inputGraph.nodes(),function(v){var node=canonicalize(inputGraph.node(v));g.setNode(v,_.defaults(selectNumberAttrs(node,nodeNumAttrs),nodeDefaults));g.setParent(v,inputGraph.parent(v))});_.forEach(inputGraph.edges(),function(e){var edge=canonicalize(inputGraph.edge(e));g.setEdge(e,_.merge({},edgeDefaults,selectNumberAttrs(edge,
edgeNumAttrs),_.pick(edge,edgeAttrs)))});return g}function makeSpaceForEdgeLabels(g){var graph=g.graph();graph.ranksep/=2;_.forEach(g.edges(),function(e){var edge=g.edge(e);edge.minlen*=2;if(edge.labelpos.toLowerCase()!=="c")if(graph.rankdir==="TB"||graph.rankdir==="BT")edge.width+=edge.labeloffset;else edge.height+=edge.labeloffset})}function injectEdgeLabelProxies(g){_.forEach(g.edges(),function(e){var edge=g.edge(e);if(edge.width&&edge.height){var v=g.node(e.v),w=g.node(e.w),label={rank:(w.rank-
v.rank)/2+v.rank,e:e};util.addDummyNode(g,"edge-proxy",label,"_ep")}})}function assignRankMinMax(g){var maxRank=0;_.forEach(g.nodes(),function(v){var node=g.node(v);if(node.borderTop){node.minRank=g.node(node.borderTop).rank;node.maxRank=g.node(node.borderBottom).rank;maxRank=_.max(maxRank,node.maxRank)}});g.graph().maxRank=maxRank}function removeEdgeLabelProxies(g){_.forEach(g.nodes(),function(v){var node=g.node(v);if(node.dummy==="edge-proxy"){g.edge(node.e).labelRank=node.rank;g.removeNode(v)}})}
function translateGraph(g){var minX=Number.POSITIVE_INFINITY,maxX=0,minY=Number.POSITIVE_INFINITY,maxY=0,graphLabel=g.graph(),marginX=graphLabel.marginx||0,marginY=graphLabel.marginy||0;function getExtremes(attrs){var x=attrs.x,y=attrs.y,w=attrs.width,h=attrs.height;minX=Math.min(minX,x-w/2);maxX=Math.max(maxX,x+w/2);minY=Math.min(minY,y-h/2);maxY=Math.max(maxY,y+h/2)}_.forEach(g.nodes(),function(v){getExtremes(g.node(v))});_.forEach(g.edges(),function(e){var edge=g.edge(e);if(_.has(edge,"x"))getExtremes(edge)});
minX-=marginX;minY-=marginY;_.forEach(g.nodes(),function(v){var node=g.node(v);node.x-=minX;node.y-=minY});_.forEach(g.edges(),function(e){var edge=g.edge(e);_.forEach(edge.points,function(p){p.x-=minX;p.y-=minY});if(_.has(edge,"x"))edge.x-=minX;if(_.has(edge,"y"))edge.y-=minY});graphLabel.width=maxX-minX+marginX;graphLabel.height=maxY-minY+marginY}function assignNodeIntersects(g){_.forEach(g.edges(),function(e){var edge=g.edge(e),nodeV=g.node(e.v),nodeW=g.node(e.w),p1,p2;if(!edge.points){edge.points=
[];p1=nodeW;p2=nodeV}else{p1=edge.points[0];p2=edge.points[edge.points.length-1]}edge.points.unshift(util.intersectRect(nodeV,p1));edge.points.push(util.intersectRect(nodeW,p2))})}function fixupEdgeLabelCoords(g){_.forEach(g.edges(),function(e){var edge=g.edge(e);if(_.has(edge,"x")){if(edge.labelpos==="l"||edge.labelpos==="r")edge.width-=edge.labeloffset;switch(edge.labelpos){case "l":edge.x-=edge.width/2+edge.labeloffset;break;case "r":edge.x+=edge.width/2+edge.labeloffset;break}}})}function reversePointsForReversedEdges(g){_.forEach(g.edges(),
function(e){var edge=g.edge(e);if(edge.reversed)edge.points.reverse()})}function removeBorderNodes(g){_.forEach(g.nodes(),function(v){if(g.children(v).length){var node=g.node(v),t=g.node(node.borderTop),b=g.node(node.borderBottom),l=g.node(_.last(node.borderLeft)),r=g.node(_.last(node.borderRight));node.width=Math.abs(r.x-l.x);node.height=Math.abs(b.y-t.y);node.x=l.x+node.width/2;node.y=t.y+node.height/2}});_.forEach(g.nodes(),function(v){if(g.node(v).dummy==="border")g.removeNode(v)})}function removeSelfEdges(g){_.forEach(g.edges(),
function(e){if(e.v===e.w){var node=g.node(e.v);if(!node.selfEdges)node.selfEdges=[];node.selfEdges.push({e:e,label:g.edge(e)});g.removeEdge(e)}})}function insertSelfEdges(g){var layers=util.buildLayerMatrix(g);_.forEach(layers,function(layer){var orderShift=0;_.forEach(layer,function(v,i){var node=g.node(v);node.order=i+orderShift;_.forEach(node.selfEdges,function(selfEdge){util.addDummyNode(g,"selfedge",{width:selfEdge.label.width,height:selfEdge.label.height,rank:node.rank,order:i+ ++orderShift,
e:selfEdge.e,label:selfEdge.label},"_se")});delete node.selfEdges})})}function positionSelfEdges(g){_.forEach(g.nodes(),function(v){var node=g.node(v);if(node.dummy==="selfedge"){var selfNode=g.node(node.e.v),x=selfNode.x+selfNode.width/2,y=selfNode.y,dx=node.x-x,dy=selfNode.height/2;g.setEdge(node.e,node.label);g.removeNode(v);node.label.points=[{x:x+2*dx/3,y:y-dy},{x:x+5*dx/6,y:y-dy},{x:x+dx,y:y},{x:x+5*dx/6,y:y+dy},{x:x+2*dx/3,y:y+dy}];node.label.x=node.x;node.label.y=node.y}})}function selectNumberAttrs(obj,
attrs){return _.mapValues(_.pick(obj,attrs),Number)}function canonicalize(attrs){var newAttrs={};_.forEach(attrs,function(v,k){newAttrs[k.toLowerCase()]=v});return newAttrs}},{"./acyclic":2,"./add-border-segments":3,"./coordinate-system":4,"./graphlib":7,"./lodash":10,"./nesting-graph":11,"./normalize":12,"./order":17,"./parent-dummy-chains":22,"./position":24,"./rank":26,"./util":29}],10:[function(require,module,exports){var lodash;if(typeof require==="function")try{lodash=require("lodash")}catch(e){}if(!lodash)lodash=
window._;module.exports=lodash},{"lodash":undefined}],11:[function(require,module,exports){var _=require("./lodash"),util=require("./util");module.exports={run:run,cleanup:cleanup};function run(g){var root=util.addDummyNode(g,"root",{},"_root");var depths=treeDepths(g);var height=_.max(_.values(depths))-1;var nodeSep=2*height+1;g.graph().nestingRoot=root;_.forEach(g.edges(),function(e){g.edge(e).minlen*=nodeSep});var weight=sumWeights(g)+1;_.forEach(g.children(),function(child){dfs(g,root,nodeSep,
weight,height,depths,child)});g.graph().nodeRankFactor=nodeSep}function dfs(g,root,nodeSep,weight,height,depths,v){var children=g.children(v);if(!children.length){if(v!==root)g.setEdge(root,v,{weight:0,minlen:nodeSep});return}var top=util.addBorderNode(g,"_bt"),bottom=util.addBorderNode(g,"_bb"),label=g.node(v);g.setParent(top,v);label.borderTop=top;g.setParent(bottom,v);label.borderBottom=bottom;_.forEach(children,function(child){dfs(g,root,nodeSep,weight,height,depths,child);var childNode=g.node(child),
childTop=childNode.borderTop?childNode.borderTop:child,childBottom=childNode.borderBottom?childNode.borderBottom:child,thisWeight=childNode.borderTop?weight:2*weight,minlen=childTop!==childBottom?1:height-depths[v]+1;g.setEdge(top,childTop,{weight:thisWeight,minlen:minlen,nestingEdge:true});g.setEdge(childBottom,bottom,{weight:thisWeight,minlen:minlen,nestingEdge:true})});if(!g.parent(v))g.setEdge(root,top,{weight:0,minlen:height+depths[v]})}function treeDepths(g){var depths={};function dfs(v,depth){var children=
g.children(v);if(children&&children.length)_.forEach(children,function(child){dfs(child,depth+1)});depths[v]=depth}_.forEach(g.children(),function(v){dfs(v,1)});return depths}function sumWeights(g){return _.reduce(g.edges(),function(acc,e){return acc+g.edge(e).weight},0)}function cleanup(g){var graphLabel=g.graph();g.removeNode(graphLabel.nestingRoot);delete graphLabel.nestingRoot;_.forEach(g.edges(),function(e){var edge=g.edge(e);if(edge.nestingEdge)g.removeEdge(e)})}},{"./lodash":10,"./util":29}],
12:[function(require,module,exports){var _=require("./lodash"),util=require("./util");module.exports={run:run,undo:undo};function run(g){g.graph().dummyChains=[];_.forEach(g.edges(),function(edge){normalizeEdge(g,edge)})}function normalizeEdge(g,e){var v=e.v,vRank=g.node(v).rank,w=e.w,wRank=g.node(w).rank,name=e.name,edgeLabel=g.edge(e),labelRank=edgeLabel.labelRank;if(wRank===vRank+1)return;g.removeEdge(e);var dummy,attrs,i;for(i=0,++vRank;vRank<wRank;++i,++vRank){edgeLabel.points=[];attrs={width:0,
height:0,edgeLabel:edgeLabel,edgeObj:e,rank:vRank};dummy=util.addDummyNode(g,"edge",attrs,"_d");if(vRank===labelRank){attrs.width=edgeLabel.width;attrs.height=edgeLabel.height;attrs.dummy="edge-label";attrs.labelpos=edgeLabel.labelpos}g.setEdge(v,dummy,{weight:edgeLabel.weight},name);if(i===0)g.graph().dummyChains.push(dummy);v=dummy}g.setEdge(v,w,{weight:edgeLabel.weight},name)}function undo(g){_.forEach(g.graph().dummyChains,function(v){var node=g.node(v),origLabel=node.edgeLabel,w;g.setEdge(node.edgeObj,
origLabel);while(node.dummy){w=g.successors(v)[0];g.removeNode(v);origLabel.points.push({x:node.x,y:node.y});if(node.dummy==="edge-label"){origLabel.x=node.x;origLabel.y=node.y;origLabel.width=node.width;origLabel.height=node.height}v=w;node=g.node(v)}})}},{"./lodash":10,"./util":29}],13:[function(require,module,exports){var _=require("../lodash");module.exports=addSubgraphConstraints;function addSubgraphConstraints(g,cg,vs){var prev={},rootPrev;_.forEach(vs,function(v){var child=g.parent(v),parent,
prevChild;while(child){parent=g.parent(child);if(parent){prevChild=prev[parent];prev[parent]=child}else{prevChild=rootPrev;rootPrev=child}if(prevChild&&prevChild!==child){cg.setEdge(prevChild,child);return}child=parent}})}},{"../lodash":10}],14:[function(require,module,exports){var _=require("../lodash");module.exports=barycenter;function barycenter(g,movable){return _.map(movable,function(v){var inV=g.inEdges(v);if(!inV.length)return{v:v};else{var result=_.reduce(inV,function(acc,e){var edge=g.edge(e),
nodeU=g.node(e.v);return{sum:acc.sum+edge.weight*nodeU.order,weight:acc.weight+edge.weight}},{sum:0,weight:0});return{v:v,barycenter:result.sum/result.weight,weight:result.weight}}})}},{"../lodash":10}],15:[function(require,module,exports){var _=require("../lodash"),Graph=require("../graphlib").Graph;module.exports=buildLayerGraph;function buildLayerGraph(g,rank,relationship){var root=createRootNode(g),result=(new Graph({compound:true})).setGraph({root:root}).setDefaultNodeLabel(function(v){return g.node(v)});
_.forEach(g.nodes(),function(v){var node=g.node(v),parent=g.parent(v);if(node.rank===rank||node.minRank<=rank&&rank<=node.maxRank){result.setNode(v);result.setParent(v,parent||root);_.forEach(g[relationship](v),function(e){var u=e.v===v?e.w:e.v,edge=result.edge(u,v),weight=!_.isUndefined(edge)?edge.weight:0;result.setEdge(u,v,{weight:g.edge(e).weight+weight})});if(_.has(node,"minRank"))result.setNode(v,{borderLeft:node.borderLeft[rank],borderRight:node.borderRight[rank]})}});return result}function createRootNode(g){var v;
while(g.hasNode(v=_.uniqueId("_root")));return v}},{"../graphlib":7,"../lodash":10}],16:[function(require,module,exports){var _=require("../lodash");module.exports=crossCount;function crossCount(g,layering){var cc=0;for(var i=1;i<layering.length;++i)cc+=twoLayerCrossCount(g,layering[i-1],layering[i]);return cc}function twoLayerCrossCount(g,northLayer,southLayer){var southPos=_.zipObject(southLayer,_.map(southLayer,function(v,i){return i}));var southEntries=_.flatten(_.map(northLayer,function(v){return _.chain(g.outEdges(v)).map(function(e){return{pos:southPos[e.w],
weight:g.edge(e).weight}}).sortBy("pos").value()}),true);var firstIndex=1;while(firstIndex<southLayer.length)firstIndex<<=1;var treeSize=2*firstIndex-1;firstIndex-=1;var tree=_.map(new Array(treeSize),function(){return 0});var cc=0;_.forEach(southEntries.forEach(function(entry){var index=entry.pos+firstIndex;tree[index]+=entry.weight;var weightSum=0;while(index>0){if(index%2)weightSum+=tree[index+1];index=index-1>>1;tree[index]+=entry.weight}cc+=entry.weight*weightSum}));return cc}},{"../lodash":10}],
17:[function(require,module,exports){var _=require("../lodash"),initOrder=require("./init-order"),crossCount=require("./cross-count"),sortSubgraph=require("./sort-subgraph"),buildLayerGraph=require("./build-layer-graph"),addSubgraphConstraints=require("./add-subgraph-constraints"),Graph=require("../graphlib").Graph,util=require("../util");module.exports=order;function order(g){var maxRank=util.maxRank(g),downLayerGraphs=buildLayerGraphs(g,_.range(1,maxRank+1),"inEdges"),upLayerGraphs=buildLayerGraphs(g,
_.range(maxRank-1,-1,-1),"outEdges");var layering=initOrder(g);assignOrder(g,layering);var bestCC=Number.POSITIVE_INFINITY,best;for(var i=0,lastBest=0;lastBest<4;++i,++lastBest){sweepLayerGraphs(i%2?downLayerGraphs:upLayerGraphs,i%4>=2);layering=util.buildLayerMatrix(g);var cc=crossCount(g,layering);if(cc<bestCC){lastBest=0;best=_.cloneDeep(layering);bestCC=cc}}assignOrder(g,best)}function buildLayerGraphs(g,ranks,relationship){return _.map(ranks,function(rank){return buildLayerGraph(g,rank,relationship)})}
function sweepLayerGraphs(layerGraphs,biasRight){var cg=new Graph;_.forEach(layerGraphs,function(lg){var root=lg.graph().root;var sorted=sortSubgraph(lg,root,cg,biasRight);_.forEach(sorted.vs,function(v,i){lg.node(v).order=i});addSubgraphConstraints(lg,cg,sorted.vs)})}function assignOrder(g,layering){_.forEach(layering,function(layer){_.forEach(layer,function(v,i){g.node(v).order=i})})}},{"../graphlib":7,"../lodash":10,"../util":29,"./add-subgraph-constraints":13,"./build-layer-graph":15,"./cross-count":16,
"./init-order":18,"./sort-subgraph":20}],18:[function(require,module,exports){var _=require("../lodash");module.exports=initOrder;function initOrder(g){var visited={},simpleNodes=_.filter(g.nodes(),function(v){return!g.children(v).length}),maxRank=_.max(_.map(simpleNodes,function(v){return g.node(v).rank})),layers=_.map(_.range(maxRank+1),function(){return[]});function dfs(v){if(_.has(visited,v))return;visited[v]=true;var node=g.node(v);layers[node.rank].push(v);_.forEach(g.successors(v),dfs)}var orderedVs=
_.sortBy(simpleNodes,function(v){return g.node(v).rank});_.forEach(orderedVs,dfs);return layers}},{"../lodash":10}],19:[function(require,module,exports){var _=require("../lodash");module.exports=resolveConflicts;function resolveConflicts(entries,cg){var mappedEntries={};_.forEach(entries,function(entry,i){var tmp=mappedEntries[entry.v]={indegree:0,"in":[],out:[],vs:[entry.v],i:i};if(!_.isUndefined(entry.barycenter)){tmp.barycenter=entry.barycenter;tmp.weight=entry.weight}});_.forEach(cg.edges(),function(e){var entryV=
mappedEntries[e.v],entryW=mappedEntries[e.w];if(!_.isUndefined(entryV)&&!_.isUndefined(entryW)){entryW.indegree++;entryV.out.push(mappedEntries[e.w])}});var sourceSet=_.filter(mappedEntries,function(entry){return!entry.indegree});return doResolveConflicts(sourceSet)}function doResolveConflicts(sourceSet){var entries=[];function handleIn(vEntry){return function(uEntry){if(uEntry.merged)return;if(_.isUndefined(uEntry.barycenter)||_.isUndefined(vEntry.barycenter)||uEntry.barycenter>=vEntry.barycenter)mergeEntries(vEntry,
uEntry)}}function handleOut(vEntry){return function(wEntry){wEntry["in"].push(vEntry);if(--wEntry.indegree===0)sourceSet.push(wEntry)}}while(sourceSet.length){var entry=sourceSet.pop();entries.push(entry);_.forEach(entry["in"].reverse(),handleIn(entry));_.forEach(entry.out,handleOut(entry))}return _.chain(entries).filter(function(entry){return!entry.merged}).map(function(entry){return _.pick(entry,["vs","i","barycenter","weight"])}).value()}function mergeEntries(target,source){var sum=0,weight=0;
if(target.weight){sum+=target.barycenter*target.weight;weight+=target.weight}if(source.weight){sum+=source.barycenter*source.weight;weight+=source.weight}target.vs=source.vs.concat(target.vs);target.barycenter=sum/weight;target.weight=weight;target.i=Math.min(source.i,target.i);source.merged=true}},{"../lodash":10}],20:[function(require,module,exports){var _=require("../lodash"),barycenter=require("./barycenter"),resolveConflicts=require("./resolve-conflicts"),sort=require("./sort");module.exports=
sortSubgraph;function sortSubgraph(g,v,cg,biasRight){var movable=g.children(v),node=g.node(v),bl=node?node.borderLeft:undefined,br=node?node.borderRight:undefined,subgraphs={};if(bl)movable=_.filter(movable,function(w){return w!==bl&&w!==br});var barycenters=barycenter(g,movable);_.forEach(barycenters,function(entry){if(g.children(entry.v).length){var subgraphResult=sortSubgraph(g,entry.v,cg,biasRight);subgraphs[entry.v]=subgraphResult;if(_.has(subgraphResult,"barycenter"))mergeBarycenters(entry,
subgraphResult)}});var entries=resolveConflicts(barycenters,cg);expandSubgraphs(entries,subgraphs);var result=sort(entries,biasRight);if(bl){result.vs=_.flatten([bl,result.vs,br],true);if(g.predecessors(bl).length){var blPred=g.node(g.predecessors(bl)[0]),brPred=g.node(g.predecessors(br)[0]);if(!_.has(result,"barycenter")){result.barycenter=0;result.weight=0}result.barycenter=(result.barycenter*result.weight+blPred.order+brPred.order)/(result.weight+2);result.weight+=2}}return result}function expandSubgraphs(entries,
subgraphs){_.forEach(entries,function(entry){entry.vs=_.flatten(entry.vs.map(function(v){if(subgraphs[v])return subgraphs[v].vs;return v}),true)})}function mergeBarycenters(target,other){if(!_.isUndefined(target.barycenter)){target.barycenter=(target.barycenter*target.weight+other.barycenter*other.weight)/(target.weight+other.weight);target.weight+=other.weight}else{target.barycenter=other.barycenter;target.weight=other.weight}}},{"../lodash":10,"./barycenter":14,"./resolve-conflicts":19,"./sort":21}],
21:[function(require,module,exports){var _=require("../lodash"),util=require("../util");module.exports=sort;function sort(entries,biasRight){var parts=util.partition(entries,function(entry){return _.has(entry,"barycenter")});var sortable=parts.lhs,unsortable=_.sortBy(parts.rhs,function(entry){return-entry.i}),vs=[],sum=0,weight=0,vsIndex=0;sortable.sort(compareWithBias(!!biasRight));vsIndex=consumeUnsortable(vs,unsortable,vsIndex);_.forEach(sortable,function(entry){vsIndex+=entry.vs.length;vs.push(entry.vs);
sum+=entry.barycenter*entry.weight;weight+=entry.weight;vsIndex=consumeUnsortable(vs,unsortable,vsIndex)});var result={vs:_.flatten(vs,true)};if(weight){result.barycenter=sum/weight;result.weight=weight}return result}function consumeUnsortable(vs,unsortable,index){var last;while(unsortable.length&&(last=_.last(unsortable)).i<=index){unsortable.pop();vs.push(last.vs);index++}return index}function compareWithBias(bias){return function(entryV,entryW){if(entryV.barycenter<entryW.barycenter)return-1;else if(entryV.barycenter>
entryW.barycenter)return 1;return!bias?entryV.i-entryW.i:entryW.i-entryV.i}}},{"../lodash":10,"../util":29}],22:[function(require,module,exports){var _=require("./lodash");module.exports=parentDummyChains;function parentDummyChains(g){var postorderNums=postorder(g);_.forEach(g.graph().dummyChains,function(v){var node=g.node(v),edgeObj=node.edgeObj,pathData=findPath(g,postorderNums,edgeObj.v,edgeObj.w),path=pathData.path,lca=pathData.lca,pathIdx=0,pathV=path[pathIdx],ascending=true;while(v!==edgeObj.w){node=
g.node(v);if(ascending){while((pathV=path[pathIdx])!==lca&&g.node(pathV).maxRank<node.rank)pathIdx++;if(pathV===lca)ascending=false}if(!ascending){while(pathIdx<path.length-1&&g.node(pathV=path[pathIdx+1]).minRank<=node.rank)pathIdx++;pathV=path[pathIdx]}g.setParent(v,pathV);v=g.successors(v)[0]}})}function findPath(g,postorderNums,v,w){var vPath=[],wPath=[],low=Math.min(postorderNums[v].low,postorderNums[w].low),lim=Math.max(postorderNums[v].lim,postorderNums[w].lim),parent,lca;parent=v;do{parent=
g.parent(parent);vPath.push(parent)}while(parent&&(postorderNums[parent].low>low||lim>postorderNums[parent].lim));lca=parent;parent=w;while((parent=g.parent(parent))!==lca)wPath.push(parent);return{path:vPath.concat(wPath.reverse()),lca:lca}}function postorder(g){var result={},lim=0;function dfs(v){var low=lim;_.forEach(g.children(v),dfs);result[v]={low:low,lim:lim++}}_.forEach(g.children(),dfs);return result}},{"./lodash":10}],23:[function(require,module,exports){var _=require("../lodash"),Graph=
require("../graphlib").Graph,util=require("../util");module.exports={positionX:positionX,findType1Conflicts:findType1Conflicts,findType2Conflicts:findType2Conflicts,addConflict:addConflict,hasConflict:hasConflict,verticalAlignment:verticalAlignment,horizontalCompaction:horizontalCompaction,alignCoordinates:alignCoordinates,findSmallestWidthAlignment:findSmallestWidthAlignment,balance:balance};function findType1Conflicts(g,layering){var conflicts={};function visitLayer(prevLayer,layer){var k0=0,scanPos=
0,prevLayerLength=prevLayer.length,lastNode=_.last(layer);_.forEach(layer,function(v,i){var w=findOtherInnerSegmentNode(g,v),k1=w?g.node(w).order:prevLayerLength;if(w||v===lastNode){_.forEach(layer.slice(scanPos,i+1),function(scanNode){_.forEach(g.predecessors(scanNode),function(u){var uLabel=g.node(u),uPos=uLabel.order;if((uPos<k0||k1<uPos)&&!(uLabel.dummy&&g.node(scanNode).dummy))addConflict(conflicts,u,scanNode)})});scanPos=i+1;k0=k1}});return layer}_.reduce(layering,visitLayer);return conflicts}
function findType2Conflicts(g,layering){var conflicts={};function scan(south,southPos,southEnd,prevNorthBorder,nextNorthBorder){var v;_.forEach(_.range(southPos,southEnd),function(i){v=south[i];if(g.node(v).dummy)_.forEach(g.predecessors(v),function(u){var uNode=g.node(u);if(uNode.dummy&&(uNode.order<prevNorthBorder||uNode.order>nextNorthBorder))addConflict(conflicts,u,v)})})}function visitLayer(north,south){var prevNorthPos=-1,nextNorthPos,southPos=0;_.forEach(south,function(v,southLookahead){if(g.node(v).dummy===
"border"){var predecessors=g.predecessors(v);if(predecessors.length){nextNorthPos=g.node(predecessors[0]).order;scan(south,southPos,southLookahead,prevNorthPos,nextNorthPos);southPos=southLookahead;prevNorthPos=nextNorthPos}}scan(south,southPos,south.length,nextNorthPos,north.length)});return south}_.reduce(layering,visitLayer);return conflicts}function findOtherInnerSegmentNode(g,v){if(g.node(v).dummy)return _.find(g.predecessors(v),function(u){return g.node(u).dummy})}function addConflict(conflicts,
v,w){if(v>w){var tmp=v;v=w;w=tmp}var conflictsV=conflicts[v];if(!conflictsV)conflicts[v]=conflictsV={};conflictsV[w]=true}function hasConflict(conflicts,v,w){if(v>w){var tmp=v;v=w;w=tmp}return _.has(conflicts[v],w)}function verticalAlignment(g,layering,conflicts,neighborFn){var root={},align={},pos={};_.forEach(layering,function(layer){_.forEach(layer,function(v,order){root[v]=v;align[v]=v;pos[v]=order})});_.forEach(layering,function(layer){var prevIdx=-1;_.forEach(layer,function(v){var ws=neighborFn(v);
if(ws.length){ws=_.sortBy(ws,function(w){return pos[w]});var mp=(ws.length-1)/2;for(var i=Math.floor(mp),il=Math.ceil(mp);i<=il;++i){var w=ws[i];if(align[v]===v&&prevIdx<pos[w]&&!hasConflict(conflicts,v,w)){align[w]=v;align[v]=root[v]=root[w];prevIdx=pos[w]}}}})});return{root:root,align:align}}function horizontalCompaction(g,layering,root,align,reverseSep){var xs={},blockG=buildBlockGraph(g,layering,root,reverseSep),borderType=reverseSep?"borderLeft":"borderRight";function iterate(setXsFunc,nextNodesFunc){var stack=
blockG.nodes();var elem=stack.pop();var visited={};while(elem){if(visited[elem])setXsFunc(elem);else{visited[elem]=true;stack.push(elem);stack=stack.concat(nextNodesFunc(elem))}elem=stack.pop()}}function pass1(elem){xs[elem]=blockG.inEdges(elem).reduce(function(acc,e){return Math.max(acc,xs[e.v]+blockG.edge(e))},0)}function pass2(elem){var min=blockG.outEdges(elem).reduce(function(acc,e){return Math.min(acc,xs[e.w]-blockG.edge(e))},Number.POSITIVE_INFINITY);var node=g.node(elem);if(min!==Number.POSITIVE_INFINITY&&
node.borderType!==borderType)xs[elem]=Math.max(xs[elem],min)}iterate(pass1,_.bind(blockG.predecessors,blockG));iterate(pass2,_.bind(blockG.successors,blockG));_.forEach(align,function(v){xs[v]=xs[root[v]]});return xs}function buildBlockGraph(g,layering,root,reverseSep){var blockGraph=new Graph,graphLabel=g.graph(),sepFn=sep(graphLabel.nodesep,graphLabel.edgesep,reverseSep);_.forEach(layering,function(layer){var u;_.forEach(layer,function(v){var vRoot=root[v];blockGraph.setNode(vRoot);if(u){var uRoot=
root[u],prevMax=blockGraph.edge(uRoot,vRoot);blockGraph.setEdge(uRoot,vRoot,Math.max(sepFn(g,v,u),prevMax||0))}u=v})});return blockGraph}function findSmallestWidthAlignment(g,xss){return _.minBy(_.values(xss),function(xs){var max=Number.NEGATIVE_INFINITY;var min=Number.POSITIVE_INFINITY;_.forIn(xs,function(x,v){var halfWidth=width(g,v)/2;max=Math.max(x+halfWidth,max);min=Math.min(x-halfWidth,min)});return max-min})}function alignCoordinates(xss,alignTo){var alignToVals=_.values(alignTo),alignToMin=
_.min(alignToVals),alignToMax=_.max(alignToVals);_.forEach(["u","d"],function(vert){_.forEach(["l","r"],function(horiz){var alignment=vert+horiz,xs=xss[alignment],delta;if(xs===alignTo)return;var xsVals=_.values(xs);delta=horiz==="l"?alignToMin-_.min(xsVals):alignToMax-_.max(xsVals);if(delta)xss[alignment]=_.mapValues(xs,function(x){return x+delta})})})}function balance(xss,align){return _.mapValues(xss.ul,function(ignore,v){if(align)return xss[align.toLowerCase()][v];else{var xs=_.sortBy(_.map(xss,
v));return(xs[1]+xs[2])/2}})}function positionX(g){var layering=util.buildLayerMatrix(g),conflicts=_.merge(findType1Conflicts(g,layering),findType2Conflicts(g,layering));var xss={},adjustedLayering;_.forEach(["u","d"],function(vert){adjustedLayering=vert==="u"?layering:_.values(layering).reverse();_.forEach(["l","r"],function(horiz){if(horiz==="r")adjustedLayering=_.map(adjustedLayering,function(inner){return _.values(inner).reverse()});var neighborFn=_.bind(vert==="u"?g.predecessors:g.successors,
g);var align=verticalAlignment(g,adjustedLayering,conflicts,neighborFn);var xs=horizontalCompaction(g,adjustedLayering,align.root,align.align,horiz==="r");if(horiz==="r")xs=_.mapValues(xs,function(x){return-x});xss[vert+horiz]=xs})});var smallestWidth=findSmallestWidthAlignment(g,xss);alignCoordinates(xss,smallestWidth);return balance(xss,g.graph().align)}function sep(nodeSep,edgeSep,reverseSep){return function(g,v,w){var vLabel=g.node(v),wLabel=g.node(w),sum=0,delta;sum+=vLabel.width/2;if(_.has(vLabel,
"labelpos"))switch(vLabel.labelpos.toLowerCase()){case "l":delta=-vLabel.width/2;break;case "r":delta=vLabel.width/2;break}if(delta)sum+=reverseSep?delta:-delta;delta=0;sum+=(vLabel.dummy?edgeSep:nodeSep)/2;sum+=(wLabel.dummy?edgeSep:nodeSep)/2;sum+=wLabel.width/2;if(_.has(wLabel,"labelpos"))switch(wLabel.labelpos.toLowerCase()){case "l":delta=wLabel.width/2;break;case "r":delta=-wLabel.width/2;break}if(delta)sum+=reverseSep?delta:-delta;delta=0;return sum}}function width(g,v){return g.node(v).width}
},{"../graphlib":7,"../lodash":10,"../util":29}],24:[function(require,module,exports){var _=require("../lodash"),util=require("../util"),positionX=require("./bk").positionX;module.exports=position;function position(g){g=util.asNonCompoundGraph(g);positionY(g);_.forEach(positionX(g),function(x,v){g.node(v).x=x})}function positionY(g){var layering=util.buildLayerMatrix(g),rankSep=g.graph().ranksep,prevY=0;_.forEach(layering,function(layer){var maxHeight=_.max(_.map(layer,function(v){return g.node(v).height}));
_.forEach(layer,function(v){g.node(v).y=prevY+maxHeight/2});prevY+=maxHeight+rankSep})}},{"../lodash":10,"../util":29,"./bk":23}],25:[function(require,module,exports){var _=require("../lodash"),Graph=require("../graphlib").Graph,slack=require("./util").slack;module.exports=feasibleTree;function feasibleTree(g){var t=new Graph({directed:false});var start=g.nodes()[0],size=g.nodeCount();t.setNode(start,{});var edge,delta;while(tightTree(t,g)<size){edge=findMinSlackEdge(t,g);delta=t.hasNode(edge.v)?
slack(g,edge):-slack(g,edge);shiftRanks(t,g,delta)}return t}function tightTree(t,g){function dfs(v){_.forEach(g.nodeEdges(v),function(e){var edgeV=e.v,w=v===edgeV?e.w:edgeV;if(!t.hasNode(w)&&!slack(g,e)){t.setNode(w,{});t.setEdge(v,w,{});dfs(w)}})}_.forEach(t.nodes(),dfs);return t.nodeCount()}function findMinSlackEdge(t,g){return _.minBy(g.edges(),function(e){if(t.hasNode(e.v)!==t.hasNode(e.w))return slack(g,e)})}function shiftRanks(t,g,delta){_.forEach(t.nodes(),function(v){g.node(v).rank+=delta})}
},{"../graphlib":7,"../lodash":10,"./util":28}],26:[function(require,module,exports){var rankUtil=require("./util"),longestPath=rankUtil.longestPath,feasibleTree=require("./feasible-tree"),networkSimplex=require("./network-simplex");module.exports=rank;function rank(g){switch(g.graph().ranker){case "network-simplex":networkSimplexRanker(g);break;case "tight-tree":tightTreeRanker(g);break;case "longest-path":longestPathRanker(g);break;default:networkSimplexRanker(g)}}var longestPathRanker=longestPath;
function tightTreeRanker(g){longestPath(g);feasibleTree(g)}function networkSimplexRanker(g){networkSimplex(g)}},{"./feasible-tree":25,"./network-simplex":27,"./util":28}],27:[function(require,module,exports){var _=require("../lodash"),feasibleTree=require("./feasible-tree"),slack=require("./util").slack,initRank=require("./util").longestPath,preorder=require("../graphlib").alg.preorder,postorder=require("../graphlib").alg.postorder,simplify=require("../util").simplify;module.exports=networkSimplex;
networkSimplex.initLowLimValues=initLowLimValues;networkSimplex.initCutValues=initCutValues;networkSimplex.calcCutValue=calcCutValue;networkSimplex.leaveEdge=leaveEdge;networkSimplex.enterEdge=enterEdge;networkSimplex.exchangeEdges=exchangeEdges;function networkSimplex(g){g=simplify(g);initRank(g);var t=feasibleTree(g);initLowLimValues(t);initCutValues(t,g);var e,f;while(e=leaveEdge(t)){f=enterEdge(t,g,e);exchangeEdges(t,g,e,f)}}function initCutValues(t,g){var vs=postorder(t,t.nodes());vs=vs.slice(0,
vs.length-1);_.forEach(vs,function(v){assignCutValue(t,g,v)})}function assignCutValue(t,g,child){var childLab=t.node(child),parent=childLab.parent;t.edge(child,parent).cutvalue=calcCutValue(t,g,child)}function calcCutValue(t,g,child){var childLab=t.node(child),parent=childLab.parent,childIsTail=true,graphEdge=g.edge(child,parent),cutValue=0;if(!graphEdge){childIsTail=false;graphEdge=g.edge(parent,child)}cutValue=graphEdge.weight;_.forEach(g.nodeEdges(child),function(e){var isOutEdge=e.v===child,other=
isOutEdge?e.w:e.v;if(other!==parent){var pointsToHead=isOutEdge===childIsTail,otherWeight=g.edge(e).weight;cutValue+=pointsToHead?otherWeight:-otherWeight;if(isTreeEdge(t,child,other)){var otherCutValue=t.edge(child,other).cutvalue;cutValue+=pointsToHead?-otherCutValue:otherCutValue}}});return cutValue}function initLowLimValues(tree,root){if(arguments.length<2)root=tree.nodes()[0];dfsAssignLowLim(tree,{},1,root)}function dfsAssignLowLim(tree,visited,nextLim,v,parent){var low=nextLim,label=tree.node(v);
visited[v]=true;_.forEach(tree.neighbors(v),function(w){if(!_.has(visited,w))nextLim=dfsAssignLowLim(tree,visited,nextLim,w,v)});label.low=low;label.lim=nextLim++;if(parent)label.parent=parent;else delete label.parent;return nextLim}function leaveEdge(tree){return _.find(tree.edges(),function(e){return tree.edge(e).cutvalue<0})}function enterEdge(t,g,edge){var v=edge.v,w=edge.w;if(!g.hasEdge(v,w)){v=edge.w;w=edge.v}var vLabel=t.node(v),wLabel=t.node(w),tailLabel=vLabel,flip=false;if(vLabel.lim>wLabel.lim){tailLabel=
wLabel;flip=true}var candidates=_.filter(g.edges(),function(edge){return flip===isDescendant(t,t.node(edge.v),tailLabel)&&flip!==isDescendant(t,t.node(edge.w),tailLabel)});return _.minBy(candidates,function(edge){return slack(g,edge)})}function exchangeEdges(t,g,e,f){var v=e.v,w=e.w;t.removeEdge(v,w);t.setEdge(f.v,f.w,{});initLowLimValues(t);initCutValues(t,g);updateRanks(t,g)}function updateRanks(t,g){var root=_.find(t.nodes(),function(v){return!g.node(v).parent}),vs=preorder(t,root);vs=vs.slice(1);
_.forEach(vs,function(v){var parent=t.node(v).parent,edge=g.edge(v,parent),flipped=false;if(!edge){edge=g.edge(parent,v);flipped=true}g.node(v).rank=g.node(parent).rank+(flipped?edge.minlen:-edge.minlen)})}function isTreeEdge(tree,u,v){return tree.hasEdge(u,v)}function isDescendant(tree,vLabel,rootLabel){return rootLabel.low<=vLabel.lim&&vLabel.lim<=rootLabel.lim}},{"../graphlib":7,"../lodash":10,"../util":29,"./feasible-tree":25,"./util":28}],28:[function(require,module,exports){var _=require("../lodash");
module.exports={longestPath:longestPath,slack:slack};function longestPath(g){var visited={};function dfs(v){var label=g.node(v);if(_.has(visited,v))return label.rank;visited[v]=true;var rank=_.minBy(_.map(g.outEdges(v),function(e){return dfs(e.w)-g.edge(e).minlen}));if(rank===Number.POSITIVE_INFINITY||rank===undefined||rank===null)rank=0;return label.rank=rank}_.forEach(g.sources(),dfs)}function slack(g,e){return g.node(e.w).rank-g.node(e.v).rank-g.edge(e).minlen}},{"../lodash":10}],29:[function(require,
module,exports){var _=require("./lodash"),Graph=require("./graphlib").Graph;module.exports={addDummyNode:addDummyNode,simplify:simplify,asNonCompoundGraph:asNonCompoundGraph,successorWeights:successorWeights,predecessorWeights:predecessorWeights,intersectRect:intersectRect,buildLayerMatrix:buildLayerMatrix,normalizeRanks:normalizeRanks,removeEmptyRanks:removeEmptyRanks,addBorderNode:addBorderNode,maxRank:maxRank,partition:partition,time:time,notime:notime};function addDummyNode(g,type,attrs,name){var v;
do v=_.uniqueId(name);while(g.hasNode(v));attrs.dummy=type;g.setNode(v,attrs);return v}function simplify(g){var simplified=(new Graph).setGraph(g.graph());_.forEach(g.nodes(),function(v){simplified.setNode(v,g.node(v))});_.forEach(g.edges(),function(e){var simpleLabel=simplified.edge(e.v,e.w)||{weight:0,minlen:1},label=g.edge(e);simplified.setEdge(e.v,e.w,{weight:simpleLabel.weight+label.weight,minlen:Math.max(simpleLabel.minlen,label.minlen)})});return simplified}function asNonCompoundGraph(g){var simplified=
(new Graph({multigraph:g.isMultigraph()})).setGraph(g.graph());_.forEach(g.nodes(),function(v){if(!g.children(v).length)simplified.setNode(v,g.node(v))});_.forEach(g.edges(),function(e){simplified.setEdge(e,g.edge(e))});return simplified}function successorWeights(g){var weightMap=_.map(g.nodes(),function(v){var sucs={};_.forEach(g.outEdges(v),function(e){sucs[e.w]=(sucs[e.w]||0)+g.edge(e).weight});return sucs});return _.zipObject(g.nodes(),weightMap)}function predecessorWeights(g){var weightMap=_.map(g.nodes(),
function(v){var preds={};_.forEach(g.inEdges(v),function(e){preds[e.v]=(preds[e.v]||0)+g.edge(e).weight});return preds});return _.zipObject(g.nodes(),weightMap)}function intersectRect(rect,point){var x=rect.x;var y=rect.y;var dx=point.x-x;var dy=point.y-y;var w=rect.width/2;var h=rect.height/2;if(!dx&&!dy)throw new Error("Not possible to find intersection inside of the rectangle");var sx,sy;if(Math.abs(dy)*w>Math.abs(dx)*h){if(dy<0)h=-h;sx=h*dx/dy;sy=h}else{if(dx<0)w=-w;sx=w;sy=w*dy/dx}return{x:x+
sx,y:y+sy}}function buildLayerMatrix(g){var layering=_.map(_.range(maxRank(g)+1),function(){return[]});_.forEach(g.nodes(),function(v){var node=g.node(v),rank=node.rank;if(!_.isUndefined(rank))layering[rank][node.order]=v});return layering}function normalizeRanks(g){var min=_.minBy(_.map(g.nodes(),function(v){return g.node(v).rank}));_.forEach(g.nodes(),function(v){var node=g.node(v);if(_.has(node,"rank"))node.rank-=min})}function removeEmptyRanks(g){var offset=_.minBy(_.map(g.nodes(),function(v){return g.node(v).rank}));
var layers=[];_.forEach(g.nodes(),function(v){var rank=g.node(v).rank-offset;if(!layers[rank])layers[rank]=[];layers[rank].push(v)});var delta=0,nodeRankFactor=g.graph().nodeRankFactor;_.forEach(layers,function(vs,i){if(_.isUndefined(vs)&&i%nodeRankFactor!==0)--delta;else if(delta)_.forEach(vs,function(v){g.node(v).rank+=delta})})}function addBorderNode(g,prefix,rank,order){var node={width:0,height:0};if(arguments.length>=4){node.rank=rank;node.order=order}return addDummyNode(g,"border",node,prefix)}
function maxRank(g){return _.max(_.map(g.nodes(),function(v){var rank=g.node(v).rank;if(!_.isUndefined(rank))return rank}))}function partition(collection,fn){var result={lhs:[],rhs:[]};_.forEach(collection,function(value){if(fn(value))result.lhs.push(value);else result.rhs.push(value)});return result}function time(name,fn){var start=_.now();try{return fn()}finally{console.log(name+" time: "+(_.now()-start)+"ms")}}function notime(name,fn){return fn()}},{"./graphlib":7,"./lodash":10}],30:[function(require,
module,exports){module.exports="0.8.2"},{}]},{},[1])(1)});
//# sourceURL=build://tf-graph-common/annotation.js
var tf;
(function(b){(function(d){(function(f){(function(h){function k(q){return(d.render.AnnotationType[q]||"").toLowerCase()||null}function t(q,u){u.annotationType===d.render.AnnotationType.SUMMARY?f.selectOrCreateChild(q,"use").attr("class","summary").attr("xlink:href","#summary-icon").attr("cursor","pointer"):(q=f.node.buildShape(q,u,f.Class.Annotation.NODE),f.selectOrCreateChild(q,"title").text(u.node.name))}function l(q,u){let x=u.node.name.split("/");return p(q,x[x.length-1],u,null)}function p(q,u,
x,A){let y=f.Class.Annotation.LABEL;A&&(y+=" "+A);q=q.append("text").attr("class",y).attr("dy",".35em").attr("text-anchor",x.isIn?"end":"start").text(u);return b.graph.scene.node.enforceLabelWidth(q,-1)}function m(q,u,x,A){q.on("mouseover",y=>{A.fire("annotation-highlight",{name:y.node.name,hostName:u.node.name})}).on("mouseout",y=>{A.fire("annotation-unhighlight",{name:y.node.name,hostName:u.node.name})}).on("click",y=>{d3.event.stopPropagation();A.fire("annotation-select",{name:y.node.name,hostName:u.node.name})});
if(x.annotationType!==d.render.AnnotationType.SUMMARY&&x.annotationType!==d.render.AnnotationType.CONSTANT)q.on("contextmenu",f.contextmenu.getMenu(A,f.node.getContextMenu(x.node,A)))}function n(q,u,x,A){let y=d.layout.computeCXPositionOfNodeShape(u);x.renderNodeInfo&&x.annotationType!==d.render.AnnotationType.ELLIPSIS&&f.node.stylize(q,x.renderNodeInfo,A,f.Class.Annotation.NODE);x.annotationType===d.render.AnnotationType.SUMMARY&&(x.width+=10);q.select("text."+f.Class.Annotation.LABEL).transition().attr("x",
y+x.dx+(x.isIn?-1:1)*(x.width/2+x.labelOffset)).attr("y",u.y+x.dy);q.select("use.summary").transition().attr("x",y+x.dx-3).attr("y",u.y+x.dy-6);f.positionEllipse(q.select("."+f.Class.Annotation.NODE+" ellipse"),y+x.dx,u.y+x.dy,x.width,x.height);f.positionRect(q.select("."+f.Class.Annotation.NODE+" rect"),y+x.dx,u.y+x.dy,x.width,x.height);f.positionRect(q.select("."+f.Class.Annotation.NODE+" use"),y+x.dx,u.y+x.dy,x.width,x.height);q.select("path."+f.Class.Annotation.EDGE).transition().attr("d",w=>
{w=w.points.map(C=>({x:C.dx+y,y:C.dy+u.y}));return f.edge.interpolate(w)})}h.buildGroup=function(q,u,x,A){q=q.selectAll(function(){return this.childNodes}).data(u.list,y=>y.node.name);q.enter().append("g").attr("data-name",y=>y.node.name).each(function(y){let w=d3.select(this);A.addAnnotationGroup(y,x,w);let C=f.Class.Annotation.EDGE,G=y.renderMetaedgeInfo&&y.renderMetaedgeInfo.metaedge;G&&!G.numRegularEdges&&(C+=" "+f.Class.Annotation.CONTROL_EDGE);G&&G.numRefEdges&&(C+=" "+f.Class.Edge.REF_LINE);
f.edge.appendEdge(w,y,A,C);y.annotationType!==d.render.AnnotationType.ELLIPSIS?(l(w,y),t(w,y)):p(w,y.node.name,y,f.Class.Annotation.ELLIPSIS)}).merge(q).attr("class",y=>f.Class.Annotation.GROUP+" "+k(y.annotationType)+" "+f.node.nodeClass(y)).each(function(y){let w=d3.select(this);n(w,x,y,A);y.annotationType!==d.render.AnnotationType.ELLIPSIS&&m(w,x,y,A)});q.exit().each(function(y){let w=d3.select(this);A.removeAnnotationGroup(y,x,w)}).remove();return q}})(f.annotation||(f.annotation={}))})(d.scene||
(d.scene={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/colors.js
(function(b){b.COLORS=[{name:"Google Blue",color:"#4184f3",active:"#3a53c5",disabled:"#cad8fc"},{name:"Google Red",color:"#db4437",active:"#8f2a0c",disabled:"#e8c6c1"},{name:"Google Yellow",color:"#f4b400",active:"#db9200",disabled:"#f7e8b0"},{name:"Google Green",color:"#0f9d58",active:"#488046",disabled:"#c2e1cc"},{name:"Purple",color:"#aa46bb",active:"#5c1398",disabled:"#d7bce6"},{name:"Teal",color:"#00abc0",active:"#47828e",disabled:"#c2eaf2"},{name:"Deep Orange",color:"#ff6f42",active:"#ca4a06",
disabled:"#f2cbba"},{name:"Lime",color:"#9d9c23",active:"#7f771d",disabled:"#f1f4c2"},{name:"Indigo",color:"#5b6abf",active:"#3e47a9",disabled:"#c5c8e8"},{name:"Pink",color:"#ef6191",active:"#ca1c60",disabled:"#e9b9ce"},{name:"Deep Teal",color:"#00786a",active:"#2b4f43",disabled:"#bededa"},{name:"Deep Pink",color:"#c1175a",active:"#75084f",disabled:"#de8cae"},{name:"Gray",color:"#9E9E9E",active:"#424242",disabled:"F5F5F5"}].reduce((d,f)=>{d[f.name]=f;return d},{});b.OP_GROUP_COLORS=[{color:"Google Red",
groups:"gen_legacy_ops legacy_ops legacy_flogs_input legacy_image_input legacy_input_example_input legacy_sequence_input legacy_seti_input_input".split(" ")},{color:"Deep Orange",groups:["constant_ops"]},{color:"Indigo",groups:["state_ops"]},{color:"Purple",groups:["nn_ops","nn"]},{color:"Google Green",groups:["math_ops"]},{color:"Lime",groups:["array_ops"]},{color:"Teal",groups:["control_flow_ops","data_flow_ops"]},{color:"Pink",groups:["summary_ops"]},{color:"Deep Pink",groups:["io_ops"]}].reduce((d,
f)=>{f.groups.forEach(function(h){d[h]=f.color});return d},{})})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/common.js
(function(b){(function(d){(function(f){f.OP_GRAPH="op_graph";f.CONCEPTUAL_GRAPH="conceptual_graph";f.PROFILE="profile"})(d.SelectionType||(d.SelectionType={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/contextmenu.js
(function(b){(function(d){(function(f){(function(h){function k(t){let l=0,p=0;for(;t&&0<=t.offsetLeft&&0<=t.offsetTop;)l+=t.offsetLeft-t.scrollLeft,p+=t.offsetTop-t.scrollTop,t=t.offsetParent;return{left:l,top:p}}h.getMenu=function(t,l){const p=t.getContextMenu(),m=d3.select(t.getContextMenu());return function(n,q){function u(y){y&&y.composedPath().includes(p)||(m.style("display","none"),document.body.removeEventListener("mousedown",u,{capture:!0}))}let x=d3.event;const A=k(t);m.style("display","block").style("left",
x.clientX-A.left+1+"px").style("top",x.clientY-A.top+1+"px");x.preventDefault();x.stopPropagation();document.body.addEventListener("mousedown",u,{capture:!0});m.html("");m.append("ul").selectAll("li").data(l).enter().append("li").on("click",y=>{y.action(this,n,q);u()}).html(function(y){return y.title(n)})}}})(f.contextmenu||(f.contextmenu={}))})(d.scene||(d.scene={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/edge.js
(function(b){(function(d){(function(f){(function(h){function k(y){return y.v+d.EDGE_KEY_DELIM+y.w}function t(y,w){w=w.getNodeByName(y.v);if(null==w.outputShapes||_.isEmpty(w.outputShapes))return null;y=w.outputShapes[y.outputTensorKey];return null==y?null:0===y.length?"scalar":y.map(C=>-1===C?"?":C).join("\u00d7")}function l(y,w){return w.edgeLabelFunction?w.edgeLabelFunction(y,w):1<y.baseEdgeList.length?y.baseEdgeList.length+" tensors":t(y.baseEdgeList[0],w)}function p(y,w,C){const G=document.createElementNS(b.graph.scene.SVG_NAMESPACE,
"path");for(let D=1;D<y.length;D++)if(G.setAttribute("d",C(y.slice(0,D))),G.getTotalLength()>w)return D-1;return y.length-1}function m(y,w,C){var G=d3.line().x(N=>N.x).y(N=>N.y),D=d3.select(document.createElementNS("http://www.w3.org/2000/svg","path")).attr("d",G(y)),B=+w.attr("markerWidth"),I=w.attr("viewBox").split(" ").map(Number);I=I[2]-I[0];w=+w.attr("refX");D=D.node();if(C)return B*=1-w/I,C=D.getPointAtLength(B),G=p(y,B,G),y[G-1]={x:C.x,y:C.y},y.slice(G-1);C=1-w/I;B=D.getTotalLength()-B*C;C=
D.getPointAtLength(B);G=p(y,B,G);y[G]={x:C.x,y:C.y};return y.slice(0,G+1)}function n(y,w,C,G){G=G||f.Class.Edge.LINE;w.label&&w.label.structural&&(G+=" "+f.Class.Edge.STRUCTURAL);w.label&&w.label.metaedge&&w.label.metaedge.numRefEdges&&(G+=" "+f.Class.Edge.REFERENCE_EDGE);C.handleEdgeSelected&&(G+=" "+f.Class.Edge.SELECTABLE);let D="path_"+k(w);if(C.renderHierarchy.edgeWidthFunction)var B=C.renderHierarchy.edgeWidthFunction(w,G);else B=1,null!=w.label&&null!=w.label.metaedge&&(B=w.label.metaedge.totalSize),
B=C.renderHierarchy.edgeWidthSizedBasedScale(B);G=y.append("path").attr("id",D).attr("class",G).style("stroke-width",B+"px");w.label&&w.label.metaedge&&(w.label.metaedge.numRefEdges?(B=`reference-arrowhead-${A(B)}`,G.style("marker-start",`url(#${B})`),w.label.startMarkerId=B):(B=`dataflow-arrowhead-${A(B)}`,G.style("marker-end",`url(#${B})`),w.label.endMarkerId=B));null!=w.label&&null!=w.label.metaedge&&(w=l(w.label.metaedge,C.renderHierarchy),null!=w&&y.append("text").append("textPath").attr("xlink:href",
"#"+D).attr("startOffset","50%").attr("text-anchor","middle").attr("dominant-baseline","central").text(w))}function q(y,w,C,G,D){G=C.label;let B=G.adjoiningMetaedge,I=G.points;y=y.shadowRoot;C.label.startMarkerId&&(I=m(I,d3.select(y.querySelector("#"+C.label.startMarkerId)),!0));C.label.endMarkerId&&(I=m(I,d3.select(y.querySelector("#"+C.label.endMarkerId)),!1));if(!B)return d3.interpolate(D,h.interpolate(I));let N=B.edgeGroup.node().firstChild,O=G.metaedge.inbound;return function(){let H=N.getPointAtLength(O?
N.getTotalLength():0).matrixTransform(N.getCTM()).matrixTransform(w.getCTM().inverse()),K=O?0:I.length-1;I[K].x=H.x;I[K].y=H.y;return h.interpolate(I)}}function u(y,w){d3.select(w).select("path."+f.Class.Edge.LINE).transition().attrTween("d",function(C,G,D){return q(y,this,C,G,D)})}function x(y,w){y.classed("faded",w.label.isFadedOut);w=w.label.metaedge;y.select("path."+f.Class.Edge.LINE).classed("control-dep",w&&!w.numRegularEdges)}h.MIN_EDGE_WIDTH=.75;h.MAX_EDGE_WIDTH=12;h.EDGE_WIDTH_SIZE_BASED_SCALE=
d3.scalePow().exponent(.3).domain([1,5E6]).range([h.MIN_EDGE_WIDTH,h.MAX_EDGE_WIDTH]).clamp(!0);let A=d3.scaleQuantize().domain([h.MIN_EDGE_WIDTH,h.MAX_EDGE_WIDTH]).range(["small","medium","large","xlarge"]);h.getEdgeKey=k;h.buildGroup=function(y,w,C){let G=[];G=_.reduce(w.edges(),(D,B)=>{let I=w.edge(B);D.push({v:B.v,w:B.w,label:I});return D},G);y=f.selectOrCreateChild(y,"g",f.Class.Edge.CONTAINER).selectAll(function(){return this.childNodes}).data(G,k);y.enter().append("g").attr("class",f.Class.Edge.GROUP).attr("data-edge",
k).each(function(D){let B=d3.select(this);D.label.edgeGroup=B;C._edgeGroupIndex[k(D)]=B;if(C.handleEdgeSelected)B.on("click",I=>{d3.event.stopPropagation();C.fire("edge-select",{edgeData:I,edgeGroup:B})});n(B,D,C)}).merge(y).each(function(){u(C,this)}).each(function(D){x(d3.select(this),D,C)});y.exit().each(D=>{delete C._edgeGroupIndex[k(D)]}).remove();return y};h.getLabelForBaseEdge=t;h.getLabelForEdge=l;h.appendEdge=n;h.interpolate=d3.line().curve(d3.curveBasis).x(y=>y.x).y(y=>y.y)})(f.edge||(f.edge=
{}))})(d.scene||(d.scene={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/externs.js

//# sourceURL=build://tf-graph-common/graph.js
(function(b){(function(d){function f(H,K,M,L,Q){return(M?M+"/":"")+(H+("undefined"!==typeof L&&"undefined"!==typeof Q?"["+L+"-"+Q+"]":"#")+K)}function h(H){if(!H)return null;for(let K=0;K<H.length;K++){let {key:M,value:L}=H[K];if("_output_shapes"===M){if(!L.list.shape)break;let Q=L.list.shape.map(T=>T.unknown_rank?null:null==T.dim||1===T.dim.length&&null==T.dim[0].size?[]:T.dim.map(X=>X.size));H.splice(K,1);return Q}}return null}function k(H){if(!H)return null;for(let K=0;K<H.length;K++)if("_XlaCluster"===
H[K].key)return H[K].value.s||null;return null}function t(H){let K=[];_.each(H,M=>{let L="^"===M[0];L&&(M=M.substring(1));let Q=M,T="0",X=M.match(/(.*):(\w+:\d+)$/);if(X)Q=X[1],T=X[2];else if(X=M.match(/(.*):(\d+)$/))Q=X[1],T=X[2];0!==K.length&&Q===K[K.length-1].name||K.push({name:Q,outputTensorKey:T,isControlDependency:L})});return K}function l(H,K,M,L,Q,T){K!==M.name&&H.edges.push({v:K,w:M.name,outputTensorKey:L.outputTensorKey,isControlDependency:L.isControlDependency,isReferenceEdge:!0===Q.refEdges[M.op+
" "+T]})}function p(H,K,M){M=M||{};let L=new graphlib.Graph(M);L.setGraph({name:H,rankdir:M.rankdir||"BT",type:K});return L}function m(H){return function(K){for(let M=0;M<H.length;M++){let L=new RegExp(H[M]);if("string"===typeof K.op&&K.op.match(L))return!0}return!1}}function n(H){let K=H.split(d.NAMESPACE_DELIM);return H+d.NAMESPACE_DELIM+"("+K[K.length-1]+")"}function q(H,K){let M={},L={};H.sort();for(let Q=0;Q<H.length-1;++Q){let T=H[Q];_.each(x(T).slice(0,-1),X=>{L[X]=!0});for(let X=Q+1;X<H.length;++X){let aa=
H[X];if(_.startsWith(aa,T)){if(aa.length>T.length&&aa.charAt(T.length)===d.NAMESPACE_DELIM){M[T]=n(T);break}}else break}}_.each(K,Q=>{Q in L&&(M[Q]=n(Q))});return M}function u(H){let K=H.nodes().map(function(M){return H.neighbors(M).length});K.sort();return K}function x(H,K){let M=[],L=H.indexOf(d.NAMESPACE_DELIM);for(;0<=L;)M.push(H.substring(0,L)),L=H.indexOf(d.NAMESPACE_DELIM,L+1);K&&(K=K[H])&&M.push(K);M.push(H);return M}d.NAMESPACE_DELIM="/";d.ROOT_NAME="__root__";d.FUNCTION_LIBRARY_NODE_PREFIX=
"__function_library__";d.LARGE_ATTRS_KEY="_too_large_attrs";d.LIMIT_ATTR_SIZE=1024;d.EDGE_KEY_DELIM="--";let A;(function(H){H[H.FULL=0]="FULL";H[H.EMBEDDED=1]="EMBEDDED";H[H.META=2]="META";H[H.SERIES=3]="SERIES";H[H.CORE=4]="CORE";H[H.SHADOW=5]="SHADOW";H[H.BRIDGE=6]="BRIDGE";H[H.EDGE=7]="EDGE"})(A=d.GraphType||(d.GraphType={}));let y;(function(H){H[H.META=0]="META";H[H.OP=1]="OP";H[H.SERIES=2]="SERIES";H[H.BRIDGE=3]="BRIDGE";H[H.ELLIPSIS=4]="ELLIPSIS"})(y=d.NodeType||(d.NodeType={}));let w;(function(H){H[H.INCLUDE=
0]="INCLUDE";H[H.EXCLUDE=1]="EXCLUDE";H[H.UNSPECIFIED=2]="UNSPECIFIED"})(w=d.InclusionType||(d.InclusionType={}));(function(H){H[H.GROUP=0]="GROUP";H[H.UNGROUP=1]="UNGROUP"})(d.SeriesGroupingType||(d.SeriesGroupingType={}));class C{constructor(){this.nodes={};this.edges=[]}}d.SlimGraph=C;class G{constructor(H){this.type=y.ELLIPSIS;this.isGroupNode=!1;this.cardinality=1;this.stats=this.parentNode=null;this.setNumMoreNodes(H);this.include=w.UNSPECIFIED}setNumMoreNodes(H){this.numMoreNodes=H;this.name=
"... "+H+" more"}}d.EllipsisNodeImpl=G;class D{constructor(H){this.op=H.op;this.name=H.name;this.device=H.device;this.attr=H.attr;this.inputs=t(H.input);this.outputShapes=h(H.attr);this.xlaCluster=k(H.attr);this.compatible=!1;this.type=y.OP;this.isGroupNode=!1;this.cardinality=1;this.inEmbeddings=[];this.outEmbeddings=[];this.parentNode=null;this.include=w.UNSPECIFIED;this.owningSeries=null}}d.OpNodeImpl=D;d.createMetanode=function(H,K={}){return new I(H,K)};d.joinStatsInfoWithGraph=function(H,K,
M){_.each(H.nodes,L=>{L.stats=null});_.each(K.dev_stats,L=>{M&&!M[L.device]||_.each(L.node_stats,Q=>{let T=Q.node_name in H.nodes?Q.node_name:n(Q.node_name);if(T in H.nodes){var X=0;Q.memory&&_.each(Q.memory,la=>{la.total_bytes&&(0<la.total_bytes?X+=Number(la.total_bytes):console.log("ignoring negative memory allocation for "+T))});var aa=null;Q.output&&(aa=_.map(Q.output,la=>_.map(la.tensor_description.shape.dim,Z=>Number(Z.size))));H.nodes[T].device=L.device;null==H.nodes[T].stats&&(H.nodes[T].stats=
new B(aa));H.nodes[T].stats.addBytesAllocation(X);Q.all_end_rel_micros&&(0<Q.all_end_rel_micros?H.nodes[T].stats.addExecutionTime(Q.all_start_micros,Q.all_start_micros+Q.all_end_rel_micros):console.log("ignoring negative runtime for "+T))}})})};class B{constructor(H){this.totalBytes=0;this.outputSize=H}addExecutionTime(H,K){this.startTime=null!=this.startTime?Math.min(this.startTime,H):H;this.endTime=null!=this.endTime?Math.max(this.endTime,K):K}addBytesAllocation(H){this.totalBytes=null!=this.totalBytes?
Math.max(this.totalBytes,H):H}combine(H){null!=H.totalBytes&&(this.totalBytes+=H.totalBytes);null!=H.getTotalMicros()&&this.addExecutionTime(H.startTime,H.endTime)}getTotalMicros(){return null==this.startTime||null==this.endTime?null:this.endTime-this.startTime}}d.NodeStats=B;class I{constructor(H,K={}){this.name=H;this.type=y.META;this.depth=1;this.isGroupNode=!0;this.cardinality=0;this.metagraph=p(H,A.META,K);this.bridgegraph=null;this.opHistogram={};this.deviceHistogram={};this.xlaClusterHistogram=
{};this.compatibilityHistogram={compatible:0,incompatible:0};this.parentNode=this.templateId=null;this.hasNonControlEdges=!1;this.include=w.UNSPECIFIED;this.associatedFunction=""}getFirstChild(){return this.metagraph.node(this.metagraph.nodes()[0])}getRootOp(){let H=this.name.split("/");return this.metagraph.node(this.name+"/("+H[H.length-1]+")")}leaves(){let H=[],K=[this],M;for(;K.length;){let L=K.shift();L.isGroupNode?(M=L.metagraph,_.each(M.nodes(),Q=>K.push(M.node(Q)))):H.push(L.name)}return H}}
d.MetanodeImpl=I;d.createMetaedge=function(H,K){return new N(H,K)};class N{constructor(H,K){this.v=H;this.w=K;this.baseEdgeList=[];this.inbound=null;this.totalSize=this.numRefEdges=this.numControlEdges=this.numRegularEdges=0}addBaseEdge(H,K){this.baseEdgeList.push(H);H.isControlDependency?this.numControlEdges+=1:this.numRegularEdges+=1;H.isReferenceEdge&&(this.numRefEdges+=1);this.totalSize+=N.computeSizeOfEdge(H,K);K.maxMetaEdgeSize=Math.max(K.maxMetaEdgeSize,this.totalSize)}static computeSizeOfEdge(H,
K){let M=K.node(H.v);if(!M.outputShapes)return 1;K.hasShapeInfo=!0;H=Object.keys(M.outputShapes).map(L=>M.outputShapes[L]).map(L=>null==L?1:L.reduce((Q,T)=>{-1===T&&(T=1);return Q*T},1));return _.sum(H)}}d.MetaedgeImpl=N;d.createSeriesNode=function(H,K,M,L,Q,T){return new O(H,K,M,L,Q,T)};d.getSeriesNodeName=f;class O{constructor(H,K,M,L,Q,T){this.name=Q||f(H,K,M);this.type=y.SERIES;this.hasLoop=!1;this.prefix=H;this.suffix=K;this.clusterId=L;this.ids=[];this.parent=M;this.isGroupNode=!0;this.cardinality=
0;this.metagraph=p(Q,A.SERIES,T);this.parentNode=this.bridgegraph=null;this.deviceHistogram={};this.xlaClusterHistogram={};this.compatibilityHistogram={compatible:0,incompatible:0};this.hasNonControlEdges=!1;this.include=w.UNSPECIFIED}}d.DefaultBuildParams={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}};d.build=function(H,K,M){let L={},Q={},T={},X=m(K.inEmbeddingTypes),aa=m(K.outEmbeddingTypes),la=[],Z=H.node,ba=Array(Z.length);return b.graph.util.runAsyncTask("Normalizing names",30,()=>{let ea=Array(Z.length),ca=0;const ka=Ea=>{let va=new D(Ea);if(X(va))return la.push(va.name),L[va.name]=va;if(aa(va))return la.push(va.name),Q[va.name]=va,_.each(va.inputs,xa=>{xa=xa.name;T[xa]=T[xa]||[];T[xa].push(va)}),va;ea[ca]=
va;ba[ca]=va.name;ca++;return va};_.each(Z,ka);const Y=Ea=>{const va=d.FUNCTION_LIBRARY_NODE_PREFIX+Ea.signature.name;ka({name:va,input:[],device:"",op:"",attr:[]});if(Ea.signature.input_arg){let ya=0;var xa=Sa=>{ka({name:va+d.NAMESPACE_DELIM+Sa.name,input:[],device:"",op:"input_arg",attr:[{key:"T",value:{type:Sa.type}}]}).functionInputIndex=ya;ya++};Ea.signature.input_arg.name?xa(Ea.signature.input_arg):_.each(Ea.signature.input_arg,xa)}let Aa=0;const Fa={};Ea.signature.output_arg&&(xa=ya=>{Fa[va+
d.NAMESPACE_DELIM+ya.name]=Aa;Aa++},Ea.signature.output_arg.name?xa(Ea.signature.output_arg):_.each(Ea.signature.output_arg,xa));_.each(Ea.node_def,ya=>{ya.name=va+"/"+ya.name;"string"===typeof ya.input&&(ya.input=[ya.input]);const Sa=ka(ya);_.isNumber(Fa[ya.name])&&(Sa.functionOutputIndex=Fa[ya.name]);_.each(Sa.inputs,Xa=>{Xa.name=va+d.NAMESPACE_DELIM+Xa.name})})};H.library&&H.library.function&&_.each(H.library.function,Y);ea.splice(ca);ba.splice(ca);return ea},M).then(ea=>b.graph.util.runAsyncTask("Building the data structure",
70,()=>{let ca=q(ba,la),ka=new C;_.each(ea,Y=>{let Ea=ca[Y.name]||Y.name;ka.nodes[Ea]=Y;Y.name in T&&(Y.outEmbeddings=T[Y.name],_.each(Y.outEmbeddings,va=>{va.name=ca[va.name]||va.name}));Y.name=Ea});_.each(ea,Y=>{_.each(Y.inputs,(Ea,va)=>{let xa=Ea.name;if(xa in L){Ea=L[xa];Y.inEmbeddings.push(Ea);for(var Aa of Ea.inputs)l(ka,ca[Aa.name]||Aa.name,Y,Aa,K,va)}else if(xa in Q){Aa=Q[xa];for(let Fa of Aa.inputs)l(ka,ca[Fa.name]||Fa.name,Y,Ea,K,va)}else l(ka,ca[xa]||xa,Y,Ea,K,va)})});_.each(L,Y=>{Y.name=
ca[Y.name]||Y.name});return ka},M))};d.createGraph=p;d.getStrictName=n;d.hasSimilarDegreeSequence=function(H,K){H=u(H);K=u(K);for(let M=0;M<H.length;M++)if(H[M]!==K[M])return!1;return!0};d.getHierarchicalPath=x;d.getIncludeNodeButtonString=function(H){return H===b.graph.InclusionType.EXCLUDE?"Add to main graph":"Remove from main graph"};d.getGroupSeriesNodeButtonString=function(H){return H===b.graph.SeriesGroupingType.GROUP?"Ungroup this series of nodes":"Group this series of nodes"};d.toggleNodeSeriesGroup=
function(H,K){H[K]=K in H&&H[K]!==b.graph.SeriesGroupingType.GROUP?b.graph.SeriesGroupingType.GROUP:b.graph.SeriesGroupingType.UNGROUP}})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/hierarchy.js
(function(b){(function(d){(function(f){function h(x,A,y,w){A=y?x.inEdges(A.name):x.outEdges(A.name);_.each(A,C=>{C=x.edge(C);(C.numRegularEdges?w.regular:w.control).push(C)})}function k(x,A){const y={};_.each(A.nodes,w=>{let C=d.getHierarchicalPath(w.name),G=x.root;G.depth=Math.max(C.length,G.depth);y[w.op]||(y[w.op]=[]);y[w.op].push(w);for(let B=0;B<C.length;B++){G.depth=Math.max(G.depth,C.length-B);G.cardinality+=w.cardinality;G.opHistogram[w.op]=(G.opHistogram[w.op]||0)+1;null!=w.device&&(G.deviceHistogram[w.device]=
(G.deviceHistogram[w.device]||0)+1);null!=w.xlaCluster&&(G.xlaClusterHistogram[w.xlaCluster]=(G.xlaClusterHistogram[w.xlaCluster]||0)+1);w.compatible?G.compatibilityHistogram.compatible=(G.compatibilityHistogram.compatible||0)+1:G.compatibilityHistogram.incompatible=(G.compatibilityHistogram.incompatible||0)+1;_.each(w.inEmbeddings,N=>{N.compatible?G.compatibilityHistogram.compatible=(G.compatibilityHistogram.compatible||0)+1:G.compatibilityHistogram.incompatible=(G.compatibilityHistogram.incompatible||
0)+1});_.each(w.outEmbeddings,N=>{N.compatible?G.compatibilityHistogram.compatible=(G.compatibilityHistogram.compatible||0)+1:G.compatibilityHistogram.incompatible=(G.compatibilityHistogram.incompatible||0)+1});if(B===C.length-1)break;var D=C[B];let I=x.node(D);I||(I=d.createMetanode(D,x.graphOptions),I.parentNode=G,x.setNode(D,I),G.metagraph.setNode(D,I),0===D.indexOf(b.graph.FUNCTION_LIBRARY_NODE_PREFIX)&&G.name===b.graph.ROOT_NAME&&(D=D.substring(b.graph.FUNCTION_LIBRARY_NODE_PREFIX.length),y[D]||
(y[D]=[]),x.libraryFunctions[D]={node:I,usages:y[D]},I.associatedFunction=D));G=I}x.setNode(w.name,w);w.parentNode=G;G.metagraph.setNode(w.name,w);_.each(w.inEmbeddings,function(B){x.setNode(B.name,B);B.parentNode=w});_.each(w.outEmbeddings,function(B){x.setNode(B.name,B);B.parentNode=w})})}function t(x,A){let y=x.getNodeMap(),w=[],C=[],G=(D,B)=>{let I=0;for(;D;)B[I++]=D.name,D=D.parentNode;return I-1};_.each(A.edges,D=>{var B=G(A.nodes[D.v],w),I=G(A.nodes[D.w],C);if(-1!==B&&-1!==I){for(;w[B]===C[I];)if(B--,
I--,0>B||0>I)throw Error("No difference found between ancestor paths.");var N=y[w[B+1]];B=w[B];I=C[I];var O=N.metagraph.edge(B,I);O||(O=d.createMetaedge(B,I),N.metagraph.setEdge(B,I,O));N.hasNonControlEdges||D.isControlDependency||(N.hasNonControlEdges=!0);O.addBaseEdge(D,x)}})}function l(x,A,y,w,C,G){let D=x.metagraph;_.each(D.nodes(),B=>{B=D.node(B);B.type===b.graph.NodeType.META&&l(B,A,y,w,C,G)});x=p(D);x=(G?n:m)(x,D,A.graphOptions);_.each(x,function(B,I){let N=B.metagraph.nodes();_.each(N,O=>
{O=D.node(O);O.owningSeries||(O.owningSeries=I)});N.length<w&&!(B.name in C)&&(C[B.name]=b.graph.SeriesGroupingType.UNGROUP);B.name in C&&C[B.name]===b.graph.SeriesGroupingType.UNGROUP||(A.setNode(I,B),D.setNode(I,B),_.each(N,O=>{let H=D.node(O);B.metagraph.setNode(O,H);B.parentNode=H.parentNode;B.cardinality++;null!=H.device&&(B.deviceHistogram[H.device]=(B.deviceHistogram[H.device]||0)+1);null!=H.xlaCluster&&(B.xlaClusterHistogram[H.xlaCluster]=(B.xlaClusterHistogram[H.xlaCluster]||0)+1);H.compatible?
B.compatibilityHistogram.compatible=(B.compatibilityHistogram.compatible||0)+1:B.compatibilityHistogram.incompatible=(B.compatibilityHistogram.incompatible||0)+1;_.each(H.inEmbeddings,K=>{K.compatible?B.compatibilityHistogram.compatible=(B.compatibilityHistogram.compatible||0)+1:B.compatibilityHistogram.incompatible=(B.compatibilityHistogram.incompatible||0)+1});_.each(H.outEmbeddings,K=>{K.compatible?B.compatibilityHistogram.compatible=(B.compatibilityHistogram.compatible||0)+1:B.compatibilityHistogram.incompatible=
(B.compatibilityHistogram.incompatible||0)+1});H.parentNode=B;y[O]=I;D.removeNode(O)}))})}function p(x){return _.reduce(x.nodes(),(A,y)=>{y=x.node(y);if(y.type===d.NodeType.META)return A;let w=y.op;w&&(A[w]=A[w]||[],A[w].push(y.name));return A},{})}function m(x,A,y){let w={};_.each(x,function(C,G){if(!(1>=C.length)){var D={};_.each(C,function(B){var I="*"===B.charAt(B.length-1),N=B.split("/"),O=N[N.length-1];N=N.slice(0,N.length-1).join("/");var H=O.match(/^(\D*)_(\d+)$/);let K="";H?(O=H[1],H=H[2]):
(O=I?O.substr(0,O.length-1):O,H=0,K=I?"*":"");I=d.getSeriesNodeName(O,K,N);D[I]=D[I]||[];B=d.createSeriesNode(O,K,N,+H,B,y);D[I].push(B)});_.each(D,function(B){if(!(2>B.length)){B.sort(function(N,O){return+N.clusterId-+O.clusterId});var I=[B[0]];for(let N=1;N<B.length;N++){let O=B[N];O.clusterId===I[I.length-1].clusterId+1?I.push(O):(q(I,w,+G,A,y),I=[O])}q(I,w,+G,A,y)}})}});return w}function n(x,A,y){let w={};_.each(x,function(C,G){if(!(1>=C.length)){var D={},B={};_.each(C,function(N){let O="*"===
N.charAt(N.length-1);var H=N.split("/");let K=H[H.length-1];H=H.slice(0,H.length-1).join("/");const M=/(\d+)/g;var L;let Q,T,X,aa=0;for(;L=M.exec(K);)++aa,Q=K.slice(0,L.index),T=L[0],L=K.slice(L.index+L[0].length),X=d.getSeriesNodeName(Q,L,H),D[X]=D[X],D[X]||(D[X]=d.createSeriesNode(Q,L,H,+T,N,y)),D[X].ids.push(T),B[N]=B[N]||[],B[N].push([X,T]);1>aa&&(Q=O?K.substr(0,K.length-1):K,T=0,L=O?"*":"",X=d.getSeriesNodeName(Q,L,H),D[X]=D[X],D[X]||(D[X]=d.createSeriesNode(Q,L,H,+T,N,y)),D[X].ids.push(T),B[N]=
B[N]||[],B[N].push([X,T]))});var I={};_.each(B,function(N,O){N.sort(function(M,L){return D[L[0]].ids.length-D[M[0]].ids.length});var H=N[0][0];N=N[0][1];I[H]=I[H]||[];const K=O.split("/");O=d.createSeriesNode(D[H].prefix,D[H].suffix,K.slice(0,K.length-1).join("/"),+N,O,y);I[H].push(O)});_.each(I,function(N){if(!(2>N.length)){N.sort(function(H,K){return+H.clusterId-+K.clusterId});var O=[N[0]];for(let H=1;H<N.length;H++){let K=N[H];K.clusterId===O[O.length-1].clusterId+1?O.push(K):(q(O,w,+G,A,y),O=
[K])}q(O,w,+G,A,y)}})}});return w}function q(x,A,y,w,C){if(1<x.length){let G=d.getSeriesNodeName(x[0].prefix,x[0].suffix,x[0].parent,x[0].clusterId,x[x.length-1].clusterId),D=d.createSeriesNode(x[0].prefix,x[0].suffix,x[0].parent,y,G,C);_.each(x,function(B){D.ids.push(B.clusterId);D.metagraph.setNode(B.name,w.node(B.name))});A[G]=D}}class u{constructor(x){this.hasShapeInfo=!1;this.maxMetaEdgeSize=1;this.graphOptions=x||{};this.graphOptions.compound=!0;this.root=d.createMetanode(d.ROOT_NAME,this.graphOptions);
this.libraryFunctions={};this.xlaClusters=this.devices=this.templates=null;this.index={};this.index[d.ROOT_NAME]=this.root;this.orderings={}}getNodeMap(){return this.index}node(x){return this.index[x]}setNode(x,A){this.index[x]=A}getBridgegraph(x){var A=this.index[x];if(!A)throw Error("Could not find node in hierarchy: "+x);if(!("metagraph"in A))return null;if(A.bridgegraph)return A.bridgegraph;let y=A.bridgegraph=d.createGraph("BRIDGEGRAPH",d.GraphType.BRIDGE,this.graphOptions);if(!(A.parentNode&&
"metagraph"in A.parentNode))return y;var w=A.parentNode;A=w.metagraph;w=this.getBridgegraph(w.name);_.each([A,w],C=>{C.edges().filter(G=>G.v===x||G.w===x).forEach(G=>{let D=G.w===x,B=C.edge(G);_.each(B.baseEdgeList,I=>{let [N,O]=D?[I.w,G.v]:[I.v,G.w];var H=this.getChildName(x,N);H={v:D?O:H,w:D?H:O};let K=y.edge(H);K||(K=d.createMetaedge(H.v,H.w),K.inbound=D,y.setEdge(H.v,H.w,K));K.addBaseEdge(I,this)})})});return y}getChildName(x,A){let y=this.index[A];for(;y;){if(y.parentNode&&y.parentNode.name===
x)return y.name;y=y.parentNode}throw Error("Could not find immediate child for descendant: "+A);}getPredecessors(x){let A=this.index[x];if(!A)throw Error("Could not find node with name: "+x);let y=this.getOneWayEdges(A,!0);A.isGroupNode||_.each(A.inEmbeddings,w=>{_.each(A.inputs,C=>{if(C.name===w.name){let G=new d.MetaedgeImpl(w.name,x);G.addBaseEdge({isControlDependency:C.isControlDependency,outputTensorKey:C.outputTensorKey,isReferenceEdge:!1,v:w.name,w:x},this);y.regular.push(G)}})});return y}getSuccessors(x){let A=
this.index[x];if(!A)throw Error("Could not find node with name: "+x);let y=this.getOneWayEdges(A,!1);A.isGroupNode||_.each(A.outEmbeddings,w=>{_.each(w.inputs,C=>{if(C.name===x){let G=new d.MetaedgeImpl(x,w.name);G.addBaseEdge({isControlDependency:C.isControlDependency,outputTensorKey:C.outputTensorKey,isReferenceEdge:!1,v:x,w:w.name},this);y.regular.push(G)}})});return y}getOneWayEdges(x,A){let y={control:[],regular:[]};if(!x.parentNode||!x.parentNode.isGroupNode)return y;var w=x.parentNode;let C=
w.metagraph;w=this.getBridgegraph(w.name);h(C,x,A,y);h(w,x,A,y);return y}getTopologicalOrdering(x){var A=this.index[x];if(!A)throw Error("Could not find node with name: "+x);if(!A.isGroupNode)return null;if(x in this.orderings)return this.orderings[x];let y={},w={},C=A.metagraph;_.each(C.edges(),D=>{C.edge(D).numRegularEdges&&(D.v in y||(y[D.v]=[]),y[D.v].push(D.w),w[D.w]=!0)});let G=_.difference(_.keys(y),_.keys(w));x=this.orderings[x]={};for(A=0;G.length;){let D=G.shift();x[D]=A++;_.each(y[D],B=>
G.push(B));delete y[D]}return x}getTemplateIndex(){let x=d3.keys(this.templates),A=d3.scaleOrdinal().domain(x).range(d3.range(0,x.length));return y=>A(y)}}f.DefaultHierarchyParams={verifyTemplate:!0,seriesNodeMinSize:5,seriesMap:{},rankDirection:"BT",useGeneralizedSeriesPatterns:!1};f.build=function(x,A,y){let w=new u({rankdir:A.rankDirection}),C={};return b.graph.util.runAsyncTask("Adding nodes",20,()=>{let G={},D={};_.each(x.nodes,B=>{B.device&&(G[B.device]=!0);B.xlaCluster&&(D[B.xlaCluster]=!0)});
w.devices=_.keys(G);w.xlaClusters=_.keys(D);k(w,x)},y).then(()=>b.graph.util.runAsyncTask("Detect series",20,()=>{0<A.seriesNodeMinSize&&l(w.root,w,C,A.seriesNodeMinSize,A.seriesMap,A.useGeneralizedSeriesPatterns)},y)).then(()=>b.graph.util.runAsyncTask("Adding edges",30,()=>{t(w,x,C)},y)).then(()=>b.graph.util.runAsyncTask("Finding similar subgraphs",30,()=>{w.templates=d.template.detect(w,A.verifyTemplate)},y)).then(()=>w)};f.joinAndAggregateStats=function(x){let A={},y={};_.each(x.root.leaves(),
w=>{w=x.node(w);null!=w.device&&(A[w.device]=!0);null!=w.xlaCluster&&(y[w.xlaCluster]=!0)});x.devices=_.keys(A);x.xlaClusters=_.keys(y);_.each(x.getNodeMap(),w=>{w.isGroupNode&&(w.stats=new d.NodeStats(null),w.deviceHistogram={})});_.each(x.root.leaves(),w=>{let C=w=x.node(w);for(;null!=C.parentNode;){if(null!=w.device){var G=C.parentNode.deviceHistogram;G[w.device]=(G[w.device]||0)+1}null!=w.xlaCluster&&(G=C.parentNode.xlaClusterHistogram,G[w.xlaCluster]=(G[w.xlaCluster]||0)+1);null!=w.stats&&C.parentNode.stats.combine(w.stats);
C=C.parentNode}})};f.getIncompatibleOps=function(x,A){let y=[],w={};_.each(x.root.leaves(),C=>{C=x.node(C);if(C.type==d.NodeType.OP){if(!C.compatible)if(C.owningSeries)if(A&&A.seriesMap[C.owningSeries]===b.graph.SeriesGroupingType.UNGROUP)y.push(C);else{if(!w[C.owningSeries]){let G=x.node(C.owningSeries);G&&(w[C.owningSeries]=G,y.push(G))}}else y.push(C);_.each(C.inEmbeddings,G=>{G.compatible||y.push(G)});_.each(C.outEmbeddings,G=>{G.compatible||y.push(G)})}});return y}})(d.hierarchy||(d.hierarchy=
{}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/layout.js
(function(b){(function(d){(function(f){function h(w){w.node.isGroupNode&&t(w);w.node.type===d.NodeType.META?p(w):w.node.type===d.NodeType.SERIES&&m(w)}function k(w){w.inboxWidth=0<w.inAnnotations.list.length?f.PARAMS.annotations.inboxWidth:0;w.outboxWidth=0<w.outAnnotations.list.length?f.PARAMS.annotations.outboxWidth:0;w.coreBox.width=w.width;w.coreBox.height=w.height;w.width=Math.max(w.coreBox.width+w.inboxWidth+w.outboxWidth,3*w.displayName.length)}function t(w){let C=w.coreGraph.nodes().map(G=>
w.coreGraph.node(G)).concat(w.isolatedInExtract,w.isolatedOutExtract,w.libraryFunctionsExtract);_.each(C,G=>{switch(G.node.type){case d.NodeType.OP:_.extend(G,f.PARAMS.nodeSize.op);break;case d.NodeType.BRIDGE:_.extend(G,f.PARAMS.nodeSize.bridge);break;case d.NodeType.META:G.expanded?h(G):(_.extend(G,f.PARAMS.nodeSize.meta),G.height=f.PARAMS.nodeSize.meta.height(G.node.cardinality));break;case d.NodeType.SERIES:G.expanded?(_.extend(G,f.PARAMS.nodeSize.series.expanded),h(G)):_.extend(G,G.node.hasNonControlEdges?
f.PARAMS.nodeSize.series.vertical:f.PARAMS.nodeSize.series.horizontal);break;default:throw Error("Unrecognized node type: "+G.node.type);}G.expanded||k(G);n(G)})}function l(w,C){_.extend(w.graph(),{nodesep:C.nodeSep,ranksep:C.rankSep,edgesep:C.edgeSep});let G=[],D=[];_.each(w.nodes(),H=>{w.node(H).node.type===d.NodeType.BRIDGE?G.push(H):D.push(H)});if(!D.length)return{width:0,height:0};dagre.layout(w);let B=Infinity,I=Infinity,N=-Infinity,O=-Infinity;_.each(D,H=>{H=w.node(H);var K=.5*H.width,M=H.x-
K;K=H.x+K;B=M<B?M:B;N=K>N?K:N;K=.5*H.height;M=H.y-K;H=H.y+K;I=M<I?M:I;O=H>O?H:O});_.each(w.edges(),H=>{H=w.edge(H);if(!H.structural){var K=w.node(H.metaedge.v),M=w.node(H.metaedge.w);if(3===H.points.length&&A(H.points)){if(null!=K){var L=K.expanded?K.x:u(K);H.points[0].x=L}null!=M&&(L=M.expanded?M.x:u(M),H.points[2].x=L);H.points=[H.points[0],H.points[1]]}L=H.points[H.points.length-2];null!=M&&(H.points[H.points.length-1]=y(L,M));M=H.points[1];null!=K&&(H.points[0]=y(M,K));_.each(H.points,Q=>{B=Q.x<
B?Q.x:B;N=Q.x>N?Q.x:N;I=Q.y<I?Q.y:I;O=Q.y>O?Q.y:O})}});_.each(w.nodes(),H=>{H=w.node(H);H.x-=B;H.y-=I});_.each(w.edges(),H=>{_.each(w.edge(H).points,K=>{K.x-=B;K.y-=I})});return{width:N-B,height:O-I}}function p(w){let C=f.PARAMS.subscene.meta;_.extend(w,C);_.extend(w.coreBox,l(w.coreGraph,f.PARAMS.graph.meta));var G=w.isolatedInExtract.length?_.max(w.isolatedInExtract,B=>B.width).width:null;w.inExtractBox.width=null!=G?G:0;w.inExtractBox.height=_.reduce(w.isolatedInExtract,(B,I,N)=>{N=0<N?C.extractYOffset:
0;I.x=0;I.y=B+N+I.height/2;return B+N+I.height},0);G=w.isolatedOutExtract.length?_.max(w.isolatedOutExtract,B=>B.width).width:null;w.outExtractBox.width=null!=G?G:0;w.outExtractBox.height=_.reduce(w.isolatedOutExtract,(B,I,N)=>{N=0<N?C.extractYOffset:0;I.x=0;I.y=B+N+I.height/2;return B+N+I.height},0);G=w.libraryFunctionsExtract.length?_.max(w.libraryFunctionsExtract,B=>B.width).width:null;w.libraryFunctionsBox.width=null!=G?G:0;w.libraryFunctionsBox.height=_.reduce(w.libraryFunctionsExtract,(B,I,
N)=>{N=0<N?C.extractYOffset:0;I.x=0;I.y=B+N+I.height/2;return B+N+I.height},0);G=0;0<w.isolatedInExtract.length&&G++;0<w.isolatedOutExtract.length&&G++;0<w.libraryFunctionsExtract.length&&G++;0<w.coreGraph.nodeCount()&&G++;let D=f.PARAMS.subscene.meta.extractXOffset;G=1>=G?0:G*D;w.coreBox.width+=Math.max(f.MIN_AUX_WIDTH,w.inExtractBox.width+w.outExtractBox.width)+G+w.libraryFunctionsBox.width+G;w.coreBox.height=C.labelHeight+Math.max(w.inExtractBox.height,w.coreBox.height,w.libraryFunctionsBox.height,
w.outExtractBox.height);w.width=w.coreBox.width+C.paddingLeft+C.paddingRight;w.height=w.paddingTop+w.coreBox.height+w.paddingBottom}function m(w){let C=w.coreGraph,G=f.PARAMS.subscene.series;_.extend(w,G);_.extend(w.coreBox,l(w.coreGraph,f.PARAMS.graph.series));_.each(C.nodes(),D=>{C.node(D).excluded=!1});w.width=w.coreBox.width+G.paddingLeft+G.paddingRight;w.height=w.coreBox.height+G.paddingTop+G.paddingBottom}function n(w){if(!w.expanded){var C=w.inAnnotations.list,G=w.outAnnotations.list;_.each(C,
K=>q(K));_.each(G,K=>q(K));var D=f.PARAMS.annotations,B=_.reduce(C,(K,M,L)=>{L=0<L?D.yOffset:0;M.dx=-(w.coreBox.width+M.width)/2-D.xOffset;M.dy=K+L+M.height/2;return K+L+M.height},0);_.each(C,K=>{K.dy-=B/2;K.labelOffset=D.labelOffset});var I=_.reduce(G,(K,M,L)=>{L=0<L?D.yOffset:0;M.dx=(w.coreBox.width+M.width)/2+D.xOffset;M.dy=K+L+M.height/2;return K+L+M.height},0);_.each(G,K=>{K.dy-=I/2;K.labelOffset=D.labelOffset});var N=Math.min(w.height/2-w.radius,B/2);N=0>N?0:N;var O=d3.scaleLinear().domain([0,
C.length-1]).range([-N,N]);_.each(C,(K,M)=>{K.points=[{dx:K.dx+K.width/2,dy:K.dy},{dx:-w.coreBox.width/2,dy:1<C.length?O(M):0}]});N=Math.min(w.height/2-w.radius,I/2);N=0>N?0:N;var H=d3.scaleLinear().domain([0,G.length-1]).range([-N,N]);_.each(G,(K,M)=>{K.points=[{dx:w.coreBox.width/2,dy:1<G.length?H(M):0},{dx:K.dx-K.width/2,dy:K.dy}]});w.height=Math.max(w.height,B,I)}}function q(w){switch(w.annotationType){case d.render.AnnotationType.CONSTANT:_.extend(w,f.PARAMS.constant.size);break;case d.render.AnnotationType.SHORTCUT:if(w.node.type===
d.NodeType.OP)_.extend(w,f.PARAMS.shortcutSize.op);else if(w.node.type===d.NodeType.META)_.extend(w,f.PARAMS.shortcutSize.meta);else if(w.node.type===d.NodeType.SERIES)_.extend(w,f.PARAMS.shortcutSize.series);else throw Error("Invalid node type: "+w.node.type);break;case d.render.AnnotationType.SUMMARY:_.extend(w,f.PARAMS.constant.size)}}function u(w){return w.expanded?w.x:w.x-w.width/2+(w.inAnnotations.list.length?w.inboxWidth:0)+w.coreBox.width/2}function x(w,C){return 180*Math.atan((C.y-w.y)/(C.x-
w.x))/Math.PI}function A(w){let C=x(w[0],w[1]);for(let G=1;G<w.length-1;G++){let D=x(w[G],w[G+1]);if(1<Math.abs(D-C))return!1;C=D}return!0}function y(w,C){let G=C.expanded?C.x:u(C),D=C.y;var B=w.x-G;w=w.y-D;let I=C.expanded?C.width:C.coreBox.width,N=C.expanded?C.height:C.coreBox.height;Math.abs(w)*I/2>Math.abs(B)*N/2?(0>w&&(N=-N),C=0===w?0:N/2*B/w,B=N/2):(0>B&&(I=-I),C=I/2,B=0===B?0:I/2*w/B);return{x:G+C,y:D+B}}f.PARAMS={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:d3.scaleLinear().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:120},constant:{size:{width:4,height:4}},series:{maxStackCount:3,parallelStackOffsetRatio:.2,towerStackOffsetRatio:.5},minimap:{size:150}};f.MIN_AUX_WIDTH=
140;f.layoutScene=h;f.computeCXPositionOfNodeShape=u})(d.layout||(d.layout={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/loader.js
var Ui=this&&this.__awaiter||function(b,d,f,h){return new (f||(f=Promise))(function(k,t){function l(n){try{m(h.next(n))}catch(q){t(q)}}function p(n){try{m(h["throw"](n))}catch(q){t(q)}}function m(n){n.done?k(n.value):(new f(function(q){q(n.value)})).then(l,p)}m((h=h.apply(b,d||[])).next())})};
(function(b){(function(d){(function(f){f.fetchAndConstructHierarchicalGraph=function(h,k,t,l=new d.op.TpuCompatibilityProvider,p=d.hierarchy.DefaultHierarchyParams){const m=d.util.getSubtaskTracker(h,20,"Graph"),n=d.util.getSubtaskTracker(h,50,"Namespace hierarchy");return d.parser.fetchAndParseGraphData(k,t,d.util.getSubtaskTracker(h,30,"Data")).then(function(q){if(!q.node)throw 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 d.build(q,d.DefaultBuildParams,m)},()=>{throw 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(q=>Ui(this,void 0,void 0,function*(){d.op.checkOpsForCompatibility(q,l);const u=yield d.hierarchy.build(q,p,n);return{graph:q,graphHierarchy:u}})).catch(q=>{h.reportError(`Graph visualization failed.\n\n${q}`,q);throw q;
})}})(d.loader||(d.loader={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/node.js
(function(b){(function(d){(function(f){(function(h){function k(Z,ba,ea){if(ba.node.isGroupNode){if(ba.expanded)return f.buildGroup(Z,ba,ea,f.Class.Subscene.GROUP);f.selectChild(Z,"g",f.Class.Subscene.GROUP).remove()}return null}function t(Z,ba){let ea=ba.x-ba.width/2+ba.paddingLeft;ba=ba.y-ba.height/2+ba.paddingTop;Z=f.selectChild(Z,"g",f.Class.Subscene.GROUP);f.translate(Z,ea,ba)}function l(Z,ba,ea){Z=f.selectOrCreateChild(Z,"g",f.Class.Node.BUTTON_CONTAINER);f.selectOrCreateChild(Z,"circle",f.Class.Node.BUTTON_CIRCLE);
f.selectOrCreateChild(Z,"path",f.Class.Node.EXPAND_BUTTON).attr("d","M0,-2.2 V2.2 M-2.2,0 H2.2");f.selectOrCreateChild(Z,"path",f.Class.Node.COLLAPSE_BUTTON).attr("d","M-2.2,0 H2.2");Z.on("click",ca=>{d3.event.stopPropagation();ea.fire("node-toggle-expand",{name:ca.node.name})});f.positionButton(Z,ba)}function p(Z,ba,ea,ca){if(ca)Z.attr("pointer-events","none");else{var ka=f.contextmenu.getMenu(ea,m(ba.node,ea));Z.on("dblclick",Y=>{ea.fire("node-toggle-expand",{name:Y.node.name})}).on("mouseover",
Y=>{ea.isNodeExpanded(Y)||ea.fire("node-highlight",{name:Y.node.name})}).on("mouseout",Y=>{ea.isNodeExpanded(Y)||ea.fire("node-unhighlight",{name:Y.node.name})}).on("click",Y=>{d3.event.stopPropagation();ea.fire("node-select",{name:Y.node.name})}).on("contextmenu",(Y,Ea)=>{ea.fire("node-select",{name:Y.node.name});ka.call(Y,Ea)})}}function m(Z,ba){let ea=[{title:()=>d.getIncludeNodeButtonString(Z.include),action:()=>{ba.fire("node-toggle-extract",{name:Z.name})}}];ba.nodeContextMenuItems&&(ea=ea.concat(ba.nodeContextMenuItems));
n(Z)&&ea.push({title:()=>x(Z),action:()=>{ba.fire("node-toggle-seriesgroup",{name:q(Z)})}});return ea}function n(Z){return null!==q(Z)}function q(Z){return Z?Z.type===d.NodeType.SERIES?Z.name:Z.type===d.NodeType.OP?Z.owningSeries:null:null}function u(Z){let ba=null;if(!Z)return null;Z.type===d.NodeType.SERIES?ba=Z:Z.parentNode&&Z.parentNode.type===d.NodeType.SERIES&&(ba=Z.parentNode);return ba}function x(Z){return b.graph.getGroupSeriesNodeButtonString(null!==u(Z)?b.graph.SeriesGroupingType.GROUP:
b.graph.SeriesGroupingType.UNGROUP)}function A(Z,ba,ea){var ca=ba.displayName;let ka=ba.node.type===d.NodeType.META&&!ba.expanded;Z=f.selectOrCreateChild(Z,"text",f.Class.Node.LABEL);let Y=Z.node();Y.parentNode.appendChild(Y);Z.attr("dy",".35em").attr("text-anchor","middle");ka&&(ca.length>ea.maxMetanodeLabelLength&&(ca=ca.substr(0,ea.maxMetanodeLabelLength-2)+"..."),ea=w(ea),Z.attr("font-size",ea(ca.length)+"px"));ca=Z.text(ca);y(ca,ba.node.type,ba);return Z}function y(Z,ba,ea){let ca=Z.node();var ka=
ca.getComputedTextLength();let Y=ca.textContent,Ea=null;switch(ba){case d.NodeType.META:ea&&!ea.expanded&&(Ea=d.layout.PARAMS.nodeSize.meta.maxLabelWidth);break;case d.NodeType.OP:Ea=d.layout.PARAMS.nodeSize.op.maxLabelWidth;break;case -1:Ea=d.layout.PARAMS.annotations.maxLabelWidth}if(!(null===Ea||ka<=Ea)){for(ka=1;ca.getSubStringLength(0,ka)<Ea;)ka++;ba=ca.textContent.substr(0,ka);do ba=ba.substr(0,ba.length-1),ca.textContent=ba+"...",ka=ca.getComputedTextLength();while(ka>Ea&&0<ba.length);return Z.append("title").text(Y)}}
function w(Z){aa||(aa=d3.scaleLinear().domain([Z.maxMetanodeLabelLengthLargeFont,Z.maxMetanodeLabelLength]).range([Z.maxMetanodeLabelLengthFontSize,Z.minMetanodeLabelLengthFontSize]).clamp(!0));return aa}function C(Z,ba,ea,ca){f.selectChild(Z,"text",f.Class.Node.LABEL).transition().attr("x",ba).attr("y",ea+ca)}function G(Z,ba,ea){Z=f.selectOrCreateChild(Z,"g",ea);switch(ba.node.type){case d.NodeType.OP:ba=ba.node;if(_.isNumber(ba.functionInputIndex)||_.isNumber(ba.functionOutputIndex)){f.selectOrCreateChild(Z,
"polygon",f.Class.Node.COLOR_TARGET);break}f.selectOrCreateChild(Z,"ellipse",f.Class.Node.COLOR_TARGET);break;case d.NodeType.SERIES:ea="annotation";ba.coreGraph&&(ea=ba.node.hasNonControlEdges?"vertical":"horizontal");let ca=[f.Class.Node.COLOR_TARGET];ba.isFadedOut&&ca.push("faded-ellipse");f.selectOrCreateChild(Z,"use",ca).attr("xlink:href","#op-series-"+ea+"-stamp");f.selectOrCreateChild(Z,"rect",f.Class.Node.COLOR_TARGET).attr("rx",ba.radius).attr("ry",ba.radius);break;case d.NodeType.BRIDGE:f.selectOrCreateChild(Z,
"rect",f.Class.Node.COLOR_TARGET).attr("rx",ba.radius).attr("ry",ba.radius);break;case d.NodeType.META:f.selectOrCreateChild(Z,"rect",f.Class.Node.COLOR_TARGET).attr("rx",ba.radius).attr("ry",ba.radius);break;default:throw Error("Unrecognized node type: "+ba.node.type);}return Z}function D(Z){switch(Z.node.type){case d.NodeType.OP:return f.Class.OPNODE;case d.NodeType.META:return f.Class.METANODE;case d.NodeType.SERIES:return f.Class.SERIESNODE;case d.NodeType.BRIDGE:return f.Class.BRIDGENODE;case d.NodeType.ELLIPSIS:return f.Class.ELLIPSISNODE}throw Error("Unrecognized node type: "+
Z.node.type);}function B(Z,ba){var ea=f.selectChild(Z,"g",f.Class.Node.SHAPE);let ca=d.layout.computeCXPositionOfNodeShape(ba);switch(ba.node.type){case d.NodeType.OP:{const ka=ba.node;_.isNumber(ka.functionInputIndex)||_.isNumber(ka.functionOutputIndex)?(ea=f.selectChild(ea,"polygon"),f.positionTriangle(ea,ba.x,ba.y,ba.coreBox.width,ba.coreBox.height)):(ea=f.selectChild(ea,"ellipse"),f.positionEllipse(ea,ca,ba.y,ba.coreBox.width,ba.coreBox.height));C(Z,ca,ba.y,ba.labelOffset);break}case d.NodeType.META:ea=
ea.selectAll("rect");ba.expanded?(f.positionRect(ea,ba.x,ba.y,ba.width,ba.height),t(Z,ba),C(Z,ca,ba.y,-ba.height/2+ba.labelHeight/2)):(f.positionRect(ea,ca,ba.y,ba.coreBox.width,ba.coreBox.height),C(Z,ca,ba.y,0));break;case d.NodeType.SERIES:ea=f.selectChild(ea,"use");ba.expanded?(f.positionRect(ea,ba.x,ba.y,ba.width,ba.height),t(Z,ba),C(Z,ca,ba.y,-ba.height/2+ba.labelHeight/2)):(f.positionRect(ea,ca,ba.y,ba.coreBox.width,ba.coreBox.height),C(Z,ca,ba.y,ba.labelOffset));break;case d.NodeType.BRIDGE:Z=
f.selectChild(ea,"rect");f.positionRect(Z,ba.x,ba.y,ba.width,ba.height);break;default:throw Error("Unrecognized node type: "+ba.node.type);}}function I(Z,ba,ea){let ca=b.graph.util.escapeQuerySelector(Z);if(!ea)return`url(#${ca})`;ea=d3.select(ea);let ka=ea.select("defs#_graph-gradients");ka.empty()&&(ka=ea.append("defs").attr("id","_graph-gradients"));let Y=ka.select("linearGradient#"+ca);if(Y.empty()){Y=ka.append("linearGradient").attr("id",Z);Y.selectAll("*").remove();let Ea=0;_.each(ba,va=>{let xa=
va.color;Y.append("stop").attr("offset",Ea).attr("stop-color",xa);Y.append("stop").attr("offset",Ea+va.proportion).attr("stop-color",xa);Ea+=va.proportion})}return`url(#${ca})`}function N(Z,ba,ea,ca,ka){let Y=d.render.MetanodeColors;switch(ba){case la.STRUCTURE:return ea.node.type===d.NodeType.META?(ba=ea.node.templateId,null===ba?Y.UNKNOWN:Y.STRUCTURE_PALETTE(Z(ba),ca)):ea.node.type===d.NodeType.SERIES?ca?Y.EXPANDED_COLOR:"white":ea.node.type===d.NodeType.BRIDGE?ea.structural?"#f0e":ea.node.inbound?
"#0ef":"#fe0":_.isNumber(ea.node.functionInputIndex)?"#795548":_.isNumber(ea.node.functionOutputIndex)?"#009688":"white";case la.DEVICE:return null==ea.deviceColors?Y.UNKNOWN:ca?Y.EXPANDED_COLOR:I("device-"+ea.node.name,ea.deviceColors,ka);case la.XLA_CLUSTER:return null==ea.xlaClusterColors?Y.UNKNOWN:ca?Y.EXPANDED_COLOR:I("xla-"+ea.node.name,ea.xlaClusterColors,ka);case la.COMPUTE_TIME:return ca?Y.EXPANDED_COLOR:ea.computeTimeColor||Y.UNKNOWN;case la.MEMORY:return ca?Y.EXPANDED_COLOR:ea.memoryColor||
Y.UNKNOWN;case la.OP_COMPATIBILITY:return null==ea.compatibilityColors?Y.UNKNOWN:ca?Y.EXPANDED_COLOR:I("op-compat-"+ea.node.name,ea.compatibilityColors,ka);default:throw Error("Unknown case to color nodes by");}}function O(Z,ba,ea,ca){ca=ca||f.Class.Node.SHAPE;let ka=ea.isNodeSelected(ba.node.name),Y=ba.isInExtract||ba.isOutExtract||ba.isLibraryFunction,Ea=ba.expanded&&ca!==f.Class.Annotation.NODE,va=ba.isFadedOut;Z.classed("highlighted",ea.isNodeHighlighted(ba.node.name));Z.classed("selected",ka);
Z.classed("extract",Y);Z.classed("expanded",Ea);Z.classed("faded",va);Z=Z.select("."+ca+" ."+f.Class.Node.COLOR_TARGET);ba=N(ea.templateIndex,la[ea.colorBy.toUpperCase()],ba,Ea,ea.getGraphSvgRoot());Z.style("fill",ba);Z.style("stroke",ka?null:H(ba))}function H(Z){return"url"===Z.substring(0,3)?d.render.MetanodeColors.GRADIENT_OUTLINE:d3.rgb(Z).darker().toString()}function K(Z,ba){let ea=[];Z=ba.getNodeByName(Z);if(Z instanceof b.graph.OpNodeImpl)return[Z].concat(Z.inEmbeddings);Z=Z.metagraph.nodes();
_.each(Z,function(ca){ea=ea.concat(K(ca,ba))});return ea}function M(Z,ba,ea,ca){if(ca[ea.name])return ca;ca[ea.name]=!0;var ka=ea.inputs;let Y=X(ba,ea);d3.select(Z).select(`.node[data-name="${Y.name}"]`).classed("input-highlight",!0);let Ea={};_.each(ka,function(Aa){Aa=ba.getNodeByName(Aa.name);if(void 0!==Aa){Aa instanceof d.MetanodeImpl&&(Aa=b.graph.getStrictName(Aa.name),Aa=ba.getNodeByName(Aa));var Fa=X(ba,Aa),ya=Ea[Fa.name];ya?ya.opNodes.push(Aa):Ea[Fa.name]={visibleParent:Fa,opNodes:[Aa]}}});
let va={},xa=[Y];va[Y.name]={traced:!1,index:0,connectionEndpoints:[]};ea=Y;for(ka=1;ea.name!==b.graph.ROOT_NAME;ka++)ea=ea.parentNode,va[ea.name]={traced:!1,index:ka,connectionEndpoints:[]},xa[ka]=ea;_.forOwn(Ea,function(Aa){let Fa=Aa.visibleParent;_.each(Aa.opNodes,function(ya){ca=M(Z,ba,ya,ca)});Fa.name!==Y.name&&L(Z,Fa,va,xa)});return ca}function L(Z,ba,ea,ca){var ka=ba,Y=ba;for(ba=[];!ea[ka.name];)Y.name!==ka.name&&ba.push([Y,ka]),Y=ka,ka=ka.parentNode;ea=ea[ka.name].index;let Ea=ca[Math.max(ea-
1,0)].name;Y=ka=Y.name;const va=d3.select(Z);va.selectAll(`[data-edge="${Y}--${Ea}"]`).classed("input-edge-highlight",!0);_.each(ba,function(xa){va.selectAll(`[data-edge="${xa[0].name}--${Ea}`+`~~${xa[1].name}~~OUT"]`).classed("input-edge-highlight",!0)});for(Z=1;Z<ea;Z++)va.selectAll(`[data-edge="${ka}~~${ca[Z].name}`+`~~IN--${ca[Z-1].name}"]`).classed("input-edge-highlight",!0)}function Q(Z,ba){let ea={};_.each(ba,function(ca){ca=Z.getNodeByName(ca);ca=X(Z,ca);ea[ca.name]=ca});return ea}function T(Z,
ba){_.forOwn(ba,function(ea){for(;ea.name!==b.graph.ROOT_NAME;){const ca=d3.select(Z).select(`.node[data-name="${ea.name}"]`);!ca.nodes().length||ca.classed("input-highlight")||ca.classed("selected")||ca.classed("op")||ca.classed("input-parent",!0);ea=ea.parentNode}})}function X(Z,ba){let ea=!1,ca=ba;for(;!ea;)if(ba=ca,ca=ba.parentNode,void 0===ca)ea=!0;else{let ka=Z.getRenderNodeByName(ca.name);ka&&(ka.expanded||ca instanceof d.OpNodeImpl)&&(ea=!0)}return ba}h.buildGroup=function(Z,ba,ea){Z=f.selectOrCreateChild(Z,
"g",f.Class.Node.CONTAINER).selectAll(function(){return this.childNodes}).data(ba,ca=>ca.node.name+":"+ca.node.type);Z.enter().append("g").attr("data-name",ca=>ca.node.name).each(function(ca){let ka=d3.select(this);ea.addNodeGroup(ca.node.name,ka)}).merge(Z).attr("class",ca=>f.Class.Node.GROUP+" "+D(ca)).each(function(ca){let ka=d3.select(this);var Y=f.selectOrCreateChild(ka,"g",f.Class.Annotation.INBOX);f.annotation.buildGroup(Y,ca.inAnnotations,ca,ea);Y=f.selectOrCreateChild(ka,"g",f.Class.Annotation.OUTBOX);
f.annotation.buildGroup(Y,ca.outAnnotations,ca,ea);Y=G(ka,ca,f.Class.Node.SHAPE);ca.node.isGroupNode&&l(Y,ca,ea);p(Y,ca,ea);k(ka,ca,ea);Y=A(ka,ca,ea);p(Y,ca,ea,ca.node.type===d.NodeType.META);O(ka,ca,ea);B(ka,ca)});Z.exit().each(function(ca){ea.removeNodeGroup(ca.node.name);let ka=d3.select(this);0<ca.inAnnotations.list.length&&ka.select("."+f.Class.Annotation.INBOX).selectAll("."+f.Class.Annotation.GROUP).each(Y=>{ea.removeAnnotationGroup(Y,ca)});0<ca.outAnnotations.list.length&&ka.select("."+f.Class.Annotation.OUTBOX).selectAll("."+
f.Class.Annotation.GROUP).each(Y=>{ea.removeAnnotationGroup(Y,ca)})}).remove();return Z};h.getContextMenu=m;h.canBeInSeries=n;h.getSeriesName=q;h.getGroupSettingLabel=x;h.enforceLabelWidth=y;let aa=null;h.buildShape=G;h.nodeClass=D;let la;(function(Z){Z[Z.STRUCTURE=0]="STRUCTURE";Z[Z.DEVICE=1]="DEVICE";Z[Z.XLA_CLUSTER=2]="XLA_CLUSTER";Z[Z.COMPUTE_TIME=3]="COMPUTE_TIME";Z[Z.MEMORY=4]="MEMORY";Z[Z.OP_COMPATIBILITY=5]="OP_COMPATIBILITY"})(la=h.ColorBy||(h.ColorBy={}));h.removeGradientDefinitions=function(Z){d3.select(Z).select("defs#_graph-gradients").remove()};
h.getFillForNode=N;h.stylize=O;h.getStrokeForFill=H;h.updateInputTrace=function(Z,ba,ea,ca){const ka=d3.select(Z);ka.selectAll(".input-highlight").classed("input-highlight",!1);ka.selectAll(".non-input").classed("non-input",!1);ka.selectAll(".input-parent").classed("input-parent",!1);ka.selectAll(".input-child").classed("input-child",!1);ka.selectAll(".input-edge-highlight").classed("input-edge-highlight",!1);ka.selectAll(".non-input-edge-highlight").classed("non-input-edge-highlight",!1);ka.selectAll(".input-highlight-selected").classed("input-highlight-selected",
!1);if(ba&&ca&&ea){ea=K(ea,ba);var Y={};_.each(ea,function(Ea){Y=M(Z,ba,Ea,Y)});ea=Object.keys(Y);ea=Q(ba,ea);T(Z,ea);ka.selectAll("g.node:not(.selected):not(.input-highlight):not(.input-parent):not(.input-children)").classed("non-input",!0).each(function(Ea){ka.selectAll(`[data-name="${Ea.node.name}"]`).classed("non-input",!0)});ka.selectAll("g.edge:not(.input-edge-highlight)").classed("non-input-edge-highlight",!0)}};h.getVisibleParent=X})(f.node||(f.node={}))})(d.scene||(d.scene={}))})(b.graph||
(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/op.js
(function(b){(function(d){(function(f){class h{isNotTpuOp(k){return-1!=k.toLowerCase().search("cpu:")||-1!=k.toLowerCase().search("gpu:")?!0:-1==k.toLowerCase().search("tpu")}opValid(k){return 0==k.name.search(d.FUNCTION_LIBRARY_NODE_PREFIX)||!k.op||k.device&&this.isNotTpuOp(k.device)||k.device&&-1!=k.device.search("TPU_SYSTEM")?!0:_.includes(h.WHITELIST,k.op)}}h.WHITELIST="Abs Acos Acosh Add AddN AdjustContrastv2 AdjustHue AdjustSaturation All Angle Any ApproximateEqual ArgMax ArgMin Asin Asinh Assert AssignAddVariableOp AssignSubVariableOp AssignVariableOp Atan Atan2 Atanh AvgPool AvgPool3D AvgPool3DGrad AvgPoolGrad BatchMatMul BatchToSpace BatchToSpaceND BiasAdd BiasAddGrad BiasAddV1 Bitcast BitwiseAnd BitwiseOr BitwiseXor BroadcastArgs BroadcastGradientArgs Bucketize Cast Ceil CheckNumerics Cholesky ClipByValue Complex ComplexAbs Concat ConcatOffset ConcatV2 Conj ConjugateTranspose Const ControlTrigger Conv2D Conv2DBackpropFilter Conv2DBackpropInput Conv3D Conv3DBackpropFilterV2 Conv3DBackpropInputV2 Cos Cosh Cross CrossReplicaSum Cumprod Cumsum DepthToSpace DepthwiseConv2dNative DepthwiseConv2dNativeBackpropFilter DepthwiseConv2dNativeBackpropInput Diag DiagPart Digamma Div DynamicStitch Elu EluGrad Empty Equal Erf Erfc Exp ExpandDims Expm1 ExtractImagePatches FFT FFT2D FFT3D FakeQuantWithMinMaxArgs FakeQuantWithMinMaxArgsGradient FakeQuantWithMinMaxVars FakeQuantWithMinMaxVarsGradient Fill Floor FloorDiv FloorMod FusedBatchNorm FusedBatchNormGrad FusedBatchNormGradV2 FusedBatchNormV2 Gather GatherNd GatherV2 GetItem Greater GreaterEqual HSVToRGB IFFT IFFT2D IFFT3D IRFFT IRFFT2D IRFFT3D Identity IdentityN If Imag InfeedDequeue InfeedDequeueTuple InplaceAdd InplaceUpdate Inv Invert InvertPermutation IsFinite IsInf IsNan L2Loss LRN LRNGrad LeftShift Less LessEqual Lgamma LinSpace ListDiff Log Log1p LogSoftmax LogicalAnd LogicalNot LogicalOr MatMul MatrixBandPart MatrixDiag MatrixDiagPart MatrixSetDiag MatrixTriangularSolve Max MaxPool MaxPool3D MaxPool3DGrad MaxPool3DGradGrad MaxPoolGrad MaxPoolGradGrad MaxPoolGradGradV2 MaxPoolGradV2 MaxPoolV2 Maximum Mean Min Minimum MirrorPad Mod Mul Multinomial Neg NoOp NonMaxSuppressionV4 NotEqual OneHot OnesLike OutfeedEnqueue OutfeedEnqueueTuple Pack Pad PadV2 ParallelDynamicStitch PlaceholderWithDefault Pow PreventGradient Prod Qr QuantizeAndDequantizeV2 QuantizeAndDequantizeV3 RFFT RFFT2D RFFT3D RGBToHSV RandomShuffle RandomStandardNormal RandomUniform RandomUniformInt Range Rank ReadVariableOp Real RealDiv Reciprocal ReciprocalGrad RecvTPUEmbeddingActivations Relu Relu6 Relu6Grad ReluGrad Reshape ResizeBilinear ResizeBilinearGrad ResourceApplyAdaMax ResourceApplyAdadelta ResourceApplyAdagrad ResourceApplyAdagradDA ResourceApplyAdam ResourceApplyAddSign ResourceApplyCenteredRMSProp ResourceApplyFtrl ResourceApplyFtrlV2 ResourceApplyGradientDescent ResourceApplyMomentum ResourceApplyPowerSign ResourceApplyProximalAdagrad ResourceApplyProximalGradientDescent ResourceApplyRMSProp ResourceGather ResourceScatterAdd ResourceScatterDiv ResourceScatterMax ResourceScatterMin ResourceScatterMul ResourceScatterNdAdd ResourceScatterNdUpdate ResourceScatterSub ResourceScatterUpdate ResourceStridedSliceAssign Reverse ReverseSequence ReverseV2 RightShift Rint Round Rsqrt RsqrtGrad ScatterNd Select Selu SeluGrad SendTPUEmbeddingGradients 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 StatelessIf StatelessRandomNormal StatelessRandomUniform StatelessTruncatedNormal StatelessWhile StopGradient StridedSlice StridedSliceGrad Sub Sum SymbolicGradient TPUEmbeddingActivations Tan Tanh TanhGrad TensorArrayCloseV3 TensorArrayConcatV3 TensorArrayGatherV3 TensorArrayGradV3 TensorArrayReadV3 TensorArrayScatterV3 TensorArraySizeV3 TensorArraySplitV3 TensorArrayV3 TensorArrayWriteV3 Tile TopKV2 Transpose TruncateDiv TruncateMod TruncatedNormal Unpack UnsortedSegmentMax UnsortedSegmentMin UnsortedSegmentProd UnsortedSegmentSum VarIsInitializedOp VariableShape While XlaDynamicUpdateSlice XlaHostCompute XlaIf XlaRecv XlaReduceWindow XlaSend XlaSort XlaWhile ZerosLike Enter Exit LoopCond Merge NextIteration Switch _Arg _ParallelConcatUpdate _Retval _TPUCompile _TPUExecute 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".split(" ");
f.TpuCompatibilityProvider=h;f.checkOpsForCompatibility=function(k,t){if(null===t)throw Error("Compatibility provider required, but got: "+t);_.each(k.nodes,l=>{l.compatible=t.opValid(l);_.each(l.inEmbeddings,p=>{p.compatible=t.opValid(p)});_.each(l.outEmbeddings,p=>{p.compatible=t.opValid(p)})})}})(d.op||(d.op={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/parser.js
(function(b){(function(d){(function(f){function h(u){if("true"===u)return!0;if("false"===u)return!1;if('"'===u[0])return u.substring(1,u.length-1);let x=parseFloat(u);return isNaN(x)?u:x}function k(u){return new Promise((x,A)=>{fetch(u).then(y=>{y.ok?y.arrayBuffer().then(x,A):y.text().then(A,A)})})}function t(u,x,A=1E6,y="\n"){return new Promise(function(w,C){function G(D,B,I){var N=I>=u.byteLength;B=B.split(y);B[0]=D+B[0];const O=N?"":B.pop();for(let H of B)try{x(H)}catch(K){C(K);return}N?w(!0):
(D=new Blob([u.slice(I,I+A)]),N=new FileReader,N.onload=function(H){G(O,H.target.result,I+A)},N.readAsText(D))}G("","",0)})}function l(u){return m(u,n)}function p(u){return m(u,q).then(x=>x.step_stats)}function m(u,x){function A(B){let I=B.indexOf(":"),N=B.substring(0,I).trim();B=h(B.substring(I+2).trim());return{name:N,value:B}}function y(B,I,N,O){let H=B[I];null==H?B[I]=O.join(".")in x?[N]:N:Array.isArray(H)?H.push(N):B[I]=[H,N]}let w={},C=[],G=[],D=w;return t(u,function(B){if(B)switch(B=B.trim(),
B[B.length-1]){case "{":B=B.substring(0,B.length-2).trim();let I={};C.push(D);G.push(B);y(D,B,I,G);D=I;break;case "}":D=C.pop();G.pop();break;default:B=A(B),y(D,B.name,B.value,G.concat(B.name))}}).then(function(){return w})}f.fetchPbTxt=k;f.fetchAndParseMetadata=function(u,x){return b.graph.util.runTask(()=>null==u?Promise.resolve(null):k(u),x).then(A=>b.graph.util.runAsyncPromiseTask("Parsing metadata.pbtxt",60,()=>null!=A?p(A):Promise.resolve(null),x))};f.fetchAndParseGraphData=function(u,x,A){return b.graph.util.runAsyncPromiseTask("Reading graph pbtxt",
40,()=>x?new Promise(function(y,w){let C=new FileReader;C.onload=()=>y(C.result);C.onerror=()=>w(C.error);C.readAsArrayBuffer(x)}):k(u),A).then(y=>b.graph.util.runAsyncPromiseTask("Parsing graph.pbtxt",60,()=>l(y),A))};f.streamParse=t;const n={"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},q={"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};f.parseGraphPbTxt=l;f.parseStatsPbTxt=p})(d.parser||(d.parser={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/proto.js

//# sourceURL=build://tf-graph-common/render.js
(function(b){(function(d){(function(f){function h(L,Q,T,X,aa){Q=new I(Q,T,X,aa,!0);L.inAnnotations.push(Q)}function k(L,Q,T,X,aa){Q=new I(Q,T,X,aa,!1);L.outAnnotations.push(Q)}function t(L,Q){_.each(L.nodes(),T=>{T=L.node(T);T.expanded=1<Q;if(0<Q)switch(T.node.type){case d.NodeType.META:case d.NodeType.SERIES:l(T,Q-1)}})}function l(L,Q){L.coreGraph&&t(L.coreGraph,Q)}function p(L,Q,T){let X=L.node(Q),aa=L.node(T),la=L.edge(Q,T);if(X.node.include!==d.InclusionType.INCLUDE&&aa.node.include!==d.InclusionType.INCLUDE||
X.node.include===d.InclusionType.EXCLUDE||aa.node.include===d.InclusionType.EXCLUDE)k(X,aa.node,aa,la,N.SHORTCUT),h(aa,X.node,X,la,N.SHORTCUT),L.removeEdge(Q,T)}function m(L,Q,T){let X=L.coreGraph,aa=X.node(Q);aa.isOutExtract=!0;_.each(X.predecessors(Q),la=>{p(X,la,Q)});(G.detachAllEdgesForHighDegree||T)&&_.each(X.successors(Q),la=>{p(X,Q,la)});0===X.neighbors(Q).length&&(aa.node.include=d.InclusionType.EXCLUDE,L.isolatedOutExtract.push(aa),X.removeNode(Q))}function n(L,Q,T){let X=L.coreGraph,aa=
X.node(Q);aa.isInExtract=!0;_.each(X.successors(Q),la=>{p(X,Q,la)});(G.detachAllEdgesForHighDegree||T)&&_.each(X.predecessors(Q),la=>{p(X,la,Q)});0===X.neighbors(Q).length&&(aa.node.include=d.InclusionType.EXCLUDE,L.isolatedInExtract.push(aa),X.removeNode(Q))}function q(L,Q){if(L.type===d.NodeType.OP)for(var T=0;T<Q.length;T++){if(L.op===Q[T])return!0}else if(L.type===d.NodeType.META&&(L=L.getRootOp()))for(T=0;T<Q.length;T++)if(L.op===Q[T])return!0;return!1}function u(L){let Q=L.coreGraph;_.each(Q.nodes(),
T=>{Q.node(T).node.include!==d.InclusionType.EXCLUDE||T.startsWith(b.graph.FUNCTION_LIBRARY_NODE_PREFIX)||(L.coreGraph.outEdges(T).length>L.coreGraph.inEdges(T).length?m(L,T,!0):n(L,T,!0))})}function x(L){let Q=L.coreGraph;_.each(Q.nodes(),T=>{let X=Q.node(T);X.node.include===d.InclusionType.UNSPECIFIED&&q(X.node,G.outExtractTypes)&&m(L,T)})}function A(L){let Q=L.coreGraph;_.each(Q.nodes(),T=>{let X=Q.node(T);X.node.include===d.InclusionType.UNSPECIFIED&&q(X.node,G.inExtractTypes)&&n(L,T)})}function y(L){let Q=
L.coreGraph,T={},X={},aa=0;_.each(Q.nodes(),ka=>{if(Q.node(ka).node.include===d.InclusionType.UNSPECIFIED){var Y=_.reduce(Q.predecessors(ka),(va,xa)=>{xa=Q.edge(xa,ka).metaedge;return va+(xa.numRegularEdges?1:0)},0);0===Y&&0<Q.predecessors(ka).length&&(Y=Q.predecessors(ka).length);var Ea=_.reduce(Q.successors(ka),(va,xa)=>{xa=Q.edge(ka,xa).metaedge;return va+(xa.numRegularEdges?1:0)},0);0===Ea&&0<Q.successors(ka).length&&(Ea=Q.successors(ka).length);T[ka]=Y;X[ka]=Ea;aa++}});if(!(aa<G.minNodeCountForExtraction)){var la=
G.minDegreeForExtraction-1,Z=Math.round(.75*aa),ba=Math.round(.25*aa),ea=Object.keys(T).sort((ka,Y)=>T[ka]-T[Y]),ca=T[ea[Z]];ca=ca+ca-T[ea[ba]];ca=Math.max(ca,la);for(let ka=aa-1;T[ea[ka]]>ca;ka--)n(L,ea[ka]);ea=Object.keys(X).sort((ka,Y)=>X[ka]-X[Y]);Z=X[ea[Z]];ba=Z+4*(Z-X[ea[ba]]);ba=Math.max(ba,la);for(la=aa-1;X[ea[la]]>ba;la--)(Z=Q.node(ea[la]))&&!Z.isInExtract&&m(L,ea[la])}}function w(L){let Q=L.coreGraph,T={};_.each(Q.edges(),X=>{Q.edge(X).metaedge.numRegularEdges||((T[X.v]=T[X.v]||[]).push(X),
(T[X.w]=T[X.w]||[]).push(X))});_.each(T,X=>{X.length>G.maxControlDegree&&_.each(X,aa=>p(Q,aa.v,aa.w))})}function C(L){u(L);G.outExtractTypes&&x(L);G.inExtractTypes&&A(L);y(L);G.maxControlDegree&&w(L);let Q=L.coreGraph;_.each(Q.nodes(),T=>{let X=Q.node(T);var aa=Q.neighbors(T).length;if(X.node.include===d.InclusionType.UNSPECIFIED&&0===aa){aa=0<X.outAnnotations.list.length;let la=0<X.inAnnotations.list.length;X.isInExtract?(L.isolatedInExtract.push(X),X.node.include=d.InclusionType.EXCLUDE,Q.removeNode(T)):
X.isOutExtract?(L.isolatedOutExtract.push(X),X.node.include=d.InclusionType.EXCLUDE,Q.removeNode(T)):G.extractIsolatedNodesWithAnnotationsOnOneSide&&(aa&&!la?(X.isInExtract=!0,L.isolatedInExtract.push(X),X.node.include=d.InclusionType.EXCLUDE,Q.removeNode(T)):la&&!aa&&(X.isOutExtract=!0,L.isolatedOutExtract.push(X),X.node.include=d.InclusionType.EXCLUDE,Q.removeNode(T)))}})}f.OpNodeColors={DEFAULT_FILL:"#ffffff",DEFAULT_STROKE:"#b2b2b2",COMPATIBLE:"#0f9d58",INCOMPATIBLE:"#db4437"};f.MetanodeColors=
{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(L,Q){var T=f.MetanodeColors.HUES;L=T[L%T.length];T=Math.sin(L*Math.PI/360);return d3.hsl(L,.01*(Q?30:90-60*T),.01*(Q?95:80)).toString()},DEVICE_PALETTE(L){return f.MetanodeColors.STRUCTURE_PALETTE(L)},XLA_CLUSTER_PALETTE(L){return f.MetanodeColors.STRUCTURE_PALETTE(L)},UNKNOWN:"#eee",GRADIENT_OUTLINE:"#888"};f.SeriesNodeColors={DEFAULT_FILL:"white",
DEFAULT_STROKE:"#b2b2b2"};const G={enableExtraction:!0,minNodeCountForExtraction:15,minDegreeForExtraction:5,maxControlDegree:4,maxBridgePathDegree:4,outExtractTypes:["NoOp"],inExtractTypes:[],detachAllEdgesForHighDegree:!0,extractIsolatedNodesWithAnnotationsOnOneSide:!0,enableBridgegraph:!0,minMaxColors:["#fff5f0","#fb6a4a"],maxAnnotations:5},D=new RegExp("^(?:"+b.graph.FUNCTION_LIBRARY_NODE_PREFIX+")?(\\w+)_[a-z0-9]{8}(?:_\\d+)?$");class B{constructor(L,Q){this.hierarchy=L;this.displayingStats=
Q;this.index={};this.renderedOpNames=[];this.computeScales();this.hasSubhierarchy={};this.root=new M(L.root,L.graphOptions);this.index[L.root.name]=this.root;this.renderedOpNames.push(L.root.name);this.buildSubhierarchy(L.root.name);this.root.expanded=!0;this.traceInputs=!1}computeScales(){this.deviceColorMap=d3.scaleOrdinal().domain(this.hierarchy.devices).range(_.map(d3.range(this.hierarchy.devices.length),f.MetanodeColors.DEVICE_PALETTE));this.xlaClusterColorMap=d3.scaleOrdinal().domain(this.hierarchy.xlaClusters).range(_.map(d3.range(this.hierarchy.xlaClusters.length),
f.MetanodeColors.XLA_CLUSTER_PALETTE));let L=this.hierarchy.root.metagraph;var Q=d3.max(L.nodes(),T=>{T=L.node(T);if(null!=T.stats)return T.stats.totalBytes});this.memoryUsageScale=d3.scaleLinear().domain([0,Q]).range(G.minMaxColors);Q=d3.max(L.nodes(),T=>{T=L.node(T);if(null!=T.stats)return T.stats.getTotalMicros()});this.computeTimeScale=d3.scaleLinear().domain([0,Q]).range(G.minMaxColors);this.edgeWidthSizedBasedScale=this.hierarchy.hasShapeInfo?d.scene.edge.EDGE_WIDTH_SIZE_BASED_SCALE:d3.scaleLinear().domain([1,
this.hierarchy.maxMetaEdgeSize]).range([d.scene.edge.MIN_EDGE_WIDTH,d.scene.edge.MAX_EDGE_WIDTH])}getRenderNodeByName(L){return this.index[L]}getNodeByName(L){return this.hierarchy.node(L)}colorHistogram(L,Q){if(0<Object.keys(L).length){const T=_.sum(Object.keys(L).map(X=>L[X]));return Object.keys(L).map(X=>({color:Q(X),proportion:L[X]/T}))}console.info("no pairs found!");return null}getOrCreateRenderNodeByName(L){if(!L)return null;if(L in this.index)return this.index[L];var Q=this.hierarchy.node(L);
if(!Q)return null;let T=Q.isGroupNode?new M(Q,this.hierarchy.graphOptions):new H(Q);this.index[L]=T;this.renderedOpNames.push(L);Q.stats&&(T.memoryColor=this.memoryUsageScale(Q.stats.totalBytes),T.computeTimeColor=this.computeTimeScale(Q.stats.getTotalMicros()));T.isFadedOut=this.displayingStats&&!b.graph.util.hasDisplayableNodeStats(Q.stats);var X=null,aa=null,la=null;if(Q.isGroupNode){X=Q.deviceHistogram;aa=Q.xlaClusterHistogram;var Z=Q.compatibilityHistogram.compatible;Q=Q.compatibilityHistogram.incompatible;
if(0!=Z||0!=Q)la=Z/(Z+Q)}else(Z=T.node.device)&&(X={[Z]:1}),(Z=T.node.xlaCluster)&&(aa={[Z]:1}),T.node.type===d.NodeType.OP&&(la=T.node.compatible?1:0);X&&(T.deviceColors=this.colorHistogram(X,this.deviceColorMap));aa&&(T.xlaClusterColors=this.colorHistogram(aa,this.xlaClusterColorMap));null!=la&&(T.compatibilityColors=[{color:b.graph.render.OpNodeColors.COMPATIBLE,proportion:la},{color:b.graph.render.OpNodeColors.INCOMPATIBLE,proportion:1-la}]);return this.index[L]}getNearestVisibleAncestor(L){var Q=
d.getHierarchicalPath(L);let T=0,X=null;for(;T<Q.length&&(L=Q[T],X=this.getRenderNodeByName(L),X.expanded);T++);return T==Q.length-2&&(Q=Q[T+1],X.inAnnotations.nodeNames[Q]||X.outAnnotations.nodeNames[Q])?Q:L}setDepth(L){l(this.root,+L)}isNodeAuxiliary(L){let Q=this.getRenderNodeByName(L.node.parentNode.name),T=_.find(Q.isolatedInExtract,X=>X.node.name===L.node.name);if(T)return!0;T=_.find(Q.isolatedOutExtract,X=>X.node.name===L.node.name);return!!T}getNamesOfRenderedOps(){return this.renderedOpNames}cloneAndAddFunctionOpNode(L,
Q,T,X){var aa=T.name.replace(Q,X);let la=L.metagraph.node(aa);if(la)return la;la=new d.OpNodeImpl({name:aa,input:[],device:T.device,op:T.op,attr:_.cloneDeep(T.attr)});la.cardinality=T.cardinality;la.include=T.include;la.outputShapes=_.cloneDeep(T.outputShapes);la.xlaCluster=T.xlaCluster;la.functionInputIndex=T.functionInputIndex;la.functionOutputIndex=T.functionOutputIndex;la.inputs=T.inputs.map(Z=>{const ba=_.clone(Z);ba.name=Z.name.replace(Q,X);return ba});la.parentNode=L;L.metagraph.setNode(la.name,
la);this.hierarchy.setNode(la.name,la);aa=Z=>this.cloneAndAddFunctionOpNode(L,Q,Z,X);la.inEmbeddings=T.inEmbeddings.map(aa);la.outEmbeddings=T.outEmbeddings.map(aa);return la}cloneFunctionLibraryMetanode(L,Q,T,X,aa){const la={};L=this.cloneFunctionLibraryMetanodeHelper(L,Q,T,X,aa,la);_.isEmpty(la)||this.patchEdgesFromFunctionOutputs(Q,la);return L}cloneFunctionLibraryMetanodeHelper(L,Q,T,X,aa,la){const Z=b.graph.createMetanode(T.name.replace(X,aa));Z.depth=T.depth;Z.cardinality=T.cardinality;Z.templateId=
T.templateId;Z.opHistogram=_.clone(T.opHistogram);Z.deviceHistogram=_.clone(T.deviceHistogram);Z.xlaClusterHistogram=_.clone(T.xlaClusterHistogram);Z.hasNonControlEdges=T.hasNonControlEdges;Z.include=T.include;Z.nodeAttributes=_.clone(T.nodeAttributes);Z.associatedFunction=T.associatedFunction;_.each(T.metagraph.nodes(),ba=>{ba=T.metagraph.node(ba);switch(ba.type){case d.NodeType.META:ba=this.cloneFunctionLibraryMetanodeHelper(L,Q,ba,X,aa,la);ba.parentNode=Z;Z.metagraph.setNode(ba.name,ba);this.hierarchy.setNode(ba.name,
ba);break;case d.NodeType.OP:ba=this.cloneAndAddFunctionOpNode(Z,X,ba,aa);_.isNumber(ba.functionInputIndex)&&this.patchEdgesIntoFunctionInputs(Q,ba);_.isNumber(ba.functionOutputIndex)&&(la[ba.functionOutputIndex]=ba);break;default:console.warn(ba.name+" is oddly neither a metanode nor an opnode.")}});this.cloneLibraryMetanodeEdges(T,Z,X,aa);return Z}cloneLibraryMetanodeEdges(L,Q,T,X){_.each(L.metagraph.edges(),aa=>{aa=L.metagraph.edge(aa);const la=aa.v.replace(T,X),Z=aa.w.replace(T,X),ba=new d.MetaedgeImpl(la,
Z);ba.inbound=aa.inbound;ba.numRegularEdges=aa.numRegularEdges;ba.numControlEdges=aa.numControlEdges;ba.numRefEdges=aa.numRefEdges;ba.totalSize=aa.totalSize;aa.baseEdgeList&&(ba.baseEdgeList=aa.baseEdgeList.map(ea=>{const ca=_.clone(ea);ca.v=ea.v.replace(T,X);ca.w=ea.w.replace(T,X);return ca}));Q.metagraph.node(Z)?Q.metagraph.setEdge(la,Z,ba):Q.metagraph.setEdge(Z,la,ba)})}patchEdgesIntoFunctionInputs(L,Q){let T=Math.min(Q.functionInputIndex,L.inputs.length-1);for(var X=_.clone(L.inputs[T]);X.isControlDependency;)T++,
X=L.inputs[T];Q.inputs.push(X);X=this.hierarchy.getPredecessors(L.name);let aa,la=0;_.each(X.regular,Z=>{la+=Z.numRegularEdges;if(la>T)return aa=Z,!1});_.each(aa.baseEdgeList,Z=>{Z.w===L.name&&(Z.w=Q.name);Z.v===L.name&&(Z.v=Q.name)})}patchEdgesFromFunctionOutputs(L,Q){const T=this.hierarchy.getSuccessors(L.name);_.each(T.regular,X=>{_.each(X.baseEdgeList,aa=>{const la=this.hierarchy.node(aa.w);_.each(la.inputs,Z=>{Z.name===L.name&&(Z.name=Q[Z.outputTensorKey].name,Z.outputTensorKey=aa.outputTensorKey)})});
_.each(X.baseEdgeList,aa=>{aa.v=Q[aa.outputTensorKey].name;aa.outputTensorKey="0"})})}buildSubhierarchy(L){if(!(L in this.hasSubhierarchy)){this.hasSubhierarchy[L]=!0;var Q=this.index[L];if(Q.node.type===d.NodeType.META||Q.node.type===d.NodeType.SERIES){var T=Q.node.metagraph,X=Q.coreGraph,aa=[],la=[];_.isEmpty(this.hierarchy.libraryFunctions)||(_.each(T.nodes(),xa=>{const Aa=T.node(xa),Fa=this.hierarchy.libraryFunctions[Aa.op];Fa&&0!==xa.indexOf(b.graph.FUNCTION_LIBRARY_NODE_PREFIX)&&(xa=this.cloneFunctionLibraryMetanode(T,
Aa,Fa.node,Fa.node.name,Aa.name),aa.push(Aa),la.push(xa))}),_.each(la,(xa,Aa)=>{Aa=aa[Aa];xa.parentNode=Aa.parentNode;T.setNode(Aa.name,xa);this.hierarchy.setNode(Aa.name,xa)}));_.each(T.nodes(),xa=>{let Aa=this.getOrCreateRenderNodeByName(xa),Fa=Aa.node;X.setNode(xa,Aa);Fa.isGroupNode||(_.each(Fa.inEmbeddings,ya=>{let Sa=new K(null),Xa=new H(ya);h(Aa,ya,Xa,Sa,N.CONSTANT);this.index[ya.name]=Xa}),_.each(Fa.outEmbeddings,ya=>{let Sa=new K(null),Xa=new H(ya);k(Aa,ya,Xa,Sa,N.SUMMARY);this.index[ya.name]=
Xa}))});_.each(T.edges(),xa=>{var Aa=T.edge(xa);Aa=new K(Aa);Aa.isFadedOut=this.index[xa.v].isFadedOut||this.index[xa.w].isFadedOut;X.setEdge(xa.v,xa.w,Aa)});G.enableExtraction&&Q.node.type===d.NodeType.META&&C(Q);_.isEmpty(this.hierarchy.libraryFunctions)||this.buildSubhierarchiesForNeededFunctions(T);L===b.graph.ROOT_NAME&&_.forOwn(this.hierarchy.libraryFunctions,xa=>{xa=xa.node;const Aa=this.getOrCreateRenderNodeByName(xa.name);Q.libraryFunctionsExtract.push(Aa);Aa.node.include=d.InclusionType.EXCLUDE;
X.removeNode(xa.name)});var Z=Q.node.parentNode;if(Z){var ba=this.index[Z.name],ea=(xa,...Aa)=>Aa.concat([xa?"IN":"OUT"]).join("~~"),ca=this.hierarchy.getBridgegraph(L),ka={},Y={},Ea={};_.each(ca.edges(),xa=>{let Aa=!!T.node(xa.w),Fa=Aa?xa.v:xa.w;ca.edge(xa).numRegularEdges?Aa?Y[Fa]=(Y[Fa]||0)+1:ka[Fa]=(ka[Fa]||0)+1:Ea[Fa]=(Ea[Fa]||0)+1});var va=this.hierarchy.getNodeMap();_.each(ca.edges(),xa=>{var Aa=ca.edge(xa);let Fa=!!T.node(xa.w),[ya,Sa]=Fa?[xa.w,xa.v]:[xa.v,xa.w];var Xa=this.index[ya],ub=this.index[Sa],
Bb=ub?ub.node:va[Sa],qb=!Aa.numRegularEdges&&Ea[Sa]>G.maxControlDegree,[,zb]=Fa?[Q.inAnnotations,Xa.inAnnotations]:[Q.outAnnotations,Xa.outAnnotations];let vb=(Fa?Y:ka)[Sa]>G.maxBridgePathDegree;xa=null;var Gb=!1;G.enableBridgegraph&&!vb&&!qb&&Xa.isInCore()&&(Gb=Nb=>ba.coreGraph.edge(Fa?{v:Nb,w:L}:{v:L,w:Nb}),(xa=Gb(Sa))||(xa=Gb(ea(Fa,Sa,Z.name))),Gb=!!xa);Xa=!1;if(xa&&!Aa.numRegularEdges){Xa=xa;for(qb=ba.node;Xa.adjoiningMetaedge;)Xa=Xa.adjoiningMetaedge,qb=qb.parentNode;qb=this.hierarchy.getTopologicalOrdering(qb.name);
Xa=Xa.metaedge;Xa=qb[Xa.v]>qb[Xa.w]}Gb&&!Xa?(Bb=ea(Fa,L),ub=ea(Fa,Sa,L),zb=X.node(ub),zb||(Gb=X.node(Bb),Gb||(Gb=new H({name:Bb,type:d.NodeType.BRIDGE,isGroupNode:!1,cardinality:0,parentNode:null,stats:null,include:d.InclusionType.UNSPECIFIED,inbound:Fa,nodeAttributes:{}}),this.index[Bb]=Gb,X.setNode(Bb,Gb)),zb=new H({name:ub,type:d.NodeType.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,include:d.InclusionType.UNSPECIFIED,inbound:Fa,nodeAttributes:{}}),this.index[ub]=zb,X.setNode(ub,
zb),X.setParent(ub,Bb),Gb.node.cardinality++),Aa=new K(Aa),Aa.adjoiningMetaedge=xa,Fa?X.setEdge(ub,ya,Aa):X.setEdge(ya,ub,Aa)):zb.push(new I(Bb,ub,new K(Aa),N.SHORTCUT,Fa))});_.each([!0,!1],xa=>{let Aa=ea(xa,L),Fa=X.node(Aa);Fa&&_.each(X.nodes(),ya=>{if(X.node(ya).node.type!==d.NodeType.BRIDGE&&(xa?!X.predecessors(ya).length:!X.successors(ya).length)){var Sa=ea(xa,L,"STRUCTURAL_TARGET"),Xa=X.node(Sa);Xa||(Xa=new H({name:Sa,type:d.NodeType.BRIDGE,isGroupNode:!1,cardinality:1,parentNode:null,stats:null,
include:d.InclusionType.UNSPECIFIED,inbound:xa,nodeAttributes:{}}),Xa.structural=!0,this.index[Sa]=Xa,X.setNode(Sa,Xa),Fa.node.cardinality++,X.setParent(Sa,Aa));Xa=new K(null);Xa.structural=!0;Xa.weight--;xa?X.setEdge(Sa,ya,Xa):X.setEdge(ya,Sa,Xa)}})})}}}}buildSubhierarchiesForNeededFunctions(L){_.each(L.edges(),Q=>{Q=L.edge(Q);Q=new K(Q);_.forEach(Q.metaedge.baseEdgeList,T=>{var X=T.v.split(b.graph.NAMESPACE_DELIM);for(var aa=X.length;0<=aa;aa--){T=X.slice(0,aa);const la=this.hierarchy.node(T.join(b.graph.NAMESPACE_DELIM));
if(la){if(la.type===d.NodeType.OP&&this.hierarchy.libraryFunctions[la.op])for(X=1;X<T.length;X++)(aa=T.slice(0,X).join(b.graph.NAMESPACE_DELIM))&&this.buildSubhierarchy(aa);break}}})})}}f.RenderGraphInfo=B;class I{constructor(L,Q,T,X,aa){this.node=L;this.renderNodeInfo=Q;this.renderMetaedgeInfo=T;this.annotationType=X;this.height=this.width=this.dy=this.dx=0;T&&T.metaedge&&(this.v=T.metaedge.v,this.w=T.metaedge.w);this.isIn=aa;this.points=[]}}f.Annotation=I;let N;(function(L){L[L.SHORTCUT=0]="SHORTCUT";
L[L.CONSTANT=1]="CONSTANT";L[L.SUMMARY=2]="SUMMARY";L[L.ELLIPSIS=3]="ELLIPSIS"})(N=f.AnnotationType||(f.AnnotationType={}));class O{constructor(){this.list=[];this.nodeNames={}}push(L){if(!(L.node.name in this.nodeNames))if(this.nodeNames[L.node.name]=!0,this.list.length<G.maxAnnotations)this.list.push(L);else{var Q=this.list[this.list.length-1];Q.annotationType===N.ELLIPSIS?(L=Q.node,L.setNumMoreNodes(++L.numMoreNodes)):(Q=new b.graph.EllipsisNodeImpl(1),this.list.push(new I(Q,new H(Q),null,N.ELLIPSIS,
L.isIn)))}}}f.AnnotationList=O;class H{constructor(L){this.node=L;this.expanded=!1;this.inAnnotations=new O;this.outAnnotations=new O;this.outboxWidth=this.inboxWidth=this.height=this.width=this.y=this.x=0;this.structural=this.excluded=!1;this.paddingBottom=this.paddingRight=this.paddingLeft=this.paddingTop=this.labelHeight=this.radius=this.labelOffset=0;this.isOutExtract=this.isInExtract=!1;this.coreBox={width:0,height:0};this.isFadedOut=!1;this.displayName=L.name.substring(L.name.lastIndexOf(b.graph.NAMESPACE_DELIM)+
1);L.type===d.NodeType.META&&L.associatedFunction&&((L=this.displayName.match(D))?this.displayName=L[1]:_.startsWith(this.displayName,b.graph.FUNCTION_LIBRARY_NODE_PREFIX)&&(this.displayName=this.displayName.substring(b.graph.FUNCTION_LIBRARY_NODE_PREFIX.length)))}isInCore(){return!this.isInExtract&&!this.isOutExtract&&!this.isLibraryFunction}}f.RenderNodeInfo=H;class K{constructor(L){this.metaedge=L;this.adjoiningMetaedge=null;this.structural=!1;this.weight=1;this.isFadedOut=!1}}f.RenderMetaedgeInfo=
K;class M extends H{constructor(L,Q){super(L);L=L.metagraph.graph();Q.compound=!0;this.coreGraph=d.createGraph(L.name,d.GraphType.CORE,Q);this.inExtractBox={width:0,height:0};this.outExtractBox={width:0,height:0};this.libraryFunctionsBox={width:0,height:0};this.isolatedInExtract=[];this.isolatedOutExtract=[];this.libraryFunctionsExtract=[]}}f.RenderGroupNodeInfo=M;f.makeInExtract=n;f.mapIndexToHue=function(L){return 1+579.2561679725*L%358};f.expandUntilNodeIsShown=function(L,Q){var T=document.getElementById("scene");
Q=Q.split("/");var X=Q[Q.length-1].match(/(.*):\w+/);2===X.length&&(Q[Q.length-1]=X[1]);X=Q[0];let aa=L.getRenderNodeByName(X);for(let la=1;la<Q.length&&aa.node.type!==b.graph.NodeType.OP;la++)L.buildSubhierarchy(X),aa.expanded=!0,T.setNodeExpanded(aa),X+="/"+Q[la],aa=L.getRenderNodeByName(X);return aa.node.name}})(d.render||(d.render={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/scene.js
(function(b){(function(d){(function(f){function h(q,u,x,A){var y=k(q,u,x);if(!y.empty())return y;u=document.createElementNS("http://www.w3.org/2000/svg",u);if(x instanceof Array)for(y=0;y<x.length;y++)u.classList.add(x[y]);else u.classList.add(x);A?q.node().insertBefore(u,A):q.node().appendChild(u);return d3.select(u).datum(q.datum())}function k(q,u,x){q=q.node().childNodes;for(let A=0;A<q.length;A++){let y=q[A];if(y.tagName===u)if(x instanceof Array){let w=!0;for(let C=0;C<x.length;C++)w=w&&y.classList.contains(x[C]);
if(w)return d3.select(y)}else if(!x||y.classList.contains(x))return d3.select(y)}return d3.select(null)}function t(q,u){let x=u.node.type===d.NodeType.SERIES?0:d.layout.PARAMS.subscene.meta.labelHeight;l(k(q,"g",f.Class.Scene.CORE),0,x);var A=0<u.isolatedInExtract.length,y=0<u.isolatedOutExtract.length;let w=0<u.libraryFunctionsExtract.length,C=d.layout.PARAMS.subscene.meta.extractXOffset,G=0;A&&(G+=u.outExtractBox.width);y&&(G+=u.outExtractBox.width);A&&(A=u.coreBox.width,A=G<d.layout.MIN_AUX_WIDTH?
A-d.layout.MIN_AUX_WIDTH+u.inExtractBox.width/2:A-u.inExtractBox.width/2-u.outExtractBox.width-(y?C:0),A=A-u.libraryFunctionsBox.width-(w?C:0),l(k(q,"g",f.Class.Scene.INEXTRACT),A,x));y&&(y=u.coreBox.width,y=G<d.layout.MIN_AUX_WIDTH?y-d.layout.MIN_AUX_WIDTH+u.outExtractBox.width/2:y-u.outExtractBox.width/2,y=y-u.libraryFunctionsBox.width-(w?C:0),l(k(q,"g",f.Class.Scene.OUTEXTRACT),y,x));w&&(u=u.coreBox.width-u.libraryFunctionsBox.width/2,l(k(q,"g",f.Class.Scene.FUNCTION_LIBRARY),u,x))}function l(q,
u,x){null!=q.attr("transform")&&(q=q.transition("position"));q.attr("transform","translate("+u+","+x+")")}function p(q,u){return u?q.toFixed(0):1<=Math.abs(q)?q.toFixed(1):q.toExponential(1)}function m(q,u,x,A){let y="Device: "+q.device_name+"\n";y+="dtype: "+q.dtype+"\n";let w="(scalar)";0<q.shape.length&&(w="("+q.shape.join(",")+")");y=y+("\nshape: "+w+"\n\n#(elements): ")+(u+"\n");q=[];for(u=0;u<x.length;u++)0<x[u]&&q.push("#("+f.healthPillEntries[u].label+"): "+x[u]);y+=q.join(", ")+"\n\n";A.max>=
A.min&&(y+="min: "+A.min+", max: "+A.max+"\n",y+="mean: "+A.mean+", stddev: "+A.stddev);return y}function n(q,u,x,A,y=60,w=10,C=0,G){d3.select(q.parentNode).selectAll(".health-pill").remove();if(u){var D=u.value,B=D.slice(2,8),I=B[0],N=B[1],O=B[5],H=D[1],K={min:D[8],max:D[9],mean:D[10],stddev:Math.sqrt(D[11])};null==y&&(y=60);null==w&&(w=10);null==C&&(C=0);null!=x&&x.node.type===b.graph.NodeType.OP&&(y/=2,w/=2);D=document.createElementNS(f.SVG_NAMESPACE,"g");D.classList.add("health-pill");var M=document.createElementNS(f.SVG_NAMESPACE,
"defs");D.appendChild(M);var L=document.createElementNS(f.SVG_NAMESPACE,"linearGradient");A="health-pill-gradient-"+A;L.setAttribute("id",A);var Q=0,T="0%";for(let aa=0;aa<B.length;aa++)if(B[aa]){Q+=B[aa];var X=document.createElementNS(f.SVG_NAMESPACE,"stop");X.setAttribute("offset",T);X.setAttribute("stop-color",f.healthPillEntries[aa].background_color);L.appendChild(X);T=document.createElementNS(f.SVG_NAMESPACE,"stop");X=100*Q/H+"%";T.setAttribute("offset",X);T.setAttribute("stop-color",f.healthPillEntries[aa].background_color);
L.appendChild(T);T=X}M.appendChild(L);M=document.createElementNS(f.SVG_NAMESPACE,"rect");M.setAttribute("fill","url(#"+A+")");M.setAttribute("width",String(y));M.setAttribute("height",String(w));M.setAttribute("y",String(C));D.appendChild(M);M=document.createElementNS(f.SVG_NAMESPACE,"title");M.textContent=m(u,H,B,K);D.appendChild(M);u=!1;if(null!=x&&(M=x.x-y/2,w=x.y-w-x.height/2-2,0>x.labelOffset&&(w+=x.labelOffset),D.setAttribute("transform","translate("+M+", "+w+")"),(B[2]||B[3]||B[4])&&(x=x.node.attr)&&
x.length))for(B=0;B<x.length;B++)if("T"===x[B].key){u=(x=x[B].value.type)&&/^DT_(BOOL|INT|UINT)/.test(x);break}x=document.createElementNS(f.SVG_NAMESPACE,"text");if(Number.isFinite(K.min)&&Number.isFinite(K.max)){if(B=p(K.min,u),K=p(K.max,u),x.textContent=1<H?B+" ~ "+K:B,0<I||0<N||0<O)x.textContent+=" (",H=[],0<I&&H.push(`NaN\u00d7${I}`),0<N&&H.push(`-\u221e\u00d7${N}`),0<O&&H.push(`+\u221e\u00d7${O}`),x.textContent+=H.join("; ")+")"}else x.textContent="(No finite elements)";x.classList.add("health-pill-stats");
null==G&&(G=y/2);x.setAttribute("x",String(G));x.setAttribute("y",String(C-2));D.appendChild(x);Polymer.dom(q.parentNode).appendChild(D)}}f.SVG_NAMESPACE="http://www.w3.org/2000/svg";f.Class={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"};f.healthPillEntries=[{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"}];f.fit=function(q,u,x,A){var y=q.getBoundingClientRect();let w=null;try{if(w=u.getBBox(),0===w.width)return}catch(C){return}u=d.layout.PARAMS.graph;y=d3.zoomIdentity.scale(.9*Math.min(y.width/
w.width,y.height/w.height,2)).translate(u.padding.paddingLeft,u.padding.paddingTop);d3.select(q).transition().duration(500).call(x.transform,y).on("end.fitted",()=>{x.on("end.fitted",null);A()})};f.panToNode=function(q,u,x,A){x=d3.select(u).select(`[data-name="${q}"]`).node();if(!x)return console.warn(`panToNode() failed for node name "${q}"`),!1;var y=x.getBBox(),w=x.getScreenCTM();q=u.createSVGPoint();x=u.createSVGPoint();q.x=y.x;q.y=y.y;x.x=y.x+y.width;x.y=y.y+y.height;q=q.matrixTransform(w);x=
x.matrixTransform(w);w=(G,D,B,I)=>!(G>B&&D<I);y=u.getBoundingClientRect();const C=y.top+y.height-150;return w(q.x,x.x,y.left,y.left+y.width-320)||w(q.y,x.y,y.top,C)?(w=y.left+y.width/2-(q.x+x.x)/2,q=y.top+y.height/2-(q.y+x.y)/2,x=d3.zoomTransform(u),d3.select(u).transition().duration(500).call(A.translateBy,w/x.k,q/x.k),!0):!1};f.selectOrCreateChild=h;f.selectChild=k;f.buildGroup=function(q,u,x,A){A=A||f.Class.Scene.GROUP;let y=k(q,"g",A).empty();q=h(q,"g",A);A=h(q,"g",f.Class.Scene.CORE);let w=_.reduce(u.coreGraph.nodes(),
(C,G)=>{G=u.coreGraph.node(G);G.excluded||C.push(G);return C},[]);u.node.type===d.NodeType.SERIES&&w.reverse();f.edge.buildGroup(A,u.coreGraph,x);f.node.buildGroup(A,w,x);0<u.isolatedInExtract.length?(A=h(q,"g",f.Class.Scene.INEXTRACT),f.node.buildGroup(A,u.isolatedInExtract,x)):k(q,"g",f.Class.Scene.INEXTRACT).remove();0<u.isolatedOutExtract.length?(A=h(q,"g",f.Class.Scene.OUTEXTRACT),f.node.buildGroup(A,u.isolatedOutExtract,x)):k(q,"g",f.Class.Scene.OUTEXTRACT).remove();0<u.libraryFunctionsExtract.length?
(A=h(q,"g",f.Class.Scene.FUNCTION_LIBRARY),f.node.buildGroup(A,u.libraryFunctionsExtract,x)):k(q,"g",f.Class.Scene.FUNCTION_LIBRARY).remove();t(q,u);y&&q.attr("opacity",0).transition().attr("opacity",1);return q};f.addGraphClickListener=function(q,u){d3.select(q).on("click",()=>{u.fire("graph-select")})};f.translate=l;f.positionRect=function(q,u,x,A,y){q.transition().attr("x",u-A/2).attr("y",x-y/2).attr("width",A).attr("height",y)};f.positionTriangle=function(q,u,x,A,y){y/=2;A/=2;u=[[u,x-y],[u+A,
x+y],[u-A,x+y]];q.transition().attr("points",u.map(w=>w.join(",")).join(" "))};f.positionButton=function(q,u){let x=d.layout.computeCXPositionOfNodeShape(u)+(u.expanded?u.width:u.coreBox.width)/2-6,A=u.y-(u.expanded?u.height:u.coreBox.height)/2+6;u.node.type!==d.NodeType.SERIES||u.expanded||(x+=10,A-=2);u="translate("+x+","+A+")";q.selectAll("path").transition().attr("transform",u);q.select("circle").transition().attr({cx:x,cy:A,r:d.layout.PARAMS.nodeSize.meta.expandButtonRadius})};f.positionEllipse=
function(q,u,x,A,y){q.transition().attr("cx",u).attr("cy",x).attr("rx",A/2).attr("ry",y/2)};f.humanizeHealthPillStat=p;f.addHealthPill=n;f.addHealthPills=function(q,u,x){if(u){var A=1;d3.select(q).selectAll("g.nodeshape").each(function(y){const w=u[y.node.name];n(this,w?w[x]:null,y,A++)})}}})(d.scene||(d.scene={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/template.js
(function(b){(function(d){(function(f){function h(n){let q=_.map({depth:n.depth,"|V|":n.metagraph.nodes().length,"|E|":n.metagraph.edges().length},function(u,x){return x+"\x3d"+u}).join(" ");n=_.map(n.opHistogram,function(u,x){return x+"\x3d"+u}).join(",");return q+" [ops] "+n}function k(n){const q=n.getNodeMap();let u=Object.keys(q).reduce((x,A)=>{const y=q[A];if(y.type!==d.NodeType.META)return x;A=A.split("/").length-1;let w=h(y),C=x[w]||{nodes:[],level:A};x[w]=C;C.nodes.push(y);C.level>A&&(C.level=
A);return x},{});return Object.keys(u).map(x=>[x,u[x]]).filter(([,x])=>{x=x.nodes;if(1<x.length)return!0;x=x[0];return x.type===d.NodeType.META&&x.associatedFunction}).sort(([,x])=>x.nodes[0].depth)}function t(n,q){return _.reduce(n,function(u,x){let A=x[0],y=[];x[1].nodes.forEach(function(w){for(let C=0;C<y.length;C++)if(!q||p(y[C].metanode.metagraph,w.metagraph)){w.templateId=y[C].metanode.templateId;y[C].members.push(w.name);return}w.templateId=A+"["+y.length+"]";y.push({metanode:w,members:[w.name]})});
y.forEach(function(w){u[w.metanode.templateId]={level:x[1].level,nodes:w.members}});return u},{})}function l(n,q,u){return _.sortBy(n,[x=>q.node(x).op,x=>q.node(x).templateId,x=>q.neighbors(x).length,x=>q.predecessors(x).length,x=>q.successors(x).length,x=>x.substr(u.length)])}function p(n,q){function u(I,N){let O=I.substr(x.length),H=N.substr(A.length);if(y[O]^w[H])return console.warn("different visit pattern","["+x+"]",O,"["+A+"]",H),!0;y[O]||(y[O]=w[H]=!0,C.push({n1:I,n2:N}));return!1}if(!b.graph.hasSimilarDegreeSequence(n,
q))return!1;let x=n.graph().name,A=q.graph().name,y={},w={},C=[];var G=n.sources(),D=q.sources();if(G.length!==D.length)return console.log("different source length"),!1;G=l(G,n,x);D=l(D,q,A);for(var B=0;B<G.length;B++)if(u(G[B],D[B]))return!1;for(;0<C.length;){D=C.pop();if(!m(n.node(D.n1),q.node(D.n2)))return!1;G=n.successors(D.n1);D=q.successors(D.n2);if(G.length!==D.length)return console.log("# of successors mismatch",G,D),!1;G=l(G,n,x);D=l(D,q,A);for(B=0;B<G.length;B++)if(u(G[B],D[B]))return!1}return!0}
function m(n,q){if(n.type===d.NodeType.META)return n.templateId&&q.templateId&&n.templateId===q.templateId;if(n.type===d.NodeType.OP&&q.type===d.NodeType.OP)return n.op===q.op;if(n.type===d.NodeType.SERIES&&q.type===d.NodeType.SERIES){let u=n.metagraph.nodeCount();return u===q.metagraph.nodeCount()&&(0===u||n.metagraph.node(n.metagraph.nodes()[0]).op===q.metagraph.node(q.metagraph.nodes()[0]).op)}return!1}f.detect=function(n,q){n=k(n);let u=t(n,q);return Object.keys(u).sort(x=>u[x].level).reduce((x,
A)=>{x[A]=u[A];return x},{})}})(d.template||(d.template={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/util.js
(function(b){(function(d){(function(f){f.time=function(h,k){let t=Date.now();k=k();console.log(h,":",Date.now()-t,"ms");return k};f.getTracker=function(h){return{setMessage:function(k){h.set("progress",{value:h.progress.value,msg:k})},updateProgress:function(k){h.set("progress",{value:h.progress.value+k,msg:h.progress.msg})},reportError:function(k,t){console.error(t.stack);h.set("progress",{value:h.progress.value,msg:k,error:!0})}}};f.getSubtaskTracker=function(h,k,t){return{setMessage:function(l){h.setMessage(t+
": "+l)},updateProgress:function(l){h.updateProgress(l*k/100)},reportError:function(l,p){h.reportError(t+": "+l,p)}}};f.runTask=function(h,k){k.setMessage("Reading metadata pbtxt");try{let t=b.graph.util.time("Reading metadata pbtxt",h);k.updateProgress(40);return t}catch(t){k.reportError("Failed Reading metadata pbtxt",t)}};f.runAsyncTask=function(h,k,t,l){return new Promise(p=>{l.setMessage(h);setTimeout(function(){try{let m=b.graph.util.time(h,t);l.updateProgress(k);p(m)}catch(m){l.reportError("Failed "+
h,m)}},20)})};f.runAsyncPromiseTask=function(h,k,t,l){return new Promise((p,m)=>{function n(q){l.reportError("Failed "+h,q);m(q)}l.setMessage(h);setTimeout(function(){try{let q=Date.now();t().then(function(u){console.log(h,":",Date.now()-q,"ms");l.updateProgress(k);p(u)}).catch(n)}catch(q){n(q)}},20)})};f.escapeQuerySelector=function(h){return h.replace(/([:.\[\],/\\\(\)])/g,"\\$1")};f.MEMORY_UNITS=[{symbol:"B"},{symbol:"KB",numUnits:1024},{symbol:"MB",numUnits:1024},{symbol:"GB",numUnits:1024},{symbol:"TB",
numUnits:1024},{symbol:"PB",numUnits:1024}];f.TIME_UNITS=[{symbol:"\u00b5s"},{symbol:"ms",numUnits:1E3},{symbol:"s",numUnits:1E3},{symbol:"min",numUnits:60},{symbol:"hr",numUnits:60},{symbol:"days",numUnits:24}];f.convertUnitsToHumanReadable=function(h,k,t=0){return t+1<k.length&&h>=k[t+1].numUnits?b.graph.util.convertUnitsToHumanReadable(h/k[t+1].numUnits,k,t+1):Number(h.toPrecision(3))+" "+k[t].symbol};f.hasDisplayableNodeStats=function(h){return h&&(0<h.totalBytes||0<h.getTotalMicros()||h.outputSize)?
!0:!1};f.removeCommonPrefix=function(h){if(2>h.length)return h;let k=0,t=0,l=_.min(_.map(h,p=>p.length));for(;;){k++;let p=_.map(h,m=>m.substring(0,k));if(p.every((m,n)=>0===n?!0:m===p[n-1])){if(k>=l)return h;t=k}else break}return _.map(h,p=>p.substring(t))};f.computeHumanFriendlyTime=function(h){h=+new Date-+new Date(h/1E3);return 3E4>h?"just now":6E4>h?Math.floor(h/1E3)+" seconds ago":12E4>h?"a minute ago":36E5>h?Math.floor(h/6E4)+" minutes ago":1==Math.floor(h/36E5)?"an hour ago":864E5>h?Math.floor(h/
36E5)+" hours ago":1728E5>h?"yesterday":Math.floor(h/864E5)+" days ago"}})(d.util||(d.util={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/minimap.js
(function(b){(function(d){class f{constructor(h,k,t,l,p,m){this.svg=h;this.labelPadding=m;this.zoomG=k;this.mainZoom=t;this.maxWandH=p;h=d3.select(l.shadowRoot);let n=h.select("svg"),q=n.select("rect");this.viewpointCoord={x:0,y:0};k=d3.drag().subject(Object).on("drag",()=>{this.viewpointCoord.x=d3.event.x;this.viewpointCoord.y=d3.event.y;this.updateViewpoint()});q.datum(this.viewpointCoord).call(k);n.on("click",()=>{if(!d3.event.defaultPrevented){var u=Number(q.attr("width")),x=Number(q.attr("height")),
A=d3.mouse(n.node());this.viewpointCoord.x=A[0]-u/2;this.viewpointCoord.y=A[1]-x/2;this.updateViewpoint()}});this.viewpoint=q.node();this.minimapSvg=n.node();this.minimap=l;this.canvas=h.select("canvas.first").node();this.canvasBuffer=h.select("canvas.second").node();this.downloadCanvas=h.select("canvas.download").node();d3.select(this.downloadCanvas).style("display","none");this.update()}updateViewpoint(){d3.select(this.viewpoint).attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y);let h=
-this.viewpointCoord.x*this.scaleMain/this.scaleMinimap,k=-this.viewpointCoord.y*this.scaleMain/this.scaleMinimap;d3.select(this.svg).call(this.mainZoom.transform,d3.zoomIdentity.translate(h,k).scale(this.scaleMain))}update(){let h=null;try{if(h=this.zoomG.getBBox(),0===h.width)return}catch(u){return}var k=d3.select("#graphdownload");this.download=k.node();k.on("click",()=>{URL.revokeObjectURL(this.download.href);var u=this.downloadCanvas.toDataURL("image/png");const x=u.slice(0,u.indexOf(","));if(x.endsWith(";base64")){var A=
atob(u.slice(u.indexOf(",")+1));u=(new Uint8Array(A.length)).map((y,w)=>A.charCodeAt(w));this.download.href=URL.createObjectURL(new Blob([u],{type:"image/png"}))}else console.warn(`non-base64 data URL (${x}); cannot use blob download`),this.download.href=u});k=d3.select(this.svg);var t="",l=this.svg;l=(l.getRootNode?l.getRootNode():this.svg.parentNode).styleSheets;for(var p=0;p<l.length;p++)try{var m=l[p].cssRules||l[p].rules;if(null!=m)for(let u=0;u<m.length;u++)t+=m[u].cssText.replace(/ ?tf-[\w-]+ ?/g,
"")+"\n"}catch(u){if("SecurityError"!==u.name)throw u;}m=k.append("style");m.text(t);t=d3.select(this.zoomG);l=t.attr("transform");t.attr("transform",null);h.height+=h.y;h.width+=h.x;h.height+=2*this.labelPadding;h.width+=2*this.labelPadding;k.attr("width",h.width).attr("height",h.height);this.scaleMinimap=this.maxWandH/Math.max(h.width,h.height);this.minimapSize={width:h.width*this.scaleMinimap,height:h.height*this.scaleMinimap};d3.select(this.minimapSvg).attr(this.minimapSize);d3.select(this.canvasBuffer).attr(this.minimapSize);
p=d3.select(this.downloadCanvas);p.style("width",h.width);p.style("height",h.height);p.attr("width",3*h.width);p.attr("height",3*h.height);null!=this.translate&&null!=this.zoom&&requestAnimationFrame(()=>this.zoom());let n=(new XMLSerializer).serializeToString(this.svg);m.remove();k.attr("width",null).attr("height",null);t.attr("transform",l);let q=new Image;q.onload=()=>{var u=this.canvasBuffer.getContext("2d");u.clearRect(0,0,this.canvasBuffer.width,this.canvasBuffer.height);u.drawImage(q,0,0,this.minimapSize.width,
this.minimapSize.height);requestAnimationFrame(()=>{d3.select(this.canvasBuffer).style("display",null);d3.select(this.canvas).style("display","none");[this.canvas,this.canvasBuffer]=[this.canvasBuffer,this.canvas]});u=this.downloadCanvas.getContext("2d");u.clearRect(0,0,this.downloadCanvas.width,this.downloadCanvas.height);u.drawImage(q,0,0,this.downloadCanvas.width,this.downloadCanvas.height)};q.onerror=()=>{q.src=URL.createObjectURL(new Blob([n],{type:"image/svg+xml;charset\x3dutf-8"}))};q.src=
"data:image/svg+xml;charset\x3dutf-8,"+encodeURIComponent(n)}zoom(h){if(null!=this.scaleMinimap){h&&(this.translate=[h.x,h.y],this.scaleMain=h.k);var k=this.svg.getBoundingClientRect(),t=d3.select(this.viewpoint);this.viewpointCoord.x=-this.translate[0]*this.scaleMinimap/this.scaleMain;this.viewpointCoord.y=-this.translate[1]*this.scaleMinimap/this.scaleMain;h=k.width*this.scaleMinimap/this.scaleMain;k=k.height*this.scaleMinimap/this.scaleMain;t.attr("x",this.viewpointCoord.x).attr("y",this.viewpointCoord.y).attr("width",
h).attr("height",k);t=this.minimapSize.width;var l=this.minimapSize.height,p=this.viewpointCoord.x,m=this.viewpointCoord.y;.8>(Math.min(Math.max(0,p+h),t)-Math.min(Math.max(0,p),t))*(Math.min(Math.max(0,m+k),l)-Math.min(Math.max(0,m),l))/(t*l)?this.minimap.classList.remove("hidden"):this.minimap.classList.add("hidden")}}}d.Minimap=f})(b.scene||(b.scene={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph/tf-graph-minimap.html.js
Polymer({is:"tf-graph-minimap",init:function(b,d,f,h,k){return new tf.scene.Minimap(b,d,f,this,h,k)}});

//# sourceURL=build://tf-graph/tf-graph-scene.html.js
Polymer({is:"tf-graph-scene",properties:{renderHierarchy:Object,name:String,colorBy:String,traceInputs:Boolean,_hasRenderHierarchyBeenFitOnce:Boolean,_isAttached:Boolean,_zoom:Object,highlightedNode:{type:String,observer:"_highlightedNodeChanged"},selectedNode:{type:String,observer:"_selectedNodeChanged"},handleEdgeSelected:Object,_zoomed:{type:Boolean,observer:"_onZoomChanged",value:!1},_zoomStartCoords:{type:Object,value:null},_zoomTransform:{type:Object,value:null},_maxZoomDistanceForClick:{type:Number,
value:20},templateIndex:Function,minimap:Object,_nodeGroupIndex:{type:Object,value:function(){return{}}},_annotationGroupIndex:{type:Object,value:function(){return{}}},_edgeGroupIndex:{type:Object,value:function(){return{}}},maxMetanodeLabelLengthFontSize:{type:Number,value:9},minMetanodeLabelLengthFontSize:{type:Number,value:6},maxMetanodeLabelLengthLargeFont:{type:Number,value:11},maxMetanodeLabelLength:{type:Number,value:18},progress:Object,nodeContextMenuItems:Array,nodeNamesToHealthPills:Object,
healthPillStepIndex:Number},observers:["_colorByChanged(colorBy)","_renderHierarchyChanged(renderHierarchy)","_animateAndFit(_isAttached, renderHierarchy)","_updateHealthPills(nodeNamesToHealthPills, healthPillStepIndex)","_updateInputTrace(traceInputs, selectedNode)"],getNode:function(b){return this.renderHierarchy.getRenderNodeByName(b)},isNodeExpanded:function(b){return b.expanded},setNodeExpanded:function(){this._build(this.renderHierarchy);this._updateLabels(!this._zoomed)},panToNode(b){tf.graph.scene.panToNode(b,
this.$.svg,this.$.root,this._zoom)&&(this._zoomed=!0)},getGraphSvgRoot(){return this.$.svg},getContextMenu(){return this.$.contextMenu},_resetState:function(){this._nodeGroupIndex={};this._annotationGroupIndex={};this._edgeGroupIndex={};this._updateLabels(!1);d3.select(this.$.svg).select("#root").selectAll("*").remove();tf.graph.scene.node.removeGradientDefinitions(this.$.svg)},_build:function(b){this.templateIndex=b.hierarchy.getTemplateIndex();tf.graph.util.time("tf-graph-scene (layout):",function(){tf.graph.layout.layoutScene(b.root,
this)}.bind(this));tf.graph.util.time("tf-graph-scene (build scene):",function(){tf.graph.scene.buildGroup(d3.select(this.$.root),b.root,this);tf.graph.scene.addGraphClickListener(this.$.svg,this);this._updateInputTrace()}.bind(this));setTimeout(function(){this._updateHealthPills(this.nodeNamesToHealthPills,this.healthPillStepIndex);this.minimap.update()}.bind(this),tf.graph.layout.PARAMS.animation.duration)},ready:function(){this._zoom=d3.zoom().on("end",function(){this._zoomStartCoords&&(Math.sqrt(Math.pow(this._zoomStartCoords.x-
this._zoomTransform.x,2)+Math.pow(this._zoomStartCoords.y-this._zoomTransform.y,2))<this._maxZoomDistanceForClick?this._fireEnableClick():setTimeout(this._fireEnableClick.bind(this),50));this._zoomStartCoords=null}.bind(this)).on("zoom",function(){this._zoomTransform=d3.event.transform;this._zoomStartCoords||(this._zoomStartCoords=this._zoomTransform,this.fire("disable-click"));this._zoomed=!0;d3.select(this.$.root).attr("transform",d3.event.transform);this.minimap.zoom(d3.event.transform)}.bind(this));
d3.select(this.$.svg).call(this._zoom).on("dblclick.zoom",null);d3.select(window).on("resize",function(){this.minimap.zoom()}.bind(this));this.minimap=this.$.minimap.init(this.$.svg,this.$.root,this._zoom,tf.graph.layout.PARAMS.minimap.size,tf.graph.layout.PARAMS.subscene.meta.labelHeight)},attached:function(){this.set("_isAttached",!0)},detached:function(){this.set("_isAttached",!1)},_renderHierarchyChanged:function(b){this._hasRenderHierarchyBeenFitOnce=!1;this._resetState();this._build(b)},_animateAndFit:function(b){!this._hasRenderHierarchyBeenFitOnce&&
b&&setTimeout(this.fit.bind(this),tf.graph.layout.PARAMS.animation.duration)},_updateLabels:function(b){var d=this.$$(".title"),f=d.style,h=this.$$(".auxTitle"),k=h.style,t=this.$$(".functionLibraryTitle").style;const l=d3.select(this.$.svg);var p=l.select("."+tf.graph.scene.Class.Scene.GROUP+"\x3e."+tf.graph.scene.Class.Scene.CORE).node();if(b&&p&&this.progress&&100===this.progress.value){b=l.select("."+tf.graph.scene.Class.Scene.GROUP+"\x3e."+tf.graph.scene.Class.Scene.INEXTRACT).node()||l.select("."+
tf.graph.scene.Class.Scene.GROUP+"\x3e."+tf.graph.scene.Class.Scene.OUTEXTRACT).node();var m=p.getCTM().e;p=b?b.getCTM().e:null;f.display="inline";f.left=m+"px";null!==p&&p!==m?(k.display="inline",p=Math.max(m+d.getBoundingClientRect().width,p),k.left=p+"px"):k.display="none";d=(d=l.select("."+tf.graph.scene.Class.Scene.GROUP+"\x3e."+tf.graph.scene.Class.Scene.FUNCTION_LIBRARY).node())?d.getCTM().e:null;null!==d&&d!==p?(t.display="inline",d=Math.max(p+h.getBoundingClientRect().width,d),t.left=d+"px"):
t.display="none"}else f.display="none",k.display="none",t.display="none"},_colorByChanged:function(){null!=this.renderHierarchy&&(_.each(this._nodeGroupIndex,(b,d)=>{this._updateNodeState(d)}),this.minimap.update())},fit:function(){this._hasRenderHierarchyBeenFitOnce=!0;tf.graph.scene.fit(this.$.svg,this.$.root,this._zoom,function(){this._zoomed=!1}.bind(this))},isNodeSelected:function(b){return b===this.selectedNode},isNodeHighlighted:function(b){return b===this.highlightedNode},addAnnotationGroup:function(b,
d,f){b=b.node.name;this._annotationGroupIndex[b]=this._annotationGroupIndex[b]||{};this._annotationGroupIndex[b][d.node.name]=f},getAnnotationGroupsIndex:function(b){return this._annotationGroupIndex[b]},removeAnnotationGroup:function(b,d){delete this._annotationGroupIndex[b.node.name][d.node.name]},addNodeGroup:function(b,d){this._nodeGroupIndex[b]=d},getNodeGroup:function(b){return this._nodeGroupIndex[b]},removeNodeGroup:function(b){delete this._nodeGroupIndex[b]},addEdgeGroup:function(b,d){this._edgeGroupIndex[b]=
d},getEdgeGroup:function(b){return this._edgeGroupIndex[b]},_updateHealthPills:function(b,d){tf.graph.scene.addHealthPills(this.$.svg,b,d)},_updateNodeState:function(b){var d=this.getNode(b),f=this.getNodeGroup(b);f&&tf.graph.scene.node.stylize(f,d,this);d.node.type===tf.graph.NodeType.META&&d.node.associatedFunction&&!d.isLibraryFunction&&(f=d3.select("."+tf.graph.scene.Class.Scene.GROUP+"\x3e."+tf.graph.scene.Class.Scene.FUNCTION_LIBRARY+' g[data-name\x3d"'+(tf.graph.FUNCTION_LIBRARY_NODE_PREFIX+
d.node.associatedFunction)+'"]'),tf.graph.scene.node.stylize(f,d,this));_.each(this.getAnnotationGroupsIndex(b),h=>{tf.graph.scene.node.stylize(h,d,this,tf.graph.scene.Class.Annotation.NODE)})},_selectedNodeChanged:function(b,d){if(b!==d&&(d&&this._updateNodeState(d),b)){this.minimap.update();d=this.renderHierarchy.hierarchy.node(b);for(var f=[];null!=d.parentNode&&d.parentNode.name!=tf.graph.ROOT_NAME;)d=d.parentNode,f.push(d.name);var h;_.forEachRight(f,k=>{this.renderHierarchy.buildSubhierarchy(k);
k=this.renderHierarchy.getRenderNodeByName(k);k.node.isGroupNode&&!k.expanded&&(k.expanded=!0,h||(h=k))});h&&(this.setNodeExpanded(h),this._zoomed=!0);b&&this._updateNodeState(b);setTimeout(()=>{this.panToNode(b)},tf.graph.layout.PARAMS.animation.duration)}},_highlightedNodeChanged:function(b,d){b!==d&&(b&&this._updateNodeState(b),d&&this._updateNodeState(d))},_onZoomChanged:function(){this._updateLabels(!this._zoomed)},_fireEnableClick:function(){this.fire("enable-click")},_updateInputTrace:function(){tf.graph.scene.node.updateInputTrace(this.getGraphSvgRoot(),
this.renderHierarchy,this.selectedNode,this.traceInputs)}});

//# sourceURL=build://tf-graph/tf-graph.html.js
Polymer({is:"tf-graph",properties:{graphHierarchy:{type:Object,notify:!0,observer:"_graphChanged"},basicGraph:Object,stats:Object,devicesForStats:Object,hierarchyParams:Object,progress:{type:Object,notify:!0},title:String,selectedNode:{type:String,notify:!0},selectedEdge:{type:Object,notify:!0},_lastSelectedEdgeGroup:Object,highlightedNode:{type:String,notify:!0},colorBy:String,colorByParams:{type:Object,notify:!0,readOnly:!0},renderHierarchy:{type:Object,readOnly:!0,notify:!0},traceInputs:Boolean,
nodeContextMenuItems:Array,_renderDepth:{type:Number,value:1},_allowGraphSelect:{type:Boolean,value:!0},nodeNamesToHealthPills:Object,healthPillStepIndex:Number,edgeWidthFunction:{type:Object,value:""},handleNodeSelected:{type:Object,value:""},edgeLabelFunction:{type:Object,value:""},handleEdgeSelected:{type:Object,value:""}},observers:["_statsChanged(stats, devicesForStats)","_buildNewRenderHierarchy(graphHierarchy, edgeWidthFunction, handleNodeSelected, edgeLabelFunction, handleEdgeSelected)","_selectedNodeChanged(selectedNode)",
"_selectedEdgeChanged(selectedEdge)"],panToNode(b){this.$$("tf-graph-scene").panToNode(b)},_buildNewRenderHierarchy(b){b&&this._buildRenderHierarchy(b)},_statsChanged:function(b,d){this.graphHierarchy&&(b&&d&&(tf.graph.joinStatsInfoWithGraph(this.basicGraph,b,d),tf.graph.hierarchy.joinAndAggregateStats(this.graphHierarchy)),this._buildRenderHierarchy(this.graphHierarchy))},_buildRenderHierarchy:function(b){tf.graph.util.time("new tf.graph.render.Hierarchy",function(){function d(h){return{minValue:h.domain()[0],
maxValue:h.domain()[1],startColor:h.range()[0],endColor:h.range()[1]}}if(b.root.type===tf.graph.NodeType.META){var f=new tf.graph.render.RenderGraphInfo(b,!!this.stats);f.edgeLabelFunction=this.edgeLabelFunction;f.edgeWidthFunction=this.edgeWidthFunction;this._setColorByParams({compute_time:d(f.computeTimeScale),memory:d(f.memoryUsageScale),device:_.map(f.deviceColorMap.domain(),function(h){return{device:h,color:f.deviceColorMap(h)}}),xla_cluster:_.map(f.xlaClusterColorMap.domain(),function(h){return{xla_cluster:h,
color:f.xlaClusterColorMap(h)}})});this._setRenderHierarchy(f);this.async(function(){this.fire("rendered")})}}.bind(this))},_getVisible:function(b){return b?this.renderHierarchy.getNearestVisibleAncestor(b):b},listeners:{"graph-select":"_graphSelected","disable-click":"_disableClick","enable-click":"_enableClick","node-toggle-expand":"_nodeToggleExpand","node-select":"_nodeSelected","node-highlight":"_nodeHighlighted","node-unhighlight":"_nodeUnhighlighted","node-toggle-extract":"_nodeToggleExtract",
"node-toggle-seriesgroup":"_nodeToggleSeriesGroup","edge-select":"_edgeSelected","annotation-select":"_nodeSelected","annotation-highlight":"_nodeHighlighted","annotation-unhighlight":"_nodeUnhighlighted"},fit:function(){this.$.scene.fit()},_graphChanged:function(){this.fire("graph-select")},_graphSelected:function(){this._allowGraphSelect&&(this.set("selectedNode",null),this.set("selectedEdge",null));this._allowGraphSelect=!0},_disableClick:function(){this._allowGraphSelect=!1},_enableClick:function(){this._allowGraphSelect=
!0},_selectedNodeChanged(b){this.handleNodeSelected&&this.handleNodeSelected(b)},_selectedEdgeChanged(b){this._deselectPreviousEdge();b&&(this._lastSelectedEdgeGroup.classed(tf.graph.scene.Class.Edge.SELECTED,!0),this._updateMarkerOfSelectedEdge(b));this.handleEdgeSelected&&this.handleEdgeSelected(b)},_nodeSelected:function(b){this._allowGraphSelect&&this.set("selectedNode",b.detail.name);this._allowGraphSelect=!0},_edgeSelected(b){this._allowGraphSelect&&(this.set("_lastSelectedEdgeGroup",b.detail.edgeGroup),
this.set("selectedEdge",b.detail.edgeData));this._allowGraphSelect=!0},_nodeHighlighted:function(b){this.set("highlightedNode",b.detail.name)},_nodeUnhighlighted:function(){this.set("highlightedNode",null)},_nodeToggleExpand:function(b){this._nodeSelected(b);b=b.detail.name;var d=this.renderHierarchy.getRenderNodeByName(b);d.node.type!==tf.graph.NodeType.OP&&(this.renderHierarchy.buildSubhierarchy(b),d.expanded=!d.expanded,this.async(function(){this.$.scene.setNodeExpanded(d)},75))},_nodeToggleExtract:function(b){this.nodeToggleExtract(b.detail.name)},
nodeToggleExtract:function(b){b=this.renderHierarchy.getRenderNodeByName(b);b.node.include=b.node.include==tf.graph.InclusionType.INCLUDE?tf.graph.InclusionType.EXCLUDE:b.node.include==tf.graph.InclusionType.EXCLUDE?tf.graph.InclusionType.INCLUDE:this.renderHierarchy.isNodeAuxiliary(b)?tf.graph.InclusionType.INCLUDE:tf.graph.InclusionType.EXCLUDE;this._buildRenderHierarchy(this.graphHierarchy)},_nodeToggleSeriesGroup:function(b){this.nodeToggleSeriesGroup(b.detail.name)},nodeToggleSeriesGroup:function(b){tf.graph.toggleNodeSeriesGroup(this.hierarchyParams.seriesMap,
b);this.set("progress",{value:0,msg:""});tf.graph.hierarchy.build(this.basicGraph,this.hierarchyParams,tf.graph.util.getSubtaskTracker(tf.graph.util.getTracker(this),100,"Namespace hierarchy")).then(function(d){this.set("graphHierarchy",d);this._buildRenderHierarchy(this.graphHierarchy)}.bind(this))},_deselectPreviousEdge(){d3.select("."+tf.graph.scene.Class.Edge.SELECTED).classed(tf.graph.scene.Class.Edge.SELECTED,!1).each(b=>{if(b.label){const d=d3.select(this).selectAll("path.edgeline");b.label.startMarkerId&&
d.style("marker-start",`url(#${b.label.startMarkerId})`);b.label.endMarkerId&&d.style("marker-end",`url(#${b.label.endMarkerId})`)}})},_updateMarkerOfSelectedEdge(b){if(b.label){var d=b.label.startMarkerId||b.label.endMarkerId;if(d){const f=d.replace("dataflow-","selected-");let h=this.$$("#"+f);h||(d=this.$.scene.querySelector("#"+d),h=d.cloneNode(!0),h.setAttribute("id",f),h.classList.add("selected-arrowhead"),d.parentNode.appendChild(h));b=b.label.startMarkerId?"marker-start":"marker-end";this._lastSelectedEdgeGroup.selectAll("path.edgeline").style(b,
`url(#${f})`)}}},not:function(b){return!b}});

//# sourceURL=build://tf-graph-loader/tf-graph-loader.js
(function(b){(function(d){(function(){Polymer({is:"tf-graph-loader",_template:null,properties:{datasets:Array,selectedData:{type:Number,value:0},selectedFile:Object,compatibilityProvider:{type:Object,value:()=>new b.graph.op.TpuCompatibilityProvider},overridingHierarchyParams:{type:Object,value:()=>({})},progress:{type:Object,notify:!0},outGraphHierarchy:{type:Object,readOnly:!0,notify:!0},outGraph:{type:Object,readOnly:!0,notify:!0},outHierarchyParams:{type:Object,readOnly:!0,notify:!0}},observers:["_loadData(datasets, selectedData, overridingHierarchyParams, compatibilityProvider)",
"_loadFile(selectedFile, overridingHierarchyParams, compatibilityProvider)"],_loadData(){this.debounce("load",()=>{const f=this.datasets[this.selectedData];f&&this._parseAndConstructHierarchicalGraph(f.path)})},_parseAndConstructHierarchicalGraph(f,h){const k=this.overridingHierarchyParams,t=this.compatibilityProvider;this.progress={value:0,msg:""};const l=b.graph.util.getTracker(this),p=Object.assign({},b.graph.hierarchy.DefaultHierarchyParams,k);b.graph.loader.fetchAndConstructHierarchicalGraph(l,
f,h,t,p).then(({graph:m,graphHierarchy:n})=>{this._setOutHierarchyParams(p);this._setOutGraph(m);this._setOutGraphHierarchy(n)})},_loadFile(f){if(f){f=f.target;var h=f.files[0];h&&(f.value="",this._parseAndConstructHierarchicalGraph(null,h))}}})})(d.loader||(d.loader={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-debugger-dashboard/health-pills.js
var Vi;
(function(b){function d(k,t){if(null==k)throw Error(`Missing refValue for condition (${t}).`);}function f(k){return null==k||0==k.length||1!==k[0]}const h={INF_OR_NAN:{description:"Contains +/-\u221e or NaN",predicate:k=>0<k[2]||0<k[3]||0<k[7]},INF:{description:"Contains +/-\u221e",predicate:k=>0<k[3]||0<k[7]},NAN:{description:"Contains NaN",predicate:k=>0<k[2]},MAX_GT:{description:"Max \x3e",predicate:(k,t)=>{d(t,"MAX_GT");return k[9]>t}},MAX_LT:{description:"Max \x3c",predicate:(k,t)=>{d(t,"MAX_LT");
return k[9]<t}},MIN_GT:{description:"Min \x3e",predicate:(k,t)=>{d(t,"MIN_GT");return k[8]>t}},MIN_LT:{description:"Min \x3c",predicate:(k,t)=>{d(t,"MIN_LT");return k[8]<t}},MEAN_GT:{description:"Mean \x3e",predicate:(k,t)=>{d(t,"MEAN_GT");return k[10]>t}},MEAN_LT:{description:"Mean \x3c",predicate:(k,t)=>{d(t,"MEAN_LT");return k[10]<t}},RANGE_GT:{description:"Max - Min \x3e",predicate:(k,t)=>{d(t,"RANGE_GT");return k[9]-k[8]>t}},RANGE_LT:{description:"Max - Min \x3c",predicate:(k,t)=>{d(t,"RANGE_LT");
return k[9]-k[8]<t}},STDDEV_GT:{description:"Standard deviation \x3e",predicate:(k,t)=>{d(t,"STDDEV_GT");return Math.sqrt(k[11])>t}},STDDEV_LT:{description:"Standard deviation \x3c",predicate:(k,t)=>{d(t,"STDDEV_LT");return Math.sqrt(k[11])<t}}};b.tensorConditionDescription2Key=function(k){for(const t in h)if(h.hasOwnProperty(t)&&h[t].description===k)return t;return null};b.checkHealthPillAgainstTensorConditionKey=function(k,t,l){if(f(t))return!1;k=h[k].predicate;return k(t,l)}})(Vi||(Vi={}));

//# sourceURL=build://tf-debugger-dashboard/tf-debugger-continue-dialog.html.js
Polymer({is:"tf-debugger-continue-dialog",properties:{continueNum:{type:Number,value:5},sessionRunGo:Function,tensorConditionGo:Function,forceContinuationStop:Function,_continueButtonText:{type:String,value:"Continue..."},_continueButtonContinueText:{type:String,value:"Continue...",readonly:!0},_continueButtonStopText:{type:String,value:"Stop Continuation",readonly:!0},_selectedTensorCondition:String,_tensorConditionRefValue:{type:Number,value:0,notify:!0},_isRefValueInputHidden:{type:Boolean,value:!0,
notify:!0}},observers:["_onSelectedTensorConditionChanged(_selectedTensorCondition)"],notifyContinuationStop(){this.updateContinueButtonText(!1)},_openDialog(){this.$.continueDialog.open()},_closeDialog(){this.$.continueDialog.close()},_continueButtonCallback(){this._continueButtonText===this._continueButtonStopText?this.forceContinuationStop():this._openDialog()},updateContinueButtonText(b){this.set("_continueButtonText",b?this._continueButtonStopText:this._continueButtonContinueText)},_sessionRunGoButtonCallback(){0<
this.continueNum?(this.sessionRunGo(this.continueNum),this.updateContinueButtonText(!0),this._closeDialog()):this.set("continueNum",1)},_tensorContinueGoButtonCallback(){if(null!=this._selectedTensorCondition){var b=Vi.tensorConditionDescription2Key(this._selectedTensorCondition);null==b&&console.error("Invalid Tensor Condition name:"+this._selectedTensorCondition);var d=Number(this._tensorConditionRefValue);Number.isFinite(d)?(this.tensorConditionGo(b,d),this.updateContinueButtonText(!0),this._closeDialog()):
this.set("_tensorConditionRefValue",0)}},_onSelectedTensorConditionChanged(b){b=Vi.tensorConditionDescription2Key(b);this.set("_isRefValueInputHidden",-1!==["INF_OR_NAN","INF","NAN"].indexOf(b))}});

//# sourceURL=build://tf-debugger-dashboard/tf-debugger-initial-dialog.html.js
Polymer({is:"tf-debugger-initial-dialog",properties:{_title:{type:String,value:null},_customMessage:{type:String,value:null},_hasCustomMessage:{type:Boolean,computed:"_computeHasCustomMessage(_customMessage)"},_host:{type:String,value:null},_port:{type:String,value:null},_open:{type:Boolean},_hidden:{type:Boolean,computed:"_computeHidden(_open)",reflectToAttribute:!0}},openDialog(b,d){this.set("_title","Debugger is waiting for Session.run() connections...");this.set("_customMessage",null);this.$.dialog.open();
null!=b&&null!=d&&(this.set("_host",b),this.set("_port",d))},closeDialog(){this.$.dialog.close()},openDisabledDialog(){this.set("_title","Debugger is not enabled in this TensorBoard instance");this.set("_customMessage","To enable the debugger in TensorBoard, use the flag: --debugger_port \x3cport_number\x3e");this.$.dialog.open()},_computeHidden(b){return!b},_computeHasCustomMessage(b){return!_.isEmpty(b)}});

//# sourceURL=build://tf-debugger-dashboard/tf-debugger-resizer.html.js
Polymer({is:"tf-debugger-resizer",properties:{currentLength:{type:Number,notify:!0},minLength:Number,maxLength:Number,isHorizontal:{type:Boolean,value:!1,reflectToAttribute:!0},_resizerIdentifier:{type:Boolean,value:!0,readOnly:!0,reflectToAttribute:!0},_isVertical:{type:Boolean,computed:"_computeIsVertical(isHorizontal)",reflectToAttribute:!0,readOnly:!0},_dragStartPosition:Number,_dragStartLength:Number,_previousMouseMoveCallback:Object,_previousMouseUpCallback:Object},listeners:{mousedown:"_handleMouseDown"},
_handleMouseDown(b){b.preventDefault();this._endDrag();this._previousMouseMoveCallback=d=>{d.preventDefault();d=this._dragStartLength+(this._getPositionRelativeToViewport(d)-this._dragStartPosition);d=Math.max(d,this.minLength);d=Math.min(d,this.maxLength);this.set("currentLength",d)};this._previousMouseUpCallback=d=>{d.preventDefault();this._endDrag()};this.set("_dragStartPosition",this._getPositionRelativeToViewport(b));this.set("_dragStartLength",this.currentLength);window.addEventListener("mouseup",
this._previousMouseUpCallback,!1);window.addEventListener("mousemove",this._previousMouseMoveCallback,!1)},_getPositionRelativeToViewport(b){return this.isHorizontal?b.clientY:b.clientX},_endDrag(){window.removeEventListener("mousemove",this._previousMouseMoveCallback,!1);this._previousMouseMoveCallback=null;window.removeEventListener("mouseup",this._previousMouseUpCallback,!1);this._previousMouseUpCallback=null},_computeIsVertical(b){return!b}});

//# sourceURL=build://tf-debugger-dashboard/selection-tree-node.js
(function(b){b.NODE_NAME_SEPARATOR="/";b.DEVICE_NAME_PATTERN=/^\/job:[A-Za-z0-9_]+\/replica:[0-9_]+\/task:[0-9]+\/device:[A-Za-z0-9_]+:[0-9]+/;let d;(function(k){k[k.EMPTY=0]="EMPTY";k[k.CHECKED=1]="CHECKED";k[k.PARTIAL=2]="PARTIAL"})(d=b.CheckboxState||(b.CheckboxState={}));b.splitNodeName=function(k){let t=[];const l=k.match(b.DEVICE_NAME_PATTERN);null!=l&&(t.push(l[0]),"/"!==k[l[0].length]&&console.error('No slash ("/") after device name in node name:',k),k=k.slice(l[0].length+1));return t.concat(k.split(b.NODE_NAME_SEPARATOR))};
b.getCleanNodeName=function(k){let t=k;const l=k.match(b.DEVICE_NAME_PATTERN);null!=l?(t.length>l[0].length&&"/"!=t[l[0].length]&&console.error('No slash ("/") after device name in node name:',k),t=t.slice(l[0].length+1)):"/"===t[0]&&(t=t.slice(1));t.indexOf(")")===t.length-1&&(t=t.slice(0,t.indexOf("/(")));return t};b.sortAndBaseExpandDebugWatches=function(k){k.sort((l,p)=>l.node_name<p.node_name?-1:l.node_name>p.node_name?1:l.output_slot-p.output_slot);for(let l=0;l<k.length;++l){var t=k[l].node_name+
"/";let p=!1;for(let m=l+1;m<k.length;++m)if(0===k[m].node_name.indexOf(t)){p=!0;break}p&&(t=k[l].node_name.split("/"),k[l].node_name+="/("+t[t.length-1]+")")}};b.removeNodeNameBaseExpansion=function(k){return k.endsWith(")")?k.slice(0,k.lastIndexOf("/(")):k};b.assembleDeviceAndNodeNames=function(k){const t=[null,null];if(k[0].match(b.DEVICE_NAME_PATTERN)){let l=k[0];"/"===l[l.length-1]&&(l=l.slice(0,l.length-1));t[0]=l;t[1]=k.slice(1).join("/")}else t[1]=k.join("/");return t};let f;(function(k){k[k.NodeName=
0]="NodeName";k[k.OpType=1]="OpType"})(f=b.DebugWatchFilterMode||(b.DebugWatchFilterMode={}));b.filterDebugWatches=function(k,t,l){if(t===f.NodeName)return k.filter(p=>p.node_name.match(l));if(t===f.OpType)return k.filter(p=>p.op_type.match(l))};class h{constructor(k,t,l,p){this.debugWatchChange=t;this.debugWatch=p;this.name=k;this.debugWatch=p;this.checkboxState=d.EMPTY;this.parent=l;this.children={};this.checkbox=document.createElement("paper-checkbox");this.checkbox.addEventListener("change",()=>
{this._handleChange()},!1)}_handleChange(){if(this.avoidPropagation)this.debugWatch&&this.debugWatchChange(this.debugWatch,this.isCheckboxChecked());else if(this.debugWatch)this.setCheckboxState(this.isCheckboxChecked()?d.CHECKED:d.EMPTY,!0),this.isCheckboxChecked()?this.setNodesAboveToChecked():this.setNodesAboveToEmpty(),this.debugWatchChange(this.debugWatch,this.isCheckboxChecked());else if(this.setCheckboxState(this.isCheckboxChecked()?d.CHECKED:d.EMPTY,!0),this.isCheckboxChecked()){const t=_.values(this.children);
for(;t.length;){var k=t.pop();_.forEach(k.children,l=>t.push(l));k.setCheckboxState(d.CHECKED,!0)}this.setNodesAboveToChecked()}else{const t=_.values(this.children);for(;t.length;)k=t.pop(),_.forEach(k.children,l=>t.push(l)),k.setCheckboxState(d.EMPTY,!0);this.setNodesAboveToEmpty()}}isLeaf(){return!!this.debugWatch}setToAllCheckedExternally(){this.setCheckboxState(d.CHECKED);this._handleChange()}setCheckboxState(k,t){this.avoidPropagation=t;this.checkboxState=k;this.checkbox.classList.toggle("partial-checkbox",
k===d.PARTIAL);k===d.CHECKED?this.checkbox.setAttribute("checked","checked"):this.checkbox.removeAttribute("checked");this.avoidPropagation=!1}isCheckboxChecked(){return this.checkbox.hasAttribute("checked")}setNodesAboveToChecked(){let k=this.parent,t=!1;for(;k;)t?k.setCheckboxState(d.PARTIAL,!0):(t=-1!==_.findIndex(_.values(k.children),l=>l.checkboxState!==d.CHECKED),k.setCheckboxState(t?d.PARTIAL:d.CHECKED,!0)),k=k.parent}setNodesAboveToEmpty(){let k=this.parent,t=!1;for(;k;)t?k.setCheckboxState(d.PARTIAL,
!0):(t=-1!==_.findIndex(_.values(k.children),l=>l.checkboxState!==d.EMPTY),k.setCheckboxState(t?d.PARTIAL:d.EMPTY,!0)),k=k.parent}setLevelDom(k){this.levelDom=k}}b.SelectionTreeNode=h})(Vi||(Vi={}));

//# sourceURL=build://tf-debugger-dashboard/tf-op-selector.html.js
Polymer({is:"tf-op-selector",properties:{debugWatches:Array,debugWatchChange:Object,nodeClicked:Function,forceExpandAndCheckNodeName:{type:String,value:null},forceExpandNodeName:{type:String,value:null},_selectedDebugWatchMapping:{type:Object,value:()=>({})},_levelName2Container:{type:Object,value:null},_levelName2Node:{type:Object,value:null},_watchHierarchy:{type:Object,computed:"_computeWatchHierarchy(debugWatches, debugWatchChange, _filterMode, _filterInput)"},_filterMode:{type:String,value:"Node Name",
notify:!0},_filterInput:{type:String,value:"",notify:!0},_isLoading:{type:Boolean,value:!1},_highlightedLevelDom:{type:Object,value:null}},observers:["_renderHierarchyWithTimeout(_watchHierarchy, debugWatchChange)","_handleForceNodeExpandAndCheck(forceExpandAndCheckNodeName)","_handleForceNodeExpand(forceExpandNodeName)"],_computeWatchHierarchy(b,d,f,h){h=h.trim();let k=b;null!=f&&0<h.length&&(k=Vi.filterDebugWatches(b,Vi.DebugWatchFilterMode[f.replace(/\s/g,"")],new RegExp(h)));const t=new Vi.SelectionTreeNode("",
d);t.isRoot=!0;_.forEach(k,l=>{const p=Vi.splitNodeName(l.device_name+"/"+l.node_name);let m=t;_.forEach(p,(n,q)=>{q===p.length-1?(q=new Vi.SelectionTreeNode(n,d,m,l),m.children[n]=q):(m.children[n]||(m.children[n]=new Vi.SelectionTreeNode(n,d,m)),m=m.children[n])})});return t},_clearSelectorHierarchy(){const b=this.$$("#selector-hierarchy");for(;b.firstChild;)b.removeChild(b.firstChild)},_renderHierarchyWithTimeout(b,d,f,h){this._isLoading||(this.set("_isLoading",!0),this._clearSelectorHierarchy(),
setTimeout(()=>{this._renderHierarchy(b,d,f,h)},10))},_renderHierarchy(b,d){this.set("_levelName2Container",{});this.set("_levelName2Node",{});b=this._renderLevel(null,null,b,d);Polymer.dom(this.$$("#selector-hierarchy")).appendChild(b);this.set("_isLoading",!1)},_renderLevel(b,d,f,h){const k=document.createElement("div");null!=b&&k.setAttribute("level-name",b);let t;t=null==d?b:d+"/"+b;Polymer.dom(k).classList.add("level-container");const l=document.createElement("iron-collapse");if(b){this._levelName2Container[t]=
l;l.removeAttribute("opened");Polymer.dom(k).classList.add("indented-level-container");d=document.createElement("div");Polymer.dom(d).classList.add("level-title");const n=document.createElement("paper-icon-button");Polymer.dom(n).classList.add("node-expand-button");const q=()=>{n.setAttribute("icon",l.hasAttribute("opened")?"expand-less":"expand-more")};n.addEventListener("click",()=>{l.hasAttribute("opened")?l.removeAttribute("opened"):l.setAttribute("opened",!0);q()},!1);q();Polymer.dom(d).appendChild(n);
Polymer.dom(d).appendChild(f.checkbox);f.setLevelDom(d);const u=document.createElement("span");Polymer.dom(u).classList.add("level-title-text");u.textContent=b;Polymer.dom(d).appendChild(u);Polymer.dom(k).appendChild(d);(b.match(Vi.DEVICE_NAME_PATTERN)||1===Object.keys(f.children).length)&&l.setAttribute("opened",!0)}else l.setAttribute("opened",!0);const p=[],m=[];Polymer.dom(l).classList.add("content-container");_.forEach(f.children,(n,q)=>{const u=n.debugWatch;var x=t;null==t&&(x="");x+="/"+q;
this._levelName2Node[x]=n;null!=this._selectedDebugWatchMapping[x]&&(n.setCheckboxState(Vi.CheckboxState.CHECKED),n.setNodesAboveToChecked());if(u){x=document.createElement("div");Polymer.dom(x).classList.add("op-description");n.checkbox.addEventListener("change",y=>{this._handleLeafNodeSelected(h,u,y.target.checked)},!1);Polymer.dom(x).appendChild(n.checkbox);n.setLevelDom(x);var A=document.createElement("span");A.textContent="["+u.op_type+"]";A.setAttribute("class","op-type");Polymer.dom(x).appendChild(A);
A=document.createElement("span");A.textContent=q;A.setAttribute("class","op-title-leaf");A.addEventListener("click",()=>{const y=this._getDeviceAndNodeNames(q,k);this.nodeClicked(y[0],y[1])},!1);Polymer.dom(x).appendChild(A);m.push(x)}else n.checkbox.addEventListener("change",y=>{this._handleMetaNodeChange(n,h,y.target.checked)}),p.push(this._renderLevel(q,t,n,h))});b=n=>{Polymer.dom(l).appendChild(n)};_.forEach(m,b);_.forEach(p,b);Polymer.dom(k).appendChild(l);return k},_getLeafDebugWatches(b,d){b.debugWatch?
d.push(b.debugWatch):_.forEach(b.children,f=>{this._getLeafDebugWatches(f,d)})},_getDeviceAndNodeNames(b,d){for(b=[b];;){const f=d.getAttribute("level-name");if(null==f)break;else b.push(f);d=Polymer.dom(d).parentNode.parentNode}b.reverse();return Vi.assembleDeviceAndNodeNames(b)},_handleMetaNodeChange(b,d,f){let h=[];this._getLeafDebugWatches(b,h);_.forEach(h,k=>{this._handleLeafNodeSelected(d,k,f)})},_handleLeafNodeSelected(b,d,f){const h=d.device_name+"/"+d.node_name;f?this._selectedDebugWatchMapping[h]=
d:delete this._selectedDebugWatchMapping[h];b(d,f)},_handleForceNode(b,d){this.set("_filterInput","");setTimeout(()=>{if(null!=b&&null!=this._levelName2Container){var f=Vi.splitNodeName(b);for(let k=1;k<=f.length;++k){var h=f.slice(0,k).join("/");const t=this._levelName2Node[h];null!=t&&null!=t.levelDom&&t.levelDom.scrollIntoView({block:"center",behaviour:"smooth"});k<f.length?null!=this._levelName2Container[h]&&this._levelName2Container[h].setAttribute("opened",!0):(t.debugWatch||this._handleMetaNodeChange(t,
t.debugWatchChange,!0),d&&(t.setToAllCheckedExternally(),(h=t.debugWatch)&&null==this._selectedDebugWatchMapping[h.node_name]&&(this._selectedDebugWatchMapping[b]=h)),null!=this._highlightedLevelDom&&this._highlightedLevelDom.classList.remove("highlighted"),t.levelDom.classList.add("highlighted"),this.set("_highlightedLevelDom",t.levelDom))}}},20)},_handleForceNodeExpandAndCheck(b){this._handleForceNode(b,!0)},_handleForceNodeExpand(b){this._handleForceNode(b,!1)}});

//# sourceURL=build://tf-debugger-dashboard/tf-session-runs-view.html.js
Polymer({is:"tf-session-runs-view",properties:{latestSessionRun:Object,sessionRunKeyToDeviceNames:Object,soleActive:Boolean,nodeOrTensorClicked:Function,_runKey2Count:{type:Object,value:{}},_runKey2NumDevices:{type:Object,value:{}},_activeRunKey:String},observers:["renderLatest(latestSessionRun)","setSoleActiveStatus(soleActive)"],renderLatest(b){b=JSON.stringify(b);this._runKey2Count[b]=void 0===this._runKey2Count[b]?1:this._runKey2Count[b]+1;void 0===this._runKey2NumDevices[b]&&(this._runKey2NumDevices[b]=
0);this._activeRunKey=b;this._renderSessionRunTable()},updateNumDevices(b){null!=this._activeRunKey&&(this._runKey2NumDevices[this._activeRunKey]=b,this._renderSessionRunTable())},setSoleActiveStatus(){this._renderSessionRunTable()},_renderSessionRunTable(){this._clearTable();this._renderHeader();let b;for(const f in this._runKey2Count)if(this._runKey2Count.hasOwnProperty(f)){var d=JSON.parse(f);(d=this._renderRow(d,this._runKey2NumDevices[f],this._runKey2Count[f],this._activeRunKey===f,this.soleActive))&&
(b=d)}b&&(Polymer.dom(this.$$("#session-runs-table")).parentNode.parentNode.scrollTop=b.offsetTop)},_clearTable(){const b=this.$$("#session-runs-table");for(;b.firstChild;)b.removeChild(b.firstChild)},_renderHeader(){const b=document.createElement("tr"),d=document.createElement("th");d.textContent="Feeds";const f=document.createElement("th");f.textContent="Fetches";const h=document.createElement("th");h.textContent="Targets";const k=document.createElement("th");k.textContent="#(Devices)";const t=
document.createElement("th");t.textContent="Count";b.appendChild(d);b.appendChild(f);b.appendChild(h);b.appendChild(k);b.appendChild(t);Polymer.dom(this.$$("#session-runs-table")).appendChild(b)},_renderRow(b,d,f,h,k){const t=document.createElement("tr"),l=this._renderGraphElements(b.feeds),p=this._renderGraphElements(b.fetches);b=this._renderGraphElements(b.targets);const m=document.createElement("td");m.textContent=d;d=document.createElement("td");d.textContent=f;t.appendChild(l);t.appendChild(p);
t.appendChild(b);t.appendChild(m);t.appendChild(d);h&&(k?t.setAttribute("class","sole-active-session-run"):t.setAttribute("class","active-session-run"));Polymer.dom(this.$$("#session-runs-table")).appendChild(t);if(h)return t},_renderGraphElements(b){const d=document.createElement("td");_.forEach(b,f=>{const h=document.createElement("div");h.textContent=f;h.setAttribute("class","node-or-tensor-element");h.addEventListener("click",()=>{this.nodeOrTensorClicked(f)});d.appendChild(h)});return d}});

//# sourceURL=build://tf-debugger-dashboard/tf-source-code-view.html.js
Polymer({is:"tf-source-code-view",properties:{requestManager:{type:Object,value:null},focusNodeName:{type:String,value:null},_oldFocusNodeName:{type:String,value:null},debugWatches:{type:Array,value:[]},nodeClicked:{type:Function,value:null},continueToNode:{type:Function,value:null},_highlightedElements:{type:Array,value:[]},_filePathSelected:Number,_fullFilePaths:{type:Array,value:null},_shortFilePaths:{type:Array,value:null},_fileLines:{type:Array,value:null},_nodeName2DeviceName:{type:Object,value:null},
_nodeName2BaseExpandedNodeName:{type:Object,value:null},_nodeName2NodeElements:{type:Object,value:null},_nodeName2StackTopNodeElement:{type:Object,value:null},_setHightlightOriginNodeElement:{type:Object,value:null},_fullStackShown:{type:Boolean,value:!1},_fullStackNodeName:{type:String,value:null},_renderDelayMillis:{type:Number,value:50,readonly:!0}},observers:["_renderFile(_filePathSelected)","_focusOnNode(focusNodeName)"],render(b){null!=b&&this.set("_debugWatches",b);this._querySourceCodeEndPoint({mode:"paths"}).then(d=>
{this.set("_fullFilePaths",d.paths);const f=d.paths.map(h=>({id:h,name:this._shortenPath(h,d.paths)}));this.set("_shortFilePaths",f);0<f.length&&this.set("_filePathSelected",0)})},_shortenPath(b){b=b.replace(/\\/g,"/");b=b.split("/");return b[b.length-1]},_renderFile(b){if(null!=b){var d=this._shortFilePaths[b].id;this._querySourceCodeEndPoint({mode:"content",file_path:d}).then(f=>{const h=[],k=f.content[d],t=f.lineno_to_op_name_and_stack_pos;f={};for(var l in t)t.hasOwnProperty(l)&&(f[l]=t[l].length);
this._filterFileTracebacksByDebugWatches(t);for(l=0;l<k.length;++l){const m=l+1;h.push({lineno:m,numNodes:null!=t[m]?String(t[m].length)+"/"+String(f[m])+" \u25bc":"",text:this._htmlEscape(k[l])})}this.set("_fileLines",h);const p=this;setTimeout(()=>{const m={},n={};for(const u in t){if(!t.hasOwnProperty(u))continue;for(var q=p.$$("#source-line-nodes-"+u);q.firstChild;)q.removeChild(q.firstChild);const x=t[u];x.sort(function(A,y){return A[0]<y[0]?-1:A[0]>y[0]?1:0});for(let A=0;A<x.length;++A){const y=
x[A][0],w=x[A][1],C=document.createElement("div"),G=document.createElement("span");G.setAttribute("class","source-line-node-enttry");G.setAttribute("sourceLineno",u);G.textContent=y;G.addEventListener("tap",()=>{this.nodeClicked(this._nodeName2DeviceName[y],this._nodeName2BaseExpandedNodeName[y],!0)});const D=document.createElement("paper-icon-button");D.setAttribute("icon","filter-list");D.setAttribute("title","Show stack");D.addEventListener("tap",()=>{this._highlightNodeElements(y);this.set("_fullStackNodeName",
y);this.set("_fullStackShown",!0);this._populateFullStack(y,this._fullFilePaths[this._filePathSelected],Number(u))});const B=document.createElement("paper-icon-button");B.setAttribute("icon","forward");B.setAttribute("title","Continue to");B.addEventListener("tap",()=>{this.nodeClicked(this._nodeName2DeviceName[y],this._nodeName2BaseExpandedNodeName[y],!0);const I=this._nodeName2DeviceName[y],N=this._nodeName2BaseExpandedNodeName[y];this.set("_setHightlightOriginNodeElement",G);this.continueToNode(I,
N)});C.appendChild(D);C.appendChild(B);C.appendChild(G);q.appendChild(C);m.hasOwnProperty(y)||(m[y]=[]);m[y].push(G);n.hasOwnProperty(y)||(n[y]=[G,w]);w>n[y][1]&&(n[y]=[G,w])}q.setAttribute("hidden",!0);q=p.$$("#source-line-node-toggle-"+u);null==q.getAttribute("tapCallbackSet")&&(q.addEventListener("tap",()=>{p._toggleLineNodes(Number(u))}),q.setAttribute("tapCallbackSet",!0))}p.set("_nodeName2NodeElements",m);for(const u in n)n.hasOwnProperty(u)&&(n[u]=n[u][0]);p.set("_nodeName2StackTopNodeElement",
n)},this._renderDelayMillis)})}},_toggleLineNodes(b,d=!1){b=this.$$("#source-line-nodes-"+b);null==b.getAttribute("hidden")&&!0!==d?b.setAttribute("hidden",!0):b.removeAttribute("hidden")},_filterFileTracebacksByDebugWatches(b){const d=this.debugWatches.map(k=>Vi.removeNodeNameBaseExpansion(k.node_name)),f={},h={};for(const k of this.debugWatches){const t=Vi.removeNodeNameBaseExpansion(k.node_name);f[t]=k.device_name;h[t]=k.node_name}this.set("_nodeName2DeviceName",f);this.set("_nodeName2BaseExpandedNodeName",
h);for(const k in b)b.hasOwnProperty(k)&&(b[k]=b[k].filter(t=>_.includes(d,t[0])))},_querySourceCodeEndPoint(b){const d=vc.getRouter().pluginRoute("debugger","/source_code");b=vc.addParams(d,b);return this.requestManager.request(b)},_htmlEscape(b){return b.replace(/ /g,"\u00a0")},_focusOnNode(b){if(null!=b){var d=this._shortFilePaths[this._filePathSelected].id,f=this;this._querySourceCodeEndPoint({mode:"op_traceback",op_name:b}).then(h=>{const k=h.op_traceback[b];h=[];for(let l=0;l<k.length;++l){const p=
k[l][1];k[l][0]===d&&h.push(p)}for(var t of f._highlightedElements)t.classList.remove("highlighted-source-line");t=[];for(const l of h)h=this.$$("#source-line-"+l),t.push(h),h.classList.add("highlighted-source-line"),f._toggleLineNodes(l,!0);f.set("_highlightedElements",t);this._highlightNodeElements(b)})}},_highlightNodeElements(b){if(null!=this._oldFocusNodeName)for(const d of this._nodeName2NodeElements[this._oldFocusNodeName])d.style["font-weight"]="normal";for(const d of this._nodeName2NodeElements[b])d.style["font-weight"]=
"bold";null==this._setHightlightOriginNodeElement?this._nodeName2StackTopNodeElement[b].scrollIntoView({block:"center",behaviour:"smooth"}):this.set("_setHightlightOriginNodeElement",null);this.set("_oldFocusNodeName",b)},_populateFullStack(b,d,f){this._querySourceCodeEndPoint({mode:"op_traceback",op_name:b}).then(h=>{const k=this.$$("#full-stack-content");for(;k.firstChild;)k.removeChild(k.firstChild);for(const t of h.op_traceback[b]){const l=document.createElement("li"),p=t[0],m=Number(t[1]);l.textContent=
p+": "+String(m);_.includes(this._fullFilePaths,p)?(l.classList.add("stack-frame-clickable"),l.style.color="blue",l.style["text-decoration"]="underline",l.style.cursor="pointer",p===d&&m===f&&(l.style["font-weight"]="bold"),l.addEventListener("tap",()=>{this.set("_filePathSelected",this._fullFilePaths.indexOf(p));setTimeout(()=>{this._toggleLineNodes(m,!0);for(const n of this._nodeName2NodeElements[b])Number(n.getAttribute("sourceLineno"))===Number(m)&&(n.scrollIntoView({block:"center",behaviour:"smooth"}),
this.set("_setHightlightOriginNodeElement",l),this._highlightNodeElements(b),d===p&&f===m||this._populateFullStack(b,p,m))},2*this._renderDelayMillis)})):(l.classList.add("stack-frame-nonclickable"),l.style.color="#555");k.appendChild(l)}})},_closeFullStackDialog(){this.set("_fullStackShown",!1)}});

//# sourceURL=build://tf-debugger-dashboard/tf-tensor-data-summary.html.js
Polymer({is:"tf-tensor-data-summary",properties:{latestTensorData:Object,expandHandler:Object,continueToCallback:Function,highlightedNodeName:{type:String,value:null},tensorNameClicked:{type:Function,value:null},getHealthPill:Function,_healthPillsEnabled:{type:Boolean,value:!0,notify:!0},_watchKeys:{type:Array,value:[]},_watchKey2Data:{type:Object,value:{}},_watchKey2Count:{type:Object,value:{}},_watchKey2ExpandHandler:{type:Object,value:{}},_watchKey2ValueShort:{type:Object,value:{}},_watchKey2Row:{type:Object,
value:{}},_activeWatchKey:String,_healthPillWidth:{type:Number,value:200,readonly:!0},_healthPillHeight:{type:Number,value:32,readonly:!0}},observers:["_renderLatest(latestTensorData, expandHandler)","_highlight(highlightedNodeName)"],listeners:{"show-health-pills.change":"_showHealthPillsChanged"},ready(){this._renderHealthPillLegend()},enableHealthPills(){this.set("_healthPillsEnabled",!0);this._renderHealthPillLegend()},_showHealthPillsChanged(){this._healthPillsEnabled?this._renderHealthPillLegend():
this._clearHealthPillLegend();this._renderAll()},_renderAll(){this._clearTensorDataTable();for(const b of this._watchKeys)this._renderLatest(this._watchKey2Data[b],this._watchKey2ExpandHandler[b])},_tensorData2WatchKey(b){return b.deviceName+"/"+b.tensorName+":"+b.debugOp},_renderLatest(b,d){if(b){var f=this._tensorData2WatchKey(b),h=null;"Uninitialized"!==b.dtype&&"Unsupported"!==b.dtype&&(h=()=>d(b));var k=null!=b.value?JSON.stringify(b.value,(t,l)=>l.toFixed?Number(l.toFixed(3)):l):"(Click to view)";
this._watchKey2Data[f]=b;-1===this._watchKeys.indexOf(f)?(this._watchKeys.push(f),this._watchKey2Count[f]=1):this._watchKey2Count[f]+=1;this._watchKey2ExpandHandler[f]=h;this._watchKey2ValueShort[f]=k;this._activeWatchKey=f;this._removeActiveStatusFromAllRows();this._renderRow(f)}},_clearTensorDataTable(){for(const b in this._watchKey2Row)this._watchKey2Row.hasOwnProperty(b)&&(this._watchKey2Row[b].remove(),delete this._watchKey2Row[b])},_clearTensorDataRow(b){for(;b.firstChild;)b.removeChild(b.firstChild)},
_clearHealthPillLegend(){const b=this.$$("#health-pill-legend");for(;b.firstChild;)b.removeChild(b.firstChild)},_renderHealthPillLegend(){this._clearHealthPillLegend();const b=this.$$("#health-pill-legend");var d=document.createElement("div");d.textContent="Legend:";b.appendChild(d);d.style["margin-right"]="0.5em";d.style.display="inline-block";for(d=0;d<tf.graph.scene.healthPillEntries.length;++d){const f=tf.graph.scene.healthPillEntries[d],h=document.createElement("div");h.style.display="inline-block";
h.style["margin-right"]="0.25em";const k=document.createElement("span");k.textContent="\u25a0";k.style.color=f.background_color;const t=document.createElement("span");t.textContent=f.label;t.style.color=f.background_color;h.appendChild(k);h.appendChild(t);b.appendChild(h)}},_removeActiveStatusFromAllRows(){for(const b in this._watchKey2Row){if(!this._watchKey2Row.hasOwnProperty(b))continue;const d=this._watchKey2Row[b];Polymer.dom(d).classList.remove("active-tensor");Polymer.dom(d).classList.remove("highlighted")}},
_renderRow(b){let d,f=!1;null!=this._watchKey2Row[b]?(d=this._watchKey2Row[b],this._clearTensorDataRow(d),f=!1):(d=document.createElement("tr"),f=!0);const h=this._watchKey2Data[b].deviceName,k=this._watchKey2Data[b].maybeBaseExpandedNodeName,t=h+"/"+k;var l=this._watchKey2Count[b],p=this._watchKey2Data[b].tensorName,m=this._watchKey2Data[b].debugOp,n=this._watchKey2ValueShort[b];const q=this._watchKey2ExpandHandler[b],u=b===this._activeWatchKey,x=document.createElement("td");Polymer.dom(x).classList.add("tensor-name");
x.style["text-decoration"]="underline";x.style.cursor="pointer";x.textContent=p;x.addEventListener("tap",()=>{null!=this.tensorNameClicked&&this.tensorNameClicked(h,k)});const A=document.createElement("td");A.textContent=l;const y=this._watchKey2Data[b].dtype;l=document.createElement("td");const w=this._watchKey2Data[b].shape;l.textContent=y;const C=document.createElement("td");C.textContent=JSON.stringify(w);const G=document.createElement("td");G.textContent=n;Polymer.dom(G).classList.add("value-expansion-link");
null!=q&&(G.addEventListener("tap",q,!1),G.style["text-decoration"]="underline",G.style.cursor="pointer");n=null;n=this._healthPillsEnabled?this._renderHealthPill(p+":"+m,{device_name:h,node_name:k,dtype:y,shape:w,value:null},q):document.createElement("td");p=document.createElement("td");m=document.createElement("paper-icon-button");m.setAttribute("icon","forward");m.setAttribute("title","Continue to");m.addEventListener("click",()=>{this.continueToCallback(h,k)});p.appendChild(m);d.appendChild(x);
d.appendChild(A);d.appendChild(l);d.appendChild(C);d.appendChild(G);d.appendChild(n);d.appendChild(p);d.setAttribute("nodeNameWithDevice",t);u&&(Polymer.dom(d).classList.add("active-tensor"),Polymer.dom(d).classList.add("highlighted"));this._watchKey2Row[b]=d;f&&Polymer.dom(this.$$("#tensor-data-table tbody")).appendChild(d);d.scrollIntoView({block:"end",inline:"nearest",behaviour:"smooth"})},_renderHealthPill(b,d,f){const h=document.createElement("td");Polymer.dom(h).classList.add("health-pill");
null!=f&&h.addEventListener("tap",f,!1);f=document.createElementNS(tf.graph.scene.SVG_NAMESPACE,"svg");f.setAttribute("width",this._healthPillWidth);f.setAttribute("height",this._healthPillHeight);const k=document.createElementNS(tf.graph.scene.SVG_NAMESPACE,"g");f.appendChild(k);h.appendChild(f);const t="tdp/"+b;this.getHealthPill(b,d.device_name,d.node_name,l=>{null==l?(h.textContent="N/A",h.style.color="gray"):(d.value=l,tf.graph.scene.addHealthPill(k,d,null,t,this._healthPillWidth,this._healthPillHeight/
2,this._healthPillHeight/2,0))});return h},_highlight(b){Polymer.dom(this.$$("#tensor-data-table"));const d=[];for(const f in this._watchKey2Row){if(!this._watchKey2Row.hasOwnProperty(f))continue;const h=this._watchKey2Row[f];null!=h.getAttribute&&(h.getAttribute("nodeNameWithDevice")===b?d.push(h):Polymer.dom(h).classList.remove("highlighted"))}if(null!=b)for(b=0;b<d.length;++b)Polymer.dom(d[b]).classList.add("highlighted"),d[b].scrollIntoView({block:"end",inline:"nearest",behaviour:"smooth"})}});

//# sourceURL=build://tensor-widget/tensor_widget_binary.js
var Wi=this&&this.__extends||function(){function b(d,f){b=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(h,k){h.__proto__=k}||function(h,k){for(var t in k)k.hasOwnProperty(t)&&(h[t]=k[t])};return b(d,f)}return function(d,f){function h(){this.constructor=d}b(d,f);d.prototype=null===f?Object.create(f):(h.prototype=f.prototype,new h)}}(),Xi=this&&this.__generator||function(b,d){function f(n){return function(q){return h([n,q])}}function h(n){if(t)throw new TypeError("Generator is already executing.");
for(;k;)try{if(t=1,l&&(p=n[0]&2?l["return"]:n[0]?l["throw"]||((p=l["return"])&&p.call(l),0):l.next)&&!(p=p.call(l,n[1])).done)return p;if(l=0,p)n=[n[0]&2,p.value];switch(n[0]){case 0:case 1:p=n;break;case 4:return k.label++,{value:n[1],done:!1};case 5:k.label++;l=n[1];n=[0];continue;case 7:n=k.ops.pop();k.trys.pop();continue;default:if(!(p=k.trys,p=0<p.length&&p[p.length-1])&&(6===n[0]||2===n[0])){k=0;continue}if(3===n[0]&&(!p||n[1]>p[0]&&n[1]<p[3]))k.label=n[1];else if(6===n[0]&&k.label<p[1])k.label=
p[1],p=n;else if(p&&k.label<p[2])k.label=p[2],k.ops.push(n);else{p[2]&&k.ops.pop();k.trys.pop();continue}}n=d.call(b,k)}catch(q){n=[6,q],l=0}finally{t=p=0}if(n[0]&5)throw n[1];return{value:n[0]?n[1]:void 0,done:!0}}var k={label:0,sent:function(){if(p[0]&1)throw p[1];return p[1]},trys:[],ops:[]},t,l,p,m;return m={next:f(0),"throw":f(1),"return":f(2)},"function"===typeof Symbol&&(m[Symbol.iterator]=function(){return this}),m},Yi=this&&this.__read||function(b,d){var f="function"===typeof Symbol&&b[Symbol.iterator];
if(!f)return b;b=f.call(b);var h,k=[];try{for(;(void 0===d||0<d--)&&!(h=b.next()).done;)k.push(h.value)}catch(l){var t={error:l}}finally{try{h&&!h.done&&(f=b["return"])&&f.call(b)}finally{if(t)throw t.error;}}return k};
(function(){function b(H,K,M,L){return new (M||(M=Promise))(function(Q,T){function X(Z){try{la(L.next(Z))}catch(ba){T(ba)}}function aa(Z){try{la(L["throw"](Z))}catch(ba){T(ba)}}function la(Z){Z.done?Q(Z.value):(new M(function(ba){ba(Z.value)})).then(X,aa)}la((L=L.apply(H,K||[])).next())})}function d(H){return null!==H.match(/^int[0-9]+$/)||null!==H.match(/^uint[0-9]+$/)}function f(H){return null!==H.match(/^float[0-9]+$/)||null!==H.match(/^bfloat[0-9]+$/)}function h(H){return"bool"===H.toLowerCase()||
"boolean"===H.toLowerCase()}function k(H){return"str"===H.toLowerCase()||"string"===H.toLowerCase()}function t(H){var K=1;H.forEach(function(M){K*=M});return K}function l(H){return 0===H.length?"scalar":"["+H+"]"}function p(H){var K={slicingDimsAndIndices:[],viewingDims:[],verticalRange:null,horizontalRange:null},M=H.length;if(1===M)K.viewingDims=[0];else if(1<M){if(2<M)for(var L=0;L<M-2;++L)K.slicingDimsAndIndices.push({dim:L,index:0===H[L]?null:0});for(L=H.length-2;L<H.length;++L)K.viewingDims.push(L)}return K}
function m(H,K){if(H.viewingDims[0]!==K.viewingDims[0]||H.viewingDims[1]!==K.viewingDims[1])return!1;K=H.slicingDimsAndIndices.map(function(M){return M.dim});K.sort();H=H.slicingDimsAndIndices.map(function(M){return M.dim});H.sort();return JSON.stringify(K)===JSON.stringify(H)}function n(H){return 20>=H.length?H:H.slice(0,10)+"..."+H.slice(H.length-7,H.length)}function q(H,K,M,L){void 0===M&&(M=2);if(isNaN(H))return"NaN";if(-Infinity===H)return"-\u221e";if(Infinity===H)return"+\u221e";null==L&&(L=
Math.abs(H),L=1E3>L&&.01<=L||0===L?"fixed":"exponential");return null==L||"fixed"===L?K?""+H:H.toFixed(M):H.toExponential(M)}function u(H,K){void 0===K&&(K=!0);return H?K?"T":"True":K?"F":"False"}function x(H,K){void 0===K&&(K=4);return null===K||H.length<=K?H:H.slice(0,K-1)+"\u2026"}var A=function(){function H(K){this.isShown=!1;this.blurHideFunction=null;this.dropdown=document.createElement("div");this.dropdown.classList.add("tensor-widget-dim-dropdown");this.dropdown.style.position="fixed";this.dropdown.style.display=
"none";K.appendChild(this.dropdown)}H.prototype.show=function(K,M,L){var Q=this;L.forEach(function(X){var aa=document.createElement("div");aa.classList.add("tensor-widget-dim-dropdown-menu-item");aa.textContent=X.caption;Q.dropdown.appendChild(aa);X.disabled?aa.classList.add("tensor-widget-dim-dropdown-menu-item-disabled"):(aa.addEventListener("click",function(la){la.stopPropagation();Q.dropdown.click();if(null!==X.onClick)X.onClick(la);Q.hide()}),aa.addEventListener("mouseenter",function(la){if(null!==
X.onHover)X.onHover(la);aa.classList.add("tensor-widget-dim-dropdown-menu-item-active")}),aa.addEventListener("mouseleave",function(){aa.classList.remove("tensor-widget-dim-dropdown-menu-item-active");if(null!==X.onHover){for(var la=[],Z=0;Z<aa.children.length;++Z){var ba=aa.children[Z];ba.classList.contains("tensor-widget-dim-dropdown")&&la.push(ba)}la.forEach(function(ea){return aa.removeChild(ea)})}}))});this.dropdown.style.display="block";this.dropdown.style.top=K+"px";this.dropdown.style.left=
M+"px";L=this.dropdown.getBoundingClientRect();var T=L.left-M;this.dropdown.style.top=(K-(L.top-K)).toFixed(1)+"px";this.dropdown.style.left=(M-T).toFixed(1)+"px";this.isShown=!0;this.blurHideFunction=function(){Q.hide()};setTimeout(function(){return window.addEventListener("click",Q.blurHideFunction)},50)};H.prototype.hide=function(){for(this.dropdown.style.display="none";this.dropdown.firstChild;)this.dropdown.removeChild(this.dropdown.firstChild);this.isShown=!1;null!=this.blurHideFunction&&window.removeEventListener("click",
this.blurHideFunction)};H.prototype.shown=function(){return this.isShown};return H}(),y=function(){function H(K,M){var L=this;this.config=K;this.parentElement=M;this.baseFlatMenu=new A(this.parentElement);this.currentChoiceSelections={};this.config.items.forEach(function(Q,T){null!=Q.options&&(L.currentChoiceSelections[T]=Q.defaultSelection)})}H.prototype.show=function(K,M){var L=this,Q=[];this.config.items.forEach(function(T,X){var aa={caption:T.caption,onClick:null,onHover:null};if(null!=T.options){var la=
L.currentChoiceSelections[X];aa.onHover=function(Z){var ba=Z.target,ea=[];T.options.forEach(function(ca,ka){ea.push({caption:ka===la?ca+" (\u2713)":ca,onClick:function(){la!==ka&&(L.currentChoiceSelections[X]=ka,T.callback(ka))},onHover:null})});Z=new A(ba);ba=ba.getBoundingClientRect();Z.show(ba.top,ba.right,ea)}}else aa.onClick=T.callback;null==T.isEnabled||T.isEnabled()||(aa.disabled=!0);Q.push(aa)});this.baseFlatMenu.show(K,M,Q)};H.prototype.hide=function(){this.baseFlatMenu.hide()};H.prototype.shown=
function(){return this.baseFlatMenu.shown()};return H}(),w;(function(H){H[H.UP=1]="UP";H[H.DOWN=2]="DOWN";H[H.LEFT=3]="LEFT";H[H.RIGHT=4]="RIGHT"})(w||(w={}));var C=function(){function H(K,M,L,Q,T,X){this.shape=K;this.sliceDims=[];this.sliceIndices=[];if(0===t(this.shape))throw Error("TensorElementSelection doesn't support tensor with zero elements.");for(K=0;K<M.slicingDimsAndIndices.length;++K){this.sliceDims.push(M.slicingDimsAndIndices[K].dim);var aa=M.slicingDimsAndIndices[K].index;if(null===
aa)throw Error("Failed to create TensorElementSelection due to undetermined slicing index at dimension "+K);this.sliceIndices.push(aa)}this.rank=this.shape.length;if(0<this.rank&&this.sliceDims.length>=this.rank)throw Error("Expected sliceDims to have a length less than rank "+this.rank+", but got length "+this.sliceDims.length);this.viewDims=[];for(K=0;K<this.rank;++K)-1===this.sliceDims.indexOf(K)&&this.viewDims.push(K);if(2<this.viewDims.length)throw Error("Only selections in 1D and 2D are supported.");
this.rowStart=null==L?0:L;this.colStart=null==Q?0:Q;this.rowCount=null==T?1:T;this.colCount=null==X?1:X}H.prototype.getElementStatus=function(K){if(K.length!==this.rank)throw Error("Expected indices to have a rank of "+this.rank+", but got "+(K.length+" (["+K+"])"));for(var M=0;M<K.length;++M)if(-1!==this.sliceDims.indexOf(M)&&K[M]!==this.sliceIndices[this.sliceDims.indexOf(M)])return null;M=null;var L=this.rowStart+this.rowCount,Q=this.colStart+this.colCount;if(0===this.viewDims.length)0===K.length&&
(M={topEdge:!0,bottomEdge:!0,leftEdge:!0,rightEdge:!0});else if(1===this.viewDims.length){var T=this.viewDims[0];K[T]>=this.rowStart&&K[T]<L&&(M={topEdge:K[T]===this.rowStart,bottomEdge:K[T]===L-1,leftEdge:!0,rightEdge:!0})}else if(2===this.viewDims.length){T=this.viewDims[0];var X=this.viewDims[1];K[T]>=this.rowStart&&K[T]<L&&K[X]>=this.colStart&&K[X]<Q&&(M={topEdge:K[T]===this.rowStart,bottomEdge:K[T]===L-1,leftEdge:K[X]===this.colStart,rightEdge:K[X]===Q-1})}else throw Error("Unexpected length of viewDims: "+
this.viewDims);return M};H.prototype.move=function(K,M){var L=null;if(0===this.rank||1===this.rank&&(K===w.LEFT||K===w.RIGHT))return null;if(null===M.verticalRange||null===M.verticalRange[1])throw Error("Failed to move due to undetermined vertical range.");K===w.UP?0<this.rowStart&&(this.rowStart--,null!=M.verticalRange&&this.rowStart<M.verticalRange[0]&&(L=w.UP)):K===w.DOWN?null!=M.viewingDims&&null!=M.viewingDims[0]&&this.rowStart<this.shape[M.viewingDims[0]]-1&&(this.rowStart++,null!=M.verticalRange&&
this.rowStart>=M.verticalRange[1]&&(L=w.DOWN)):K===w.LEFT?0<this.colStart&&(this.colStart--,null!=M.horizontalRange&&this.colStart<M.horizontalRange[0]&&(L=w.LEFT)):K===w.RIGHT&&null!=M.viewingDims&&null!=M.viewingDims[1]&&this.colStart<this.shape[M.viewingDims[1]]-1&&(this.colStart++,null!=M.horizontalRange&&this.colStart>=M.horizontalRange[1]&&(L=w.RIGHT));this.colCount=this.rowCount=1;return L};H.prototype.getRowStart=function(){return this.rowStart};H.prototype.getRowCount=function(){return this.rowCount};
H.prototype.getColStart=function(){return this.colStart};H.prototype.getColCount=function(){return this.colCount};return H}(),G=function(){function H(K,M,L){void 0===L&&(L=function(){});this.rootDiv=K;this.shape=M;this.onSlicingSpecChange=L;this.dimControls=[];this.dimInputs=[];this.commas=[];this.dropdowns=[];this.bracketDivs=[null,null];this.dimControlsListenerAttached=[];this.rank=this.shape.length;if(3>this.rank)throw Error("Dimension control is not applicable to tensor shapes less than 3D: received "+
(this.rank+"D tensor shape: ")+(JSON.stringify(this.shape)+"."));this.createComponents();this.slicingSpec=p(M)}H.prototype.createComponents=function(){for(var K=this;this.rootDiv.firstChild;)this.rootDiv.removeChild(this.rootDiv.firstChild);this.dimControls=[];this.dimInputs=[];this.commas=[];this.dropdowns=[];this.dimControlsListenerAttached=[];this.bracketDivs[0]=document.createElement("div");this.bracketDivs[0].textContent="Slicing: [";this.bracketDivs[0].classList.add("tensor-widget-dim-brackets");
this.rootDiv.appendChild(this.bracketDivs[0]);for(var M=0;M<this.rank;++M){var L=document.createElement("div");L.classList.add("tensor-widget-dim");L.title="Dimension "+M+": size\x3d"+this.shape[M];this.rootDiv.appendChild(L);this.dimControls.push(L);this.dimControlsListenerAttached.push(!1);L=document.createElement("input");L.classList.add("tensor-widget-dim");L.style.display="none";this.rootDiv.appendChild(L);this.dimInputs.push(L);M<this.rank-1&&(L=document.createElement("div"),L.classList.add("tensor-widget-dim-comma"),
L.textContent=",",this.rootDiv.appendChild(L),this.commas.push(L));L=document.createElement("div");L.classList.add("tensor-widget-dim-dropdown");L.style.display="none";this.rootDiv.appendChild(L);this.dropdowns.push(L)}this.bracketDivs[1]=document.createElement("div");this.bracketDivs[1].textContent="]";this.bracketDivs[1].classList.add("tensor-widget-dim-brackets");this.rootDiv.appendChild(this.bracketDivs[1]);this.rootDiv.addEventListener("mouseleave",function(){K.clearAllDropdowns()})};H.prototype.render=
function(K){function M(aa){var la=X.dimControls[aa],Z=X.dimInputs[aa],ba=X.dropdowns[aa];if("none"!==Z.style.display)return"continue";var ea=X.shape[aa];if(-1!==Q.indexOf(aa)){var ca=T[Q.indexOf(aa)];la.textContent=String(ca);Z.classList.add("tensor-widget-dim");Z.type="number";Z.min="0";Z.max=String(ea-1);Z.value=String(ca);X.dimControlsListenerAttached[aa]||(la.addEventListener("click",function(){L.clearAllDropdowns();la.style.display="none";Z.style.display="inline-block"}),Z.addEventListener("change",
function(){if(null===L.slicingSpec)throw Error("Slicing control change callback failed due to missing spec.");var ka=parseInt(Z.value,10);!isFinite(ka)||0>ka||ka>=ea||Math.floor(ea)!=ea?Z.value=String(L.slicingSpec.slicingDimsAndIndices[Q.indexOf(aa)].index):(L.slicingSpec.slicingDimsAndIndices[Q.indexOf(aa)].index=ka,la.textContent=String(ka),L.onSlicingSpecChange(L.slicingSpec))}),Z.addEventListener("blur",function(){Z.style.display="none";la.style.display="inline-block"}),X.dimControlsListenerAttached[aa]=
!0)}else{if(X.slicingSpec.viewingDims[0]===aa){if(null===X.slicingSpec.verticalRange)throw Error("Missing vertical range.");la.textContent="\u2195 "+X.slicingSpec.verticalRange[0]+":"+X.slicingSpec.verticalRange[1]}else{if(null===X.slicingSpec.horizontalRange)throw Error("Missing horizontal range.");la.textContent="\u2194 "+X.slicingSpec.horizontalRange[0]+":"+X.slicingSpec.horizontalRange[1]}la.classList.add("tensor-widget-dim");X.dimControlsListenerAttached[aa]||(la.addEventListener("click",function(){var ka=
la.getBoundingClientRect();L.renderDropdownMenuItems(ba,ka.bottom,ka.left,aa)}),X.dimControlsListenerAttached[aa]=!0)}}var L=this;null!=K&&(this.slicingSpec=JSON.parse(JSON.stringify(K)));if(null===this.slicingSpec)throw Error("Slicing control rendering failed due to missing slicing spec.");var Q=this.slicingSpec.slicingDimsAndIndices.map(function(aa){return aa.dim}),T=this.slicingSpec.slicingDimsAndIndices.map(function(aa){return aa.index}),X=this;for(K=0;K<this.rank;++K)M(K)};H.prototype.renderDropdownMenuItems=
function(K,M,L,Q){function T(ea){if(-1===aa.indexOf(ea)||Q===la.slicingSpec.viewingDims[1]&&ea<=la.slicingSpec.viewingDims[0]||Q==la.slicingSpec.viewingDims[0]&&ea>=la.slicingSpec.viewingDims[1])return"continue";var ca=document.createElement("div");ca.classList.add("tensor-widget-dim-dropdown-menu-item");ca.textContent="Swap with dimension "+ea;K.appendChild(ca);ca.addEventListener("mouseenter",function(){ca.classList.add("tensor-widget-dim-dropdown-menu-item-active");X.dimControls[ea].classList.add("tensor-widget-dim-highlighted")});
ca.addEventListener("mouseleave",function(){ca.classList.remove("tensor-widget-dim-dropdown-menu-item-active");X.dimControls[ea].classList.remove("tensor-widget-dim-highlighted")});var ka=la.slicingSpec.viewingDims[0]===Q;ca.addEventListener("click",function(){if(null===X.slicingSpec)throw Error("Dimension swapping failed due to missing slicing spec");var Y=aa.indexOf(ea);X.slicingSpec.viewingDims[ka?0:1]=ea;X.slicingSpec.slicingDimsAndIndices[Y]={dim:Q,index:0};X.slicingSpec.verticalRange=null;X.slicingSpec.horizontalRange=
null;if(X.onSlicingSpecChange)X.onSlicingSpecChange(X.slicingSpec)})}var X=this;if(null===this.slicingSpec)throw Error("Slicing control cannot render dropdown menu items due to missing slicing spec.");this.clearAllDropdowns();for(var aa=this.slicingSpec.slicingDimsAndIndices.map(function(ea){return ea.dim}),la=this,Z=0;Z<this.rank;++Z)T(Z);K.addEventListener("mouseleave",function(){K.style.display="none"});if(K.firstChild){K.style.position="fixed";K.style.top=M+"px";K.style.left=L+"px";K.style.display=
"block";Z=K.getBoundingClientRect();var ba=Z.left-L;K.style.top=(M-(Z.top-M)).toFixed(1)+"px";K.style.left=(L-ba).toFixed(1)+"px"}};H.prototype.setSlicingSpec=function(K){this.slicingSpec=JSON.parse(JSON.stringify(K));if(null===this.slicingSpec)throw Error("Cannot set slicing spec to null.");this.render(this.slicingSpec)};H.prototype.clearAllDropdowns=function(){this.dropdowns.forEach(function(K){if(null!=K){for(;K.firstChild;)K.removeChild(K.firstChild);K.style.display="none"}})};return H}(),D=function(){function H(K){this.config=
K;if(!isFinite(K.min))throw Error("min value ("+K.min+") is not finite");if(!isFinite(K.max))throw Error("max value ("+K.max+") is not finite");if(K.max<K.min)throw Error("max ("+K.max+") is \x3c min ("+K.min+")");}H.prototype.render=function(K,M){if(this.config.min!==this.config.max){var L=K.getContext("2d");if(null!=L){for(var Q=K.width/100,T=K.height,X=.6*T,aa=0;100>aa;++aa){var la=Q*aa,Z=.2*T,ba=Yi(this.getRGB(aa/100*(this.config.max-this.config.min)+this.config.min),3),ea=ba[0],ca=ba[1];ba=ba[2];
L.beginPath();L.fillStyle="rgba("+ea+", "+ca+", "+ba+", 1)";L.fillRect(la,Z,Q,X);L.stroke()}null!=M&&M>=this.config.min&&M<=this.config.max&&(K=(M-this.config.min)/(this.config.max-this.config.min)*K.width,L.beginPath(),L.fillStyle="rgba(0, 0, 0, 1)",L.moveTo(K,.2*T),L.lineTo(K-4,0),L.lineTo(K+4,0),L.fill(),L.beginPath(),L.moveTo(K,.8*T),L.lineTo(K-4,T),L.lineTo(K+4,T),L.fill())}}};return H}(),B=function(H){function K(){return null!==H&&H.apply(this,arguments)||this}Wi(K,H);K.prototype.getRGB=function(M){if(isNaN(M))return[255,
0,0];if(!isFinite(M))return 0<M?[0,0,255]:[255,127.5,0];M=this.config.min===this.config.max?.5:(M-this.config.min)/(this.config.max-this.config.min);M=Math.max(Math.min(M,1),0);return[255*M,255*M,255*M]};return K}(D);D=function(H){function K(){return null!==H&&H.apply(this,arguments)||this}Wi(K,H);K.prototype.getRGB=function(M){if(isNaN(M))return[63.75,63.75,63.75];if(!isFinite(M))return 0>M?[127.5,127.5,127.5]:[191.25,191.25,191.25];var L=0,Q=0,T=0;M=this.config.min===this.config.max?.5:(M-this.config.min)/
(this.config.max-this.config.min);M=Math.max(Math.min(M,1),0);.35>=M?(Q=M/.35,T=1):.35<M&&.65>=M?(L=(M-.35)/(.65-.35),Q=1,T=(.65-M)/(.65-.35)):.65<M&&(L=1,Q=(1-M)/.35);return[255*L,255*Q,255*T]};return K}(D);var I;(function(H){H[H.TEXT=1]="TEXT";H[H.IMAGE=2]="IMAGE"})(I||(I={}));var N={Grayscale:B,Jet:D},O=function(){function H(K,M,L){this.rootElement=K;this.tensorView=M;this.baseRulerTick=this.topRuler=this.valueSection=this.slicingSpecRoot=this.menuThumb=this.infoSubsection=this.headerSection=null;
this.topRulerTicks=[];this.leftRulerTicks=[];this.valueRows=[];this.valueDivs=[];this.slicingControl=this.valueTooltip=null;this.colsCutoff=this.rowsCutoff=!1;this.menu=this.menuConfig=this.selection=null;this.colorMapName="Grayscale";this.colorMap=null;this.showIndicesOnTicks=!1;this.imageCellSize=16;this.minImageCellSize=4;this.maxImageCellSize=40;this.zoomStepRatio=1.2;this.numericSummary=null;this.options=L||{};this.slicingSpec=p(this.tensorView.spec.shape);this.rank=this.tensorView.spec.shape.length;
this.valueRenderMode=I.TEXT}H.prototype.render=function(){return b(this,void 0,void 0,function(){return Xi(this,function(K){switch(K.label){case 0:this.rootElement.classList.add("tensor-widget");this.renderHeader();if(!(d(this.tensorView.spec.dtype)||f(this.tensorView.spec.dtype)||h(this.tensorView.spec.dtype)||k(this.tensorView.spec.dtype)))throw Error("Rendering dtype "+this.tensorView.spec.dtype+" is not supported yet.");return[4,this.renderValues()];case 1:return K.sent(),[2]}})})};H.prototype.renderHeader=
function(){null==this.headerSection&&(this.headerSection=document.createElement("div"),this.headerSection.classList.add("tensor-widget-header"),this.rootElement.appendChild(this.headerSection),this.createMenu());this.renderInfo()};H.prototype.renderInfo=function(){if(null===this.headerSection)throw Error("Rendering tensor info failed due to mising header section");null==this.infoSubsection&&(this.infoSubsection=document.createElement("div"),this.infoSubsection.classList.add("tensor-widget-info"),
this.headerSection.appendChild(this.infoSubsection));for(;this.infoSubsection.firstChild;)this.infoSubsection.removeChild(this.infoSubsection.firstChild);this.renderName();this.renderDType();this.renderShape()};H.prototype.renderName=function(){if(null==this.infoSubsection)throw Error("Rendering tensor name failed due to missing info subsection.");if(null!=this.options.name&&0!==this.options.name.length){var K=document.createElement("div");K.classList.add("tensor-widget-tensor-name");K.textContent=
n(this.options.name);K.title=this.options.name;this.infoSubsection.appendChild(K)}};H.prototype.renderDType=function(){if(null==this.infoSubsection)throw Error("Rendering tensor dtype failed due to missing info subsection.");var K=document.createElement("div");K.classList.add("tensor-widget-dtype");var M=document.createElement("span");M.classList.add("tensor-widget-dtype-label");M.textContent="dtype:";K.appendChild(M);M=document.createElement("span");M.textContent=this.tensorView.spec.dtype;K.appendChild(M);
this.infoSubsection.appendChild(K)};H.prototype.renderShape=function(){if(null==this.infoSubsection)throw Error("Rendering tensor shape failed due to missing info subsection.");var K=document.createElement("div");K.classList.add("tensor-widget-shape");var M=document.createElement("div");M.classList.add("tensor-widget-shape-label");M.textContent="shape:";K.appendChild(M);M=document.createElement("div");M.classList.add("tensor-widget-shape-value");M.textContent=l(this.tensorView.spec.shape);K.appendChild(M);
this.infoSubsection.appendChild(K)};H.prototype.createMenu=function(){var K=this;this.menuConfig={items:[]};if(f(this.tensorView.spec.dtype)||d(this.tensorView.spec.dtype)||h(this.tensorView.spec.dtype))this.menuConfig.items.push({caption:"Select display mode...",options:["Text","Image"],defaultSelection:0,callback:function(M){0===M?(K.valueRenderMode=I.TEXT,K.renderValues()):(K.valueRenderMode=I.IMAGE,K.tensorView.getNumericSummary().then(function(L){K.numericSummary=L;K.renderValues()}))}}),this.menuConfig.items.push({caption:"Select color map...",
options:Object.keys(N),defaultSelection:0,callback:function(M){K.colorMapName=Object.keys(N)[M];K.renderValues()},isEnabled:function(){return K.valueRenderMode===I.IMAGE}}),this.menuConfig.items.push({caption:"Zoom in (Image mode)",callback:function(){K.zoomInOneStepAndRenderValues()},isEnabled:function(){return K.valueRenderMode===I.IMAGE}}),this.menuConfig.items.push({caption:"Zoom out (Image mode)",callback:function(){K.zoomOutOneStepAndRenderValues()},isEnabled:function(){return K.valueRenderMode===
I.IMAGE}});null!==this.menuConfig&&0<this.menuConfig.items.length&&(this.menu=new y(this.menuConfig,this.headerSection),this.renderMenuThumb())};H.prototype.zoomInOneStepAndRenderValues=function(){this.imageCellSize*this.zoomStepRatio<=this.maxImageCellSize&&(this.imageCellSize*=this.zoomStepRatio,this.renderValues())};H.prototype.zoomOutOneStepAndRenderValues=function(){this.imageCellSize/this.zoomStepRatio>=this.minImageCellSize&&(this.imageCellSize/=this.zoomStepRatio,this.renderValues())};H.prototype.renderMenuThumb=
function(){var K=this;if(null==this.headerSection)throw Error("Rendering menu thumb failed due to missing header section.");this.menuThumb=document.createElement("div");this.menuThumb.textContent="\u22ee";this.menuThumb.classList.add("tensor-widget-menu-thumb");this.headerSection.appendChild(this.menuThumb);this.menuThumb.addEventListener("click",function(){if(null!==K.menu)if(K.menu.shown())K.menu.hide();else{var M=K.menuThumb.getBoundingClientRect();K.menu.show(M.bottom,M.left)}})};H.prototype.renderValues=
function(){return b(this,void 0,void 0,function(){var K=this;return Xi(this,function(M){switch(M.label){case 0:return 2<this.rank&&null===this.slicingSpecRoot&&(this.slicingSpecRoot=document.createElement("div"),this.slicingSpecRoot.classList.add("tensor-widget-slicing-group"),this.rootElement.appendChild(this.slicingSpecRoot)),null==this.valueSection&&(this.valueSection=document.createElement("div"),this.valueSection.classList.add("tensor-widget-value-section"),this.rootElement.appendChild(this.valueSection),
this.valueSection.addEventListener("wheel",function(L){return b(K,void 0,void 0,function(){var Q;return Xi(this,function(T){switch(T.label){case 0:Q=!1;null==this.options.wheelZoomKey||"ctrl"===this.options.wheelZoomKey?Q=L.ctrlKey:"alt"===this.options.wheelZoomKey?Q=L.altKey:"shift"===this.options.wheelZoomKey&&(Q=L.shiftKey);if(Q&&this.valueRenderMode===I.IMAGE)return L.stopPropagation(),L.preventDefault(),0<L.deltaY?this.zoomOutOneStepAndRenderValues():this.zoomInOneStepAndRenderValues(),[2];if(null==
this.selection)return[2];L.stopPropagation();L.preventDefault();this.hideValueTooltip();return[4,this.scrollUpOrDown(0<L.deltaY?w.DOWN:w.UP)];case 1:return T.sent(),[2]}})})}),this.valueSection.tabIndex=1024,this.valueSection.addEventListener("keydown",function(L){var Q=[38,40,37,39];if(null!=K.selection&&-1!==Q.indexOf(L.keyCode)){L.stopPropagation();L.preventDefault();K.hideValueTooltip();var T=Q=null;38===L.keyCode?T=w.UP:40===L.keyCode?T=w.DOWN:37===L.keyCode?T=w.LEFT:39===L.keyCode&&(T=w.RIGHT);
null!==T&&(Q=K.selection.move(T,K.slicingSpec));null===Q?K.renderSelection():Q===w.UP||Q===w.DOWN?K.scrollUpOrDown(Q):(Q===w.LEFT||Q===w.RIGHT)&&K.scrollLeftOrRight(Q)}})),this.clearValueSection(),this.createTopRuler(),this.createLeftRuler(),this.createValueDivs(),[4,this.renderRulersAndValueDivs()];case 1:return M.sent(),2<this.rank&&(this.slicingControl=new G(this.slicingSpecRoot,this.tensorView.spec.shape,function(L){return b(K,void 0,void 0,function(){return Xi(this,function(Q){switch(Q.label){case 0:if(m(this.slicingSpec,
L))return[3,2];this.slicingSpec=JSON.parse(JSON.stringify(L));return[4,this.render()];case 1:return Q.sent(),[3,4];case 2:return this.slicingSpec=JSON.parse(JSON.stringify(L)),[4,this.renderRulersAndValueDivs()];case 3:Q.sent(),Q.label=4;case 4:return[2]}})})}),this.slicingControl.render(this.slicingSpec)),[2]}})})};H.prototype.clearValueSection=function(){if(null!==this.valueSection){for(;this.valueSection.firstChild;)this.valueSection.removeChild(this.valueSection.firstChild);this.topRuler=null;
this.valueRows=[]}};H.prototype.createTopRuler=function(){var K=this;if(null===this.valueSection)throw Error("Failed to create top ruler due to missing value section.");null==this.topRuler&&(this.topRuler=document.createElement("div"),this.topRuler.classList.add("tenesor-widget-top-ruler"),this.topRuler.style.whiteSpace="nowrap",this.valueSection.appendChild(this.topRuler),this.topRulerTicks=[],this.topRuler.addEventListener("wheel",function(X){return b(K,void 0,void 0,function(){return Xi(this,function(aa){switch(aa.label){case 0:if(null==
this.selection)return[2];X.stopPropagation();X.preventDefault();this.hideValueTooltip();return[4,this.scrollLeftOrRight(0<X.deltaY?w.RIGHT:w.LEFT)];case 1:return aa.sent(),[2]}})})}));for(;this.topRuler.firstChild;)this.topRuler.removeChild(this.topRuler.firstChild);this.baseRulerTick=document.createElement("div");this.baseRulerTick.classList.add("tensor-widget-top-ruler-tick");this.topRuler.appendChild(this.baseRulerTick);2<=this.rank&&(this.slicingSpec.horizontalRange=[0,null]);var M=1>=this.rank?
1:this.tensorView.spec.shape[this.slicingSpec.viewingDims[1]];var L=this.rootElement.getBoundingClientRect().right;this.colsCutoff=!1;for(var Q=0;Q<M;++Q){var T=document.createElement("div");T.classList.add("tensor-widget-top-ruler-tick");this.valueRenderMode===I.IMAGE&&(T.style.width=this.imageCellSize+"px");this.topRuler.appendChild(T);this.topRulerTicks.push(T);if(T.getBoundingClientRect().right>=L){if(2<=this.rank){if(null===this.slicingSpec.horizontalRange)throw Error("Missing horizontal range for "+
this.rank+"D tensor.");this.slicingSpec.horizontalRange[1]=Q+1;this.colsCutoff=!0}break}}if(!this.colsCutoff&&2<=this.rank){if(null===this.slicingSpec.horizontalRange)throw Error("Missing horizontal range for "+this.rank+"D tensor.");this.slicingSpec.horizontalRange[1]=M}};H.prototype.createLeftRuler=function(){if(null===this.valueSection)throw Error("Failed to create left ruler due to missing value section.");this.valueRows=[];this.leftRulerTicks=[];1<=this.rank&&(this.slicingSpec.verticalRange=
[0,null]);var K=0===this.rank?1:this.tensorView.spec.shape[this.slicingSpec.viewingDims[0]];this.rowsCutoff=!1;for(var M=this.rootElement.getBoundingClientRect().bottom,L=0;L<K;++L){var Q=document.createElement("div");Q.classList.add("tensor-widget-value-row");this.valueRenderMode===I.IMAGE&&(Q.style.height=this.imageCellSize+"px",Q.style.lineHeight=this.imageCellSize+"px");this.valueSection.appendChild(Q);this.valueRows.push(Q);var T=document.createElement("div");T.classList.add("tensor-widget-top-ruler-tick");
this.valueRenderMode===I.IMAGE&&(T.style.height=this.imageCellSize+"px",T.style.lineHeight=this.imageCellSize+"px");Q.appendChild(T);this.leftRulerTicks.push(T);if(T.getBoundingClientRect().bottom>=M){if(1<=this.rank){if(null===this.slicingSpec.verticalRange)throw Error("Missing vertical range for "+this.rank+"D tensor.");this.slicingSpec.verticalRange[1]=L+1;this.rowsCutoff=!0}break}}if(!this.rowsCutoff&&1<=this.rank){if(null===this.slicingSpec.verticalRange)throw Error("Missing vertical range for "+
this.rank+"D tensor.");this.slicingSpec.verticalRange[1]=K}};H.prototype.createValueDivs=function(){function K(aa){function la(ba){var ea=document.createElement("div");ea.classList.add("tensor-widget-value-div");T.valueRenderMode===I.IMAGE&&(ea.style.width=T.imageCellSize+"px",ea.style.height=T.imageCellSize+"px",ea.style.lineHeight=T.imageCellSize+"px");T.valueRows[aa].appendChild(ea);T.valueDivs[aa].push(ea);ea.addEventListener("click",function(){M.selection=new C(M.tensorView.spec.shape,M.slicingSpec,
null==M.slicingSpec.verticalRange||null==M.slicingSpec.verticalRange[0]?0:M.slicingSpec.verticalRange[0]+aa,null==M.slicingSpec.horizontalRange||null==M.slicingSpec.horizontalRange[0]?0:M.slicingSpec.horizontalRange[0]+ba,1,1);M.renderSelection()});ea.addEventListener("mouseenter",function(){var ca=ea.getAttribute("detailed-value");if(null!==ca){var ka=M.rootElement.getBoundingClientRect(),Y=ea.getBoundingClientRect(),Ea=Y.bottom-Y.top,va=Y.right-Y.left,xa=M.calculateIndices(aa,ba);M.drawValueTooltip(xa,
ca,Y.top-ka.top+.8*Ea,Y.left-ka.left+.75*va)}});ea.addEventListener("mouseleave",function(){M.hideValueTooltip()})}T.valueDivs[aa]=[];for(var Z=0;Z<L;++Z)la(Z)}var M=this;if(null===this.valueRows)throw Error("Value rows are unexpectedly uninitialized.");this.valueDivs=[];for(var L=this.topRulerTicks.length,Q=this.valueRows.length,T=this,X=0;X<Q;++X)K(X)};H.prototype.renderTopRuler=function(){if(2<=this.rank)for(var K=this.tensorView.spec.shape[this.slicingSpec.viewingDims[1]],M=0;M<this.topRulerTicks.length;++M){if(null===
this.slicingSpec.horizontalRange)throw Error("Missing horizontal range for "+this.rank+"D tensor.");var L=this.slicingSpec.horizontalRange[0]+M;this.showIndicesOnTicks&&(this.topRulerTicks[M].textContent=L<K?""+L:"")}};H.prototype.renderLeftRuler=function(){if(1<=this.rank)for(var K=this.tensorView.spec.shape[this.slicingSpec.viewingDims[0]],M=0;M<this.leftRulerTicks.length;++M){if(null===this.slicingSpec.verticalRange)throw Error("Missing vertcial range for "+this.rank+"D tensor.");var L=this.slicingSpec.verticalRange[0]+
M;this.showIndicesOnTicks&&(this.leftRulerTicks[M].textContent=L<K?""+L:"")}};H.prototype.renderValueDivs=function(){return b(this,void 0,void 0,function(){var K,M,L,Q,T,X,aa,la,Z,ba,ea,ca,ka,Y,Ea,va,xa;return Xi(this,function(Aa){switch(Aa.label){case 0:return K=this.valueDivs.length,M=this.valueDivs[0].length,[4,this.tensorView.view(this.slicingSpec)];case 1:L=Aa.sent();0===this.rank?L=[[L]]:1===this.rank&&(L=L.map(function(Fa){return[Fa]}));Q=this.getValueClass();T=this.valueRenderMode;if(T===
I.IMAGE){if(null==this.numericSummary)throw Error("Failed to render image representation of tensor due to missing numeric summary");X=this.numericSummary;aa=X.minimum;la=X.maximum;if(null==aa||null==la)throw Error("Failed to render image representation of tensor due to missing minimum or maximum values in numeric summary");Z={min:aa,max:la};this.colorMap=this.colorMapName in N?new N[this.colorMapName](Z):new B(Z)}for(ba=0;ba<K;++ba)for(ea=0;ea<M;++ea)ca=this.valueDivs[ba][ea],ba<L.length&&ea<L[ba].length?
(ka=L[ba][ea],T===I.IMAGE?(Y=Yi(this.colorMap.getRGB(ka),3),Ea=Y[0],va=Y[1],xa=Y[2],ca.style.backgroundColor="rgb("+Ea+", "+va+", "+xa+")"):"numeric"===Q?ca.textContent=q(ka,d(this.tensorView.spec.dtype)):"boolean"===Q?ca.textContent=u(ka):"string"===Q&&(ca.textContent=x(ka)),ca.setAttribute("detailed-value",this.getDetailedValueTooltipString(ka))):(ca.textContent="",ca.setAttribute("detailed-value",""));this.renderSelection();return[2]}})})};H.prototype.getDetailedValueTooltipString=function(K){return"boolean"===
this.getValueClass()?u(K,!1):"string"===this.getValueClass()?"Length-"+K.length+' string: "'+x(K,500)+'"':String(K)};H.prototype.renderSelection=function(){if(null!=this.selection)for(var K=this.valueDivs.length,M=this.valueDivs[0].length,L=0;L<K;++L)for(var Q=0;Q<M;++Q){var T=this.valueDivs[L][Q];T.classList.remove("tensor-widget-value-div-selection");T.classList.remove("tensor-widget-value-div-selection-top");T.classList.remove("tensor-widget-value-div-selection-bottom");T.classList.remove("tensor-widget-value-div-selection-left");
T.classList.remove("tensor-widget-value-div-selection-right");var X=this.calculateIndices(L,Q);X=this.selection.getElementStatus(X);null!==X&&(T.classList.add("tensor-widget-value-div-selection"),X.topEdge&&T.classList.add("tensor-widget-value-div-selection-top"),X.bottomEdge&&T.classList.add("tensor-widget-value-div-selection-bottom"),X.leftEdge&&T.classList.add("tensor-widget-value-div-selection-left"),X.rightEdge&&T.classList.add("tensor-widget-value-div-selection-right"))}};H.prototype.calculateIndices=
function(K,M){for(var L=[],Q=this.slicingSpec.slicingDimsAndIndices.map(function(la){return la.dim}),T=this.slicingSpec.slicingDimsAndIndices.map(function(la){return la.index}),X=0;X<this.rank;++X)if(-1!==Q.indexOf(X)){var aa=T[Q.indexOf(X)];if(null===aa)throw Error("Failed to calculate indices: Undetermined index at dimension "+X);L.push(aa)}else if(X===this.slicingSpec.viewingDims[0]){if(null===this.slicingSpec.verticalRange||null===this.slicingSpec.verticalRange[0])throw Error("Failed to calculate indices due to undertermined vertical range.");
L.push(this.slicingSpec.verticalRange[0]+K)}else if(X===this.slicingSpec.viewingDims[1]){if(null===this.slicingSpec.horizontalRange||null===this.slicingSpec.horizontalRange[0])throw Error("Failed to calculate indices due to undertermined vertical range.");L.push(this.slicingSpec.horizontalRange[0]+M)}return L};H.prototype.drawValueTooltip=function(K,M,L,Q){null===this.valueTooltip&&(this.valueTooltip=document.createElement("div"),this.valueTooltip.classList.add("tensor-widget-value-tooltip"),this.rootElement.appendChild(this.valueTooltip));
for(;this.valueTooltip.firstChild;)this.valueTooltip.removeChild(this.valueTooltip.firstChild);var T=document.createElement("div");T.classList.add("tensor-widget-value-tooltip-indices");T.textContent="Indices: "+JSON.stringify(K);this.valueTooltip.appendChild(T);K=document.createElement("div");K.classList.add("tensor-widget-value-tooltip-value");K.textContent=M;this.valueTooltip.appendChild(K);this.valueTooltip.style.top=L+"px";this.valueTooltip.style.left=Q+"px";this.valueTooltip.style.display="block";
this.valueRenderMode==I.IMAGE&&null!=this.colorMap&&(L=document.createElement("canvas"),L.classList.add("tensor-widget-value-tooltip-colorbar"),this.valueTooltip.appendChild(L),this.colorMap.render(L,parseFloat(M)))};H.prototype.hideValueTooltip=function(){null!=this.valueTooltip&&(this.valueTooltip.style.display="none")};H.prototype.renderRulersAndValueDivs=function(){return b(this,void 0,void 0,function(){return Xi(this,function(K){switch(K.label){case 0:return null!=this.slicingControl&&this.slicingControl.setSlicingSpec(this.slicingSpec),
this.calculateShowIndicesOnRulerTicks(),this.renderTopRuler(),this.renderLeftRuler(),[4,this.renderValueDivs()];case 1:return K.sent(),[2]}})})};H.prototype.calculateShowIndicesOnRulerTicks=function(){if(2<=this.rank){var K=this.topRulerTicks[0].getBoundingClientRect();this.showIndicesOnTicks=K.right-K.left>9*Math.ceil(Math.log(this.tensorView.spec.shape[this.slicingSpec.viewingDims[0]])/Math.LN10)}else 1===this.rank?(K=this.leftRulerTicks[0].getBoundingClientRect(),this.showIndicesOnTicks=16<K.bottom-
K.top):this.showIndicesOnTicks=!1};H.prototype.scrollHorizontally=function(K){return b(this,void 0,void 0,function(){var M,L;return Xi(this,function(Q){switch(Q.label){case 0:if(1>=this.rank)return[2];if(null===this.slicingSpec.horizontalRange)throw Error("Missing horizontal range for "+this.rank+"D tensor.");M=this.tensorView.spec.shape[this.slicingSpec.viewingDims[1]];if(0>K||K>=M)throw Error("Index out of bound: "+K+" is outside [0, "+M+"])");this.slicingSpec.horizontalRange[0]=K;this.slicingSpec.horizontalRange[1]=
K+this.topRulerTicks.length;L=this.tensorView.spec.shape[this.slicingSpec.viewingDims[1]];this.slicingSpec.horizontalRange[1]>L&&(this.slicingSpec.horizontalRange[1]=L);return[4,this.renderRulersAndValueDivs()];case 1:return Q.sent(),[2]}})})};H.prototype.scrollVertically=function(K){return b(this,void 0,void 0,function(){var M,L;return Xi(this,function(Q){switch(Q.label){case 0:if(0===this.rank)return[2];if(null===this.slicingSpec.verticalRange)throw Error("Missing vertical range for "+this.rank+
"D tensor.");if(null===this.valueRows)throw Error("Vertical scrolling failed due to missing value rows.");M=this.tensorView.spec.shape[this.slicingSpec.viewingDims[0]];if(0>K||K>=M)throw Error("Index out of bound: "+K+" is outside [0, "+M+"])");this.slicingSpec.verticalRange[0]=K;this.slicingSpec.verticalRange[1]=K+this.valueRows.length;L=this.tensorView.spec.shape[this.slicingSpec.viewingDims[0]];this.slicingSpec.verticalRange[1]>L&&(this.slicingSpec.verticalRange[1]=L);return[4,this.renderRulersAndValueDivs()];
case 1:return Q.sent(),[2]}})})};H.prototype.scrollUpOrDown=function(K){return b(this,void 0,void 0,function(){var M,L,Q;return Xi(this,function(T){switch(T.label){case 0:if(0===this.rank||!this.rowsCutoff)return[2];if(null===this.slicingSpec.verticalRange)throw Error("Missing vertical range for "+this.rank+"D tensor.");if(null===this.valueRows)throw Error("Vertical scrolling failed due to missing value rows.");M=this.slicingSpec.verticalRange[0];if(K!==w.DOWN)return[3,3];L=this.valueRows.length-
1;Q=this.tensorView.spec.shape[this.slicingSpec.viewingDims[0]]-L;return M<Q?[4,this.scrollVertically(M+1)]:[3,2];case 1:T.sent(),T.label=2;case 2:return[3,5];case 3:return 0<=M-1?[4,this.scrollVertically(M-1)]:[3,5];case 4:T.sent(),T.label=5;case 5:return[2]}})})};H.prototype.scrollLeftOrRight=function(K){return b(this,void 0,void 0,function(){var M,L,Q;return Xi(this,function(T){switch(T.label){case 0:if(1>=this.rank||!this.colsCutoff)return[2];if(null===this.slicingSpec.horizontalRange)throw Error("Horizontal scrolling failed due to missing horizontal range.");
M=this.slicingSpec.horizontalRange[0];if(K!==w.RIGHT)return[3,3];L=this.topRulerTicks.length-1;Q=this.tensorView.spec.shape[this.slicingSpec.viewingDims[1]]-L;return M<Q?[4,this.scrollHorizontally(M+1)]:[3,2];case 1:T.sent(),T.label=2;case 2:return[3,5];case 3:return 0<=M-1?[4,this.scrollHorizontally(M-1)]:[3,5];case 4:T.sent(),T.label=5;case 5:return[2]}})})};H.prototype.navigateToIndices=function(){return b(this,void 0,void 0,function(){return Xi(this,function(){throw Error("navigateToIndices() is not implemented yet.");
})})};H.prototype.getValueClass=function(){var K=this.tensorView.spec.dtype;return d(K)||f(K)?"numeric":h(K)?"boolean":"string"};return H}();D=Object.freeze({tensorWidget:function(H,K,M){return new O(H,K,M)},VERSION:"0.0.0"});window.tensor_widget=D})();

//# sourceURL=build://tf-debugger-dashboard/tf-debugger-line-chart.html.js
Polymer({is:"tf-debugger-line-chart",properties:{data:{type:Object,value:null},_defaultSeriesName:{type:String,value:"__debugger_data__",readonly:!0},_lineChartXComponentsCreationMethod:{type:Object,readOnly:!0,value:()=>()=>{const b=new Plottable.Scales.Linear;return{scale:b,axis:new Plottable.Axes.Numeric(b,"bottom"),accessor:d=>d.step}}},_lineChartYValueAccessor:{type:Object,readOnly:!0,value:()=>b=>b.scalar},_lineChartTooltipColumns:{type:Array,readOnly:!0,value:()=>[{title:"Name",evaluate:b=>
"step\x3d"+b.datum.step+"; scalar\x3d "+b.datum.scalar}]},_lineChartSmoothingEnabled:{type:Boolean,value:!1,readOnly:!0}},observers:["render(data)"],render(b){if(null!=b){var d=this.$$("vz-line-chart2");d.setVisibleSeries([this._defaultSeriesName]);var f=[],h=b.x;b=b.y;for(let k=0;k<h.length;++k)f.push({step:h[k],scalar:b[k]});d.setSeriesData(this._defaultSeriesName,f)}}});

//# sourceURL=build://tf-debugger-dashboard/tf-tensor-value-view.html.js
Polymer({is:"tf-tensor-value-view",properties:{viewId:String,tensorName:String,debugOp:String,deviceName:String,maybeBaseExpandedNodeName:String,slicing:String,timeIndices:String,dtype:String,shape:Array,continueToButtonCallback:Object,closeButtonCallback:Object,tensorNameCallback:Object,tensorWidget:Object,getHealthPill:Function,_isTensorValueScalar:{type:Boolean,value:!1},_isTensorValueLineChart:{type:Boolean,value:!1},_isTensorValueImage:{type:Boolean,value:!1},_dataScalar:{type:Number,value:null},
_lineChartData:{type:Array,value:null},_dataImageSrc:{type:String,value:null},_requestManager:{type:Object,value:()=>new vc.RequestManager(10)}},observers:["_updateTimeIndicesToggle(timeIndices)"],renderTensorValue(){if(this.tensorName)if(null==this.slicing){this.set("_useTensorWidget",!0);const d={spec:{dtype:this.dtype,shape:this.shape},get:()=>{throw Error("tensorView.get() is not implemented yet.");},view:f=>{const h=this;return hc(function*(){const k=h.shape.length,t=f.slicingDimsAndIndices.map(m=>
m.dim),l=f.slicingDimsAndIndices.map(m=>m.index);let p="[";for(let m=0;m<k;++m)-1!==t.indexOf(m)?p+=`${l[t.indexOf(m)]}`:f.viewingDims[0]===m?p+=`${f.verticalRange[0]}:${f.verticalRange[1]}`:f.viewingDims[1]===m&&(p+=`${f.horizontalRange[0]}:${f.horizontalRange[1]}`),m<k-1&&(p+=",");p+="]";return new Promise((m,n)=>{const q=h._getTensorDataURL({watch_key:h.tensorName+":"+h.debugOp,slicing:p,time_indices:h.timeIndices,mapping:"none"});h._requestManager.request(q).then(u=>{null==u.error?m(u.tensor_data[u.tensor_data.length-
1]):n(u.error)}).catch(u=>n(u))})})},getNumericSummary:()=>{const f=this;return hc(function*(){return new Promise((h,k)=>{const t=f.tensorName+":"+f.debugOp;f.getHealthPill(t,f.deviceName,f.maybeBaseExpandedNodeName,l=>{null==l?k(`Failed to get health pill for watch key ${t}`):h({elementCount:l[1],minimum:l[8],maximum:l[9]})})})})}};setTimeout(()=>{null==this.tensorWidget&&(this.tensorWidget=tensor_widget.tensorWidget(this.$$("#tensor-widget"),d,{wheelZoomKey:"alt"}));this.tensorWidget.render()},
10)}else{this.set("_useTensorWidget",!1);var b=this._rankFromSlicing(this.slicing.trim());const d=this._isTimeIndicesSingleStep(this.timeIndices);let f=b;if(!d){if(1<b){this._showToast("History for tensors \x3e 1D is not yet supported.");return}f+=1}b=this._getTensorDataURL({watch_key:this.tensorName+":"+this.debugOp,slicing:this.slicing,time_indices:this.timeIndices,mapping:2<=f?"image/png":"none"});this._requestManager.request(b).then(h=>{this.$$("#debug-op").textContent=this._calculateDebugOpToDisplay();
if(null!=h.error)this._showToast(h.error.type+": "+h.error.message);else if(h=d?h.tensor_data[0]:h.tensor_data,0===f)this._setVisualizationType("scalar"),this.set("_dataScalar",h);else if(1===f){this._setVisualizationType("lineChart");let k={x:[],y:h};for(let t=0;t<h.length;++t)k.x.push(t+1);this.set("_lineChartData",k)}else 2<=f?(this._setVisualizationType("image"),this.set("_dataImageSrc","data:image/png;base64,"+h)):this._showToast("Visualization of rank-"+f+" tensors is not yet supported.")})}},
refresh(){this.tensorName.trim()&&this.renderTensorValue()},_getTensorDataURL(b){const d=vc.getRouter().pluginRoute("debugger","/tensor_data");return vc.addParams(d,b)},_rankFromSlicing(b){b.startsWith("[")&&(b=b.slice(1,b.length-1));if(0===b.length)return 0;{b=b.split(",");let d=b.length;for(const f of b)isNaN(Number(f))||d--;return d}},_setVisualizationType(b){"scalar"===b?(this.set("_isValueScalar",!0),this.set("_isValueLineChart",!1),this.set("_isValueImage",!1)):"lineChart"===b?(this.set("_isValueScalar",
!1),this.set("_isValueLineChart",!0),this.set("_isValueImage",!1)):"image"===b?(this.set("_isValueScalar",!1),this.set("_isValueLineChart",!1),this.set("_isValueImage",!0)):console.error("Invalid visualizationType:",b)},_timeIndicesToggleButtonCallback(){"full history"===Polymer.dom(this.$$("#time-indices-toggle-button")).textContent.toLowerCase()?this.set("timeIndices",":"):this.set("timeIndices","-1");this.renderTensorValue()},_updateTimeIndicesToggle(b){this._isTimeIndicesSingleStep(b)?Polymer.dom(this.$$("#time-indices-toggle-button")).textContent=
"Full History":Polymer.dom(this.$$("#time-indices-toggle-button")).textContent="Latest Time Point"},_isTimeIndicesSingleStep(b){b.startsWith("[")&&(b=b.slice(1,b.length-1));return!isNaN(Number(b))},_calculateDebugOpToDisplay(){return"DebugIdentity"===this.debugOp?"":this.debugOp},_showToast(b){this.$.tensorValueToast.setAttribute("text",b);this.$.tensorValueToast.open()}});

//# sourceURL=build://tf-debugger-dashboard/tf-tensor-value-multi-view.html.js
Polymer({is:"tf-tensor-value-multi-view",properties:{continueToCallback:Function,tensorNameClicked:Function,_tensorViewCounter:{type:Number,value:0},getHealthPill:Function},addView(b){const d=this.$$("#multi-tensor-view-container"),f=document.createElement("tf-tensor-value-view");f.setAttribute("class","debugger-tensor-view");f.viewId=b.viewId;f.tensorName=b.tensorName;f.debugOp=b.debugOp;f.deviceName=b.deviceName;f.maybeBaseExpandedNodeName=b.maybeBaseExpandedNodeName;f.dtype=b.dtype;f.shape=b.shape;
f.slicing=b.slicing;f.timeIndices=b.timeIndices;f.closeButtonCallback=this._createCloseButtonCallback(b.viewId);f.continueToButtonCallback=()=>{this.continueToCallback(b.deviceName,b.maybeBaseExpandedNodeName)};f.tensorNameCallback=()=>{this.tensorNameClicked(b.deviceName,b.maybeBaseExpandedNodeName)};f.getHealthPill=this.getHealthPill;d.appendChild(f);f.refresh()},getViews(){const b=[];_.forEach(this.root.querySelectorAll(".debugger-tensor-view"),d=>{b.push({viewId:d.viewId,tensorName:d.tensorName,
debugOp:d.debugOp,slicing:d.slicing,timeIndices:d.timeIndices})});return b},renderTensorValues(){_.forEach(this.root.querySelectorAll(".debugger-tensor-view"),b=>{b.renderTensorValue()})},_redrawViews(b){const d=this.$$("#multi-tensor-view-container");_.forEach(this.root.querySelectorAll(".debugger-tensor-view"),f=>{d.removeChild(f)});_.forEach(b,f=>{this.addView(f)})},_createCloseButtonCallback(b){return()=>{const d=[],f=this.root.querySelectorAll(".debugger-tensor-view");for(let h=0;h<f.length;++h){const k=
f[h];k.viewId!==b&&d.push({viewId:k.viewId,tensorName:k.tensorName,debugOp:k.debugOp,dtype:k.dtype,shape:k.shape,slicing:k.slicing,timeIndices:k.timeIndices})}this._redrawViews(d)}}});

//# sourceURL=build://tf-debugger-dashboard/tensor-shape-helper.js
(function(b){function d(f,h){return f<=h?"::":"::"+Math.ceil(f/h)}b.getDefaultSlicing=function(f){return 0===f.length?"":1===f.length?"["+d(f[0],1E3)+"]":2===f.length?"["+d(f[0],250)+", "+d(f[1],250)+"]":null};b.rankFromSlicing=function(f){f.startsWith("[")&&(f=f.slice(1,f.length-1));if(0===f.length)return 0;{f=f.split(",");let h=f.length;for(const k of f)isNaN(Number(k))||h--;return h}}})(Vi||(Vi={}));

//# sourceURL=build://tf-debugger-dashboard/tf-debugger-dashboard.html.js
const Zi=()=>window.innerHeight||document.documentElement.clientHeight||document.body.clientHeight,Hk=()=>window.innerWidth||document.documentElement.clientWidth||document.body.clientWidth,Ik=(Zi()-70)/2;
Polymer({is:"tf-debugger-dashboard",properties:{_topRightTabs:{type:Array,value:[{id:"tab-runtime-graphs",name:"Runtime Graphs"},{id:"tab-tensor-values",name:"Tensor Values"}],readonly:!0},_isTopRightRuntimeGraphsActive:{type:Boolean,value:!0},_isTopRightTensorValuesActive:{type:Boolean,value:!1},_topRightSelected:{type:String,value:"0",observer:"_topRightSelectedChanged"},_longPollCount:{type:Number,value:0},_stepButtonText:{type:String,value:"Step"},_continueButtonText:{type:String,value:"Continue..."},
_tensorViewIdCounter:{type:Number,value:0},isReloadDisabled:{type:Boolean,value:!0,readOnly:!0},alreadyStarted:{type:Boolean,value:!1},_currentSessionRunInfo:{type:String,value:null},_sessionRunTotalCounter:{type:Number,value:0},_sessionRunCounters:{type:Object,value:{}},_sessionRunKey2DeviceNames:{type:Object,value:{}},_activeSessionRunKey:{type:String,value:null},_activeSessionRunDevices:{type:Array,value:[]},_activeSessionRunNumDevices:{type:Number,value:-1},_activeRuntimeGraphDeviceName:{type:String,
value:null,notify:!0},_highlightNodeName:{type:String,value:null},_continueToType:{type:String,value:""},_continueToCounter:{type:Number,value:0},_continueStop:{type:Boolean,value:!1},_continueToTarget:{type:String,value:""},_continueToCounterTarget:{type:Number,value:-1},_forceExpandAndCheckNodeName:String,_forceExpandNodeName:String,_sourceFocusNodeName:String,_sourceCodeShown:{type:Boolean,value:!1,observer:"_showSourceCodeChanged"},_graphProgress:{type:Object},_requestManager:{type:Object,value:()=>
new vc.RequestManager(50)},_busy:{type:Boolean,value:!1},_leftPaneWidth:{type:Number,value:pd.getNumberInitializer("_leftPaneWidth",{defaultValue:450}),observer:"_leftPaneWidthObserver"},_minleftPaneWidth:{type:Number,value:450,readOnly:!0},_maxleftPaneWidth:{type:Number,computed:"_computeMaxleftPaneWidth(_windowWidth, _maxMainContentWidth, _resizerWidth)"},_maxMainContentWidth:{type:Number,value:350,readOnly:!0},_topRightQuadrantHeight:{type:Number,value:pd.getNumberInitializer("_topRightQuadrantHeight",
{defaultValue:Ik}),observer:"_topRightQuadrantHeightObserver"},_minTopRightQuadrantHeight:{type:Number,value:200,readOnly:!0},_maxTopRightQuadrantHeight:{type:Number,computed:"_computeMaxTopRightQuadrantHeight(_windowHeight, _resizerWidth)"},_resizerWidth:{type:Number,value:30,readOnly:!0},_windowWidth:Number,_windowHeight:Number,_debugWatches:Array,_latestSessionRun:Object},observers:["_onActiveRuntimeGraphDeviceNameChange(_activeRuntimeGraphDeviceName)","_sizeDashboardRegions(_leftPaneWidth, _topRightQuadrantHeight, _windowWidth)",
"_graphProgressUpdated(_graphProgress)"],ready(){this._handleWindowResize();window.addEventListener("resize",()=>{this._handleWindowResize()},!1);this.reload()},long_poll(){const b={pos:++this._longPollCount};let d=vc.getRouter().pluginRoute("debugger","/comm");d=vc.addParams(d,b);this._requestManager.request(d).then(f=>{const h=f.type;f=f.data;if("meta"===h){var k=f.run_key,t=k[0].split(","),l=k[1].split(",");const m=k[2].split(",");var p=this._activeSessionRunKey;this.set("_activeSessionRunKey",
k);this.set("_latestSessionRun",{feeds:t,fetches:l,targets:m});this.set("_sessionRunSoleActive",!0);void 0===this._sessionRunKey2DeviceNames[k]?(this._sessionRunKey2DeviceNames[k]=[],this.set("_activeSessionRunDevices",[])):this.set("_activeSessionRunDevices",this._sessionRunKey2DeviceNames[k]);this._currentSessionRunInfo=t="Feeds: "+t+"; Fetches: "+l+"; Targets: "+m;this._sessionRunCounters.hasOwnProperty(t)?this._sessionRunCounters[t]+=1:this._sessionRunCounters[t]=1;this._sessionRunTotalCounter++;
this.$.initialDialog.closeDialog();this._continueToType&&_.isEqual(p,k)||(this._processGatedGrpcDebugOps(k,!1),this._announceNewSessionRun())}else"tensor"===h?(k=f.device_name,p=f.node_name,t=f.maybe_base_expanded_node_name,this._activeRuntimeGraphDeviceName!=k?this.set("_activeRuntimeGraphDeviceName",k):!this._continueToType&&this._isTopRightRuntimeGraphsActive&&(this._focusOnGraphNode(k,t),this.set("_forceExpandNodeName",k+"/"+t)),this.set("_sessionRunSoleActive",!1),l=p+":"+f.output_slot,this.set("_latestTensorData",
{deviceName:k,tensorName:l,nodeName:p,maybeBaseExpandedNodeName:t,debugOp:f.debug_op,dtype:f.dtype,shape:f.shape,value:f.values}),this._maybeUpdateTensorValueViews(l,f.debug_op),this.set("_busy",!1)):console.error("Invalid long-polling response type: ",h);null!=this._continueToType&&this._processContinueTo(h,f);this.long_poll()})},_processContinueTo(b,d){this._continueStop?this._clearContinueTo():"SessionRun"===this._continueToType?this._processContinueToSessionRun("meta"===b):"TensorCondition"===
this._continueToType?this._step():"op"===this._continueToType?this._processContinueToOp("meta"===b,d):null!=this._continueToType&&""!==this._continueToType&&console.error("Invalid _continueToType:",this._continueToType)},_processContinueToSessionRun(b){b&&this.set("_continueToCounter",this._continueToCounter+1);this._continueToCounter<this._continueToCounterTarget?this._step():this._clearContinueTo()},_processContinueToOp(b,d){b&&this._announceNewSessionRun();b=d.device_name;d=d.maybe_base_expanded_node_name;
const f=null==d?null:Vi.removeNodeNameBaseExpansion(d);b+"/"+d===this._continueToTarget||b+"/"+f===this._continueToTarget?(this._clearContinueTo(),this._sourceCodeShown&&this.set("_sourceFocusNodeName",f)):this._step()},_maybeUpdateTensorValueViews(b,d){const f=this.$$("#tensorValueMultiView");if(null!=f){var h=!1;_.forEach(f.getViews(),k=>{if(k.tensorName===b&&k.debugOp===d)return h=!0,!1});h&&f.renderTensorValues()}},reload(){if(!this.alreadyStarted){this.set("alreadyStarted",!0);var b=vc.getRouter().pluginRoute("debugger",
"/debugger_grpc_host_port");this._requestManager.request(b).then(d=>{0<d.port?(this.$.initialDialog.openDialog(d.host,d.port),this.long_poll()):this.$.initialDialog.openDisabledDialog()})}},_showSourceCodeChanged(){this._sourceCodeShown?(this.$$("#node-entries").style.height="40%",this.$.sourceCodeView.render()):this.$$("#node-entries").style.height="80%"},_showToast(b){this.$.toast.setAttribute("text",b);this.$.toast.open()},_announceNewSessionRun(){this._showToast("Session.run() #"+this._sessionRunTotalCounter+
" is starting.")},_displayGraph(b,d){b={run_key:JSON.stringify(b),device_name:d};b=vc.addParams("/data/plugin/debugger/debugger_graph",b);this.$.loader.datasets=[{name:"/debugger_graph",path:b}];this.$.loader.set("selectedDataset",0)},_processGatedGrpcDebugOps(b,d){d?console.log("Polling for first GraphDef for run key:",b):this.set("_activeRuntimeGraphDeviceName",null);var f={mode:"retrieve_all",run_key:JSON.stringify(b)};const h=vc.getRouter().pluginRoute("debugger","/gated_grpc");f=vc.addParams(h,
f);let k=[];this._requestManager.request(f).then(t=>{if(0==t.device_names.length)d||this._step(),this._processGatedGrpcDebugOps(b,!0);else{var l=null;for(const p in t.gated_grpc_tensors)if(t.gated_grpc_tensors.hasOwnProperty(p)){-1===this._sessionRunKey2DeviceNames[b].indexOf(p)&&(this._sessionRunKey2DeviceNames[b].push(p),this.$.sessionRunsView.updateNumDevices(this._sessionRunKey2DeviceNames[b].length));this.set("_activeSessionRunDevices",this._sessionRunKey2DeviceNames[b].slice());l=this._activeSessionRunDevices[this._activeSessionRunDevices.length-
1];const m=t.gated_grpc_tensors[p];for(let n=0;n<m.length;++n)k.push({device_name:p,node_name:m[n][0],op_type:m[n][1],output_slot:m[n][2],debug_op:m[n][3]})}null!=l&&(this.set("_activeRuntimeGraphDeviceName",l),t=Polymer.dom(this.$$("#active-runtime-graph-device-name")),null!=t&&t.setAttribute("selected",l));Vi.sortAndBaseExpandDebugWatches(k);this.set("_debugWatches",k);this.$.sourceCodeView.render(k)}})},_createDebugWatchChangeHandler(){return(b,d)=>{d=d?"break":"disable";this._requestBreakpointStateChange(Vi.getCleanNodeName(b.device_name+
"/"+b.node_name),b.output_slot,b.debug_op,d)}},_focusOnGraphNode(b,d){null!=b&&this._activeRuntimeGraphDeviceName!==b&&this.set("_activeRuntimeGraphDeviceName",b);this._setTopRightRuntimeGraphsToActive();const f=this.$$("#graph");if(f.selectedNode===d)f.panToNode(d);else{const h=f.get("renderHierarchy").hierarchy.getNodeMap();null==h[d]&&(d=Vi.removeNodeNameBaseExpansion(d));null!=h[d]&&f.set("selectedNode",d)}this.set("_highlightNodeName",b+"/"+d)},_createNodeClickedHandler(){return(b,d,f)=>{this._sourceCodeShown&&
!0!==f&&this.set("_sourceFocusNodeName",Vi.removeNodeNameBaseExpansion(d));this._focusOnGraphNode(b,d);this.set("_forceExpandNodeName",b+"/"+d)}},_createFeedFetchTargetClickedHandler(){return b=>{let d=b;-1!==d.indexOf(":")&&(d=d.slice(0,d.indexOf(":")));b=_.find(this._debugWatches,f=>f.node_name===d||0===f.node_name.indexOf(d)&&"("===f.node_name[d.length]);null==b?this._showToast("Node '"+d+"' is not in the runtime graph of the current Session.run or does not have a debug op attached."):this._focusOnGraphNode(b.device_name,
d)}},_createTensorDataExpandHandler(){return b=>{this._setTopRightTensorValuesToActive();setTimeout(()=>{this.$$("#tensorValueMultiView").addView({viewId:this._createTensorViewId(),deviceName:b.deviceName,tensorName:b.tensorName,nodeName:b.nodeName,maybeBaseExpandedNodeName:b.maybeBaseExpandedNodeName,debugOp:b.debugOp,dtype:b.dtype,shape:b.shape,slicing:Vi.getDefaultSlicing(b.shape),timeIndices:"-1"})},10)}},_createTensorViewId(){const b="debugger-tensor-view-"+this._tensorViewIdCounter;this._tensorViewIdCounter++;
return b},_createNodeContextMenuItems(){return[{title:()=>"Expand and highlight",action:b=>{const d=Vi.getCleanNodeName(b.node.name);b=this._activeRuntimeGraphDeviceName+"/"+b.node.name;this.set("_forceExpandNodeName",b);this.set("_highlightNodeName",b);this._sourceCodeShown&&this.set("_sourceFocusNodeName",Vi.removeNodeNameBaseExpansion(d))}},{title:()=>"Add breakpoint",action:b=>{const d=Vi.getCleanNodeName(b.node.name);this.set("_forceExpandAndCheckNodeName",this._activeRuntimeGraphDeviceName+
"/"+b.node.name);this._sourceCodeShown&&this.set("_sourceFocusNodeName",Vi.removeNodeNameBaseExpansion(d))}},{title:()=>"Continue to",action:b=>{-1!==["_Arg","_Retval"].indexOf(b.node.op)?this._showToast('Cannot continue to node "'+b.node.name+'", due to op type "'+b.node.op+'".'):this._continueToNode(this._activeRuntimeGraphDeviceName,b.node.name)}}]},_createGetHealthPill(){return(b,d,f,h)=>{var k={watch_key:b,time_indices:"-1",mapping:"health-pill"};const t=vc.getRouter().pluginRoute("debugger",
"/tensor_data");k=vc.addParams(t,k);this._requestManager.request(k).then(l=>{l=l.tensor_data[0];h(l);this._conditionalHealthPillStop(b,d,f,l)})}},_conditionalHealthPillStop(b,d,f,h){if("TensorCondition"===this._continueToType&&Vi.checkHealthPillAgainstTensorConditionKey(this._continueToTarget,h,this._continueToCounterTarget)){this.set("_continueStop",!0);h=Vi.removeNodeNameBaseExpansion(f);this._sourceCodeShown&&this.set("_sourceFocusNodeName",h);this._focusOnGraphNode(d,f);const k=d+"/"+f;this.set("_forceExpandNodeName",
k);setTimeout(()=>{this.set("_highlightNodeName",null);this.set("_highlightNodeName",k)},100);this._showToast('Tensor condition "'+this._continueToTarget+'" is met by watch key: "'+b+'".\nStopping continuation.')}},_continueToNode(b,d){const f=Vi.getCleanNodeName(d);b=b+"/"+d;this._requestBreakpointStateChange(f,0,"DebugIdentity","break");this.set("_forceExpandAndCheckNodeName",b);this._sourceCodeShown&&this.set("_sourceFocusNodeName",Vi.removeNodeNameBaseExpansion(f));this._setContinueTo("op",b);
this.$.continueDialog.updateContinueButtonText(!0);this._step()},_createContinueToNodeHandler(){return(b,d)=>{this._continueToNode(b,d)}},_onActiveRuntimeGraphDeviceNameChange(b){const d=Polymer.dom(this.$$("#runtime-graph-device-name"));if(0<this._activeSessionRunDevices.length){let f;f=b+(" (device "+(this._activeSessionRunDevices.indexOf(b)+1)+" of "+this._activeSessionRunDevices.length+")");this._isTopRightRuntimeGraphsActive&&null!=d&&(d.textContent=f)}else this._isTopRightRuntimeGraphsActive&&
null!=d&&(d.textContent="Waiting for device...");null!=b&&this._displayGraph(this._activeSessionRunKey,b)},_step(){if(null!=this._activeSessionRunKey){this.set("_busy",!0);var b={mode:"retrieve_device_names",run_key:JSON.stringify(this._activeSessionRunKey)},d=vc.getRouter().pluginRoute("debugger","/gated_grpc");b=vc.addParams(d,b);this._requestManager.request(b).then(f=>{let h=!1;for(let k=0;k<f.device_names.length;++k)if(-1===this._activeSessionRunDevices.indexOf(f.device_names[k])){h=!0;break}f=
vc.getRouter().pluginRoute("debugger","/ack");this._requestManager.request(f).then(()=>{h&&this._processGatedGrpcDebugOps(this._activeSessionRunKey,!1)})})}},_createSessionRunGo(){return b=>{this._setContinueTo("SessionRun",this._currentSessionRunInfo,b);this._step()}},_createTensorConditionGo(){return(b,d)=>{this._setContinueTo("TensorCondition",b,d);this.$.tensorDataSummary.enableHealthPills();this._step()}},_createForceContinuationStop(){return()=>{this._showToast('Continuation of type "'+this._continueToType+
'" was interrupted by user.');this.set("_continueStop",!0)}},_setContinueTo(b,d,f=-1){this._continueToType=b;this._continueToTarget=d;this._continueToCounterTarget=f;this._continueToCounter=0;this._continueStop=!1},_clearContinueTo(){this.$.continueDialog.notifyContinuationStop();this._continueToTarget=this._continueToType="";this._continueToCounterTarget=-1;this._continueToCounter=0;this._continueStop=!1;this.set("_busy",!1)},_createContinueToCallback(){return(b,d)=>{this._setContinueTo("op",b+"/"+
d);this._step();this._isTopRightRuntimeGraphsActive&&this._focusOnGraphNode(b,d);this.set("_forceExpandNodeName",b+"/"+d)}},_topRightSelectedChanged(b){b=this._topRightTabs[b].id;this.set("_isTopRightRuntimeGraphsActive","tab-runtime-graphs"===b);this.set("_isTopRightTensorValuesActive","tab-tensor-values"===b)},_setTopRightRuntimeGraphsToActive(){this.set("_topRightSelected","0");this.set("_isTopRightRuntimeGraphsActive",!0);this.set("_isTopRightTensorValuesActive",!1)},_setTopRightTensorValuesToActive(){this.set("_topRightSelected",
"1");this.set("_isTopRightRuntimeGraphsActive",!1);this.set("_isTopRightTensorValuesActive",!0)},_requestBreakpointStateChange(b,d,f,h){b={mode:"set_state",node_name:b,output_slot:d,debug_op:f,state:h};d=vc.getRouter().pluginRoute("debugger","/gated_grpc");b=vc.addParams(d,b);this.set("_busy",!0);this._requestManager.request(b).then(k=>{this.set("_busy",!1);console.log("Breakpoint set_state response: ",k)})},_graphProgressUpdated(b){const d=this.$$("#top-right-progress-bar");null==this._latestSessionRun?
(d.setAttribute("value",0),this.set("_busy",!1)):(d.setAttribute("value",b.value),this.set("_busy",100>b.value))},_handleWindowResize(){this.set("_windowWidth",Hk());this.set("_windowHeight",Zi());this._sizeDashboardRegions(this._leftPaneWidth,this._topRightQuadrantHeight,this._windowWidth)},_computeMaxleftPaneWidth(b,d,f){return b-d-f},_computeMaxTopRightQuadrantHeight(b,d){return b-d-70},_sizeDashboardRegions(b,d,f){this.$$("#left-pane").style.width=b+"px";b=f-b-this._resizerWidth-8;this.$$("#center-content").style.width=
b+"px";b=d-this._resizerWidth;this.$$("#top-right-quadrant").style.height=b+"px";this.$$("#tensor-data").style.top=d+"px"},_leftPaneWidthObserver:pd.getNumberObserver("_leftPaneWidth",{defaultValue:450}),_topRightQuadrantHeightObserver:pd.getNumberObserver("_topRightQuadrantHeight",{defaultValue:Ik})});

//# sourceURL=build://paper-material/paper-material.html.js
Polymer({is:"paper-material",properties:{elevation:{type:Number,reflectToAttribute:!0,value:1},animated:{type:Boolean,reflectToAttribute:!0,value:!1}}});

//# sourceURL=build://tf-graph-debugger-data-card/tf-graph-debugger-data-card.html.js
(function(){Polymer({is:"tf-graph-debugger-data-card",properties:{renderHierarchy:Object,debuggerNumericAlerts:{type:Array,notify:!0},nodeNamesToHealthPills:Object,healthPillStepIndex:{type:Number,notify:!0},specificHealthPillStep:{type:Number,value:0,notify:!0},selectedNode:{type:String,notify:!0},highlightedNode:{type:String,notify:!0},selectedNodeInclude:{type:Number,notify:!0},areHealthPillsLoading:Boolean,healthPillEntries:{type:Array,value:tf.graph.scene.healthPillEntries,readOnly:!0},healthPillValuesForSelectedNode:{type:Array,
computed:"_computeHealthPillForNode(nodeNamesToHealthPills, healthPillStepIndex, selectedNode, allStepsModeEnabled, areHealthPillsLoading)"},allStepsModeEnabled:{type:Boolean,notify:!0},_biggestStepEverSeen:{type:Number,computed:"_computeBiggestStepEverSeen(nodeNamesToHealthPills)"},_maxStepIndex:{type:Number,computed:"_computeMaxStepIndex(nodeNamesToHealthPills)"},_currentStepDisplayValue:{type:String,computed:"_computeCurrentStepDisplayValue(nodeNamesToHealthPills, healthPillStepIndex, allStepsModeEnabled, specificHealthPillStep, areHealthPillsLoading)"}},
observers:["_updateAlertsList(debuggerNumericAlerts)"],ready:function(){var b=document.getElementById("mainContainer"),d=document.querySelector("tf-dashboard-layout .scrollbar");b&&d&&(b.style.overflow="hidden",d.style.overflow="hidden")},_healthPillsAvailable:function(b,d){return b&&d},_computeTensorCountString:function(b,d){return b?b[d].toFixed(0):""},_computeHealthPillForNode:function(b,d,f,h,k){if(k||!f)return null;b=b[f];return b?(d=b[h?0:d])?d.value.slice(2,8):null:null},_computeCurrentStepDisplayValue:function(b,
d,f,h,k){if(f)return h.toFixed(0);if(k)return 0;for(let t in b)return b[t][d].step.toFixed(0);return 0},_computeBiggestStepEverSeen:function(b){for(let d in b)return b=b[d],Math.max(this._biggestStepEverSeen,b[b.length-1].step);return this._biggestStepEverSeen||0},_computeMaxStepIndex:function(b){for(let d in b)return b[d].length-1;return 0},_hasDebuggerNumericAlerts:function(b){return b&&b.length},_updateAlertsList:function(b){var d=this.$$("#numeric-alerts-body");if(d){d.innerHTML="";for(var f=
0;f<b.length;f++){var h=b[f],k=document.createElement("tr"),t=document.createElement("td");t.innerHTML=tf.graph.util.computeHumanFriendlyTime(h.first_timestamp);t.classList.add("first-offense-td");k.appendChild(t);t=document.createElement("td");t.classList.add("tensor-device-td");var l=document.createElement("div");l.classList.add("tensor-section-within-table");l.innerHTML=h.tensor_name;this._addOpExpansionListener(l,h.tensor_name);t.appendChild(l);l=document.createElement("div");l.classList.add("device-section-within-table");
l.innerHTML="("+h.device_name+")";t.appendChild(l);k.appendChild(t);t=document.createElement("div");t.classList.add("mini-health-pill");l=document.createElement("td");l.classList.add("mini-health-pill-td");l.appendChild(t);k.appendChild(l);h.neg_inf_event_count&&(l=document.createElement("div"),l.classList.add("negative-inf-mini-health-pill-section"),l.innerHTML=h.neg_inf_event_count,l.setAttribute("title",h.neg_inf_event_count+" events with -\u221e"),t.appendChild(l));h.pos_inf_event_count&&(l=document.createElement("div"),
l.classList.add("positive-inf-mini-health-pill-section"),l.innerHTML=h.pos_inf_event_count,l.setAttribute("title",h.pos_inf_event_count+" events with +\u221e"),t.appendChild(l));h.nan_event_count&&(l=document.createElement("div"),l.classList.add("nan-mini-health-pill-section"),l.innerHTML=h.nan_event_count,l.setAttribute("title",h.nan_event_count+" events with NaN"),t.appendChild(l));Polymer.dom(d).appendChild(k)}}},_addOpExpansionListener:function(b,d){b.addEventListener("click",()=>{var f=tf.graph.render.expandUntilNodeIsShown(this.renderHierarchy,
d),h,k=document.querySelector("tf-graph-info#graph-info");k&&(h=k.scrollHeight-k.scrollTop);var t=this.selectedNode;this.set("selectedNode",f);f=()=>{k.scrollTop=k.scrollHeight-h};k&&(t?f():window.setTimeout(f,20))})}})})();

//# sourceURL=build://iron-scroll-target-behavior/iron-scroll-target-behavior.html.js
Polymer.IronScrollTargetBehavior={properties:{scrollTarget:{type:HTMLElement,value:function(){return this._defaultScrollTarget}}},observers:["_scrollTargetChanged(scrollTarget, isAttached)"],_shouldHaveListener:!0,_scrollTargetChanged:function(b,d){this._oldScrollTarget&&(this._toggleScrollListener(!1,this._oldScrollTarget),this._oldScrollTarget=null);d&&("document"===b?this.scrollTarget=this._doc:"string"===typeof b?this.scrollTarget=(d=this.domHost)&&d.$?d.$[b]:Polymer.dom(this.ownerDocument).querySelector("#"+
b):this._isValidScrollTarget()&&(this._oldScrollTarget=b,this._toggleScrollListener(this._shouldHaveListener,b)))},_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(b){this.scrollTarget===this._doc?window.scrollTo(window.pageXOffset,b):this._isValidScrollTarget()&&(this.scrollTarget.scrollTop=b)},set _scrollLeft(b){this.scrollTarget===this._doc?window.scrollTo(b,window.pageYOffset):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=b)},scroll:function(b,d){this.scrollTarget===this._doc?window.scrollTo(b,d):this._isValidScrollTarget()&&(this.scrollTarget.scrollLeft=b,this.scrollTarget.scrollTop=d)},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(b,d){d=d===this._doc?window:d;b?this._boundScrollHandler||(this._boundScrollHandler=this._scrollHandler.bind(this),d.addEventListener("scroll",this._boundScrollHandler)):
this._boundScrollHandler&&(d.removeEventListener("scroll",this._boundScrollHandler),this._boundScrollHandler=null)},toggleScrollListener:function(b){this._shouldHaveListener=b;this._toggleScrollListener(b,this.scrollTarget)}};

//# sourceURL=build://iron-list/iron-list.html.js
(function(){var b=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),d=b&&8<=b[1],f=null!=Polymer.flush,h=f?Polymer.Async.animationFrame:0,k=f?Polymer.Async.idlePeriod:1,t=f?Polymer.Async.microTask:2;Polymer.OptionalMutableDataBehavior||(Polymer.OptionalMutableDataBehavior={});Polymer({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:[Polymer.Templatizer,Polymer.IronResizableBehavior,Polymer.IronScrollTargetBehavior,Polymer.OptionalMutableDataBehavior],
_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,_collection: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(){return(this.grid?this._physicalRows*this._rowHeight:this._physicalSize)-this._viewportHeight},get _itemsParent(){return Polymer.dom(Polymer.dom(this._userTemplate).parentNode)},get _maxScrollTop(){return this._estScrollHeight-this._viewportHeight+this._scrollOffset},
get _maxVirtualStart(){var l=this._convertIndexToCompleteRow(this._virtualCount);return Math.max(0,l-this._physicalCount)},set _virtualStart(l){l=this._clamp(l,0,this._maxVirtualStart);this.grid&&(l-=l%this._itemsPerRow);this._virtualStartVal=l},get _virtualStart(){return this._virtualStartVal||0},set _physicalStart(l){l%=this._physicalCount;0>l&&(l=this._physicalCount+l);this.grid&&(l-=l%this._itemsPerRow);this._physicalStartVal=l},get _physicalStart(){return this._physicalStartVal||0},get _physicalEnd(){return(this._physicalStart+
this._physicalCount-1)%this._physicalCount},set _physicalCount(l){this._physicalCountVal=l},get _physicalCount(){return this._physicalCountVal||0},get _optPhysicalSize(){return 0===this._viewportHeight?Infinity:this._viewportHeight*this._maxPages},get _isVisible(){return!(!this.offsetWidth&&!this.offsetHeight)},get firstVisibleIndex(){var l=this._firstVisibleIndexVal;if(null==l){var p=this._physicalTop+this._scrollOffset;this._firstVisibleIndexVal=l=this._iterateItems(function(m,n){p+=this._getPhysicalSizeIncrement(m);
if(p>this._scrollPosition)return this.grid?n-n%this._itemsPerRow:n;if(this.grid&&this._virtualCount-1===n)return n-n%this._itemsPerRow})||0}return l},get lastVisibleIndex(){var l=this._lastVisibleIndexVal;if(null==l){if(this.grid)l=Math.min(this._virtualCount,this.firstVisibleIndex+this._estRowsInView*this._itemsPerRow-1);else{var p=this._physicalTop+this._scrollOffset;this._iterateItems(function(m,n){p<this._scrollBottom&&(l=n);p+=this._getPhysicalSizeIncrement(m)})}this._lastVisibleIndexVal=l}return l},
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,h);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(l){this.style.webkitOverflowScrolling=l===this?"touch":"";this.style.overflowY=l===this?"auto":"";this._firstVisibleIndexVal=this._lastVisibleIndexVal=null;this._debounce("_render",this._render,h)},updateViewportBoundaries:function(){var l=window.getComputedStyle(this);this._scrollerPaddingTop=
this.scrollTarget===this?0:parseInt(l["padding-top"],10);this._isRTL="rtl"===l.direction;this._viewportWidth=this.$.items.offsetWidth;this._viewportHeight=this._scrollTargetHeight;this.grid&&this._updateGridMetrics()},_scrollHandler:function(){var l=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),p=l-this._scrollPosition,m=0<=p;this._scrollPosition=l;this._lastVisibleIndexVal=this._firstVisibleIndexVal=null;Math.abs(p)>this._physicalSize&&0<this._physicalSize?(p-=this._scrollOffset,m=Math.round(p/
this._physicalAverage)*this._itemsPerRow,this._virtualStart+=m,this._physicalStart+=m,this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage,this._update()):0<this._physicalCount&&(l=this._getReusables(m),m?(this._physicalTop=l.physicalTop,this._virtualStart+=l.indexes.length,this._physicalStart+=l.indexes.length):(this._virtualStart-=l.indexes.length,this._physicalStart-=l.indexes.length),this._update(l.indexes,m?null:l.indexes),this._debounce("_increasePoolIfNeeded",
this._increasePoolIfNeeded.bind(this,0),t))},_getReusables:function(l){var p=[],m=this._hiddenContentSize*this._ratio,n=this._virtualStart,q=this._virtualEnd,u=this._physicalCount,x=this._physicalTop+this._scrollOffset;var A=this._physicalBottom+this._scrollOffset;var y=this._scrollTop,w=this._scrollBottom;if(l){var C=this._physicalStart;A=y-x}else C=this._physicalEnd,A-=w;for(;;){var G=this._getPhysicalSizeIncrement(C);A-=G;if(p.length>=u||A<=m)break;if(l){if(q+p.length+1>=this._virtualCount)break;
if(x+G>=y-this._scrollOffset)break;p.push(C);x+=G;C=(C+1)%u}else{if(0>=n-p.length)break;if(x+this._physicalSize-G<=w)break;p.push(C);x-=G;C=0===C?u-1:C-1}}return{indexes:p,physicalTop:x-this._scrollOffset}},_update:function(l,p){if(!(l&&0===l.length||0===this._physicalCount)){this._manageFocus();this._assignModels(l);this._updateMetrics(l);if(p)for(;p.length;)l=p.pop(),this._physicalTop-=this._getPhysicalSizeIncrement(l);this._positionItems();this._updateScrollerSize()}},_createPool:function(l){this._ensureTemplatized();
var p,m=Array(l);for(p=0;p<l;p++){var n=this.stamp(null);m[p]=n.root.querySelector("*");this._itemsParent.appendChild(n.root)}return m},_isClientFull:function(){return 0!=this._scrollBottom&&this._physicalBottom-1>=this._scrollBottom&&this._physicalTop<=this._scrollPosition},_increasePoolIfNeeded:function(l){l=this._clamp(this._physicalCount+l,3,this._virtualCount-this._virtualStart);l=this._convertIndexToCompleteRow(l);if(this.grid){var p=l%this._itemsPerRow;p&&l-p<=this._physicalCount&&(l+=this._itemsPerRow);
l-=p}l-=this._physicalCount;p=Math.round(.5*this._physicalCount);if(!(0>l)){if(0<l){p=window.performance.now();[].push.apply(this._physicalItems,this._createPool(l));for(var m=0;m<l;m++)this._physicalSizes.push(0);this._physicalCount+=l;this._physicalStart>this._physicalEnd&&this._isIndexRendered(this._focusedVirtualIndex)&&this._getPhysicalIndex(this._focusedVirtualIndex)<this._physicalEnd&&(this._physicalStart+=l);this._update();this._templateCost=(window.performance.now()-p)/l;p=Math.round(.5*
this._physicalCount)}this._virtualEnd>=this._virtualCount-1||0===p||(this._isClientFull()?this._physicalSize<this._optPhysicalSize&&this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,this._clamp(Math.round(50/this._templateCost),1,p)),k):this._debounce("_increasePoolIfNeeded",this._increasePoolIfNeeded.bind(this,p),t))}},_render:function(){if(this.isAttached&&this._isVisible)if(0!==this._physicalCount){var l=this._getReusables(!0);this._physicalTop=l.physicalTop;this._virtualStart+=
l.indexes.length;this._physicalStart+=l.indexes.length;this._update(l.indexes);this._update();this._increasePoolIfNeeded(0)}else 0<this._virtualCount&&(this.updateViewportBoundaries(),this._increasePoolIfNeeded(3))},_ensureTemplatized:function(){if(!this.ctor){(this._userTemplate=this.queryEffectiveChildren("template"))||console.warn("iron-list requires a template to be provided in light-dom");var l={__key__:!0};l[this.as]=!0;l[this.indexAs]=!0;l[this.selectedAs]=!0;l.tabIndex=!0;this._instanceProps=
l;this.templatize(this._userTemplate,this.mutableData)}},_gridChanged:function(l,p){"undefined"!==typeof p&&(this.notifyResize(),Polymer.flush?Polymer.flush():Polymer.dom.flush(),l&&this._updateGridMetrics())},_itemsChanged:function(l){if("items"===l.path)this._physicalTop=this._virtualStart=0,this._virtualCount=this.items?this.items.length:0,this._collection=this.items&&Polymer.Collection?Polymer.Collection.get(this.items):null,this._physicalIndexForKey={},this._lastVisibleIndexVal=this._firstVisibleIndexVal=
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,h);else if("items.splices"===l.path){this._adjustVirtualIndex(l.value.indexSplices);this._virtualCount=this.items?this.items.length:0;if(l.value.indexSplices.some(function(m){return 0<m.addedCount||0<m.removed.length})){var p=
this._getActiveElement();this.contains(p)&&p.blur()}l=l.value.indexSplices.some(function(m){return m.index+m.addedCount>=this._virtualStart&&m.index<=this._virtualEnd},this);this._isClientFull()&&!l||this._debounce("_render",this._render,h)}else"items.length"!==l.path&&this._forwardItemPath(l.path,l.value)},_forwardItemPath:function(l,p){l=l.slice(6);var m=l.indexOf(".");-1===m&&(m=l.length);var n,q=this.modelForElement(this._offscreenFocusedItem);if(f){var u=parseInt(l.substring(0,m),10);if(n=this._isIndexRendered(u)){var x=
this._getPhysicalIndex(u);var A=this.modelForElement(this._physicalItems[x])}else q&&(A=q);if(!A||A[this.indexAs]!==u)return}else if(u=l.substring(0,m),q&&q.__key__===u)A=q;else if(x=this._physicalIndexForKey[u],A=this.modelForElement(this._physicalItems[x]),!A||A.__key__!==u)return;l=l.substring(m+1);l=this.as+(l?"."+l:"");f?A._setPendingPropertyOrPath(l,p,!1,!0):A.notifyPath(l,p,!0);A._flushProperties&&A._flushProperties(!0);n&&(this._updateMetrics([x]),this._positionItems(),this._updateScrollerSize())},
_adjustVirtualIndex:function(l){l.forEach(function(p){p.removed.forEach(this._removeItem,this);p.index<this._virtualStart&&(p=Math.max(p.addedCount-p.removed.length,p.index-this._virtualStart),this._virtualStart+=p,0<=this._focusedVirtualIndex&&(this._focusedVirtualIndex+=p))},this)},_removeItem:function(l){this.$.selector.deselect(l);this._focusedItem&&this.modelForElement(this._focusedItem)[this.as]===l&&this._removeFocusedItem()},_iterateItems:function(l,p){var m,n;if(2===arguments.length&&p)for(n=
0;n<p.length;n++){var q=p[n];var u=this._computeVidx(q);if(null!=(m=l.call(this,q,u)))return m}else{q=this._physicalStart;for(u=this._virtualStart;q<this._physicalCount;q++,u++)if(null!=(m=l.call(this,q,u)))return m;for(q=0;q<this._physicalStart;q++,u++)if(null!=(m=l.call(this,q,u)))return m}},_computeVidx:function(l){return l>=this._physicalStart?this._virtualStart+(l-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+l},_assignModels:function(l){this._iterateItems(function(p,
m){var n=this._physicalItems[p],q=this.items&&this.items[m];if(null!=q){var u=this.modelForElement(n);u.__key__=this._collection?this._collection.getKey(q):null;this._forwardProperty(u,this.as,q);this._forwardProperty(u,this.selectedAs,this.$.selector.isSelected(q));this._forwardProperty(u,this.indexAs,m);this._forwardProperty(u,"tabIndex",this._focusedVirtualIndex===m?0:-1);this._physicalIndexForKey[u.__key__]=p;u._flushProperties&&u._flushProperties(!0);n.removeAttribute("hidden")}else n.setAttribute("hidden",
"")},l)},_updateMetrics:function(l){Polymer.flush?Polymer.flush():Polymer.dom.flush();var p=0,m=0,n=this._physicalAverageCount,q=this._physicalAverage;this._iterateItems(function(u){m+=this._physicalSizes[u];this._physicalSizes[u]=this._physicalItems[u].offsetHeight;p+=this._physicalSizes[u];this._physicalAverageCount+=this._physicalSizes[u]?1:0},l);this.grid?(this._updateGridMetrics(),this._physicalSize=Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight):(m=1===this._itemsPerRow?m:
Math.ceil(this._physicalCount/this._itemsPerRow)*this._rowHeight,this._physicalSize=this._physicalSize+p-m,this._itemsPerRow=1);this._physicalAverageCount!==n&&(this._physicalAverage=Math.round((q*n+p)/this._physicalAverageCount))},_updateGridMetrics:function(){this._itemWidth=0<this._physicalCount?this._physicalItems[0].getBoundingClientRect().width:200;this._rowHeight=0<this._physicalCount?this._physicalItems[0].offsetHeight:200;this._itemsPerRow=this._itemWidth?Math.floor(this._viewportWidth/this._itemWidth):
this._itemsPerRow},_positionItems:function(){this._adjustScrollPosition();var l=this._physicalTop;if(this.grid){var p=(this._viewportWidth-this._itemsPerRow*this._itemWidth)/2;this._iterateItems(function(m,n){var q=Math.floor(n%this._itemsPerRow*this._itemWidth+p);this._isRTL&&(q*=-1);this.translate3d(q+"px",l+"px",0,this._physicalItems[m]);this._shouldRenderNextRow(n)&&(l+=this._rowHeight)})}else this._iterateItems(function(m){this.translate3d(0,l+"px",0,this._physicalItems[m]);l+=this._physicalSizes[m]})},
_getPhysicalSizeIncrement:function(l){return this.grid?this._computeVidx(l)%this._itemsPerRow!==this._itemsPerRow-1?0:this._rowHeight:this._physicalSizes[l]},_shouldRenderNextRow:function(l){return l%this._itemsPerRow===this._itemsPerRow-1},_adjustScrollPosition:function(){var l=0===this._virtualStart?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);if(0!==l){this._physicalTop-=l;var p=this._scrollTop;!d&&0<p&&this._resetScrollPosition(p-l)}},_resetScrollPosition:function(l){this.scrollTarget&&
0<=l&&(this._scrollPosition=this._scrollTop=l)},_updateScrollerSize:function(l){this._estScrollHeight=this.grid?this._virtualRowCount*this._rowHeight:this._physicalBottom+Math.max(this._virtualCount-this._physicalCount-this._virtualStart,0)*this._physicalAverage;if((l=(l=(l=l||0===this._scrollHeight)||this._scrollPosition>=this._estScrollHeight-this._physicalSize)||this.grid&&this.$.items.style.height<this._estScrollHeight)||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._viewportHeight)this.$.items.style.height=
this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight},scrollToItem:function(l){return this.scrollToIndex(this.items.indexOf(l))},scrollToIndex:function(l){if(!("number"!==typeof l||0>l||l>this.items.length-1)&&(Polymer.flush?Polymer.flush():Polymer.dom.flush(),0!==this._physicalCount)){l=this._clamp(l,0,this._virtualCount-1);if(!this._isIndexRendered(l)||l>=this._maxVirtualStart)this._virtualStart=this.grid?l-2*this._itemsPerRow:l-1;this._manageFocus();this._assignModels();this._updateMetrics();
this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage;for(var p=this._physicalStart,m=this._virtualStart,n=0,q=this._hiddenContentSize;m<l&&n<=q;)n+=this._getPhysicalSizeIncrement(p),p=(p+1)%this._physicalCount,m++;this._updateScrollerSize(!0);this._positionItems();this._resetScrollPosition(this._physicalTop+this._scrollOffset+n);this._increasePoolIfNeeded(0);this._lastVisibleIndexVal=this._firstVisibleIndexVal=null}},_resetAverage:function(){this._physicalAverageCount=
this._physicalAverage=0},_resizeHandler:function(){this._debounce("_render",function(){this._lastVisibleIndexVal=this._firstVisibleIndexVal=null;this.updateViewportBoundaries();this._isVisible?(this.toggleScrollListener(!0),this._resetAverage(),this._render()):this.toggleScrollListener(!1)},h)},selectItem:function(l){return this.selectIndex(this.items.indexOf(l))},selectIndex:function(l){if(!(0>l||l>=this._virtualCount)){!this.multiSelection&&this.selectedItem&&this.clearSelection();if(this._isIndexRendered(l)){var p=
this.modelForElement(this._physicalItems[this._getPhysicalIndex(l)]);p&&(p[this.selectedAs]=!0);this.updateSizeForIndex(l)}this.$.selector.selectIndex?this.$.selector.selectIndex(l):this.$.selector.select(this.items[l])}},deselectItem:function(l){return this.deselectIndex(this.items.indexOf(l))},deselectIndex:function(l){0>l||l>=this._virtualCount||(this._isIndexRendered(l)&&(this.modelForElement(this._physicalItems[this._getPhysicalIndex(l)])[this.selectedAs]=!1,this.updateSizeForIndex(l)),this.$.selector.deselectIndex?
this.$.selector.deselectIndex(l):this.$.selector.deselect(this.items[l]))},toggleSelectionForItem:function(l){return this.toggleSelectionForIndex(this.items.indexOf(l))},toggleSelectionForIndex:function(l){(this.$.selector.isIndexSelected?this.$.selector.isIndexSelected(l):this.$.selector.isSelected(this.items[l]))?this.deselectIndex(l):this.selectIndex(l)},clearSelection:function(){this._iterateItems(function(l){this.modelForElement(this._physicalItems[l])[this.selectedAs]=!1});this.$.selector.clearSelection()},
_selectionEnabledChanged:function(l){(l?this.listen:this.unlisten).call(this,this,"tap","_selectionHandler")},_selectionHandler:function(l){var p=this.modelForElement(l.target);if(p){var m=Polymer.dom(l).path[0];l=this._getActiveElement();var n=this._physicalItems[this._getPhysicalIndex(p[this.indexAs])];if("input"!==m.localName&&"button"!==m.localName&&"select"!==m.localName){m=p.tabIndex;p.tabIndex=-100;var q=l?l.tabIndex:-1;p.tabIndex=m;l&&n!==l&&n.contains(l)&&-100!==q||this.toggleSelectionForItem(p[this.as])}}},
_multiSelectionChanged:function(l){this.clearSelection();this.$.selector.multi=l},updateSizeForItem:function(l){return this.updateSizeForIndex(this.items.indexOf(l))},updateSizeForIndex:function(l){if(!this._isIndexRendered(l))return null;this._updateMetrics([this._getPhysicalIndex(l)]);this._positionItems();return null},_manageFocus:function(){var l=this._focusedVirtualIndex;0<=l&&l<this._virtualCount?this._isIndexRendered(l)?this._restoreFocusedItem():this._createFocusBackfillItem():0<this._virtualCount&&
0<this._physicalCount&&(this._focusedPhysicalIndex=this._physicalStart,this._focusedVirtualIndex=this._virtualStart,this._focusedItem=this._physicalItems[this._physicalStart])},_convertIndexToCompleteRow:function(l){this._itemsPerRow=this._itemsPerRow||1;return this.grid?Math.ceil(l/this._itemsPerRow)*this._itemsPerRow:l},_isIndexRendered:function(l){return l>=this._virtualStart&&l<=this._virtualEnd},_isIndexVisible:function(l){return l>=this.firstVisibleIndex&&l<=this.lastVisibleIndex},_getPhysicalIndex:function(l){return f?
(this._physicalStart+(l-this._virtualStart))%this._physicalCount:this._physicalIndexForKey[this._collection.getKey(this.items[l])]},focusItem:function(l){this._focusPhysicalItem(l)},_focusPhysicalItem:function(l){if(!(0>l||l>=this._virtualCount)){this._restoreFocusedItem();this._isIndexRendered(l)||this.scrollToIndex(l);var p=this._physicalItems[this._getPhysicalIndex(l)],m=this.modelForElement(p),n;m.tabIndex=-100;-100===p.tabIndex&&(n=p);n||(n=Polymer.dom(p).querySelector('[tabindex\x3d"-100"]'));
m.tabIndex=0;this._focusedVirtualIndex=l;n&&n.focus()}},_removeFocusedItem:function(){this._offscreenFocusedItem&&this._itemsParent.removeChild(this._offscreenFocusedItem);this._focusedItem=this._focusBackfillItem=this._offscreenFocusedItem=null;this._focusedPhysicalIndex=this._focusedVirtualIndex=-1},_createFocusBackfillItem:function(){var l=this._focusedPhysicalIndex;if(!(this._offscreenFocusedItem||0>this._focusedVirtualIndex)){if(!this._focusBackfillItem){var p=this.stamp(null);this._focusBackfillItem=
p.root.querySelector("*");this._itemsParent.appendChild(p.root)}this._offscreenFocusedItem=this._physicalItems[l];this.modelForElement(this._offscreenFocusedItem).tabIndex=0;this._physicalItems[l]=this._focusBackfillItem;this._focusedPhysicalIndex=l;this.translate3d(0,"-10000px",0,this._offscreenFocusedItem)}},_restoreFocusedItem:function(){if(this._offscreenFocusedItem&&!(0>this._focusedVirtualIndex)){this._assignModels();var l=this._focusedPhysicalIndex=this._getPhysicalIndex(this._focusedVirtualIndex),
p=this._physicalItems[l];if(p){var m=this.modelForElement(p),n=this.modelForElement(this._offscreenFocusedItem);m[this.as]===n[this.as]?(this._focusBackfillItem=p,m.tabIndex=-1,this._physicalItems[l]=this._offscreenFocusedItem,this.translate3d(0,"-10000px",0,this._focusBackfillItem)):(this._removeFocusedItem(),this._focusBackfillItem=null);this._offscreenFocusedItem=null}}},_didFocus:function(l){l=this.modelForElement(l.target);var p=this.modelForElement(this._focusedItem),m=null!==this._offscreenFocusedItem,
n=this._focusedVirtualIndex;l&&(p===l?this._isIndexVisible(n)||this.scrollToIndex(n):(this._restoreFocusedItem(),p&&(p.tabIndex=-1),l.tabIndex=0,this._focusedVirtualIndex=n=l[this.indexAs],this._focusedPhysicalIndex=this._getPhysicalIndex(n),this._focusedItem=this._physicalItems[this._focusedPhysicalIndex],m&&!this._offscreenFocusedItem&&this._update()))},_keydownHandler:function(l){switch(l.keyCode){case 40:this._focusedVirtualIndex<this._virtualCount-1&&l.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:0<this._focusedVirtualIndex&&l.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(l)}},_clamp:function(l,
p,m){return Math.min(m,Math.max(p,l))},_debounce:function(l,p,m){f?(this._debouncers=this._debouncers||{},this._debouncers[l]=Polymer.Debouncer.debounce(this._debouncers[l],m,p.bind(this)),Polymer.enqueueDebouncer(this._debouncers[l])):Polymer.dom.addDebouncer(this.debounce(l,p))},_forwardProperty:function(l,p,m){f?l._setPendingProperty(p,m):l[p]=m},_forwardHostPropV2:function(l,p){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(m){m&&this.modelForElement(m).forwardHostProp(l,
p)},this)},_notifyInstancePropV2:function(l,p,m){Polymer.Path.matches(this.as,p)&&(l=l[this.indexAs],p==this.as&&(this.items[l]=m),this.notifyPath(Polymer.Path.translate(this.as,"items."+l,p),m))},_getStampedChildren:function(){return this._physicalItems},_forwardInstancePath:function(l,p,m){0===p.indexOf(this.as+".")&&this.notifyPath("items."+l.__key__+"."+p.slice(this.as.length+1),m)},_forwardParentPath:function(l,p){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(m){m&&
this.modelForElement(m).notifyPath(l,p,!0)},this)},_forwardParentProp:function(l,p){(this._physicalItems||[]).concat([this._offscreenFocusedItem,this._focusBackfillItem]).forEach(function(m){m&&(this.modelForElement(m)[l]=p)},this)},_getActiveElement:function(){var l=this._itemsParent.node.domHost;return Polymer.dom(l?l.root:document).activeElement}})})();

//# sourceURL=build://paper-item/paper-item-body.html.js
Polymer({is:"paper-item-body"});

//# sourceURL=build://tf-graph-common/tf-graph-icon.js
(function(b){(function(d){(function(f){let h;(function(k){k.CONST="CONST";k.META="META";k.OP="OP";k.SERIES="SERIES";k.SUMMARY="SUMMARY"})(h=f.GraphIconType||(f.GraphIconType={}));Polymer({is:"tf-graph-icon",properties:{type:String,vertical:{type:Boolean,value:!1},fillOverride:{type:String,value:null},strokeOverride:{type:String,value:null},height:{type:Number,value:20},faded:{type:Boolean,value:!1},_fill:{type:String,computed:"_computeFill(type, fillOverride)"},_stroke:{type:String,computed:"_computeStroke(type, strokeOverride)"}},
getSvgDefinableElement(){return this.$.svgDefs},_computeFill(k,t){if(null!=t)return t;switch(k){case h.META:return b.graph.render.MetanodeColors.DEFAULT_FILL;case h.SERIES:return b.graph.render.SeriesNodeColors.DEFAULT_FILL;default:return b.graph.render.OpNodeColors.DEFAULT_FILL}},_computeStroke(k,t){if(null!=t)return t;switch(k){case h.META:return b.graph.render.MetanodeColors.DEFAULT_STROKE;case h.SERIES:return b.graph.render.SeriesNodeColors.DEFAULT_STROKE;default:return b.graph.render.OpNodeColors.DEFAULT_STROKE}},
_isType(k,t){return k===t},_fadedClass:function(k,t){return k?"faded-"+t:""}})})(d.icon||(d.icon={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-common/tf-node-icon.html.js
(function(){Polymer({is:"tf-node-icon",properties:{node:{type:Object,value:null},renderInfo:{type:Object,value:null},colorBy:{type:Object,value:"structural"},templateIndex:{type:Function,value:null},type:{type:String,value:null},vertical:{type:Boolean,value:!1},const:{type:Boolean,value:!1},summary:{type:Boolean,value:!1},fill:{type:String,value:null},height:{type:Number,value:20},_fillOverride:{type:String,computed:"_computeFillOverride(node, renderInfo, colorBy, templateIndex, fill)",observer:"_onFillOverrideChanged"}},
_computeFillOverride:function(b,d,f,h,k){return b&&d&&f&&h?(b=tf.graph.scene.node,b.getFillForNode(h,b.ColorBy[f.toUpperCase()],d,!1)):k},_getStrokeOverride:function(b){return b?tf.graph.scene.node.getStrokeForFill(b):null},_getType:function(b,d,f,h){const k=tf.graph.icon.GraphIconType;if(b)switch(b.type){case tf.graph.NodeType.OP:return b=b.op,"string"!==typeof b?k.OP:"Const"===b||f?k.CONST:b.endsWith("Summary")||d?k.SUMMARY:k.OP;case tf.graph.NodeType.META:return k.META;case tf.graph.NodeType.SERIES:return k.SERIES}return h},
_isVertical:function(b,d){return b?b.hasNonControlEdges:!!d},_getFaded:function(b){return b&&b.isFadedOut},_onFillOverrideChanged(b,d){const f=this.node,h=this.renderInfo,k=this.colorBy,t=this.templateIndex,l=tf.graph.scene.node;b!==d&&l.removeGradientDefinitions(this.$.icon.getSvgDefinableElement());f&&h&&k&&t&&l.getFillForNode(t,l.ColorBy[k.toUpperCase()],h,!1,this.$.icon.getSvgDefinableElement())}})})();

//# sourceURL=build://tf-graph-op-compat-card/tf-graph-op-compat-list-item.html.js
(function(){Polymer({is:"tf-graph-op-compat-list-item",properties:{cardNode:Object,itemNode:Object,edgeLabel:String,itemRenderInfo:Object,name:String,itemType:{type:String,observer:"_itemTypeChanged"},colorBy:String,colorByParams:Object,templateIndex:Function},_itemTypeChanged:function(){"subnode"!==this.itemType?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")},_nodeListener:function(b){this.fire("node-list-item-"+b.type,{nodeName:this.name,type:this.itemType})},
_fadedClass:function(b){return b&&b.isFadedOut?"faded":""}})})();

//# sourceURL=build://tf-graph-op-compat-card/tf-graph-op-compat-card.html.js
(function(){Polymer({is:"tf-graph-op-compat-card",properties:{graphHierarchy:Object,hierarchyParams:Object,renderHierarchy:Object,nodeTitle:String,_templateIndex:{type:Function,computed:"_getTemplateIndex(graphHierarchy)"},_incompatibleOpNodes:{type:Object,computed:"_getIncompatibleOpNodes(graphHierarchy, hierarchyParams)"},_expanded:{type:Boolean,value:!0},_opCompatScore:{type:Number,computed:"_computeOpCompatScore(graphHierarchy)"},_opCompatScoreLabel:{type:String,computed:"_getOpCompatScoreLabel(_opCompatScore)"},
_opCompatColor:{type:String,value:tf.graph.render.OpNodeColors.COMPATIBLE},_opIncompatColor:{type:String,value:tf.graph.render.OpNodeColors.INCOMPATIBLE},_totalIncompatOps:{type:Number,computed:"_getTotalIncompatibleOps(graphHierarchy)"}},_getTemplateIndex:function(b){return b.getTemplateIndex()},_getNode:function(b,d){return d.node(b)},_getPrintableHTMLNodeName:function(b){return(b||"").replace(/\//g,"\x3cwbr\x3e/")},_getRenderInfo:function(b){return this.renderHierarchy.getOrCreateRenderNodeByName(b)},
_toggleExpanded:function(){this._expanded=!this._expanded},_getToggleIcon:function(b){return b?"expand-less":"expand-more"},_resizeList:function(b){(b=document.querySelector(b))&&b.fire("iron-resize")},_getIncompatibleOpNodes:function(b,d){if(b&&b.root)return this.async(this._resizeList.bind(this,"#incompatibleOpsList")),tf.graph.hierarchy.getIncompatibleOps(b,d)},_computeOpCompatScore:function(b){if(b&&b.root){var d=b.root;b=d.compatibilityHistogram.compatible;d=d.compatibilityHistogram.incompatible;
return 0==b&&0==d?0:Math.floor(100*b/(b+d))/100}return 0},_getOpCompatScoreLabel:function(b){return d3.format(".0%")(b)},_getTotalIncompatibleOps:function(b){return b&&b.root?b.root.compatibilityHistogram.incompatible:0}})})();

//# sourceURL=build://tf-graph-info/tf-node-list-item.html.js
(function(){Polymer({is:"tf-node-list-item",properties:{cardNode:Object,itemNode:Object,edgeLabel:String,itemRenderInfo:Object,name:String,itemType:{type:String,observer:"_itemTypeChanged"},colorBy:String,colorByParams:Object,templateIndex:Function},_itemTypeChanged:function(){"subnode"!==this.itemType?this.$["list-item"].classList.add("clickable"):this.$["list-item"].classList.remove("clickable")},_nodeListener:function(b){this.fire("node-list-item-"+b.type,{cardNode:this.cardNode.name,nodeName:this.name,
type:this.itemType})},_fadedClass:function(b){return b&&b.isFadedOut?"faded":""}})})();

//# sourceURL=build://tf-graph-info/tf-node-info.html.js
(function(){Polymer({is:"tf-node-info",properties:{graphNodeName:String,graphHierarchy:Object,renderHierarchy:Object,colorBy:String,_templateIndex:{type:Function,computed:"_getTemplateIndex(graphHierarchy)"},_node:{type:Object,computed:"_getNode(graphNodeName, graphHierarchy)",observer:"_resetState"},_nodeStats:{type:Object,computed:"_getNodeStats(graphNodeName, graphHierarchy)",observer:"_resetState"},_hasDisplayableNodeStats:{type:Object,computed:"_getHasDisplayableNodeStats(_nodeStats)"},_nodeStatsFormattedBytes:{type:String,
computed:"_getNodeStatsFormattedBytes(_nodeStats)"},_nodeStatsFormattedComputeTime:{type:String,computed:"_getNodeStatsFormattedComputeTime(_nodeStats)"},_nodeStatsFormattedOutputSizes:{type:Array,computed:"_getNodeStatsFormattedOutputSizes(_nodeStats)"},nodeInclude:{type:Number,observer:"_nodeIncludeStateChanged"},_attributes:{type:Array,computed:"_getAttributes(_node)"},_device:{type:String,computed:"_getDevice(_node)"},_successors:{type:Object,computed:"_getSuccessors(_node, graphHierarchy)"},
_predecessors:{type:Object,computed:"_getPredecessors(_node, graphHierarchy)"},_functionUsages:{type:Array,computed:"_getFunctionUsages(_node, graphHierarchy)"},_subnodes:{type:Array,computed:"_getSubnodes(_node)"},_expanded:{type:Boolean,value:!0},_totalPredecessors:{type:Number,computed:"_getTotalPred(_predecessors)"},_totalSuccessors:{type:Number,computed:"_getTotalSucc(_successors)"},_openedControlPred:{type:Boolean,value:!1},_openedControlSucc:{type:Boolean,value:!1},_auxButtonText:String,_groupButtonText:String},
expandNode:function(){this.fire("_node.expand",this.node)},_getTemplateIndex:function(b){return b.getTemplateIndex()},_getNode:function(b,d){return d.node(b)},_getNodeStats:function(b,d){return(b=this._getNode(b,d))?b.stats:null},_getTotalMicros:function(b){return b?b.getTotalMicros():0},_getHasDisplayableNodeStats:function(b){return tf.graph.util.hasDisplayableNodeStats(b)},_getNodeStatsFormattedBytes:function(b){if(b&&b.totalBytes)return tf.graph.util.convertUnitsToHumanReadable(b.totalBytes,tf.graph.util.MEMORY_UNITS)},
_getNodeStatsFormattedComputeTime:function(b){if(b&&b.getTotalMicros())return tf.graph.util.convertUnitsToHumanReadable(b.getTotalMicros(),tf.graph.util.TIME_UNITS)},_getNodeStatsFormattedOutputSizes:function(b){if(b&&b.outputSize&&b.outputSize.length)return _.map(b.outputSize,function(d){return 0===d.length?"scalar":"["+d.join(", ")+"]"})},_getPrintableHTMLNodeName:function(b){return(b||"").replace(/\//g,"\x3cwbr\x3e/")},_getRenderInfo:function(b){return this.renderHierarchy.getOrCreateRenderNodeByName(b)},
_getAttributes:function(b){this.async(this._resizeList.bind(this,"#attributesList"));if(!b||!b.attr)return[];var d=[];_.each(b.attr,function(f){f.key===tf.graph.LARGE_ATTRS_KEY?d=d.concat(f.value.list.s.map(function(h){return{key:h,value:"Too large to show..."}})):d.push({key:f.key,value:JSON.stringify(f.value)})});return d},_getDevice:function(b){return b?b.device:null},_getSuccessors(b,d){this._refreshNodeItemList("inputsList");return b?this._convertEdgeListToEdgeInfoList(d.getSuccessors(b.name),
!1,b.isGroupNode):{regular:[],control:[]}},_getPredecessors(b,d){this._refreshNodeItemList("outputsList");return b?this._convertEdgeListToEdgeInfoList(d.getPredecessors(b.name),!0,b.isGroupNode):{regular:[],control:[]}},_getFunctionUsages(b,d){this._refreshNodeItemList("functionUsagesList");return b&&b.type===tf.graph.NodeType.META?(b=d.libraryFunctions[b.associatedFunction])?b.usages:[]:[]},_refreshNodeItemList(b){this.async(this._resizeList.bind(this,`#${b}`))},_convertEdgeListToEdgeInfoList:function(b,
d,f){var h=t=>_.map(t.baseEdgeList,l=>{var p=d?l.v:l.w;return{name:p,node:this._getNode(p,this.graphHierarchy),edgeLabel:tf.graph.scene.edge.getLabelForBaseEdge(l,this.renderHierarchy),renderInfo:this._getRenderInfo(p,this.renderHierarchy)}}),k=function(t){var l=[];_.each(t,p=>{var m=d?p.v:p.w;f&&1!=p.baseEdgeList.length?l.push({name:m,node:this._getNode(m,this.graphHierarchy),edgeLabel:tf.graph.scene.edge.getLabelForEdge(p,this.renderHierarchy),renderInfo:this._getRenderInfo(m,this.renderHierarchy)}):
l=l.concat(h(p))});return l}.bind(this);return{regular:k(b.regular),control:k(b.control)}},_getSubnodes:function(b){return b&&b.metagraph?b.metagraph.nodes():null},_getTotalPred:function(b){return b.regular.length+b.control.length},_getTotalSucc:function(b){return b.regular.length+b.control.length},_toggleControlPred:function(){this._openedControlPred=!this._openedControlPred},_toggleControlSucc:function(){this._openedControlSucc=!this._openedControlSucc},_toggleExpanded:function(){this._expanded=
!this._expanded},_getToggleIcon:function(b){return b?"expand-less":"expand-more"},_resetState:function(){this._openedControlSucc=this._openedControlPred=!1;this.set("_groupButtonText",tf.graph.scene.node.getGroupSettingLabel(this._node));this._node&&(Polymer.dom(this.$.nodetitle).innerHTML=this._getPrintableHTMLNodeName(this._node.name))},_resizeList:function(b){(b=document.querySelector(b))&&b.fire("iron-resize")},_toggleInclude:function(){this.fire("node-toggle-inclusion",{name:this.graphNodeName})},
_nodeIncludeStateChanged:function(b){this.set("_auxButtonText",tf.graph.getIncludeNodeButtonString(b))},_toggleGroup:function(){var b=tf.graph.scene.node.getSeriesName(this._node);this.fire("node-toggle-seriesgroup",{name:b})},_isLibraryFunction(b){return b&&b.name.startsWith(tf.graph.FUNCTION_LIBRARY_NODE_PREFIX)},_isInSeries:function(b){return tf.graph.scene.node.canBeInSeries(b)}})})();

//# sourceURL=build://tf-graph-info/tf-graph-info.html.js
(function(){Polymer({is:"tf-graph-info",properties:{title:String,graphHierarchy:Object,graph:Object,renderHierarchy:Object,nodeNamesToHealthPills:Object,healthPillStepIndex:{type:Number,notify:!0},colorBy:String,compatNodeTitle:String,selectedNode:{type:String,notify:!0},highlightedNode:{type:String,notify:!0},selectedNodeInclude:{type:Number,notify:!0},debuggerDataEnabled:Boolean},listeners:{"node-list-item-click":"_nodeListItemClicked","node-list-item-mouseover":"_nodeListItemMouseover","node-list-item-mouseout":"_nodeListItemMouseout"},
_nodeListItemClicked:function(b){this.selectedNode=b.detail.nodeName},_nodeListItemMouseover:function(b){this.highlightedNode=b.detail.nodeName},_nodeListItemMouseout:function(){this.highlightedNode=null},_healthPillsAvailable:function(b,d){return b&&d&&0<Object.keys(d).length},_equals:function(b,d){return b===d}})})();

//# sourceURL=build://tf-graph-board/tf-graph-board.html.js
Polymer({is:"tf-graph-board",properties:{graphHierarchy:Object,graph:Object,stats:Object,progress:Object,traceInputs:Boolean,colorBy:String,colorByParams:{type:Object,notify:!0},renderHierarchy:{type:Object,notify:!0},debuggerDataEnabled:Boolean,areHealthPillsLoading:Boolean,debuggerNumericAlerts:{type:Array,notify:!0},nodeNamesToHealthPills:Object,allStepsModeEnabled:{type:Boolean,notify:!0,value:!1},specificHealthPillStep:{type:Number,notify:!0,value:0},healthPillStepIndex:Number,selectedNode:{type:String,
notify:!0},compatNodeTitle:{type:String,value:"TPU Compatibility"},edgeWidthFunction:Object,_selectedNodeInclude:Number,_highlightedNode:String,handleNodeSelected:Object,edgeLabelFunction:Object,handleEdgeSelected:Object},observers:["_updateNodeInclude(selectedNode, renderHierarchy)"],fit:function(){this.$.graph.fit()},_isNotComplete:function(b){return 100>b.value},_getContainerClass:function(b){var d="container";b.error&&(d+=" error");this._isNotComplete(b)&&(d+=" loading");return d},_onNodeInclusionToggled(b){this.$.graph.nodeToggleExtract(b.detail.name)},
_onNodeSeriesGroupToggled(b){this.$.graph.nodeToggleSeriesGroup(b.detail.name)},_updateNodeInclude(){const b=this.renderHierarchy?this.renderHierarchy.getNodeByName(this.selectedNode):null;this._selectedNodeInclude=b?b.include:tf.graph.InclusionType.UNSPECIFIED}});

//# sourceURL=build://iron-menu-behavior/iron-menubar-behavior.html.js
Polymer.IronMenubarBehaviorImpl={hostAttributes:{role:"menubar"},keyBindings:{left:"_onLeftKey",right:"_onRightKey"},_onUpKey:function(b){this.focusedItem.click();b.detail.keyboardEvent.preventDefault()},_onDownKey:function(b){this.focusedItem.click();b.detail.keyboardEvent.preventDefault()},get _isRTL(){return"rtl"===window.getComputedStyle(this).direction},_onLeftKey:function(b){this._isRTL?this._focusNext():this._focusPrevious();b.detail.keyboardEvent.preventDefault()},_onRightKey:function(b){this._isRTL?
this._focusPrevious():this._focusNext();b.detail.keyboardEvent.preventDefault()},_onKeydown:function(b){this.keyboardEventMatchesKeys(b,"up down left right esc")||this._focusWithKeyboardEvent(b)}};Polymer.IronMenubarBehavior=[Polymer.IronMenuBehavior,Polymer.IronMenubarBehaviorImpl];

//# sourceURL=build://paper-radio-button/paper-radio-button.html.js
Polymer({is:"paper-radio-button",behaviors:[Polymer.PaperCheckedElementBehavior],hostAttributes:{role:"radio","aria-checked":!1,tabindex:0},properties:{ariaActiveAttribute:{type:String,value:"aria-checked"}},ready:function(){this._rippleContainer=this.$.radioContainer},attached:function(){Polymer.RenderStatus.afterNextRender(this,function(){if("-1px"===this.getComputedStyleValue("--calculated-paper-radio-button-ink-size").trim()){var b=parseFloat(this.getComputedStyleValue("--calculated-paper-radio-button-size").trim()),
d=Math.floor(3*b);d%2!==b%2&&d++;this.updateStyles({"--paper-radio-button-ink-size":d+"px"})}})}});

//# sourceURL=build://paper-radio-group/paper-radio-group.html.js
Polymer({is:"paper-radio-group",behaviors:[Polymer.IronMenubarBehavior],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(b){var d=this._valueToItem(b);if(!d||!d.hasAttribute("disabled")){if(this.selected){d=this._valueToItem(this.selected);if(this.selected==b)if(this.allowEmptySelection)b="";else{d&&
(d.checked=!0);return}d&&(d.checked=!1)}Polymer.IronSelectableBehavior.select.apply(this,[b]);this.fire("paper-radio-group-changed")}},_activateFocusedItem:function(){this._itemActivate(this._valueForItem(this.focusedItem),this.focusedItem)},_onUpKey:function(b){this._focusPrevious();b.preventDefault();this._activateFocusedItem()},_onDownKey:function(b){this._focusNext();b.preventDefault();this._activateFocusedItem()},_onLeftKey:function(b){Polymer.IronMenubarBehaviorImpl._onLeftKey.apply(this,arguments);
this._activateFocusedItem()},_onRightKey:function(b){Polymer.IronMenubarBehaviorImpl._onRightKey.apply(this,arguments);this._activateFocusedItem()}});

//# sourceURL=build://paper-tooltip/paper-tooltip.html.js
Polymer({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 b=Polymer.dom(this).parentNode,d=Polymer.dom(this).getOwnerRoot();return this.for?Polymer.dom(d).querySelector("#"+this.for):b.nodeType==Node.DOCUMENT_FRAGMENT_NODE?d.host:b},attached:function(){this._findTarget()},detached:function(){this.manualMode||this._removeListeners()},
playAnimation:function(b){"entry"===b?this.show():"exit"===b&&this.hide()},cancelAnimation:function(){this.$.tooltip.classList.add("cancel-animation")},show:function(){if(!this._showing){if(""===Polymer.dom(this).textContent.trim()){for(var b=!0,d=Polymer.dom(this).getEffectiveChildNodes(),f=0;f<d.length;f++)if(""!==d[f].textContent.trim()){b=!1;break}if(b)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(){this._showing&&(this._animationPlaying?(this._showing=!1,this._cancelAnimation()):(this._onAnimationFinish(),this._showing=!1,this._animationPlaying=!0))},updatePosition:function(){if(this._target&&this.offsetParent){var b=this.offset;14!=this.marginTop&&14==this.offset&&(b=this.marginTop);var d=this.offsetParent.getBoundingClientRect(),f=this._target.getBoundingClientRect(),
h=this.getBoundingClientRect(),k=(f.width-h.width)/2,t=(f.height-h.height)/2,l=f.left-d.left,p=f.top-d.top;switch(this.position){case "top":var m=l+k;var n=p-h.height-b;break;case "bottom":m=l+k;n=p+f.height+b;break;case "left":m=l-h.width-b;n=p+t;break;case "right":m=l+f.width+b,n=p+t}this.fitToVisibleBounds?(d.left+m+h.width>window.innerWidth?(this.style.right="0px",this.style.left="auto"):(this.style.left=Math.max(0,m)+"px",this.style.right="auto"),d.top+n+h.height>window.innerHeight?(this.style.bottom=
d.height+"px",this.style.top="auto"):(this.style.top=Math.max(-d.top,n)+"px",this.style.bottom="auto")):(this.style.left=m+"px",this.style.top=n+"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(b){500!==b&&this.updateStyles({"--paper-tooltip-delay-in":b+"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(b){if("entry"===b&&""!==this.animationEntry)return this.animationEntry;
if("exit"===b&&""!==this.animationExit)return this.animationExit;if(this.animationConfig[b]&&"string"===typeof this.animationConfig[b][0].name){if(this.animationConfig[b][0].timing&&this.animationConfig[b][0].timing.delay&&0!==this.animationConfig[b][0].timing.delay){var d=this.animationConfig[b][0].timing.delay;"entry"===b?this.updateStyles({"--paper-tooltip-delay-in":d+"ms"}):"exit"===b&&this.updateStyles({"--paper-tooltip-delay-out":d+"ms"})}return this.animationConfig[b][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")}});

//# sourceURL=build://tf-graph-node-search/tf-graph-node-search.html.js
Polymer({is:"tf-graph-node-search",properties:{renderHierarchy:Object,selectedNode:{type:String,notify:!0},_rawRegexInput:{type:String,value:""},_regexInput:{type:String,computed:"_computeRegexInput(renderHierarchy, _rawRegexInput)"},_previousRegexInput:{type:String,value:""},_searchTimeoutDelay:{type:Number,value:150,readOnly:!0},_searchPending:Boolean,_maxRegexResults:{type:Number,value:42},_regexMatches:Array},observers:["_regexInputChanged(_regexInput)"],_computeRegexInput(b,d){return d.trim()},
_regexInputChanged(){this._requestSearch()},_clearSearchResults(){this.set("_regexMatches",[])},_requestSearch(){this._searchPending||(this._regexInput===this._previousRegexInput?this._searchPending=!1:(this._searchPending=!0,this._executeSearch(),this.async(()=>{this._searchPending=!1;this._requestSearch()},this._searchTimeoutDelay)))},_executeSearch(){if(this._previousRegexInput=this._regexInput){try{var b=new RegExp(this._regexInput)}catch(f){this._clearSearchResults();return}var d=[];_.each(this.renderHierarchy.hierarchy.getNodeMap(),
(f,h)=>{if(d.length>=this._maxRegexResults)return!1;b.test(h)&&d.push(h)});this.set("_regexMatches",d)}else this._clearSearchResults()},_matchClicked(b){this.set("selectedNode",b.model.item)}});

//# sourceURL=build://tf-graph-controls/tf-graph-controls.js
(function(b){(function(d){(function(f){const h=/device:([^:]+:[0-9]+)$/,k=[{regex:h}],t=[];let l;(function(m){m.COMPUTE_TIME="compute_time";m.MEMORY="memory";m.STRUCTURE="structure";m.XLA_CLUSTER="xla_cluster";m.OP_COMPATIBILITY="op_compatibility"})(l=f.ColorBy||(f.ColorBy={}));const p=new Set([l.COMPUTE_TIME,l.MEMORY]);Polymer({is:"tf-graph-controls",properties:{stats:{value:null,type:Object,observer:"_statsChanged"},devicesForStats:{value:null,type:Object,notify:!0,readonly:!0},colorBy:{type:String,
value:l.STRUCTURE,notify:!0},colorByParams:{type:Object,notify:!0,readonly:!0},datasets:{type:Array,observer:"_datasetsChanged",value:()=>[]},renderHierarchy:{type:Object},selection:{type:Object,notify:!0,readOnly:!0,computed:"_computeSelection(datasets, _selectedRunIndex, _selectedTagIndex, _selectedGraphType)"},selectedFile:{type:Object,notify:!0},_selectedRunIndex:{type:Number,value:0,observer:"_selectedRunIndexChanged"},traceInputs:{type:Boolean,notify:!0,value:!1},_selectedTagIndex:{type:Number,
value:0,observer:"_selectedTagIndexChanged"},_selectedGraphType:{type:String,value:b.graph.SelectionType.OP_GRAPH},selectedNode:{type:String,notify:!0},_currentDevices:{type:Array,computed:"_getCurrentDevices(devicesForStats)"},_currentDeviceParams:{type:Array,computed:"_getCurrentDeviceParams(colorByParams)"},_currentXlaClusterParams:{type:Array,computed:"_getCurrentXlaClusterParams(colorByParams)"},_currentGradientParams:{type:Object,computed:"_getCurrentGradientParams(colorByParams, colorBy)"},
showSessionRunsDropdown:{type:Boolean,value:!0},showUploadButton:{type:Boolean,value:!0},healthPillsFeatureEnabled:Boolean,healthPillsToggledOn:{type:Boolean,notify:!0},_legendOpened:{type:Boolean,value:!0}},_xlaClustersProvided:function(m){return m&&m.hierarchy&&0<m.hierarchy.xlaClusters.length},_statsChanged:function(m){if(null!=m){var n={};_.each(m.dev_stats,function(q){var u=_.some(k,function(A){return A.regex.test(q.device)}),x=_.some(t,function(A){return A.regex.test(q.device)});u&&!x&&(n[q.device]=
!0)});this.set("devicesForStats",n)}},_getCurrentDevices:function(m){var n=this.stats;n=(n?n.dev_stats:[]).map(u=>u.device).filter(u=>k.some(x=>x.regex.test(u)));const q=b.graph.util.removeCommonPrefix(n);if(1==q.length){const u=q[0].match(h);u&&(q[0]=u[1])}return n.map((u,x)=>{let A=null;t.forEach(y=>{y.regex.test(u)&&(A=y.msg)});return{device:u,suffix:q[x],used:m[u],ignoredMsg:A}})},_deviceCheckboxClicked:function(m){m=m.target;const n=Object.assign({},this.devicesForStats),q=m.value;m.checked?
n[q]=!0:delete n[q];this.set("devicesForStats",n)},_numTags:function(m,n){return this._getTags(m,n).length},_getTags:function(m,n){return m&&m[n]?m[n].tags:[]},_fit:function(){this.fire("fit-tap")},_isGradientColoring:function(m,n){return p.has(n)&&null!=m},_equals:function(m,n){return m===n},_getCurrentDeviceParams:function(m){m=m.device.filter(u=>k.some(x=>x.regex.test(u.device)));const n=b.graph.util.removeCommonPrefix(m.map(u=>u.device));if(1==n.length){var q=n[0].match(h);q&&(n[0]=q[1])}return m.map((u,
x)=>({device:n[x],color:u.color}))},_getCurrentXlaClusterParams:function(m){return m.xla_cluster},_getCurrentGradientParams:function(m,n){if(this._isGradientColoring(this.stats,n)){m=m[n];var q=m.minValue,u=m.maxValue;n===l.MEMORY?(q=b.graph.util.convertUnitsToHumanReadable(q,b.graph.util.MEMORY_UNITS),u=b.graph.util.convertUnitsToHumanReadable(u,b.graph.util.MEMORY_UNITS)):n===l.COMPUTE_TIME&&(q=b.graph.util.convertUnitsToHumanReadable(q,b.graph.util.TIME_UNITS),u=b.graph.util.convertUnitsToHumanReadable(u,
b.graph.util.TIME_UNITS));return{minValue:q,maxValue:u,startColor:m.startColor,endColor:m.endColor}}},download:function(){this.$.graphdownload.click()},_updateFileInput:function(m){var n=m.target.files[0];if(n){n=n.name;var q=n.lastIndexOf(".");0<=q&&(n=n.substring(0,q));q=n.lastIndexOf("/");0<=q&&(n=n.substring(q+1));this._setDownloadFilename(n);this.set("selectedFile",m)}},_datasetsChanged:function(m,n){null!=n&&(this._selectedRunIndex=0)},_computeSelection:function(m,n,q,u){return m[n]&&m[n].tags[q]?
{run:m[n].name,tag:m[n].tags[q].tag,type:u}:null},_selectedRunIndexChanged:function(m){this.datasets&&(this.colorBy=l.STRUCTURE,this._selectedTagIndex=0,this._selectedGraphType=this._getDefaultSelectionType(),this.traceInputs=!1,this._setDownloadFilename(this.datasets[m]?this.datasets[m].name:""))},_selectedTagIndexChanged(){this._selectedGraphType=this._getDefaultSelectionType()},_getDefaultSelectionType(){const m=this.datasets,n=this._selectedRunIndex,q=this._selectedTagIndex;return m&&m[n]&&m[n].tags[q]&&
!m[n].tags[q].opGraph?m[n].tags[q].profile?b.graph.SelectionType.PROFILE:m[n].tags[q].conceptualGraph?b.graph.SelectionType.CONCEPTUAL_GRAPH:b.graph.SelectionType.OP_GRAPH:b.graph.SelectionType.OP_GRAPH},_getFile:function(){this.$$("#file").click()},_setDownloadFilename:function(m){this.$.graphdownload.setAttribute("download",m+".png")},_statsNotNull:function(m){return null!==m},_toggleLegendOpen(){this.set("_legendOpened",!this._legendOpened)},_getToggleText(m){return m?"Close legend.":"Expand legend."},
_getToggleLegendIcon(m){return m?"expand-more":"expand-less"},_getSelectionOpGraphDisabled(m,n,q){return!m[n]||!m[n].tags[q]||!m[n].tags[q].opGraph},_getSelectionProfileDisabled(m,n,q){return!m[n]||!m[n].tags[q]||!m[n].tags[q].profile},_getSelectionConceptualGraphDisabled(m,n,q){return!m[n]||!m[n].tags[q]||!m[n].tags[q].conceptualGraph}})})(d.controls||(d.controls={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-loader/tf-graph-dashboard-loader.js
Ui=this&&this.__awaiter||function(b,d,f,h){return new (f||(f=Promise))(function(k,t){function l(n){try{m(h.next(n))}catch(q){t(q)}}function p(n){try{m(h["throw"](n))}catch(q){t(q)}}function m(n){n.done?k(n.value):(new f(function(q){q(n.value)})).then(l,p)}m((h=h.apply(b,d||[])).next())})};
(function(b){(function(d){(function(){Polymer({is:"tf-graph-dashboard-loader",_template:null,properties:{datasets:Array,progress:{type:Object,notify:!0},selection:Object,selectedFile:Object,compatibilityProvider:{type:Object,value:()=>new b.graph.op.TpuCompatibilityProvider},hierarchyParams:{type:Object,value:()=>b.graph.hierarchy.DefaultHierarchyParams},outGraphHierarchy:{type:Object,readOnly:!0,notify:!0},outGraph:{type:Object,readOnly:!0,notify:!0},outStats:{type:Object,readOnly:!0,notify:!0},
_graphRunTag:Object},observers:["_selectionChanged(selection, compatibilityProvider)","_selectedFileChanged(selectedFile, compatibilityProvider)"],_selectionChanged(){this.debounce("selectionchange",()=>{this._load(this.selection)})},_load:function(f){const h=f.run,k=f.tag;f=f.type;switch(f){case b.graph.SelectionType.OP_GRAPH:case b.graph.SelectionType.CONCEPTUAL_GRAPH:this._setOutStats(null);var t=new URLSearchParams;t.set("run",h);t.set("conceptual",String(f===b.graph.SelectionType.CONCEPTUAL_GRAPH));
k&&t.set("tag",k);f=vc.getRouter().pluginRoute("graphs","/graph",t);return this._fetchAndConstructHierarchicalGraph(f).then(()=>{this._graphRunTag={run:h,tag:k}});case b.graph.SelectionType.PROFILE:{({tags:f}=this.datasets.find(({name:m})=>m===h));const l=f.find(m=>m.tag===k).opGraph?k:null;console.assert(f.find(m=>m.tag===l),`Required tag (${l}) is missing.`);f=this._graphRunTag&&this._graphRunTag.run===h&&this._graphRunTag.tag===l?Promise.resolve():this._load({run:h,tag:l,type:b.graph.SelectionType.OP_GRAPH});
t=new URLSearchParams;t.set("tag",k);t.set("run",h);const p=vc.getRouter().pluginRoute("graphs","/run_metadata",t);return f.then(()=>this._readAndParseMetadata(p))}default:return Promise.reject(Error(`Unknown selection type: ${f}`))}},_readAndParseMetadata:function(f){this.set("progress",{value:0,msg:""});b.graph.parser.fetchAndParseMetadata(f,b.graph.util.getTracker(this)).then(h=>{this._setOutStats(h)})},_fetchAndConstructHierarchicalGraph:function(f,h){return Ui(this,void 0,void 0,function*(){this.set("progress",
{value:0,msg:""});return b.graph.loader.fetchAndConstructHierarchicalGraph(b.graph.util.getTracker(this),f,h,this.compatibilityProvider,this.hierarchyParams).then(({graph:k,graphHierarchy:t})=>{this._setOutGraph(k);this._setOutGraphHierarchy(t)})})},_selectedFileChanged:function(f){if(f){f=f.target;var h=f.files[0];h&&(f.value="",this._fetchAndConstructHierarchicalGraph(null,h))}}})})(d.loader||(d.loader={}))})(b.graph||(b.graph={}))})(tf||(tf={}));

//# sourceURL=build://tf-graph-dashboard/tf-graph-dashboard.html.js
Polymer({is:"tf-graph-dashboard",properties:{_datasets:{type:Array,value:()=>[]},_datasetsFetched:{type:Boolean,value:!1},_selectedDataset:{type:Number,value:0},_renderHierarchy:{type:Object,observer:"_renderHierarchyChanged"},_requestManager:{type:Object,value:()=>new vc.RequestManager},_canceller:{type:Object,value:()=>new vc.Canceller},_debuggerDataEnabled:Boolean,allStepsModeEnabled:Boolean,specificHealthPillStep:{type:Number,value:0},healthPillsToggledOn:{type:Boolean,value:!1,observer:"_healthPillsToggledOnChanged"},
selectedNode:{type:String,notify:!0},_isAttached:Boolean,_initialized:Boolean,_areHealthPillsLoading:Boolean,_debuggerNumericAlerts:{type:Array,value:[],notify:!0},_nodeNamesToHealthPills:{type:Object,value:{}},_healthPillStepIndex:Number,_healthPillRequestId:{type:Number,value:1},_healthPillStepRequestTimerId:Number,_healthPillStepRequestTimerDelay:{type:Number,value:500,readOnly:!0},runs:Array,run:{type:String,notify:!0,value:pd.getStringInitializer("run",{defaultValue:"",useLocalStorage:!1}),observer:"_runObserver"},
_selection:{type:Object},_compatibilityProvider:Object,_traceInputs:Boolean},listeners:{"node-toggle-expand":"_handleNodeToggleExpand"},observers:["_maybeFetchHealthPills(_debuggerDataEnabled, allStepsModeEnabled, specificHealthPillStep, _selectedNode)","_maybeInitializeDashboard(_isAttached)","_determineSelectedDataset(_datasetsFetched, _datasets, run)","_updateSelectedDatasetName(_datasetsFetched, _datasets, _selectedDataset)"],attached:function(){this.set("_isAttached",!0)},detached:function(){this.set("_isAttached",
!1)},reload:function(){this._debuggerDataEnabled||this._requestManager.request(vc.getRouter().pluginsListing()).then(this._canceller.cancellable(b=>{b.cancelled||b.value["debugger"]&&this.set("_debuggerDataEnabled",!0)}));this._maybeFetchHealthPills()},_fit:function(){this.$$("#graphboard").fit()},_runObserver:pd.getStringObserver("run",{defaultValue:"",polymerProperty:"run",useLocalStorage:!1}),_fetchDataset(){return this._requestManager.request(vc.getRouter().pluginRoute("graphs","/info"))},_fetchHealthPills(b,
d){b={node_names:JSON.stringify(b),run:"__debugger_data__"};void 0!==d&&(b.step=d);d=vc.getRouter().pluginRoute("debugger","/health_pills");return this._requestManager.request(d,b)},_fetchDebuggerNumericsAlerts(){return this._requestManager.request(vc.getRouter().pluginRoute("debugger","/numerics_alert_report"))},_graphUrl(b,d,f){return vc.getRouter().pluginRoute("graphs","/graph",new URLSearchParams({run:b,limit_attr_size:d,large_attrs_key:f}))},_shouldRequestHealthPills:function(){return this._debuggerDataEnabled&&
this.healthPillsToggledOn&&this._renderHierarchy&&this._datasetsState(this._datasetsFetched,this._datasets,"PRESENT")},_maybeInitializeDashboard:function(b){!this._initialized&&b&&(this.set("_compatibilityProvider",new tf.graph.op.TpuCompatibilityProvider),this._initialized=!0,this._fetchDataset().then(d=>{this._datasets=Object.keys(d).sort(rc.compareTagNames).map(f=>{const h=d[f];var k=Object.keys(h.tags).sort(rc.compareTagNames).map(t=>h.tags[t]).map(({tag:t,conceptual_graph:l,op_graph:p,profile:m})=>
({tag:t,displayName:t,conceptualGraph:l,opGraph:p,profile:m}));k=h.run_graph?[{tag:null,displayName:"Default",conceptualGraph:!1,opGraph:!0,profile:!1},...k]:k;return{name:f,tags:k}});this._datasetsFetched=!0}))},_determineSelectedDataset(b,d,f){f?(d=d.findIndex(h=>h.name===f),-1===d?b&&(b=this.$$("#error-dialog"),b.textContent=`No dataset named "${f}" could be found.`,b.open()):this.set("_selectedDataset",d)):this.set("_selectedDataset",0)},_updateSelectedDatasetName(b,d,f){b&&(d.length<=f||this.set("run",
d[f].name))},_requestHealthPills:function(){this.set("_areHealthPillsLoading",!0);var b=++this._healthPillRequestId;null!==this._healthPillStepRequestTimerId&&(window.clearTimeout(this._healthPillStepRequestTimerId),this._healthPillStepRequestTimerId=null);this.allStepsModeEnabled?this._healthPillStepRequestTimerId=setTimeout(function(){this._healthPillStepRequestTimerId=null;this._initiateNetworkRequestForHealthPills(b)}.bind(this),this._healthPillStepRequestTimerDelay):this._initiateNetworkRequestForHealthPills(b)},
_initiateNetworkRequestForHealthPills:function(b){if(this._healthPillRequestId===b){var d=this._fetchHealthPills(this._renderHierarchy.getNamesOfRenderedOps(),this.allStepsModeEnabled?this.specificHealthPillStep:void 0),f=this._fetchDebuggerNumericsAlerts();Promise.all([d,f]).then(function(h){var k=h[0];h=h[1];if(this.healthPillsToggledOn&&b===this._healthPillRequestId){for(var t in k){this.set("_healthPillStepIndex",k[t].length-1);break}this.set("_debuggerNumericAlerts",h);this.set("_nodeNamesToHealthPills",
k);this.set("_areHealthPillsLoading",!1);this.set("_healthPillStepRequestTimerId",null)}}.bind(this))}},_datasetsState:function(b,d,f){return b?d&&d.length?"PRESENT"===f:"EMPTY"===f:"NOT_LOADED"===f},_renderHierarchyChanged:function(){this.reload()},_handleNodeToggleExpand:function(){this._maybeFetchHealthPills()},_healthPillsToggledOnChanged:function(b){b?this.reload():this.set("_nodeNamesToHealthPills",{})},_maybeFetchHealthPills:function(){this._shouldRequestHealthPills()&&this._requestHealthPills()}});

//# sourceURL=build://vz-distribution-chart/vz-distribution-chart.js
var Jk;
(function(b){class d{constructor(f,h){this.run2datasets={};this.colorScale=h;this.buildChart(f)}getDataset(f){void 0===this.run2datasets[f]&&(this.run2datasets[f]=new Plottable.Dataset([],{run:f}));return this.run2datasets[f]}buildChart(f){this.outer&&this.outer.destroy();f=rg.getXComponents(f);this.xAccessor=f.accessor;this.xScale=f.scale;this.xAxis=f.axis;this.xAxis.margin(0).tickLabelPadding(3);this.yScale=new Plottable.Scales.Linear;this.yAxis=new Plottable.Axes.Numeric(this.yScale,"left");f=
rg.multiscaleFormatter(rg.Y_AXIS_FORMATTER_PRECISION);this.yAxis.margin(0).tickLabelPadding(5).formatter(f);this.yAxis.usesTextWidthApproximation();f=this.buildPlot(this.xAccessor,this.xScale,this.yScale);this.gridlines=new Plottable.Components.Gridlines(this.xScale,this.yScale);this.center=new Plottable.Components.Group([this.gridlines,f]);this.outer=new Plottable.Components.Table([[this.yAxis,this.center],[null,this.xAxis]])}buildPlot(f,h,k){let t=[0,228,1587,3085,5E3,6915,8413,9772,1E4],l=_.range(t.length-
1).map(u=>(t[u+1]-t[u])/2500),p=t.map((u,x)=>A=>A[x][1]),m=p[4],n=_.range(p.length-1).map(u=>{let x=new Plottable.Plots.Area;x.x(f,h);let A=4<u?p[u]:p[u+1];x.y(4<u?p[u+1]:p[u],k);x.y0(A);x.attr("fill",(y,w,C)=>this.colorScale.scale(C.metadata().run));x.attr("stroke",(y,w,C)=>this.colorScale.scale(C.metadata().run));x.attr("stroke-weight",()=>"0.5px");x.attr("stroke-opacity",()=>l[u]);x.attr("fill-opacity",()=>l[u]);return x}),q=new Plottable.Plots.Line;q.x(f,h);q.y(m,k);q.attr("stroke",(u,x,A)=>this.colorScale.scale(A.run));
this.plots=n;return new Plottable.Components.Group(n)}setVisibleSeries(f){this.runs=f;let h=f.map(k=>this.getDataset(k));this.plots.forEach(k=>k.datasets(h))}setSeriesData(f,h){this.getDataset(f).data(h)}renderTo(f){this.targetSVG=f;this.outer.renderTo(f)}redraw(){this.outer.redraw()}destroy(){this.outer.destroy()}}b.DistributionChart=d;Polymer({is:"vz-distribution-chart",properties:{colorScale:{type:Object,value:function(){return(new Plottable.Scales.Color).range(d3.schemeCategory10)}},xType:{type:String,
value:"step"},_attached:Boolean,_chart:Object,_visibleSeriesCache:{type:Array,value:function(){return[]}},_seriesDataCache:{type:Object,value:function(){return{}}},_makeChartAsyncCallbackId:{type:Number,value:null}},observers:["_makeChart(xType, colorScale, _attached)","_reloadFromCache(_chart)"],setVisibleSeries:function(f){this._visibleSeriesCache=f;this._chart&&(this._chart.setVisibleSeries(f),this.redraw())},setSeriesData:function(f,h){this._seriesDataCache[f]=h;this._chart&&this._chart.setSeriesData(f,
h)},redraw:function(){this._chart.redraw()},ready:function(){this.scopeSubtree(this.$.chartdiv,!0)},_makeChart:function(f,h,k){null===this._makeChartAsyncCallbackId&&this.cancelAsync(this._makeChartAsyncCallbackId);this._makeChartAsyncCallbackId=this.async(function(){this._makeChartAsyncCallbackId=null;if(k){this._chart&&this._chart.destroy();var t=new d(f,h),l=d3.select(this.$.chartdiv);t.renderTo(l);this._chart=t}},350)},_reloadFromCache:function(){this._chart&&(this._chart.setVisibleSeries(this._visibleSeriesCache),
this._visibleSeriesCache.forEach(function(f){this._chart.setSeriesData(f,this._seriesDataCache[f]||[])}.bind(this)))},attached:function(){this._attached=!0},detached:function(){this._attached=!1}})})(Jk||(Jk={}));

//# sourceURL=build://tf-distribution-dashboard/tf-distribution-loader.html.js
Polymer({is:"tf-distribution-loader",properties:{run:String,tag:String,tagMetadata:Object,xType:String,dataToLoad:{type:Array,computed:"_computeDataToLoad(run, tag)"},getDataLoadName:{type:Function,value:()=>({run:b})=>b},getDataLoadUrl:{type:Function,value:()=>({tag:b,run:d})=>vc.addParams(vc.getRouter().pluginRoute("distributions","/distributions"),{tag:b,run:d})},loadDataCallback:{type:Function,value:function(){return(b,d,f)=>{b=f.map(h=>{const [k,t,l]=h;l.wall_time=new Date(1E3*k);l.step=t;return l});
d=this.getDataLoadName(d);this.$.chart.setSeriesData(d,b);this.$.chart.setVisibleSeries([d])}}},_colorScale:{type:Object,value:()=>({scale:pf.runsColorScale}),readOnly:!0},_runColor:{type:String,computed:"_computeRunColor(run)"},_expanded:{type:Boolean,value:!1,reflectToAttribute:!0},requestManager:Object,_canceller:{type:Object,value:()=>new vc.Canceller}},observers:["reload(run, tag)"],behaviors:[qd.DataLoaderBehavior],_computeDataToLoad(b,d){return[{run:b,tag:d}]},_computeRunColor(b){return this._colorScale.scale(b)},
redraw(){this.$.chart.redraw()},_toggleExpanded(){this.set("_expanded",!this._expanded);this.redraw()}});

//# sourceURL=build://tf-distribution-dashboard/tf-distribution-dashboard.html.js
Polymer({is:"tf-distribution-dashboard",properties:{_xType:{type:String,value:"step"},_selectedRuns:Array,_runToTag:Object,_runToTagInfo:Object,_dataNotFound:Boolean,_tagFilter:String,_categoriesDomReady:Boolean,_categories:{type:Array,computed:"_makeCategories(_runToTag, _selectedRuns, _tagFilter, _categoriesDomReady)"},_requestManager:{type:Object,value:()=>new vc.RequestManager}},ready(){this.reload()},reload(){this._fetchTags().then(()=>{this._reloadDistributions()})},_fetchTags(){const b=vc.getRouter().pluginRoute("distributions",
"/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,this._runToTagInfo)){var f=_.mapValues(d,k=>Object.keys(k)),h=vc.getTags(f);this.set("_dataNotFound",0===h.length);this.set("_runToTag",f);this.set("_runToTagInfo",d);this.async(()=>{this.set("_categoriesDomReady",!0)})}})},_reloadDistributions(){this.root.querySelectorAll("tf-distribution-loader").forEach(b=>{b.reload()})},_shouldOpen(b){return 2>=b},_makeCategories(b,d,f){return $c.categorizeRunTagCombinations(b,d,f)},_tagMetadata(b,
d,f){return b[d][f]}});

//# sourceURL=build://vz-histogram-timeseries/vz-histogram-timeseries.html.js
Polymer({is:"vz-histogram-timeseries",properties:{mode:{type:String,value:"offset"},timeProperty:{type:String,value:"step"},bins:{type:String,value:"bins"},x:{type:String,value:"x"},dx:{type:String,value:"dx"},y:{type:String,value:"y"},colorScale:{type:Object,value:function(){return d3.scaleOrdinal(d3.schemeCategory10)}},modeTransitionDuration:{type:Number,value:500},_attached:Boolean,_name:{type:String,value:null},_data:{type:Array,value:null}},observers:["redraw(timeProperty, _attached)","_modeRedraw(mode)"],
ready:function(){this.scopeSubtree(this.$.svg,!0)},attached:function(){this._attached=!0},detached:function(){this._attached=!1},setSeriesData:function(b,d){this._name=b;this._data=d;this.redraw()},redraw:function(){this._draw(0)},_modeRedraw:function(){this._draw(this.modeTransitionDuration)},_draw:function(b){if(this._attached&&this._data){if(void 0===b)throw Error("vz-histogram-timeseries _draw needs duration");if(0>=this._data.length)throw Error("Not enough steps in the data");if(!this._data[0].hasOwnProperty(this.bins))throw Error("No bins property of '"+
this.bins+"' in data");if(0>=this._data[0][this.bins].length)throw Error("Must have at least one bin in bins in data");if(!this._data[0][this.bins][0].hasOwnProperty(this.x))throw Error("No x property '"+this.x+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.dx))throw Error("No dx property '"+this.dx+"' on bins data");if(!this._data[0][this.bins][0].hasOwnProperty(this.y))throw Error("No y property '"+this.y+"' on bins data");var d=this.timeProperty,f=this.x,h=this.bins,k=this.dx,
t=this.y,l=this._data,p=this.mode,m=d3.hcl(this.colorScale(this._name)),n=d3.select(this.$.tooltip),q=function(ya){return ya[f]},u=function(ya){return ya[t]},x=function(ya){return ya[f]+ya[k]},A=function(ya){return ya[d]};"relative"===d&&(A=function(ya){return ya.wall_time-l[0].wall_time});var y=this.$.svg.getBoundingClientRect(),w=y.width,C=y.height,G=5;if("offset"===p){var D=C/2.5;G=D+5}else D=C-G-20;var B=w-24-60,I=C-G-20;d3.min(l,q);d3.max(l,x);var N=d3.format(".3n");y=d3.format(".0f");"wall_time"===
d?y=d3.timeFormat("%m/%d %X"):"relative"===d&&(y=function(ya){return d3.format(".1r")(ya/36E5)+"h"});var O=l.map(function(ya){return[d3.min(ya[h],q),d3.max(ya[h],x)]}),H=l.map(function(ya){return d3.extent(ya[h],u)}),K=d3.extent(l,A),M=("wall_time"===d?d3.scaleTime():d3.scaleLinear()).domain(K).range([0,"offset"===p?I:0]),L=d3.scaleLinear().domain([0,d3.max(l,function(ya,Sa){return H[Sa][1]})]).range([D,0]),Q=d3.scaleLinear().domain(L.domain()).range([500,0]),T=d3.scaleLinear().domain([d3.min(l,function(ya,
Sa){return O[Sa][0]}),d3.max(l,function(ya,Sa){return O[Sa][1]})]).nice().range([0,B]),X=d3.scaleLinear().domain(T.domain()).range([0,500]),aa=d3.scaleLinear().domain(d3.extent(l,A)).range([m.darker(),m.brighter()]).interpolate(d3.interpolateHcl);m=d3.axisBottom(T).ticks();var la=d3.axisRight(M).ticks().tickFormat(y),Z=d3.axisRight(L).ticks().tickSize(B+5).tickFormat(N),ba=function(ya){return ya[f]+ya[k]/2},ea=d3.line().x(function(ya){return X(ba(ya))}).y(function(ya){return Q(ya[t])}),ca=function(ya){return"M"+
X(ba(ya[0]))+","+Q(0)+"L"+ea(ya).slice(1)+"L"+X(ba(ya[ya.length-1]))+","+Q(0)},ka=this.$.svg;y=d3.select(ka);b=y.transition().duration(b);y=y.select("g").classed("small",function(){return 0<B&&150>=B}).classed("medium",function(){return 150<B&&300>=B}).classed("large",function(){return 300<B});b=b.select("g").attr("transform","translate(24,"+G+")");var Y=d3.bisector(x).left;K=y.select(".stage").on("mouseover",function(){va.style("opacity",1);xa.style("opacity",1);Aa.style("opacity",1);Fa.style("opacity",
1);n.style("opacity",1)}).on("mouseout",function(){va.style("opacity",0);xa.style("opacity",0);Aa.style("opacity",0);Fa.style("opacity",0);va.classed("hover-closest",!1);Ea.classed("outline-hover",!1);n.style("opacity",0)}).on("mousemove",function(){function ya(Ab){return Math.min(Ab[h].length-1,Y(Ab[h],Xa))}var Sa=d3.mouse(this),Xa=T.invert(Sa[0]);M.invert(Sa[1]);var ub,Bb=Infinity,qb;va.attr("transform",function(Ab){var Hb=ya(Ab);qb=Ab;var ic=T(Ab[h][Hb][f]+Ab[h][Hb][k]/2);Hb=L(Ab[h][Hb][t]);var bc=
"offset"===p?M(A(Ab))-(D-Hb):Hb;bc=Math.abs(Sa[1]-bc);bc<Bb&&(Bb=bc,ub=Ab);return"translate("+ic+","+Hb+")"});va.select("text").text(function(Ab){var Hb=ya(Ab);return Ab[h][Hb][t]});va.classed("hover-closest",function(Ab){return Ab===ub});Ea.classed("outline-hover",function(Ab){return Ab===ub});var zb=ya(qb);xa.attr("transform",function(){return"translate("+T(qb[h][zb][f]+qb[h][zb][k]/2)+", "+I+")"}).select("text").text(function(){return N(qb[h][zb][f]+qb[h][zb][k]/2)});var vb=la.tickFormat();Aa.attr("transform",
function(){return"translate("+B+", "+("offset"===p?M(A(ub)):0)+")"}).style("display","offset"===p?"":"none").select("text").text(function(){return vb(A(ub))});var Gb=Z.tickFormat();Fa.attr("transform",function(){return"translate("+B+", "+("offset"===p?0:L(ub[h][zb][t]))+")"}).style("display","offset"===p?"none":"").select("text").text(function(){return Gb(ub[h][zb][t])});var Nb=d3.mouse(ka);n.style("transform","translate("+(Nb[0]+15)+"px,"+(Nb[1]-15)+"px)").select("span").text("offset"===p?Gb(ub[h][zb][t]):
("step"===d?"step ":"")+vb(A(ub)))});K.select(".background").attr("transform","translate(-24,"+-G+")").attr("width",w).attr("height",C);C=K.selectAll(".histogram").data(l);C.exit().remove();w=C.enter().append("g").attr("class","histogram");C=w.merge(C).sort(function(ya,Sa){return A(ya)-A(Sa)});G=b.selectAll(".histogram").attr("transform",function(ya){return"translate(0, "+("offset"===p?M(A(ya))-D:0)+")"});w.append("line").attr("class","baseline");G.select(".baseline").style("stroke-opacity",function(){return"offset"===
p?.1:0}).attr("y1",D).attr("y2",D).attr("x2",B);w.append("path").attr("class","outline");var Ea=C.select(".outline").attr("vector-effect","non-scaling-stroke").attr("d",function(ya){return ca(ya[h])}).style("stroke-width",1);G.select(".outline").attr("transform","scale("+B/500+", "+D/500+")").style("stroke",function(ya){return"offset"===p?"white":aa(A(ya))}).style("fill-opacity",function(){return"offset"===p?1:0}).style("fill",function(ya){return aa(A(ya))});w=w.append("g").attr("class","hover").style("fill",
function(ya){return aa(A(ya))});var va=C.select(".hover");w.append("circle").attr("r",2);w.append("text").style("display","none").attr("dx",4);w=y.select(".x-axis-hover").selectAll(".label").data(["x"]);C=w.enter().append("g").attr("class","label");var xa=w.merge(C);C.append("rect").attr("x",-20).attr("y",6).attr("width",40).attr("height",14);C.append("line").attr("x1",0).attr("x2",0).attr("y1",0).attr("y2",6);C.append("text").attr("dy",18);w=y.select(".y-axis-hover").selectAll(".label").data(["y"]);
C=w.enter().append("g").attr("class","label");var Aa=w.merge(C);C.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14);C.append("line").attr("x1",0).attr("x2",6).attr("y1",0).attr("y2",0);C.append("text").attr("dx",8).attr("dy",4);y=y.select(".y-slice-axis-hover").selectAll(".label").data(["y"]);w=y.enter().append("g").attr("class","label");var Fa=y.merge(w);w.append("rect").attr("x",8).attr("y",-6).attr("width",40).attr("height",14);w.append("line").attr("x1",0).attr("x2",6).attr("y1",
0).attr("y2",0);w.append("text").attr("dx",8).attr("dy",4);b.select(".y.axis.slice").style("opacity","offset"===p?0:1).attr("transform","translate(0, "+("offset"===p?-D:0)+")").call(Z);b.select(".x.axis").attr("transform","translate(0, "+I+")").call(m);b.select(".y.axis").style("opacity","offset"===p?1:0).attr("transform","translate("+B+", "+("offset"===p?0:I)+")").call(la);b.selectAll(".tick text").attr("fill","#aaa");b.selectAll(".axis path.domain").attr("stroke","none")}}});

//# sourceURL=build://tf-histogram-dashboard/histogramCore.js
var Kk;
(function(b){function d(h){const [k,t,l]=h;return{wall_time:k,step:t,min:d3.min(l.map(([p])=>p)),max:d3.max(l.map(([,p])=>p)),buckets:l.map(([p,m,n])=>({left:p,right:m,count:n}))}}function f(h,k,t,l=30){t===k&&(t=1.1*k+1,k=k/1.1-1);const p=(t-k)/l;let m=0;return d3.range(k,t,p).map(n=>{const q=n+p;let u=0;for(;m<h.buckets.length;){const A=Math.min(t,h.buckets[m].right);var x=Math.max(k,h.buckets[m].left);const y=Math.min(A,q)-Math.max(x,n);x=y/(A-x)*h.buckets[m].count;u+=0<y?x:0;if(A>q)break;m++}return{x:n,
dx:p,y:u}})}b.backendToIntermediate=d;b.intermediateToD3=f;b.backendToVz=function(h){h=h.map(d);const k=d3.min(h,l=>l.min),t=d3.max(h,l=>l.max);return h.map(l=>({wall_time:l.wall_time,step:l.step,bins:f(l,k,t)}))}})(Kk||(Kk={}));

//# sourceURL=build://tf-histogram-dashboard/tf-histogram-loader.html.js
Polymer({is:"tf-histogram-loader",properties:{run:String,tag:String,dataToLoad:{type:Array,computed:"_computeDataToLoad(run, tag)"},getDataLoadName:{type:Function,value:()=>({run:b})=>b},getDataLoadUrl:{type:Function,value:()=>({tag:b,run:d})=>vc.addParams(vc.getRouter().pluginRoute("histograms","/histograms"),{tag:b,run:d})},loadDataCallback:{type:Function,value:function(){return(b,d,f)=>{b=Kk.backendToVz(f);d=this.getDataLoadName(d);this.$.chart.setSeriesData(d,b)}}},tagMetadata:Object,timeProperty:String,
histogramMode:String,_colorScaleFunction:{type:Object,value:()=>pf.runsColorScale},_runColor:{type:String,computed:"_computeRunColor(run)"},_expanded:{type:Boolean,value:!1,reflectToAttribute:!0}},observers:["reload(run, tag, requestManager)"],behaviors:[qd.DataLoaderBehavior],_computeDataToLoad(b,d){return[{run:b,tag:d}]},_computeRunColor(b){return this._colorScaleFunction(b)},redraw(){this.$.chart.redraw()},_toggleExpanded(){this.set("_expanded",!this._expanded);this.redraw()}});

//# sourceURL=build://tf-histogram-dashboard/tf-histogram-dashboard.html.js
Polymer({is:"tf-histogram-dashboard",properties:{_histogramMode:{type:String,value:"offset"},_timeProperty:{type:String,value:"step"},_selectedRuns:Array,_runToTag:Object,_runToTagInfo:Object,_dataNotFound:Boolean,_tagFilter:String,_restamp:{type:Boolean,value:!1},_categoriesDomReady:Boolean,_categories:{type:Array,computed:"_makeCategories(_runToTag, _selectedRuns, _tagFilter, _categoriesDomReady)"},_requestManager:{type:Object,value:()=>new vc.RequestManager}},listeners:{"content-visibility-changed":"_redrawCategoryPane"},
_redrawCategoryPane(b,d){d&&b.target.querySelectorAll("tf-histogram-loader").forEach(f=>f.redraw())},ready(){this.reload()},reload(){this._fetchTags().then(()=>{this._reloadHistograms()})},_fetchTags(){const b=vc.getRouter().pluginRoute("histograms","/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,this._runToTagInfo)){var f=_.mapValues(d,k=>Object.keys(k)),h=vc.getTags(f);this.set("_dataNotFound",0===h.length);this.set("_runToTag",f);this.set("_runToTagInfo",d);this.async(()=>
{this.set("_categoriesDomReady",!0)})}})},_reloadHistograms(){this.root.querySelectorAll("tf-histogram-loader").forEach(b=>{b.reload()})},_shouldOpen(b){return 2>=b},_makeCategories(b,d,f){return $c.categorizeRunTagCombinations(b,d,f)},_tagMetadata(b,d,f){return b[d][f]}});

//# sourceURL=build://tf-text-dashboard/tf-text-loader.html.js
Polymer({is:"tf-text-loader",properties:{run:String,tag:String,_runColor:{type:String,computed:"_computeRunColor(run)"},_texts:{type:Array,value:[]},requestManager:Object,_canceller:{type:Object,value:()=>new vc.Canceller}},_computeRunColor(b){return pf.runsColorScale(b)},attached(){this._attached=!0;this.reload()},reload(){if(this._attached){this._canceller.cancelAll();var b=vc.addParams(vc.getRouter().pluginRoute("text","/text"),{tag:this.tag,run:this.run}),d=this._canceller.cancellable(f=>{f.cancelled||
(f=f.value.map(h=>({wall_time:new Date(1E3*h.wall_time),step:h.step,text:h.text})),this.set("_texts",f.slice().reverse()))});this.requestManager.request(b).then(d)}},_formatStep(b){return d3.format(",")(b)}});

//# sourceURL=build://tf-text-dashboard/tf-text-dashboard.html.js
Polymer({is:"tf-text-dashboard",properties:{_selectedRuns:Array,_runToTag:Object,_dataNotFound:Boolean,_tagFilter:String,_categoriesDomReady:Boolean,_categories:{type:Array,computed:"_makeCategories(_runToTag, _selectedRuns, _tagFilter, _categoriesDomReady)"},_requestManager:{type:Object,value:()=>new vc.RequestManager}},ready(){this.reload()},reload(){this._fetchTags().then(()=>{this._reloadTexts()})},_shouldOpen(b){return 2>=b},_fetchTags(){const b=vc.getRouter().pluginRoute("text","/tags");return this._requestManager.request(b).then(d=>
{if(!_.isEqual(d,this._runToTag)){var f=vc.getTags(d);this.set("_dataNotFound",0===f.length);this.set("_runToTag",d);this.async(()=>{this.set("_categoriesDomReady",!0)})}})},_reloadTexts(){this.root.querySelectorAll("tf-text-loader").forEach(b=>{b.reload()})},_makeCategories(b,d,f){return $c.categorizeRunTagCombinations(b,d,f)}});

//# sourceURL=build://tf-pr-curve-dashboard/tf-pr-curve-card.html.js
Polymer({is:"tf-pr-curve-card",properties:{runs:Array,tag:String,tagMetadata:Object,runToStepCap:Object,requestManager:Object,active:Boolean,_expanded:{type:Boolean,value:!1,reflectToAttribute:!0},_runToPrCurveEntry:{type:Object,value:()=>({})},_previousRunToPrCurveEntry:{type:Object,value:()=>({})},_runsWithStepAvailable:{type:Array,computed:"_computeRunsWithStepAvailable(runs, _runToPrCurveEntry)"},_setOfRelevantRuns:{type:Object,computed:"_computeSetOfRelevantRuns(_runsWithStepAvailable)"},_runToDataOverTime:Object,
_colorScaleFunction:{type:Object,value:()=>({scale:pf.runsColorScale})},_canceller:{type:Object,value:()=>new vc.Canceller},_attached:Boolean,_xComponentsCreationMethod:{type:Object,readOnly:!0,value:()=>()=>{const b=new Plottable.Scales.Linear;return{scale:b,axis:new Plottable.Axes.Numeric(b,"bottom"),accessor:d=>d.recall}}},_yValueAccessor:{type:Object,readOnly:!0,value:()=>b=>b.precision},_tooltipColumns:{type:Array,readOnly:!0,value:()=>{const b=rg.multiscaleFormatter(rg.Y_TOOLTIP_FORMATTER_PRECISION),
d=f=>isNaN(f)?"NaN":b(f);return[{title:"Run",evaluate:f=>f.dataset.metadata().name},{title:"Threshold",evaluate:f=>d(f.datum.thresholds)},{title:"Precision",evaluate:f=>d(f.datum.precision)},{title:"Recall",evaluate:f=>d(f.datum.recall)},{title:"TP",evaluate:f=>f.datum.true_positives},{title:"FP",evaluate:f=>f.datum.false_positives},{title:"TN",evaluate:f=>f.datum.true_negatives},{title:"FN",evaluate:f=>f.datum.false_negatives}]}},_seriesDataFields:{type:Array,value:"thresholds precision recall true_positives false_positives true_negatives false_negatives".split(" "),
readOnly:!0},_defaultXRange:{type:Array,value:[-.05,1.05],readOnly:!0},_defaultYRange:{type:Array,value:[-.05,1.05],readOnly:!0},_dataUrl:{type:Function,value:function(){return b=>{const d=this.tag;return vc.addParams(vc.getRouter().pluginRoute("pr_curves","/pr_curves"),{tag:d,run:b})}}},_smoothingEnabled:{type:Boolean,value:!1,readOnly:!0}},observers:["reload(runs, tag)","_setChartData(_runToPrCurveEntry, _previousRunToPrCurveEntry, _setOfRelevantRuns)","_updateRunToPrCurveEntry(_runToDataOverTime, runToStepCap)"],
_createProcessDataFunction(){return(b,d,f)=>{this.set("_runToDataOverTime",Object.assign({},this._runToDataOverTime,f))}},_computeRunColor(b){return this._colorScaleFunction.scale(b)},attached(){this._attached=!0;this.reload()},reload(){this._attached&&(0===this.runs.length?this.set("_runToDataOverTime",{}):this.$$("tf-line-chart-data-loader").reload())},_setChartData(b,d,f){_.forOwn(b,(h,k)=>{const t=d[k];t&&b[k].step===t.step||(f[k]?this._updateSeriesDataForRun(k,h):this._clearSeriesData(k))})},
_updateSeriesDataForRun(b,d){const f=_.reduce(this._seriesDataFields,(k,t)=>{k[t]=d[t].slice().reverse();return k},{}),h=Array(f[this._seriesDataFields[0]].length);for(let k=0;k<h.length;k++)h[k]=_.mapValues(f,t=>t[k]);this.$$("tf-line-chart-data-loader").setSeriesData(b,h)},_clearSeriesData(b){this.$$("tf-line-chart-data-loader").setSeriesData(b,[])},_updateRunToPrCurveEntry(b,d){const f={};_.forOwn(b,(h,k)=>{h&&h.length&&(f[k]=this._computeEntryClosestOrEqualToStepCap(d[k],h))});this.set("_previousRunToPrCurveEntry",
this._runToPrCurveEntry);this.set("_runToPrCurveEntry",f)},_computeEntryClosestOrEqualToStepCap(b,d){b=Math.min(_.sortedIndex(d.map(f=>f.step),b),d.length-1);return d[b]},_computeRunsWithStepAvailable(b,d){return _.filter(b,f=>d[f]).sort()},_computeSetOfRelevantRuns(b){const d={};_.forEach(b,f=>{d[f]=!0});return d},_computeCurrentStepForRun(b,d){return(b=b[d])?b.step:null},_computeCurrentWallTimeForRun(b,d){return(b=b[d])?(new Date(1E3*b.wall_time)).toString():null},_toggleExpanded(){this.set("_expanded",
!this._expanded);this.redraw()},_resetDomain(){this.$$("tf-line-chart-data-loader").resetDomain()},redraw(){this.$$("tf-line-chart-data-loader").redraw()}});

//# sourceURL=build://tf-pr-curve-dashboard/tf-pr-curve-steps-selector.html.js
Polymer({is:"tf-pr-curve-steps-selector",properties:{runs:Array,runToAvailableTimeEntries:Object,runToStep:{type:Object,notify:!0,computed:"_computeRunToStep(runToAvailableTimeEntries, _runToStepIndex)"},timeDisplayType:String,_runToStepIndex:{type:Object,value:()=>({})},_runsWithSliders:{type:Array,computed:"_computeRunsWithSliders(runs, runToAvailableTimeEntries)"}},observers:["_updateStepsForNewRuns(runToAvailableTimeEntries)"],_computeColorForRun(b){return pf.runsColorScale(b)},_computeTimeTextForRun(b,
d,f,h){d=d[f];if(!_.isNumber(d))return"";b=b[f];if(!b)return"";b=b[d][h];if("step"===h)return`step ${b}`;if("relative"===h)return 1>b?`${(1E3*b).toFixed(2)} ms`:`${b.toFixed(2)} s`;if("wall_time"===h)return(new Date(1E3*b)).toString();throw Error(`The display type of ${h} is not recognized.`);},_sliderValueChanged(b){const d=b.target.dataset.run,f=b.target.immediateValue,h=Object.assign({},this._runToStepIndex);isNaN(f)?delete h[d]:h[d]=b.target.immediateValue;this._runToStepIndex=h},_computeMaxStepIndexForRun(b,
d){return(b=b[d])&&b.length?b.length-1:0},_updateStepsForNewRuns(b){const d=Object.assign({},this._runToStepIndex);_.forOwn(b,(f,h)=>{_.isNumber(d[h])||(d[h]=f.length-1)});this._runToStepIndex=d},_getStep(b,d){return this._runToStepIndex?this._runToStepIndex[d]:0},_computeRunToStep(b,d){const f={};_.forOwn(d,(h,k)=>{const t=b[k];t&&(f[k]=t[h].step)});return f},_computeRunsWithSliders(b,d){return b.filter(f=>d[f])}});

//# sourceURL=build://tf-pr-curve-dashboard/tf-pr-curve-dashboard.html.js
Polymer({is:"tf-pr-curve-dashboard",properties:{_timeDisplayType:{type:String,value:"step"},_selectedRuns:{type:Array,value:()=>[]},_runToTagInfo:{type:Object,value:()=>({})},_runToAvailableTimeEntries:{type:Object,value:{}},_relevantSelectedRuns:{type:Array,computed:"_computeRelevantSelectedRuns(_selectedRuns, _runToTagInfo)"},_runsWithPrCurveData:Array,_runToStep:{type:Object,notify:!0},_dataNotFound:Boolean,_tagFilter:String,_categoriesDomReady:Boolean,_categories:{type:Array,computed:"_makeCategories(_runToTagInfo, _selectedRuns, _tagFilter, _categoriesDomReady)"},
_getCategoryItemKey:{type:Function,value:()=>b=>b.tag},_requestManager:{type:Object,value:()=>new vc.RequestManager},_step:{type:Number,value:0,notify:!0}},ready(){this.reload()},reload(){Promise.all([this._fetchTags(),this._fetchTimeEntriesPerRun()]).then(()=>{this._reloadCards()})},_shouldOpen(b){return 2>=b},_fetchTags(){const b=vc.getRouter().pluginRoute("pr_curves","/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,this._runToTagInfo)){var f=_.mapValues(d,h=>_.keys(h));
f=vc.getTags(f);this.set("_dataNotFound",0===f.length);this.set("_runToTagInfo",d);this.async(()=>{this.set("_categoriesDomReady",!0)})}})},_fetchTimeEntriesPerRun(){const b=vc.getRouter().pluginRoute("pr_curves","/available_time_entries");return this._requestManager.request(b).then(d=>{_.forOwn(d,f=>{_.forEach(f,h=>{h.relative=h.wall_time-f[0].wall_time})});this.set("_runToAvailableTimeEntries",d);d=_.keys(d).slice().sort();_.isEqual(d,this._runsWithPrCurveData)||this.set("_runsWithPrCurveData",
d)})},_reloadCards(){_.forEach(this.root.querySelectorAll("tf-pr-curve-card"),b=>{b.reload()})},_makeCategories(b,d,f){b=_.mapValues(b,h=>Object.keys(h));return $c.categorizeTags(b,d,f)},_computeColorForRun(b){return pf.runsColorScale(b)},_computeRelevantSelectedRuns(b,d){return b.filter(f=>d[f])},_tagMetadata(b,d,f){const h={};d.forEach(k=>{h[k]=b[k][f]});d=f.replace(/\/pr_curves$/,"");return rf.aggregateTagInfo(h,d)}});

//# sourceURL=build://tf-profile-redirect-dashboard/tf-profile-redirect-dashboard.html.js
(function(){Polymer({is:"tf-profile-redirect-dashboard",properties:{_installCommand:{type:String,readOnly:!0,value:"pip install -U tensorboard_plugin_profile"}},_copyInstallCommand(){const b=this;return hc(function*(){const d=()=>hc(function*(){b.$.commandTextarea.select();try{yield navigator.clipboard.writeText(b._installCommand)}catch(f){if(!document.execCommand("copy"))return Promise.reject()}});try{yield d(),b.$.copiedMessage.innerText="Copied."}catch(f){b.$.copiedMessage.innerText="Failed to copy to clipboard."}})},
_removeCopiedMessage(){this.$.copiedMessage.innerText=""}})})();

//# sourceURL=build://tf-tensorboard/plugin-dialog.html.js
Polymer({is:"tf-plugin-dialog",properties:{_title:{type:String,value:null},_customMessage:{type:String,value:null},_open:{type:Boolean},_hidden:{type:Boolean,computed:"_computeHidden(_open)",reflectToAttribute:!0},_useNativeBackdrop:{type:Boolean,value:!1,readOnly:!0}},openNoTensorFlowDialog(){this.openDialog("This plugin is disabled without TensorFlow",'To enable this plugin in TensorBoard, install TensorFlow with "pip install tensorflow" or equivalent.')},openOldTensorFlowDialog(b){this.openDialog("This plugin is disabled without TensorFlow "+
b,"To enable this plugin in TensorBoard, install TensorFlow "+b+' or greater with "pip install tensorflow" or equivalent.')},openDialog(b,d){this.set("_title",b);this.set("_customMessage",d);this.$.dialog.open()},closeDialog(){this.$.dialog.close()},_computeHidden(b){return!b}});

//# sourceURL=build://tf-beholder-dashboard/tf-beholder-video.html.js
(function(){const b=vc.getRouter().pluginRoute("beholder","/beholder-frame"),d=vc.getRouter().pluginRoute("beholder","/ping");Polymer({is:"tf-beholder-video",properties:{fps:{type:Number,value:10,observer:"_fpsChanged"},pingSleep:{type:Number,value:1E3},xhrTimeout:{type:Number,value:2500},_imageURL:{type:String,value:"data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs\x3d"},_xhr:Object,_timer:Number,_isDead:Boolean},attached(){this.set("_imageURL",b);this._ping()},detached(){this._clear();
this.set("_imageURL","data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs\x3d")},_ping(){this._clear();this._xhr=new XMLHttpRequest;this._xhr.open("GET",d,!0);this._xhr.timeout=this.xhrTimeout;this._xhr.onload=this._onPingLoad.bind(this);this._xhr.onerror=this._onPing.bind(this,!1,this.pingSleep);this._xhr.ontimeout=this._onPing.bind(this,!1,1);this._xhr.send(null)},_onPingLoad(){if(200==this._xhr.status){const f=JSON.parse(this._xhr.responseText);this._onPing("alive"==f.status,this.pingSleep)}else this._onPing(!1,
this.pingSleep)},_onPing(f,h){f&&this._isDead&&this.set("_imageURL",b+"?t\x3d"+(new Date).getTime());this._isDead=!f;this._timer=window.setTimeout(()=>this._ping(),h)},_clear(){this._timer&&(window.clearTimeout(this._timer),this._timer=null);this._xhr&&(this._xhr.readyState<XMLHttpRequest.DONE&&this._xhr.abort(),this._xhr=null)},_fpsChanged(f,h){0==f?this._clear():0==h&&this._ping()}})})();

//# sourceURL=build://tf-beholder-dashboard/tf-beholder-info.html.js
(function(){const b=vc.getRouter().pluginRoute("beholder","/section-info");Polymer({is:"tf-beholder-info",properties:{fps:{type:Number,value:10,observer:"_fpsChanged"},xhrTimeout:{type:Number,value:1E4},_items:{type:Array,value:()=>[{name:"Loading..."}]},_xhr:Object,_timer:Number},attached(){this._load()},detached(){this._clear()},_load(){this._clear();this._xhr=new XMLHttpRequest;this._xhr.open("GET",b,!0);this._xhr.timeout=this.xhrTimeout;this._xhr.onload=this._onLoad.bind(this);this._xhr.onerror=
this._retry.bind(this,this._getSleep());this._xhr.ontimeout=this._retry.bind(this,1);this._xhr.send(null)},_onLoad(){if(200==this._xhr.status){const d=JSON.parse(this._xhr.responseText);console.assert(Array.isArray(d),"Expected response to be in an array");this._items=d}this._retry(this._getSleep())},_retry(d){this._timer=window.setTimeout(this._load.bind(this),d)},_getSleep(){return 1E3/(0===this.fps?1:this.fps)},_clear(){this._timer&&(window.clearTimeout(this._timer),this._timer=null);this._xhr&&
(this._xhr.readyState<XMLHttpRequest.DONE&&this._xhr.abort(),this._xhr=null)},_fpsChanged(d,f){0==d?this._clear():0==f&&this._load()}})})();

//# sourceURL=build://tf-beholder-dashboard/tf-beholder-dashboard.html.js
(function(){Polymer({is:"tf-beholder-dashboard",properties:{_requestManager:{type:Object,value:()=>new vc.RequestManager(10,0)},_isAvailable:Boolean,_values:{type:String,value:"trainable_variables",observer:"_configChanged"},_mode:{type:String,value:"variance",observer:"_configChanged"},_scaling:{type:String,value:"layer",observer:"_configChanged"},_windowSize:{type:Number,value:15,observer:"_configChanged"},_previousFPS:{type:Number,value:30},_FPS:{type:Number,value:10,observer:"_configChanged"},
_recordText:{type:String,value:"start recording"},_isRecording:{type:Boolean,value:!1,observer:"_configChanged"},_showAll:{type:Boolean,value:!1,observer:"_configChanged"},_colormap:{type:String,value:"magma",observer:"_configChanged"},_is_active:{type:Boolean,value:!1,observer:"_configChanged"},_controls_disabled:{type:Boolean,value:!1,observer:"_configChanged"}},_valuesNotFrame(b){return"frames"!==b},_varianceSelected(b){return"variance"===b},_configChanged(){if(this._is_active&&!this._controls_disabled){var b=
[this._values,this._mode,this._scaling,this._windowSize,this._FPS,this._isRecording,this._showAll,this._colormap],d;for(d of b)if("undefined"===typeof d||""===d)return;b=vc.getRouter().pluginRoute("beholder","/change-config");this._requestManager.request(b,{values:this._values,mode:this._mode,scaling:this._scaling,window_size:this._windowSize,FPS:this._FPS,is_recording:this._isRecording,show_all:this._showAll,colormap:this._colormap})}},_toggleRecord(){"start recording"==this._recordText?(this.set("_recordText",
"stop recording"),this.set("_isRecording",!0)):(this.set("_recordText","start recording"),this.set("_isRecording",!1));this.$.record_button.classList.toggle("is-recording")},attached:function(){this._requestManager.request(vc.getRouter().pluginsListing()).then(b=>{"beholder"in b?(this.$.initialDialog.closeDialog(),this.set("_isAvailable",!0)):(this.$.initialDialog.openNoTensorFlowDialog(),this.set("_isAvailable",!1))})},ready(){this.reload()},reload(){if(this._isAvailable){const b=vc.getRouter().pluginRoute("beholder",
"/is-active");this._requestManager.request(b).then(d=>{this.set("_is_active",d.is_active);this.set("_controls_disabled",!d.is_config_writable)})}}});qf.registerDashboard()})();

//# sourceURL=build://tf-hparams-utils/tf-hparams-utils.html.js
(function(b){(function(d){(function(f){function h(B){return""!==B.displayName&&void 0!==B.displayName?B.displayName:B.name}function k(B){if(""!==B.displayName&&void 0!==B.displayName)return B.displayName;let I=B.name.group;B=B.name.tag;void 0===I&&(I="");void 0===B&&(B="");return""===I?B:I+"."+B}function t(B){return B.hparamColumns.length}function l(B){return B.metricColumns.length}function p(B,I){return B[I]}function m(B,I){return B.find(N=>_.isEqual(N.name,I))}function n(B,I,N){return I.hparams[B.hparamColumns[N].hparamInfo.name]}
function q(B,I,N){B=m(I.metricValues,B.metricColumns[N].metricInfo.name);return void 0===B?void 0:B.value}function u(B,I,N){return N<B.hparamColumns.length?n(B,I,N):q(B,I,N-B.hparamColumns.length)}function x(B){return B.hparamInfos.length}function A(B){return B.metricInfos.length}function y(B,I,N){return I.hparams[B.hparamInfos[N].name]}function w(B,I,N){B=m(I.metricValues,B.metricInfos[N].name);return void 0===B?void 0:B.value}function C(B,I,N){return N<B.hparamInfos.length?y(B,I,N):w(B,I,N-B.hparamInfos.length)}
function G(B){return _.isNumber(B)?B.toPrecision(5):void 0===B?"":B.toString()}function D(B,I){return B*B+I*I}f.hparamName=h;f.metricName=k;f.schemaColumnName=function(B,I){return I<B.hparamColumns.length?h(B.hparamColumns[I].hparamInfo):k(B.metricColumns[I-B.hparamColumns.length].metricInfo)};f.numHParams=t;f.numMetrics=l;f.numColumns=function(B){return t(B)+l(B)};f.hparamValueByName=p;f.metricValueByName=m;f.hparamValueByIndex=n;f.metricValueByIndex=q;f.columnValueByIndex=u;f.numericColumnExtent=
function(B,I,N){return d3.extent(I,O=>u(B,O,N))};f.getAbsoluteColumnIndex=function(B,I,N){if(N<I.hparamInfos.length)B=B.hparamColumns.findIndex(O=>O.hparamInfo.name===I.hparamInfos[N].name);else{const O=I.metricInfos[N-I.hparamInfos.length].name;B=B.hparamColumns.length+B.metricColumns.findIndex(H=>H.metricInfo.name===O)}console.assert(-1!==B);return B};f.schemaVisibleColumnName=function(B,I){return I<B.hparamInfos.length?h(B.hparamInfos[I]):k(B.metricInfos[I-B.hparamInfos.length])};f.numVisibleHParams=
x;f.numVisibleMetrics=A;f.numVisibleColumns=function(B){return x(B)+A(B)};f.visibleNumericColumnExtent=function(B,I,N){return d3.extent(I,O=>C(B,O,N))};f.prettyPrintHParamValueByName=function(B,I){return G(p(B,I))};f.prettyPrintMetricValueByName=function(B,I){return G(m(B,I))};f.sessionGroupWithName=function(B,I){return B.find(N=>N.name===I)};f.hparamValueByVisibleIndex=y;f.metricValueByVisibleIndex=w;f.columnValueByVisibleIndex=C;f.prettyPrint=G;f.l2NormSquared=D;f.euclideanDist=function(B,I,N,O){return Math.sqrt(D(B-
N,I-O))};f.pointToRectangleDist=function(B,I,N,O,H,K){if(B<N&&I<O)return f.euclideanDist(B,I,N,O);if(N<=B&&B<H&&I<O)return O-I;if(H<=B&&I<O)return f.euclideanDist(B,I,H,O);if(B<N&&O<=I&&I<K)return N-B;if(N<=B&&B<H&&O<=I&&I<K)return 0;if(H<=B&&O<=I&&I<K)return B-H;if(B<N&&K<=I)return f.euclideanDist(B,I,N,K);if(N<=B&&B<H&&K<=I)return I-K;if(H<=B&&K<=I)return f.euclideanDist(B,I,H,K);throw"Point (x,y) must be in one of the regions defined above.";};f.translateStr=function(B,I){return void 0===I?"translate("+
B+")":"translate("+B+","+I+")"};f.rotateStr=function(B,I){let N="rotate(90";void 0!==B&&void 0!==I&&(N=N+","+B+","+I);return N+")"};f.isNullOrUndefined=function(B){return null===B||void 0===B};f.quadTreeVisitPointsInRect=function(B,I,N,O,H,K){B.visit((M,L,Q,T,X)=>{if(void 0===M.length){do L=B.x()(M.data),Q=B.y()(M.data),I<=L&&L<O&&N<=Q&&Q<H&&K(M.data);while(M=M.next);return!0}return L>=O||T<=I||Q>=H||X<=N})};f.quadTreeVisitPointsInDisk=function(B,I,N,O,H){B.visit((K,M,L,Q,T)=>{if(void 0===K.length){do M=
B.x()(K.data),L=B.y()(K.data),M=f.euclideanDist(I,N,M,L),M<=O&&H(K.data,M);while(K=K.next);return!0}return f.pointToRectangleDist(I,N,M,L,Q,T)>O})};f.filterSet=function(B,I){const N=new Set;B.forEach(O=>{I(O)&&N.add(O)});return N};f.setArrayObservably=function(B,I){const N=B.get("sessionGroups",B);Array.isArray(N)?B.splice.apply(B,["sessionGroups",0,N.length].concat(I)):B.set("sessionGroups",I)};f.hashOfString=function(B){let I=0;for(let N=0;N<B.length;++N)I=31*I+B.charCodeAt(N)&4294967295;return I+
Math.pow(2,31)}})(d.utils||(d.utils={}))})(b.hparams||(b.hparams={}))})(tf||(tf={}));

//# sourceURL=build://vaadin-split-layout/vaadin-split-layout.html.js
Polymer({is:"vaadin-split-layout",behaviors:[Polymer.IronResizableBehavior],properties:{vertical:{type:Boolean,reflectToAttribute:!0,value:!1},_previousPrimaryPointerEvents:String,_previousSecondaryPointerEvents:String},attached:function(){this._observer=Polymer.dom(this).observeNodes(this._processChildren)},detached:function(){Polymer.dom(this).unobserveNodes(this._observer)},_processChildren:function(){this.getEffectiveChildren().filter(function(b){return b.classList.contains("splitter-handle")?
(Polymer.dom(b).setAttribute("slot","handle"),!1):!0}).forEach(function(b,d){0===d?(this._primaryChild=b,Polymer.dom(b).setAttribute("slot","primary")):1==d?(this._secondaryChild=b,Polymer.dom(b).setAttribute("slot","secondary")):Polymer.dom(b).removeAttribute("slot")}.bind(this))},_setFlexBasis:function(b,d,f){d=Math.max(0,Math.min(d,f));0===d&&(d=1E-6);b.style.flex="1 1 "+d+"px"},_onHandleTrack:function(b){if(this._primaryChild&&this._secondaryChild){var d=this.vertical?"height":"width";"start"===
b.detail.state?(this._startSize={container:this.getBoundingClientRect()[d]-this.$.splitter.getBoundingClientRect()[d],primary:this._primaryChild.getBoundingClientRect()[d],secondary:this._secondaryChild.getBoundingClientRect()[d]},this._previousPrimaryPointerEvents=this._primaryChild.style.pointerEvents,this._previousSecondaryPointerEvents=this._secondaryChild.style.pointerEvents,this._primaryChild.style.pointerEvents="none",this._secondaryChild.style.pointerEvents="none"):(d=this.vertical?b.detail.dy:
b.detail.dx,this._setFlexBasis(this._primaryChild,this._startSize.primary+d,this._startSize.container),this._setFlexBasis(this._secondaryChild,this._startSize.secondary-d,this._startSize.container),this.notifyResize(),"end"===b.detail.state&&(delete this._startSize,this._primaryChild.style.pointerEvents=this._previousPrimaryPointerEvents,this._secondaryChild.style.pointerEvents=this._previousSecondaryPointerEvents))}},_preventDefault:function(b){b.preventDefault()}});

//# sourceURL=build://tf-hparams-query-pane/tf-hparams-query-pane.html.js
Polymer({is:"tf-hparams-query-pane",properties:{backend:Object,experimentName:String,configuration:{type:Object,value:()=>({schema:{hparamColumns:[],metricColumns:[]},columnsVisibility:[],visibleSchema:{hparamInfos:[],metricInfos:[]}}),readOnly:!0,notify:!0},sessionGroups:{type:Array,value:()=>[],readOnly:!0,notify:!0},_experiment:Object,_hparams:Array,_metrics:Array,_statuses:{type:Array,value:()=>[{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}]},_getExperimentResolved:{type:Object,value:function(){return new Promise(b=>{this._resolveGetExperiment=b})}},_resolveGetExperiment:Function,_listSessionGroupsCanceller:{type:Object,value:()=>new vc.Canceller},_sortByIndex:Number,_sortDirection:Number,_pageSizeInput:{type:Object,value:{value:"100",invalid:!1}},_pageNumberInput:{type:Object,value:{value:"1",invalid:!1}},
_pageCountStr:{type:String,value:"?"},_totalSessionGroupsCountStr:String,_sessionGroupsRequest:Object},observers:["_computeExperimentAndRelatedProps(backend, experimentName)","_updateConfiguration(_hparams.*, _metrics.*)"],reload(){this._queryServer()},_csvUrl(b,d){return this._downloadDataUrl(b,d,"csv")},_jsonUrl(b,d){return this._downloadDataUrl(b,d,"json")},_latexUrl(b,d){return this._downloadDataUrl(b,d,"latex")},_downloadDataUrl(b,d,f){return this.backend.getDownloadUrl(f,b,d.columnsVisibility)},
_computeExperimentAndRelatedProps(){const b=tf.hparams.utils;b.isNullOrUndefined(this.backend)||b.isNullOrUndefined(this.experimentName)||this.backend.getExperiment({experimentName:this.experimentName}).then(d=>{_.isEqual(d,this._experiment)||(this.set("_experiment",d),this._computeHParams(),this._computeMetrics(),this._queryServer(),this._resolveGetExperiment())})},_computeHParams(){const b=[];this._experiment.hparamInfos.forEach((d,f)=>{const h={info:d,displayed:5>f,filter:{}};h.info.hasOwnProperty("domainDiscrete")?
(h.filter.domainDiscrete=[],h.info.domainDiscrete.forEach(k=>{h.filter.domainDiscrete.push({value:k,checked:!0})})):"DATA_TYPE_BOOL"===h.info.type?h.filter.domainDiscrete=[{value:!1,checked:!0},{value:!0,checked:!0}]:"DATA_TYPE_FLOAT64"===h.info.type?h.filter.interval={min:{value:"",invalid:!1},max:{value:"",invalid:!1}}:"DATA_TYPE_STRING"===h.info.type?h.filter.regexp="":console.warn("unknown hparam.info.type: %s",h.info.type);b.push(h)});this.set("_hparams",b)},_computeMetrics(){const b=[];this._experiment.metricInfos.forEach((d,
f)=>{b.push({info:d,filter:{interval:{min:{value:"",invalid:!1},max:{value:"",invalid:!1}}},displayed:5>f})});this.set("_metrics",b)},_computeSchema(){return this._hparams&&this._metrics?{hparamColumns:this._hparams.map(b=>({hparamInfo:b.info})),metricColumns:this._metrics.map(b=>({metricInfo:b.info}))}:{hparamColumns:[],metricColumns:[]}},_updateConfiguration(){this.debounce("_updateConfiguration",()=>{this._setConfiguration({schema:this._computeSchema(),columnsVisibility:this._computeColumnsVisibility(),
visibleSchema:this._computeVisibleSchema()})})},_computeColumnsVisibility(){return this._hparams&&this._metrics?this._hparams.map(b=>b.displayed).concat(this._metrics.map(b=>b.displayed)):[]},_computeVisibleSchema(){if(!this._hparams||!this._metrics)return{hparamInfos:[],metricInfos:[]};const b=this._hparams.filter(f=>f.displayed).map(f=>f.info),d=this._metrics.filter(f=>f.displayed).map(f=>f.info);return{hparamInfos:b,metricInfos:d}},_queryServer(){this.debounce("queryServer",()=>this._queryServerNoDebounce(),
100)},_queryServerNoDebounce(){return this._sendListSessionGroupsRequest().then(this._listSessionGroupsCanceller.cancellable(({value:b,cancelled:d})=>{d||(0<=b.totalSize?(this.set("_pageCountStr",String(Math.ceil(b.totalSize/+this._pageSizeInput.value))),this.set("_totalSessionGroupsCountStr",b.totalSize)):(this.set("_pageCountStr","?"),this.set("_totalSessionGroupsCountStr","Unknown")),tf.hparams.utils.setArrayObservably(this,b.sessionGroups))}))},_sendListSessionGroupsRequest(){const b=this._buildListSessionGroupsRequest();
if(null!==b)return this.set("_sessionGroupsRequest",b),this._listSessionGroupsCanceller.cancelAll(),this.backend.listSessionGroups(b)},_buildListSessionGroupsRequest(){function b(m){var n=f.get(m+".min.value");console.assert(void 0!==n);n=""===n?"-Infinity":+n;f.set(m+".min.invalid",isNaN(n));h=h&&!isNaN(n);var q=f.get(m+".max.value");console.assert(void 0!==q);q=""===q?"Infinity":+q;f.set(m+".max.invalid",isNaN(q));h=h&&!isNaN(q);return isNaN(n)||isNaN(q)?null:{minValue:n,maxValue:q}}function d(m){var n=
f.get(m+".value");console.assert(void 0!==n);n=+n;const q=Number.isInteger(n)&&0<n;f.set(m+".invalid",!q);h=h&&q;return q?n:null}const f=this;let h=!0;const k=this._statuses.filter(m=>m.allowed).map(m=>m.value);let t=[];this._hparams.forEach((m,n)=>{let q={hparam:m.info.name};if(m.filter.domainDiscrete)q.filterDiscrete=[],m.filter.domainDiscrete.forEach(u=>{u.checked&&q.filterDiscrete.push(u.value)});else if(m.filter.interval)q.filterInterval=b("_hparams."+n+".filter.interval");else if(m.filter.regexp)q.filterRegexp=
m.filter.regexp;else return console.error("hparam.filter with no domainDiscrete, interval or regexp properties set: %s",m),null;t.push(q)});this._metrics.forEach((m,n)=>{m={metric:m.info.name,filterInterval:b("_metrics."+n+".filter.interval")};t.push(m)});if(void 0!==this._sortByIndex&&void 0!==this._sortDirection){if(!(this._sortByIndex in t))return console.error("No column in colParams with index sortByIndex: %s",this._sortByIndex),null;t[this._sortByIndex].order=0===this._sortDirection?"ORDER_ASC":
"ORDER_DESC"}const l=d("_pageNumberInput"),p=d("_pageSizeInput");return h?{experimentName:this.experimentName,allowedStatuses:k,colParams:t,startIndex:p*(l-1),sliceSize:p}:null},_metricSortByIndex(b){return b+this._hparams.length},_hparamName:tf.hparams.utils.hparamName,_metricName:tf.hparams.utils.metricName,_prettyPrint:tf.hparams.utils.prettyPrint});

//# sourceURL=build://iron-pages/iron-pages.html.js
Polymer({is:"iron-pages",behaviors:[Polymer.IronResizableBehavior,Polymer.IronSelectableBehavior],properties:{activateEvent:{type:String,value:null}},observers:["_selectedPageChanged(selected)"],_selectedPageChanged:function(){this.async(this.notifyResize)}});

//# sourceURL=build://paper-header-panel/paper-header-panel.html.js
(function(){var b={scroll:!0},d={standard:2,waterfall:1,"waterfall-tall":1},f={"waterfall-tall":!0};Polymer({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 Polymer.dom(this.$.headerSlot).getDistributedNodes()[0]},get scroller(){return this._getScrollerForMode(this.mode)},get visibleShadow(){return this.$.dropShadow.classList.contains("has-shadow")},_computeDropShadowHidden:function(h,k){k=d[k];this.shadow?this.toggleClass("has-shadow",!0,this.$.dropShadow):2===k?this.toggleClass("has-shadow",!0,this.$.dropShadow):
1!==k||h?this.toggleClass("has-shadow",!1,this.$.dropShadow):this.toggleClass("has-shadow",!0,this.$.dropShadow)},_computeMainContainerClass:function(h){var k={};k.flex="cover"!==h;return Object.keys(k).filter(function(t){return k[t]}).join(" ")},_addListener:function(){this.scroller.addEventListener("scroll",this.scrollHandler)},_removeListener:function(){this.scroller.removeEventListener("scroll",this.scrollHandler)},_modeChanged:function(h,k){var t=this.header;t&&(f[k]&&!f[h]?(t.classList.remove(this.tallClass),
this.async(function(){t.classList.remove("animate")},200)):this.toggleClass("animate",f[h],t));this._keepScrollingState()},_keepScrollingState:function(){var h=this.scroller,k=this.header;this._setAtTop(0===h.scrollTop);k&&this.tallClass&&f[this.mode]&&this.toggleClass(this.tallClass,this.atTop||k.classList.contains(this.tallClass)&&h.scrollHeight<this.offsetHeight,k)},_scroll:function(){this._keepScrollingState();this.fire("content-scroll",{target:this.scroller},{bubbles:!1})},_getScrollerForMode:function(h){return b[h]?
this:this.$.mainContainer}})})();

//# sourceURL=build://paper-tabs/paper-tab.html.js
Polymer({is:"paper-tab",behaviors:[Polymer.IronControlState,Polymer.IronButtonState,Polymer.PaperRippleBehavior],properties:{link:{type:Boolean,value:!1,reflectToAttribute:!0}},hostAttributes:{role:"tab"},listeners:{down:"_updateNoink",tap:"_onTap"},attached:function(){this._updateNoink()},get _parentNoink(){var b=Polymer.dom(this).parentNode;return!!b&&!!b.noink},_updateNoink:function(){this.noink=!!this.noink||!!this._parentNoink},_onTap:function(b){if(this.link){var d=this.queryEffectiveChildren("a");
d&&b.target!==d&&d.click()}}});

//# sourceURL=build://paper-tabs/paper-tabs.html.js
Polymer({is:"paper-tabs",behaviors:[Polymer.IronResizableBehavior,Polymer.IronMenubarBehavior],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._pendingActivationTimeout=this._pendingActivationItem=
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(b){Polymer.dom(this).querySelectorAll("paper-tab").forEach(b?this._setNoinkAttribute:this._removeNoinkAttribute)},_setNoinkAttribute:function(b){b.setAttribute("noink","")},_removeNoinkAttribute:function(b){b.removeAttribute("noink")},
_computeScrollButtonClass:function(b,d,f){return!d||f?"hidden":b?"not-visible":""},_computeTabsContentClass:function(b,d){return b?"scrollable"+(d?" fit-container":""):" fit-container"},_computeSelectionBarClass:function(b,d){return b?"hidden":d?"align-bottom":""},_onTabSizingChanged:function(){this.debounce("_onTabSizingChanged",function(){this._scroll();this._tabChanged(this.selectedItem)},10)},_onIronSelect:function(b){this._tabChanged(b.detail.item,this._previousTab);this._previousTab=b.detail.item;
this.cancelDebouncer("tab-changed")},_onIronDeselect:function(){this.debounce("tab-changed",function(){this._tabChanged(null,this._previousTab);this._previousTab=null},1)},_activateHandler:function(){this._cancelPendingActivation();Polymer.IronMenuBehaviorImpl._activateHandler.apply(this,arguments)},_scheduleActivation:function(b,d){this._pendingActivationItem=b;this._pendingActivationTimeout=this.async(this._bindDelayedActivationHandler,d)},_delayedActivationHandler:function(){var b=this._pendingActivationItem;
this._pendingActivationTimeout=this._pendingActivationItem=void 0;b.fire(this.activateEvent,null,{bubbles:!0,cancelable:!0})},_cancelPendingActivation:function(){void 0!==this._pendingActivationTimeout&&(this.cancelAsync(this._pendingActivationTimeout),this._pendingActivationTimeout=this._pendingActivationItem=void 0)},_onArrowKeyup:function(){this.autoselect&&this._scheduleActivation(this.focusedItem,this.autoselectDelay)},_onBlurCapture:function(b){b.target===this._pendingActivationItem&&this._cancelPendingActivation()},
get _tabContainerScrollSize(){return Math.max(0,this.$.tabsContainer.scrollWidth-this.$.tabsContainer.offsetWidth)},_scroll:function(b,d){this.scrollable&&this._affectScroll(d&&-d.ddx||0)},_down:function(){this.async(function(){this._defaultFocusAsync&&(this.cancelAsync(this._defaultFocusAsync),this._defaultFocusAsync=null)},1)},_affectScroll:function(b){this.$.tabsContainer.scrollLeft+=b;b=this.$.tabsContainer.scrollLeft;this._leftHidden=0===b;this._rightHidden=b===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(b,d){if(b){var f=this.$.tabsContent.getBoundingClientRect(),
h=f.width,k=b.getBoundingClientRect();f=k.left-f.left;this._pos={width:this._calcPercent(k.width,h),left:this._calcPercent(f,h)};if(this.noSlide||null==d)this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),this._positionBar(this._pos.width,this._pos.left);else{var t=d.getBoundingClientRect();d=this.items.indexOf(d);b=this.items.indexOf(b);this.$.selectionBar.classList.add("expand");b=d<b;this._isRTL&&(b=!b);b?this._positionBar(this._calcPercent(k.left+k.width-
t.left,h)-5,this._left):this._positionBar(this._calcPercent(t.left+t.width-k.left,h)-5,this._calcPercent(f,h)+5);this.scrollable&&this._scrollToSelectedIfNeeded(k.width,f)}}else this.$.selectionBar.classList.remove("expand"),this.$.selectionBar.classList.remove("contract"),this._positionBar(0,0)},_scrollToSelectedIfNeeded:function(b,d){d-=this.$.tabsContainer.scrollLeft;0>d?this.$.tabsContainer.scrollLeft+=d:(d+=b-this.$.tabsContainer.offsetWidth,0<d&&(this.$.tabsContainer.scrollLeft+=d))},_calcPercent:function(b,
d){return 100*b/d},_positionBar:function(b,d){b=b||0;d=d||0;this._width=b;this._left=d;this.transform("translateX("+d+"%) scaleX("+b/100+")",this.$.selectionBar)},_onBarTransitionEnd:function(){var b=this.$.selectionBar.classList;b.contains("expand")?(b.remove("expand"),b.add("contract"),this._positionBar(this._pos.width,this._pos.left)):b.contains("contract")&&b.remove("contract")}});

//# sourceURL=build://paper-toolbar/paper-toolbar.html.js
Polymer({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(b){var d=new MutationObserver(function(){this._updateAriaLabelledBy()}.bind(this));
d.observe(b,{childList:!0,subtree:!0});return d},_updateAriaLabelledBy:function(){Polymer.dom.flush();for(var b=[],d=Array.prototype.slice.call(Polymer.dom(this.root).querySelectorAll("slot")).concat(Array.prototype.slice.call(Polymer.dom(this.root).querySelectorAll("content"))),f,h=0;f=d[h];h++){f=Polymer.dom(f).getDistributedNodes();for(var k,t=0;k=f[t];t++)if(k.classList&&k.classList.contains("title"))if(k.id)b.push(k.id);else{var l="paper-toolbar-label-"+Math.floor(1E4*Math.random());k.id=l;b.push(l)}}0<
b.length&&this.setAttribute("aria-labelledby",b.join(" "))},_computeBarExtraClasses:function(b){return b?b+("justified"===b?"":"-justified"):""}});

//# sourceURL=build://tf-hparams-scale-and-color-controls/tf-hparams-scale-and-color-controls.html.js
Polymer({is:"tf-hparams-scale-and-color-controls",properties:{configuration:Object,sessionGroups:Array,options:{type:Object,notify:!0,value:null}},observers:["_configurationChanged(configuration.*)","_unselectDisabledLogScales(sessionGroups.*)"],_configurationChanged(){const b=this.configuration.visibleSchema,d=this.configuration.schema,f={columns:b.hparamInfos.map((h,k)=>({name:tf.hparams.utils.hparamName(h),index:k,absoluteIndex:tf.hparams.utils.getAbsoluteColumnIndex(d,b,k),scale:this._isNumericColumn(k)?
"LINEAR":"NON_NUMERIC"})).concat(b.metricInfos.map((h,k)=>{k+=b.hparamInfos.length;return{scale:"LINEAR",name:tf.hparams.utils.metricName(h),index:k,absoluteIndex:tf.hparams.utils.getAbsoluteColumnIndex(d,b,k)}})),minColor:"#0000FF",maxColor:"#FF0000",configuration:this.configuration};this.set("options",f);Polymer.dom.flush();this.set("options.colorByColumnIndex",this._defaultColorByColumnIndex())},_unselectDisabledLogScales(){null!==this.options&&this.options.columns.forEach(b=>{const d="options.columns."+
b.index;this._allowLogScale(b)||"LOG"!==b.scale||this.set(d+".scale","LINEAR")})},_allowLogScale(b){if(!this._isNumericColumn(b.index)||!this.sessionGroups)return!1;const [d,f]=tf.hparams.utils.visibleNumericColumnExtent(this.configuration.visibleSchema,this.sessionGroups,b.index);return 0<d||0>f},_isNumericColumn(b){return b>=this.configuration.visibleSchema.hparamInfos.length||"DATA_TYPE_FLOAT64"===this.configuration.visibleSchema.hparamInfos[b].type},_defaultColorByColumnIndex(){if(0<this.configuration.visibleSchema.metricInfos.length)return this.configuration.visibleSchema.hparamInfos.length;
const b=this.configuration.visibleSchema.hparamInfos.findIndex(d=>"DATA_TYPE_FLOAT64"===d.type);if(-1!==b)return b}});

//# sourceURL=build://vaadin-grid/vaadin-grid-active-item-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.ActiveItemBehavior={properties:{activeItem:{type:Object,notify:!0,value:null}},listeners:{"cell-activate":"_activateItem"},observers:["_activeItemChanged(activeItem)"],_activateItem:function(b){var d=b.detail.model.item;this.activeItem=this.activeItem!==d?d:null;b.stopImmediatePropagation()},_activeItemChanged:function(){this.$.scroller._physicalItems&&this.$.scroller._physicalItems.forEach(function(b){this._updateItem(b,b.item)}.bind(this))}};

//# sourceURL=build://vaadin-grid/vaadin-grid-table-scroll-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.TableScrollBehaviorImpl={properties:{_vidxOffset:{type:Number,value:0},ios:{type:Boolean,value:navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),reflectToAttribute:!0},fixedSections:{type:Boolean,reflectToAttribute:!0,computed:"_hasFixedSections(scrollbarWidth)"},_frozenCells:{type:Array,value:function(){return[]}},scrolling:{type:Boolean,reflectToAttribute:!0}},ready:function(){this.scrollTarget=this.$.table},attached:function(){this.listen(this.scrollTarget,"wheel",
"_onWheel")},detached:function(){this.unlisten(this.scrollTarget,"wheel","_onWheel")},scrollToScaledIndex:function(b){this._pendingScrollToScaledIndex=null;this.$.items.style.borderTopWidth||(this._pendingScrollToScaledIndex=b);b=Math.min(Math.max(b,0),this.size-1);this.$.table.scrollTop=b/this.size*this.$.table.scrollHeight;this._scrollHandler();this.scrollToIndex(b-this._vidxOffset);this._resetScrollPosition(this._scrollPosition);this._scrollHandler();this._vidxOffset+this.lastVisibleIndex===this.size-
1&&(this.$.table.scrollTop=this.$.table.scrollHeight-this.$.table.offsetHeight,this._scrollHandler())},_hasFixedSections:function(b){return navigator.userAgent.match(/Edge/)&&0===b},_onWheel:function(b){if(!b.ctrlKey&&!this._hasScrolledAncestor(b.target,b.deltaX,b.deltaY)){var d=this.$.table,f=b.deltaY;1===b.deltaMode&&(f*=grid.$.scroller._physicalAverage);var h=Math.abs(b.deltaX)+Math.abs(f);this._canScroll(d,b.deltaX,f)?(b.preventDefault(),d.scrollTop+=f,d.scrollLeft+=b.deltaX,this._scrollHandler(),
this._hasResidualMomentum=!0,this._ignoreNewWheel=this.debounce("ignore-new-wheel",function(){this._ignoreNewWheel=null},500)):this._hasResidualMomentum&&h<=this._previousMomentum||this._ignoreNewWheel?b.preventDefault():h>this._previousMomentum&&(this._hasResidualMomentum=!1);this._previousMomentum=h}},_hasScrolledAncestor:function(b,d,f){if(this._canScroll(b,d,f))return!0;if("vaadin-grid-cell-content"!==b.localName&&b!==this&&b.parentElement)return this._hasScrolledAncestor(b.parentElement,d,f)},
_canScroll:function(b,d,f){return 0<f&&b.scrollTop<b.scrollHeight-b.offsetHeight||0>f&&0<b.scrollTop||0<d&&b.scrollLeft<b.scrollWidth-b.offsetWidth||0>d&&0<b.scrollLeft},_scrollHandler:function(){var b=Math.max(0,Math.min(this._maxScrollTop,this._scrollTop)),d=b-this._scrollPosition,f=this._ratio,h=0,k=this._hiddenContentSize,t=f,l=[];this._scrollPosition=b;this._lastVisibleIndexVal=this._firstVisibleIndexVal=null;var p=this._scrollBottom;var m=this._physicalBottom;if(Math.abs(d)>this._physicalSize)this._physicalTop+=
d,h=Math.round(d/this._physicalAverage);else if(0>d){var n=b-this._physicalTop;l=this._virtualStart;var q=[];var u=this._physicalEnd;for(t=n/k;t<f&&h<this._physicalCount&&0<l-h&&m-this._getPhysicalSizeIncrement(u)>p;)n=this._getPhysicalSizeIncrement(u),t+=n/k,m-=n,q.push(u),h++,u=0===u?this._physicalCount-1:u-1;l=q;h=-h}else if(0<d){var x=this._virtualEnd,A=this._virtualCount-1;q=[];u=this._physicalStart;for(t=(m-p)/k;t<f&&h<this._physicalCount&&x+h<A&&this._physicalTop+this._getPhysicalSizeIncrement(u)<
b;)n=this._getPhysicalSizeIncrement(u),t+=n/k,this._physicalTop+=n,q.push(u),h++,u=(u+1)%this._physicalCount}this._virtualCount<this.size&&this._adjustVirtualIndexOffset(d);0===h?(m<p||this._physicalTop>b)&&this._increasePoolIfNeeded():(this._virtualStart+=h,this._physicalStart+=h,this._update(q,l));this._translateStationaryElements();this.hasAttribute("reordering")||(this.scrolling=!0);this.debounce("vaadin-grid-scrolling",function(){this.scrolling=!1;this._reorderRows()},100)},_adjustVirtualIndexOffset:function(b){if(1E4<
Math.abs(b))this._noScale?this._noScale=!1:(b=Math.round(this._scrollPosition/this._scrollHeight*1E3)/1E3,this._vidxOffset=Math.round(b*this.size-b*this._virtualCount),0===this._scrollTop&&this.scrollToIndex(0));else{b=this._vidxOffset||0;0===this._scrollTop?(this._vidxOffset=0,b!==this._vidxOffset&&this.scrollToIndex(0)):1E3>this.firstVisibleIndex&&0<this._vidxOffset&&(this._vidxOffset-=Math.min(this._vidxOffset,100),this.scrollToIndex(this.firstVisibleIndex+(b-this._vidxOffset)+1),this._noScale=
!0);var d=this.size-this._virtualCount;this._scrollTop>=this._maxScrollTop?(this._vidxOffset=d,b!==this._vidxOffset&&this.scrollToIndex(this._virtualCount)):this.firstVisibleIndex>this._virtualCount-1E3&&this._vidxOffset<d&&(this._vidxOffset+=Math.min(d-this._vidxOffset,100),this.scrollToIndex(this.firstVisibleIndex-(this._vidxOffset-b)),this._noScale=!0)}},_reorderRows:function(){var b=Polymer.dom(this.$.items),d=b.querySelectorAll(".vaadin-grid-row"),f=d.length-(d[0].index-(this._virtualStart+this._vidxOffset));
if(f<d.length/2)for(var h=0;h<f;h++)b.appendChild(d[h]);else for(;f<d.length;f++)b.insertBefore(d[f],d[0])},_frozenCellsChanged:function(){this.debounce("cache-elements",function(){Polymer.dom(this.domHost.root).querySelectorAll(".vaadin-grid-cell").forEach(function(b){b.style.transform=""});this._frozenCells=Array.prototype.slice.call(Polymer.dom(this.domHost.root).querySelectorAll("[frozen]"));this._translateStationaryElements()});this._updateLastFrozen()},_updateLastFrozen:function(){if(this.columnTree){var b=
this.columnTree[this.columnTree.length-1].slice(0);b.sort(function(f,h){return f._order-h._order});var d=b.reduce(function(f,h,k){h._lastFrozen=!1;return h.frozen&&!h.hidden?k:f},void 0);void 0!==d&&(b[d]._lastFrozen=!0)}},_translateStationaryElements:function(){this.fixedSections?(this.$.items.style.transform=this._getTranslate(-this._scrollLeft||0,-this._scrollTop||0),this.$.footer.style.transform=this.$.header.style.transform=this._getTranslate(-this._scrollLeft||0,0)):this.$.footer.style.transform=
this.$.header.style.transform=this._getTranslate(0,this._scrollTop);for(var b=this._getTranslate(this._scrollLeft,0),d=0;d<this._frozenCells.length;d++)this._frozenCells[d].style.transform=b},_getTranslate:function(b,d){return"translate("+b+"px,"+d+"px)"}};vaadin.elements.grid.TableScrollBehavior=[Polymer.IronScrollTargetBehavior,vaadin.elements.grid.TableScrollBehaviorImpl];

//# sourceURL=build://vaadin-grid/vaadin-grid-cell-click-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.CellClickBehavior={listeners:{click:"_onClick"},attached:function(){this._cellContentFocusHandler=function(b){b.target!==this._cellContent&&this.fire("cell-content-focus",{cell:this})}.bind(this);this.addEventListener("focus",this._cellContentFocusHandler,!0)},detached:function(){this.removeEventListener("focus",this._cellContentFocusHandler,!0)},_onClick:function(b){"vaadin-grid-sorter"!==this.localName&&this.fire("cell-focus",{cell:this});if(this._cellClick){var d=Polymer.dom(b).localTarget;
d.getDistributedNodes&&(d=Polymer.dom(d).getDistributedNodes()[0]);var f=Polymer.dom(b).path;f=Array.prototype.slice.call(f,0,f.indexOf(d)+1);d.contains(this.target&&this.target.root.activeElement||document.activeElement)||f.some(this._isFocusable)||this._cellClick(b)}},_isFocusable:function(b){var d=Polymer.dom(b).parentNode;d=-1!==Array.prototype.indexOf.call(Polymer.dom(d).querySelectorAll("[tabindex], button, input, select, textarea, object, iframe, label, a[href], area[href]"),b);return!b.disabled&&
d}};

//# sourceURL=build://vaadin-grid/vaadin-grid-table-cell.html.js
(function(){var b={properties:{column:Object,expanded:Boolean,flexGrow:Number,colSpan:Number,focused:{type:Boolean,reflectToAttribute:!0},frozen:{type:Boolean,reflectToAttribute:!0},lastFrozen:{type:Boolean,reflectToAttribute:!0},hidden:{type:Boolean,reflectToAttribute:!0},instance:Object,index:Number,item:Object,selected:Boolean,template:Object,target:Object,width:String,order:Number,reorderStatus:{type:String,reflectToAttribute:!0},_childColumns:Array,_cellContent:Object,_insertionPoint:Object,
_templatizer:Object},observers:"_columnChanged(column);_cellAttached(column, isAttached);_expandedChanged(expanded, instance);_flexGrowChanged(flexGrow);_indexChanged(index, instance);_itemChanged(item, instance);_instanceChanged(instance, target);_selectedChanged(selected, instance);_toggleContent(isAttached, _cellContent, _insertionPoint);_toggleInstance(isAttached, _templatizer, instance);_widthChanged(width);_orderChanged(order);_visibleChildColumnsChanged(_visibleChildColumns);_childColumnsChanged(_childColumns)".split(";"),
ready:function(){this.classList.add("vaadin-grid-cell");!1===Polymer.Settings.useShadow&&(this.classList.add("style-scope"),this.classList.add("vaadin-grid"))},_columnChanged:function(d){this.flexGrow=d.flexGrow;this.frozen=d.frozen;this.lastFrozen=d._lastFrozen;this.headerTemplate=d.headerTemplate;this.footerTemplate=d.footerTemplate;this.template=d.template;this.width=d.width;this.hidden=d.hidden;this.resizable=d.resizable;this._childColumns=d._childColumns;this.order=d._order;d.colSpan&&(this.colSpan=
d.colSpan);this.listen(d,"property-changed","_columnPropChanged")},_cellAttached:function(d,f){void 0!==d&&void 0!==f&&(f?this.listen(d,"property-changed","_columnPropChanged"):this.async(function(){this.isAttached||this.unlisten(d,"property-changed","_columnPropChanged")}))},_columnPropChanged:function(d){d.target==this.column&&(this[d.detail.path]=d.detail.value)},_expandedChanged:function(d,f){void 0!==d&&void 0!==f&&(f.__expanded__=d,f.expanded=d)},_flexGrowChanged:function(d){this.style.flexGrow=
d},_indexChanged:function(d,f){void 0!==d&&void 0!==f&&(f.index=d)},_itemChanged:function(d,f){void 0!==d&&void 0!==f&&(f.item=d)},_selectedChanged:function(d,f){void 0!==d&&void 0!==f&&(f.__selected__=d,f.selected=d)},_childColumnsChanged:function(d){this.colSpan=d.length},_toggleContent:function(d,f,h){void 0!==d&&void 0!==f&&void 0!==h&&(d?(Polymer.dom(f).parentNode!==this.target&&Polymer.dom(this.target).appendChild(f),Polymer.dom(this).appendChild(h)):this.async(function(){this.isAttached||Polymer.dom(f).parentNode!==
this.target||Polymer.dom(this.target).removeChild(f)}))},_toggleInstance:function(d,f,h){void 0!==d&&void 0!==f&&void 0!==h&&(d?f.addInstance(h):f.removeInstance(h))},_widthChanged:function(d){this.style.width=d},_orderChanged:function(d){this.style.order=d},_templateChanged:function(d){this.instance=d.templatizer.createInstance();this._templatizer=d.templatizer},_instanceChanged:function(d,f){void 0!==d&&void 0!==f&&(this.style.height="",this._cellContent=this._cellContent||document.createElement("vaadin-grid-cell-content"),
d="vaadin-grid-cell-content-"+(vaadin.elements.grid._contentIndex=vaadin.elements.grid._contentIndex+1||0),this._cellContent.innerHTML="",Polymer.dom(this._cellContent).appendChild(this.instance.root),this._cellContent.setAttribute("id",d),Polymer.Element?(this._cellContent.setAttribute("slot",d),this._insertionPoint=this._insertionPoint||document.createElement("slot"),this._insertionPoint.setAttribute("name",d)):(this._insertionPoint=this._insertionPoint||document.createElement("content"),this._insertionPoint.setAttribute("select",
"#"+d)))}};Polymer({is:"vaadin-grid-table-cell",behaviors:[b,vaadin.elements.grid.CellClickBehavior],observers:["_templateChanged(template)"],_cellClick:function(d){d.defaultPrevented||this.fire("cell-activate",{model:this.instance})}});Polymer({is:"vaadin-grid-table-header-cell",properties:{headerTemplate:Object,resizable:Boolean,columnResizing:{type:Boolean,reflectToAttribute:!0}},behaviors:[b,vaadin.elements.grid.CellClickBehavior],observers:["_headerTemplateChanged(headerTemplate)","_isEmptyChanged(_isEmpty, isAttached)",
"_resizableChanged(resizable)"],listeners:{mousedown:"_cancelMouseDownOnResize",mousemove:"_enableDrag",mouseout:"_disableDrag",touchstart:"_onTouchStart",touchmove:"_onTouchMove",touchend:"_onTouchEnd",contextmenu:"_onContextMenu"},_onContextMenu:function(d){this._reorderGhost&&d.preventDefault()},_onTouchStart:function(d){d.target!==this._resizeHandle&&this.target.columnReorderingAllowed&&(this._startReorderTimeout=setTimeout(this._startReorder.bind(this,d),100))},_startReorder:function(d){this._reorderGhost=
this._getGhost();this._reorderGhost.style.visibility="visible";var f=new CustomEvent("dragstart",{bubbles:!0});this._cellContent.dispatchEvent(f);this._reorderXY={x:d.touches[0].clientX-this.getBoundingClientRect().left,y:d.touches[0].clientY-this.getBoundingClientRect().top};this._updateGhostPosition(d.touches[0].clientX,d.touches[0].clientY)},_onTouchMove:function(d){if(this._reorderGhost){d.preventDefault();var f=new CustomEvent("dragover",{bubbles:!0});f.clientX=d.touches[0].clientX;f.clientY=
d.touches[0].clientY;var h=this._contentFromPoint(f.clientX,f.clientY);h&&h.dispatchEvent(f);this._updateGhostPosition(d.touches[0].clientX,d.touches[0].clientY)}else clearTimeout(this._startReorderTimeout)},_updateGhostPosition:function(d,f){d-=this._reorderXY.x;f=f-this._reorderXY.y-50;var h=parseInt(this._reorderGhost.style.left||0),k=parseInt(this._reorderGhost.style.top||0),t=this._reorderGhost.getBoundingClientRect();this._reorderGhost.style.left=h-(t.left-d)+"px";this._reorderGhost.style.top=
k-(t.top-f)+"px"},_onTouchEnd:function(d){clearTimeout(this._startReorderTimeout);this._reorderGhost&&(d.preventDefault(),d=new CustomEvent("dragend",{bubbles:!0}),this.dispatchEvent(d),this._reorderGhost.style.visibility="hidden",this._reorderGhost=null)},_contentFromPoint:function(d,f){if(Polymer.Settings.useShadow){var h=this.target.$.scroller;h.toggleAttribute("no-content-pointer-events",!0);d=this.domHost.root.elementFromPoint(d,f);h.toggleAttribute("no-content-pointer-events",!1);if(d&&d.getContentChildren)return d.getContentChildren(Polymer.Element?
"slot":"content")[0]}else return document.elementFromPoint(d,f)},_getGhost:function(){var d=this.target.$.scroller.$.reorderghost;d.innerText=this._cellContent.innerText;var f=window.getComputedStyle(this._cellContent);"boxSizing display width height background alignItems padding border flex-direction overflow".split(" ").forEach(function(h){d.style[h]=f[h]},this);return d},_enableDrag:function(){this._cellContent.draggable=this.target.columnReorderingAllowed&&!window.getSelection().toString()},_disableDrag:function(){this._cellContent.draggable=
!1},_cancelMouseDownOnResize:function(d){d.target===this._resizeHandle&&d.preventDefault()},_resizableChanged:function(d){d?(this._resizeHandle=document.createElement("div"),this._resizeHandle.classList.add("vaadin-grid-column-resize-handle"),this.listen(this._resizeHandle,"track","_onTrack"),Polymer.dom(this).appendChild(this._resizeHandle)):this._resizeHandle&&(this.unlisten(this._resizeHandle,"track","_onTrack"),Polymer.dom(this).removeChild(this._resizeHandle))},_onTrack:function(d){this.columnResizing=
!0;var f=this.column;"vaadin-grid-column-group"===f.localName&&(f=Array.prototype.slice.call(f._childColumns,0).sort(function(t,l){return t._order-l._order}).filter(function(t){return!t.hidden}).pop());var h=this._getHeaderCellByColumn(f);if(h.offsetWidth){var k=window.getComputedStyle(h._cellContent);f.width=Math.max(10+parseInt(k.paddingLeft)+parseInt(k.paddingRight),h.offsetWidth+d.detail.x-h.getBoundingClientRect().right)+"px";f.flexGrow=0}Array.prototype.slice.call(Polymer.dom(this.parentElement.parentElement).querySelectorAll(".vaadin-grid-row:last-child .vaadin-grid-cell")).sort(function(t,
l){return t.column._order-l.column._order}).forEach(function(t,l,p){l<p.indexOf(h)&&(t.column.width=t.offsetWidth+"px",t.column.flexGrow=0)});this.columnResizing&&"end"===d.detail.state&&(this.columnResizing=!1);this.fire("column-resizing")},_getHeaderCellByColumn:function(d){return Array.prototype.filter.call(Polymer.dom(this.parentElement.parentElement).querySelectorAll(".vaadin-grid-row:last-child .vaadin-grid-cell"),function(f){return f.column===d})[0]},_headerTemplateChanged:function(d){void 0!==
d&&(null===d||!this._isColumnRow&&"vaadin-grid-column-group"!==this.column.localName?(this.instance={root:document.createElement("div")},this._isEmpty=!0):(this.instance=d.templatizer.createInstance(),this._templatizer=d.templatizer,this._isEmpty=!1))},_isEmptyChanged:function(d,f){f&&this.fire("cell-empty-changed")}});Polymer({is:"vaadin-grid-table-footer-cell",properties:{footerTemplate:Object},behaviors:[b,vaadin.elements.grid.CellClickBehavior],observers:["_footerTemplateChanged(footerTemplate)",
"_isEmptyChanged(_isEmpty, isAttached)"],_footerTemplateChanged:function(d){void 0!==d&&(null===d||!this._isColumnRow&&"vaadin-grid-column-group"!==this.column.localName?(this.instance={root:document.createElement("div")},this._isEmpty=!0):(this.instance=d.templatizer.createInstance(),this._templatizer=d.templatizer,this._isEmpty=!1))},_isEmptyChanged:function(d,f){f&&this.fire("cell-empty-changed")}});Polymer({is:"vaadin-grid-sizer-cell",behaviors:[b]})})();

//# sourceURL=build://vaadin-grid/vaadin-grid-sizer.html.js
Polymer({is:"vaadin-grid-sizer",properties:{columnTree:Array,top:Number,_columns:Array},observers:["_columnTreeChanged(columnTree)","_topChanged(top)"],_columnTreeChanged:function(b){this._columns=b[b.length-1]},_topChanged:function(b){this.style.top=b+"px"}});

//# sourceURL=build://vaadin-grid/vaadin-grid-table-outer-scroller.html.js
Polymer({is:"vaadin-grid-table-outer-scroller",properties:{scrollTarget:{type:Object,observer:"_scrollTargetChanged"},passthrough:{type:Boolean,reflectToAttribute:!0,value:!0}},listeners:{scroll:"_syncScrollTarget"},attached:function(){this.listen(this.domHost,"mousemove","_onMouseMove");this.style.webkitOverflowScrolling="touch"},detached:function(){this.unlisten(this.domHost,"mousemove","_onMouseMove")},_scrollTargetChanged:function(b,d){d&&this.unlisten(d,"scroll","_syncOuterScroller");this.listen(b,
"scroll","_syncOuterScroller")},_onMouseMove:function(b){this.passthrough=b.offsetY<=this.clientHeight&&b.offsetX<=this.clientWidth},_syncOuterScroller:function(){this._syncingScrollTarget||(this._syncingOuterScroller=!0,this.scrollTop=this.domHost._scrollTop,this.scrollLeft=this.domHost._scrollLeft);this._syncingScrollTarget=!1},_syncScrollTarget:function(){this._syncingOuterScroller||(this._syncingScrollTarget=!0,this.scrollTarget.scrollTop=this.scrollTop,this.scrollTarget.scrollLeft=this.scrollLeft,
this.domHost._scrollHandler());this._syncingOuterScroller=!1}});

//# sourceURL=build://vaadin-grid/vaadin-grid-focusable-cell-container-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.FocusableCellContainerBehavior={properties:{focused:{type:Boolean,reflectToAttribute:!0},_focusedRow:Object,_focusedRowIndex:Number,_focusedCell:Object,_focusedCellIndex:Number,_lastFocusedCell:Object},observers:["_announceFocusedCell(_focusedCell, focused)","_dispatchEvents(_focusedCell, focused)","_focusedCellChanged(_focusedRowIndex, _focusedCellIndex)"],_announceFocusedCell:function(b,d){void 0!==b&&void 0!==d&&this.domHost.navigating&&d&&(d=Polymer.Element?b._cellContent.getAttribute("slot"):
b._cellContent.id,"vaadin-grid-table-body"!==this.is||b.hasAttribute("detailscell")||(b=Array.prototype.indexOf.call(Polymer.dom(b.parentElement).querySelectorAll(".vaadin-grid-cell"),b),d=this.domHost.$.header.lastElementChild.children[b]._cellContent.id+" "+d),this.domHost.$.footerFocusTrap.activeTarget=d)},_dispatchEvents:function(b,d){void 0!==b&&void 0!==d&&(this._lastFocusedCell&&(this._lastFocusedCell._cellContent.dispatchEvent(new CustomEvent("cell-focusout")),this._lastFocusedCell=void 0),
d&&(b._cellContent.dispatchEvent(new CustomEvent("cell-focusin")),this._lastFocusedCell=b))},_focusedCellChanged:function(b,d){void 0!==b&&void 0!==d&&Array.prototype.forEach.call(Polymer.dom(this).children,function(f,h){f.focused=h===b;f.focused&&(this._focusedRow=f,this._focusedCellIndex=Math.min(d,f.children.length-1),this._focusedCell=f.children[this._focusedCellIndex]);f.cells.forEach(function(k,t){k.focused=t===this._focusedCellIndex}.bind(this))}.bind(this))},focusLeft:function(){if(!this._focusedCell.hasAttribute("detailscell")){var b=
this._visibleCellIndexes();0<b.length&&(this._focusedCellIndex=b[Math.max(0,b.indexOf(this._focusedCellIndex)-1)])}},focusDown:function(){this._focusedRowIndex=Math.min(this._focusedRowIndex+1,this.children.length-1)},_visibleCellIndexes:function(){var b=[];if(this._focusedRow&&this._focusedRow.children){for(var d=this._focusedRow.children,f=0;f<d.length;f++)d[f].hidden||d[f]===this._focusedRow._rowDetailsCell||b.push(f);b.sort(function(h,k){return d[h].column._order<d[k].column._order?-1:1})}return b},
focusPageDown:function(){this._focusedRowIndex=Math.min(this._focusedRowIndex+10,this.children.length-1)},focusPageUp:function(){this._focusedRowIndex=Math.max(0,this._focusedRowIndex-10)},focusRight:function(){if(!this._focusedCell.hasAttribute("detailscell")){var b=this._visibleCellIndexes();0<b.length&&(this._focusedCellIndex=b[Math.min(b.indexOf(this._focusedCellIndex)+1,b.length-1)])}},focusUp:function(){this._focusedRowIndex=Math.max(0,this._focusedRowIndex-1)},focusHome:function(){if(!this._focusedCell.hasAttribute("detailscell")){var b=
this._visibleCellIndexes();0<b.length&&(this._focusedCellIndex=b[0])}},focusEnd:function(){if(!this._focusedCell.hasAttribute("detailscell")){var b=this._visibleCellIndexes();0<b.length&&(this._focusedCellIndex=b[b.length-1])}},focusFirst:function(){this._focusedRowIndex=0;this.focusHome()},focusLast:function(){this._focusedRowIndex=this.children.length-1;this.focusEnd()}};

//# sourceURL=build://vaadin-grid/vaadin-grid-table-header-footer.html.js
(function(){var b={properties:{columnTree:Array,target:Object,_rows:Array},observers:["_columnTreeChanged(columnTree, target)","_rowsChanged(_rows)"],_columnTreeChanged:function(d,f){if(void 0!==d&&void 0!==f){this._rows&&this._rows.forEach(function(l){Polymer.dom(l).innerHTML=""});for(var h=[],k=0;k<d.length;k++){var t=this._createRow();t.target=f;t._isColumnRow=k==d.length-1;t.columns=d[k];h.push(t)}this._rows="vaadin-grid-table-header"===this.localName?h:h.reverse()}},_rowsChanged:function(d){Polymer.dom(this).innerHTML=
"";d.forEach(function(f){Polymer.dom(this).appendChild(f)}.bind(this))}};Polymer({is:"vaadin-grid-table-header",behaviors:[b,vaadin.elements.grid.FocusableCellContainerBehavior],_createRow:function(){return document.createElement("vaadin-grid-table-header-row")}});Polymer({is:"vaadin-grid-table-body",behaviors:[vaadin.elements.grid.FocusableCellContainerBehavior],observers:["_announceFocusedRow(_focusedRow)"],_announceFocusedRow:function(d){this.fire("iron-announce",{text:"Row "+(d.index+1)+" of "+
this.domHost.size})},_moveFocusToDetailsCell:function(){this._focusedCell.focused=!1;this._focusedRow._rowDetailsCell.focused=!0;this._focusedCell=this._focusedRow._rowDetailsCell},_focusedRowHasDetailsCell:function(){return this._focusedRow&&this._focusedRow._rowDetailsCell&&this._focusedCell!==this._focusedRow._rowDetailsCell},focusDown:function(){this._focusedRowHasDetailsCell()?this._moveFocusToDetailsCell():this._focusedRowIndex=Math.min(this._focusedRowIndex+1,this.domHost.size-1)},focusUp:function(){this._focusedRow&&
this._focusedCell===this._focusedRow._rowDetailsCell?this._focusedCellChanged(this._focusedRowIndex,this._focusedCellIndex):(this._focusedRowIndex=Math.max(0,this._focusedRowIndex-1),this._focusedRowHasDetailsCell()&&this._moveFocusToDetailsCell())},focusLast:function(){this._focusedRowIndex=this.domHost.size-1;this.focusEnd()},_focusedCellChanged:function(d,f){void 0!==d&&void 0!==f&&Array.prototype.forEach.call(Polymer.dom(this).children,function(h){h.focused=h.index===d;h.index===d&&(this._focusedRow=
h,this._focusedCell=h.children[f]);h.iterateCells(function(k,t){k.focused=t===f})}.bind(this))}});Polymer({is:"vaadin-grid-table-footer",behaviors:[b,vaadin.elements.grid.FocusableCellContainerBehavior],_createRow:function(){return document.createElement("vaadin-grid-table-footer-row")}})})();

//# sourceURL=build://vaadin-grid/vaadin-grid-table-focus-trap.html.js
Polymer({is:"vaadin-grid-table-focus-trap",hostAttributes:{role:"gridcell"},properties:{activeTarget:{type:String,observer:"_activeTargetChanged"}},ready:function(){this._primary=Polymer.dom(this.root).querySelector(".primary");this._secondary=Polymer.dom(this.root).querySelector(".secondary");if(Polymer.Settings.useNativeShadow||Polymer.Settings.useShadow)Polymer.dom(this).appendChild(this._secondary),Polymer.dom(this).appendChild(this._primary)},focus:function(){this._focused!==this._primary?this._primary.focus():
this._secondary.focus()},_onBaitFocus:function(b){this._focused=b.target;this._movingFocusInternally||(this.fire("focus-gained"),this._primary.tabIndex=-1)},_onBaitBlur:function(){this._movingFocusInternally||(this.fire("focus-lost"),this._primary.tabIndex=0)},_activeTargetChanged:function(b){this._movingFocusInternally=!0;this._focused===this._primary?(this._secondary.setAttribute("aria-labelledby",b),this._secondary.focus()):(this._primary.setAttribute("aria-labelledby",b),this._primary.focus());
this._movingFocusInternally=!1},_reannounce:function(){this._movingFocusInternally=!0;this._focused===this._primary?(this._secondary.setAttribute("aria-labelledby",this.activeTarget),this._secondary.focus()):(this._primary.setAttribute("aria-labelledby",this.activeTarget),this._primary.focus());this._movingFocusInternally=!1}});

//# sourceURL=build://vaadin-grid/vaadin-grid-table-row.html.js
(function(){var b={properties:{active:{type:Boolean,reflectToAttribute:!0,value:!1},columns:Array,index:Number,cells:{value:[]},target:Object,expanded:{value:!1},focused:{type:Boolean,reflectToAttribute:!0},item:Object,selected:{reflectToAttribute:!0},_rowDetailsCell:Object,rowDetailsTemplate:Object},observers:"_columnsChanged(columns, target);_indexChanged(index, cells);_itemChanged(item, cells);_itemChangedForDetails(item, _rowDetailsCell);_rowDetailsChanged(expanded, rowDetailsTemplate, target);_rowDetailsCellIndexChanged(_rowDetailsCell, index);_rowDetailsCellChanged(_rowDetailsCell, target);_selectedChanged(selected, cells);_selectedChangedForDetails(selected, _rowDetailsCell)".split(";"),
ready:function(){this.classList.add("vaadin-grid-row");!1===Polymer.Settings.useShadow&&(this.classList.add("style-scope"),this.classList.add("vaadin-grid"))},iterateCells:function(d){this.cells.forEach(d);this._rowDetailsCell&&d(this._rowDetailsCell)},_rowDetailsChanged:function(d,f,h){if(void 0!==d&&void 0!==f&&void 0!==h){if(d){var k=document.createElement("vaadin-grid-table-cell");k.setAttribute("detailscell",!0);k.frozen=!0;k.target=h;k.template=f;k.toggleAttribute("lastcolumn",!0);Polymer.dom(this.root).appendChild(k);
Polymer.dom.flush();this._rowDetailsCell=k}else this._rowDetailsCell&&(Polymer.dom(this.root).removeChild(this._rowDetailsCell),this._rowDetailsCell=null);this.iterateCells(function(t){t.expanded=d});this.target.$.scroller._frozenCellsChanged()}},_updateRowVisibility:function(){this.hidden=this.cells.every(function(d){return d._isEmpty})},_rowDetailsCellChanged:function(d,f){void 0!==d&&void 0!==f&&f.$.scroller._update()},_rowDetailsCellIndexChanged:function(d,f){void 0!==d&&void 0!==f&&(d?(d.index=
f,Polymer.dom.flush(),this.updateRowDetailsCellMetrics()):this.style.paddingBottom="")},updateRowDetailsCellMetrics:function(){this._rowDetailsCell&&(this.target&&this.target._observer&&this.target._observer.flush&&this.target._observer.flush(),this._rowDetailsCell.style.height="",this.style.paddingBottom=this._rowDetailsCell.style.height=this._rowDetailsCell.clientHeight+"px")},_columnsChanged:function(d,f){if(void 0!==d&&void 0!==f){Polymer.dom(this).innerHTML="";var h=[];d.forEach(function(k){var t=
"_"+this.is.replace(/-/g,"_")+"_cells";t=k[t]=k[t]||[];var l=t.filter(function(m){return!Polymer.dom(m).parentNode})[0];if(!l){l=this._createCell();var p=Array.prototype.some.call(this.target.querySelectorAll("dom-repeat"),function(m){return!m.restamp});(p=p||"vaadin-grid-table-header-row"===this.is||"vaadin-grid-table-footer-row"===this.is)||t.push(l)}l.index=this.index;l.target=this.target;l._isColumnRow=this._isColumnRow;l.column=k;l.expanded=this.expanded;Polymer.dom(this).appendChild(l);h.push(l)}.bind(this));
this.cells=h}},_indexChanged:function(d,f){void 0!==d&&void 0!==f&&f.forEach(function(h){h.index=d})},_itemChanged:function(d,f){void 0!==d&&void 0!==f&&f.forEach(function(h){h.item=d})},_itemChangedForDetails:function(d,f){void 0!==d&&void 0!==f&&f&&(f.item=d)},_selectedChanged:function(d,f){void 0!==d&&void 0!==f&&f.forEach(function(h){h.selected=d})},_selectedChangedForDetails:function(d,f){void 0!==d&&void 0!==f&&f&&(f.selected=d)},updateLastColumn:function(){this.cells.slice(0).sort(function(d,
f){return d.column._order-f.column._order}).forEach(function(d,f,h){d.toggleAttribute("lastcolumn",f===h.length-1)})}};Polymer({is:"vaadin-grid-table-row",behaviors:[b],_createCell:function(){return document.createElement("vaadin-grid-table-cell")}});Polymer({is:"vaadin-grid-table-header-row",behaviors:[b],observers:["_updateRowVisibility(columns)"],listeners:{"cell-empty-changed":"_updateRowVisibility"},_createCell:function(){return document.createElement("vaadin-grid-table-header-cell")}});Polymer({is:"vaadin-grid-table-footer-row",
behaviors:[b],observers:["_updateRowVisibility(columns)"],listeners:{"cell-empty-changed":"_updateRowVisibility"},_createCell:function(){return document.createElement("vaadin-grid-table-footer-cell")}})})();

//# sourceURL=build://vaadin-grid/vaadin-grid-templatizer.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};vaadin.elements.grid.Templatizer=function(){};
vaadin.elements.grid.Templatizer=Polymer({is:"vaadin-grid-templatizer",behaviors:[Polymer.Templatizer],properties:{dataHost:Object,template:Object,_templateInstances:{type:Array,value:function(){return[]}},_parentPathValues:{value:function(){return{}}}},observers:["_templateInstancesChanged(_templateInstances.*, _parentPathValues.*)"],created:function(){this._parentModel=!0;this._instanceProps={expanded:!0,index:!0,item:!0,selected:!0}},createInstance:function(){this._ensureTemplatized();var b=this.stamp({});
this.addInstance(b);return b},addInstance:function(b){-1===this._templateInstances.indexOf(b)&&this.push("_templateInstances",b)},removeInstance:function(b){this.splice("_templateInstances",this._templateInstances.indexOf(b),1)},_ensureTemplatized:function(){this.template._templatized||(this.template._templatized=!0,this.templatize(this.template),this._parentProps=this._parentProps||{},Polymer.Element||Object.keys(this._parentProps).forEach(function(){},this))},_forwardInstanceProp:function(b,d,f){void 0!==
b["__"+d+"__"]&&b["__"+d+"__"]!==f&&this.fire("template-instance-changed",{prop:d,value:f,inst:b})},_forwardInstancePath:function(b,d,f){0!==d.indexOf("item.")||this._suppressItemChangeEvent||this.fire("item-changed",{item:b.item,path:d.substring(5),value:f})},_notifyInstancePropV2:function(b,d,f){this._forwardInstanceProp(b,d,f);this._forwardInstancePath(b,d,f)},_forwardParentProp:function(b,d){this._parentPathValues[b]=d;this._templateInstances.forEach(function(f){f.set(b,d)},this)},_forwardParentPath:function(b,
d){this.set(["_parentPathValues",b],d);this._templateInstances.forEach(function(f){f.notifyPath(b,d)},this)},_forwardHostPropV2:function(b,d){this._forwardParentProp(b,d);this._templateInstances&&this._templateInstances.forEach(function(f){f.notifyPath(b,d)},this)},_templateInstancesChanged:function(b){if("_templateInstances"===b.path){var d=0;var f=this._templateInstances.length}else if("_templateInstances.splices"===b.path)d=b.value.index,f=b.value.addedCount;else return;Object.keys(this._parentPathValues||
{}).forEach(function(h){for(var k=d;k<d+f;k++)this._templateInstances[k].set(h,this._parentPathValues[h])},this)}});

//# sourceURL=build://vaadin-grid/vaadin-grid-row-details-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.RowDetailsBehavior={properties:{expandedItems:{type:Array,value:function(){return[]}}},listeners:{"template-instance-changed":"_templateInstanceChangedExpanded"},observers:["_expandedItemsChanged(expandedItems.*, dataProvider)","_rowDetailsTemplateChanged(_rowDetailsTemplate)"],_expandedItemsChanged:function(b,d){void 0!==b&&void 0!==d&&(this._flushItemsDebouncer(),this.$.scroller._physicalItems&&this.$.scroller._physicalItems.forEach(function(f){f.expanded=this._isExpanded(f.item)}.bind(this)))},
_rowDetailsTemplateChanged:function(b){var d=new vaadin.elements.grid.Templatizer;d.dataHost=this.dataHost;d._instanceProps={expanded:!0,index:!0,item:!0,selected:!0};Polymer.dom(this.root).appendChild(d);d.template=b;b.templatizer=d},_isExpanded:function(b){return this.expandedItems&&-1!==this.expandedItems.indexOf(b)},expandItem:function(b){this._isExpanded(b)||this.push("expandedItems",b)},collapseItem:function(b){this._isExpanded(b)&&this.splice("expandedItems",this.expandedItems.indexOf(b),1)},
_templateInstanceChangedExpanded:function(b){"expanded"===b.detail.prop&&(b.detail.value?this.expandItem(b.detail.inst.item):this.collapseItem(b.detail.inst.item),b.stopPropagation())}};

//# sourceURL=build://vaadin-grid/vaadin-grid-data-provider-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.DataProviderBehavior={listeners:{"item-changed":"_templateItemChanged"},properties:{pageSize:{type:Number,value:50,observer:"_pageSizeChanged"},dataProvider:{type:Object,notify:!0,observer:"_dataProviderChanged"},_loading:Boolean,_cache:{type:Object,value:function(){return{}}},_pendingRequests:{type:Object,value:function(){return{}}}},_templateItemChanged:function(b){var d=b.detail.item;Array.prototype.forEach.call(Polymer.dom(this.$.items).children,function(f){f.item===d&&f.iterateCells(function(h){h._templatizer._suppressItemChangeEvent=
!0;h.instance.notifyPath("item."+b.detail.path,b.detail.value);h._templatizer._suppressItemChangeEvent=!1})})},_getCachedItem:function(b){var d=this._getPageForIndex(b),f=this._cache&&this._cache[d];return f?f[b-d*this.pageSize]:null},_getItem:function(b,d){this._updateItem(d,this._getCachedItem(b));this._eagerlyLoadPages();var f=this._uncachedPagesForPhysicalItems();0<f.length&&(this._loading=!0,this.debounce("load",function(){f.forEach(function(h){this._loadPage(h)}.bind(this))},100))},_cachedPagesForPhysicalItems:function(){return this._pagesForPhysicalItems().filter(function(b){return void 0!==
this._cache&&void 0!==this._cache[b]}.bind(this))},_uncachedPagesForPhysicalItems:function(){return this._pagesForPhysicalItems().filter(function(b){return void 0!==this._cache&&void 0===this._cache[b]}.bind(this))},_eagerlyLoadPages:function(){var b=this._cachedPagesForPhysicalItems().slice(0);if(0<b.length){b.sort(function(f,h){return f>h});var d=Math.min(b[b.length-1]+1,Math.max(0,Math.floor(this.size/this.pageSize)-1));this._loadPage(Math.max(0,b[0]-1));this._loadPage(d)}},_pagesForPhysicalItems:function(){return[this._getPageForIndex(this.$.scroller.firstVisibleIndex+
this.$.scroller._vidxOffset)].concat(this.$.scroller._physicalItems.filter(function(b){return b.index}).map(function(b){return this._getPageForIndex(b.index)}.bind(this))).reduce(function(b,d){-1===b.indexOf(d)&&b.push(d);return b},[])},_updateItems:function(b,d){for(var f=0;f<this.pageSize;f++){var h=this.$.scroller._virtualIndexToItem[b*this.pageSize+f];h&&(this._updateItem(h,d[f]),this.debounce("update-heights",function(){this.$.scroller._updateMetrics();this.$.scroller._positionItems();this.$.scroller._updateScrollerSize()},
1))}},_loadPage:function(b,d){d=d||this._updateItems.bind(this);if(!this._cache[b]&&!this._pendingRequests[b]&&this.dataProvider){this._pendingRequests[b]=!0;var f={page:b,pageSize:this.pageSize,sortOrders:this._mapSorters(),filters:this._mapFilters()};this.dataProvider(f,function(h){this._cache[b]=h;delete this._pendingRequests[b];d(b,h);this._loading=0<this._pendingRequests.length;this.debounce("check-size",this._checkSize,2E3)}.bind(this))}},_getPageForIndex:function(b){return Math.floor(b/this.pageSize)},
clearCache:function(){this._cache={};this._pendingRequests={};this.$.scroller.hasData&&this.$.scroller._update();this._flushItemsDebouncer()},_flushItemsDebouncer:function(){this.flushDebouncer("load")},_pageSizeChanged:function(b,d){void 0!==d&&b!==d&&this.clearCache()},_checkSize:function(){void 0===this.size&&console.warn('The \x3cvaadin-grid\x3e needs a value for "size" property in order to display rows.')},_dataProviderChanged:function(b,d){void 0!==d&&this.clearCache();this.$.scroller.hasData||
(this._loading=!0,this._loadPage(0,function(){this.$.scroller.hasData=!0}.bind(this)))}};

//# sourceURL=build://vaadin-grid/vaadin-grid-selection-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.SelectionBehavior={properties:{selectedItems:{type:Object,notify:!0,value:function(){return[]}}},observers:["_selectedItemsChanged(selectedItems.*)"],listeners:{"template-instance-changed":"_templateInstanceChangedSelection"},_templateInstanceChangedSelection:function(b){if("selected"===b.detail.prop){var d=b.detail.inst.item;(this._isSelected(d)?this.deselectItem:this.selectItem).bind(this)(d);this.fire("iron-announce",{text:(this._isSelected(d)?"Selected":"Deselected")+" Row "+
(b.detail.inst.index+1)+" of "+this.size});b.stopPropagation()}},_isSelected:function(b){return this.selectedItems&&-1<this.selectedItems.indexOf(b)},selectItem:function(b){b=this._takeItem(b);this._isSelected(b)||this.push("selectedItems",b)},deselectItem:function(b){b=this._takeItem(b);b=this.selectedItems.indexOf(b);-1<b&&this.splice("selectedItems",b,1)},_toggleItem:function(b){b=this._takeItem(b);-1===this.selectedItems.indexOf(b)?this.selectItem(b):this.deselectItem(b)},_takeItem:function(b){return"number"===
typeof b&&0<=b&&this.items&&this.items.length>b?this.items[b]:b},_selectedItemsChanged:function(b){!this.$.scroller._physicalItems||"selectedItems"!==b.path&&"selectedItems.splices"!==b.path||this.$.scroller._physicalItems.forEach(function(d){d.selected=this._isSelected(d.item)}.bind(this))}};

//# sourceURL=build://vaadin-grid/vaadin-grid-keyboard-navigation-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.TableKeyboardBehaviorImpl={hostAttributes:{role:"application",tabindex:0},keyBindings:{"ctrl+home":"_onCtrlHome","ctrl+end":"_onCtrlEnd",down:"_onArrowDown",end:"_onEnd",enter:"_onEnter",esc:"_onEscape",f2:"_onF2",home:"_onHome",left:"_onArrowLeft",pagedown:"_onPageDown",pageup:"_onPageUp",right:"_onArrowRight",space:"_onSpace",tab:"_onTab",up:"_onArrowUp"},attached:function(){Polymer.IronA11yAnnouncer.requestAvailability()},properties:{_virtualFocus:{type:Object,observer:"_virtualFocusChanged"},
interacting:{type:Boolean,reflectToAttribute:!0,value:!1},navigating:{type:Boolean,reflectToAttribute:!0,value:!1}},listeners:{focus:"_onFocus","cell-focus":"_onCellFocus","cell-content-focus":"_onCellContentFocus"},ready:function(){document.addEventListener("keydown",function(b){9===b.keyCode&&(this._tabbed=!0);9===b.keyCode&&b.shiftKey&&(this._shiftTabbed=!0)}.bind(this),!0);document.addEventListener("keyup",function(b){9===b.keyCode&&(this._tabbed=!1);9===b.keyCode&&b.shiftKey&&(this._shiftTabbed=
!1)}.bind(this),!0)},_isFooterVisible:function(){return 0<this.$.footer._rows.filter(function(b){return!b.hidden}).length},_onFocus:function(){this._tabbed&&!this._shiftTabbed&&this._activateNavigation()},_activateNavigation:function(){this.$.footerFocusTrap.focus()},_onFocusout:function(){this.interacting=this.navigating=!1},_onFooterFocus:function(){this.navigating=!0;this.interacting=!1;this._virtualFocus=this._virtualFocus||(this._shiftTabbed?this._isFooterVisible()?this.$.footer:this.$.items:
this.$.header)},_virtualFocusChanged:function(b,d){d&&(d.focused=!1);b&&(b._focusedCellIndex=b._focusedCellIndex||0,b._focusedRowIndex=b._focusedRowIndex||0,b.focused=!0,b===this.$.items&&this._ensureVirtualFocusInViewport())},_onTab:function(b){if(!this.interacting&&this._virtualFocus)if(this.navigating)if(b.detail.keyboardEvent.shiftKey)switch(this._virtualFocus){case this.$.footer:this._virtualFocus=this.$.items;b.preventDefault();break;case this.$.items:this._virtualFocus=this.$.header;b.preventDefault();
break;case this.$.header:this.focus(),this._virtualFocus=null}else switch(this._virtualFocus){case this.$.header:this._virtualFocus=this.$.items;b.preventDefault();break;case this.$.items:this._isFooterVisible()?(this._virtualFocus=this.$.footer,b.preventDefault()):this.async(function(){this._virtualFocus=null},1);break;case this.$.footer:this._virtualFocus=null}else this._activateNavigation(),b.preventDefault()},_isAboveViewport:function(b){return this.firstVisibleIndex>b},_onArrowDown:function(b){this.interacting||
(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusDown(),this._ensureVirtualFocusInViewport())},_scrollPageDown:function(){var b=this.$.header.getBoundingClientRect(),d=this.$.footer.getBoundingClientRect();this.$.scroller.$.table.scrollTop+=d.top-b.bottom;this.$.scroller._scrollHandler()},_onPageDown:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus===this.$.items?(b=this.$.scroller.lastVisibleIndex,this._scrollPageDown(),this._virtualFocus._focusedRowIndex+=
this.$.scroller.lastVisibleIndex-b||this.$.scroller.lastVisibleIndex-this._virtualFocus._focusedRowIndex,this._ensureVirtualFocusInViewport()):this._virtualFocus.focusPageDown())},_scrollPageUp:function(){var b=this.$.header.getBoundingClientRect(),d=this.$.footer.getBoundingClientRect();this.$.scroller.$.table.scrollTop-=d.top-b.bottom;this.$.scroller._scrollHandler()},_onPageUp:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus===this.$.items?(b=this.$.scroller.lastVisibleIndex,
this._scrollPageUp(),this._virtualFocus._focusedRowIndex-=b-this.$.scroller.lastVisibleIndex||this._virtualFocus._focusedRowIndex,this._ensureVirtualFocusInViewport()):this._virtualFocus.focusPageUp())},_onArrowUp:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusUp(),this._ensureVirtualFocusInViewport())},_onArrowRight:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusRight(),this._ensureVirtualFocusInViewport())},
_onArrowLeft:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusLeft(),this._ensureVirtualFocusInViewport())},_onHome:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusHome(),this._ensureVirtualFocusInViewport())},_onEnd:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusEnd(),this._ensureVirtualFocusInViewport())},_moveFocusToFocusTarget:function(){var b=this._virtualFocus._focusedCell._cellContent;
(b=b.querySelector("[focus-target]")||b.firstElementChild)&&b.focus()},_onEnter:function(b){this.interacting?"input"===b.detail.keyboardEvent.target.localName&&"text"===b.detail.keyboardEvent.target.type&&this.$.footerFocusTrap.focus():(b.preventDefault(),this._moveFocusToFocusTarget())},_onEscape:function(){this.interacting?this.$.footerFocusTrap.focus():this.navigating&&(this.navigating=!1)},_onF2:function(b){b.preventDefault();this.interacting?this.$.footerFocusTrap.focus():this._moveFocusToFocusTarget()},
_onCtrlHome:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusFirst(),this._ensureVirtualFocusInViewport())},_onCtrlEnd:function(b){this.interacting||(b.preventDefault(),this.navigating=!0,this._virtualFocus.focusLast(),this._ensureVirtualFocusInViewport())},_onSpace:function(b){if(!this.interacting){b.preventDefault();b=this._virtualFocus._focusedCell;var d=b.getContentChildren(Polymer.Element?"slot":"content")[0].firstElementChild;d?d.click():this.navigating&&
this.fire("cell-activate",{model:b.instance})}},_onCellContentFocus:function(b){this.interacting=!0;this._onCellFocus(b)},_onCellFocus:function(b){b=b.detail.cell;var d=b.parentElement,f=d.parentElement,h=Array.prototype.indexOf.call(Polymer.dom(f).children,d);f===this.$.items&&(h=d.index);f._focusedRowIndex=h;f._focusedCellIndex=Array.prototype.indexOf.call(Polymer.dom(d).children,b);this._virtualFocus=f;b.hasAttribute("detailscell")&&(f._focusedCellIndex=0,f._moveFocusToDetailsCell())},_ensureVirtualFocusInViewport:function(){var b=
this.$.scroller._vidxOffset+this.$.scroller._virtualStart,d=this._virtualFocus._focusedRowIndex;this._virtualFocus===this.$.items&&(d<b||d>b+this.$.scroller._physicalCount)&&(this.$.scroller.scrollToScaledIndex(d),this._virtualFocus._focusedCellChanged(d,this._virtualFocus._focusedCellIndex));this._ensureElementInViewport(this._virtualFocus._focusedCell)},_ensureElementInViewport:function(b){var d=b.getBoundingClientRect();if(this._virtualFocus===this.$.items){var f=this.$.footer.getBoundingClientRect().top,
h=this.$.header.getBoundingClientRect().bottom;d.bottom>f?this.$.scroller.$.table.scrollTop+=d.bottom-f:d.top<h&&(this.$.scroller.$.table.scrollTop+=d.top-h)}if(!b.hasAttribute("detailscell")){b=this.$.scroller.$.table.getBoundingClientRect().right;f=this.$.scroller.$.table.getBoundingClientRect().left;if(h=this._virtualFocus._focusedRow.querySelector("[last-frozen]"))f=h.getBoundingClientRect().right;d.right>b?this.$.scroller.$.table.scrollLeft+=d.right-b:d.left<f&&(this.$.scroller.$.table.scrollLeft+=
d.left-f)}}};vaadin.elements.grid.TableKeyboardBehavior=[vaadin.elements.grid.TableKeyboardBehaviorImpl,Polymer.IronA11yKeysBehavior];

//# sourceURL=build://vaadin-grid/vaadin-grid-column-reordering-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};vaadin.elements.grid.ColumnReorderingBehavior={properties:{columnReorderingAllowed:{type:Boolean,value:!1}}};
vaadin.elements.grid.TableColumnReorderingBehavior={properties:{_orderBaseScope:{type:Number,value:1E7}},listeners:{dragstart:"_onDragStart",dragover:"_onDragOver",dragend:"_onDragEnd"},observers:["_updateOrders(columnTree, columnTree.*)"],_updateOrders:function(b,d){void 0!==b&&void 0!==d&&b[0].forEach(function(f,h){f._order=(h+1)*this._orderBaseScope},this)},_onDragStart:function(b){if("vaadin-grid-cell-content"===b.target.localName){var d=this._getCellByCellContent(b.target);d&&(this.toggleAttribute("reordering",
!0),this._draggedColumn=d.column,this._setSiblingsReorderStatus(this._draggedColumn,"allowed"),this._draggedColumn._reorderStatus="dragging",b.dataTransfer&&(b.dataTransfer.setData("text",""),b.dataTransfer.effectAllowed="move"),this._autoScroller())}},_setSiblingsReorderStatus:function(b,d){Array.prototype.filter.call(Polymer.dom(Polymer.dom(b).parentNode).children,function(f){return/column/.test(f.localName)&&this._isSwapAllowed(f,b)},this).forEach(function(f){f._reorderStatus=d})},_onDragOver:function(b){if(this._draggedColumn){var d=
(Polymer.Element?b.composedPath():Polymer.dom(b).path).filter(function(f){return"vaadin-grid-cell-content"===f.localName})[0];d&&(b.preventDefault(),d=this._getCellByCellContent(d),(d=this._getTargetColumn(d,this._draggedColumn))&&this._isSwapAllowed(this._draggedColumn,d)&&this._isSwappableByPosition(d,b.clientX)&&this._swapColumnOrders(this._draggedColumn,d),this._lastDragClientX=b.clientX)}},_autoScroller:function(){if(this._lastDragClientX){var b=this._lastDragClientX-this.getBoundingClientRect().right+
50,d=this.getBoundingClientRect().left-this._lastDragClientX+50;0<b?this.$.table.scrollLeft+=b/10:0<d&&(this.$.table.scrollLeft-=d/10);this._scrollHandler()}this._draggedColumn&&this.async(this._autoScroller,10)},_onDragEnd:function(){this._draggedColumn&&(this.toggleAttribute("reordering",!1),this._draggedColumn._reorderStatus="",this._setSiblingsReorderStatus(this._draggedColumn,""),this._lastDragClientX=this._draggedColumn=null)},_isSwapAllowed:function(b,d){if(b&&d){var f=b.parentElement===d.parentElement,
h=b.frozen===d.frozen;return b!==d&&f&&h}},_isSwappableByPosition:function(b,d){var f=Array.prototype.filter.call(Polymer.dom(this.$.header).querySelectorAll(".vaadin-grid-cell"),function(k){return k.column===b})[0],h=this.$.header.querySelector("[reorder-status\x3ddragging]").getBoundingClientRect();return f.getBoundingClientRect().left>h.left?d>f.getBoundingClientRect().right-h.width:d<f.getBoundingClientRect().left+h.width},_getCellByCellContent:function(b){if(Polymer.Element)return b.assignedSlot.parentNode;
b=Polymer.dom(b).getDestinationInsertionPoints()[0];return Polymer.dom(b).parentNode},_swapColumnOrders:function(b,d){var f=b._order;b._order=d._order;d._order=f;this._updateLastFrozen();this._updateLastColumn()},_getTargetColumn:function(b,d){if(b&&d){for(var f=b.column;f.parentElement!==d.parentElement&&f!==this.target;)f=f.parentElement;return f.parentElement===d.parentElement?f:b.column}}};

//# sourceURL=build://vaadin-grid/iron-list-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.IronListBehaviorImpl=function(){var b=navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/),d=b&&8<=b[1];return{is:"iron-list",properties:{maxPhysicalCount:{type:Number,value:500},as:{type:String,value:"item"},indexAs:{type:String,value:"index"}},_ratio:.5,_scrollerPaddingTop:0,_scrollPosition:0,_physicalSize:0,_physicalAverage:0,_physicalAverageCount:0,_physicalTop:0,_virtualCount:0,_physicalIndexForKey:null,_estScrollHeight:0,_scrollHeight:0,_viewportHeight:0,_viewportWidth:0,
_physicalItems:null,_physicalSizes:null,_firstVisibleIndexVal:null,_lastVisibleIndexVal:null,_collection:null,_itemsRendered:!1,_lastPage:null,_maxPages:3,_itemsPerRow:1,_itemWidth:0,_rowHeight: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._scrollerPaddingTop},_minVirtualStart:0,get _maxVirtualStart(){return Math.max(0,this._virtualCount-this._physicalCount)},_virtualStartVal:0,set _virtualStart(f){this._virtualStartVal=Math.min(this._maxVirtualStart,Math.max(this._minVirtualStart,f))},get _virtualStart(){return this._virtualStartVal||0},_physicalStartVal:0,set _physicalStart(f){this._physicalStartVal=f%this._physicalCount;0>this._physicalStartVal&&(this._physicalStartVal=this._physicalCount+this._physicalStartVal);
this._physicalEnd=(this._physicalStart+this._physicalCount-1)%this._physicalCount},get _physicalStart(){return this._physicalStartVal||0},_physicalCountVal:0,set _physicalCount(f){this._physicalCountVal=f;this._physicalEnd=(this._physicalStart+this._physicalCount-1)%this._physicalCount},get _physicalCount(){return this._physicalCountVal},_physicalEnd:0,get _optPhysicalSize(){return this._viewportHeight*this._maxPages},get _optPhysicalCount(){return this._estRowsInView*this._itemsPerRow*this._maxPages},
get _isVisible(){return this.scrollTarget&&!(!this.scrollTarget.offsetWidth&&!this.scrollTarget.offsetHeight)},get firstVisibleIndex(){if(null===this._firstVisibleIndexVal){var f=Math.floor(this._physicalTop+this._scrollerPaddingTop);this._firstVisibleIndexVal=this._iterateItems(function(h,k){f+=this._getPhysicalSizeIncrement(h);if(f>this._scrollPosition)return k})||0}return this._firstVisibleIndexVal},get lastVisibleIndex(){if(null===this._lastVisibleIndexVal){var f=this._physicalTop;this._iterateItems(function(h,
k){if(f<this._scrollBottom)this._lastVisibleIndexVal=k;else return!0;f+=this._getPhysicalSizeIncrement(h)})}return this._lastVisibleIndexVal},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)},attached:function(){this.updateViewportBoundaries();this._render();this.listen(this,"iron-resize",
"_resizeHandler")},detached:function(){this._itemsRendered=!1;this.unlisten(this,"iron-resize","_resizeHandler")},updateViewportBoundaries:function(){this._scrollerPaddingTop=this.scrollTarget===this?0:parseInt(window.getComputedStyle(this)["padding-top"]||0,10);this._viewportHeight=this._scrollTargetHeight},_update:function(f,h){this._assignModels(f);this._updateMetrics(f);if(h)for(;h.length;)f=h.pop(),this._physicalTop-=this._getPhysicalSizeIncrement(f);this._positionItems();this._updateScrollerSize();
this._increasePoolIfNeeded()},_increasePoolIfNeeded:function(){if(0===this._viewportHeight)return!1;var f=this._physicalSizes.reduce(function(k,t){return k+(t||100)},0),h=f>this._viewportHeight;if(f>=this._optPhysicalSize&&h)return!1;f=Math.floor(this._physicalSize/this._viewportHeight);0===f?this._debounceTemplate(this._increasePool.bind(this,Math.round(.5*this._physicalCount))):this._lastPage!==f&&h?Polymer.dom.addDebouncer(this.debounce("_debounceTemplate",this._increasePool.bind(this,this._itemsPerRow),
16)):this._debounceTemplate(this._increasePool.bind(this,Math.ceil(this._viewportHeight/(this._physicalSize/this._physicalCount)*this._maxPages-this._physicalCount)||1));this._lastPage=f;return!0},_debounceTemplate:function(f){Polymer.dom.addDebouncer(this.debounce("_debounceTemplate",f))},_increasePool:function(f){var h=this._physicalCount;f=Math.min(this._physicalCount+f,this._virtualCount-this._virtualStart,Math.max(this.maxPhysicalCount,25))-h;0>=f||([].push.apply(this._physicalItems,this._createPool(f)),
[].push.apply(this._physicalSizes,Array(f)),this._physicalCount=h+f,this._update())},_render:function(){var f=0<this._virtualCount||0<this._physicalCount;this.isAttached&&!this._itemsRendered&&this._isVisible&&f&&(this._lastPage=0,this._update(),this._itemsRendered=!0)},_iterateItems:function(f,h){var k,t;if(2===arguments.length&&h)for(t=0;t<h.length;t++){var l=h[t];var p=this._computeVidx(l);if(null!=(k=f.call(this,l,p)))return k}else{l=this._physicalStart;for(p=this._virtualStart;l<this._physicalCount;l++,
p++)if(null!=(k=f.call(this,l,p)))return k;for(l=0;l<this._physicalStart;l++,p++)if(null!=(k=f.call(this,l,p)))return k}},_computeVidx:function(f){return f>=this._physicalStart?this._virtualStart+(f-this._physicalStart):this._virtualStart+(this._physicalCount-this._physicalStart)+f},_updateMetrics:function(f){this.scrolling&&Polymer.dom.flush();var h=0,k=0,t=this._physicalAverageCount,l=this._physicalAverage;this._iterateItems(function(p){k+=this._physicalSizes[p]||0;this._physicalSizes[p]=this._physicalItems[p].offsetHeight;
h+=this._physicalSizes[p];this._physicalAverageCount+=this._physicalSizes[p]?1:0},f);this._viewportHeight=this._scrollTargetHeight;this._physicalSize=this._physicalSize+h-k;this._physicalAverageCount!==t&&(this._physicalAverage=Math.round((l*t+h)/this._physicalAverageCount))},_positionItems:function(){this._adjustScrollPosition();var f=this._physicalTop;this._iterateItems(function(h){this._physicalItems[h].style.transform=this._getTranslate(0,f);f+=this._physicalSizes[h]})},_getPhysicalSizeIncrement:function(f){return this._physicalSizes[f]},
_shouldRenderNextRow:function(f){return f%this._itemsPerRow===this._itemsPerRow-1},_adjustScrollPosition:function(){var f=0===this._virtualStart?this._physicalTop:Math.min(this._scrollPosition+this._physicalTop,0);f&&(this._physicalTop-=f,d||0===this._physicalTop||this._resetScrollPosition(this._scrollTop-f))},_resetScrollPosition:function(f){this.scrollTarget&&(this._scrollPosition=this._scrollTop=f)},_updateScrollerSize:function(f){this._estScrollHeight=this._physicalBottom+Math.max(this._virtualCount-
this._physicalCount-this._virtualStart,0)*this._physicalAverage;if((f=(f=f||0===this._scrollHeight)||this._scrollPosition>=this._estScrollHeight-this._physicalSize)||Math.abs(this._estScrollHeight-this._scrollHeight)>=this._optPhysicalSize)this.$.items.style.height=this._estScrollHeight+"px",this._scrollHeight=this._estScrollHeight},scrollToIndex:function(f){Polymer.dom.flush();f=Math.min(Math.max(f,0),this._virtualCount-1);if(!this._isIndexRendered(f)||f>=this._maxVirtualStart)this._virtualStart=
f-1;this._assignModels();this._updateMetrics();this._physicalTop=Math.floor(this._virtualStart/this._itemsPerRow)*this._physicalAverage;for(var h=this._physicalStart,k=this._virtualStart,t=0,l=this._hiddenContentSize;k<f&&t<=l;)t+=this._getPhysicalSizeIncrement(h),h=(h+1)%this._physicalCount,k++;this._updateScrollerSize(!0);this._positionItems();this._resetScrollPosition(this._physicalTop+this._scrollerPaddingTop+t);this._increasePoolIfNeeded();this._lastVisibleIndexVal=this._firstVisibleIndexVal=
null},_resetAverage:function(){this._physicalAverageCount=this._physicalAverage=0},_resizeHandler:function(){Polymer.dom.addDebouncer(this.debounce("_debounceTemplate",function(){this.updateViewportBoundaries();this._render();this._itemsRendered&&this._physicalItems&&this._isVisible&&(this._resetAverage(),this.scrollToIndex(this.firstVisibleIndex))}.bind(this),1))},updateSizeForItem:function(f){f=this._physicalIndexForKey[f];null!=f&&(this._updateMetrics([f]),this._positionItems())},_isIndexRendered:function(f){return f>=
this._virtualStart&&f<=this._virtualEnd},_isIndexVisible:function(f){return f>=this.firstVisibleIndex&&f<=this.lastVisibleIndex}}}();vaadin.elements.grid.IronListBehavior=[Polymer.Templatizer,Polymer.IronScrollTargetBehavior,vaadin.elements.grid.IronListBehaviorImpl];

//# sourceURL=build://vaadin-grid/vaadin-grid-table.html.js
Polymer({is:"vaadin-grid-table",behaviors:[vaadin.elements.grid.IronListBehavior,vaadin.elements.grid.TableScrollBehavior,vaadin.elements.grid.TableColumnReorderingBehavior,Polymer.Templatizer],properties:{size:Number,columnTree:Array,bindData:Function,rowDetailsTemplate:Object,columnReorderingAllowed:{type:Boolean,reflectToAttribute:!0},safari:{type:Boolean,value:/^((?!chrome|android).)*safari/i.test(navigator.userAgent)},scrollbarWidth:{type:Number,value:function(){var b=document.createElement("div");
b.style.width="100px";b.style.height="100px";b.style.overflow="scroll";b.style.position="absolute";b.style.top="-9999px";document.body.appendChild(b);var d=b.offsetWidth-b.clientWidth;document.body.removeChild(b);return d}},target:Object,hasData:Boolean},observers:["_columnTreeChanged(columnTree, _physicalItems, _physicalCountVal)","_sizeChanged(size, bindData, hasData)","_rowDetailsTemplateChanged(rowDetailsTemplate, _physicalItems, _physicalCountVal)"],listeners:{"property-changed":"_columnPropChanged",
animationend:"_onAnimationEnd","column-resizing":"_onColumnResize"},ready:function(){this.$=this.$||{};this.$.header=this.domHost.$.header;this.$.items=this.domHost.$.items;this.$.footer=this.domHost.$.footer},_onColumnResize:function(){this.toggleAttribute("column-resizing",this.$.header.querySelector("[column-resizing]"));this._gridResizeHandler()},_onAnimationEnd:function(b){/appear/.test(b.animationName)&&(this._render(),this._updateHeaderFooterMetrics(),b.stopPropagation())},_columnPropChanged:function(b){"headerTemplate"===
b.detail.path&&this.toggleAttribute("has-templates",!0,this.$.header);"footerTemplate"===b.detail.path&&this.toggleAttribute("has-templates",!0,this.$.footer);/frozen|hidden/.test(b.detail.path)&&this._frozenCellsChanged();"hidden"===b.detail.path&&this._gridResizeHandler()},_hideOuterScroller:function(b,d){return 0===b&&!d},_hideTableOverflow:function(b,d){return 0===b&&d},_rowDetailsTemplateChanged:function(b,d,f){void 0!==b&&d&&void 0!==f&&Array.prototype.forEach.call(d,function(h){h.rowDetailsTemplate=
b})},_columnTreeChanged:function(b,d,f){void 0!==b&&d&&void 0!==f&&(Polymer.RenderStatus.afterNextRender(this,this._update),this._frozenCellsChanged(),this._hasTemplatesChanged(b),Array.prototype.forEach.call(d,function(h){h.columns=b[b.length-1]}),this._gridResizeHandler(),Polymer.dom.flush(this),this._updateLastColumn())},_updateLastColumn:function(){Array.prototype.forEach.call(Polymer.dom(this.domHost.root).querySelectorAll(".vaadin-grid-row"),function(b){b.updateLastColumn()})},_updateHeaderFooterMetrics:function(){this._physicalSizes&&
Polymer.dom.flush();this._updateHeaderFooterMetricsSync();Polymer.RenderStatus.afterNextRender(this.$.header,function(){this._updateHeaderFooterMetricsSync();this._pendingScrollToScaledIndex&&this.scrollToScaledIndex(this._pendingScrollToScaledIndex)}.bind(this))},_updateHeaderFooterMetricsSync:function(){var b=this.$.header.clientHeight+"px",d=this.$.footer.clientHeight+"px";[this.$.outersizer,this.$.fixedsizer,this.$.items].forEach(function(f){f.style.borderTopWidth=b;f.style.borderBottomWidth=
d})},_hasTemplatesChanged:function(b){var d=!1,f=!1;b.forEach(function(h){return h.forEach(function(k){d=d||k.headerTemplate;f=f||k.footerTemplate})});this.toggleAttribute("has-templates",d,this.$.header);this.toggleAttribute("has-templates",f,this.$.footer)},_createPool:function(b){for(var d=Array(b),f=0;f<b;f++){var h=document.createElement("vaadin-grid-table-row");h.target=this.domHost;d[f]=h;h.setAttribute("hidden","");Polymer.dom(this.$.items).appendChild(h)}return d},_sizeChanged:function(b,
d,f){if(void 0!==b&&void 0!==d&&void 0!==f){var h=this._scrollTop,k=this.firstVisibleIndex+this._vidxOffset;this._virtualCount=Math.min(b,1E5);this._physicalIndexForKey={};this._lastVisibleIndexVal=this._firstVisibleIndexVal=null;this._vidxOffset=0;this._physicalItems||(this._physicalCount=Math.max(1,Math.min(25,this._virtualCount)),this._physicalItems=this._createPool(this._physicalCount),this._physicalSizes=Array(this._physicalCount));this._itemsRendered=!1;this._debounceTemplate(function(){this._render();
this._viewportHeight&&(this.scrollToScaledIndex(Math.min(k,this.size)),this._scrollTop=h,this._scrollHandler(),this.flushDebouncer("vaadin-grid-scrolling"))})}},_assignModels:function(b){this._virtualIndexToItem=this._virtualIndexToItem||{};this._iterateItems(function(d,f){d=this._physicalItems[d];d.index&&delete this._virtualIndexToItem[d.index];d.index=f+this._vidxOffset;this._virtualIndexToItem[d.index]=d;d.toggleAttribute("odd",d.index%2);d.toggleAttribute("lastrow",d.index===this.size-1);d.toggleAttribute("hidden",
d.index>=this.size);this.bindData(d.index,d)},b)},_gridResizeHandler:function(){this._updateHeaderFooterMetrics();this._physicalSizes&&(this._physicalItems.forEach(function(b){b.updateRowDetailsCellMetrics()}),this.debounce("vaadin-grid-resizing",function(){this._update()}.bind(this),1))}});

//# sourceURL=build://vaadin-grid/vaadin-grid-column.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.ColumnBaseBehavior={properties:{resizable:{type:Boolean,value:function(){if("vaadin-grid-column-group"!==this.localName){var b=Polymer.dom(this).parentNode;return b&&"vaadin-grid-column-group"===b.localName?b.resizable||!1:!1}}},headerTemplate:{type:Object},footerTemplate:{type:Object},frozen:{type:Boolean,notify:!0,value:!1},hidden:{type:Boolean,notify:!0},_lastFrozen:{type:Boolean,notify:!0,value:!1},_order:Number,_reorderStatus:Boolean},observers:["_footerTemplateChanged(footerTemplate)",
"_headerTemplateChanged(headerTemplate)","_lastFrozenChanged(_lastFrozen)"],created:function(){function b(d){0<=d.addedNodes.length&&(this.headerTemplate=this._prepareHeaderTemplate(),this.footerTemplate=this._prepareFooterTemplate(),this.template=this._prepareBodyTemplate())}this._templateObserver=Polymer.Element?new Polymer.FlattenedNodesObserver(this,b):Polymer.dom(this).observeNodes(b)},_prepareHeaderTemplate:function(){return this._prepareTemplatizer(this._findTemplate("template.header")||null,
{})},_prepareFooterTemplate:function(){return this._prepareTemplatizer(this._findTemplate("template.footer")||null,{})},_prepareBodyTemplate:function(){return this._prepareTemplatizer(this._findTemplate("template:not(.header):not(.footer)",{}))},_prepareTemplatizer:function(b,d){if(b&&!b.templatizer){var f=new vaadin.elements.grid.Templatizer;f.dataHost=this.dataHost;f._instanceProps=d||f._instanceProps;f.template=b;b.templatizer=f}return b},_selectFirstTemplate:function(b){return Array.prototype.filter.call(Polymer.dom(this).querySelectorAll(b),
function(d){return Polymer.dom(d).parentNode===this}.bind(this))[0]},_findTemplate:function(b){(b=this._selectFirstTemplate(b))&&this.dataHost&&(b._rootDataHost=this.dataHost._rootDataHost||this.dataHost);return b},_headerTemplateChanged:function(b){this.fire("property-changed",{path:"headerTemplate",value:b})},_footerTemplateChanged:function(b){this.fire("property-changed",{path:"footerTemplate",value:b})},_flexGrowChanged:function(b){this.fire("property-changed",{path:"flexGrow",value:b})},_widthChanged:function(b){this.fire("property-changed",
{path:"width",value:b})},_lastFrozenChanged:function(b){this.fire("property-changed",{path:"lastFrozen",value:b})}};
vaadin.elements.grid.ColumnBehaviorImpl={properties:{width:{type:String,value:"100px"},flexGrow:{type:Number,value:1},template:{type:Object}},observers:"_flexGrowChanged(flexGrow);_widthChanged(width);_templateChanged(template);_frozenChanged(frozen, isAttached);_hiddenChanged(hidden);_orderChanged(_order);_reorderStatusChanged(_reorderStatus);_resizableChanged(resizable)".split(";"),_frozenChanged:function(b,d){void 0!==b&&void 0!==d&&(void 0===this._oldFrozen&&!1===b||this.fire("property-changed",
{path:"frozen",value:b}),this._oldFrozen=b)},_templateChanged:function(b){b&&b.templatizer&&Polymer.dom(this.root).appendChild(b.templatizer);this.fire("property-changed",{path:"template",value:b},{bubbles:!1})},_hiddenChanged:function(b){this.fire("property-changed",{path:"hidden",value:b})},_orderChanged:function(b){this.fire("property-changed",{path:"order",value:b})},_reorderStatusChanged:function(b){this.fire("property-changed",{path:"reorderStatus",value:b})},_resizableChanged:function(b){this.fire("property-changed",
{path:"resizable",value:b})}};vaadin.elements.grid.ColumnBehavior=[vaadin.elements.grid.ColumnBaseBehavior,vaadin.elements.grid.ColumnBehaviorImpl];

//# sourceURL=build://vaadin-grid/vaadin-grid-column.html-2.js
Polymer({is:"vaadin-grid-column",behaviors:[vaadin.elements.grid.ColumnBehavior]});

//# sourceURL=build://vaadin-grid/vaadin-grid-array-data-provider-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.ArrayDataProviderBehavior={properties:{items:Array},observers:["_itemsChanged(items, items.*)"],_itemsChanged:function(b,d){void 0!==b&&void 0!==d&&(this.size=(b||[]).length,this.dataProvider=this.dataProvider||this._arrayDataProvider,this.clearCache())},_arrayDataProvider:function(b,d){var f=(this.items||[]).slice(0);this._checkPaths(this._filters,"filtering",f)&&(f=this._filter(f));this.size=f.length;b.sortOrders.length&&this._checkPaths(this._sorters,"sorting",f)&&(f=f.sort(this._multiSort.bind(this)));
var h=b.page*b.pageSize;d(f.slice(h,h+b.pageSize),f.length)},_checkPaths:function(b,d,f){if(!f.length)return!1;var h=!0,k;for(k in b){var t=b[k].path;if(t&&-1!==t.indexOf(".")){var l=t.replace(/\.[^\.]*$/,"");void 0===Polymer.Base.get(l,f[0])&&(console.warn('Path "'+t+'" used for '+d+" does not exist in all of the items, "+d+" is disabled."),h=!1)}}return h},_multiSort:function(b,d){return this._sorters.map(function(f){return"asc"===f.direction?this._compare(Polymer.Base.get(f.path,b),Polymer.Base.get(f.path,
d)):"desc"===f.direction?this._compare(Polymer.Base.get(f.path,d),Polymer.Base.get(f.path,b)):0},this).reduce(function(f,h){return f?f:h},0)},_normalizeEmptyValue:function(b){return 0<=[void 0,null].indexOf(b)?"":isNaN(b)?b.toString():b},_compare:function(b,d){b=this._normalizeEmptyValue(b);d=this._normalizeEmptyValue(d);return b<d?-1:b>d?1:0},_filter:function(b){return b.filter(function(d){return 0===this._filters.filter(function(f){return-1===this._normalizeEmptyValue(Polymer.Base.get(f.path,d)).toString().toLowerCase().indexOf(f.value.toString().toLowerCase())}.bind(this)).length},
this)}};

//# sourceURL=build://vaadin-grid/vaadin-grid-dynamic-columns-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.DynamicColumnsBehavior={ready:function(){this._addNodeObserver()},_hasColumnGroups:function(b){for(var d=0;d<b.length;d++)if("vaadin-grid-column-group"===b[d].localName)return!0;return!1},_getChildColumns:function(b){return Polymer.dom(b).queryDistributedElements("vaadin-grid-column, vaadin-grid-column-group, vaadin-grid-selection-column")},_flattenColumnGroups:function(b){return b.map(function(d){return"vaadin-grid-column-group"===d.localName?this._getChildColumns(d):[d]},this).reduce(function(d,
f){return d.concat(f)},[])},_getColumnTree:function(){for(var b=[],d=this.queryAllEffectiveChildren("vaadin-grid-column, vaadin-grid-column-group, vaadin-grid-selection-column");;){b.push(d);if(!this._hasColumnGroups(d))break;d=this._flattenColumnGroups(d)}return b},_updateColumnTree:function(){var b=this._getColumnTree();this._arrayEquals(b,this._columnTree)||(this._columnTree=b)},_addNodeObserver:function(){this._observer=Polymer.dom(this).observeNodes(function(b){function d(f){return f.nodeType===
Node.ELEMENT_NODE&&/^vaadin-grid-(column|selection)/i.test(f.localName)}(0<b.addedNodes.filter(d).length||0<b.removedNodes.filter(d).length)&&this._updateColumnTree();(Polymer.Settings.useNativeShadow||Polymer.Settings.useShadow)&&Polymer.dom(this).appendChild(this.$.footerFocusTrap);this.debounce("check-imports",this._checkImports,2E3)}.bind(this))},_arrayEquals:function(b,d){if(!b||!d||b.length!=d.length)return!1;for(var f=0,h=b.length;f<h;f++)if(b[f]instanceof Array&&d[f]instanceof Array){if(!this._arrayEquals(b[f],
d[f]))return!1}else if(b[f]!=d[f])return!1;return!0},_checkImports:function(){["vaadin-grid-column-group","vaadin-grid-sorter","vaadin-grid-filter","vaadin-grid-selection-column"].forEach(function(b){var d=Polymer.dom(this).querySelector(b);!d||(Polymer.isInstance?Polymer.isInstance(d):d instanceof Polymer.Element)||console.warn("Make sure you have imported the required module for \x3c"+b+"\x3e element.")},this)}};

//# sourceURL=build://vaadin-grid/vaadin-grid-sort-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};
vaadin.elements.grid.SortBehavior={properties:{multiSort:{type:Boolean,value:!1},_sorters:{type:Array,value:function(){return[]}},_previousSorters:{type:Array,value:function(){return[]}}},listeners:{"sorter-changed":"_onSorterChanged"},ready:function(){Polymer.Element&&!Polymer.Settings.useNativeShadow&&this.async(function(){var b=Polymer.dom(this).querySelectorAll("vaadin-grid-sorter");Array.prototype.forEach.call(b,function(d){d.fire&&d.fire("sorter-changed")})})},_onSorterChanged:function(b){var d=
b.target;this._removeArrayItem(this._sorters,d);d._order=null;this.multiSort?(d.direction&&this._sorters.unshift(d),this._sorters.forEach(function(f,h){f._order=1<this._sorters.length?h:null},this)):(this._sorters.forEach(function(f){f._order=null;f.direction=null}),d.direction&&(this._sorters=[d]));b.stopPropagation();this.dataProvider&&JSON.stringify(this._previousSorters)!==JSON.stringify(this._mapSorters())&&this.clearCache();this._previousSorters=this._mapSorters()},_mapSorters:function(){return this._sorters.map(function(b){return{path:b.path,
direction:b.direction}})},_removeArrayItem:function(b,d){d=b.indexOf(d);-1<d&&b.splice(d,1)}};

//# sourceURL=build://vaadin-grid/vaadin-grid-filter-behavior.html.js
window.vaadin=window.vaadin||{};vaadin.elements=vaadin.elements||{};vaadin.elements.grid=vaadin.elements.grid||{};vaadin.elements.grid.FilterBehavior={properties:{_filters:{type:Array,value:function(){return[]}}},listeners:{"filter-changed":"_filterChanged"},_filterChanged:function(b){-1===this._filters.indexOf(b.target)&&this._filters.push(b.target);b.stopPropagation();this.dataProvider&&this.clearCache()},_mapFilters:function(){return this._filters.map(function(b){return{path:b.path,value:b.value}})}};

//# sourceURL=build://vaadin-grid/vaadin-grid.html.js
Polymer({is:"vaadin-grid",properties:{_columnTree:{type:Array,notify:!0},size:Number,_rowDetailsTemplate:Object,_bindData:{type:Object,value:function(){return this._getItem.bind(this)}}},behaviors:[Polymer.IronA11yKeysBehavior,Polymer.IronResizableBehavior,vaadin.elements.grid.ActiveItemBehavior,vaadin.elements.grid.RowDetailsBehavior,vaadin.elements.grid.DataProviderBehavior,vaadin.elements.grid.DynamicColumnsBehavior,vaadin.elements.grid.ArrayDataProviderBehavior,vaadin.elements.grid.SelectionBehavior,
vaadin.elements.grid.SortBehavior,vaadin.elements.grid.FilterBehavior,vaadin.elements.grid.ColumnReorderingBehavior,vaadin.elements.grid.TableKeyboardBehavior],listeners:{"property-changed":"_columnPropChanged","iron-resize":"_gridResizeHandler"},_updateItem:function(b,d){b.style.minHeight=d?"":this.$.scroller._physicalAverage+"px";b.item=d;b.selected=this._isSelected(d);b.expanded=this._isExpanded(d);b.active=null!==d&&d==this.activeItem;b.focused=b.index===this.$.items._focusedRowIndex},_getContentTarget:function(){return this},
ready:function(){this._updateColumnTree();this._rowDetailsTemplate=Polymer.dom(this).querySelector("template.row-details")||void 0;this.$.scroller.target=this;null===document.doctype&&console.warn('\x3cvaadin-grid\x3e requires the "standards mode" declaration. Please add \x3c!DOCTYPE html\x3e to the HTML document.')},_columnPropChanged:function(b){"_childColumns"===b.detail.path&&this._updateColumnTree();b.stopPropagation()},_gridResizeHandler:function(){this.$.scroller._gridResizeHandler()}});

//# sourceURL=build://tf-hparams-session-group-details/tf-hparams-session-group-details.html.js
Polymer({is:"tf-hparams-session-group-details",properties:{backend:Object,experimentName:String,visibleSchema:Object,sessionGroup:Object,_xType:{type:String,value:rg.XType.STEP},_noMultiExperiments:{type:Boolean,value:!1},_indexOfSession:Object,_sessionGroupNameHash:Number,_requestData:{type:Function,value:function(){return({tag:b,run:d})=>this.backend.listMetricEvals({experimentName:this.experimentName,sessionName:d,metricName:b})}},_colorScale:{type:Object,value:function(){return{scale:b=>{b=JSON.parse(b)[1];
b=this._indexOfSession.get(b);const d=pf.standard;return d[(this._sessionGroupNameHash+b)%d.length]}}}}},behaviors:[Polymer.IronResizableBehavior],listeners:{"iron-resize":"redraw"},observers:["_sessionGroupChanged(sessionGroup.*)"],redraw(){Polymer.dom(this.root).querySelectorAll("tf-scalar-card").forEach(b=>b.redraw())},_sessionGroupChanged(){this.sessionGroup?(this._indexOfSession=new Map(this.sessionGroup.sessions.map((b,d)=>[b.name,d])),this._sessionGroupNameHash=tf.hparams.utils.hashOfString(this.sessionGroup.name)):
(this._indexOfSession=new Map,this._sessionGroupNameHash=0);Polymer.dom(this.root).querySelectorAll("tf-scalar-card").forEach(b=>{const d=b.get("tag");b.set("tag","");b.set("tag",d)})},_haveMetrics(){return this.visibleSchema&&Array.isArray(this.visibleSchema.metricInfos)&&0<this.visibleSchema.metricInfos.length},_haveMetricsAndSessionGroup(){return this.sessionGroup&&this._haveMetrics()},_computeSeriesForSessionGroupMetric(b,d){return null===b||null===d?[]:b.sessions.filter(f=>void 0!==tf.hparams.utils.metricValueByName(f.metricValues,
d.name)).map(f=>({tag:d.name,run:f.name}))},_computeTagMetadata(b){return{displayName:tf.hparams.utils.metricName(b),description:b.description||""}}});

//# sourceURL=build://tf-hparams-table-view/tf-hparams-table-view.html.js
Polymer({is:"tf-hparams-table-view",properties:{visibleSchema:Object,sessionGroups:Array,enableShowMetrics:Boolean,backend:Object,experimentName:String},observers:["_visibleSchemaOrSessionGroupsChanged(visibleSchema.*, sessionGroups.*)"],_visibleSchemaOrSessionGroupsChanged(){const b=this.$.sessionGroupsTable.get("expandedItems");this.$.sessionGroupsTable.set("expandedItems",[]);Polymer.dom.flush();const d=new Map;this.sessionGroups.forEach(f=>{d.set(f.name,f)});this.$.sessionGroupsTable.set("expandedItems",
b.map(f=>d.get(f.name)).filter(Boolean))},_hparamName:tf.hparams.utils.hparamName,_metricName:tf.hparams.utils.metricName,_sessionGroupHParam(b,d){return null!=b&&Object.prototype.hasOwnProperty.call(b.hparams,d)?tf.hparams.utils.prettyPrint(b.hparams[d]):""},_sessionGroupMetric(b,d){if(null==b)return null;for(let f=0;f<b.metricValues.length;++f){let h=b.metricValues[f];if(h.name.group===d.group&&h.name.tag==d.tag)return tf.hparams.utils.prettyPrint(h.value)}return""},_rowNumber(b){return b+1}});

//# sourceURL=build://tf-hparams-session-group-values/tf-hparams-session-group-values.html.js
Polymer({is:"tf-hparams-session-group-values",properties:{sessionGroup:{type:Object,value:null},visibleSchema:{type:Object,value:null}},_propertiesArePopulated:function(b,d){return void 0!==b&&null!==b&&void 0!==d&&null!==d},_singletonSessionGroups:function(b){return null===b||void 0===b?[]:[b]}});

//# sourceURL=build://tf-hparams-parallel-coords-plot/utils.html.js
(function(b){(function(d){(function(f){function h(k,t,l){function p(){if(0===k.length)return[1,2];const [m,n]=d3.extent(k);return m!==n?[m,n]:0<m?[.5*m,1.5*m]:0>m?[1.5*m,.5*m]:[-1,1]}if("LINEAR"===l)return d3.scaleLinear().domain(p()).range([t,0]);if("LOG"===l)return l=p(),0>=l[0]&&0<=l[1]?h(k,t,"LINEAR"):d3.scaleLog().domain(l).range([t,0]);if("QUANTILE"===l)return l=d3.range(20).map(m=>t-m*t/19),0===k.length&&(k=[1]),d3.scaleQuantile().domain(_.uniq(k)).range(l);if("NON_NUMERIC"===l)return d3.scalePoint().domain(_.uniq(k.sort())).range([t,
0]).padding(.1);throw RangeError("Unknown scale: "+l);}f.findClosestPath=function(k,t,l){function p(y,w,C,G){const D=y-C,B=w-G;C=m-C;G=n-G;const I=(D*C+B*G)/(D*D+B*B);return 0>=I?b.hparams.utils.l2NormSquared(C,G):1<=I?b.hparams.utils.l2NormSquared(y-m,w-n):b.hparams.utils.l2NormSquared(C-I*D,G-I*B)}if(2>t.length)return console.error("Less than two axes in parallel coordinates plot."),null;const m=l[0],n=l[1];if(m<=t[0]||m>=t[t.length-1])return null;const q=_.sortedIndex(t,m);console.assert(0<q);
console.assert(q<t.length);const u=q-1;let x=null,A=null;k.forEach(y=>{const w=p(y.controlPoints[u][0],y.controlPoints[u][1],y.controlPoints[q][0],y.controlPoints[q][1]);100<w||!(null===x||w<x)||(x=w,A=y)});return A};f.pointScaleInverseImage=function(k,t,l){return k.domain().filter(p=>{p=k(p);return t<=p&&p<=l})};f.quantileScaleInverseImage=function(k,t,l){const p=k.range(),m=p.filter(n=>t<=n&&n<=l).map(n=>{const q=k.invertExtent(n);return n===p[p.length-1]?[q[0],q[1]+1]:q});return 0==m.length?[0,
0]:d3.extent(d3.merge(m))};f.continuousScaleInverseImage=function(k,t,l){return[k.invert(t),k.invert(l)].sort((p,m)=>p-m)};f.createAxisScale=h})(d.parallel_coords_plot||(d.parallel_coords_plot={}))})(b.hparams||(b.hparams={}))})(tf||(tf={}));

//# sourceURL=build://tf-hparams-parallel-coords-plot/axes.js
(function(b){(function(d){(function(f){function h(q){return null!==q.sourceEvent}let k;(function(q){q.LINEAR="LINEAR";q.LOG="LOG";q.QUANTILE="QUANTILE";q.NON_NUMERIC="NON_NUMERIC"})(k=f.ScaleType||(f.ScaleType={}));class t{isPassing(){return!0}}class l{constructor(q,u,x,A){this._lower=q;this._upper=u;this._lowerOpen=x;this._upperOpen=A}isPassing(q){return this._before(this._lower,q,!this._lowerOpen)&&this._before(q,this._upper,!this._upperOpen)}_before(q,u,x){return x?q<=u:q<u}}class p{constructor(q){this._domainSet=
q}isPassing(q){return-1!==this._domainSet.findIndex(u=>u===q)}}class m{constructor(q,u,x,A){this._svgProps=q;this._schema=u;this._interactionManager=x;this._colIndex=A;this._isDisplayed=!1;this._scaleType=this._yScale=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(q){this._brushSelection=q;this._brushFilter=this._buildBrushFilter(this.brushSelection(),
this.scaleType(),this.yScale())}setDomainAndScale(q,u){this._scaleType=u;this._yScale=b.hparams.parallel_coords_plot.createAxisScale(q.slice(),this._svgProps.height,this.scaleType());this._brushFilter=this._buildBrushFilter(this.brushSelection(),this.scaleType(),this.yScale())}brushFilter(){return this._brushFilter}updateDOM(q){var u=d3.axisLeft(this.yScale());this.scaleType()===k.QUANTILE&&(u=u.tickValues(this.yScale().quantiles()).tickFormat(d3.format("-.6g")));var x=d3.select(q);x.selectAll("g").remove();
x.append("g").classed("axis",!0).call(u).append("text").classed("axis-title",!0).style("cursor","move").style("text-anchor","middle").attr("y",-9).text(A=>b.hparams.utils.schemaColumnName(this._schema,A));x.call(d3.drag().on("start",()=>{q.setAttribute("is-dragging","");this._interactionManager.onDragStart(this.colIndex())}).on("drag",()=>this._interactionManager.onDrag(d3.event.x)).on("end",()=>{this._interactionManager.onDragEnd();q.removeAttribute("is-dragging")}));u=d3.brushY().extent([[-8,0],
[8,this._svgProps.height+1]]).on("start",()=>{h(d3.event)&&(q.setAttribute("is-brushing",""),this._interactionManager.onBrushChanged(this.colIndex()))}).on("brush",()=>{if(h(d3.event))this._interactionManager.onBrushChanged(this.colIndex())}).on("end",()=>{h(d3.event)&&(this._interactionManager.onBrushChanged(this.colIndex()),q.removeAttribute("is-brushing"))});x=d3.select(q).append("g").classed("brush",!0);x.call(u);u.move(x,this.brushSelection())}setDisplayed(q){this._isDisplayed=q}_buildBrushFilter(q,
u,x){if(null===q)return new t;if(null===u)return console.error("Scale type is null, but brushSelection isn't: ",q),new t;switch(u){case k.LINEAR:case k.LOG:{const [A,y]=b.hparams.parallel_coords_plot.continuousScaleInverseImage(x,q[0],q[1]);return new l(A,y,!1,!1)}case k.QUANTILE:{const [A,y]=b.hparams.parallel_coords_plot.quantileScaleInverseImage(x,q[0],q[1]);return new l(A,y,!1,!0)}case k.NON_NUMERIC:return new p(b.hparams.parallel_coords_plot.pointScaleInverseImage(x,q[0],q[1]))}console.error("Unknown scale type: ",
u);return new t}}f.Axis=m;class n{constructor(q,u,x){this._svgProps=q;this._schema=u;this._axes=this._createAxes(x);this._stationaryAxesPositions=d3.scalePoint().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(q,u){console.assert(!this.isAxisDragging());const x=new Set;q.columns.forEach(y=>{const w=y.absoluteIndex;let C=this._axes[w];C.setDisplayed(!0);
const G=u.map(D=>b.hparams.utils.columnValueByIndex(this._schema,D,w));C.setDomainAndScale(G,y.scale);x.add(w)});this._axes.forEach(y=>{x.has(y.colIndex())||y.setDisplayed(!1)});this._updateStationaryAxesPositions(x);this._parentsSel=this._parentsSel.data(Array.from(x),y=>y);this._parentsSel.exit().remove();this._parentsSel=this._parentsSel.enter().append("g").classed("axis-parent",!0).merge(this._parentsSel);const A=this;this._parentsSel.call(y=>this._updateAxesPositionsInDOM(y)).each(function(y){A._axes[y].updateDOM(this)})}mapVisibleAxes(q){return this._stationaryAxesPositions.domain().map(u=>
q(this.getAxisPosition(u),this._axes[u]))}allVisibleAxesSatisfy(q){return this._stationaryAxesPositions.domain().every(u=>q(this.getAxisPosition(u),this._axes[u]))}getAxisForColIndex(q){return this._axes[q]}dragStart(q){console.assert(!this.isAxisDragging());console.assert(this._axes[q].isDisplayed());this._draggedAxis=this._axes[q];this._draggedAxisPosition=this._stationaryAxesPositions(q)}drag(q){this._draggedAxisPosition=q=Math.min(Math.max(q,0),this._svgProps.width);q=this._stationaryAxesPositions.domain();
q.sort((u,x)=>this.getAxisPosition(u)-this.getAxisPosition(x));this._stationaryAxesPositions.domain(q);this._updateAxesPositionsInDOM(this._parentsSel)}dragEnd(){console.assert(this.isAxisDragging());this._draggedAxis=this._draggedAxisPosition=null;this._updateAxesPositionsInDOM(this._parentsSel.transition().duration(500))}isAxisDragging(){return null!==this._draggedAxis}getAxisPosition(q){return null!==this._draggedAxis&&this._draggedAxis.colIndex()===q?this._draggedAxisPosition:this._stationaryAxesPositions(q)}_updateStationaryAxesPositions(q){var u=
this._stationaryAxesPositions.domain().filter(x=>q.has(x));u=Array.from(new Set([...u,...Array.from(q)]));this._stationaryAxesPositions.domain(u)}_updateAxesPositionsInDOM(q){q.attr("transform",u=>b.hparams.utils.translateStr(this.getAxisPosition(u)))}_createAxes(q){return d3.range(b.hparams.utils.numColumns(this._schema)).map(u=>new m(this._svgProps,this._schema,q,u))}}f.AxesCollection=n})(d.parallel_coords_plot||(d.parallel_coords_plot={}))})(b.hparams||(b.hparams={}))})(tf||(tf={}));

//# sourceURL=build://tf-hparams-parallel-coords-plot/lines.js
(function(b){(function(d){(function(f){let h;(function(l){l[l.FOREGROUND=0]="FOREGROUND";l[l.BACKGROUND=1]="BACKGROUND"})(h=f.LineType||(f.LineType={}));class k{constructor(l){void 0===l&&(l=d3.selectAll(null));console.assert(1>=l.size());this._sessionGroupSel=l}sessionGroup(){return 1===this._sessionGroupSel.size()?this._sessionGroupSel.datum():null}isNull(){return null===this.sessionGroup()}selection(){return this._sessionGroupSel}equalsTo(l){return this.isNull()?l.isNull():l.isNull()?!1:l.sessionGroup().name==
this.sessionGroup().name}}f.SessionGroupHandle=k;class t{constructor(l,p,m){this._svgProps=l;this._schema=p;this._axesCollection=m;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 k;this._selectedSessionGroupHandle=new k;this._d3line=d3.line().curve(d3.curveLinear)}getSessionGroupHandle(l){return null===l||void 0===l?new k:new k(this._fgPathsSel.filter(p=>p.name===l.name))}hideBackgroundLines(){this._bgPathsSel.attr("visibility","hidden")}showBackgroundLines(){this._bgPathsSel.attr("visibility",null)}peakedSessionGroupHandle(){return this._peakedSessionGroupHandle}selectedSessionGroupHandle(){return this._selectedSessionGroupHandle}recomputeControlPoints(l,p=0){(l===h.FOREGROUND?
this._fgPathsSel:this._bgPathsSel).transition().duration(p).attr("d",m=>this._pathDAttribute(m));l===h.FOREGROUND&&window.setTimeout(()=>{const m=this;this._fgPathsSel.each(function(n){m._setControlPointsProperty(this,n)})})}recomputeForegroundLinesVisibility(){this._fgPathsSel.classed("invisible-path",l=>!this._axesCollection.allVisibleAxesSatisfy((p,m)=>m.brushFilter().isPassing(b.hparams.utils.columnValueByIndex(this._schema,l,m.colIndex()))));this._updateVisibleFgPathsSel()}setForegroundLinesColor(l,
p,m){l=this._createLineColorFunction(l,p,m);this._fgPathsSel.attr("stroke",l)}redraw(l,p,m,n){const q=this._peakedSessionGroupHandle.sessionGroup(),u=this._selectedSessionGroupHandle.sessionGroup();this._sessionGroups=l;this._fgPathsSel=this._recomputePathSelection(this._fgPathsSel);this._bgPathsSel=this._recomputePathSelection(this._bgPathsSel);this._peakedSessionGroupHandle=this.getSessionGroupHandle(q);this._selectedSessionGroupHandle=this.getSessionGroupHandle(u);this.recomputeControlPoints(h.FOREGROUND);
this.recomputeControlPoints(h.BACKGROUND);this.recomputeForegroundLinesVisibility();this.setForegroundLinesColor(p,m,n)}updatePeakedSessionGroup(l){this._peakedSessionGroupHandle.selection().classed("peaked-path",!1);this._peakedSessionGroupHandle=l;this._peakedSessionGroupHandle.selection().classed("peaked-path",!0)}clearPeakedSessionGroup(){this.updatePeakedSessionGroup(new k)}updateSelectedSessionGroup(l){this._selectedSessionGroupHandle.selection().classed("selected-path",!1);this._selectedSessionGroupHandle=
l;this._selectedSessionGroupHandle.selection().classed("selected-path",!0)}findClosestSessionGroup(l,p){const m=this._axesCollection.mapVisibleAxes(n=>n);l=b.hparams.parallel_coords_plot.findClosestPath(this._visibleFgPathsSel.nodes(),m,[l,p]);return null===l?new k:new k(d3.select(l))}_createLineColorFunction(l,p,m){if(null===l)return()=>"red";const n=d3.scaleLinear().domain(b.hparams.utils.numericColumnExtent(this._schema,this._sessionGroups,l)).range([p,m]).interpolate(d3.interpolateLab);return q=>
n(b.hparams.utils.columnValueByIndex(this._schema,q,l))}_recomputePathSelection(l){l=l.data(this._sessionGroups,p=>p.name);l.exit().remove();return l.enter().append("path").merge(l)}_setControlPointsProperty(l,p){l.controlPoints=this._computeControlPoints(p)}_computeControlPoints(l){return this._axesCollection.mapVisibleAxes((p,m)=>[p,m.yScale()(b.hparams.utils.columnValueByIndex(this._schema,l,m.colIndex()))])}_pathDAttribute(l){return this._d3line(this._computeControlPoints(l))}_updateVisibleFgPathsSel(){this._visibleFgPathsSel=
this._fgPathsSel.filter(":not(.invisible-path)")}}f.LinesCollection=t})(d.parallel_coords_plot||(d.parallel_coords_plot={}))})(b.hparams||(b.hparams={}))})(tf||(tf={}));

//# sourceURL=build://tf-hparams-parallel-coords-plot/interaction_manager.js
(function(b){(function(d){(function(f){class h{constructor(t,l){this.svg=d3.select(t);t=100*l+20;this.svg.attr("viewBox",`0 0 ${t} ${240}`);this.svg.attr("preserveAspectRatio","xMidYMid");this.svg.style("min-width",t+"px");this.svg.style("min-height","240px");this.width=t-10-10;this.height=200;this.svgG=this.svg.append("g").attr("transform",b.hparams.utils.translateStr(10,30))}}f.SVGProperties=h;class k{constructor(t,l,p,m){this._svgProps=t;this._schema=l;this._peakedSessionGroupChangedCB=p;this._selectedSessionGroupChangedCB=
m;this._axesCollection=new f.AxesCollection(t,l,this);this._linesCollection=new f.LinesCollection(t,l,this._axesCollection);this._svgProps.svg.on("click",()=>this.onClick()).on("mousemove mouseenter",()=>{const [n,q]=d3.mouse(this._svgProps.svgG.node());this.onMouseMoved(n,q)}).on("mouseleave",()=>this.onMouseLeave())}onDragStart(t){this._axesCollection.dragStart(t);this._linesCollection.hideBackgroundLines()}onDrag(t){this._axesCollection.drag(t);this._linesCollection.recomputeControlPoints(f.LineType.FOREGROUND)}onDragEnd(){this._axesCollection.dragEnd();
this._linesCollection.recomputeControlPoints(f.LineType.FOREGROUND,500);window.setTimeout(()=>{this._linesCollection.recomputeControlPoints(f.LineType.BACKGROUND);this._linesCollection.showBackgroundLines()},500)}onBrushChanged(t){this._axesCollection.getAxisForColIndex(t).setBrushSelection(d3.event.selection);this._linesCollection.recomputeForegroundLinesVisibility()}onMouseMoved(t,l){this._linesCollection.updatePeakedSessionGroup(this._linesCollection.findClosestSessionGroup(t,l));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 f.SessionGroupHandle):this._linesCollection.updateSelectedSessionGroup(this._linesCollection.peakedSessionGroupHandle());this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}onOptionsOrSessionGroupsChanged(t,
l){this._axesCollection.updateAxes(t,l);const p=this._linesCollection.peakedSessionGroupHandle(),m=this._linesCollection.selectedSessionGroupHandle();this._linesCollection.redraw(l,void 0!==t.colorByColumnIndex?t.columns[t.colorByColumnIndex].absoluteIndex:null,t.minColor,t.maxColor);p.equalsTo(this._linesCollection.peakedSessionGroupHandle())||this._peakedSessionGroupChangedCB(this._linesCollection.peakedSessionGroupHandle().sessionGroup());m.equalsTo(this._linesCollection.selectedSessionGroupHandle())||
this._selectedSessionGroupChangedCB(this._linesCollection.selectedSessionGroupHandle().sessionGroup())}schema(){return this._schema}}f.InteractionManager=k})(d.parallel_coords_plot||(d.parallel_coords_plot={}))})(b.hparams||(b.hparams={}))})(tf||(tf={}));

//# sourceURL=build://tf-hparams-parallel-coords-plot/tf-hparams-parallel-coords-plot.html.js
Polymer({is:"tf-hparams-parallel-coords-plot",properties:{sessionGroups:Array,options:Object,selectedSessionGroup:{type:Object,value:null,readOnly:!0,notify:!0},closestSessionGroup:{type:Object,value:null,readOnly:!0,notify:!0},redrawCount:{type:Number,value:0},_validSessionGroups:Array,_interactionManager:Object},observers:["_optionsOrSessionGroupsChanged(options.*, sessionGroups.*)"],_optionsOrSessionGroupsChanged(){if(null!==this.options){var b=this.options.configuration;if(void 0===this._interactionManager||
!_.isEqual(this._interactionManager.schema(),b.schema)){d3.select(this.$.svg).selectAll("*").remove();const d=new tf.hparams.parallel_coords_plot.SVGProperties(this.$.svg,tf.hparams.utils.numColumns(b.schema));this.scopeSubtree(this.$.svg,!0);this._interactionManager=new tf.hparams.parallel_coords_plot.InteractionManager(d,b.schema,f=>this.closestSessionGroupChanged(f),f=>this.selectedSessionGroupChanged(f))}this._computeValidSessionGroups();this._interactionManager.onOptionsOrSessionGroupsChanged(this.options,
this._validSessionGroups);this.redrawCount++}},closestSessionGroupChanged(b){this._setClosestSessionGroup(b)},selectedSessionGroupChanged(b){this._setSelectedSessionGroup(b)},_computeValidSessionGroups(){const b=tf.hparams.utils;if(void 0===this.sessionGroups)this._validSessionGroups=void 0;else{var d=this.options.configuration.schema;this._validSessionGroups=this.sessionGroups.filter(f=>{for(let h=0;h<b.numColumns(d);++h)if(this.options.configuration.columnsVisibility[h]&&void 0===b.columnValueByIndex(d,
f,h))return!1;return!0})}}});

//# sourceURL=build://tf-hparams-parallel-coords-view/tf-hparams-parallel-coords-view.html.js
Polymer({is:"tf-hparams-parallel-coords-view",properties:{backend:Object,experimentName:String,configuration:Object,sessionGroups:Array},_closestOrSelected:function(b,d){return null!==b?b:d}});

//# sourceURL=build://tf-hparams-scatter-plot-matrix-plot/tf-hparams-scatter-plot-matrix-plot.html.js
Polymer({is:"tf-hparams-scatter-plot-matrix-plot",properties:{visibleSchema:Object,sessionGroups:Array,options:Object,selectedSessionGroup:{type:Object,value:null,readOnly:!0,notify:!0},closestSessionGroup:{type:Object,value:null,readOnly:!0,notify:!0},_container:{type:Object,value:null},_svg:{type:Object,value:null},width:{type:Number,value:0},height:{type:Number,value:0},_brushedCellIndex:{type:Object,value:null},_brushSelection:{type:Object,value:null}},observers:["_sessionGroupsChanged(sessionGroups.*)",
"_visibleSchemaChanged(visibleSchema.*)","_redraw(options.*)"],ready(){this._container=this.$.container;this._svg=d3.select(this.$.svg);this._redraw()},_sessionGroupsChanged(){null!==this.selectedSessionGroup&&this._setSelectedSessionGroup(tf.hparams.utils.sessionGroupWithName(this.sessionGroups,this.selectedSessionGroup.name)||null);this._redraw()},_visibleSchemaChanged(){this._brushSelection=this._brushedCellIndex=null;this._redraw()},_redraw(){this.debounce("_redraw",()=>{const b=tf.hparams.utils;
this.width=Math.max(150*b.numVisibleColumns(this.visibleSchema),1200);this.height=Math.max(112.5*b.numVisibleMetrics(this.visibleSchema),480);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(){function b(ka){return"x-axis-clip-path-"+ka}function d(ka){return"x-label-clip-path-"+ka}function f(ka){return"y-axis-clip-path-"+ka}function h(ka){return"y-label-clip-path-"+
ka}function k(ka,Y,Ea,va,xa){Ea=Math.floor(Ea/va);va=Y.scale();if("QUANTILE"===xa){let Aa=va.quantiles();Aa=d3.range(0,Aa.length,Math.ceil(Aa.length/Ea)).map(Fa=>Aa[Fa]);Y.tickValues(Aa).tickFormat(d3.format("-.2g"))}"LINEAR"!==xa&&"LOG"!==xa||Y.ticks(Ea);ka.call(Y);ka.selectAll(".domain").remove();ka.selectAll(".tick line").attr("stroke","#ddd")}function t(ka,Y){return O[Y](w._colValue(ka,Y))}function l(ka,Y){return H[Y](w._metricValue(ka,Y))}function p(ka,Y){const Ea=[];T[ka][Y].each(function(){Ea.push(this)});
return d3.quadtree().x(va=>d3.select(va).datum().x).y(va=>d3.select(va).datum().y).addAll(Ea)}function m(){let ka=new Set(Q.nodes());x()||(ka=n(w._brushedCellIndex,w._brushSelection));d3.selectAll(Array.from(y.filterSet(ka,Y=>!Z.has(Y)))).attr("fill",L);d3.selectAll(Array.from(y.filterSet(Z,Y=>!ka.has(Y)))).attr("fill","#ddd");Z=ka}function n(ka,Y){console.assert(null!==ka);console.assert(null!==Y);const [Ea,va]=ka,xa=new Set;y.quadTreeVisitPointsInRect(aa[Ea][va],Y[0][0],Y[0][1],Y[1][0],Y[1][1],
Aa=>{d3.select(Aa).datum().sessionGroupMarkers.forEach(Fa=>{xa.add(Fa)})});return xa}function q(ka){const Y=d3.brushSelection(ka);!u()&&null===Y||u()&&ka===la.node()&&_.isEqual(Y,w._brushSelection)||(w._brushSelection=Y,null!==Y?(la=d3.select(ka),w._brushedCellIndex=la.datum()):(la=null,w._brushedCellIndex=null),m())}function u(){return null!==w._brushedCellIndex&&null!==w._brushSelection}function x(){return!u()||w._brushSelection[0][0]===w._brushSelection[1][0]||w._brushSelection[0][1]===w._brushSelection[1][1]}
function A(ka,Y,Ea,va,xa){let Aa=Infinity,Fa=null;y.quadTreeVisitPointsInDisk(aa[ka][Y],Ea,va,xa,(ya,Sa)=>{Z.has(ya)&&Sa<Aa&&(ya=d3.select(ya).datum(),Aa=Sa,Fa=ya.sessionGroup)});return null===Fa?null:d3.selectAll(X.get(Fa))}const y=tf.hparams.utils,w=this;if(this.sessionGroups&&0!=this.sessionGroups.length&&this.visibleSchema&&0!=this.visibleSchema.metricInfos.length){var C=d3.range(y.numVisibleColumns(w.visibleSchema)),G=d3.range(y.numVisibleMetrics(w.visibleSchema)),D=d3.scaleBand().domain(C).range([85,
this.width-1-5]).paddingInner(.1),B=d3.scaleBand().domain(G).range([this.height-1-5-50,5]).paddingInner(.1),I=D.bandwidth(),N=B.bandwidth(),O=C.map(ka=>w._cellScale(ka,[0,I-1])),H=G.map(ka=>w._cellScale(ka+y.numVisibleHParams(w.visibleSchema),[N-1,0])),K=this._svg.selectAll(".x-axis").data(C).enter().append("g").classed("x-axis",!0).attr("transform",ka=>y.translateStr(D(ka),0));K.append("clipPath").attr("id",b).append("rect").attr("x",-5).attr("y",0).attr("width",I+10).attr("height",w.height-25);
K.append("clipPath").attr("id",d).append("rect").attr("x",0).attr("y",w.height-25).attr("width",I).attr("height",25);K.append("g").attr("clip-path",ka=>"url(#"+b(ka)+")").each(function(ka){d3.select(this).call(k,d3.axisBottom(O[ka]).tickSize(w.height-50),I,40,w.options.columns[ka].scale)});K.append("g").classed("x-axis-label",!0).attr("clip-path",ka=>"url(#"+d(ka)+")").append("text").attr("text-anchor","middle").attr("x",I/2).attr("y",w.height-1-12.5).text(ka=>y.schemaVisibleColumnName(w.visibleSchema,
ka)).append("title").text(ka=>y.schemaVisibleColumnName(w.visibleSchema,ka));K=this._svg.selectAll(".y-axis").data(G).enter().append("g").classed("y-axis",!0).attr("transform",ka=>y.translateStr(w.width-1,B(ka)));K.append("clipPath").attr("id",f).append("rect").attr("x",-(w.width-40-1)).attr("y",-5).attr("width",w.width-40).attr("height",N+10);K.append("clipPath").attr("id",h).append("rect").attr("x",-(w.width-1)).attr("y",0).attr("width",40).attr("height",N);K.append("g").attr("clip-path",ka=>"url(#"+
f(ka)+")").each(function(ka){d3.select(this).call(k,d3.axisLeft(H[ka]).tickSize(w.width-80),N,20,w.options.columns[ka+y.numVisibleHParams(w.visibleSchema)].scale)});K.append("g").classed("y-axis-label",!0).attr("clip-path",ka=>"url(#"+h(ka)+")").append("text").attr("text-anchor","middle").attr("x",-(w.width-20-1)).attr("y",N/2).attr("transform",y.rotateStr(-(w.width-20-1),N/2)).text(ka=>y.metricName(w.visibleSchema.metricInfos[ka])).append("title").text(ka=>y.metricName(w.visibleSchema.metricInfos[ka]));
K=this._svg.selectAll(".cell").data(d3.cross(C,G)).enter().append("g").classed("cell",!0).attr("transform",([ka,Y])=>y.translateStr(D(ka),B(Y)));K.append("g").classed("frame",!0).append("rect").attr("x",-5).attr("y",-5).attr("width",I+10).attr("height",N+10).attr("stroke","#000").attr("fill","none").attr("shape-rendering","crispEdges");var M=null;void 0!==w.options.colorByColumnIndex&&(M=d3.scaleLinear().domain(this._colExtent(this.options.colorByColumnIndex)).range([this.options.minColor,this.options.maxColor]).interpolate(d3.interpolateLab));
var L=void 0===w.options.colorByColumnIndex?()=>"red":({sessionGroup:ka})=>M(this._colValue(ka,w.options.colorByColumnIndex)),[Q,T,X]=function(ka,Y){const Ea=ka.selectAll(".data-marker").data(([xa,Aa])=>w.sessionGroups.filter(Fa=>void 0!==w._colValue(Fa,xa)&&void 0!==w._metricValue(Fa,Aa)).map(Fa=>({col:xa,metric:Aa,sessionGroup:Fa,x:t(Fa,xa),y:l(Fa,Aa),sessionGroupMarkers:null}))).enter().append("circle").classed("data-marker",!0).attr("cx",({x:xa})=>xa).attr("cy",({y:xa})=>xa).attr("r",2).attr("fill",
Y),va=new Map;w.sessionGroups.forEach(xa=>{va.set(xa,[])});Ea.each(function(xa){va.get(xa.sessionGroup).push(this)});Ea.each(xa=>{const Aa=va.get(xa.sessionGroup);xa.sessionGroupMarkers=new Set(Aa)});ka=C.map(xa=>G.map(Aa=>Ea.filter(Fa=>Fa.col==xa&&Fa.metric==Aa)));return[Ea,ka,va]}(K.append("g"),L),aa=C.map(ka=>G.map(Y=>p(ka,Y))),la=null;u()&&(la=K.filter(ka=>_.isEqual(ka,w._brushedCellIndex)),console.assert(1==la.size(),la));var Z=new Set(Q.nodes());m();var ba=d3.brush().extent([[-4,-4],[I-1+5-
1,N-1+5-1]]).on("start",function(){u()&&la.node()!=this&&ba.move(la,null);q(this)}).on("brush",function(){q(this)}).on("end",function(){q(this)});K.call(ba);u()&&ba.move(la,w._brushSelection);var ea=null,ca=null;null!==this.selectedSessionGroup&&(ca=d3.selectAll(X.get(this.selectedSessionGroup)).classed("selected-marker",!0));K.on("click",function(){var ka=ea===ca?null:ea;ka!==ca&&(null!==ca&&ca.classed("selected-marker",!1),ca=ka,null!==ca&&ca.classed("selected-marker",!0),ka=null===ca?null:ca.datum().sessionGroup,
w._setSelectedSessionGroup(ka))}).on("mousemove mouseenter",function([ka,Y]){const [Ea,va]=d3.mouse(this);ka=A(ka,Y,Ea,va,20);ea!==ka&&(null!==ea&&ea.classed("closest-marker",!1),ea=ka,null!==ea?(ea.classed("closest-marker",!0),w._setClosestSessionGroup(ea.datum().sessionGroup)):w._setClosestSessionGroup(null))}).on("mouseleave",function(){null!==ea&&(ea.classed("closest-marker",!1),ea=null,w._setClosestSessionGroup(null))});this._svg.selectAll("*").classed("tf-hparams-scatter-plot-matrix-plot",!0)}},
_cellScale(b,d){var f=this._colExtent(b);const h=d3.scaleLinear().domain(f).range(d);if("LINEAR"===this.options.columns[b].scale)return h;if("LOG"===this.options.columns[b].scale)return 0>=f[0]&&0<=f[1]?h:d3.scaleLog().domain(f).range(d);if("QUANTILE"===this.options.columns[b].scale){const k=(d[1]-d[0])/19;f=d3.range(20).map(t=>d[0]+k*t);return d3.scaleQuantile().domain(_.uniq(this.sessionGroups.map(t=>this._colValue(t,b)))).range(f)}if("NON_NUMERIC"===this.options.columns[b].scale)return d3.scalePoint().domain(_.uniq(this.sessionGroups.map(k=>
this._colValue(k,b)).sort())).range(d).padding(.1);throw"Unknown scale for column: "+b+". options: "+this.options;},_colValue(b,d){return tf.hparams.utils.columnValueByVisibleIndex(this.visibleSchema,b,d)},_metricValue(b,d){return tf.hparams.utils.metricValueByVisibleIndex(this.visibleSchema,b,d)},_colExtent(b){return tf.hparams.utils.visibleNumericColumnExtent(this.visibleSchema,this.sessionGroups,b)}});

//# sourceURL=build://tf-hparams-scatter-plot-matrix-view/tf-hparams-scatter-plot-matrix-view.html.js
Polymer({is:"tf-hparams-scatter-plot-matrix-view",properties:{backend:Object,experimentName:String,configuration:Object,sessionGroups:Array},_closestOrSelected:function(b,d){return null!==b?b:d}});

//# sourceURL=build://tf-hparams-sessions-pane/tf-hparams-sessions-pane.html.js
Polymer({is:"tf-hparams-sessions-pane",properties:{backend:Object,helpUrl:String,bugReportUrl:String,experimentName:String,configuration:Object,sessionGroups:Array,_selectedTab:{type:Number,value:0}}});

//# sourceURL=build://tf-hparams-google-analytics-tracker/tf-hparams-google-analytics-tracker.html.js
(function(){Polymer({is:"tf-hparams-google-analytics-tracker",handleEvent:function(){}})})();

//# sourceURL=build://tf-hparams-main/tf-hparams-main.html.js
Polymer({is:"tf-hparams-main",properties:{backend:Object,experimentName:String,trackingId:String,helpUrl:String,bugReportUrl:String,_configuration:Object,_sessionGroups:Array,_throttledSendEventToGA:{type:Function,value:()=>_.throttle(function(){this._handleGAEvent({detail:{hitType:"event",eventCategory:"UserInteraction",eventLabel:"Experiment: "+this.experimentName}})},6E4,{leading:!0})}},listeners:{mousemove:"_sendEventToGA",tap:"_sendEventToGA","google-analytics-tracking":"_handleGAEvent"},attached(){this._handleGAEvent({detail:{hitType:"pageview"}})},
reload(){this.$["query-pane"].reload()},_sendEventToGA(){this._throttledSendEventToGA(this)},_handleGAEvent(b){this.$.tracker.handleEvent(b)}});

//# sourceURL=build://tf-hparams-backend/tf-hparams-backend.html.js
(function(b){(function(d){class f{constructor(h,k,t=!0){this._apiUrl=h;this._requestManager=k;this._useHttpGet=t}getExperiment(h){return this._sendRequest("experiment",h)}getDownloadUrl(h,k,t){return this._apiUrl+"/download_data?"+new URLSearchParams({format:h,columnsVisibility:JSON.stringify(t),request:JSON.stringify(k)})}listSessionGroups(h){return this._sendRequest("session_groups",h)}listMetricEvals(h){return this._sendRequest("metric_evals",h)}_sendRequest(h,k){if(this._useHttpGet)return k=encodeURIComponent(JSON.stringify(k)),
this._requestManager.request(this._apiUrl+"/"+h+"?request\x3d"+k);const t=new vc.RequestOptions;t.withCredentials=!0;t.methodType="POST";t.contentType="text/plain";t.body=JSON.stringify(k);return this._requestManager.requestWithOptions(this._apiUrl+"/"+h,t)}}d.Backend=f})(b.hparams||(b.hparams={}))})(tf||(tf={}));

//# sourceURL=build://tf-hparams-dashboard/tf-hparams-dashboard.html.js
(function(){Polymer({is:"tf-hparams-dashboard",properties:{_backend:{type:Object,value:()=>new tf.hparams.Backend(vc.getRouter().pluginRoute("hparams",""),new vc.RequestManager,!!(window.TENSORBOARD_ENV||{}).IN_COLAB)}},reload(){this.$["hparams-main"].reload()}})})();

//# sourceURL=build://tf-imports/three.js
(function(b,d){"object"===typeof exports&&"undefined"!==typeof module?d(exports):"function"===typeof define&&define.amd?define(["exports"],d):(b=b||self,d(b.THREE={}))})(this,function(b){function d(){}function f(a,c){this.x=a||0;this.y=c||0}function h(a,c,e,g){this._x=a||0;this._y=c||0;this._z=e||0;this._w=void 0!==g?g:1}function k(a,c,e){this.x=a||0;this.y=c||0;this.z=e||0}function t(){this.elements=[1,0,0,0,1,0,0,0,1];0<arguments.length&&console.error("THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.")}
function l(a,c,e,g,r,v,z,E,F,J){Object.defineProperty(this,"id",{value:Nk++});this.uuid=hb.generateUUID();this.name="";this.image=void 0!==a?a:l.DEFAULT_IMAGE;this.mipmaps=[];this.mapping=void 0!==c?c:l.DEFAULT_MAPPING;this.wrapS=void 0!==e?e:1001;this.wrapT=void 0!==g?g:1001;this.magFilter=void 0!==r?r:1006;this.minFilter=void 0!==v?v:1008;this.anisotropy=void 0!==F?F:1;this.format=void 0!==z?z:1023;this.type=void 0!==E?E:1009;this.offset=new f(0,0);this.repeat=new f(1,1);this.center=new f(0,0);
this.rotation=0;this.matrixAutoUpdate=!0;this.matrix=new t;this.generateMipmaps=!0;this.premultiplyAlpha=!1;this.flipY=!0;this.unpackAlignment=4;this.encoding=void 0!==J?J:3E3;this.version=0;this.onUpdate=null}function p(a,c,e,g){this.x=a||0;this.y=c||0;this.z=e||0;this.w=void 0!==g?g:1}function m(a,c,e){this.width=a;this.height=c;this.scissor=new p(0,0,a,c);this.scissorTest=!1;this.viewport=new p(0,0,a,c);e=e||{};this.texture=new l(void 0,void 0,e.wrapS,e.wrapT,e.magFilter,e.minFilter,e.format,e.type,
e.anisotropy,e.encoding);this.texture.image={};this.texture.image.width=a;this.texture.image.height=c;this.texture.generateMipmaps=void 0!==e.generateMipmaps?e.generateMipmaps:!1;this.texture.minFilter=void 0!==e.minFilter?e.minFilter:1006;this.depthBuffer=void 0!==e.depthBuffer?e.depthBuffer:!0;this.stencilBuffer=void 0!==e.stencilBuffer?e.stencilBuffer:!0;this.depthTexture=void 0!==e.depthTexture?e.depthTexture:null}function n(a,c,e){m.call(this,a,c,e);this.samples=4}function q(){this.elements=
[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];0<arguments.length&&console.error("THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.")}function u(a,c,e,g){this._x=a||0;this._y=c||0;this._z=e||0;this._order=g||u.DefaultOrder}function x(){this.mask=1}function A(){Object.defineProperty(this,"id",{value:Ok++});this.uuid=hb.generateUUID();this.name="";this.type="Object3D";this.parent=null;this.children=[];this.up=A.DefaultUp.clone();var a=new k,c=new u,e=new h,g=new k(1,1,1);c._onChange(function(){e.setFromEuler(c,
!1)});e._onChange(function(){c.setFromQuaternion(e,void 0,!1)});Object.defineProperties(this,{position:{configurable:!0,enumerable:!0,value:a},rotation:{configurable:!0,enumerable:!0,value:c},quaternion:{configurable:!0,enumerable:!0,value:e},scale:{configurable:!0,enumerable:!0,value:g},modelViewMatrix:{value:new q},normalMatrix:{value:new t}});this.matrix=new q;this.matrixWorld=new q;this.matrixAutoUpdate=A.DefaultMatrixAutoUpdate;this.matrixWorldNeedsUpdate=!1;this.layers=new x;this.visible=!0;
this.receiveShadow=this.castShadow=!1;this.frustumCulled=!0;this.renderOrder=0;this.userData={}}function y(){A.call(this);this.type="Scene";this.overrideMaterial=this.fog=this.background=null;this.autoUpdate=!0;"undefined"!==typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}function w(a,c){this.min=void 0!==a?a:new k(Infinity,Infinity,Infinity);this.max=void 0!==c?c:new k(-Infinity,-Infinity,-Infinity)}function C(a,c,e,g,r){var v;var z=0;for(v=a.length-
3;z<=v;z+=3){Kd.fromArray(a,z);var E=c.dot(Kd),F=e.dot(Kd),J=g.dot(Kd);if(Math.max(-Math.max(E,F,J),Math.min(E,F,J))>r.x*Math.abs(Kd.x)+r.y*Math.abs(Kd.y)+r.z*Math.abs(Kd.z))return!1}return!0}function G(a,c){this.center=void 0!==a?a:new k;this.radius=void 0!==c?c:0}function D(a,c){this.origin=void 0!==a?a:new k;this.direction=void 0!==c?c:new k}function B(a,c,e){this.a=void 0!==a?a:new k;this.b=void 0!==c?c:new k;this.c=void 0!==e?e:new k}function I(a,c,e){return void 0===c&&void 0===e?this.set(a):
this.setRGB(a,c,e)}function N(a,c,e){0>e&&(e+=1);1<e&&--e;return e<1/6?a+6*(c-a)*e:.5>e?c:e<2/3?a+6*(c-a)*(2/3-e):a}function O(a){return.04045>a?.0773993808*a:Math.pow(.9478672986*a+.0521327014,2.4)}function H(a){return.0031308>a?12.92*a:1.055*Math.pow(a,.41666)-.055}function K(a,c,e,g,r,v){this.a=a;this.b=c;this.c=e;this.normal=g&&g.isVector3?g:new k;this.vertexNormals=Array.isArray(g)?g:[];this.color=r&&r.isColor?r:new I;this.vertexColors=Array.isArray(r)?r:[];this.materialIndex=void 0!==v?v:0}
function M(){Object.defineProperty(this,"id",{value:Pk++});this.uuid=hb.generateUUID();this.name="";this.type="Material";this.lights=this.fog=!0;this.blending=1;this.side=0;this.vertexTangents=this.flatShading=!1;this.vertexColors=0;this.opacity=1;this.transparent=!1;this.blendSrc=204;this.blendDst=205;this.blendEquation=100;this.blendEquationAlpha=this.blendDstAlpha=this.blendSrcAlpha=null;this.depthFunc=3;this.depthWrite=this.depthTest=!0;this.stencilFunc=519;this.stencilRef=0;this.stencilMask=
255;this.stencilZPass=this.stencilZFail=this.stencilFail=7680;this.stencilWrite=!1;this.clippingPlanes=null;this.clipShadows=this.clipIntersection=!1;this.shadowSide=null;this.colorWrite=!0;this.precision=null;this.polygonOffset=!1;this.polygonOffsetUnits=this.polygonOffsetFactor=0;this.dithering=!1;this.alphaTest=0;this.premultipliedAlpha=!1;this.toneMapped=this.visible=!0;this.userData={};this.needsUpdate=!0}function L(a){M.call(this);this.type="MeshBasicMaterial";this.color=new I(16777215);this.lightMap=
this.map=null;this.lightMapIntensity=1;this.aoMap=null;this.aoMapIntensity=1;this.envMap=this.alphaMap=this.specularMap=null;this.combine=0;this.reflectivity=1;this.refractionRatio=.98;this.wireframe=!1;this.wireframeLinewidth=1;this.wireframeLinejoin=this.wireframeLinecap="round";this.lights=this.morphTargets=this.skinning=!1;this.setValues(a)}function Q(a,c,e){if(Array.isArray(a))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");this.name="";this.array=a;this.itemSize=
c;this.count=void 0!==a?a.length/c:0;this.normalized=!0===e;this.dynamic=!1;this.updateRange={offset:0,count:-1};this.version=0}function T(a,c,e){Q.call(this,new Int8Array(a),c,e)}function X(a,c,e){Q.call(this,new Uint8Array(a),c,e)}function aa(a,c,e){Q.call(this,new Uint8ClampedArray(a),c,e)}function la(a,c,e){Q.call(this,new Int16Array(a),c,e)}function Z(a,c,e){Q.call(this,new Uint16Array(a),c,e)}function ba(a,c,e){Q.call(this,new Int32Array(a),c,e)}function ea(a,c,e){Q.call(this,new Uint32Array(a),
c,e)}function ca(a,c,e){Q.call(this,new Float32Array(a),c,e)}function ka(a,c,e){Q.call(this,new Float64Array(a),c,e)}function Y(){this.vertices=[];this.normals=[];this.colors=[];this.uvs=[];this.uvs2=[];this.groups=[];this.morphTargets={};this.skinWeights=[];this.skinIndices=[];this.boundingSphere=this.boundingBox=null;this.groupsNeedUpdate=this.uvsNeedUpdate=this.colorsNeedUpdate=this.normalsNeedUpdate=this.verticesNeedUpdate=!1}function Ea(a){if(0===a.length)return-Infinity;for(var c=a[0],e=1,g=
a.length;e<g;++e)a[e]>c&&(c=a[e]);return c}function va(){Object.defineProperty(this,"id",{value:Qk+=2});this.uuid=hb.generateUUID();this.name="";this.type="BufferGeometry";this.index=null;this.attributes={};this.morphAttributes={};this.groups=[];this.boundingSphere=this.boundingBox=null;this.drawRange={start:0,count:Infinity};this.userData={}}function xa(a,c){A.call(this);this.type="Mesh";this.geometry=void 0!==a?a:new va;this.material=void 0!==c?c:new L({color:16777215*Math.random()});this.drawMode=
0;this.updateMorphTargets()}function Aa(a,c,e,g,r,v,z,E){if(null===(1===c.side?g.intersectTriangle(z,v,r,!0,E):g.intersectTriangle(r,v,z,2!==c.side,E)))return null;sg.copy(E);sg.applyMatrix4(a.matrixWorld);c=e.ray.origin.distanceTo(sg);return c<e.near||c>e.far?null:{distance:c,point:sg.clone(),object:a}}function Fa(a,c,e,g,r,v,z,E,F,J,P){Ld.fromBufferAttribute(r,F);Md.fromBufferAttribute(r,J);Nd.fromBufferAttribute(r,P);r=a.morphTargetInfluences;if(c.morphTargets&&v&&r){Ih.set(0,0,0);Jh.set(0,0,0);
Kh.set(0,0,0);for(var R=0,S=v.length;R<S;R++){var V=r[R],W=v[R];0!==V&&($i.fromBufferAttribute(W,F),aj.fromBufferAttribute(W,J),bj.fromBufferAttribute(W,P),Ih.addScaledVector($i.sub(Ld),V),Jh.addScaledVector(aj.sub(Md),V),Kh.addScaledVector(bj.sub(Nd),V))}Ld.add(Ih);Md.add(Jh);Nd.add(Kh)}if(a=Aa(a,c,e,g,Ld,Md,Nd,sf))z&&(oe.fromBufferAttribute(z,F),pe.fromBufferAttribute(z,J),qe.fromBufferAttribute(z,P),a.uv=B.getUV(sf,Ld,Md,Nd,oe,pe,qe,new f)),E&&(oe.fromBufferAttribute(E,F),pe.fromBufferAttribute(E,
J),qe.fromBufferAttribute(E,P),a.uv2=B.getUV(sf,Ld,Md,Nd,oe,pe,qe,new f)),z=new K(F,J,P),B.getNormal(Ld,Md,Nd,z.normal),a.face=z;return a}function ya(){Object.defineProperty(this,"id",{value:Rk+=2});this.uuid=hb.generateUUID();this.name="";this.type="Geometry";this.vertices=[];this.colors=[];this.faces=[];this.faceVertexUvs=[[]];this.morphTargets=[];this.morphNormals=[];this.skinWeights=[];this.skinIndices=[];this.lineDistances=[];this.boundingSphere=this.boundingBox=null;this.groupsNeedUpdate=this.lineDistancesNeedUpdate=
this.colorsNeedUpdate=this.normalsNeedUpdate=this.uvsNeedUpdate=this.verticesNeedUpdate=this.elementsNeedUpdate=!1}function Sa(a,c,e,g,r,v){ya.call(this);this.type="BoxGeometry";this.parameters={width:a,height:c,depth:e,widthSegments:g,heightSegments:r,depthSegments:v};this.fromBufferGeometry(new Xa(a,c,e,g,r,v));this.mergeVertices()}function Xa(a,c,e,g,r,v){function z(W,ha,fa,ra,pa,qa,ua,oa,ta,Ba,Ta){var Ua=qa/ta,Ca=ua/Ba,Ha=qa/2,Da=ua/2,Ma=oa/2;ua=ta+1;var db=Ba+1,tb=qa=0,Ka,bb,jb=new k;for(bb=
0;bb<db;bb++){var Eb=bb*Ca-Da;for(Ka=0;Ka<ua;Ka++)jb[W]=(Ka*Ua-Ha)*ra,jb[ha]=Eb*pa,jb[fa]=Ma,J.push(jb.x,jb.y,jb.z),jb[W]=0,jb[ha]=0,jb[fa]=0<oa?1:-1,P.push(jb.x,jb.y,jb.z),R.push(Ka/ta),R.push(1-bb/Ba),qa+=1}for(bb=0;bb<Ba;bb++)for(Ka=0;Ka<ta;Ka++)W=S+Ka+ua*(bb+1),ha=S+(Ka+1)+ua*(bb+1),fa=S+(Ka+1)+ua*bb,F.push(S+Ka+ua*bb,W,fa),F.push(W,ha,fa),tb+=6;E.addGroup(V,tb,Ta);V+=tb;S+=qa}va.call(this);this.type="BoxBufferGeometry";this.parameters={width:a,height:c,depth:e,widthSegments:g,heightSegments:r,
depthSegments:v};var E=this;a=a||1;c=c||1;e=e||1;g=Math.floor(g)||1;r=Math.floor(r)||1;v=Math.floor(v)||1;var F=[],J=[],P=[],R=[],S=0,V=0;z("z","y","x",-1,-1,e,c,a,v,r,0);z("z","y","x",1,-1,e,c,-a,v,r,1);z("x","z","y",1,1,a,e,c,g,v,2);z("x","z","y",1,-1,a,e,-c,g,v,3);z("x","y","z",1,-1,a,c,e,g,r,4);z("x","y","z",-1,-1,a,c,-e,g,r,5);this.setIndex(F);this.addAttribute("position",new ca(J,3));this.addAttribute("normal",new ca(P,3));this.addAttribute("uv",new ca(R,2))}function ub(a){var c={},e;for(e in a){c[e]=
{};for(var g in a[e]){var r=a[e][g];c[e][g]=r&&(r.isColor||r.isMatrix3||r.isMatrix4||r.isVector2||r.isVector3||r.isVector4||r.isTexture)?r.clone():Array.isArray(r)?r.slice():r}}return c}function Bb(a){for(var c={},e=0;e<a.length;e++){var g=ub(a[e]),r;for(r in g)c[r]=g[r]}return c}function qb(a){M.call(this);this.type="ShaderMaterial";this.defines={};this.uniforms={};this.vertexShader="void main() {\n\tgl_Position \x3d projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}";this.fragmentShader=
"void main() {\n\tgl_FragColor \x3d vec4( 1.0, 0.0, 0.0, 1.0 );\n}";this.linewidth=1;this.wireframe=!1;this.wireframeLinewidth=1;this.morphNormals=this.morphTargets=this.skinning=this.clipping=this.lights=this.fog=!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;void 0!==a&&(void 0!==a.attributes&&console.error("THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead."),
this.setValues(a))}function zb(){A.call(this);this.type="Camera";this.matrixWorldInverse=new q;this.projectionMatrix=new q;this.projectionMatrixInverse=new q}function vb(a,c,e,g){zb.call(this);this.type="PerspectiveCamera";this.fov=void 0!==a?a:50;this.zoom=1;this.near=void 0!==e?e:.1;this.far=void 0!==g?g:2E3;this.focus=10;this.aspect=void 0!==c?c:1;this.view=null;this.filmGauge=35;this.filmOffset=0;this.updateProjectionMatrix()}function Gb(a,c,e,g){A.call(this);this.type="CubeCamera";var r=new vb(90,
1,a,c);r.up.set(0,-1,0);r.lookAt(new k(1,0,0));this.add(r);var v=new vb(90,1,a,c);v.up.set(0,-1,0);v.lookAt(new k(-1,0,0));this.add(v);var z=new vb(90,1,a,c);z.up.set(0,0,1);z.lookAt(new k(0,1,0));this.add(z);var E=new vb(90,1,a,c);E.up.set(0,0,-1);E.lookAt(new k(0,-1,0));this.add(E);var F=new vb(90,1,a,c);F.up.set(0,-1,0);F.lookAt(new k(0,0,1));this.add(F);var J=new vb(90,1,a,c);J.up.set(0,-1,0);J.lookAt(new k(0,0,-1));this.add(J);g=g||{format:1022,magFilter:1006,minFilter:1006};this.renderTarget=
new Nb(e,e,g);this.renderTarget.texture.name="CubeCamera";this.update=function(P,R){null===this.parent&&this.updateMatrixWorld();var S=P.getRenderTarget(),V=this.renderTarget,W=V.texture.generateMipmaps;V.texture.generateMipmaps=!1;P.setRenderTarget(V,0);P.render(R,r);P.setRenderTarget(V,1);P.render(R,v);P.setRenderTarget(V,2);P.render(R,z);P.setRenderTarget(V,3);P.render(R,E);P.setRenderTarget(V,4);P.render(R,F);V.texture.generateMipmaps=W;P.setRenderTarget(V,5);P.render(R,J);P.setRenderTarget(S)};
this.clear=function(P,R,S,V){for(var W=P.getRenderTarget(),ha=this.renderTarget,fa=0;6>fa;fa++)P.setRenderTarget(ha,fa),P.clear(R,S,V);P.setRenderTarget(W)}}function Nb(a,c,e){m.call(this,a,c,e)}function Ab(a,c,e,g,r,v,z,E,F,J,P,R){l.call(this,null,v,z,E,F,J,g,r,P,R);this.image={data:a,width:c,height:e};this.magFilter=void 0!==F?F:1003;this.minFilter=void 0!==J?J:1003;this.flipY=this.generateMipmaps=!1;this.unpackAlignment=1}function Hb(a,c){this.normal=void 0!==a?a:new k(1,0,0);this.constant=void 0!==
c?c:0}function ic(a,c,e,g,r,v){this.planes=[void 0!==a?a:new Hb,void 0!==c?c:new Hb,void 0!==e?e:new Hb,void 0!==g?g:new Hb,void 0!==r?r:new Hb,void 0!==v?v:new Hb]}function bc(){function a(r,v){!1!==e&&(g(r,v),c.requestAnimationFrame(a))}var c=null,e=!1,g=null;return{start:function(){!0!==e&&null!==g&&(c.requestAnimationFrame(a),e=!0)},stop:function(){e=!1},setAnimationLoop:function(r){g=r},setContext:function(r){c=r}}}function Od(a){function c(r,v){var z=r.array,E=r.dynamic?35048:35044,F=a.createBuffer();
a.bindBuffer(v,F);a.bufferData(v,z,E);r.onUploadCallback();v=5126;z instanceof Float32Array?v=5126:z instanceof Float64Array?console.warn("THREE.WebGLAttributes: Unsupported data buffer format: Float64Array."):z instanceof Uint16Array?v=5123:z instanceof Int16Array?v=5122:z instanceof Uint32Array?v=5125:z instanceof Int32Array?v=5124:z instanceof Int8Array?v=5120:z instanceof Uint8Array&&(v=5121);return{buffer:F,type:v,bytesPerElement:z.BYTES_PER_ELEMENT,version:r.version}}function e(r,v,z){var E=
v.array,F=v.updateRange;a.bindBuffer(z,r);!1===v.dynamic?a.bufferData(z,E,35044):-1===F.count?a.bufferSubData(z,0,E):0===F.count?console.error("THREE.WebGLObjects.updateBuffer: dynamic THREE.BufferAttribute marked as needsUpdate but updateRange.count is 0, ensure you are using set methods or updating manually."):(a.bufferSubData(z,F.offset*E.BYTES_PER_ELEMENT,E.subarray(F.offset,F.offset+F.count)),F.count=-1)}var g=new WeakMap;return{get:function(r){r.isInterleavedBufferAttribute&&(r=r.data);return g.get(r)},
remove:function(r){r.isInterleavedBufferAttribute&&(r=r.data);var v=g.get(r);v&&(a.deleteBuffer(v.buffer),g.delete(r))},update:function(r,v){r.isInterleavedBufferAttribute&&(r=r.data);var z=g.get(r);void 0===z?g.set(r,c(r,v)):z.version<r.version&&(e(z.buffer,r,v),z.version=r.version)}}}function rd(a,c,e,g){ya.call(this);this.type="PlaneGeometry";this.parameters={width:a,height:c,widthSegments:e,heightSegments:g};this.fromBufferGeometry(new Lc(a,c,e,g));this.mergeVertices()}function Lc(a,c,e,g){va.call(this);
this.type="PlaneBufferGeometry";this.parameters={width:a,height:c,widthSegments:e,heightSegments:g};a=a||1;c=c||1;var r=a/2,v=c/2;e=Math.floor(e)||1;g=Math.floor(g)||1;var z=e+1,E=g+1,F=a/e,J=c/g,P=[],R=[],S=[],V=[];for(a=0;a<E;a++){var W=a*J-v;for(c=0;c<z;c++)R.push(c*F-r,-W,0),S.push(0,0,1),V.push(c/e),V.push(1-a/g)}for(a=0;a<g;a++)for(c=0;c<e;c++)r=c+z*(a+1),v=c+1+z*(a+1),E=c+1+z*a,P.push(c+z*a,r,E),P.push(r,v,E);this.setIndex(P);this.addAttribute("position",new ca(R,3));this.addAttribute("normal",
new ca(S,3));this.addAttribute("uv",new ca(V,2))}function sd(a,c,e,g){function r(R,S){c.buffers.color.setClear(R.r,R.g,R.b,S,g)}var v=new I(0),z=0,E,F,J=null,P=0;return{getClearColor:function(){return v},setClearColor:function(R,S){v.set(R);z=void 0!==S?S:1;r(v,z)},getClearAlpha:function(){return z},setClearAlpha:function(R){z=R;r(v,z)},render:function(R,S,V,W){S=S.background;V=a.vr;(V=V.getSession&&V.getSession())&&"additive"===V.environmentBlendMode&&(S=null);null===S?(r(v,z),J=null,P=0):S&&S.isColor&&
(r(S,1),W=!0,J=null,P=0);(a.autoClear||W)&&a.clear(a.autoClearColor,a.autoClearDepth,a.autoClearStencil);if(S&&(S.isCubeTexture||S.isWebGLRenderTargetCube)){void 0===F&&(F=new xa(new Xa(1,1,1),new qb({type:"BackgroundCubeMaterial",uniforms:ub(Mc.cube.uniforms),vertexShader:Mc.cube.vertexShader,fragmentShader:Mc.cube.fragmentShader,side:1,depthTest:!1,depthWrite:!1,fog:!1})),F.geometry.removeAttribute("normal"),F.geometry.removeAttribute("uv"),F.onBeforeRender=function(ha,fa,ra){this.matrixWorld.copyPosition(ra.matrixWorld)},
Object.defineProperty(F.material,"map",{get:function(){return this.uniforms.tCube.value}}),e.update(F));W=S.isWebGLRenderTargetCube?S.texture:S;F.material.uniforms.tCube.value=W;F.material.uniforms.tFlip.value=S.isWebGLRenderTargetCube?1:-1;if(J!==S||P!==W.version)F.material.needsUpdate=!0,J=S,P=W.version;R.unshift(F,F.geometry,F.material,0,0,null)}else if(S&&S.isTexture){void 0===E&&(E=new xa(new Lc(2,2),new qb({type:"BackgroundMaterial",uniforms:ub(Mc.background.uniforms),vertexShader:Mc.background.vertexShader,
fragmentShader:Mc.background.fragmentShader,side:0,depthTest:!1,depthWrite:!1,fog:!1})),E.geometry.removeAttribute("normal"),Object.defineProperty(E.material,"map",{get:function(){return this.uniforms.t2D.value}}),e.update(E));E.material.uniforms.t2D.value=S;!0===S.matrixAutoUpdate&&S.updateMatrix();E.material.uniforms.uvTransform.value.copy(S.matrix);if(J!==S||P!==S.version)E.material.needsUpdate=!0,J=S,P=S.version;R.unshift(E,E.geometry,E.material,0,0,null)}}}}function sa(a,c,e,g){var r;this.setMode=
function(v){r=v};this.render=function(v,z){a.drawArrays(r,v,z);e.update(z,r)};this.renderInstances=function(v,z,E){if(g.isWebGL2){var F=a;var J="drawArraysInstanced"}else if(F=c.get("ANGLE_instanced_arrays"),J="drawArraysInstancedANGLE",null===F){console.error("THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}F[J](r,z,E,v.maxInstancedCount);e.update(E,r,v.maxInstancedCount)}}function Mb(a,c,e){function g(qa){if("highp"===
qa){if(0<a.getShaderPrecisionFormat(35633,36338).precision&&0<a.getShaderPrecisionFormat(35632,36338).precision)return"highp";qa="mediump"}return"mediump"===qa&&0<a.getShaderPrecisionFormat(35633,36337).precision&&0<a.getShaderPrecisionFormat(35632,36337).precision?"mediump":"lowp"}var r,v="undefined"!==typeof WebGL2RenderingContext&&a instanceof WebGL2RenderingContext,z=void 0!==e.precision?e.precision:"highp",E=g(z);E!==z&&(console.warn("THREE.WebGLRenderer:",z,"not supported, using",E,"instead."),
z=E);e=!0===e.logarithmicDepthBuffer;E=a.getParameter(34930);var F=a.getParameter(35660),J=a.getParameter(3379),P=a.getParameter(34076),R=a.getParameter(34921),S=a.getParameter(36347),V=a.getParameter(36348),W=a.getParameter(36349),ha=0<F,fa=v||!!c.get("OES_texture_float"),ra=ha&&fa,pa=v?a.getParameter(36183):0;return{isWebGL2:v,getMaxAnisotropy:function(){if(void 0!==r)return r;var qa=c.get("EXT_texture_filter_anisotropic");return r=null!==qa?a.getParameter(qa.MAX_TEXTURE_MAX_ANISOTROPY_EXT):0},
getMaxPrecision:g,precision:z,logarithmicDepthBuffer:e,maxTextures:E,maxVertexTextures:F,maxTextureSize:J,maxCubemapSize:P,maxAttributes:R,maxVertexUniforms:S,maxVaryings:V,maxFragmentUniforms:W,vertexTextures:ha,floatFragmentTextures:fa,floatVertexTextures:ra,maxSamples:pa}}function wc(){function a(){J.value!==g&&(J.value=g,J.needsUpdate=0<r);e.numPlanes=r;e.numIntersection=0}function c(P,R,S,V){var W=null!==P?P.length:0,ha=null;if(0!==W){ha=J.value;if(!0!==V||null===ha){V=S+4*W;R=R.matrixWorldInverse;
F.getNormalMatrix(R);if(null===ha||ha.length<V)ha=new Float32Array(V);for(V=0;V!==W;++V,S+=4)E.copy(P[V]).applyMatrix4(R,F),E.normal.toArray(ha,S),ha[S+3]=E.constant}J.value=ha;J.needsUpdate=!0}e.numPlanes=W;return ha}var e=this,g=null,r=0,v=!1,z=!1,E=new Hb,F=new t,J={value:null,needsUpdate:!1};this.uniform=J;this.numIntersection=this.numPlanes=0;this.init=function(P,R,S){var V=0!==P.length||R||0!==r||v;v=R;g=c(P,S,0);r=P.length;return V};this.beginShadows=function(){z=!0;c(null)};this.endShadows=
function(){z=!1;a()};this.setState=function(P,R,S,V,W,ha){if(!v||null===P||0===P.length||z&&!S)z?c(null):a();else{S=z?0:r;var fa=4*S,ra=W.clippingState||null;J.value=ra;ra=c(P,V,fa,ha);for(P=0;P!==fa;++P)ra[P]=g[P];W.clippingState=ra;this.numIntersection=R?this.numPlanes:0;this.numPlanes+=S}}}function bd(a){var c={};return{get:function(e){if(void 0!==c[e])return c[e];switch(e){case "WEBGL_depth_texture":var g=a.getExtension("WEBGL_depth_texture")||a.getExtension("MOZ_WEBGL_depth_texture")||a.getExtension("WEBKIT_WEBGL_depth_texture");
break;case "EXT_texture_filter_anisotropic":g=a.getExtension("EXT_texture_filter_anisotropic")||a.getExtension("MOZ_EXT_texture_filter_anisotropic")||a.getExtension("WEBKIT_EXT_texture_filter_anisotropic");break;case "WEBGL_compressed_texture_s3tc":g=a.getExtension("WEBGL_compressed_texture_s3tc")||a.getExtension("MOZ_WEBGL_compressed_texture_s3tc")||a.getExtension("WEBKIT_WEBGL_compressed_texture_s3tc");break;case "WEBGL_compressed_texture_pvrtc":g=a.getExtension("WEBGL_compressed_texture_pvrtc")||
a.getExtension("WEBKIT_WEBGL_compressed_texture_pvrtc");break;default:g=a.getExtension(e)}null===g&&console.warn("THREE.WebGLRenderer: "+e+" extension not supported.");return c[e]=g}}}function td(a,c,e){function g(E){var F=E.target;E=v.get(F);null!==E.index&&c.remove(E.index);for(var J in E.attributes)c.remove(E.attributes[J]);F.removeEventListener("dispose",g);v.delete(F);if(J=z.get(E))c.remove(J),z.delete(E);e.memory.geometries--}function r(E){var F=[],J=E.index,P=E.attributes.position;if(null!==
J){var R=J.array;J=J.version;P=0;for(var S=R.length;P<S;P+=3){var V=R[P+0],W=R[P+1],ha=R[P+2];F.push(V,W,W,ha,ha,V)}}else for(R=P.array,J=P.version,P=0,S=R.length/3-1;P<S;P+=3)V=P+0,W=P+1,ha=P+2,F.push(V,W,W,ha,ha,V);F=new (65535<Ea(F)?ea:Z)(F,1);F.version=J;c.update(F,34963);(R=z.get(E))&&c.remove(R);z.set(E,F)}var v=new WeakMap,z=new WeakMap;return{get:function(E,F){var J=v.get(F);if(J)return J;F.addEventListener("dispose",g);F.isBufferGeometry?J=F:F.isGeometry&&(void 0===F._bufferGeometry&&(F._bufferGeometry=
(new va).setFromObject(E)),J=F._bufferGeometry);v.set(F,J);e.memory.geometries++;return J},update:function(E){var F=E.index,J=E.attributes;null!==F&&c.update(F,34963);for(var P in J)c.update(J[P],34962);E=E.morphAttributes;for(P in E){F=E[P];J=0;for(var R=F.length;J<R;J++)c.update(F[J],34962)}},getWireframeAttribute:function(E){var F=z.get(E);if(F){var J=E.index;null!==J&&F.version<J.version&&r(E)}else r(E);return z.get(E)}}}function tg(a,c,e,g){var r,v,z;this.setMode=function(E){r=E};this.setIndex=
function(E){v=E.type;z=E.bytesPerElement};this.render=function(E,F){a.drawElements(r,F,v,E*z);e.update(F,r)};this.renderInstances=function(E,F,J){if(g.isWebGL2){var P=a;var R="drawElementsInstanced"}else if(P=c.get("ANGLE_instanced_arrays"),R="drawElementsInstancedANGLE",null===P){console.error("THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");return}P[R](r,J,v,F*z,E.maxInstancedCount);e.update(J,r,E.maxInstancedCount)}}
function Sk(){var a={frame:0,calls:0,triangles:0,points:0,lines:0};return{memory:{geometries:0,textures:0},render:a,programs:null,autoReset:!0,reset:function(){a.frame++;a.calls=0;a.triangles=0;a.points=0;a.lines=0},update:function(c,e,g){g=g||1;a.calls++;switch(e){case 4:a.triangles+=c/3*g;break;case 5:case 6:a.triangles+=g*(c-2);break;case 1:a.lines+=c/2*g;break;case 3:a.lines+=g*(c-1);break;case 2:a.lines+=g*c;break;case 0:a.points+=g*c;break;default:console.error("THREE.WebGLInfo: Unknown draw mode:",
e)}}}}function Tk(a,c){return Math.abs(c[1])-Math.abs(a[1])}function Uk(a){var c={},e=new Float32Array(8);return{update:function(g,r,v,z){var E=g.morphTargetInfluences,F=E.length;g=c[r.id];if(void 0===g){g=[];for(var J=0;J<F;J++)g[J]=[J,0];c[r.id]=g}var P=v.morphTargets&&r.morphAttributes.position;v=v.morphNormals&&r.morphAttributes.normal;for(J=0;J<F;J++){var R=g[J];0!==R[1]&&(P&&r.removeAttribute("morphTarget"+J),v&&r.removeAttribute("morphNormal"+J))}for(J=0;J<F;J++)R=g[J],R[0]=J,R[1]=E[J];g.sort(Tk);
for(J=0;8>J;J++){if(R=g[J])if(E=R[0],F=R[1]){P&&r.addAttribute("morphTarget"+J,P[E]);v&&r.addAttribute("morphNormal"+J,v[E]);e[J]=F;continue}e[J]=0}z.getUniforms().setValue(a,"morphTargetInfluences",e)}}}function Vk(a,c){var e={};return{update:function(g){var r=c.render.frame,v=g.geometry,z=a.get(g,v);e[z.id]!==r&&(v.isGeometry&&z.updateFromObject(g),a.update(z),e[z.id]=r);return z},dispose:function(){e={}}}}function cd(a,c,e,g,r,v,z,E,F,J){a=void 0!==a?a:[];l.call(this,a,void 0!==c?c:301,e,g,r,v,
void 0!==z?z:1022,E,F,J);this.flipY=!1}function re(a,c,e,g){l.call(this,null);this.image={data:a,width:c,height:e,depth:g};this.minFilter=this.magFilter=1003;this.wrapR=1001;this.flipY=this.generateMipmaps=!1}function se(a,c,e,g){l.call(this,null);this.image={data:a,width:c,height:e,depth:g};this.minFilter=this.magFilter=1003;this.wrapR=1001;this.flipY=this.generateMipmaps=!1}function te(a,c,e){var g=a[0];if(0>=g||0<g)return a;var r=c*e,v=cj[r];void 0===v&&(v=new Float32Array(r),cj[r]=v);if(0!==c)for(g.toArray(v,
0),g=1,r=0;g!==c;++g)r+=e,a[g].toArray(v,r);return v}function sc(a,c){if(a.length!==c.length)return!1;for(var e=0,g=a.length;e<g;e++)if(a[e]!==c[e])return!1;return!0}function mc(a,c){for(var e=0,g=c.length;e<g;e++)a[e]=c[e]}function dj(a,c){var e=ej[c];void 0===e&&(e=new Int32Array(c),ej[c]=e);for(var g=0;g!==c;++g)e[g]=a.allocateTextureUnit();return e}function Wk(a,c){var e=this.cache;e[0]!==c&&(a.uniform1f(this.addr,c),e[0]=c)}function Xk(a,c){var e=this.cache;if(void 0!==c.x){if(e[0]!==c.x||e[1]!==
c.y)a.uniform2f(this.addr,c.x,c.y),e[0]=c.x,e[1]=c.y}else sc(e,c)||(a.uniform2fv(this.addr,c),mc(e,c))}function Yk(a,c){var e=this.cache;if(void 0!==c.x){if(e[0]!==c.x||e[1]!==c.y||e[2]!==c.z)a.uniform3f(this.addr,c.x,c.y,c.z),e[0]=c.x,e[1]=c.y,e[2]=c.z}else if(void 0!==c.r){if(e[0]!==c.r||e[1]!==c.g||e[2]!==c.b)a.uniform3f(this.addr,c.r,c.g,c.b),e[0]=c.r,e[1]=c.g,e[2]=c.b}else sc(e,c)||(a.uniform3fv(this.addr,c),mc(e,c))}function Zk(a,c){var e=this.cache;if(void 0!==c.x){if(e[0]!==c.x||e[1]!==c.y||
e[2]!==c.z||e[3]!==c.w)a.uniform4f(this.addr,c.x,c.y,c.z,c.w),e[0]=c.x,e[1]=c.y,e[2]=c.z,e[3]=c.w}else sc(e,c)||(a.uniform4fv(this.addr,c),mc(e,c))}function $k(a,c){var e=this.cache,g=c.elements;void 0===g?sc(e,c)||(a.uniformMatrix2fv(this.addr,!1,c),mc(e,c)):sc(e,g)||(fj.set(g),a.uniformMatrix2fv(this.addr,!1,fj),mc(e,g))}function al(a,c){var e=this.cache,g=c.elements;void 0===g?sc(e,c)||(a.uniformMatrix3fv(this.addr,!1,c),mc(e,c)):sc(e,g)||(gj.set(g),a.uniformMatrix3fv(this.addr,!1,gj),mc(e,g))}
function bl(a,c){var e=this.cache,g=c.elements;void 0===g?sc(e,c)||(a.uniformMatrix4fv(this.addr,!1,c),mc(e,c)):sc(e,g)||(hj.set(g),a.uniformMatrix4fv(this.addr,!1,hj),mc(e,g))}function cl(a,c,e){var g=this.cache,r=e.allocateTextureUnit();g[0]!==r&&(a.uniform1i(this.addr,r),g[0]=r);e.safeSetTexture2D(c||ij,r)}function dl(a,c,e){var g=this.cache,r=e.allocateTextureUnit();g[0]!==r&&(a.uniform1i(this.addr,r),g[0]=r);e.setTexture2DArray(c||el,r)}function fl(a,c,e){var g=this.cache,r=e.allocateTextureUnit();
g[0]!==r&&(a.uniform1i(this.addr,r),g[0]=r);e.setTexture3D(c||gl,r)}function hl(a,c,e){var g=this.cache,r=e.allocateTextureUnit();g[0]!==r&&(a.uniform1i(this.addr,r),g[0]=r);e.safeSetTextureCube(c||jj,r)}function il(a,c){var e=this.cache;e[0]!==c&&(a.uniform1i(this.addr,c),e[0]=c)}function jl(a,c){var e=this.cache;sc(e,c)||(a.uniform2iv(this.addr,c),mc(e,c))}function kl(a,c){var e=this.cache;sc(e,c)||(a.uniform3iv(this.addr,c),mc(e,c))}function ll(a,c){var e=this.cache;sc(e,c)||(a.uniform4iv(this.addr,
c),mc(e,c))}function ml(a){switch(a){case 5126:return Wk;case 35664:return Xk;case 35665:return Yk;case 35666:return Zk;case 35674:return $k;case 35675:return al;case 35676:return bl;case 35678:case 36198:return cl;case 35679:return fl;case 35680:return hl;case 36289:return dl;case 5124:case 35670:return il;case 35667:case 35671:return jl;case 35668:case 35672:return kl;case 35669:case 35673:return ll}}function nl(a,c){a.uniform1fv(this.addr,c)}function ol(a,c){a.uniform1iv(this.addr,c)}function pl(a,
c){a.uniform2iv(this.addr,c)}function ql(a,c){a.uniform3iv(this.addr,c)}function rl(a,c){a.uniform4iv(this.addr,c)}function sl(a,c){c=te(c,this.size,2);a.uniform2fv(this.addr,c)}function tl(a,c){c=te(c,this.size,3);a.uniform3fv(this.addr,c)}function ul(a,c){c=te(c,this.size,4);a.uniform4fv(this.addr,c)}function vl(a,c){c=te(c,this.size,4);a.uniformMatrix2fv(this.addr,!1,c)}function wl(a,c){c=te(c,this.size,9);a.uniformMatrix3fv(this.addr,!1,c)}function xl(a,c){c=te(c,this.size,16);a.uniformMatrix4fv(this.addr,
!1,c)}function yl(a,c,e){var g=c.length,r=dj(e,g);a.uniform1iv(this.addr,r);for(a=0;a!==g;++a)e.safeSetTexture2D(c[a]||ij,r[a])}function zl(a,c,e){var g=c.length,r=dj(e,g);a.uniform1iv(this.addr,r);for(a=0;a!==g;++a)e.safeSetTextureCube(c[a]||jj,r[a])}function Al(a){switch(a){case 5126:return nl;case 35664:return sl;case 35665:return tl;case 35666:return ul;case 35674:return vl;case 35675:return wl;case 35676:return xl;case 35678:return yl;case 35680:return zl;case 5124:case 35670:return ol;case 35667:case 35671:return pl;
case 35668:case 35672:return ql;case 35669:case 35673:return rl}}function Bl(a,c,e){this.id=a;this.addr=e;this.cache=[];this.setValue=ml(c.type)}function kj(a,c,e){this.id=a;this.addr=e;this.cache=[];this.size=c.size;this.setValue=Al(c.type)}function lj(a){this.id=a;this.seq=[];this.map={}}function mj(a,c){a.seq.push(c);a.map[c.id]=c}function Cl(a,c,e){var g=a.name,r=g.length;for(Lh.lastIndex=0;;){var v=Lh.exec(g),z=Lh.lastIndex,E=v[1],F=v[3];"]"===v[2]&&(E|=0);if(void 0===F||"["===F&&z+2===r){mj(e,
void 0===F?new Bl(E,a,c):new kj(E,a,c));break}else v=e.map[E],void 0===v&&(v=new lj(E),mj(e,v)),e=v}}function ud(a,c){this.seq=[];this.map={};for(var e=a.getProgramParameter(c,35718),g=0;g<e;++g){var r=a.getActiveUniform(c,g);Cl(r,a.getUniformLocation(c,r.name),this)}}function nj(a,c,e){c=a.createShader(c);a.shaderSource(c,e);a.compileShader(c);return c}function Dl(a){a=a.split("\n");for(var c=0;c<a.length;c++)a[c]=c+1+": "+a[c];return a.join("\n")}function oj(a){switch(a){case 3E3:return["Linear",
"( value )"];case 3001:return["sRGB","( value )"];case 3002:return["RGBE","( value )"];case 3004:return["RGBM","( value, 7.0 )"];case 3005:return["RGBM","( value, 16.0 )"];case 3006:return["RGBD","( value, 256.0 )"];case 3007:return["Gamma","( value, float( GAMMA_FACTOR ) )"];case 3003:return["LogLuv","( value )"];default:throw Error("unsupported encoding: "+a);}}function pj(a,c,e){var g=a.getShaderParameter(c,35713),r=a.getShaderInfoLog(c).trim();return g&&""===r?"":"THREE.WebGLShader: gl.getShaderInfoLog() "+
e+"\n"+r+Dl(a.getShaderSource(c))}function ug(a,c){c=oj(c);return"vec4 "+a+"( vec4 value ) { return "+c[0]+"ToLinear"+c[1]+"; }"}function El(a,c){c=oj(c);return"vec4 "+a+"( vec4 value ) { return LinearTo"+c[0]+c[1]+"; }"}function Fl(a,c){switch(c){case 1:c="Linear";break;case 2:c="Reinhard";break;case 3:c="Uncharted2";break;case 4:c="OptimizedCineon";break;case 5:c="ACESFilmic";break;default:throw Error("unsupported toneMapping: "+c);}return"vec3 "+a+"( vec3 color ) { return "+c+"ToneMapping( color ); }"}
function Gl(a,c,e){a=a||{};return[a.derivatives||c.envMapCubeUV||c.bumpMap||c.tangentSpaceNormalMap||c.clearcoatNormalMap||c.flatShading?"#extension GL_OES_standard_derivatives : enable":"",(a.fragDepth||c.logarithmicDepthBuffer)&&e.get("EXT_frag_depth")?"#extension GL_EXT_frag_depth : enable":"",a.drawBuffers&&e.get("WEBGL_draw_buffers")?"#extension GL_EXT_draw_buffers : require":"",(a.shaderTextureLOD||c.envMap)&&e.get("EXT_shader_texture_lod")?"#extension GL_EXT_shader_texture_lod : enable":""].filter(uf).join("\n")}
function Hl(a){var c=[],e;for(e in a){var g=a[e];!1!==g&&c.push("#define "+e+" "+g)}return c.join("\n")}function Il(a,c){for(var e={},g=a.getProgramParameter(c,35721),r=0;r<g;r++){var v=a.getActiveAttrib(c,r).name;e[v]=a.getAttribLocation(c,v)}return e}function uf(a){return""!==a}function qj(a,c){return a.replace(/NUM_DIR_LIGHTS/g,c.numDirLights).replace(/NUM_SPOT_LIGHTS/g,c.numSpotLights).replace(/NUM_RECT_AREA_LIGHTS/g,c.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g,c.numPointLights).replace(/NUM_HEMI_LIGHTS/g,
c.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g,c.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS/g,c.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g,c.numPointLightShadows)}function rj(a,c){return a.replace(/NUM_CLIPPING_PLANES/g,c.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g,c.numClippingPlanes-c.numClipIntersection)}function Mh(a){return a.replace(/^[ \t]*#include +<([\w\d./]+)>/gm,function(c,e){c=rb[e];if(void 0===c)throw Error("Can not resolve #include \x3c"+e+"\x3e");return Mh(c)})}
function sj(a){return a.replace(/#pragma unroll_loop[\s]+?for \( int i = (\d+); i < (\d+); i \+\+ \) \{([\s\S]+?)(?=\})\}/g,function(c,e,g,r){c="";for(e=parseInt(e);e<parseInt(g);e++)c+=r.replace(/\[ i \]/g,"[ "+e+" ]").replace(/UNROLLED_LOOP_INDEX/g,e);return c})}function Jl(a,c,e,g,r,v,z){var E=a.getContext(),F=g.defines,J=r.vertexShader,P=r.fragmentShader,R="SHADOWMAP_TYPE_BASIC";1===v.shadowMapType?R="SHADOWMAP_TYPE_PCF":2===v.shadowMapType?R="SHADOWMAP_TYPE_PCF_SOFT":3===v.shadowMapType&&(R=
"SHADOWMAP_TYPE_VSM");var S="ENVMAP_TYPE_CUBE",V="ENVMAP_MODE_REFLECTION",W="ENVMAP_BLENDING_MULTIPLY";if(v.envMap){switch(g.envMap.mapping){case 301:case 302:S="ENVMAP_TYPE_CUBE";break;case 306:case 307:S="ENVMAP_TYPE_CUBE_UV";break;case 303:case 304:S="ENVMAP_TYPE_EQUIREC";break;case 305:S="ENVMAP_TYPE_SPHERE"}switch(g.envMap.mapping){case 302:case 304:V="ENVMAP_MODE_REFRACTION"}switch(g.combine){case 0:W="ENVMAP_BLENDING_MULTIPLY";break;case 1:W="ENVMAP_BLENDING_MIX";break;case 2:W="ENVMAP_BLENDING_ADD"}}var ha=
0<a.gammaFactor?a.gammaFactor:1,fa=z.isWebGL2?"":Gl(g.extensions,v,c),ra=Hl(F),pa=E.createProgram();g.isRawShaderMaterial?(F=[ra].filter(uf).join("\n"),0<F.length&&(F+="\n"),c=[fa,ra].filter(uf).join("\n"),0<c.length&&(c+="\n")):(F=["precision "+v.precision+" float;","precision "+v.precision+" int;","highp"===v.precision?"#define HIGH_PRECISION":"","#define SHADER_NAME "+r.name,ra,v.supportsVertexTextures?"#define VERTEX_TEXTURES":"","#define GAMMA_FACTOR "+ha,"#define MAX_BONES "+v.maxBones,v.useFog&&
v.fog?"#define USE_FOG":"",v.useFog&&v.fogExp2?"#define FOG_EXP2":"",v.map?"#define USE_MAP":"",v.envMap?"#define USE_ENVMAP":"",v.envMap?"#define "+V:"",v.lightMap?"#define USE_LIGHTMAP":"",v.aoMap?"#define USE_AOMAP":"",v.emissiveMap?"#define USE_EMISSIVEMAP":"",v.bumpMap?"#define USE_BUMPMAP":"",v.normalMap?"#define USE_NORMALMAP":"",v.normalMap&&v.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",v.normalMap&&v.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",v.clearcoatNormalMap?
"#define USE_CLEARCOAT_NORMALMAP":"",v.displacementMap&&v.supportsVertexTextures?"#define USE_DISPLACEMENTMAP":"",v.specularMap?"#define USE_SPECULARMAP":"",v.roughnessMap?"#define USE_ROUGHNESSMAP":"",v.metalnessMap?"#define USE_METALNESSMAP":"",v.alphaMap?"#define USE_ALPHAMAP":"",v.vertexTangents?"#define USE_TANGENT":"",v.vertexColors?"#define USE_COLOR":"",v.vertexUvs?"#define USE_UV":"",v.flatShading?"#define FLAT_SHADED":"",v.skinning?"#define USE_SKINNING":"",v.useVertexTexture?"#define BONE_TEXTURE":
"",v.morphTargets?"#define USE_MORPHTARGETS":"",v.morphNormals&&!1===v.flatShading?"#define USE_MORPHNORMALS":"",v.doubleSided?"#define DOUBLE_SIDED":"",v.flipSided?"#define FLIP_SIDED":"",v.shadowMapEnabled?"#define USE_SHADOWMAP":"",v.shadowMapEnabled?"#define "+R:"",v.sizeAttenuation?"#define USE_SIZEATTENUATION":"",v.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",v.logarithmicDepthBuffer&&(z.isWebGL2||c.get("EXT_frag_depth"))?"#define USE_LOGDEPTHBUF_EXT":"","uniform mat4 modelMatrix;","uniform mat4 modelViewMatrix;",
"uniform mat4 projectionMatrix;","uniform mat4 viewMatrix;","uniform mat3 normalMatrix;","uniform vec3 cameraPosition;","attribute vec3 position;","attribute vec3 normal;","attribute vec2 uv;","#ifdef USE_TANGENT","\tattribute vec4 tangent;","#endif","#ifdef USE_COLOR","\tattribute vec3 color;","#endif","#ifdef USE_MORPHTARGETS","\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(uf).join("\n"),c=[fa,"precision "+v.precision+" float;","precision "+v.precision+" int;","highp"===v.precision?"#define HIGH_PRECISION":
"","#define SHADER_NAME "+r.name,ra,v.alphaTest?"#define ALPHATEST "+v.alphaTest+(v.alphaTest%1?"":".0"):"","#define GAMMA_FACTOR "+ha,v.useFog&&v.fog?"#define USE_FOG":"",v.useFog&&v.fogExp2?"#define FOG_EXP2":"",v.map?"#define USE_MAP":"",v.matcap?"#define USE_MATCAP":"",v.envMap?"#define USE_ENVMAP":"",v.envMap?"#define "+S:"",v.envMap?"#define "+V:"",v.envMap?"#define "+W:"",v.lightMap?"#define USE_LIGHTMAP":"",v.aoMap?"#define USE_AOMAP":"",v.emissiveMap?"#define USE_EMISSIVEMAP":"",v.bumpMap?
"#define USE_BUMPMAP":"",v.normalMap?"#define USE_NORMALMAP":"",v.normalMap&&v.objectSpaceNormalMap?"#define OBJECTSPACE_NORMALMAP":"",v.normalMap&&v.tangentSpaceNormalMap?"#define TANGENTSPACE_NORMALMAP":"",v.clearcoatNormalMap?"#define USE_CLEARCOAT_NORMALMAP":"",v.specularMap?"#define USE_SPECULARMAP":"",v.roughnessMap?"#define USE_ROUGHNESSMAP":"",v.metalnessMap?"#define USE_METALNESSMAP":"",v.alphaMap?"#define USE_ALPHAMAP":"",v.sheen?"#define USE_SHEEN":"",v.vertexTangents?"#define USE_TANGENT":
"",v.vertexColors?"#define USE_COLOR":"",v.vertexUvs?"#define USE_UV":"",v.gradientMap?"#define USE_GRADIENTMAP":"",v.flatShading?"#define FLAT_SHADED":"",v.doubleSided?"#define DOUBLE_SIDED":"",v.flipSided?"#define FLIP_SIDED":"",v.shadowMapEnabled?"#define USE_SHADOWMAP":"",v.shadowMapEnabled?"#define "+R:"",v.premultipliedAlpha?"#define PREMULTIPLIED_ALPHA":"",v.physicallyCorrectLights?"#define PHYSICALLY_CORRECT_LIGHTS":"",v.logarithmicDepthBuffer?"#define USE_LOGDEPTHBUF":"",v.logarithmicDepthBuffer&&
(z.isWebGL2||c.get("EXT_frag_depth"))?"#define USE_LOGDEPTHBUF_EXT":"",(g.extensions&&g.extensions.shaderTextureLOD||v.envMap)&&(z.isWebGL2||c.get("EXT_shader_texture_lod"))?"#define TEXTURE_LOD_EXT":"","uniform mat4 viewMatrix;","uniform vec3 cameraPosition;",0!==v.toneMapping?"#define TONE_MAPPING":"",0!==v.toneMapping?rb.tonemapping_pars_fragment:"",0!==v.toneMapping?Fl("toneMapping",v.toneMapping):"",v.dithering?"#define DITHERING":"",v.outputEncoding||v.mapEncoding||v.matcapEncoding||v.envMapEncoding||
v.emissiveMapEncoding?rb.encodings_pars_fragment:"",v.mapEncoding?ug("mapTexelToLinear",v.mapEncoding):"",v.matcapEncoding?ug("matcapTexelToLinear",v.matcapEncoding):"",v.envMapEncoding?ug("envMapTexelToLinear",v.envMapEncoding):"",v.emissiveMapEncoding?ug("emissiveMapTexelToLinear",v.emissiveMapEncoding):"",v.outputEncoding?El("linearToOutputTexel",v.outputEncoding):"",v.depthPacking?"#define DEPTH_PACKING "+g.depthPacking:"","\n"].filter(uf).join("\n"));J=Mh(J);J=qj(J,v);J=rj(J,v);P=Mh(P);P=qj(P,
v);P=rj(P,v);J=sj(J);P=sj(P);z.isWebGL2&&!g.isRawShaderMaterial&&(z=!1,R=/^\s*#version\s+300\s+es\s*\n/,g.isShaderMaterial&&null!==J.match(R)&&null!==P.match(R)&&(z=!0,J=J.replace(R,""),P=P.replace(R,"")),F="#version 300 es\n\n#define attribute in\n#define varying out\n#define texture2D texture\n"+F,c=["#version 300 es\n\n#define varying in",z?"":"out highp vec4 pc_fragColor;",z?"":"#define gl_FragColor pc_fragColor","#define gl_FragDepthEXT gl_FragDepth\n#define texture2D texture\n#define textureCube texture\n#define texture2DProj textureProj\n#define texture2DLodEXT textureLod\n#define texture2DProjLodEXT textureProjLod\n#define textureCubeLodEXT textureLod\n#define texture2DGradEXT textureGrad\n#define texture2DProjGradEXT textureProjGrad\n#define textureCubeGradEXT textureGrad"].join("\n")+
"\n"+c);P=c+P;J=nj(E,35633,F+J);P=nj(E,35632,P);E.attachShader(pa,J);E.attachShader(pa,P);void 0!==g.index0AttributeName?E.bindAttribLocation(pa,0,g.index0AttributeName):!0===v.morphTargets&&E.bindAttribLocation(pa,0,"position");E.linkProgram(pa);if(a.debug.checkShaderErrors){a=E.getProgramInfoLog(pa).trim();v=E.getShaderInfoLog(J).trim();z=E.getShaderInfoLog(P).trim();S=R=!0;if(!1===E.getProgramParameter(pa,35714))R=!1,V=pj(E,J,"vertex"),W=pj(E,P,"fragment"),console.error("THREE.WebGLProgram: shader error: ",
E.getError(),"35715",E.getProgramParameter(pa,35715),"gl.getProgramInfoLog",a,V,W);else if(""!==a)console.warn("THREE.WebGLProgram: gl.getProgramInfoLog()",a);else if(""===v||""===z)S=!1;S&&(this.diagnostics={runnable:R,material:g,programLog:a,vertexShader:{log:v,prefix:F},fragmentShader:{log:z,prefix:c}})}E.deleteShader(J);E.deleteShader(P);var qa;this.getUniforms=function(){void 0===qa&&(qa=new ud(E,pa));return qa};var ua;this.getAttributes=function(){void 0===ua&&(ua=Il(E,pa));return ua};this.destroy=
function(){E.deleteProgram(pa);this.program=void 0};this.name=r.name;this.id=Kl++;this.code=e;this.usedTimes=1;this.program=pa;this.vertexShader=J;this.fragmentShader=P;return this}function Ll(a,c,e){function g(F){F=F.skeleton.bones;if(e.floatVertexTextures)return 1024;var J=Math.min(Math.floor((e.maxVertexUniforms-20)/4),F.length);return J<F.length?(console.warn("THREE.WebGLRenderer: Skeleton has "+F.length+" bones. This GPU supports "+J+"."),0):J}function r(F,J){if(F)F.isTexture?P=F.encoding:F.isWebGLRenderTarget&&
(console.warn("THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead."),P=F.texture.encoding);else var P=3E3;3E3===P&&J&&(P=3007);return P}var v=[],z={MeshDepthMaterial:"depth",MeshDistanceMaterial:"distanceRGBA",MeshNormalMaterial:"normal",MeshBasicMaterial:"basic",MeshLambertMaterial:"lambert",MeshPhongMaterial:"phong",MeshToonMaterial:"phong",MeshStandardMaterial:"physical",MeshPhysicalMaterial:"physical",MeshMatcapMaterial:"matcap",
LineBasicMaterial:"basic",LineDashedMaterial:"dashed",PointsMaterial:"points",ShadowMaterial:"shadow",SpriteMaterial:"sprite"},E="precision supportsVertexTextures map mapEncoding matcap matcapEncoding envMap envMapMode envMapEncoding lightMap aoMap emissiveMap emissiveMapEncoding bumpMap normalMap objectSpaceNormalMap tangentSpaceNormalMap clearcoatNormalMap displacementMap specularMap roughnessMap metalnessMap gradientMap alphaMap combine vertexColors vertexTangents fog useFog fogExp2 flatShading sizeAttenuation logarithmicDepthBuffer skinning maxBones useVertexTexture morphTargets morphNormals maxMorphTargets maxMorphNormals premultipliedAlpha numDirLights numPointLights numSpotLights numHemiLights numRectAreaLights shadowMapEnabled shadowMapType toneMapping physicallyCorrectLights alphaTest doubleSided flipSided numClippingPlanes numClipIntersection depthPacking dithering sheen".split(" ");
this.getParameters=function(F,J,P,R,S,V,W){var ha=z[F.type],fa=W.isSkinnedMesh?g(W):0,ra=e.precision;null!==F.precision&&(ra=e.getMaxPrecision(F.precision),ra!==F.precision&&console.warn("THREE.WebGLProgram.getParameters:",F.precision,"not supported, using",ra,"instead."));var pa=a.getRenderTarget();return{shaderID:ha,precision:ra,supportsVertexTextures:e.vertexTextures,outputEncoding:r(pa?pa.texture:null,a.gammaOutput),map:!!F.map,mapEncoding:r(F.map,a.gammaInput),matcap:!!F.matcap,matcapEncoding:r(F.matcap,
a.gammaInput),envMap:!!F.envMap,envMapMode:F.envMap&&F.envMap.mapping,envMapEncoding:r(F.envMap,a.gammaInput),envMapCubeUV:!!F.envMap&&(306===F.envMap.mapping||307===F.envMap.mapping),lightMap:!!F.lightMap,aoMap:!!F.aoMap,emissiveMap:!!F.emissiveMap,emissiveMapEncoding:r(F.emissiveMap,a.gammaInput),bumpMap:!!F.bumpMap,normalMap:!!F.normalMap,objectSpaceNormalMap:1===F.normalMapType,tangentSpaceNormalMap:0===F.normalMapType,clearcoatNormalMap:!!F.clearcoatNormalMap,displacementMap:!!F.displacementMap,
roughnessMap:!!F.roughnessMap,metalnessMap:!!F.metalnessMap,specularMap:!!F.specularMap,alphaMap:!!F.alphaMap,gradientMap:!!F.gradientMap,sheen:!!F.sheen,combine:F.combine,vertexTangents:F.normalMap&&F.vertexTangents,vertexColors:F.vertexColors,vertexUvs:!!F.map||!!F.bumpMap||!!F.normalMap||!!F.specularMap||!!F.alphaMap||!!F.emissiveMap||!!F.roughnessMap||!!F.metalnessMap||!!F.clearcoatNormalMap,fog:!!R,useFog:F.fog,fogExp2:R&&R.isFogExp2,flatShading:F.flatShading,sizeAttenuation:F.sizeAttenuation,
logarithmicDepthBuffer:e.logarithmicDepthBuffer,skinning:F.skinning&&0<fa,maxBones:fa,useVertexTexture:e.floatVertexTextures,morphTargets:F.morphTargets,morphNormals:F.morphNormals,maxMorphTargets:a.maxMorphTargets,maxMorphNormals:a.maxMorphNormals,numDirLights:J.directional.length,numPointLights:J.point.length,numSpotLights:J.spot.length,numRectAreaLights:J.rectArea.length,numHemiLights:J.hemi.length,numDirLightShadows:J.directionalShadowMap.length,numPointLightShadows:J.pointShadowMap.length,numSpotLightShadows:J.spotShadowMap.length,
numClippingPlanes:S,numClipIntersection:V,dithering:F.dithering,shadowMapEnabled:a.shadowMap.enabled&&W.receiveShadow&&0<P.length,shadowMapType:a.shadowMap.type,toneMapping:F.toneMapped?a.toneMapping:0,physicallyCorrectLights:a.physicallyCorrectLights,premultipliedAlpha:F.premultipliedAlpha,alphaTest:F.alphaTest,doubleSided:2===F.side,flipSided:1===F.side,depthPacking:void 0!==F.depthPacking?F.depthPacking:!1}};this.getProgramCode=function(F,J){var P=[];J.shaderID?P.push(J.shaderID):(P.push(F.fragmentShader),
P.push(F.vertexShader));if(void 0!==F.defines)for(var R in F.defines)P.push(R),P.push(F.defines[R]);for(R=0;R<E.length;R++)P.push(J[E[R]]);P.push(F.onBeforeCompile.toString());P.push(a.gammaOutput);P.push(a.gammaFactor);return P.join()};this.acquireProgram=function(F,J,P,R){for(var S,V=0,W=v.length;V<W;V++){var ha=v[V];if(ha.code===R){S=ha;++S.usedTimes;break}}void 0===S&&(S=new Jl(a,c,R,F,J,P,e),v.push(S));return S};this.releaseProgram=function(F){0===--F.usedTimes&&(v[v.indexOf(F)]=v[v.length-1],
v.pop(),F.destroy())};this.programs=v}function Ml(){var a=new WeakMap;return{get:function(c){var e=a.get(c);void 0===e&&(e={},a.set(c,e));return e},remove:function(c){a.delete(c)},update:function(c,e,g){a.get(c)[e]=g},dispose:function(){a=new WeakMap}}}function Nl(a,c){return a.groupOrder!==c.groupOrder?a.groupOrder-c.groupOrder:a.renderOrder!==c.renderOrder?a.renderOrder-c.renderOrder:a.program!==c.program?a.program.id-c.program.id:a.material.id!==c.material.id?a.material.id-c.material.id:a.z!==
c.z?a.z-c.z:a.id-c.id}function Ol(a,c){return a.groupOrder!==c.groupOrder?a.groupOrder-c.groupOrder:a.renderOrder!==c.renderOrder?a.renderOrder-c.renderOrder:a.z!==c.z?c.z-a.z:a.id-c.id}function tj(){function a(z,E,F,J,P,R){var S=c[e];void 0===S?(S={id:z.id,object:z,geometry:E,material:F,program:F.program||v,groupOrder:J,renderOrder:z.renderOrder,z:P,group:R},c[e]=S):(S.id=z.id,S.object=z,S.geometry=E,S.material=F,S.program=F.program||v,S.groupOrder=J,S.renderOrder=z.renderOrder,S.z=P,S.group=R);
e++;return S}var c=[],e=0,g=[],r=[],v={id:-1};return{opaque:g,transparent:r,init:function(){e=0;g.length=0;r.length=0},push:function(z,E,F,J,P,R){z=a(z,E,F,J,P,R);(!0===F.transparent?r:g).push(z)},unshift:function(z,E,F,J,P,R){z=a(z,E,F,J,P,R);(!0===F.transparent?r:g).unshift(z)},sort:function(){1<g.length&&g.sort(Nl);1<r.length&&r.sort(Ol)}}}function Pl(){function a(e){e=e.target;e.removeEventListener("dispose",a);c.delete(e)}var c=new WeakMap;return{get:function(e,g){var r=c.get(e);if(void 0===
r){var v=new tj;c.set(e,new WeakMap);c.get(e).set(g,v);e.addEventListener("dispose",a)}else v=r.get(g),void 0===v&&(v=new tj,r.set(g,v));return v},dispose:function(){c=new WeakMap}}}function Ql(){var a={};return{get:function(c){if(void 0!==a[c.id])return a[c.id];switch(c.type){case "DirectionalLight":var e={direction:new k,color:new I,shadow:!1,shadowBias:0,shadowRadius:1,shadowMapSize:new f};break;case "SpotLight":e={position:new k,direction:new k,color:new I,distance:0,coneCos:0,penumbraCos:0,decay:0,
shadow:!1,shadowBias:0,shadowRadius:1,shadowMapSize:new f};break;case "PointLight":e={position:new k,color:new I,distance:0,decay:0,shadow:!1,shadowBias:0,shadowRadius:1,shadowMapSize:new f,shadowCameraNear:1,shadowCameraFar:1E3};break;case "HemisphereLight":e={direction:new k,skyColor:new I,groundColor:new I};break;case "RectAreaLight":e={color:new I,position:new k,halfWidth:new k,halfHeight:new k}}return a[c.id]=e}}}function Rl(a,c){return(c.castShadow?1:0)-(a.castShadow?1:0)}function Sl(){for(var a=
new Ql,c={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:[],directionalShadowMap:[],directionalShadowMatrix:[],spot:[],spotShadowMap:[],spotShadowMatrix:[],rectArea:[],point:[],pointShadowMap:[],pointShadowMatrix:[],hemi:[],numDirectionalShadows:-1,numPointShadows:-1,numSpotShadows:-1},e=0;9>e;e++)c.probe.push(new k);var g=new k,r=new q,v=new q;return{setup:function(z,
E,F){for(var J=0,P=0,R=0,S=0;9>S;S++)c.probe[S].set(0,0,0);var V=E=0,W=0,ha=0,fa=0,ra=0,pa=0,qa=0;F=F.matrixWorldInverse;z.sort(Rl);S=0;for(var ua=z.length;S<ua;S++){var oa=z[S],ta=oa.color,Ba=oa.intensity,Ta=oa.distance,Ua=oa.shadow&&oa.shadow.map?oa.shadow.map.texture:null;if(oa.isAmbientLight)J+=ta.r*Ba,P+=ta.g*Ba,R+=ta.b*Ba;else if(oa.isLightProbe)for(Ua=0;9>Ua;Ua++)c.probe[Ua].addScaledVector(oa.sh.coefficients[Ua],Ba);else if(oa.isDirectionalLight){var Ca=a.get(oa);Ca.color.copy(oa.color).multiplyScalar(oa.intensity);
Ca.direction.setFromMatrixPosition(oa.matrixWorld);g.setFromMatrixPosition(oa.target.matrixWorld);Ca.direction.sub(g);Ca.direction.transformDirection(F);if(Ca.shadow=oa.castShadow)Ba=oa.shadow,Ca.shadowBias=Ba.bias,Ca.shadowRadius=Ba.radius,Ca.shadowMapSize=Ba.mapSize,c.directionalShadowMap[E]=Ua,c.directionalShadowMatrix[E]=oa.shadow.matrix,ra++;c.directional[E]=Ca;E++}else if(oa.isSpotLight){Ca=a.get(oa);Ca.position.setFromMatrixPosition(oa.matrixWorld);Ca.position.applyMatrix4(F);Ca.color.copy(ta).multiplyScalar(Ba);
Ca.distance=Ta;Ca.direction.setFromMatrixPosition(oa.matrixWorld);g.setFromMatrixPosition(oa.target.matrixWorld);Ca.direction.sub(g);Ca.direction.transformDirection(F);Ca.coneCos=Math.cos(oa.angle);Ca.penumbraCos=Math.cos(oa.angle*(1-oa.penumbra));Ca.decay=oa.decay;if(Ca.shadow=oa.castShadow)Ba=oa.shadow,Ca.shadowBias=Ba.bias,Ca.shadowRadius=Ba.radius,Ca.shadowMapSize=Ba.mapSize,c.spotShadowMap[W]=Ua,c.spotShadowMatrix[W]=oa.shadow.matrix,qa++;c.spot[W]=Ca;W++}else if(oa.isRectAreaLight)Ca=a.get(oa),
Ca.color.copy(ta).multiplyScalar(Ba),Ca.position.setFromMatrixPosition(oa.matrixWorld),Ca.position.applyMatrix4(F),v.identity(),r.copy(oa.matrixWorld),r.premultiply(F),v.extractRotation(r),Ca.halfWidth.set(.5*oa.width,0,0),Ca.halfHeight.set(0,.5*oa.height,0),Ca.halfWidth.applyMatrix4(v),Ca.halfHeight.applyMatrix4(v),c.rectArea[ha]=Ca,ha++;else if(oa.isPointLight){Ca=a.get(oa);Ca.position.setFromMatrixPosition(oa.matrixWorld);Ca.position.applyMatrix4(F);Ca.color.copy(oa.color).multiplyScalar(oa.intensity);
Ca.distance=oa.distance;Ca.decay=oa.decay;if(Ca.shadow=oa.castShadow)Ba=oa.shadow,Ca.shadowBias=Ba.bias,Ca.shadowRadius=Ba.radius,Ca.shadowMapSize=Ba.mapSize,Ca.shadowCameraNear=Ba.camera.near,Ca.shadowCameraFar=Ba.camera.far,c.pointShadowMap[V]=Ua,c.pointShadowMatrix[V]=oa.shadow.matrix,pa++;c.point[V]=Ca;V++}else oa.isHemisphereLight&&(Ca=a.get(oa),Ca.direction.setFromMatrixPosition(oa.matrixWorld),Ca.direction.transformDirection(F),Ca.direction.normalize(),Ca.skyColor.copy(oa.color).multiplyScalar(Ba),
Ca.groundColor.copy(oa.groundColor).multiplyScalar(Ba),c.hemi[fa]=Ca,fa++)}c.ambient[0]=J;c.ambient[1]=P;c.ambient[2]=R;z=c.hash;if(z.directionalLength!==E||z.pointLength!==V||z.spotLength!==W||z.rectAreaLength!==ha||z.hemiLength!==fa||z.numDirectionalShadows!==ra||z.numPointShadows!==pa||z.numSpotShadows!==qa)c.directional.length=E,c.spot.length=W,c.rectArea.length=ha,c.point.length=V,c.hemi.length=fa,c.directionalShadowMap.length=ra,c.pointShadowMap.length=pa,c.spotShadowMap.length=qa,c.directionalShadowMatrix.length=
ra,c.pointShadowMatrix.length=pa,c.spotShadowMatrix.length=qa,z.directionalLength=E,z.pointLength=V,z.spotLength=W,z.rectAreaLength=ha,z.hemiLength=fa,z.numDirectionalShadows=ra,z.numPointShadows=pa,z.numSpotShadows=qa,c.version=Tl++},state:c}}function uj(){var a=new Sl,c=[],e=[];return{init:function(){c.length=0;e.length=0},state:{lightsArray:c,shadowsArray:e,lights:a},setupLights:function(g){a.setup(c,e,g)},pushLight:function(g){c.push(g)},pushShadow:function(g){e.push(g)}}}function Ul(){function a(e){e=
e.target;e.removeEventListener("dispose",a);c.delete(e)}var c=new WeakMap;return{get:function(e,g){if(!1===c.has(e)){var r=new uj;c.set(e,new WeakMap);c.get(e).set(g,r);e.addEventListener("dispose",a)}else!1===c.get(e).has(g)?(r=new uj,c.get(e).set(g,r)):r=c.get(e).get(g);return r},dispose:function(){c=new WeakMap}}}function vd(a){M.call(this);this.type="MeshDepthMaterial";this.depthPacking=3200;this.morphTargets=this.skinning=!1;this.displacementMap=this.alphaMap=this.map=null;this.displacementScale=
1;this.displacementBias=0;this.wireframe=!1;this.wireframeLinewidth=1;this.lights=this.fog=!1;this.setValues(a)}function wd(a){M.call(this);this.type="MeshDistanceMaterial";this.referencePosition=new k;this.nearDistance=1;this.farDistance=1E3;this.morphTargets=this.skinning=!1;this.displacementMap=this.alphaMap=this.map=null;this.displacementScale=1;this.displacementBias=0;this.lights=this.fog=!1;this.setValues(a)}function vj(a,c,e){function g(ta,Ba){var Ta=c.update(ra);W.uniforms.shadow_pass.value=
ta.map.texture;W.uniforms.resolution.value=ta.mapSize;W.uniforms.radius.value=ta.radius;a.setRenderTarget(ta.mapPass);a.clear();a.renderBufferDirect(Ba,null,Ta,W,ra,null);ha.uniforms.shadow_pass.value=ta.mapPass.texture;ha.uniforms.resolution.value=ta.mapSize;ha.uniforms.radius.value=ta.radius;a.setRenderTarget(ta.map);a.clear();a.renderBufferDirect(Ba,null,Ta,ha,ra,null)}function r(ta,Ba,Ta,Ua,Ca,Ha){var Da=ta.geometry;var Ma=P;var db=ta.customDepthMaterial;Ta.isPointLight&&(Ma=R,db=ta.customDistanceMaterial);
db?Ma=db:(db=!1,Ba.morphTargets&&(Da&&Da.isBufferGeometry?db=Da.morphAttributes&&Da.morphAttributes.position&&0<Da.morphAttributes.position.length:Da&&Da.isGeometry&&(db=Da.morphTargets&&0<Da.morphTargets.length)),ta.isSkinnedMesh&&!1===Ba.skinning&&console.warn("THREE.WebGLShadowMap: THREE.SkinnedMesh with material.skinning set to false:",ta),ta=ta.isSkinnedMesh&&Ba.skinning,Da=0,db&&(Da|=1),ta&&(Da|=2),Ma=Ma[Da]);a.localClippingEnabled&&!0===Ba.clipShadows&&0!==Ba.clippingPlanes.length&&(Da=Ma.uuid,
db=Ba.uuid,ta=S[Da],void 0===ta&&(ta={},S[Da]=ta),Da=ta[db],void 0===Da&&(Da=Ma.clone(),ta[db]=Da),Ma=Da);Ma.visible=Ba.visible;Ma.wireframe=Ba.wireframe;Ma.side=3===Ha?null!=Ba.shadowSide?Ba.shadowSide:Ba.side:null!=Ba.shadowSide?Ba.shadowSide:V[Ba.side];Ma.clipShadows=Ba.clipShadows;Ma.clippingPlanes=Ba.clippingPlanes;Ma.clipIntersection=Ba.clipIntersection;Ma.wireframeLinewidth=Ba.wireframeLinewidth;Ma.linewidth=Ba.linewidth;Ta.isPointLight&&Ma.isMeshDistanceMaterial&&(Ma.referencePosition.setFromMatrixPosition(Ta.matrixWorld),
Ma.nearDistance=Ua,Ma.farDistance=Ca);return Ma}function v(ta,Ba,Ta,Ua,Ca){if(!1!==ta.visible){if(ta.layers.test(Ba.layers)&&(ta.isMesh||ta.isLine||ta.isPoints)&&(ta.castShadow||ta.receiveShadow&&3===Ca)&&(!ta.frustumCulled||z.intersectsObject(ta))){ta.modelViewMatrix.multiplyMatrices(Ta.matrixWorldInverse,ta.matrixWorld);var Ha=c.update(ta),Da=ta.material;if(Array.isArray(Da))for(var Ma=Ha.groups,db=0,tb=Ma.length;db<tb;db++){var Ka=Ma[db],bb=Da[Ka.materialIndex];bb&&bb.visible&&(bb=r(ta,bb,Ua,Ta.near,
Ta.far,Ca),a.renderBufferDirect(Ta,null,Ha,bb,ta,Ka))}else Da.visible&&(bb=r(ta,Da,Ua,Ta.near,Ta.far,Ca),a.renderBufferDirect(Ta,null,Ha,bb,ta,null))}ta=ta.children;Ha=0;for(Da=ta.length;Ha<Da;Ha++)v(ta[Ha],Ba,Ta,Ua,Ca)}}var z=new ic,E=new f,F=new f,J=new p,P=Array(4),R=Array(4),S={},V={0:1,1:0,2:2},W=new qb({defines:{SAMPLE_RATE:.25,HALF_SAMPLE_RATE:.125},uniforms:{shadow_pass:{value:null},resolution:{value:new f},radius:{value:4}},vertexShader:"void main() {\n\tgl_Position \x3d vec4( position, 1.0 );\n}",
fragmentShader:"uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include \x3cpacking\x3e\nvoid main() {\n  float mean \x3d 0.0;\n  float squared_mean \x3d 0.0;\n  \n\tfloat depth \x3d unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy  ) / resolution ) );\n  for ( float i \x3d -1.0; i \x3c 1.0 ; i +\x3d SAMPLE_RATE) {\n    #ifdef HORIZONAL_PASS\n      vec2 distribution \x3d decodeHalfRGBA ( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( i, 0.0 ) * radius ) / resolution ) );\n      mean +\x3d distribution.x;\n      squared_mean +\x3d distribution.y * distribution.y + distribution.x * distribution.x;\n    #else\n      float depth \x3d unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0,  i )  * radius ) / resolution ) );\n      mean +\x3d depth;\n      squared_mean +\x3d depth * depth;\n    #endif\n  }\n  mean \x3d mean * HALF_SAMPLE_RATE;\n  squared_mean \x3d squared_mean * HALF_SAMPLE_RATE;\n  float std_dev \x3d pow( squared_mean - mean * mean, 0.5 );\n  gl_FragColor \x3d encodeHalfRGBA( vec2( mean, std_dev ) );\n}"}),
ha=W.clone();ha.defines.HORIZONAL_PASS=1;var fa=new va;fa.addAttribute("position",new Q(new Float32Array([-1,-1,.5,3,-1,.5,-1,3,.5]),3));var ra=new xa(fa,W);for(fa=0;4!==fa;++fa){var pa=0!==(fa&1),qa=0!==(fa&2),ua=new vd({depthPacking:3201,morphTargets:pa,skinning:qa});P[fa]=ua;pa=new wd({morphTargets:pa,skinning:qa});R[fa]=pa}var oa=this;this.enabled=!1;this.autoUpdate=!0;this.needsUpdate=!1;this.type=1;this.render=function(ta,Ba,Ta){if(!1!==oa.enabled&&(!1!==oa.autoUpdate||!1!==oa.needsUpdate)&&
0!==ta.length){var Ua=a.getRenderTarget(),Ca=a.getActiveCubeFace(),Ha=a.getActiveMipmapLevel(),Da=a.state;Da.setBlending(0);Da.buffers.color.setClear(1,1,1,1);Da.buffers.depth.setTest(!0);Da.setScissorTest(!1);for(var Ma=0,db=ta.length;Ma<db;Ma++){var tb=ta[Ma],Ka=tb.shadow;if(void 0===Ka)console.warn("THREE.WebGLShadowMap:",tb,"has no shadow.");else{E.copy(Ka.mapSize);var bb=Ka.getFrameExtents();E.multiply(bb);F.copy(Ka.mapSize);if(E.x>e||E.y>e)console.warn("THREE.WebGLShadowMap:",tb,"has shadow exceeding max texture size, reducing"),
E.x>e&&(F.x=Math.floor(e/bb.x),E.x=F.x*bb.x,Ka.mapSize.x=F.x),E.y>e&&(F.y=Math.floor(e/bb.y),E.y=F.y*bb.y,Ka.mapSize.y=F.y);null!==Ka.map||Ka.isPointLightShadow||3!==this.type||(bb={minFilter:1006,magFilter:1006,format:1023},Ka.map=new m(E.x,E.y,bb),Ka.map.texture.name=tb.name+".shadowMap",Ka.mapPass=new m(E.x,E.y,bb),Ka.camera.updateProjectionMatrix());null===Ka.map&&(bb={minFilter:1003,magFilter:1003,format:1023},Ka.map=new m(E.x,E.y,bb),Ka.map.texture.name=tb.name+".shadowMap",Ka.camera.updateProjectionMatrix());
a.setRenderTarget(Ka.map);a.clear();bb=Ka.getViewportCount();for(var jb=0;jb<bb;jb++){var Eb=Ka.getViewport(jb);J.set(F.x*Eb.x,F.y*Eb.y,F.x*Eb.z,F.y*Eb.w);Da.viewport(J);Ka.updateMatrices(tb,Ta,jb);z=Ka.getFrustum();v(Ba,Ta,Ka.camera,tb,this.type)}Ka.isPointLightShadow||3!==this.type||g(Ka,Ta)}}oa.needsUpdate=!1;a.setRenderTarget(Ua,Ca,Ha)}}}function Vl(a,c,e,g){function r(ja,Ga,La){var nb=new Uint8Array(4),Va=a.createTexture();a.bindTexture(ja,Va);a.texParameteri(ja,10241,9728);a.texParameteri(ja,
10240,9728);for(ja=0;ja<La;ja++)a.texImage2D(Ga+ja,0,6408,1,1,0,6408,5121,nb);return Va}function v(ja,Ga){ra[ja]=1;0===pa[ja]&&(a.enableVertexAttribArray(ja),pa[ja]=1);qa[ja]!==Ga&&((g.isWebGL2?a:c.get("ANGLE_instanced_arrays"))[g.isWebGL2?"vertexAttribDivisor":"vertexAttribDivisorANGLE"](ja,Ga),qa[ja]=Ga)}function z(ja){!0!==ua[ja]&&(a.enable(ja),ua[ja]=!0)}function E(ja){!1!==ua[ja]&&(a.disable(ja),ua[ja]=!1)}function F(ja,Ga,La,nb,Va,ib,kb,Qa){if(0===ja)Ba&&(E(3042),Ba=!1);else if(Ba||(z(3042),
Ba=!0),5!==ja){if(ja!==Ta||Qa!==tb){if(100!==Ua||100!==Da)a.blendEquation(32774),Da=Ua=100;if(Qa)switch(ja){case 1:a.blendFuncSeparate(1,771,1,771);break;case 2:a.blendFunc(1,1);break;case 3:a.blendFuncSeparate(0,0,769,771);break;case 4:a.blendFuncSeparate(0,768,0,770);break;default:console.error("THREE.WebGLState: Invalid blending: ",ja)}else switch(ja){case 1:a.blendFuncSeparate(770,771,1,771);break;case 2:a.blendFunc(770,1);break;case 3:a.blendFunc(0,769);break;case 4:a.blendFunc(0,768);break;
default:console.error("THREE.WebGLState: Invalid blending: ",ja)}db=Ma=Ha=Ca=null;Ta=ja;tb=Qa}}else{Va=Va||Ga;ib=ib||La;kb=kb||nb;if(Ga!==Ua||Va!==Da)a.blendEquationSeparate(e.convert(Ga),e.convert(Va)),Ua=Ga,Da=Va;if(La!==Ca||nb!==Ha||ib!==Ma||kb!==db)a.blendFuncSeparate(e.convert(La),e.convert(nb),e.convert(ib),e.convert(kb)),Ca=La,Ha=nb,Ma=ib,db=kb;Ta=ja;tb=null}}function J(ja){Ka!==ja&&(ja?a.frontFace(2304):a.frontFace(2305),Ka=ja)}function P(ja){0!==ja?(z(2884),ja!==bb&&(1===ja?a.cullFace(1029):
2===ja?a.cullFace(1028):a.cullFace(1032))):E(2884);bb=ja}function R(ja,Ga,La){if(ja){if(z(32823),Eb!==Ga||xb!==La)a.polygonOffset(Ga,La),Eb=Ga,xb=La}else E(32823)}function S(ja){void 0===ja&&(ja=33984+ia-1);za!==ja&&(a.activeTexture(ja),za=ja)}var V=new function(){var ja=!1,Ga=new p,La=null,nb=new p(0,0,0,0);return{setMask:function(Va){La===Va||ja||(a.colorMask(Va,Va,Va,Va),La=Va)},setLocked:function(Va){ja=Va},setClear:function(Va,ib,kb,Qa,eb){!0===eb&&(Va*=Qa,ib*=Qa,kb*=Qa);Ga.set(Va,ib,kb,Qa);
!1===nb.equals(Ga)&&(a.clearColor(Va,ib,kb,Qa),nb.copy(Ga))},reset:function(){ja=!1;La=null;nb.set(-1,0,0,0)}}},W=new function(){var ja=!1,Ga=null,La=null,nb=null;return{setTest:function(Va){Va?z(2929):E(2929)},setMask:function(Va){Ga===Va||ja||(a.depthMask(Va),Ga=Va)},setFunc:function(Va){if(La!==Va){if(Va)switch(Va){case 0:a.depthFunc(512);break;case 1:a.depthFunc(519);break;case 2:a.depthFunc(513);break;case 3:a.depthFunc(515);break;case 4:a.depthFunc(514);break;case 5:a.depthFunc(518);break;case 6:a.depthFunc(516);
break;case 7:a.depthFunc(517);break;default:a.depthFunc(515)}else a.depthFunc(515);La=Va}},setLocked:function(Va){ja=Va},setClear:function(Va){nb!==Va&&(a.clearDepth(Va),nb=Va)},reset:function(){ja=!1;nb=La=Ga=null}}},ha=new function(){var ja=!1,Ga=null,La=null,nb=null,Va=null,ib=null,kb=null,Qa=null,eb=null;return{setTest:function(mb){ja||(mb?z(2960):E(2960))},setMask:function(mb){Ga===mb||ja||(a.stencilMask(mb),Ga=mb)},setFunc:function(mb,pb,sb){if(La!==mb||nb!==pb||Va!==sb)a.stencilFunc(mb,pb,
sb),La=mb,nb=pb,Va=sb},setOp:function(mb,pb,sb){if(ib!==mb||kb!==pb||Qa!==sb)a.stencilOp(mb,pb,sb),ib=mb,kb=pb,Qa=sb},setLocked:function(mb){ja=mb},setClear:function(mb){eb!==mb&&(a.clearStencil(mb),eb=mb)},reset:function(){ja=!1;eb=Qa=kb=ib=Va=nb=La=Ga=null}}},fa=a.getParameter(34921),ra=new Uint8Array(fa),pa=new Uint8Array(fa),qa=new Uint8Array(fa),ua={},oa=null,ta=null,Ba=null,Ta=null,Ua=null,Ca=null,Ha=null,Da=null,Ma=null,db=null,tb=!1,Ka=null,bb=null,jb=null,Eb=null,xb=null,ia=a.getParameter(35661),
na=!1;fa=0;fa=a.getParameter(7938);-1!==fa.indexOf("WebGL")?(fa=parseFloat(/^WebGL ([0-9])/.exec(fa)[1]),na=1<=fa):-1!==fa.indexOf("OpenGL ES")&&(fa=parseFloat(/^OpenGL ES ([0-9])/.exec(fa)[1]),na=2<=fa);var za=null,Ja={},Ya=new p,Na=new p,cb={};cb[3553]=r(3553,3553,1);cb[34067]=r(34067,34069,6);V.setClear(0,0,0,1);W.setClear(1);ha.setClear(0);z(2929);W.setFunc(3);J(!1);P(1);z(2884);F(0);return{buffers:{color:V,depth:W,stencil:ha},initAttributes:function(){for(var ja=0,Ga=ra.length;ja<Ga;ja++)ra[ja]=
0},enableAttribute:function(ja){v(ja,0)},enableAttributeAndDivisor:v,disableUnusedAttributes:function(){for(var ja=0,Ga=pa.length;ja!==Ga;++ja)pa[ja]!==ra[ja]&&(a.disableVertexAttribArray(ja),pa[ja]=0)},enable:z,disable:E,getCompressedTextureFormats:function(){if(null===oa&&(oa=[],c.get("WEBGL_compressed_texture_pvrtc")||c.get("WEBGL_compressed_texture_s3tc")||c.get("WEBGL_compressed_texture_etc1")||c.get("WEBGL_compressed_texture_astc")))for(var ja=a.getParameter(34467),Ga=0;Ga<ja.length;Ga++)oa.push(ja[Ga]);
return oa},useProgram:function(ja){return ta!==ja?(a.useProgram(ja),ta=ja,!0):!1},setBlending:F,setMaterial:function(ja,Ga){2===ja.side?E(2884):z(2884);var La=1===ja.side;Ga&&(La=!La);J(La);1===ja.blending&&!1===ja.transparent?F(0):F(ja.blending,ja.blendEquation,ja.blendSrc,ja.blendDst,ja.blendEquationAlpha,ja.blendSrcAlpha,ja.blendDstAlpha,ja.premultipliedAlpha);W.setFunc(ja.depthFunc);W.setTest(ja.depthTest);W.setMask(ja.depthWrite);V.setMask(ja.colorWrite);Ga=ja.stencilWrite;ha.setTest(Ga);Ga&&
(ha.setFunc(ja.stencilFunc,ja.stencilRef,ja.stencilMask),ha.setOp(ja.stencilFail,ja.stencilZFail,ja.stencilZPass));R(ja.polygonOffset,ja.polygonOffsetFactor,ja.polygonOffsetUnits)},setFlipSided:J,setCullFace:P,setLineWidth:function(ja){ja!==jb&&(na&&a.lineWidth(ja),jb=ja)},setPolygonOffset:R,setScissorTest:function(ja){ja?z(3089):E(3089)},activeTexture:S,bindTexture:function(ja,Ga){null===za&&S();var La=Ja[za];void 0===La&&(La={type:void 0,texture:void 0},Ja[za]=La);if(La.type!==ja||La.texture!==
Ga)a.bindTexture(ja,Ga||cb[ja]),La.type=ja,La.texture=Ga},compressedTexImage2D:function(){try{a.compressedTexImage2D.apply(a,arguments)}catch(ja){console.error("THREE.WebGLState:",ja)}},texImage2D:function(){try{a.texImage2D.apply(a,arguments)}catch(ja){console.error("THREE.WebGLState:",ja)}},texImage3D:function(){try{a.texImage3D.apply(a,arguments)}catch(ja){console.error("THREE.WebGLState:",ja)}},scissor:function(ja){!1===Ya.equals(ja)&&(a.scissor(ja.x,ja.y,ja.z,ja.w),Ya.copy(ja))},viewport:function(ja){!1===
Na.equals(ja)&&(a.viewport(ja.x,ja.y,ja.z,ja.w),Na.copy(ja))},reset:function(){for(var ja=0;ja<pa.length;ja++)1===pa[ja]&&(a.disableVertexAttribArray(ja),pa[ja]=0);ua={};za=oa=null;Ja={};bb=Ka=Ta=ta=null;V.reset();W.reset();ha.reset()}}}function Wl(a,c,e,g,r,v,z){function E(ia,na){return bb?new OffscreenCanvas(ia,na):document.createElementNS("http://www.w3.org/1999/xhtml","canvas")}function F(ia,na,za,Ja){var Ya=1;if(ia.width>Ja||ia.height>Ja)Ya=Ja/Math.max(ia.width,ia.height);if(1>Ya||!0===na){if("undefined"!==
typeof HTMLImageElement&&ia instanceof HTMLImageElement||"undefined"!==typeof HTMLCanvasElement&&ia instanceof HTMLCanvasElement||"undefined"!==typeof ImageBitmap&&ia instanceof ImageBitmap)return Ja=na?hb.floorPowerOfTwo:Math.floor,na=Ja(Ya*ia.width),Ya=Ja(Ya*ia.height),void 0===Ka&&(Ka=E(na,Ya)),za=za?E(na,Ya):Ka,za.width=na,za.height=Ya,za.getContext("2d").drawImage(ia,0,0,na,Ya),console.warn("THREE.WebGLRenderer: Texture has been resized from ("+ia.width+"x"+ia.height+") to ("+na+"x"+Ya+")."),
za;"data"in ia&&console.warn("THREE.WebGLRenderer: Image in DataTexture is too big ("+ia.width+"x"+ia.height+").")}return ia}function J(ia){return hb.isPowerOfTwo(ia.width)&&hb.isPowerOfTwo(ia.height)}function P(ia){return r.isWebGL2?!1:1001!==ia.wrapS||1001!==ia.wrapT||1003!==ia.minFilter&&1006!==ia.minFilter}function R(ia,na){return ia.generateMipmaps&&na&&1003!==ia.minFilter&&1006!==ia.minFilter}function S(ia,na,za,Ja){a.generateMipmap(ia);g.get(na).__maxMipLevel=Math.log(Math.max(za,Ja))*Math.LOG2E}
function V(ia,na){if(!r.isWebGL2)return ia;var za=ia;6403===ia&&(5126===na&&(za=33326),5131===na&&(za=33325),5121===na&&(za=33321));6407===ia&&(5126===na&&(za=34837),5131===na&&(za=34843),5121===na&&(za=32849));6408===ia&&(5126===na&&(za=34836),5131===na&&(za=34842),5121===na&&(za=32856));33325===za||33326===za||34842===za||34836===za?c.get("EXT_color_buffer_float"):(34843===za||34837===za)&&console.warn("THREE.WebGLRenderer: Floating point textures with RGB format not supported. Please use RGBA instead.");
return za}function W(ia){return 1003===ia||1004===ia||1005===ia?9728:9729}function ha(ia){ia=ia.target;ia.removeEventListener("dispose",ha);ra(ia);ia.isVideoTexture&&tb.delete(ia);z.memory.textures--}function fa(ia){ia=ia.target;ia.removeEventListener("dispose",fa);pa(ia);z.memory.textures--}function ra(ia){var na=g.get(ia);void 0!==na.__webglInit&&(a.deleteTexture(na.__webglTexture),g.remove(ia))}function pa(ia){var na=g.get(ia),za=g.get(ia.texture);if(ia){void 0!==za.__webglTexture&&a.deleteTexture(za.__webglTexture);
ia.depthTexture&&ia.depthTexture.dispose();if(ia.isWebGLRenderTargetCube)for(za=0;6>za;za++)a.deleteFramebuffer(na.__webglFramebuffer[za]),na.__webglDepthbuffer&&a.deleteRenderbuffer(na.__webglDepthbuffer[za]);else a.deleteFramebuffer(na.__webglFramebuffer),na.__webglDepthbuffer&&a.deleteRenderbuffer(na.__webglDepthbuffer);g.remove(ia.texture);g.remove(ia)}}function qa(ia,na){var za=g.get(ia);ia.isVideoTexture&&db(ia);if(0<ia.version&&za.__version!==ia.version){var Ja=ia.image;if(void 0===Ja)console.warn("THREE.WebGLRenderer: Texture marked for update but image is undefined");
else if(!1===Ja.complete)console.warn("THREE.WebGLRenderer: Texture marked for update but image is incomplete");else{Ta(za,ia,na);return}}e.activeTexture(33984+na);e.bindTexture(3553,za.__webglTexture)}function ua(ia,na){if(6===ia.image.length){var za=g.get(ia);if(0<ia.version&&za.__version!==ia.version){Ba(za,ia);e.activeTexture(33984+na);e.bindTexture(34067,za.__webglTexture);a.pixelStorei(37440,ia.flipY);var Ja=ia&&ia.isCompressedTexture;na=ia.image[0]&&ia.image[0].isDataTexture;for(var Ya=[],
Na=0;6>Na;Na++)Ya[Na]=Ja||na?na?ia.image[Na].image:ia.image[Na]:F(ia.image[Na],!1,!0,r.maxCubemapSize);var cb=Ya[0],ja=J(cb)||r.isWebGL2,Ga=v.convert(ia.format),La=v.convert(ia.type),nb=V(Ga,La);ta(34067,ia,ja);if(Ja){for(Na=0;6>Na;Na++){var Va=Ya[Na].mipmaps;for(Ja=0;Ja<Va.length;Ja++){var ib=Va[Ja];1023!==ia.format&&1022!==ia.format?-1<e.getCompressedTextureFormats().indexOf(Ga)?e.compressedTexImage2D(34069+Na,Ja,nb,ib.width,ib.height,0,ib.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()"):
e.texImage2D(34069+Na,Ja,nb,ib.width,ib.height,0,Ga,La,ib.data)}}za.__maxMipLevel=Va.length-1}else{Va=ia.mipmaps;for(Na=0;6>Na;Na++)if(na)for(e.texImage2D(34069+Na,0,nb,Ya[Na].width,Ya[Na].height,0,Ga,La,Ya[Na].data),Ja=0;Ja<Va.length;Ja++)ib=Va[Ja],ib=ib.image[Na].image,e.texImage2D(34069+Na,Ja+1,nb,ib.width,ib.height,0,Ga,La,ib.data);else for(e.texImage2D(34069+Na,0,nb,Ga,La,Ya[Na]),Ja=0;Ja<Va.length;Ja++)ib=Va[Ja],e.texImage2D(34069+Na,Ja+1,nb,Ga,La,ib.image[Na]);za.__maxMipLevel=Va.length}R(ia,
ja)&&S(34067,ia,cb.width,cb.height);za.__version=ia.version;if(ia.onUpdate)ia.onUpdate(ia)}else e.activeTexture(33984+na),e.bindTexture(34067,za.__webglTexture)}}function oa(ia,na){e.activeTexture(33984+na);e.bindTexture(34067,g.get(ia).__webglTexture)}function ta(ia,na,za){za?(a.texParameteri(ia,10242,v.convert(na.wrapS)),a.texParameteri(ia,10243,v.convert(na.wrapT)),32879!==ia&&35866!==ia||a.texParameteri(ia,32882,v.convert(na.wrapR)),a.texParameteri(ia,10240,v.convert(na.magFilter)),a.texParameteri(ia,
10241,v.convert(na.minFilter))):(a.texParameteri(ia,10242,33071),a.texParameteri(ia,10243,33071),32879!==ia&&35866!==ia||a.texParameteri(ia,32882,33071),1001===na.wrapS&&1001===na.wrapT||console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping."),a.texParameteri(ia,10240,W(na.magFilter)),a.texParameteri(ia,10241,W(na.minFilter)),1003!==na.minFilter&&1006!==na.minFilter&&console.warn("THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter."));
!(za=c.get("EXT_texture_filter_anisotropic"))||1015===na.type&&null===c.get("OES_texture_float_linear")||1016===na.type&&null===(r.isWebGL2||c.get("OES_texture_half_float_linear"))||!(1<na.anisotropy||g.get(na).__currentAnisotropy)||(a.texParameterf(ia,za.TEXTURE_MAX_ANISOTROPY_EXT,Math.min(na.anisotropy,r.getMaxAnisotropy())),g.get(na).__currentAnisotropy=na.anisotropy)}function Ba(ia,na){void 0===ia.__webglInit&&(ia.__webglInit=!0,na.addEventListener("dispose",ha),ia.__webglTexture=a.createTexture(),
z.memory.textures++)}function Ta(ia,na,za){var Ja=3553;na.isDataTexture2DArray&&(Ja=35866);na.isDataTexture3D&&(Ja=32879);Ba(ia,na);e.activeTexture(33984+za);e.bindTexture(Ja,ia.__webglTexture);a.pixelStorei(37440,na.flipY);a.pixelStorei(37441,na.premultiplyAlpha);a.pixelStorei(3317,na.unpackAlignment);za=P(na)&&!1===J(na.image);za=F(na.image,za,!1,r.maxTextureSize);var Ya=J(za)||r.isWebGL2,Na=v.convert(na.format),cb=v.convert(na.type),ja=V(Na,cb);ta(Ja,na,Ya);var Ga=na.mipmaps;if(na.isDepthTexture){ja=
6402;if(1015===na.type){if(!r.isWebGL2)throw Error("Float Depth Texture only supported in WebGL2.0");ja=36012}else r.isWebGL2&&(ja=33189);1026===na.format&&6402===ja&&1012!==na.type&&1014!==na.type&&(console.warn("THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture."),na.type=1012,cb=v.convert(na.type));1027===na.format&&(ja=34041,1020!==na.type&&(console.warn("THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture."),na.type=1020,cb=
v.convert(na.type)));e.texImage2D(3553,0,ja,za.width,za.height,0,Na,cb,null)}else if(na.isDataTexture)if(0<Ga.length&&Ya){for(var La=0,nb=Ga.length;La<nb;La++)Ja=Ga[La],e.texImage2D(3553,La,ja,Ja.width,Ja.height,0,Na,cb,Ja.data);na.generateMipmaps=!1;ia.__maxMipLevel=Ga.length-1}else e.texImage2D(3553,0,ja,za.width,za.height,0,Na,cb,za.data),ia.__maxMipLevel=0;else if(na.isCompressedTexture){La=0;for(nb=Ga.length;La<nb;La++)Ja=Ga[La],1023!==na.format&&1022!==na.format?-1<e.getCompressedTextureFormats().indexOf(Na)?
e.compressedTexImage2D(3553,La,ja,Ja.width,Ja.height,0,Ja.data):console.warn("THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()"):e.texImage2D(3553,La,ja,Ja.width,Ja.height,0,Na,cb,Ja.data);ia.__maxMipLevel=Ga.length-1}else if(na.isDataTexture2DArray)e.texImage3D(35866,0,ja,za.width,za.height,za.depth,0,Na,cb,za.data),ia.__maxMipLevel=0;else if(na.isDataTexture3D)e.texImage3D(32879,0,ja,za.width,za.height,za.depth,0,Na,cb,za.data),ia.__maxMipLevel=0;else if(0<
Ga.length&&Ya){La=0;for(nb=Ga.length;La<nb;La++)Ja=Ga[La],e.texImage2D(3553,La,ja,Na,cb,Ja);na.generateMipmaps=!1;ia.__maxMipLevel=Ga.length-1}else e.texImage2D(3553,0,ja,Na,cb,za),ia.__maxMipLevel=0;R(na,Ya)&&S(3553,na,za.width,za.height);ia.__version=na.version;if(na.onUpdate)na.onUpdate(na)}function Ua(ia,na,za,Ja){var Ya=v.convert(na.texture.format),Na=v.convert(na.texture.type),cb=V(Ya,Na);e.texImage2D(Ja,0,cb,na.width,na.height,0,Ya,Na,null);a.bindFramebuffer(36160,ia);a.framebufferTexture2D(36160,
za,Ja,g.get(na.texture).__webglTexture,0);a.bindFramebuffer(36160,null)}function Ca(ia,na,za){a.bindRenderbuffer(36161,ia);if(na.depthBuffer&&!na.stencilBuffer)za?(za=Ma(na),a.renderbufferStorageMultisample(36161,za,33189,na.width,na.height)):a.renderbufferStorage(36161,33189,na.width,na.height),a.framebufferRenderbuffer(36160,36096,36161,ia);else if(na.depthBuffer&&na.stencilBuffer)za?(za=Ma(na),a.renderbufferStorageMultisample(36161,za,35056,na.width,na.height)):a.renderbufferStorage(36161,34041,
na.width,na.height),a.framebufferRenderbuffer(36160,33306,36161,ia);else{ia=v.convert(na.texture.format);var Ja=v.convert(na.texture.type);ia=V(ia,Ja);za?(za=Ma(na),a.renderbufferStorageMultisample(36161,za,ia,na.width,na.height)):a.renderbufferStorage(36161,ia,na.width,na.height)}a.bindRenderbuffer(36161,null)}function Ha(ia,na){if(na&&na.isWebGLRenderTargetCube)throw Error("Depth Texture with cube render targets is not supported");a.bindFramebuffer(36160,ia);if(!na.depthTexture||!na.depthTexture.isDepthTexture)throw Error("renderTarget.depthTexture must be an instance of THREE.DepthTexture");
g.get(na.depthTexture).__webglTexture&&na.depthTexture.image.width===na.width&&na.depthTexture.image.height===na.height||(na.depthTexture.image.width=na.width,na.depthTexture.image.height=na.height,na.depthTexture.needsUpdate=!0);qa(na.depthTexture,0);ia=g.get(na.depthTexture).__webglTexture;if(1026===na.depthTexture.format)a.framebufferTexture2D(36160,36096,3553,ia,0);else if(1027===na.depthTexture.format)a.framebufferTexture2D(36160,33306,3553,ia,0);else throw Error("Unknown depthTexture format");
}function Da(ia){var na=g.get(ia),za=!0===ia.isWebGLRenderTargetCube;if(ia.depthTexture){if(za)throw Error("target.depthTexture not supported in Cube render targets");Ha(na.__webglFramebuffer,ia)}else if(za)for(na.__webglDepthbuffer=[],za=0;6>za;za++)a.bindFramebuffer(36160,na.__webglFramebuffer[za]),na.__webglDepthbuffer[za]=a.createRenderbuffer(),Ca(na.__webglDepthbuffer[za],ia);else a.bindFramebuffer(36160,na.__webglFramebuffer),na.__webglDepthbuffer=a.createRenderbuffer(),Ca(na.__webglDepthbuffer,
ia);a.bindFramebuffer(36160,null)}function Ma(ia){return r.isWebGL2&&ia.isWebGLMultisampleRenderTarget?Math.min(r.maxSamples,ia.samples):0}function db(ia){var na=z.render.frame;tb.get(ia)!==na&&(tb.set(ia,na),ia.update())}var tb=new WeakMap,Ka,bb="undefined"!==typeof OffscreenCanvas,jb=0,Eb=!1,xb=!1;this.allocateTextureUnit=function(){var ia=jb;ia>=r.maxTextures&&console.warn("THREE.WebGLTextures: Trying to use "+ia+" texture units while this GPU supports only "+r.maxTextures);jb+=1;return ia};this.resetTextureUnits=
function(){jb=0};this.setTexture2D=qa;this.setTexture2DArray=function(ia,na){var za=g.get(ia);0<ia.version&&za.__version!==ia.version?Ta(za,ia,na):(e.activeTexture(33984+na),e.bindTexture(35866,za.__webglTexture))};this.setTexture3D=function(ia,na){var za=g.get(ia);0<ia.version&&za.__version!==ia.version?Ta(za,ia,na):(e.activeTexture(33984+na),e.bindTexture(32879,za.__webglTexture))};this.setTextureCube=ua;this.setTextureCubeDynamic=oa;this.setupRenderTarget=function(ia){var na=g.get(ia),za=g.get(ia.texture);
ia.addEventListener("dispose",fa);za.__webglTexture=a.createTexture();z.memory.textures++;var Ja=!0===ia.isWebGLRenderTargetCube,Ya=!0===ia.isWebGLMultisampleRenderTarget,Na=J(ia)||r.isWebGL2;if(Ja)for(na.__webglFramebuffer=[],Ya=0;6>Ya;Ya++)na.__webglFramebuffer[Ya]=a.createFramebuffer();else if(na.__webglFramebuffer=a.createFramebuffer(),Ya)if(r.isWebGL2){na.__webglMultisampledFramebuffer=a.createFramebuffer();na.__webglColorRenderbuffer=a.createRenderbuffer();a.bindRenderbuffer(36161,na.__webglColorRenderbuffer);
Ya=v.convert(ia.texture.format);var cb=v.convert(ia.texture.type);Ya=V(Ya,cb);cb=Ma(ia);a.renderbufferStorageMultisample(36161,cb,Ya,ia.width,ia.height);a.bindFramebuffer(36160,na.__webglMultisampledFramebuffer);a.framebufferRenderbuffer(36160,36064,36161,na.__webglColorRenderbuffer);a.bindRenderbuffer(36161,null);ia.depthBuffer&&(na.__webglDepthRenderbuffer=a.createRenderbuffer(),Ca(na.__webglDepthRenderbuffer,ia,!0));a.bindFramebuffer(36160,null)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.");
if(Ja){e.bindTexture(34067,za.__webglTexture);ta(34067,ia.texture,Na);for(Ya=0;6>Ya;Ya++)Ua(na.__webglFramebuffer[Ya],ia,36064,34069+Ya);R(ia.texture,Na)&&S(34067,ia.texture,ia.width,ia.height);e.bindTexture(34067,null)}else e.bindTexture(3553,za.__webglTexture),ta(3553,ia.texture,Na),Ua(na.__webglFramebuffer,ia,36064,3553),R(ia.texture,Na)&&S(3553,ia.texture,ia.width,ia.height),e.bindTexture(3553,null);ia.depthBuffer&&Da(ia)};this.updateRenderTargetMipmap=function(ia){var na=ia.texture,za=J(ia)||
r.isWebGL2;if(R(na,za)){za=ia.isWebGLRenderTargetCube?34067:3553;var Ja=g.get(na).__webglTexture;e.bindTexture(za,Ja);S(za,na,ia.width,ia.height);e.bindTexture(za,null)}};this.updateMultisampleRenderTarget=function(ia){if(ia.isWebGLMultisampleRenderTarget)if(r.isWebGL2){var na=g.get(ia);a.bindFramebuffer(36008,na.__webglMultisampledFramebuffer);a.bindFramebuffer(36009,na.__webglFramebuffer);na=ia.width;var za=ia.height,Ja=16384;ia.depthBuffer&&(Ja|=256);ia.stencilBuffer&&(Ja|=1024);a.blitFramebuffer(0,
0,na,za,0,0,na,za,Ja,9728)}else console.warn("THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.")};this.safeSetTexture2D=function(ia,na){ia&&ia.isWebGLRenderTarget&&(!1===Eb&&(console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead."),Eb=!0),ia=ia.texture);qa(ia,na)};this.safeSetTextureCube=function(ia,na){ia&&ia.isWebGLRenderTargetCube&&(!1===xb&&(console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead."),
xb=!0),ia=ia.texture);ia&&ia.isCubeTexture||Array.isArray(ia.image)&&6===ia.image.length?ua(ia,na):oa(ia,na)}}function wj(a,c,e){return{convert:function(g){if(1E3===g)return 10497;if(1001===g)return 33071;if(1002===g)return 33648;if(1003===g)return 9728;if(1004===g)return 9984;if(1005===g)return 9986;if(1006===g)return 9729;if(1007===g)return 9985;if(1008===g)return 9987;if(1009===g)return 5121;if(1017===g)return 32819;if(1018===g)return 32820;if(1019===g)return 33635;if(1010===g)return 5120;if(1011===
g)return 5122;if(1012===g)return 5123;if(1013===g)return 5124;if(1014===g)return 5125;if(1015===g)return 5126;if(1016===g){if(e.isWebGL2)return 5131;var r=c.get("OES_texture_half_float");if(null!==r)return r.HALF_FLOAT_OES}if(1021===g)return 6406;if(1022===g)return 6407;if(1023===g)return 6408;if(1024===g)return 6409;if(1025===g)return 6410;if(1026===g)return 6402;if(1027===g)return 34041;if(1028===g)return 6403;if(100===g)return 32774;if(101===g)return 32778;if(102===g)return 32779;if(200===g)return 0;
if(201===g)return 1;if(202===g)return 768;if(203===g)return 769;if(204===g)return 770;if(205===g)return 771;if(206===g)return 772;if(207===g)return 773;if(208===g)return 774;if(209===g)return 775;if(210===g)return 776;if(33776===g||33777===g||33778===g||33779===g)if(r=c.get("WEBGL_compressed_texture_s3tc"),null!==r){if(33776===g)return r.COMPRESSED_RGB_S3TC_DXT1_EXT;if(33777===g)return r.COMPRESSED_RGBA_S3TC_DXT1_EXT;if(33778===g)return r.COMPRESSED_RGBA_S3TC_DXT3_EXT;if(33779===g)return r.COMPRESSED_RGBA_S3TC_DXT5_EXT}if(35840===
g||35841===g||35842===g||35843===g)if(r=c.get("WEBGL_compressed_texture_pvrtc"),null!==r){if(35840===g)return r.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;if(35841===g)return r.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;if(35842===g)return r.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;if(35843===g)return r.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG}if(36196===g&&(r=c.get("WEBGL_compressed_texture_etc1"),null!==r))return r.COMPRESSED_RGB_ETC1_WEBGL;if(37808===g||37809===g||37810===g||37811===g||37812===g||37813===g||37814===g||37815===g||37816===
g||37817===g||37818===g||37819===g||37820===g||37821===g)if(r=c.get("WEBGL_compressed_texture_astc"),null!==r)return g;if(103===g||104===g){if(e.isWebGL2){if(103===g)return 32775;if(104===g)return 32776}r=c.get("EXT_blend_minmax");if(null!==r){if(103===g)return r.MIN_EXT;if(104===g)return r.MAX_EXT}}if(1020===g){if(e.isWebGL2)return 34042;r=c.get("WEBGL_depth_texture");if(null!==r)return r.UNSIGNED_INT_24_8_WEBGL}return 0}}}function ue(){A.call(this);this.type="Group"}function vf(a){vb.call(this);
this.cameras=a||[]}function xj(a,c,e){yj.setFromMatrixPosition(c.matrixWorld);zj.setFromMatrixPosition(e.matrixWorld);var g=yj.distanceTo(zj),r=c.projectionMatrix.elements,v=e.projectionMatrix.elements,z=r[14]/(r[10]-1);e=r[14]/(r[10]+1);var E=(r[9]+1)/r[5],F=(r[9]-1)/r[5],J=(r[8]-1)/r[0],P=(v[8]+1)/v[0];r=z*J;v=z*P;P=g/(-J+P);J=P*-J;c.matrixWorld.decompose(a.position,a.quaternion,a.scale);a.translateX(J);a.translateZ(P);a.matrixWorld.compose(a.position,a.quaternion,a.scale);a.matrixWorldInverse.getInverse(a.matrixWorld);
c=z+P;z=e+P;a.projectionMatrix.makePerspective(r-J,v+(g-J),E*e/z*c,F*e/z*c,c,z)}function Nh(a){function c(){return null!==J&&!0===J.isPresenting}function e(){if(c()){var Ha=J.getEyeParameters("left");z=2*Ha.renderWidth*ha;E=Ha.renderHeight*ha;Ta=a.getPixelRatio();a.getSize(Ba);a.setDrawingBufferSize(z,E,1);ua.viewport.set(0,0,z/2,E);oa.viewport.set(z/2,0,z/2,E);Ca.start();F.dispatchEvent({type:"sessionstart"})}else F.enabled&&a.setDrawingBufferSize(Ba.width,Ba.height,Ta),Ca.stop(),F.dispatchEvent({type:"sessionend"})}
function g(Ha){for(var Da=navigator.getGamepads&&navigator.getGamepads(),Ma=0,db=0,tb=Da.length;Ma<tb;Ma++){var Ka=Da[Ma];if(Ka&&("Daydream Controller"===Ka.id||"Gear VR Controller"===Ka.id||"Oculus Go Controller"===Ka.id||"OpenVR Gamepad"===Ka.id||Ka.id.startsWith("Oculus Touch")||Ka.id.startsWith("HTC Vive Focus")||Ka.id.startsWith("Spatial Controller"))){if(db===Ha)return Ka;db++}}}function r(){for(var Ha=0;Ha<S.length;Ha++){var Da=S[Ha],Ma=g(Ha);if(void 0!==Ma&&void 0!==Ma.pose){if(null===Ma.pose)break;
var db=Ma.pose;!1===db.hasPosition&&Da.position.set(.2,-.6,-.05);null!==db.position&&Da.position.fromArray(db.position);null!==db.orientation&&Da.quaternion.fromArray(db.orientation);Da.matrix.compose(Da.position,Da.quaternion,Da.scale);Da.matrix.premultiply(V);Da.matrix.decompose(Da.position,Da.quaternion,Da.scale);Da.matrixWorldNeedsUpdate=!0;Da.visible=!0;db="Daydream Controller"===Ma.id?0:1;void 0===Ua[Ha]&&(Ua[Ha]=!1);Ua[Ha]!==Ma.buttons[db].pressed&&(Ua[Ha]=Ma.buttons[db].pressed,!0===Ua[Ha]?
Da.dispatchEvent({type:"selectstart"}):(Da.dispatchEvent({type:"selectend"}),Da.dispatchEvent({type:"select"})))}else Da.visible=!1}}function v(Ha,Da){null!==Da&&4===Da.length&&Ha.set(Da[0]*z,Da[1]*E,Da[2]*z,Da[3]*E)}var z,E,F=this,J=null,P=null,R=null,S=[],V=new q,W=new q,ha=1,fa="local-floor";"undefined"!==typeof window&&"VRFrameData"in window&&(P=new window.VRFrameData,window.addEventListener("vrdisplaypresentchange",e,!1));var ra=new q,pa=new h,qa=new k,ua=new vb;ua.viewport=new p;ua.layers.enable(1);
var oa=new vb;oa.viewport=new p;oa.layers.enable(2);var ta=new vf([ua,oa]);ta.layers.enable(1);ta.layers.enable(2);var Ba=new f,Ta,Ua=[];this.enabled=!1;this.getController=function(Ha){var Da=S[Ha];void 0===Da&&(Da=new ue,Da.matrixAutoUpdate=!1,Da.visible=!1,S[Ha]=Da);return Da};this.getDevice=function(){return J};this.setDevice=function(Ha){void 0!==Ha&&(J=Ha);Ca.setContext(Ha)};this.setFramebufferScaleFactor=function(Ha){ha=Ha};this.setReferenceSpaceType=function(Ha){fa=Ha};this.setPoseTarget=function(Ha){void 0!==
Ha&&(R=Ha)};this.getCamera=function(Ha){var Da="local-floor"===fa?1.6:0;if(!1===c())return Ha.position.set(0,Da,0),Ha.rotation.set(0,0,0),Ha;J.depthNear=Ha.near;J.depthFar=Ha.far;J.getFrameData(P);if("local-floor"===fa){var Ma=J.stageParameters;Ma?V.fromArray(Ma.sittingToStandingTransform):V.makeTranslation(0,Da,0)}Da=P.pose;Ma=null!==R?R:Ha;Ma.matrix.copy(V);Ma.matrix.decompose(Ma.position,Ma.quaternion,Ma.scale);null!==Da.orientation&&(pa.fromArray(Da.orientation),Ma.quaternion.multiply(pa));null!==
Da.position&&(pa.setFromRotationMatrix(V),qa.fromArray(Da.position),qa.applyQuaternion(pa),Ma.position.add(qa));Ma.updateMatrixWorld();ua.near=Ha.near;oa.near=Ha.near;ua.far=Ha.far;oa.far=Ha.far;ua.matrixWorldInverse.fromArray(P.leftViewMatrix);oa.matrixWorldInverse.fromArray(P.rightViewMatrix);W.getInverse(V);"local-floor"===fa&&(ua.matrixWorldInverse.multiply(W),oa.matrixWorldInverse.multiply(W));Ha=Ma.parent;null!==Ha&&(ra.getInverse(Ha.matrixWorld),ua.matrixWorldInverse.multiply(ra),oa.matrixWorldInverse.multiply(ra));
ua.matrixWorld.getInverse(ua.matrixWorldInverse);oa.matrixWorld.getInverse(oa.matrixWorldInverse);ua.projectionMatrix.fromArray(P.leftProjectionMatrix);oa.projectionMatrix.fromArray(P.rightProjectionMatrix);xj(ta,ua,oa);Ha=J.getLayers();Ha.length&&(Ha=Ha[0],v(ua.viewport,Ha.leftBounds),v(oa.viewport,Ha.rightBounds));r();return ta};this.getStandingMatrix=function(){return V};this.isPresenting=c;var Ca=new bc;this.setAnimationLoop=function(Ha){Ca.setAnimationLoop(Ha);c()&&Ca.start()};this.submitFrame=
function(){c()&&J.submitFrame()};this.dispose=function(){"undefined"!==typeof window&&window.removeEventListener("vrdisplaypresentchange",e)};this.setFrameOfReferenceType=function(){console.warn("THREE.WebVRManager: setFrameOfReferenceType() has been deprecated.")}}function Aj(a,c){function e(){return null!==F&&null!==J}function g(qa){for(var ua=0;ua<S.length;ua++)V[ua]===qa.inputSource&&S[ua].dispatchEvent({type:qa.type})}function r(){a.setFramebuffer(null);a.setRenderTarget(a.getRenderTarget());
pa.stop();E.dispatchEvent({type:"sessionend"})}function v(qa){J=qa;pa.setContext(F);pa.start();E.dispatchEvent({type:"sessionstart"})}function z(qa,ua){null===ua?qa.matrixWorld.copy(qa.matrix):qa.matrixWorld.multiplyMatrices(ua.matrixWorld,qa.matrix);qa.matrixWorldInverse.getInverse(qa.matrixWorld)}var E=this,F=null,J=null,P="local-floor",R=null,S=[],V=[],W=new vb;W.layers.enable(1);W.viewport=new p;var ha=new vb;ha.layers.enable(2);ha.viewport=new p;var fa=new vf([W,ha]);fa.layers.enable(1);fa.layers.enable(2);
this.enabled=!1;this.getController=function(qa){var ua=S[qa];void 0===ua&&(ua=new ue,ua.matrixAutoUpdate=!1,ua.visible=!1,S[qa]=ua);return ua};this.setFramebufferScaleFactor=function(){};this.setReferenceSpaceType=function(qa){P=qa};this.getSession=function(){return F};this.setSession=function(qa){F=qa;null!==F&&(F.addEventListener("select",g),F.addEventListener("selectstart",g),F.addEventListener("selectend",g),F.addEventListener("end",r),F.updateRenderState({baseLayer:new XRWebGLLayer(F,c)}),F.requestReferenceSpace(P).then(v),
V=F.inputSources,F.addEventListener("inputsourceschange",function(){V=F.inputSources;console.log(V);for(var ua=0;ua<S.length;ua++)S[ua].userData.inputSource=V[ua]}))};this.getCamera=function(qa){if(e()){var ua=qa.parent,oa=fa.cameras;z(fa,ua);for(var ta=0;ta<oa.length;ta++)z(oa[ta],ua);qa.matrixWorld.copy(fa.matrixWorld);qa=qa.children;ta=0;for(ua=qa.length;ta<ua;ta++)qa[ta].updateMatrixWorld(!0);xj(fa,W,ha);return fa}return qa};this.isPresenting=e;var ra=null,pa=new bc;pa.setAnimationLoop(function(qa,
ua){R=ua.getViewerPose(J);if(null!==R){var oa=R.views,ta=F.renderState.baseLayer;a.setFramebuffer(ta.framebuffer);for(var Ba=0;Ba<oa.length;Ba++){var Ta=oa[Ba],Ua=ta.getViewport(Ta),Ca=fa.cameras[Ba];Ca.matrix.fromArray(Ta.transform.inverse.matrix).getInverse(Ca.matrix);Ca.projectionMatrix.fromArray(Ta.projectionMatrix);Ca.viewport.set(Ua.x,Ua.y,Ua.width,Ua.height);0===Ba&&fa.matrix.copy(Ca.matrix)}}for(Ba=0;Ba<S.length;Ba++){oa=S[Ba];if(ta=V[Ba])if(ta=ua.getPose(ta.targetRaySpace,J),null!==ta){oa.matrix.fromArray(ta.transform.matrix);
oa.matrix.decompose(oa.position,oa.rotation,oa.scale);oa.visible=!0;continue}oa.visible=!1}ra&&ra(qa)});this.setAnimationLoop=function(qa){ra=qa};this.dispose=function(){};this.getStandingMatrix=function(){console.warn("THREE.WebXRManager: getStandingMatrix() is no longer needed.");return new q};this.getDevice=function(){console.warn("THREE.WebXRManager: getDevice() has been deprecated.")};this.setDevice=function(){console.warn("THREE.WebXRManager: setDevice() has been deprecated.")};this.setFrameOfReferenceType=
function(){console.warn("THREE.WebXRManager: setFrameOfReferenceType() has been deprecated.")};this.submitFrame=function(){}}function Oh(a){var c;function e(){return null===ib?cc:1}function g(){Lb=new bd(Ra);dc=new Mb(Ra,Lb,a);dc.isWebGL2||(Lb.get("WEBGL_depth_texture"),Lb.get("OES_texture_float"),Lb.get("OES_texture_half_float"),Lb.get("OES_texture_half_float_linear"),Lb.get("OES_standard_derivatives"),Lb.get("OES_element_index_uint"),Lb.get("ANGLE_instanced_arrays"));Lb.get("OES_texture_float_linear");
Nc=new wj(Ra,Lb,dc);yb=new Vl(Ra,Lb,Nc,dc);yb.scissor(Sb.copy(ve).multiplyScalar(cc).floor());yb.viewport(Kb.copy(we).multiplyScalar(cc).floor());xd=new Sk(Ra);ec=new Ml;Oc=new Wl(Ra,Lb,yb,ec,dc,Nc,xd);vg=new Od(Ra);Ph=new td(Ra,vg,xd);xe=new Vk(Ph,xd);Bj=new Uk(Ra);Pd=new Ll(ja,Lb,dc);wg=new Pl;ye=new Ul;yd=new sd(ja,yb,xe,na);Cj=new sa(Ra,Lb,xd,dc);Dj=new tg(Ra,Lb,xd,dc);xd.programs=Pd.programs;ja.capabilities=dc;ja.extensions=Lb;ja.properties=ec;ja.renderLists=wg;ja.state=yb;ja.info=xd}function r(U){U.preventDefault();
console.log("THREE.WebGLRenderer: Context Lost.");Ga=!0}function v(){console.log("THREE.WebGLRenderer: Context Restored.");Ga=!1;g()}function z(U){U=U.target;U.removeEventListener("dispose",z);E(U)}function E(U){F(U);ec.remove(U)}function F(U){var da=ec.get(U).program;U.program=void 0;void 0!==da&&Pd.releaseProgram(da)}function J(U,da){U.render(function(ma){ja.renderBufferImmediate(ma,da)})}function P(U,da,ma){if(ma&&ma.isInstancedBufferGeometry&&!dc.isWebGL2&&null===Lb.get("ANGLE_instanced_arrays"))console.error("THREE.WebGLRenderer.setupVertexAttributes: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.");
else{yb.initAttributes();var Ia=ma.attributes;da=da.getAttributes();U=U.defaultAttributeValues;for(var Oa in da){var ab=da[Oa];if(0<=ab){var Pa=Ia[Oa];if(void 0!==Pa){var fb=Pa.normalized,Cb=Pa.itemSize,ob=vg.get(Pa);if(void 0!==ob){var $a=ob.buffer,Pc=ob.type;ob=ob.bytesPerElement;if(Pa.isInterleavedBufferAttribute){var xc=Pa.data,ze=xc.stride;Pa=Pa.offset;xc&&xc.isInstancedInterleavedBuffer?(yb.enableAttributeAndDivisor(ab,xc.meshPerAttribute),void 0===ma.maxInstancedCount&&(ma.maxInstancedCount=
xc.meshPerAttribute*xc.count)):yb.enableAttribute(ab);Ra.bindBuffer(34962,$a);Ra.vertexAttribPointer(ab,Cb,Pc,fb,ze*ob,Pa*ob)}else Pa.isInstancedBufferAttribute?(yb.enableAttributeAndDivisor(ab,Pa.meshPerAttribute),void 0===ma.maxInstancedCount&&(ma.maxInstancedCount=Pa.meshPerAttribute*Pa.count)):yb.enableAttribute(ab),Ra.bindBuffer(34962,$a),Ra.vertexAttribPointer(ab,Cb,Pc,fb,0,0)}}else if(void 0!==U&&(fb=U[Oa],void 0!==fb))switch(fb.length){case 2:Ra.vertexAttrib2fv(ab,fb);break;case 3:Ra.vertexAttrib3fv(ab,
fb);break;case 4:Ra.vertexAttrib4fv(ab,fb);break;default:Ra.vertexAttrib1fv(ab,fb)}}}yb.disableUnusedAttributes()}}function R(U,da,ma,Ia){if(!1!==U.visible){if(U.layers.test(da.layers))if(U.isGroup)ma=U.renderOrder;else if(U.isLOD)!0===U.autoUpdate&&U.update(da);else if(U.isLight)cb.pushLight(U),U.castShadow&&cb.pushShadow(U);else if(U.isSprite){if(!U.frustumCulled||Qh.intersectsSprite(U)){Ia&&zd.setFromMatrixPosition(U.matrixWorld).applyMatrix4(wf);var Oa=xe.update(U),ab=U.material;ab.visible&&Na.push(U,
Oa,ab,ma,zd.z,null)}}else if(U.isImmediateRenderObject)Ia&&zd.setFromMatrixPosition(U.matrixWorld).applyMatrix4(wf),Na.push(U,null,U.material,ma,zd.z,null);else if(U.isMesh||U.isLine||U.isPoints)if(U.isSkinnedMesh&&U.skeleton.update(),!U.frustumCulled||Qh.intersectsObject(U))if(Ia&&zd.setFromMatrixPosition(U.matrixWorld).applyMatrix4(wf),Oa=xe.update(U),ab=U.material,Array.isArray(ab))for(var Pa=Oa.groups,fb=0,Cb=Pa.length;fb<Cb;fb++){var ob=Pa[fb],$a=ab[ob.materialIndex];$a&&$a.visible&&Na.push(U,
Oa,$a,ma,zd.z,ob)}else ab.visible&&Na.push(U,Oa,ab,ma,zd.z,null);U=U.children;fb=0;for(Cb=U.length;fb<Cb;fb++)R(U[fb],da,ma,Ia)}}function S(U,da,ma,Ia){for(var Oa=0,ab=U.length;Oa<ab;Oa++){var Pa=U[Oa],fb=Pa.object,Cb=Pa.geometry,ob=void 0===Ia?Pa.material:Ia;Pa=Pa.group;if(ma.isArrayCamera){sb=ma;for(var $a=ma.cameras,Pc=0,xc=$a.length;Pc<xc;Pc++){var ze=$a[Pc];fb.layers.test(ze.layers)&&(yb.viewport(Kb.copy(ze.viewport)),cb.setupLights(ze),V(fb,da,ze,Cb,ob,Pa))}}else sb=null,V(fb,da,ma,Cb,ob,Pa)}}
function V(U,da,ma,Ia,Oa,ab){U.onBeforeRender(ja,da,ma,Ia,Oa,ab);cb=ye.get(da,sb||ma);U.modelViewMatrix.multiplyMatrices(ma.matrixWorldInverse,U.matrixWorld);U.normalMatrix.getNormalMatrix(U.modelViewMatrix);U.isImmediateRenderObject?(yb.setMaterial(Oa),Ia=ha(ma,da.fog,Oa,U),eb=c=null,mb=!1,J(U,Ia)):ja.renderBufferDirect(ma,da.fog,Ia,Oa,U,ab);cb=ye.get(da,sb||ma)}function W(U,da,ma){var Ia=ec.get(U),Oa=cb.state.lights,ab=Oa.state.version;ma=Pd.getParameters(U,Oa.state,cb.state.shadowsArray,da,yc.numPlanes,
yc.numIntersection,ma);var Pa=Pd.getProgramCode(U,ma),fb=Ia.program,Cb=!0;if(void 0===fb)U.addEventListener("dispose",z);else if(fb.code!==Pa)F(U);else{if(Ia.lightsStateVersion!==ab)Ia.lightsStateVersion=ab;else if(void 0!==ma.shaderID)return;Cb=!1}Cb&&(ma.shaderID?(Pa=Mc[ma.shaderID],Ia.shader={name:U.type,uniforms:ub(Pa.uniforms),vertexShader:Pa.vertexShader,fragmentShader:Pa.fragmentShader}):Ia.shader={name:U.type,uniforms:U.uniforms,vertexShader:U.vertexShader,fragmentShader:U.fragmentShader},
Pa=Pd.getProgramCode(U,ma),fb=Pd.acquireProgram(U,Ia.shader,ma,Pa),Ia.program=fb,U.program=fb);ma=fb.getAttributes();if(U.morphTargets)for(Pa=U.numSupportedMorphTargets=0;Pa<ja.maxMorphTargets;Pa++)0<=ma["morphTarget"+Pa]&&U.numSupportedMorphTargets++;if(U.morphNormals)for(Pa=U.numSupportedMorphNormals=0;Pa<ja.maxMorphNormals;Pa++)0<=ma["morphNormal"+Pa]&&U.numSupportedMorphNormals++;ma=Ia.shader.uniforms;if(!U.isShaderMaterial&&!U.isRawShaderMaterial||!0===U.clipping)Ia.numClippingPlanes=yc.numPlanes,
Ia.numIntersection=yc.numIntersection,ma.clippingPlanes=yc.uniform;Ia.fog=da;Ia.lightsStateVersion=ab;U.lights&&(ma.ambientLightColor.value=Oa.state.ambient,ma.lightProbe.value=Oa.state.probe,ma.directionalLights.value=Oa.state.directional,ma.spotLights.value=Oa.state.spot,ma.rectAreaLights.value=Oa.state.rectArea,ma.pointLights.value=Oa.state.point,ma.hemisphereLights.value=Oa.state.hemi,ma.directionalShadowMap.value=Oa.state.directionalShadowMap,ma.directionalShadowMatrix.value=Oa.state.directionalShadowMatrix,
ma.spotShadowMap.value=Oa.state.spotShadowMap,ma.spotShadowMatrix.value=Oa.state.spotShadowMatrix,ma.pointShadowMap.value=Oa.state.pointShadowMap,ma.pointShadowMatrix.value=Oa.state.pointShadowMatrix);U=Ia.program.getUniforms();U=ud.seqWithValue(U.seq,ma);Ia.uniformsList=U}function ha(U,da,ma,Ia){Oc.resetTextureUnits();var Oa=ec.get(ma),ab=cb.state.lights;xg&&(Rh||U!==pb)&&yc.setState(ma.clippingPlanes,ma.clipIntersection,ma.clipShadows,U,Oa,U===pb&&ma.id===Qa);!1===ma.needsUpdate&&(void 0===Oa.program?
ma.needsUpdate=!0:ma.fog&&Oa.fog!==da?ma.needsUpdate=!0:ma.lights&&Oa.lightsStateVersion!==ab.state.version?ma.needsUpdate=!0:void 0===Oa.numClippingPlanes||Oa.numClippingPlanes===yc.numPlanes&&Oa.numIntersection===yc.numIntersection||(ma.needsUpdate=!0));ma.needsUpdate&&(W(ma,da,Ia),ma.needsUpdate=!1);var Pa=!1,fb=ab=!1,Cb=Oa.program,ob=Cb.getUniforms(),$a=Oa.shader.uniforms;yb.useProgram(Cb.program)&&(fb=ab=Pa=!0);ma.id!==Qa&&(Qa=ma.id,ab=!0);if(Pa||pb!==U){ob.setValue(Ra,"projectionMatrix",U.projectionMatrix);
dc.logarithmicDepthBuffer&&ob.setValue(Ra,"logDepthBufFC",2/(Math.log(U.far+1)/Math.LN2));pb!==U&&(pb=U,fb=ab=!0);if(ma.isShaderMaterial||ma.isMeshPhongMaterial||ma.isMeshStandardMaterial||ma.envMap)Pa=ob.map.cameraPosition,void 0!==Pa&&Pa.setValue(Ra,zd.setFromMatrixPosition(U.matrixWorld));(ma.isMeshPhongMaterial||ma.isMeshLambertMaterial||ma.isMeshBasicMaterial||ma.isMeshStandardMaterial||ma.isShaderMaterial||ma.skinning)&&ob.setValue(Ra,"viewMatrix",U.matrixWorldInverse)}if(ma.skinning&&(ob.setOptional(Ra,
Ia,"bindMatrix"),ob.setOptional(Ra,Ia,"bindMatrixInverse"),U=Ia.skeleton))if(Pa=U.bones,dc.floatVertexTextures){if(void 0===U.boneTexture){Pa=Math.sqrt(4*Pa.length);Pa=hb.ceilPowerOfTwo(Pa);Pa=Math.max(Pa,4);var Pc=new Float32Array(Pa*Pa*4);Pc.set(U.boneMatrices);var xc=new Ab(Pc,Pa,Pa,1023,1015);xc.needsUpdate=!0;U.boneMatrices=Pc;U.boneTexture=xc;U.boneTextureSize=Pa}ob.setValue(Ra,"boneTexture",U.boneTexture,Oc);ob.setValue(Ra,"boneTextureSize",U.boneTextureSize)}else ob.setOptional(Ra,U,"boneMatrices");
ab&&(ob.setValue(Ra,"toneMappingExposure",ja.toneMappingExposure),ob.setValue(Ra,"toneMappingWhitePoint",ja.toneMappingWhitePoint),ma.lights&&tb($a,fb),da&&ma.fog&&oa($a,da),ma.isMeshBasicMaterial?fa($a,ma):ma.isMeshLambertMaterial?(fa($a,ma),ta($a,ma)):ma.isMeshPhongMaterial?(fa($a,ma),ma.isMeshToonMaterial?Ta($a,ma):Ba($a,ma)):ma.isMeshStandardMaterial?(fa($a,ma),ma.isMeshPhysicalMaterial?Ca($a,ma):Ua($a,ma)):ma.isMeshMatcapMaterial?(fa($a,ma),Ha($a,ma)):ma.isMeshDepthMaterial?(fa($a,ma),Da($a,
ma)):ma.isMeshDistanceMaterial?(fa($a,ma),Ma($a,ma)):ma.isMeshNormalMaterial?(fa($a,ma),db($a,ma)):ma.isLineBasicMaterial?(ra($a,ma),ma.isLineDashedMaterial&&pa($a,ma)):ma.isPointsMaterial?qa($a,ma):ma.isSpriteMaterial?ua($a,ma):ma.isShadowMaterial&&($a.color.value.copy(ma.color),$a.opacity.value=ma.opacity),void 0!==$a.ltc_1&&($a.ltc_1.value=Wa.LTC_1),void 0!==$a.ltc_2&&($a.ltc_2.value=Wa.LTC_2),ud.upload(Ra,Oa.uniformsList,$a,Oc));ma.isShaderMaterial&&!0===ma.uniformsNeedUpdate&&(ud.upload(Ra,Oa.uniformsList,
$a,Oc),ma.uniformsNeedUpdate=!1);ma.isSpriteMaterial&&ob.setValue(Ra,"center",Ia.center);ob.setValue(Ra,"modelViewMatrix",Ia.modelViewMatrix);ob.setValue(Ra,"normalMatrix",Ia.normalMatrix);ob.setValue(Ra,"modelMatrix",Ia.matrixWorld);return Cb}function fa(U,da){U.opacity.value=da.opacity;da.color&&U.diffuse.value.copy(da.color);da.emissive&&U.emissive.value.copy(da.emissive).multiplyScalar(da.emissiveIntensity);da.map&&(U.map.value=da.map);da.alphaMap&&(U.alphaMap.value=da.alphaMap);da.specularMap&&
(U.specularMap.value=da.specularMap);da.envMap&&(U.envMap.value=da.envMap,U.flipEnvMap.value=da.envMap.isCubeTexture?-1:1,U.reflectivity.value=da.reflectivity,U.refractionRatio.value=da.refractionRatio,U.maxMipLevel.value=ec.get(da.envMap).__maxMipLevel);da.lightMap&&(U.lightMap.value=da.lightMap,U.lightMapIntensity.value=da.lightMapIntensity);da.aoMap&&(U.aoMap.value=da.aoMap,U.aoMapIntensity.value=da.aoMapIntensity);if(da.map)var ma=da.map;else da.specularMap?ma=da.specularMap:da.displacementMap?
ma=da.displacementMap:da.normalMap?ma=da.normalMap:da.bumpMap?ma=da.bumpMap:da.roughnessMap?ma=da.roughnessMap:da.metalnessMap?ma=da.metalnessMap:da.alphaMap?ma=da.alphaMap:da.emissiveMap&&(ma=da.emissiveMap);void 0!==ma&&(ma.isWebGLRenderTarget&&(ma=ma.texture),!0===ma.matrixAutoUpdate&&ma.updateMatrix(),U.uvTransform.value.copy(ma.matrix))}function ra(U,da){U.diffuse.value.copy(da.color);U.opacity.value=da.opacity}function pa(U,da){U.dashSize.value=da.dashSize;U.totalSize.value=da.dashSize+da.gapSize;
U.scale.value=da.scale}function qa(U,da){U.diffuse.value.copy(da.color);U.opacity.value=da.opacity;U.size.value=da.size*cc;U.scale.value=.5*zc;U.map.value=da.map;null!==da.map&&(!0===da.map.matrixAutoUpdate&&da.map.updateMatrix(),U.uvTransform.value.copy(da.map.matrix))}function ua(U,da){U.diffuse.value.copy(da.color);U.opacity.value=da.opacity;U.rotation.value=da.rotation;U.map.value=da.map;null!==da.map&&(!0===da.map.matrixAutoUpdate&&da.map.updateMatrix(),U.uvTransform.value.copy(da.map.matrix))}
function oa(U,da){U.fogColor.value.copy(da.color);da.isFog?(U.fogNear.value=da.near,U.fogFar.value=da.far):da.isFogExp2&&(U.fogDensity.value=da.density)}function ta(U,da){da.emissiveMap&&(U.emissiveMap.value=da.emissiveMap)}function Ba(U,da){U.specular.value.copy(da.specular);U.shininess.value=Math.max(da.shininess,1E-4);da.emissiveMap&&(U.emissiveMap.value=da.emissiveMap);da.bumpMap&&(U.bumpMap.value=da.bumpMap,U.bumpScale.value=da.bumpScale,1===da.side&&(U.bumpScale.value*=-1));da.normalMap&&(U.normalMap.value=
da.normalMap,U.normalScale.value.copy(da.normalScale),1===da.side&&U.normalScale.value.negate());da.displacementMap&&(U.displacementMap.value=da.displacementMap,U.displacementScale.value=da.displacementScale,U.displacementBias.value=da.displacementBias)}function Ta(U,da){Ba(U,da);da.gradientMap&&(U.gradientMap.value=da.gradientMap)}function Ua(U,da){U.roughness.value=da.roughness;U.metalness.value=da.metalness;da.roughnessMap&&(U.roughnessMap.value=da.roughnessMap);da.metalnessMap&&(U.metalnessMap.value=
da.metalnessMap);da.emissiveMap&&(U.emissiveMap.value=da.emissiveMap);da.bumpMap&&(U.bumpMap.value=da.bumpMap,U.bumpScale.value=da.bumpScale,1===da.side&&(U.bumpScale.value*=-1));da.normalMap&&(U.normalMap.value=da.normalMap,U.normalScale.value.copy(da.normalScale),1===da.side&&U.normalScale.value.negate());da.displacementMap&&(U.displacementMap.value=da.displacementMap,U.displacementScale.value=da.displacementScale,U.displacementBias.value=da.displacementBias);da.envMap&&(U.envMapIntensity.value=
da.envMapIntensity)}function Ca(U,da){Ua(U,da);U.reflectivity.value=da.reflectivity;U.clearcoat.value=da.clearcoat;U.clearcoatRoughness.value=da.clearcoatRoughness;da.sheen&&U.sheen.value.copy(da.sheen);da.clearcoatNormalMap&&(U.clearcoatNormalScale.value.copy(da.clearcoatNormalScale),U.clearcoatNormalMap.value=da.clearcoatNormalMap,1===da.side&&U.clearcoatNormalScale.value.negate());U.transparency.value=da.transparency}function Ha(U,da){da.matcap&&(U.matcap.value=da.matcap);da.bumpMap&&(U.bumpMap.value=
da.bumpMap,U.bumpScale.value=da.bumpScale,1===da.side&&(U.bumpScale.value*=-1));da.normalMap&&(U.normalMap.value=da.normalMap,U.normalScale.value.copy(da.normalScale),1===da.side&&U.normalScale.value.negate());da.displacementMap&&(U.displacementMap.value=da.displacementMap,U.displacementScale.value=da.displacementScale,U.displacementBias.value=da.displacementBias)}function Da(U,da){da.displacementMap&&(U.displacementMap.value=da.displacementMap,U.displacementScale.value=da.displacementScale,U.displacementBias.value=
da.displacementBias)}function Ma(U,da){da.displacementMap&&(U.displacementMap.value=da.displacementMap,U.displacementScale.value=da.displacementScale,U.displacementBias.value=da.displacementBias);U.referencePosition.value.copy(da.referencePosition);U.nearDistance.value=da.nearDistance;U.farDistance.value=da.farDistance}function db(U,da){da.bumpMap&&(U.bumpMap.value=da.bumpMap,U.bumpScale.value=da.bumpScale,1===da.side&&(U.bumpScale.value*=-1));da.normalMap&&(U.normalMap.value=da.normalMap,U.normalScale.value.copy(da.normalScale),
1===da.side&&U.normalScale.value.negate());da.displacementMap&&(U.displacementMap.value=da.displacementMap,U.displacementScale.value=da.displacementScale,U.displacementBias.value=da.displacementBias)}function tb(U,da){U.ambientLightColor.needsUpdate=da;U.lightProbe.needsUpdate=da;U.directionalLights.needsUpdate=da;U.pointLights.needsUpdate=da;U.spotLights.needsUpdate=da;U.rectAreaLights.needsUpdate=da;U.hemisphereLights.needsUpdate=da}a=a||{};var Ka=void 0!==a.canvas?a.canvas:document.createElementNS("http://www.w3.org/1999/xhtml",
"canvas"),bb=void 0!==a.context?a.context:null,jb=void 0!==a.alpha?a.alpha:!1,Eb=void 0!==a.depth?a.depth:!0,xb=void 0!==a.stencil?a.stencil:!0,ia=void 0!==a.antialias?a.antialias:!1,na=void 0!==a.premultipliedAlpha?a.premultipliedAlpha:!0,za=void 0!==a.preserveDrawingBuffer?a.preserveDrawingBuffer:!1,Ja=void 0!==a.powerPreference?a.powerPreference:"default",Ya=void 0!==a.failIfMajorPerformanceCaveat?a.failIfMajorPerformanceCaveat:!1,Na=null,cb=null;this.domElement=Ka;this.debug={checkShaderErrors:!0};
this.sortObjects=this.autoClearStencil=this.autoClearDepth=this.autoClearColor=this.autoClear=!0;this.clippingPlanes=[];this.localClippingEnabled=!1;this.gammaFactor=2;this.physicallyCorrectLights=this.gammaOutput=this.gammaInput=!1;this.toneMappingWhitePoint=this.toneMappingExposure=this.toneMapping=1;this.maxMorphTargets=8;this.maxMorphNormals=4;var ja=this,Ga=!1,La=null,nb=0,Va=0,ib=null,kb=null,Qa=-1;var eb=c=null;var mb=!1;var pb=null,sb=null,Kb=new p,Sb=new p,nc=null,Qc=Ka.width,zc=Ka.height,
cc=1,we=new p(0,0,Qc,zc),ve=new p(0,0,Qc,zc),Sh=!1,Qh=new ic,yc=new wc,xg=!1,Rh=!1,wf=new q,zd=new k;try{jb={alpha:jb,depth:Eb,stencil:xb,antialias:ia,premultipliedAlpha:na,preserveDrawingBuffer:za,powerPreference:Ja,failIfMajorPerformanceCaveat:Ya,xrCompatible:!0};Ka.addEventListener("webglcontextlost",r,!1);Ka.addEventListener("webglcontextrestored",v,!1);var Ra=bb||Ka.getContext("webgl",jb)||Ka.getContext("experimental-webgl",jb);if(null===Ra){if(null!==Ka.getContext("webgl"))throw Error("Error creating WebGL context with your selected attributes.");
throw Error("Error creating WebGL context.");}void 0===Ra.getShaderPrecisionFormat&&(Ra.getShaderPrecisionFormat=function(){return{rangeMin:1,rangeMax:1,precision:1}})}catch(U){throw console.error("THREE.WebGLRenderer: "+U.message),U;}var Lb,dc,yb,xd,ec,Oc,vg,Ph,xe,Pd,wg,ye,yd,Bj,Cj,Dj,Nc;g();var dd="undefined"!==typeof navigator&&"xr"in navigator&&"supportsSession"in navigator.xr?new Aj(ja,Ra):new Nh(ja);this.vr=dd;var Ej=new vj(ja,xe,dc.maxTextureSize);this.shadowMap=Ej;this.getContext=function(){return Ra};
this.getContextAttributes=function(){return Ra.getContextAttributes()};this.forceContextLoss=function(){var U=Lb.get("WEBGL_lose_context");U&&U.loseContext()};this.forceContextRestore=function(){var U=Lb.get("WEBGL_lose_context");U&&U.restoreContext()};this.getPixelRatio=function(){return cc};this.setPixelRatio=function(){var U=window.devicePixelRatio;void 0!==U&&(cc=U,this.setSize(Qc,zc,!1))};this.getSize=function(U){void 0===U&&(console.warn("WebGLRenderer: .getsize() now requires a Vector2 as an argument"),
U=new f);return U.set(Qc,zc)};this.setSize=function(U,da,ma){dd.isPresenting()?console.warn("THREE.WebGLRenderer: Can't change size while VR device is presenting."):(Qc=U,zc=da,Ka.width=Math.floor(U*cc),Ka.height=Math.floor(da*cc),!1!==ma&&(Ka.style.width=U+"px",Ka.style.height=da+"px"),this.setViewport(U,da))};this.getDrawingBufferSize=function(U){void 0===U&&(console.warn("WebGLRenderer: .getdrawingBufferSize() now requires a Vector2 as an argument"),U=new f);return U.set(Qc*cc,zc*cc).floor()};
this.setDrawingBufferSize=function(U,da,ma){Qc=U;zc=da;cc=ma;Ka.width=Math.floor(U*ma);Ka.height=Math.floor(da*ma);this.setViewport(U,da)};this.getCurrentViewport=function(U){void 0===U&&(console.warn("WebGLRenderer: .getCurrentViewport() now requires a Vector4 as an argument"),U=new p);return U.copy(Kb)};this.getViewport=function(U){return U.copy(we)};this.setViewport=function(U,da){(0).isVector4?we.set((0).x,(0).y,(0).z,(0).w):we.set(0,0,U,da);yb.viewport(Kb.copy(we).multiplyScalar(cc).floor())};
this.getScissor=function(U){return U.copy(ve)};this.setScissor=function(U,da,ma,Ia){U.isVector4?ve.set(U.x,U.y,U.z,U.w):ve.set(U,da,ma,Ia);yb.scissor(Sb.copy(ve).multiplyScalar(cc).floor())};this.getScissorTest=function(){return Sh};this.setScissorTest=function(U){yb.setScissorTest(Sh=U)};this.getClearColor=function(){return yd.getClearColor()};this.setClearColor=function(){yd.setClearColor.apply(yd,arguments)};this.getClearAlpha=function(){return yd.getClearAlpha()};this.setClearAlpha=function(){yd.setClearAlpha.apply(yd,
arguments)};this.clear=function(U,da,ma){var Ia=0;if(void 0===U||U)Ia|=16384;if(void 0===da||da)Ia|=256;if(void 0===ma||ma)Ia|=1024;Ra.clear(Ia)};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(){Ka.removeEventListener("webglcontextlost",r,!1);Ka.removeEventListener("webglcontextrestored",v,!1);wg.dispose();ye.dispose();ec.dispose();xe.dispose();dd.dispose();yg.stop()};this.renderBufferImmediate=
function(U,da){yb.initAttributes();var ma=ec.get(U);U.hasPositions&&!ma.position&&(ma.position=Ra.createBuffer());U.hasNormals&&!ma.normal&&(ma.normal=Ra.createBuffer());U.hasUvs&&!ma.uv&&(ma.uv=Ra.createBuffer());U.hasColors&&!ma.color&&(ma.color=Ra.createBuffer());da=da.getAttributes();U.hasPositions&&(Ra.bindBuffer(34962,ma.position),Ra.bufferData(34962,U.positionArray,35048),yb.enableAttribute(da.position),Ra.vertexAttribPointer(da.position,3,5126,!1,0,0));U.hasNormals&&(Ra.bindBuffer(34962,ma.normal),
Ra.bufferData(34962,U.normalArray,35048),yb.enableAttribute(da.normal),Ra.vertexAttribPointer(da.normal,3,5126,!1,0,0));U.hasUvs&&(Ra.bindBuffer(34962,ma.uv),Ra.bufferData(34962,U.uvArray,35048),yb.enableAttribute(da.uv),Ra.vertexAttribPointer(da.uv,2,5126,!1,0,0));U.hasColors&&(Ra.bindBuffer(34962,ma.color),Ra.bufferData(34962,U.colorArray,35048),yb.enableAttribute(da.color),Ra.vertexAttribPointer(da.color,3,5126,!1,0,0));yb.disableUnusedAttributes();Ra.drawArrays(4,0,U.count);U.count=0};this.renderBufferDirect=
function(U,da,ma,Ia,Oa,ab){yb.setMaterial(Ia,Oa.isMesh&&0>Oa.matrixWorld.determinant());var Pa=ha(U,da,Ia,Oa),fb=!1;if(c!==ma.id||eb!==Pa.id||mb!==(!0===Ia.wireframe))c=ma.id,eb=Pa.id,mb=!0===Ia.wireframe,fb=!0;Oa.morphTargetInfluences&&(Bj.update(Oa,ma,Ia,Pa),fb=!0);var Cb=ma.index,ob=ma.attributes.position;da=1;!0===Ia.wireframe&&(Cb=Ph.getWireframeAttribute(ma),da=2);U=Cj;if(null!==Cb){var $a=vg.get(Cb);U=Dj;U.setIndex($a)}fb&&(P(Ia,Pa,ma),null!==Cb&&Ra.bindBuffer(34963,$a.buffer));$a=Infinity;
null!==Cb?$a=Cb.count:void 0!==ob&&($a=ob.count);ob=ma.drawRange.start*da;Pa=null!==ab?ab.start*da:0;Cb=Math.max(ob,Pa);ab=Math.max(0,Math.min($a,ob+ma.drawRange.count*da,Pa+(null!==ab?ab.count*da:Infinity))-1-Cb+1);if(0!==ab){if(Oa.isMesh)if(!0===Ia.wireframe)yb.setLineWidth(Ia.wireframeLinewidth*e()),U.setMode(1);else switch(Oa.drawMode){case 0:U.setMode(4);break;case 1:U.setMode(5);break;case 2:U.setMode(6)}else Oa.isLine?(Ia=Ia.linewidth,void 0===Ia&&(Ia=1),yb.setLineWidth(Ia*e()),Oa.isLineSegments?
U.setMode(1):Oa.isLineLoop?U.setMode(2):U.setMode(3)):Oa.isPoints?U.setMode(0):Oa.isSprite&&U.setMode(4);ma&&ma.isInstancedBufferGeometry?0<ma.maxInstancedCount&&U.renderInstances(ma,Cb,ab):U.render(Cb,ab)}};this.compile=function(U,da){cb=ye.get(U,da);cb.init();U.traverse(function(ma){ma.isLight&&(cb.pushLight(ma),ma.castShadow&&cb.pushShadow(ma))});cb.setupLights(da);U.traverse(function(ma){if(ma.material)if(Array.isArray(ma.material))for(var Ia=0;Ia<ma.material.length;Ia++)W(ma.material[Ia],U.fog,
ma);else W(ma.material,U.fog,ma)})};var Th=null,yg=new bc;yg.setAnimationLoop(function(U){dd.isPresenting()||Th&&Th(U)});"undefined"!==typeof window&&yg.setContext(window);this.setAnimationLoop=function(U){Th=U;dd.setAnimationLoop(U);yg.start()};this.render=function(U,da,ma,Ia){if(void 0!==ma){console.warn("THREE.WebGLRenderer.render(): the renderTarget argument has been removed. Use .setRenderTarget() instead.");var Oa=ma}if(void 0!==Ia){console.warn("THREE.WebGLRenderer.render(): the forceClear argument has been removed. Use .clear() instead.");
var ab=Ia}da&&da.isCamera?Ga||(eb=c=null,mb=!1,Qa=-1,pb=null,!0===U.autoUpdate&&U.updateMatrixWorld(),null===da.parent&&da.updateMatrixWorld(),dd.enabled&&(da=dd.getCamera(da)),cb=ye.get(U,da),cb.init(),U.onBeforeRender(ja,U,da,Oa||ib),wf.multiplyMatrices(da.projectionMatrix,da.matrixWorldInverse),Qh.setFromMatrix(wf),Rh=this.localClippingEnabled,xg=yc.init(this.clippingPlanes,Rh,da),Na=wg.get(U,da),Na.init(),R(U,da,0,ja.sortObjects),!0===ja.sortObjects&&Na.sort(),xg&&yc.beginShadows(),Ej.render(cb.state.shadowsArray,
U,da),cb.setupLights(da),xg&&yc.endShadows(),this.info.autoReset&&this.info.reset(),void 0!==Oa&&this.setRenderTarget(Oa),yd.render(Na,U,da,ab),ma=Na.opaque,Ia=Na.transparent,U.overrideMaterial?(Oa=U.overrideMaterial,ma.length&&S(ma,U,da,Oa),Ia.length&&S(Ia,U,da,Oa)):(ma.length&&S(ma,U,da),Ia.length&&S(Ia,U,da)),null!==ib&&(Oc.updateRenderTargetMipmap(ib),Oc.updateMultisampleRenderTarget(ib)),yb.buffers.depth.setTest(!0),yb.buffers.depth.setMask(!0),yb.buffers.color.setMask(!0),yb.setPolygonOffset(!1),
dd.enabled&&dd.submitFrame(),cb=Na=null):console.error("THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.")};this.setFramebuffer=function(U){La!==U&&Ra.bindFramebuffer(36160,U);La=U};this.getActiveCubeFace=function(){return nb};this.getActiveMipmapLevel=function(){return Va};this.getRenderTarget=function(){return ib};this.setRenderTarget=function(U,da,ma){ib=U;nb=da;Va=ma;U&&void 0===ec.get(U).__webglFramebuffer&&Oc.setupRenderTarget(U);var Ia=La,Oa=!1;U?(Ia=ec.get(U).__webglFramebuffer,
U.isWebGLRenderTargetCube?(Ia=Ia[da||0],Oa=!0):Ia=U.isWebGLMultisampleRenderTarget?ec.get(U).__webglMultisampledFramebuffer:Ia,Kb.copy(U.viewport),Sb.copy(U.scissor),nc=U.scissorTest):(Kb.copy(we).multiplyScalar(cc).floor(),Sb.copy(ve).multiplyScalar(cc).floor(),nc=Sh);kb!==Ia&&(Ra.bindFramebuffer(36160,Ia),kb=Ia);yb.viewport(Kb);yb.scissor(Sb);yb.setScissorTest(nc);Oa&&(U=ec.get(U.texture),Ra.framebufferTexture2D(36160,36064,34069+(da||0),U.__webglTexture,ma||0))};this.readRenderTargetPixels=function(U,
da,ma,Ia,Oa,ab,Pa){if(U&&U.isWebGLRenderTarget){var fb=ec.get(U).__webglFramebuffer;U.isWebGLRenderTargetCube&&void 0!==Pa&&(fb=fb[Pa]);if(fb){Pa=!1;fb!==kb&&(Ra.bindFramebuffer(36160,fb),Pa=!0);try{var Cb=U.texture,ob=Cb.format,$a=Cb.type;1023!==ob&&Nc.convert(ob)!==Ra.getParameter(35739)?console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format."):1009===$a||Nc.convert($a)===Ra.getParameter(35738)||1015===$a&&(dc.isWebGL2||Lb.get("OES_texture_float")||
Lb.get("WEBGL_color_buffer_float"))||1016===$a&&(dc.isWebGL2?Lb.get("EXT_color_buffer_float"):Lb.get("EXT_color_buffer_half_float"))?36053===Ra.checkFramebufferStatus(36160)?0<=da&&da<=U.width-Ia&&0<=ma&&ma<=U.height-Oa&&Ra.readPixels(da,ma,Ia,Oa,Nc.convert(ob),Nc.convert($a),ab):console.error("THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete."):console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.")}finally{Pa&&
Ra.bindFramebuffer(36160,kb)}}}else console.error("THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.")};this.copyFramebufferToTexture=function(U,da,ma){var Ia=da.image.width,Oa=da.image.height,ab=Nc.convert(da.format);Oc.setTexture2D(da,0);Ra.copyTexImage2D(3553,ma||0,ab,U.x,U.y,Ia,Oa,0)};this.copyTextureToTexture=function(U,da,ma,Ia){var Oa=da.image.width,ab=da.image.height,Pa=Nc.convert(ma.format),fb=Nc.convert(ma.type);Oc.setTexture2D(ma,0);da.isDataTexture?
Ra.texSubImage2D(3553,Ia||0,U.x,U.y,Oa,ab,Pa,fb,da.image.data):Ra.texSubImage2D(3553,Ia||0,U.x,U.y,Pa,fb,da.image)};"undefined"!==typeof __THREE_DEVTOOLS__&&__THREE_DEVTOOLS__.dispatchEvent(new CustomEvent("observe",{detail:this}))}function zg(a,c){this.name="";this.color=new I(a);this.density=void 0!==c?c:2.5E-4}function Ag(a,c,e){this.name="";this.color=new I(a);this.near=void 0!==c?c:1;this.far=void 0!==e?e:1E3}function Qd(a,c){this.array=a;this.stride=c;this.count=void 0!==a?a.length/c:0;this.dynamic=
!1;this.updateRange={offset:0,count:-1};this.version=0}function xf(a,c,e,g){this.data=a;this.itemSize=c;this.offset=e;this.normalized=!0===g}function Ad(a){M.call(this);this.type="SpriteMaterial";this.color=new I(16777215);this.map=null;this.rotation=0;this.sizeAttenuation=!0;this.lights=!1;this.transparent=!0;this.setValues(a)}function yf(a){A.call(this);this.type="Sprite";if(void 0===Ae){Ae=new va;var c=new Qd(new Float32Array([-.5,-.5,0,0,0,.5,-.5,0,1,0,.5,.5,0,1,1,-.5,.5,0,0,1]),5);Ae.setIndex([0,
1,2,0,2,3]);Ae.addAttribute("position",new xf(c,3,0,!1));Ae.addAttribute("uv",new xf(c,2,3,!1))}this.geometry=Ae;this.material=void 0!==a?a:new Ad;this.center=new f(.5,.5)}function Bg(a,c,e,g,r,v){Be.subVectors(a,e).addScalar(.5).multiply(g);void 0!==r?(zf.x=v*Be.x-r*Be.y,zf.y=r*Be.x+v*Be.y):zf.copy(Be);a.copy(c);a.x+=zf.x;a.y+=zf.y;a.applyMatrix4(Fj)}function Af(){A.call(this);this.type="LOD";Object.defineProperties(this,{levels:{enumerable:!0,value:[]}});this.autoUpdate=!0}function Bf(a,c){a&&a.isGeometry&&
console.error("THREE.SkinnedMesh no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.");xa.call(this,a,c);this.type="SkinnedMesh";this.bindMode="attached";this.bindMatrix=new q;this.bindMatrixInverse=new q}function Cg(a,c){a=a||[];this.bones=a.slice(0);this.boneMatrices=new Float32Array(16*this.bones.length);if(void 0===c)this.calculateInverses();else if(this.bones.length===c.length)this.boneInverses=c.slice(0);else for(console.warn("THREE.Skeleton boneInverses is the wrong length."),
this.boneInverses=[],a=0,c=this.bones.length;a<c;a++)this.boneInverses.push(new q)}function Uh(){A.call(this);this.type="Bone"}function Fb(a){M.call(this);this.type="LineBasicMaterial";this.color=new I(16777215);this.linewidth=1;this.linejoin=this.linecap="round";this.lights=!1;this.setValues(a)}function Vb(a,c,e){1===e&&console.error("THREE.Line: parameter THREE.LinePieces no longer supported. Use THREE.LineSegments instead.");A.call(this);this.type="Line";this.geometry=void 0!==a?a:new va;this.material=
void 0!==c?c:new Fb({color:16777215*Math.random()})}function Ib(a,c){Vb.call(this,a,c);this.type="LineSegments"}function Dg(a,c){Vb.call(this,a,c);this.type="LineLoop"}function Ac(a){M.call(this);this.type="PointsMaterial";this.color=new I(16777215);this.map=null;this.size=1;this.sizeAttenuation=!0;this.lights=this.morphTargets=!1;this.setValues(a)}function Ce(a,c){A.call(this);this.type="Points";this.geometry=void 0!==a?a:new va;this.material=void 0!==c?c:new Ac({color:16777215*Math.random()});this.updateMorphTargets()}
function Vh(a,c,e,g,r,v,z){var E=Wh.distanceSqToPoint(a);E<e&&(e=new k,Wh.closestPointToPoint(a,e),e.applyMatrix4(g),a=r.ray.origin.distanceTo(e),a<r.near||a>r.far||v.push({distance:a,distanceToRay:Math.sqrt(E),point:e,index:c,face:null,object:z}))}function Xh(a,c,e,g,r,v,z,E,F){l.call(this,a,c,e,g,r,v,z,E,F);this.format=void 0!==z?z:1022;this.minFilter=void 0!==v?v:1006;this.magFilter=void 0!==r?r:1006;this.generateMipmaps=!1}function De(a,c,e,g,r,v,z,E,F,J,P,R){l.call(this,null,v,z,E,F,J,g,r,P,
R);this.image={width:c,height:e};this.mipmaps=a;this.generateMipmaps=this.flipY=!1}function Cf(a,c,e,g,r,v,z,E,F){l.call(this,a,c,e,g,r,v,z,E,F);this.needsUpdate=!0}function Df(a,c,e,g,r,v,z,E,F,J){J=void 0!==J?J:1026;if(1026!==J&&1027!==J)throw Error("DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat");void 0===e&&1026===J&&(e=1012);void 0===e&&1027===J&&(e=1020);l.call(this,null,g,r,v,z,E,J,e,F);this.image={width:a,height:c};this.magFilter=void 0!==z?z:1003;this.minFilter=
void 0!==E?E:1003;this.generateMipmaps=this.flipY=!1}function Ee(a){va.call(this);this.type="WireframeGeometry";var c=[],e,g,r,v=[0,0],z={},E=["a","b","c"];if(a&&a.isGeometry){var F=a.faces;var J=0;for(g=F.length;J<g;J++){var P=F[J];for(e=0;3>e;e++){var R=P[E[e]];var S=P[E[(e+1)%3]];v[0]=Math.min(R,S);v[1]=Math.max(R,S);R=v[0]+","+v[1];void 0===z[R]&&(z[R]={index1:v[0],index2:v[1]})}}for(R in z)J=z[R],E=a.vertices[J.index1],c.push(E.x,E.y,E.z),E=a.vertices[J.index2],c.push(E.x,E.y,E.z)}else if(a&&
a.isBufferGeometry)if(E=new k,null!==a.index){F=a.attributes.position;P=a.index;var V=a.groups;0===V.length&&(V=[{start:0,count:P.count,materialIndex:0}]);a=0;for(r=V.length;a<r;++a)for(J=V[a],e=J.start,g=J.count,J=e,g=e+g;J<g;J+=3)for(e=0;3>e;e++)R=P.getX(J+e),S=P.getX(J+(e+1)%3),v[0]=Math.min(R,S),v[1]=Math.max(R,S),R=v[0]+","+v[1],void 0===z[R]&&(z[R]={index1:v[0],index2:v[1]});for(R in z)J=z[R],E.fromBufferAttribute(F,J.index1),c.push(E.x,E.y,E.z),E.fromBufferAttribute(F,J.index2),c.push(E.x,
E.y,E.z)}else for(F=a.attributes.position,J=0,g=F.count/3;J<g;J++)for(e=0;3>e;e++)z=3*J+e,E.fromBufferAttribute(F,z),c.push(E.x,E.y,E.z),z=3*J+(e+1)%3,E.fromBufferAttribute(F,z),c.push(E.x,E.y,E.z);this.addAttribute("position",new ca(c,3))}function Ef(a,c,e){ya.call(this);this.type="ParametricGeometry";this.parameters={func:a,slices:c,stacks:e};this.fromBufferGeometry(new Fe(a,c,e));this.mergeVertices()}function Fe(a,c,e){va.call(this);this.type="ParametricBufferGeometry";this.parameters={func:a,
slices:c,stacks:e};var g=[],r=[],v=[],z=[],E=new k,F=new k,J=new k,P=new k,R=new k,S,V;3>a.length&&console.error("THREE.ParametricGeometry: Function must now modify a Vector3 as third parameter.");var W=c+1;for(S=0;S<=e;S++){var ha=S/e;for(V=0;V<=c;V++){var fa=V/c;a(fa,ha,F);r.push(F.x,F.y,F.z);0<=fa-1E-5?(a(fa-1E-5,ha,J),P.subVectors(F,J)):(a(fa+1E-5,ha,J),P.subVectors(J,F));0<=ha-1E-5?(a(fa,ha-1E-5,J),R.subVectors(F,J)):(a(fa,ha+1E-5,J),R.subVectors(J,F));E.crossVectors(P,R).normalize();v.push(E.x,
E.y,E.z);z.push(fa,ha)}}for(S=0;S<e;S++)for(V=0;V<c;V++)a=S*W+V+1,E=(S+1)*W+V+1,F=(S+1)*W+V,g.push(S*W+V,a,F),g.push(a,E,F);this.setIndex(g);this.addAttribute("position",new ca(r,3));this.addAttribute("normal",new ca(v,3));this.addAttribute("uv",new ca(z,2))}function Ff(a,c,e,g){ya.call(this);this.type="PolyhedronGeometry";this.parameters={vertices:a,indices:c,radius:e,detail:g};this.fromBufferGeometry(new jc(a,c,e,g));this.mergeVertices()}function jc(a,c,e,g){function r(W,ha,fa,ra){ra=Math.pow(2,
ra);var pa=[],qa,ua;for(qa=0;qa<=ra;qa++){pa[qa]=[];var oa=W.clone().lerp(fa,qa/ra),ta=ha.clone().lerp(fa,qa/ra),Ba=ra-qa;for(ua=0;ua<=Ba;ua++)pa[qa][ua]=0===ua&&qa===ra?oa:oa.clone().lerp(ta,ua/Ba)}for(qa=0;qa<ra;qa++)for(ua=0;ua<2*(ra-qa)-1;ua++)W=Math.floor(ua/2),0===ua%2?(z(pa[qa][W+1]),z(pa[qa+1][W]),z(pa[qa][W])):(z(pa[qa][W+1]),z(pa[qa+1][W+1]),z(pa[qa+1][W]))}function v(){for(var W=0;W<V.length;W+=6){var ha=V[W+0],fa=V[W+2],ra=V[W+4],pa=Math.min(ha,fa,ra);.9<Math.max(ha,fa,ra)&&.1>pa&&(.2>
ha&&(V[W+0]+=1),.2>fa&&(V[W+2]+=1),.2>ra&&(V[W+4]+=1))}}function z(W){S.push(W.x,W.y,W.z)}function E(W,ha){W*=3;ha.x=a[W+0];ha.y=a[W+1];ha.z=a[W+2]}function F(){for(var W=new k,ha=new k,fa=new k,ra=new k,pa=new f,qa=new f,ua=new f,oa=0,ta=0;oa<S.length;oa+=9,ta+=6){W.set(S[oa+0],S[oa+1],S[oa+2]);ha.set(S[oa+3],S[oa+4],S[oa+5]);fa.set(S[oa+6],S[oa+7],S[oa+8]);pa.set(V[ta+0],V[ta+1]);qa.set(V[ta+2],V[ta+3]);ua.set(V[ta+4],V[ta+5]);ra.copy(W).add(ha).add(fa).divideScalar(3);var Ba=P(ra);J(pa,ta+0,W,
Ba);J(qa,ta+2,ha,Ba);J(ua,ta+4,fa,Ba)}}function J(W,ha,fa,ra){0>ra&&1===W.x&&(V[ha]=W.x-1);0===fa.x&&0===fa.z&&(V[ha]=ra/2/Math.PI+.5)}function P(W){return Math.atan2(W.z,-W.x)}function R(W){return Math.atan2(-W.y,Math.sqrt(W.x*W.x+W.z*W.z))}va.call(this);this.type="PolyhedronBufferGeometry";this.parameters={vertices:a,indices:c,radius:e,detail:g};e=e||1;g=g||0;var S=[],V=[];(function(W){for(var ha=new k,fa=new k,ra=new k,pa=0;pa<c.length;pa+=3)E(c[pa+0],ha),E(c[pa+1],fa),E(c[pa+2],ra),r(ha,fa,ra,
W)})(g);(function(W){for(var ha=new k,fa=0;fa<S.length;fa+=3)ha.x=S[fa+0],ha.y=S[fa+1],ha.z=S[fa+2],ha.normalize().multiplyScalar(W),S[fa+0]=ha.x,S[fa+1]=ha.y,S[fa+2]=ha.z})(e);(function(){for(var W=new k,ha=0;ha<S.length;ha+=3){W.x=S[ha+0];W.y=S[ha+1];W.z=S[ha+2];var fa=P(W)/2/Math.PI+.5,ra=R(W)/Math.PI+.5;V.push(fa,1-ra)}F();v()})();this.addAttribute("position",new ca(S,3));this.addAttribute("normal",new ca(S.slice(),3));this.addAttribute("uv",new ca(V,2));0===g?this.computeVertexNormals():this.normalizeNormals()}
function Gf(a,c){ya.call(this);this.type="TetrahedronGeometry";this.parameters={radius:a,detail:c};this.fromBufferGeometry(new Ge(a,c));this.mergeVertices()}function Ge(a,c){jc.call(this,[1,1,1,-1,-1,1,-1,1,-1,1,-1,-1],[2,1,0,0,3,2,1,3,0,2,3,1],a,c);this.type="TetrahedronBufferGeometry";this.parameters={radius:a,detail:c}}function Hf(a,c){ya.call(this);this.type="OctahedronGeometry";this.parameters={radius:a,detail:c};this.fromBufferGeometry(new Rd(a,c));this.mergeVertices()}function Rd(a,c){jc.call(this,
[1,0,0,-1,0,0,0,1,0,0,-1,0,0,0,1,0,0,-1],[0,2,4,0,4,3,0,3,5,0,5,2,1,2,5,1,5,3,1,3,4,1,4,2],a,c);this.type="OctahedronBufferGeometry";this.parameters={radius:a,detail:c}}function If(a,c){ya.call(this);this.type="IcosahedronGeometry";this.parameters={radius:a,detail:c};this.fromBufferGeometry(new He(a,c));this.mergeVertices()}function He(a,c){var e=(1+Math.sqrt(5))/2;jc.call(this,[-1,e,0,1,e,0,-1,-e,0,1,-e,0,0,-1,e,0,1,e,0,-1,-e,0,1,-e,e,0,-1,e,0,1,-e,0,-1,-e,0,1],[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],a,c);this.type="IcosahedronBufferGeometry";this.parameters={radius:a,detail:c}}function Jf(a,c){ya.call(this);this.type="DodecahedronGeometry";this.parameters={radius:a,detail:c};this.fromBufferGeometry(new Ie(a,c));this.mergeVertices()}function Ie(a,c){var e=(1+Math.sqrt(5))/2,g=1/e;jc.call(this,[-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,-g,-e,0,-g,e,0,g,-e,0,g,e,-g,-e,0,-g,e,0,g,
-e,0,g,e,0,-e,0,-g,e,0,-g,-e,0,g,e,0,g],[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],a,c);this.type="DodecahedronBufferGeometry";this.parameters={radius:a,detail:c}}function Kf(a,c,e,g,r,v){ya.call(this);this.type="TubeGeometry";this.parameters={path:a,tubularSegments:c,radius:e,
radialSegments:g,closed:r};void 0!==v&&console.warn("THREE.TubeGeometry: taper has been removed.");a=new Sd(a,c,e,g,r);this.tangents=a.tangents;this.normals=a.normals;this.binormals=a.binormals;this.fromBufferGeometry(a);this.mergeVertices()}function Sd(a,c,e,g,r){function v(qa){S=a.getPointAt(qa/c,S);var ua=F.normals[qa];qa=F.binormals[qa];for(W=0;W<=g;W++){var oa=W/g*Math.PI*2,ta=Math.sin(oa);oa=-Math.cos(oa);P.x=oa*ua.x+ta*qa.x;P.y=oa*ua.y+ta*qa.y;P.z=oa*ua.z+ta*qa.z;P.normalize();fa.push(P.x,
P.y,P.z);J.x=S.x+e*P.x;J.y=S.y+e*P.y;J.z=S.z+e*P.z;ha.push(J.x,J.y,J.z)}}function z(){for(W=1;W<=c;W++)for(V=1;V<=g;V++){var qa=(g+1)*W+(V-1),ua=(g+1)*W+V,oa=(g+1)*(W-1)+V;pa.push((g+1)*(W-1)+(V-1),qa,oa);pa.push(qa,ua,oa)}}function E(){for(V=0;V<=c;V++)for(W=0;W<=g;W++)R.x=V/c,R.y=W/g,ra.push(R.x,R.y)}va.call(this);this.type="TubeBufferGeometry";this.parameters={path:a,tubularSegments:c,radius:e,radialSegments:g,closed:r};c=c||64;e=e||1;g=g||8;r=r||!1;var F=a.computeFrenetFrames(c,r);this.tangents=
F.tangents;this.normals=F.normals;this.binormals=F.binormals;var J=new k,P=new k,R=new f,S=new k,V,W,ha=[],fa=[],ra=[],pa=[];(function(){for(V=0;V<c;V++)v(V);v(!1===r?c:0);E();z()})();this.setIndex(pa);this.addAttribute("position",new ca(ha,3));this.addAttribute("normal",new ca(fa,3));this.addAttribute("uv",new ca(ra,2))}function Lf(a,c,e,g,r,v,z){ya.call(this);this.type="TorusKnotGeometry";this.parameters={radius:a,tube:c,tubularSegments:e,radialSegments:g,p:r,q:v};void 0!==z&&console.warn("THREE.TorusKnotGeometry: heightScale has been deprecated. Use .scale( x, y, z ) instead.");
this.fromBufferGeometry(new Je(a,c,e,g,r,v));this.mergeVertices()}function Je(a,c,e,g,r,v){function z(ta,Ba,Ta,Ua,Ca){var Ha=Math.sin(ta);Ba=Ta/Ba*ta;Ta=Math.cos(Ba);Ca.x=Ua*(2+Ta)*.5*Math.cos(ta);Ca.y=Ua*(2+Ta)*Ha*.5;Ca.z=Ua*Math.sin(Ba)*.5}va.call(this);this.type="TorusKnotBufferGeometry";this.parameters={radius:a,tube:c,tubularSegments:e,radialSegments:g,p:r,q:v};a=a||1;c=c||.4;e=Math.floor(e)||64;g=Math.floor(g)||8;r=r||2;v=v||3;var E=[],F=[],J=[],P=[],R,S=new k,V=new k,W=new k,ha=new k,fa=new k,
ra=new k,pa=new k;for(R=0;R<=e;++R){var qa=R/e*r*Math.PI*2;z(qa,r,v,a,W);z(qa+.01,r,v,a,ha);ra.subVectors(ha,W);pa.addVectors(ha,W);fa.crossVectors(ra,pa);pa.crossVectors(fa,ra);fa.normalize();pa.normalize();for(qa=0;qa<=g;++qa){var ua=qa/g*Math.PI*2,oa=-c*Math.cos(ua);ua=c*Math.sin(ua);S.x=W.x+(oa*pa.x+ua*fa.x);S.y=W.y+(oa*pa.y+ua*fa.y);S.z=W.z+(oa*pa.z+ua*fa.z);F.push(S.x,S.y,S.z);V.subVectors(S,W).normalize();J.push(V.x,V.y,V.z);P.push(R/e);P.push(qa/g)}}for(qa=1;qa<=e;qa++)for(R=1;R<=g;R++)a=
(g+1)*qa+(R-1),c=(g+1)*qa+R,r=(g+1)*(qa-1)+R,E.push((g+1)*(qa-1)+(R-1),a,r),E.push(a,c,r);this.setIndex(E);this.addAttribute("position",new ca(F,3));this.addAttribute("normal",new ca(J,3));this.addAttribute("uv",new ca(P,2))}function Mf(a,c,e,g,r){ya.call(this);this.type="TorusGeometry";this.parameters={radius:a,tube:c,radialSegments:e,tubularSegments:g,arc:r};this.fromBufferGeometry(new Ke(a,c,e,g,r));this.mergeVertices()}function Ke(a,c,e,g,r){va.call(this);this.type="TorusBufferGeometry";this.parameters=
{radius:a,tube:c,radialSegments:e,tubularSegments:g,arc:r};a=a||1;c=c||.4;e=Math.floor(e)||8;g=Math.floor(g)||6;r=r||2*Math.PI;var v=[],z=[],E=[],F=[],J=new k,P=new k,R=new k,S,V;for(S=0;S<=e;S++)for(V=0;V<=g;V++){var W=V/g*r,ha=S/e*Math.PI*2;P.x=(a+c*Math.cos(ha))*Math.cos(W);P.y=(a+c*Math.cos(ha))*Math.sin(W);P.z=c*Math.sin(ha);z.push(P.x,P.y,P.z);J.x=a*Math.cos(W);J.y=a*Math.sin(W);R.subVectors(P,J).normalize();E.push(R.x,R.y,R.z);F.push(V/g);F.push(S/e)}for(S=1;S<=e;S++)for(V=1;V<=g;V++)a=(g+
1)*(S-1)+V-1,c=(g+1)*(S-1)+V,r=(g+1)*S+V,v.push((g+1)*S+V-1,a,r),v.push(a,c,r);this.setIndex(v);this.addAttribute("position",new ca(z,3));this.addAttribute("normal",new ca(E,3));this.addAttribute("uv",new ca(F,2))}function Gj(a,c,e,g,r){if(r===0<Xl(a,c,e,g))for(r=c;r<e;r+=g)var v=Hj(r,a[r],a[r+1],v);else for(r=e-g;r>=c;r-=g)v=Hj(r,a[r],a[r+1],v);v&&Td(v,v.next)&&(Nf(v),v=v.next);return v}function Of(a,c){if(!a)return a;c||(c=a);do{var e=!1;if(a.steiner||!Td(a,a.next)&&0!==Wb(a.prev,a,a.next))a=a.next;
else{Nf(a);a=c=a.prev;if(a===a.next)break;e=!0}}while(e||a!==c);return c}function Pf(a,c,e,g,r,v,z){if(a){!z&&v&&Yl(a,g,r,v);for(var E=a,F,J;a.prev!==a.next;)if(F=a.prev,J=a.next,v?Zl(a,g,r,v):$l(a))c.push(F.i/e),c.push(a.i/e),c.push(J.i/e),Nf(a),E=a=J.next;else if(a=J,a===E){z?1===z?(a=am(a,c,e),Pf(a,c,e,g,r,v,2)):2===z&&bm(a,c,e,g,r,v):Pf(Of(a),c,e,g,r,v,1);break}}}function $l(a){var c=a.prev,e=a.next;if(0<=Wb(c,a,e))return!1;for(var g=a.next.next;g!==a.prev;){if(Le(c.x,c.y,a.x,a.y,e.x,e.y,g.x,
g.y)&&0<=Wb(g.prev,g,g.next))return!1;g=g.next}return!0}function Zl(a,c,e,g){var r=a.prev,v=a.next;if(0<=Wb(r,a,v))return!1;var z=r.x>a.x?r.x>v.x?r.x:v.x:a.x>v.x?a.x:v.x,E=r.y>a.y?r.y>v.y?r.y:v.y:a.y>v.y?a.y:v.y,F=Yh(r.x<a.x?r.x<v.x?r.x:v.x:a.x<v.x?a.x:v.x,r.y<a.y?r.y<v.y?r.y:v.y:a.y<v.y?a.y:v.y,c,e,g);c=Yh(z,E,c,e,g);e=a.prevZ;for(g=a.nextZ;e&&e.z>=F&&g&&g.z<=c;){if(e!==a.prev&&e!==a.next&&Le(r.x,r.y,a.x,a.y,v.x,v.y,e.x,e.y)&&0<=Wb(e.prev,e,e.next))return!1;e=e.prevZ;if(g!==a.prev&&g!==a.next&&Le(r.x,
r.y,a.x,a.y,v.x,v.y,g.x,g.y)&&0<=Wb(g.prev,g,g.next))return!1;g=g.nextZ}for(;e&&e.z>=F;){if(e!==a.prev&&e!==a.next&&Le(r.x,r.y,a.x,a.y,v.x,v.y,e.x,e.y)&&0<=Wb(e.prev,e,e.next))return!1;e=e.prevZ}for(;g&&g.z<=c;){if(g!==a.prev&&g!==a.next&&Le(r.x,r.y,a.x,a.y,v.x,v.y,g.x,g.y)&&0<=Wb(g.prev,g,g.next))return!1;g=g.nextZ}return!0}function am(a,c,e){var g=a;do{var r=g.prev,v=g.next.next;!Td(r,v)&&Ij(r,g,g.next,v)&&Qf(r,v)&&Qf(v,r)&&(c.push(r.i/e),c.push(g.i/e),c.push(v.i/e),Nf(g),Nf(g.next),g=a=v);g=g.next}while(g!==
a);return g}function bm(a,c,e,g,r,v){var z=a;do{for(var E=z.next.next;E!==z.prev;){if(z.i!==E.i&&cm(z,E)){a=Jj(z,E);z=Of(z,z.next);a=Of(a,a.next);Pf(z,c,e,g,r,v);Pf(a,c,e,g,r,v);return}E=E.next}z=z.next}while(z!==a)}function dm(a,c,e,g){var r=[],v;var z=0;for(v=c.length;z<v;z++){var E=c[z]*g;var F=z<v-1?c[z+1]*g:a.length;E=Gj(a,E,F,g,!1);E===E.next&&(E.steiner=!0);r.push(em(E))}r.sort(fm);for(z=0;z<r.length;z++)gm(r[z],e),e=Of(e,e.next);return e}function fm(a,c){return a.x-c.x}function gm(a,c){if(c=
hm(a,c))a=Jj(c,a),Of(a,a.next)}function hm(a,c){var e=c,g=a.x,r=a.y,v=-Infinity;do{if(r<=e.y&&r>=e.next.y&&e.next.y!==e.y){var z=e.x+(r-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(z<=g&&z>v){v=z;if(z===g){if(r===e.y)return e;if(r===e.next.y)return e.next}var E=e.x<e.next.x?e:e.next}}e=e.next}while(e!==c);if(!E)return null;if(g===v)return E.prev;c=E;z=E.x;var F=E.y,J=Infinity;for(e=E.next;e!==c;){if(g>=e.x&&e.x>=z&&g!==e.x&&Le(r<F?g:v,r,z,F,r<F?v:g,r,e.x,e.y)){var P=Math.abs(r-e.y)/(g-e.x);(P<J||P===J&&
e.x>E.x)&&Qf(e,a)&&(E=e,J=P)}e=e.next}return E}function Yl(a,c,e,g){var r=a;do null===r.z&&(r.z=Yh(r.x,r.y,c,e,g)),r.prevZ=r.prev,r=r.nextZ=r.next;while(r!==a);r.prevZ.nextZ=null;r.prevZ=null;im(r)}function im(a){var c,e,g,r,v=1;do{var z=a;var E=a=null;for(e=0;z;){e++;var F=z;for(c=g=0;c<v&&(g++,F=F.nextZ,F);c++);for(r=v;0<g||0<r&&F;)0!==g&&(0===r||!F||z.z<=F.z)?(c=z,z=z.nextZ,g--):(c=F,F=F.nextZ,r--),E?E.nextZ=c:a=c,c.prevZ=E,E=c;z=F}E.nextZ=null;v*=2}while(1<e);return a}function Yh(a,c,e,g,r){a=
32767*(a-e)*r;c=32767*(c-g)*r;a=(a|a<<8)&16711935;a=(a|a<<4)&252645135;a=(a|a<<2)&858993459;c=(c|c<<8)&16711935;c=(c|c<<4)&252645135;c=(c|c<<2)&858993459;return(a|a<<1)&1431655765|((c|c<<1)&1431655765)<<1}function em(a){var c=a,e=a;do{if(c.x<e.x||c.x===e.x&&c.y<e.y)e=c;c=c.next}while(c!==a);return e}function Le(a,c,e,g,r,v,z,E){return 0<=(r-z)*(c-E)-(a-z)*(v-E)&&0<=(a-z)*(g-E)-(e-z)*(c-E)&&0<=(e-z)*(v-E)-(r-z)*(g-E)}function cm(a,c){return a.next.i!==c.i&&a.prev.i!==c.i&&!jm(a,c)&&Qf(a,c)&&Qf(c,a)&&
km(a,c)}function Wb(a,c,e){return(c.y-a.y)*(e.x-c.x)-(c.x-a.x)*(e.y-c.y)}function Td(a,c){return a.x===c.x&&a.y===c.y}function Ij(a,c,e,g){return Td(a,e)&&Td(c,g)||Td(a,g)&&Td(e,c)?!0:0<Wb(a,c,e)!==0<Wb(a,c,g)&&0<Wb(e,g,a)!==0<Wb(e,g,c)}function jm(a,c){var e=a;do{if(e.i!==a.i&&e.next.i!==a.i&&e.i!==c.i&&e.next.i!==c.i&&Ij(e,e.next,a,c))return!0;e=e.next}while(e!==a);return!1}function Qf(a,c){return 0>Wb(a.prev,a,a.next)?0<=Wb(a,c,a.next)&&0<=Wb(a,a.prev,c):0>Wb(a,c,a.prev)||0>Wb(a,a.next,c)}function km(a,
c){var e=a,g=!1,r=(a.x+c.x)/2;c=(a.y+c.y)/2;do e.y>c!==e.next.y>c&&e.next.y!==e.y&&r<(e.next.x-e.x)*(c-e.y)/(e.next.y-e.y)+e.x&&(g=!g),e=e.next;while(e!==a);return g}function Jj(a,c){var e=new Zh(a.i,a.x,a.y),g=new Zh(c.i,c.x,c.y),r=a.next,v=c.prev;a.next=c;c.prev=a;e.next=r;r.prev=e;g.next=e;e.prev=g;v.next=g;g.prev=v;return g}function Hj(a,c,e,g){a=new Zh(a,c,e);g?(a.next=g.next,a.prev=g,g.next.prev=a,g.next=a):(a.prev=a,a.next=a);return a}function Nf(a){a.next.prev=a.prev;a.prev.next=a.next;a.prevZ&&
(a.prevZ.nextZ=a.nextZ);a.nextZ&&(a.nextZ.prevZ=a.prevZ)}function Zh(a,c,e){this.i=a;this.x=c;this.y=e;this.nextZ=this.prevZ=this.z=this.next=this.prev=null;this.steiner=!1}function Xl(a,c,e,g){for(var r=0,v=e-g;c<e;c+=g)r+=(a[v]-a[c])*(a[c+1]+a[v+1]),v=c;return r}function Kj(a){var c=a.length;2<c&&a[c-1].equals(a[0])&&a.pop()}function Lj(a,c){for(var e=0;e<c.length;e++)a.push(c[e].x),a.push(c[e].y)}function Ud(a,c){ya.call(this);this.type="ExtrudeGeometry";this.parameters={shapes:a,options:c};this.fromBufferGeometry(new Rc(a,
c));this.mergeVertices()}function Rc(a,c){function e(F){function J(Qa,eb,mb){eb||console.error("THREE.ExtrudeGeometry: vec does not exist");return eb.clone().multiplyScalar(mb).add(Qa)}function P(Qa,eb,mb){var pb=Qa.x-eb.x;var sb=Qa.y-eb.y;var Kb=mb.x-Qa.x;var Sb=mb.y-Qa.y,nc=pb*pb+sb*sb;if(Math.abs(pb*Sb-sb*Kb)>Number.EPSILON){var Qc=Math.sqrt(nc),zc=Math.sqrt(Kb*Kb+Sb*Sb);nc=eb.x-sb/Qc;eb=eb.y+pb/Qc;Sb=((mb.x-Sb/zc-nc)*Sb-(mb.y+Kb/zc-eb)*Kb)/(pb*Sb-sb*Kb);Kb=nc+pb*Sb-Qa.x;pb=eb+sb*Sb-Qa.y;sb=Kb*
Kb+pb*pb;if(2>=sb)return new f(Kb,pb);sb=Math.sqrt(sb/2)}else Qa=!1,pb>Number.EPSILON?Kb>Number.EPSILON&&(Qa=!0):pb<-Number.EPSILON?Kb<-Number.EPSILON&&(Qa=!0):Math.sign(sb)===Math.sign(Sb)&&(Qa=!0),Qa?(Kb=-sb,sb=Math.sqrt(nc)):(Kb=pb,pb=sb,sb=Math.sqrt(nc/2));return new f(Kb/sb,pb/sb)}function R(Qa,eb){for(ja=Qa.length;0<=--ja;){var mb=ja;var pb=ja-1;0>pb&&(pb=Qa.length-1);var sb,Kb=qa+2*Ua;for(sb=0;sb<Kb;sb++){var Sb=Ya*sb,nc=Ya*(sb+1);W(eb+mb+Sb,eb+pb+Sb,eb+pb+nc,eb+mb+nc)}}}function S(Qa,eb,mb){ra.push(Qa);
ra.push(eb);ra.push(mb)}function V(Qa,eb,mb){ha(Qa);ha(eb);ha(mb);Qa=r.length/3;Qa=Ha.generateTopUV(g,r,Qa-3,Qa-2,Qa-1);fa(Qa[0]);fa(Qa[1]);fa(Qa[2])}function W(Qa,eb,mb,pb){ha(Qa);ha(eb);ha(pb);ha(eb);ha(mb);ha(pb);Qa=r.length/3;Qa=Ha.generateSideWallUV(g,r,Qa-6,Qa-3,Qa-2,Qa-1);fa(Qa[0]);fa(Qa[1]);fa(Qa[3]);fa(Qa[1]);fa(Qa[2]);fa(Qa[3])}function ha(Qa){r.push(ra[3*Qa]);r.push(ra[3*Qa+1]);r.push(ra[3*Qa+2])}function fa(Qa){v.push(Qa.x);v.push(Qa.y)}var ra=[],pa=void 0!==c.curveSegments?c.curveSegments:
12,qa=void 0!==c.steps?c.steps:1,ua=void 0!==c.depth?c.depth:100,oa=void 0!==c.bevelEnabled?c.bevelEnabled:!0,ta=void 0!==c.bevelThickness?c.bevelThickness:6,Ba=void 0!==c.bevelSize?c.bevelSize:ta-2,Ta=void 0!==c.bevelOffset?c.bevelOffset:0,Ua=void 0!==c.bevelSegments?c.bevelSegments:3,Ca=c.extrudePath,Ha=void 0!==c.UVGenerator?c.UVGenerator:lm;void 0!==c.amount&&(console.warn("THREE.ExtrudeBufferGeometry: amount has been renamed to depth."),ua=c.amount);var Da=!1;if(Ca){var Ma=Ca.getSpacedPoints(qa);
Da=!0;oa=!1;var db=Ca.computeFrenetFrames(qa,!1);var tb=new k;var Ka=new k;var bb=new k}oa||(Ta=Ba=ta=Ua=0);var jb;pa=F.extractPoints(pa);F=pa.shape;var Eb=pa.holes;if(!ed.isClockWise(F)){F=F.reverse();var xb=0;for(jb=Eb.length;xb<jb;xb++){var ia=Eb[xb];ed.isClockWise(ia)&&(Eb[xb]=ia.reverse())}}var na=ed.triangulateShape(F,Eb),za=F;xb=0;for(jb=Eb.length;xb<jb;xb++)ia=Eb[xb],F=F.concat(ia);var Ja,Ya=F.length,Na,cb=na.length;pa=[];var ja=0;var Ga=za.length;var La=Ga-1;for(Ja=ja+1;ja<Ga;ja++,La++,Ja++)La===
Ga&&(La=0),Ja===Ga&&(Ja=0),pa[ja]=P(za[ja],za[La],za[Ja]);Ca=[];var nb=pa.concat();xb=0;for(jb=Eb.length;xb<jb;xb++){ia=Eb[xb];var Va=[];ja=0;Ga=ia.length;La=Ga-1;for(Ja=ja+1;ja<Ga;ja++,La++,Ja++)La===Ga&&(La=0),Ja===Ga&&(Ja=0),Va[ja]=P(ia[ja],ia[La],ia[Ja]);Ca.push(Va);nb=nb.concat(Va)}for(La=0;La<Ua;La++){Ga=La/Ua;var ib=ta*Math.cos(Ga*Math.PI/2);Ja=Ba*Math.sin(Ga*Math.PI/2)+Ta;ja=0;for(Ga=za.length;ja<Ga;ja++){var kb=J(za[ja],pa[ja],Ja);S(kb.x,kb.y,-ib)}xb=0;for(jb=Eb.length;xb<jb;xb++)for(ia=
Eb[xb],Va=Ca[xb],ja=0,Ga=ia.length;ja<Ga;ja++)kb=J(ia[ja],Va[ja],Ja),S(kb.x,kb.y,-ib)}Ja=Ba+Ta;for(ja=0;ja<Ya;ja++)kb=oa?J(F[ja],nb[ja],Ja):F[ja],Da?(Ka.copy(db.normals[0]).multiplyScalar(kb.x),tb.copy(db.binormals[0]).multiplyScalar(kb.y),bb.copy(Ma[0]).add(Ka).add(tb),S(bb.x,bb.y,bb.z)):S(kb.x,kb.y,0);for(Ga=1;Ga<=qa;Ga++)for(ja=0;ja<Ya;ja++)kb=oa?J(F[ja],nb[ja],Ja):F[ja],Da?(Ka.copy(db.normals[Ga]).multiplyScalar(kb.x),tb.copy(db.binormals[Ga]).multiplyScalar(kb.y),bb.copy(Ma[Ga]).add(Ka).add(tb),
S(bb.x,bb.y,bb.z)):S(kb.x,kb.y,ua/qa*Ga);for(La=Ua-1;0<=La;La--){Ga=La/Ua;ib=ta*Math.cos(Ga*Math.PI/2);Ja=Ba*Math.sin(Ga*Math.PI/2)+Ta;ja=0;for(Ga=za.length;ja<Ga;ja++)kb=J(za[ja],pa[ja],Ja),S(kb.x,kb.y,ua+ib);xb=0;for(jb=Eb.length;xb<jb;xb++)for(ia=Eb[xb],Va=Ca[xb],ja=0,Ga=ia.length;ja<Ga;ja++)kb=J(ia[ja],Va[ja],Ja),Da?S(kb.x,kb.y+Ma[qa-1].y,Ma[qa-1].x+ib):S(kb.x,kb.y,ua+ib)}(function(){var Qa=r.length/3;if(oa){var eb=0*Ya;for(ja=0;ja<cb;ja++)Na=na[ja],V(Na[2]+eb,Na[1]+eb,Na[0]+eb);eb=Ya*(qa+2*Ua);
for(ja=0;ja<cb;ja++)Na=na[ja],V(Na[0]+eb,Na[1]+eb,Na[2]+eb)}else{for(ja=0;ja<cb;ja++)Na=na[ja],V(Na[2],Na[1],Na[0]);for(ja=0;ja<cb;ja++)Na=na[ja],V(Na[0]+Ya*qa,Na[1]+Ya*qa,Na[2]+Ya*qa)}g.addGroup(Qa,r.length/3-Qa,0)})();(function(){var Qa=r.length/3,eb=0;R(za,eb);eb+=za.length;xb=0;for(jb=Eb.length;xb<jb;xb++)ia=Eb[xb],R(ia,eb),eb+=ia.length;g.addGroup(Qa,r.length/3-Qa,1)})()}va.call(this);this.type="ExtrudeBufferGeometry";this.parameters={shapes:a,options:c};a=Array.isArray(a)?a:[a];for(var g=this,
r=[],v=[],z=0,E=a.length;z<E;z++)e(a[z]);this.addAttribute("position",new ca(r,3));this.addAttribute("uv",new ca(v,2));this.computeVertexNormals()}function Mj(a,c,e){e.shapes=[];if(Array.isArray(a))for(var g=0,r=a.length;g<r;g++)e.shapes.push(a[g].uuid);else e.shapes.push(a.uuid);void 0!==c.extrudePath&&(e.options.extrudePath=c.extrudePath.toJSON());return e}function Rf(a,c){ya.call(this);this.type="TextGeometry";this.parameters={text:a,parameters:c};this.fromBufferGeometry(new Me(a,c));this.mergeVertices()}
function Me(a,c){c=c||{};var e=c.font;if(!e||!e.isFont)return console.error("THREE.TextGeometry: font parameter is not an instance of THREE.Font."),new ya;a=e.generateShapes(a,c.size);c.depth=void 0!==c.height?c.height:50;void 0===c.bevelThickness&&(c.bevelThickness=10);void 0===c.bevelSize&&(c.bevelSize=8);void 0===c.bevelEnabled&&(c.bevelEnabled=!1);Rc.call(this,a,c);this.type="TextBufferGeometry"}function Sf(a,c,e,g,r,v,z){ya.call(this);this.type="SphereGeometry";this.parameters={radius:a,widthSegments:c,
heightSegments:e,phiStart:g,phiLength:r,thetaStart:v,thetaLength:z};this.fromBufferGeometry(new Bd(a,c,e,g,r,v,z));this.mergeVertices()}function Bd(a,c,e,g,r,v,z){va.call(this);this.type="SphereBufferGeometry";this.parameters={radius:a,widthSegments:c,heightSegments:e,phiStart:g,phiLength:r,thetaStart:v,thetaLength:z};a=a||1;c=Math.max(3,Math.floor(c)||8);e=Math.max(2,Math.floor(e)||6);g=void 0!==g?g:0;r=void 0!==r?r:2*Math.PI;v=void 0!==v?v:0;z=void 0!==z?z:Math.PI;var E=Math.min(v+z,Math.PI),F,
J,P=0,R=[],S=new k,V=new k,W=[],ha=[],fa=[],ra=[];for(J=0;J<=e;J++){var pa=[],qa=J/e,ua=0;0==J&&0==v?ua=.5/c:J==e&&E==Math.PI&&(ua=-.5/c);for(F=0;F<=c;F++){var oa=F/c;S.x=-a*Math.cos(g+oa*r)*Math.sin(v+qa*z);S.y=a*Math.cos(v+qa*z);S.z=a*Math.sin(g+oa*r)*Math.sin(v+qa*z);ha.push(S.x,S.y,S.z);V.copy(S).normalize();fa.push(V.x,V.y,V.z);ra.push(oa+ua,1-qa);pa.push(P++)}R.push(pa)}for(J=0;J<e;J++)for(F=0;F<c;F++)a=R[J][F+1],g=R[J][F],r=R[J+1][F],z=R[J+1][F+1],(0!==J||0<v)&&W.push(a,g,z),(J!==e-1||E<Math.PI)&&
W.push(g,r,z);this.setIndex(W);this.addAttribute("position",new ca(ha,3));this.addAttribute("normal",new ca(fa,3));this.addAttribute("uv",new ca(ra,2))}function Tf(a,c,e,g,r,v){ya.call(this);this.type="RingGeometry";this.parameters={innerRadius:a,outerRadius:c,thetaSegments:e,phiSegments:g,thetaStart:r,thetaLength:v};this.fromBufferGeometry(new Ne(a,c,e,g,r,v));this.mergeVertices()}function Ne(a,c,e,g,r,v){va.call(this);this.type="RingBufferGeometry";this.parameters={innerRadius:a,outerRadius:c,thetaSegments:e,
phiSegments:g,thetaStart:r,thetaLength:v};a=a||.5;c=c||1;r=void 0!==r?r:0;v=void 0!==v?v:2*Math.PI;e=void 0!==e?Math.max(3,e):8;g=void 0!==g?Math.max(1,g):1;var z=[],E=[],F=[],J=[],P=a,R=(c-a)/g,S=new k,V=new f,W,ha;for(W=0;W<=g;W++){for(ha=0;ha<=e;ha++)a=r+ha/e*v,S.x=P*Math.cos(a),S.y=P*Math.sin(a),E.push(S.x,S.y,S.z),F.push(0,0,1),V.x=(S.x/c+1)/2,V.y=(S.y/c+1)/2,J.push(V.x,V.y);P+=R}for(W=0;W<g;W++)for(c=W*(e+1),ha=0;ha<e;ha++)a=ha+c,r=a+e+1,v=a+e+2,P=a+1,z.push(a,r,P),z.push(r,v,P);this.setIndex(z);
this.addAttribute("position",new ca(E,3));this.addAttribute("normal",new ca(F,3));this.addAttribute("uv",new ca(J,2))}function Uf(a,c,e,g){ya.call(this);this.type="LatheGeometry";this.parameters={points:a,segments:c,phiStart:e,phiLength:g};this.fromBufferGeometry(new Oe(a,c,e,g));this.mergeVertices()}function Oe(a,c,e,g){va.call(this);this.type="LatheBufferGeometry";this.parameters={points:a,segments:c,phiStart:e,phiLength:g};c=Math.floor(c)||12;e=e||0;g=g||2*Math.PI;g=hb.clamp(g,0,2*Math.PI);var r=
[],v=[],z=[],E=1/c,F=new k,J=new f,P;for(P=0;P<=c;P++){var R=e+P*E*g;var S=Math.sin(R),V=Math.cos(R);for(R=0;R<=a.length-1;R++)F.x=a[R].x*S,F.y=a[R].y,F.z=a[R].x*V,v.push(F.x,F.y,F.z),J.x=P/c,J.y=R/(a.length-1),z.push(J.x,J.y)}for(P=0;P<c;P++)for(R=0;R<a.length-1;R++)e=R+P*a.length,E=e+a.length,F=e+a.length+1,J=e+1,r.push(e,E,J),r.push(E,F,J);this.setIndex(r);this.addAttribute("position",new ca(v,3));this.addAttribute("uv",new ca(z,2));this.computeVertexNormals();if(g===2*Math.PI)for(g=this.attributes.normal.array,
r=new k,v=new k,z=new k,e=c*a.length*3,R=P=0;P<a.length;P++,R+=3)r.x=g[R+0],r.y=g[R+1],r.z=g[R+2],v.x=g[e+R+0],v.y=g[e+R+1],v.z=g[e+R+2],z.addVectors(r,v).normalize(),g[R+0]=g[e+R+0]=z.x,g[R+1]=g[e+R+1]=z.y,g[R+2]=g[e+R+2]=z.z}function Vd(a,c){ya.call(this);this.type="ShapeGeometry";"object"===typeof c&&(console.warn("THREE.ShapeGeometry: Options parameter has been removed."),c=c.curveSegments);this.parameters={shapes:a,curveSegments:c};this.fromBufferGeometry(new Wd(a,c));this.mergeVertices()}function Wd(a,
c){function e(P){var R,S=r.length/3;P=P.extractPoints(c);var V=P.shape,W=P.holes;!1===ed.isClockWise(V)&&(V=V.reverse());P=0;for(R=W.length;P<R;P++){var ha=W[P];!0===ed.isClockWise(ha)&&(W[P]=ha.reverse())}var fa=ed.triangulateShape(V,W);P=0;for(R=W.length;P<R;P++)ha=W[P],V=V.concat(ha);P=0;for(R=V.length;P<R;P++)ha=V[P],r.push(ha.x,ha.y,0),v.push(0,0,1),z.push(ha.x,ha.y);P=0;for(R=fa.length;P<R;P++)V=fa[P],g.push(V[0]+S,V[1]+S,V[2]+S),F+=3}va.call(this);this.type="ShapeBufferGeometry";this.parameters=
{shapes:a,curveSegments:c};c=c||12;var g=[],r=[],v=[],z=[],E=0,F=0;if(!1===Array.isArray(a))e(a);else for(var J=0;J<a.length;J++)e(a[J]),this.addGroup(E,F,J),E+=F,F=0;this.setIndex(g);this.addAttribute("position",new ca(r,3));this.addAttribute("normal",new ca(v,3));this.addAttribute("uv",new ca(z,2))}function Nj(a,c){c.shapes=[];if(Array.isArray(a))for(var e=0,g=a.length;e<g;e++)c.shapes.push(a[e].uuid);else c.shapes.push(a.uuid);return c}function Pe(a,c){va.call(this);this.type="EdgesGeometry";this.parameters=
{thresholdAngle:c};var e=[];c=Math.cos(hb.DEG2RAD*(void 0!==c?c:1));var g=[0,0],r={},v=["a","b","c"];if(a.isBufferGeometry){var z=new ya;z.fromBufferGeometry(a)}else z=a.clone();z.mergeVertices();z.computeFaceNormals();a=z.vertices;z=z.faces;for(var E=0,F=z.length;E<F;E++)for(var J=z[E],P=0;3>P;P++){var R=J[v[P]];var S=J[v[(P+1)%3]];g[0]=Math.min(R,S);g[1]=Math.max(R,S);R=g[0]+","+g[1];void 0===r[R]?r[R]={index1:g[0],index2:g[1],face1:E,face2:void 0}:r[R].face2=E}for(R in r)if(g=r[R],void 0===g.face2||
z[g.face1].normal.dot(z[g.face2].normal)<=c)v=a[g.index1],e.push(v.x,v.y,v.z),v=a[g.index2],e.push(v.x,v.y,v.z);this.addAttribute("position",new ca(e,3))}function Xd(a,c,e,g,r,v,z,E){ya.call(this);this.type="CylinderGeometry";this.parameters={radiusTop:a,radiusBottom:c,height:e,radialSegments:g,heightSegments:r,openEnded:v,thetaStart:z,thetaLength:E};this.fromBufferGeometry(new fd(a,c,e,g,r,v,z,E));this.mergeVertices()}function fd(a,c,e,g,r,v,z,E){function F(pa){var qa,ua=new f,oa=new k,ta=0,Ba=!0===
pa?a:c,Ta=!0===pa?1:-1;var Ua=W;for(qa=1;qa<=g;qa++)R.push(0,fa*Ta,0),S.push(0,Ta,0),V.push(.5,.5),W++;var Ca=W;for(qa=0;qa<=g;qa++){var Ha=qa/g*E+z,Da=Math.cos(Ha);Ha=Math.sin(Ha);oa.x=Ba*Ha;oa.y=fa*Ta;oa.z=Ba*Da;R.push(oa.x,oa.y,oa.z);S.push(0,Ta,0);ua.x=.5*Da+.5;ua.y=.5*Ha*Ta+.5;V.push(ua.x,ua.y);W++}for(qa=0;qa<g;qa++)ua=Ua+qa,oa=Ca+qa,!0===pa?P.push(oa,oa+1,ua):P.push(oa+1,oa,ua),ta+=3;J.addGroup(ra,ta,!0===pa?1:2);ra+=ta}va.call(this);this.type="CylinderBufferGeometry";this.parameters={radiusTop:a,
radiusBottom:c,height:e,radialSegments:g,heightSegments:r,openEnded:v,thetaStart:z,thetaLength:E};var J=this;a=void 0!==a?a:1;c=void 0!==c?c:1;e=e||1;g=Math.floor(g)||8;r=Math.floor(r)||1;v=void 0!==v?v:!1;z=void 0!==z?z:0;E=void 0!==E?E:2*Math.PI;var P=[],R=[],S=[],V=[],W=0,ha=[],fa=e/2,ra=0;(function(){var pa,qa,ua=new k,oa=new k,ta=0,Ba=(c-a)/e;for(qa=0;qa<=r;qa++){var Ta=[],Ua=qa/r,Ca=Ua*(c-a)+a;for(pa=0;pa<=g;pa++){var Ha=pa/g,Da=Ha*E+z,Ma=Math.sin(Da);Da=Math.cos(Da);oa.x=Ca*Ma;oa.y=-Ua*e+fa;
oa.z=Ca*Da;R.push(oa.x,oa.y,oa.z);ua.set(Ma,Ba,Da).normalize();S.push(ua.x,ua.y,ua.z);V.push(Ha,1-Ua);Ta.push(W++)}ha.push(Ta)}for(pa=0;pa<g;pa++)for(qa=0;qa<r;qa++)ua=ha[qa+1][pa],oa=ha[qa+1][pa+1],Ba=ha[qa][pa+1],P.push(ha[qa][pa],ua,Ba),P.push(ua,oa,Ba),ta+=6;J.addGroup(ra,ta,0);ra+=ta})();!1===v&&(0<a&&F(!0),0<c&&F(!1));this.setIndex(P);this.addAttribute("position",new ca(R,3));this.addAttribute("normal",new ca(S,3));this.addAttribute("uv",new ca(V,2))}function Vf(a,c,e,g,r,v,z){Xd.call(this,
0,a,c,e,g,r,v,z);this.type="ConeGeometry";this.parameters={radius:a,height:c,radialSegments:e,heightSegments:g,openEnded:r,thetaStart:v,thetaLength:z}}function Wf(a,c,e,g,r,v,z){fd.call(this,0,a,c,e,g,r,v,z);this.type="ConeBufferGeometry";this.parameters={radius:a,height:c,radialSegments:e,heightSegments:g,openEnded:r,thetaStart:v,thetaLength:z}}function Xf(a,c,e,g){ya.call(this);this.type="CircleGeometry";this.parameters={radius:a,segments:c,thetaStart:e,thetaLength:g};this.fromBufferGeometry(new Qe(a,
c,e,g));this.mergeVertices()}function Qe(a,c,e,g){va.call(this);this.type="CircleBufferGeometry";this.parameters={radius:a,segments:c,thetaStart:e,thetaLength:g};a=a||1;c=void 0!==c?Math.max(3,c):8;e=void 0!==e?e:0;g=void 0!==g?g:2*Math.PI;var r=[],v=[],z=[],E=[],F,J=new k,P=new f;v.push(0,0,0);z.push(0,0,1);E.push(.5,.5);var R=0;for(F=3;R<=c;R++,F+=3){var S=e+R/c*g;J.x=a*Math.cos(S);J.y=a*Math.sin(S);v.push(J.x,J.y,J.z);z.push(0,0,1);P.x=(v[F]/a+1)/2;P.y=(v[F+1]/a+1)/2;E.push(P.x,P.y)}for(F=1;F<=
c;F++)r.push(F,F+1,0);this.setIndex(r);this.addAttribute("position",new ca(v,3));this.addAttribute("normal",new ca(z,3));this.addAttribute("uv",new ca(E,2))}function Yd(a){M.call(this);this.type="ShadowMaterial";this.color=new I(0);this.transparent=!0;this.setValues(a)}function Re(a){qb.call(this,a);this.type="RawShaderMaterial"}function Sc(a){M.call(this);this.defines={STANDARD:""};this.type="MeshStandardMaterial";this.color=new I(16777215);this.metalness=this.roughness=.5;this.lightMap=this.map=
null;this.lightMapIntensity=1;this.aoMap=null;this.aoMapIntensity=1;this.emissive=new I(0);this.emissiveIntensity=1;this.bumpMap=this.emissiveMap=null;this.bumpScale=1;this.normalMap=null;this.normalMapType=0;this.normalScale=new f(1,1);this.displacementMap=null;this.displacementScale=1;this.displacementBias=0;this.envMap=this.alphaMap=this.metalnessMap=this.roughnessMap=null;this.envMapIntensity=1;this.refractionRatio=.98;this.wireframe=!1;this.wireframeLinewidth=1;this.wireframeLinejoin=this.wireframeLinecap=
"round";this.morphNormals=this.morphTargets=this.skinning=!1;this.setValues(a)}function Zd(a){Sc.call(this);this.defines={STANDARD:"",PHYSICAL:""};this.type="MeshPhysicalMaterial";this.reflectivity=.5;this.clearcoatRoughness=this.clearcoat=0;this.sheen=null;this.clearcoatNormalScale=new f(1,1);this.clearcoatNormalMap=null;this.transparency=0;this.setValues(a)}function Bc(a){M.call(this);this.type="MeshPhongMaterial";this.color=new I(16777215);this.specular=new I(1118481);this.shininess=30;this.lightMap=
this.map=null;this.lightMapIntensity=1;this.aoMap=null;this.aoMapIntensity=1;this.emissive=new I(0);this.emissiveIntensity=1;this.bumpMap=this.emissiveMap=null;this.bumpScale=1;this.normalMap=null;this.normalMapType=0;this.normalScale=new f(1,1);this.displacementMap=null;this.displacementScale=1;this.displacementBias=0;this.envMap=this.alphaMap=this.specularMap=null;this.combine=0;this.reflectivity=1;this.refractionRatio=.98;this.wireframe=!1;this.wireframeLinewidth=1;this.wireframeLinejoin=this.wireframeLinecap=
"round";this.morphNormals=this.morphTargets=this.skinning=!1;this.setValues(a)}function $d(a){Bc.call(this);this.defines={TOON:""};this.type="MeshToonMaterial";this.gradientMap=null;this.setValues(a)}function ae(a){M.call(this);this.type="MeshNormalMaterial";this.bumpMap=null;this.bumpScale=1;this.normalMap=null;this.normalMapType=0;this.normalScale=new f(1,1);this.displacementMap=null;this.displacementScale=1;this.displacementBias=0;this.wireframe=!1;this.wireframeLinewidth=1;this.morphNormals=this.morphTargets=
this.skinning=this.lights=this.fog=!1;this.setValues(a)}function be(a){M.call(this);this.type="MeshLambertMaterial";this.color=new I(16777215);this.lightMap=this.map=null;this.lightMapIntensity=1;this.aoMap=null;this.aoMapIntensity=1;this.emissive=new I(0);this.emissiveIntensity=1;this.envMap=this.alphaMap=this.specularMap=this.emissiveMap=null;this.combine=0;this.reflectivity=1;this.refractionRatio=.98;this.wireframe=!1;this.wireframeLinewidth=1;this.wireframeLinejoin=this.wireframeLinecap="round";
this.morphNormals=this.morphTargets=this.skinning=!1;this.setValues(a)}function ce(a){M.call(this);this.defines={MATCAP:""};this.type="MeshMatcapMaterial";this.color=new I(16777215);this.bumpMap=this.map=this.matcap=null;this.bumpScale=1;this.normalMap=null;this.normalMapType=0;this.normalScale=new f(1,1);this.displacementMap=null;this.displacementScale=1;this.displacementBias=0;this.alphaMap=null;this.lights=this.morphNormals=this.morphTargets=this.skinning=!1;this.setValues(a)}function de(a){Fb.call(this);
this.type="LineDashedMaterial";this.scale=1;this.dashSize=3;this.gapSize=1;this.setValues(a)}function oc(a,c,e,g){this.parameterPositions=a;this._cachedIndex=0;this.resultBuffer=void 0!==g?g:new c.constructor(e);this.sampleValues=c;this.valueSize=e}function Eg(a,c,e,g){oc.call(this,a,c,e,g);this._offsetNext=this._weightNext=this._offsetPrev=this._weightPrev=-0}function Yf(a,c,e,g){oc.call(this,a,c,e,g)}function Fg(a,c,e,g){oc.call(this,a,c,e,g)}function Xb(a,c,e,g){if(void 0===a)throw Error("THREE.KeyframeTrack: track name is undefined");
if(void 0===c||0===c.length)throw Error("THREE.KeyframeTrack: no keyframes in track named "+a);this.name=a;this.times=Tb.convertArray(c,this.TimeBufferType);this.values=Tb.convertArray(e,this.ValueBufferType);this.setInterpolation(g||this.DefaultInterpolation)}function Gg(a,c,e){Xb.call(this,a,c,e)}function Hg(a,c,e,g){Xb.call(this,a,c,e,g)}function Se(a,c,e,g){Xb.call(this,a,c,e,g)}function Ig(a,c,e,g){oc.call(this,a,c,e,g)}function Zf(a,c,e,g){Xb.call(this,a,c,e,g)}function Jg(a,c,e,g){Xb.call(this,
a,c,e,g)}function Te(a,c,e,g){Xb.call(this,a,c,e,g)}function tc(a,c,e){this.name=a;this.tracks=e;this.duration=void 0!==c?c:-1;this.uuid=hb.generateUUID();0>this.duration&&this.resetDuration()}function mm(a){switch(a.toLowerCase()){case "scalar":case "double":case "float":case "number":case "integer":return Se;case "vector":case "vector2":case "vector3":case "vector4":return Te;case "color":return Hg;case "quaternion":return Zf;case "bool":case "boolean":return Gg;case "string":return Jg}throw Error("THREE.KeyframeTrack: Unsupported typeName: "+
a);}function nm(a){if(void 0===a.type)throw Error("THREE.KeyframeTrack: track type undefined, can not parse");var c=mm(a.type);if(void 0===a.times){var e=[],g=[];Tb.flattenJSON(a.keys,e,g,"value");a.times=e;a.values=g}return void 0!==c.parse?c.parse(a):new c(a.name,a.times,a.values,a.interpolation)}function $h(a,c,e){var g=this,r=!1,v=0,z=0,E=void 0;this.onStart=void 0;this.onLoad=a;this.onProgress=c;this.onError=e;this.itemStart=function(F){z++;if(!1===r&&void 0!==g.onStart)g.onStart(F,v,z);r=!0};
this.itemEnd=function(F){v++;if(void 0!==g.onProgress)g.onProgress(F,v,z);if(v===z&&(r=!1,void 0!==g.onLoad))g.onLoad()};this.itemError=function(F){if(void 0!==g.onError)g.onError(F)};this.resolveURL=function(F){return E?E(F):F};this.setURLModifier=function(F){E=F;return this}}function Db(a){this.manager=void 0!==a?a:Oj;this.crossOrigin="anonymous";this.resourcePath=this.path=""}function uc(a){Db.call(this,a)}function ai(a){Db.call(this,a)}function bi(a){Db.call(this,a);this._parser=null}function Kg(a){Db.call(this,
a);this._parser=null}function Ue(a){Db.call(this,a)}function Lg(a){Db.call(this,a)}function Mg(a){Db.call(this,a)}function Za(){this.type="Curve";this.arcLengthDivisions=200}function pc(a,c,e,g,r,v,z,E){Za.call(this);this.type="EllipseCurve";this.aX=a||0;this.aY=c||0;this.xRadius=e||1;this.yRadius=g||1;this.aStartAngle=r||0;this.aEndAngle=v||2*Math.PI;this.aClockwise=z||!1;this.aRotation=E||0}function Ve(a,c,e,g,r,v){pc.call(this,a,c,e,e,g,r,v);this.type="ArcCurve"}function ci(){function a(v,z,E,
F){c=v;e=E;g=-3*v+3*z-2*E-F;r=2*v-2*z+E+F}var c=0,e=0,g=0,r=0;return{initCatmullRom:function(v,z,E,F,J){a(z,E,J*(E-v),J*(F-z))},initNonuniformCatmullRom:function(v,z,E,F,J,P,R){a(z,E,((z-v)/J-(E-v)/(J+P)+(E-z)/P)*P,((E-z)/P-(F-z)/(P+R)+(F-E)/R)*P)},calc:function(v){var z=v*v;return c+e*v+g*z+r*z*v}}}function Zb(a,c,e,g){Za.call(this);this.type="CatmullRomCurve3";this.points=a||[];this.closed=c||!1;this.curveType=e||"centripetal";this.tension=g||.5}function Pj(a,c,e,g,r){c=.5*(g-c);r=.5*(r-e);var v=
a*a;return(2*e-2*g+c+r)*a*v+(-3*e+3*g-2*c-r)*v+c*a+e}function om(a,c){a=1-a;return a*a*c}function pm(a,c){return 2*(1-a)*a*c}function qm(a,c){return a*a*c}function $f(a,c,e,g){return om(a,c)+pm(a,e)+qm(a,g)}function rm(a,c){a=1-a;return a*a*a*c}function sm(a,c){var e=1-a;return 3*e*e*a*c}function tm(a,c){return 3*(1-a)*a*a*c}function um(a,c){return a*a*a*c}function ag(a,c,e,g,r){return rm(a,c)+sm(a,e)+tm(a,g)+um(a,r)}function Cc(a,c,e,g){Za.call(this);this.type="CubicBezierCurve";this.v0=a||new f;
this.v1=c||new f;this.v2=e||new f;this.v3=g||new f}function Tc(a,c,e,g){Za.call(this);this.type="CubicBezierCurve3";this.v0=a||new k;this.v1=c||new k;this.v2=e||new k;this.v3=g||new k}function kc(a,c){Za.call(this);this.type="LineCurve";this.v1=a||new f;this.v2=c||new f}function Dc(a,c){Za.call(this);this.type="LineCurve3";this.v1=a||new k;this.v2=c||new k}function Ec(a,c,e){Za.call(this);this.type="QuadraticBezierCurve";this.v0=a||new f;this.v1=c||new f;this.v2=e||new f}function Uc(a,c,e){Za.call(this);
this.type="QuadraticBezierCurve3";this.v0=a||new k;this.v1=c||new k;this.v2=e||new k}function Fc(a){Za.call(this);this.type="SplineCurve";this.points=a||[]}function gd(){Za.call(this);this.type="CurvePath";this.curves=[];this.autoClose=!1}function Gc(a){gd.call(this);this.type="Path";this.currentPoint=new f;a&&this.setFromPoints(a)}function Cd(a){Gc.call(this,a);this.uuid=hb.generateUUID();this.type="Shape";this.holes=[]}function Jb(a,c){A.call(this);this.type="Light";this.color=new I(a);this.intensity=
void 0!==c?c:1;this.receiveShadow=void 0}function Ng(a,c,e){Jb.call(this,a,e);this.type="HemisphereLight";this.castShadow=void 0;this.position.copy(A.DefaultUp);this.updateMatrix();this.groundColor=new I(c)}function Vc(a){this.camera=a;this.bias=0;this.radius=1;this.mapSize=new f(512,512);this.mapPass=this.map=null;this.matrix=new q;this._frustum=new ic;this._frameExtents=new f(1,1);this._viewportCount=1;this._viewports=[new p(0,0,1,1)]}function Og(){Vc.call(this,new vb(50,1,.5,500))}function Pg(a,
c,e,g,r,v){Jb.call(this,a,c);this.type="SpotLight";this.position.copy(A.DefaultUp);this.updateMatrix();this.target=new A;Object.defineProperty(this,"power",{get:function(){return this.intensity*Math.PI},set:function(z){this.intensity=z/Math.PI}});this.distance=void 0!==e?e:0;this.angle=void 0!==g?g:Math.PI/3;this.penumbra=void 0!==r?r:0;this.decay=void 0!==v?v:1;this.shadow=new Og}function di(){Vc.call(this,new vb(90,1,.5,500));this._frameExtents=new f(4,2);this._viewportCount=6;this._viewports=[new p(2,
1,1,1),new p(0,1,1,1),new p(3,1,1,1),new p(1,1,1,1),new p(3,0,1,1),new p(1,0,1,1)];this._cubeDirections=[new k(1,0,0),new k(-1,0,0),new k(0,0,1),new k(0,0,-1),new k(0,1,0),new k(0,-1,0)];this._cubeUps=[new k(0,1,0),new k(0,1,0),new k(0,1,0),new k(0,1,0),new k(0,0,1),new k(0,0,-1)]}function Qg(a,c,e,g){Jb.call(this,a,c);this.type="PointLight";Object.defineProperty(this,"power",{get:function(){return 4*this.intensity*Math.PI},set:function(r){this.intensity=r/(4*Math.PI)}});this.distance=void 0!==e?
e:0;this.decay=void 0!==g?g:1;this.shadow=new di}function bg(a,c,e,g,r,v){zb.call(this);this.type="OrthographicCamera";this.zoom=1;this.view=null;this.left=void 0!==a?a:-1;this.right=void 0!==c?c:1;this.top=void 0!==e?e:1;this.bottom=void 0!==g?g:-1;this.near=void 0!==r?r:.1;this.far=void 0!==v?v:2E3;this.updateProjectionMatrix()}function Rg(){Vc.call(this,new bg(-5,5,5,-5,.5,500))}function Sg(a,c){Jb.call(this,a,c);this.type="DirectionalLight";this.position.copy(A.DefaultUp);this.updateMatrix();
this.target=new A;this.shadow=new Rg}function Tg(a,c){Jb.call(this,a,c);this.type="AmbientLight";this.castShadow=void 0}function Ug(a,c,e,g){Jb.call(this,a,c);this.type="RectAreaLight";this.width=void 0!==e?e:10;this.height=void 0!==g?g:10}function Vg(a){Db.call(this,a);this.textures={}}function Wg(){va.call(this);this.type="InstancedBufferGeometry";this.maxInstancedCount=void 0}function Xg(a,c,e,g){"number"===typeof e&&(g=e,e=!1,console.error("THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument."));
Q.call(this,a,c,e);this.meshPerAttribute=g||1}function Yg(a){Db.call(this,a)}function Zg(a){Db.call(this,a)}function ei(a){"undefined"===typeof createImageBitmap&&console.warn("THREE.ImageBitmapLoader: createImageBitmap() not supported.");"undefined"===typeof fetch&&console.warn("THREE.ImageBitmapLoader: fetch() not supported.");Db.call(this,a);this.options=void 0}function fi(){this.type="ShapePath";this.color=new I;this.subPaths=[];this.currentPath=null}function gi(a){this.type="Font";this.data=
a}function vm(a,c,e){a=Array.from?Array.from(a):String(a).split("");c/=e.resolution;for(var g=(e.boundingBox.yMax-e.boundingBox.yMin+e.underlineThickness)*c,r=[],v=0,z=0,E=0;E<a.length;E++){var F=a[E];"\n"===F?(v=0,z-=g):(F=wm(F,c,v,z,e),v+=F.offsetX,r.push(F.path))}return r}function wm(a,c,e,g,r){var v=r.glyphs[a]||r.glyphs["?"];if(v){a=new fi;if(v.o){r=v._cachedOutline||(v._cachedOutline=v.o.split(" "));for(var z=0,E=r.length;z<E;)switch(r[z++]){case "m":var F=r[z++]*c+e;var J=r[z++]*c+g;a.moveTo(F,
J);break;case "l":F=r[z++]*c+e;J=r[z++]*c+g;a.lineTo(F,J);break;case "q":F=r[z++]*c+e;J=r[z++]*c+g;var P=r[z++]*c+e;var R=r[z++]*c+g;a.quadraticCurveTo(P,R,F,J);break;case "b":F=r[z++]*c+e;J=r[z++]*c+g;P=r[z++]*c+e;R=r[z++]*c+g;var S=r[z++]*c+e;var V=r[z++]*c+g;a.bezierCurveTo(P,R,S,V,F,J)}}return{offsetX:v.ha*c,path:a}}console.error('THREE.Font: character "'+a+'" does not exists in font family '+r.familyName+".")}function hi(a){Db.call(this,a)}function $g(a){Db.call(this,a)}function ah(){this.coefficients=
[];for(var a=0;9>a;a++)this.coefficients.push(new k)}function Hc(a,c){Jb.call(this,void 0,c);this.sh=void 0!==a?a:new ah}function ii(a,c,e){Hc.call(this,void 0,e);a=(new I).set(a);e=(new I).set(c);c=new k(a.r,a.g,a.b);a=new k(e.r,e.g,e.b);e=Math.sqrt(Math.PI);var g=e*Math.sqrt(.75);this.sh.coefficients[0].copy(c).add(a).multiplyScalar(e);this.sh.coefficients[1].copy(c).sub(a).multiplyScalar(g)}function ji(a,c){Hc.call(this,void 0,c);a=(new I).set(a);this.sh.coefficients[0].set(a.r,a.g,a.b).multiplyScalar(2*
Math.sqrt(Math.PI))}function Qj(){this.type="StereoCamera";this.aspect=1;this.eyeSep=.064;this.cameraL=new vb;this.cameraL.layers.enable(1);this.cameraL.matrixAutoUpdate=!1;this.cameraR=new vb;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}}function ki(a){this.autoStart=void 0!==a?a:!0;this.elapsedTime=this.oldTime=this.startTime=0;this.running=!1}function li(){A.call(this);this.type="AudioListener";
this.context=mi.getContext();this.gain=this.context.createGain();this.gain.connect(this.context.destination);this.filter=null;this.timeDelta=0;this._clock=new ki}function We(a){A.call(this);this.type="Audio";this.listener=a;this.context=a.context;this.gain=this.context.createGain();this.gain.connect(a.getInput());this.autoplay=!1;this.buffer=null;this.detune=0;this.loop=!1;this.offset=this.startTime=0;this.duration=void 0;this.playbackRate=1;this.isPlaying=!1;this.hasPlaybackControl=!0;this.sourceType=
"empty";this.filters=[]}function ni(a){We.call(this,a);this.panner=this.context.createPanner();this.panner.panningModel="HRTF";this.panner.connect(this.gain)}function oi(a,c){this.analyser=a.context.createAnalyser();this.analyser.fftSize=void 0!==c?c:2048;this.data=new Uint8Array(this.analyser.frequencyBinCount);a.getOutput().connect(this.analyser)}function pi(a,c,e){this.binding=a;this.valueSize=e;a=Float64Array;switch(c){case "quaternion":c=this._slerp;break;case "string":case "bool":a=Array;c=
this._select;break;default:c=this._lerp}this.buffer=new a(4*e);this._mixBufferRegion=c;this.referenceCount=this.useCount=this.cumulativeWeight=0}function Rj(a,c,e){e=e||$b.parseTrackName(c);this._targetGroup=a;this._bindings=a.subscribe_(c,e)}function $b(a,c,e){this.path=c;this.parsedPath=e||$b.parseTrackName(c);this.node=$b.findNode(a,this.parsedPath.nodeName)||a;this.rootNode=a}function Sj(){this.uuid=hb.generateUUID();this._objects=Array.prototype.slice.call(arguments);this.nCachedObjects_=0;var a=
{};this._indicesByUUID=a;for(var c=0,e=arguments.length;c!==e;++c)a[arguments[c].uuid]=c;this._paths=[];this._parsedPaths=[];this._bindings=[];this._bindingsIndicesByPath={};var g=this;this.stats={objects:{get total(){return g._objects.length},get inUse(){return this.total-g.nCachedObjects_}},get bindingsPerObject(){return g._bindings.length}}}function Tj(a,c,e){this._mixer=a;this._clip=c;this._localRoot=e||null;a=c.tracks;c=a.length;e=Array(c);for(var g={endingStart:2400,endingEnd:2400},r=0;r!==
c;++r){var v=a[r].createInterpolant(null);e[r]=v;v.settings=g}this._interpolantSettings=g;this._interpolants=e;this._propertyBindings=Array(c);this._weightInterpolant=this._timeScaleInterpolant=this._byClipCacheIndex=this._cacheIndex=null;this.loop=2201;this._loopCount=-1;this._startTime=null;this.time=0;this._effectiveWeight=this.weight=this._effectiveTimeScale=this.timeScale=1;this.repetitions=Infinity;this.paused=!1;this.enabled=!0;this.clampWhenFinished=!1;this.zeroSlopeAtEnd=this.zeroSlopeAtStart=
!0}function qi(a){this._root=a;this._initMemoryManager();this.time=this._accuIndex=0;this.timeScale=1}function bh(a,c){"string"===typeof a&&(console.warn("THREE.Uniform: Type parameter is no longer needed."),a=c);this.value=a}function ri(a,c,e){Qd.call(this,a,c);this.meshPerAttribute=e||1}function Uj(a,c,e,g){this.ray=new D(a,c);this.near=e||0;this.far=g||Infinity;this.camera=null;this.params={Mesh:{},Line:{},LOD:{},Points:{threshold:1},Sprite:{}};Object.defineProperties(this.params,{PointCloud:{get:function(){console.warn("THREE.Raycaster: params.PointCloud has been renamed to params.Points.");
return this.Points}}})}function Vj(a,c){return a.distance-c.distance}function si(a,c,e,g){if(!1!==a.visible&&(a.raycast(c,e),!0===g)){a=a.children;g=0;for(var r=a.length;g<r;g++)si(a[g],c,e,!0)}}function Wj(a,c,e){this.radius=void 0!==a?a:1;this.phi=void 0!==c?c:0;this.theta=void 0!==e?e:0;return this}function Xj(a,c,e){this.radius=void 0!==a?a:1;this.theta=void 0!==c?c:0;this.y=void 0!==e?e:0;return this}function ti(a,c){this.min=void 0!==a?a:new f(Infinity,Infinity);this.max=void 0!==c?c:new f(-Infinity,
-Infinity)}function ui(a,c){this.start=void 0!==a?a:new k;this.end=void 0!==c?c:new k}function cg(a){A.call(this);this.material=a;this.render=function(){}}function dg(a,c,e,g){this.object=a;this.size=void 0!==c?c:1;a=void 0!==e?e:16711680;g=void 0!==g?g:1;c=0;(e=this.object.geometry)&&e.isGeometry?c=3*e.faces.length:e&&e.isBufferGeometry&&(c=e.attributes.normal.count);e=new va;c=new ca(6*c,3);e.addAttribute("position",c);Ib.call(this,e,new Fb({color:a,linewidth:g}));this.matrixAutoUpdate=!1;this.update()}
function Xe(a,c){A.call(this);this.light=a;this.light.updateMatrixWorld();this.matrix=a.matrixWorld;this.matrixAutoUpdate=!1;this.color=c;a=new va;c=[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(var e=0,g=1;32>e;e++,g++){var r=e/32*Math.PI*2,v=g/32*Math.PI*2;c.push(Math.cos(r),Math.sin(r),1,Math.cos(v),Math.sin(v),1)}a.addAttribute("position",new ca(c,3));c=new Fb({fog:!1});this.cone=new Ib(a,c);this.add(this.cone);this.update()}function Yj(a){var c=[];a&&a.isBone&&c.push(a);
for(var e=0;e<a.children.length;e++)c.push.apply(c,Yj(a.children[e]));return c}function Ye(a){for(var c=Yj(a),e=new va,g=[],r=[],v=new I(0,0,1),z=new I(0,1,0),E=0;E<c.length;E++){var F=c[E];F.parent&&F.parent.isBone&&(g.push(0,0,0),g.push(0,0,0),r.push(v.r,v.g,v.b),r.push(z.r,z.g,z.b))}e.addAttribute("position",new ca(g,3));e.addAttribute("color",new ca(r,3));g=new Fb({vertexColors:2,depthTest:!1,depthWrite:!1,transparent:!0});Ib.call(this,e,g);this.root=a;this.bones=c;this.matrix=a.matrixWorld;this.matrixAutoUpdate=
!1}function Ze(a,c,e){this.light=a;this.light.updateMatrixWorld();this.color=e;a=new Bd(c,4,2);c=new L({wireframe:!0,fog:!1});xa.call(this,a,c);this.matrix=this.light.matrixWorld;this.matrixAutoUpdate=!1;this.update()}function $e(a,c){this.type="RectAreaLightHelper";this.light=a;this.color=c;a=new va;a.addAttribute("position",new ca([1,1,0,-1,1,0,-1,-1,0,1,-1,0,1,1,0],3));a.computeBoundingSphere();c=new Fb({fog:!1});Vb.call(this,a,c);a=new va;a.addAttribute("position",new ca([1,1,0,-1,1,0,-1,-1,0,
1,1,0,-1,-1,0,1,-1,0],3));a.computeBoundingSphere();this.add(new xa(a,new L({side:1,fog:!1})));this.update()}function af(a,c,e){A.call(this);this.light=a;this.light.updateMatrixWorld();this.matrix=a.matrixWorld;this.matrixAutoUpdate=!1;this.color=e;a=new Rd(c);a.rotateY(.5*Math.PI);this.material=new L({wireframe:!0,fog:!1});void 0===this.color&&(this.material.vertexColors=2);c=a.getAttribute("position");a.addAttribute("color",new Q(new Float32Array(3*c.count),3));this.add(new xa(a,this.material));
this.update()}function bf(a,c){this.lightProbe=a;this.size=c;a=new qb({defines:{GAMMA_OUTPUT:""},uniforms:{sh:{value:this.lightProbe.sh.coefficients},intensity:{value:this.lightProbe.intensity}},vertexShader:"varying vec3 vNormal;\nvoid main() {\n\tvNormal \x3d normalize( normalMatrix * normal );\n\tgl_Position \x3d projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",fragmentShader:"#define RECIPROCAL_PI 0.318309886\nvec3 inverseTransformDirection( in vec3 normal, in mat4 matrix ) {\n\t// matrix is assumed to be orthogonal\n\treturn normalize( ( vec4( normal, 0.0 ) * matrix ).xyz );\n}\nvec3 linearToOutput( in vec3 a ) {\n\t#ifdef GAMMA_OUTPUT\n\t\treturn pow( a, vec3( 1.0 / float( GAMMA_FACTOR ) ) );\n\t#else\n\t\treturn a;\n\t#endif\n}\n// source: https://graphics.stanford.edu/papers/envmap/envmap.pdf\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\t// normal is assumed to have unit length\n\tfloat x \x3d normal.x, y \x3d normal.y, z \x3d normal.z;\n\t// band 0\n\tvec3 result \x3d shCoefficients[ 0 ] * 0.886227;\n\t// band 1\n\tresult +\x3d shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult +\x3d shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult +\x3d shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\t// band 2\n\tresult +\x3d shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult +\x3d shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult +\x3d shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult +\x3d shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult +\x3d shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nuniform vec3 sh[ 9 ]; // sh coefficients\nuniform float intensity; // light probe intensity\nvarying vec3 vNormal;\nvoid main() {\n\tvec3 normal \x3d normalize( vNormal );\n\tvec3 worldNormal \x3d inverseTransformDirection( normal, viewMatrix );\n\tvec3 irradiance \x3d shGetIrradianceAt( worldNormal, sh );\n\tvec3 outgoingLight \x3d RECIPROCAL_PI * irradiance * intensity;\n\toutgoingLight \x3d linearToOutput( outgoingLight );\n\tgl_FragColor \x3d vec4( outgoingLight, 1.0 );\n}"});
c=new Bd(1,32,16);xa.call(this,c,a);this.onBeforeRender()}function ch(a,c,e,g){a=a||10;c=c||10;e=new I(void 0!==e?e:4473924);g=new I(void 0!==g?g:8947848);var r=c/2,v=a/c,z=a/2;a=[];for(var E=[],F=0,J=0,P=-z;F<=c;F++,P+=v){a.push(-z,0,P,z,0,P);a.push(P,0,-z,P,0,z);var R=F===r?e:g;R.toArray(E,J);J+=3;R.toArray(E,J);J+=3;R.toArray(E,J);J+=3;R.toArray(E,J);J+=3}c=new va;c.addAttribute("position",new ca(a,3));c.addAttribute("color",new ca(E,3));e=new Fb({vertexColors:2});Ib.call(this,c,e)}function dh(a,
c,e,g,r,v){a=a||10;c=c||16;e=e||8;g=g||64;r=new I(void 0!==r?r:4473924);v=new I(void 0!==v?v:8947848);var z=[],E=[],F;for(F=0;F<=c;F++){var J=F/c*2*Math.PI;var P=Math.sin(J)*a;J=Math.cos(J)*a;z.push(0,0,0);z.push(P,0,J);var R=F&1?r:v;E.push(R.r,R.g,R.b);E.push(R.r,R.g,R.b)}for(F=0;F<=e;F++){R=F&1?r:v;var S=a-a/e*F;for(c=0;c<g;c++)J=c/g*2*Math.PI,P=Math.sin(J)*S,J=Math.cos(J)*S,z.push(P,0,J),E.push(R.r,R.g,R.b),J=(c+1)/g*2*Math.PI,P=Math.sin(J)*S,J=Math.cos(J)*S,z.push(P,0,J),E.push(R.r,R.g,R.b)}a=
new va;a.addAttribute("position",new ca(z,3));a.addAttribute("color",new ca(E,3));z=new Fb({vertexColors:2});Ib.call(this,a,z)}function cf(a,c,e,g){this.audio=a;this.range=c||1;this.divisionsInnerAngle=e||16;this.divisionsOuterAngle=g||2;a=new va;a.addAttribute("position",new Q(new Float32Array(3*(3*(this.divisionsInnerAngle+2*this.divisionsOuterAngle)+3)),3));c=new Fb({color:65280});e=new Fb({color:16776960});Vb.call(this,a,[e,c]);this.update()}function eg(a,c,e,g){this.object=a;this.size=void 0!==
c?c:1;a=void 0!==e?e:16776960;g=void 0!==g?g:1;c=0;(e=this.object.geometry)&&e.isGeometry?c=e.faces.length:console.warn("THREE.FaceNormalsHelper: only THREE.Geometry is supported. Use THREE.VertexNormalsHelper, instead.");e=new va;c=new ca(6*c,3);e.addAttribute("position",c);Ib.call(this,e,new Fb({color:a,linewidth:g}));this.matrixAutoUpdate=!1;this.update()}function df(a,c,e){A.call(this);this.light=a;this.light.updateMatrixWorld();this.matrix=a.matrixWorld;this.matrixAutoUpdate=!1;this.color=e;
void 0===c&&(c=1);a=new va;a.addAttribute("position",new ca([-c,c,0,c,c,0,c,-c,0,-c,-c,0,-c,c,0],3));c=new Fb({fog:!1});this.lightPlane=new Vb(a,c);this.add(this.lightPlane);a=new va;a.addAttribute("position",new ca([0,0,0,0,0,1],3));this.targetLine=new Vb(a,c);this.add(this.targetLine);this.update()}function fg(a){function c(V,W,ha){e(V,ha);e(W,ha)}function e(V,W){v.push(0,0,0);z.push(W.r,W.g,W.b);void 0===E[V]&&(E[V]=[]);E[V].push(v.length/3-1)}var g=new va,r=new Fb({color:16777215,vertexColors:1}),
v=[],z=[],E={},F=new I(16755200),J=new I(16711680),P=new I(43775),R=new I(16777215),S=new I(3355443);c("n1","n2",F);c("n2","n4",F);c("n4","n3",F);c("n3","n1",F);c("f1","f2",F);c("f2","f4",F);c("f4","f3",F);c("f3","f1",F);c("n1","f1",F);c("n2","f2",F);c("n3","f3",F);c("n4","f4",F);c("p","n1",J);c("p","n2",J);c("p","n3",J);c("p","n4",J);c("u1","u2",P);c("u2","u3",P);c("u3","u1",P);c("c","t",R);c("p","c",S);c("cn1","cn2",S);c("cn3","cn4",S);c("cf1","cf2",S);c("cf3","cf4",S);g.addAttribute("position",
new ca(v,3));g.addAttribute("color",new ca(z,3));Ib.call(this,g,r);this.camera=a;this.camera.updateProjectionMatrix&&this.camera.updateProjectionMatrix();this.matrix=a.matrixWorld;this.matrixAutoUpdate=!1;this.pointMap=E;this.update()}function Pb(a,c,e,g,r,v,z){eh.set(r,v,z).unproject(g);a=c[a];if(void 0!==a)for(e=e.getAttribute("position"),c=0,g=a.length;c<g;c++)e.setXYZ(a[c],eh.x,eh.y,eh.z)}function hd(a,c){this.object=a;void 0===c&&(c=16776960);a=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]);var e=new Float32Array(24),g=new va;g.setIndex(new Q(a,1));g.addAttribute("position",new Q(e,3));Ib.call(this,g,new Fb({color:c}));this.matrixAutoUpdate=!1;this.update()}function gg(a,c){this.type="Box3Helper";this.box=a;c=c||16776960;a=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]);var e=new va;e.setIndex(new Q(a,1));e.addAttribute("position",new ca([1,1,1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,-1,1,-1,-1,-1,-1,1,-1,-1],3));Ib.call(this,e,new Fb({color:c}));this.geometry.computeBoundingSphere()}
function hg(a,c,e){this.type="PlaneHelper";this.plane=a;this.size=void 0===c?1:c;a=void 0!==e?e:16776960;c=new va;c.addAttribute("position",new ca([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],3));c.computeBoundingSphere();Vb.call(this,c,new Fb({color:a}));c=new va;c.addAttribute("position",new ca([1,1,1,-1,1,1,-1,-1,1,1,1,1,-1,-1,1,1,-1,1],3));c.computeBoundingSphere();this.add(new xa(c,new L({color:a,opacity:.2,transparent:!0,depthWrite:!1})))}function id(a,c,e,g,r,v){A.call(this);
void 0===a&&(a=new k(0,0,1));void 0===c&&(c=new k(0,0,0));void 0===e&&(e=1);void 0===g&&(g=16776960);void 0===r&&(r=.2*e);void 0===v&&(v=.2*r);void 0===fh&&(fh=new va,fh.addAttribute("position",new ca([0,0,0,0,1,0],3)),vi=new fd(0,.5,1,5,1),vi.translate(0,-.5,0));this.position.copy(c);this.line=new Vb(fh,new Fb({color:g}));this.line.matrixAutoUpdate=!1;this.add(this.line);this.cone=new xa(vi,new L({color:g}));this.cone.matrixAutoUpdate=!1;this.add(this.cone);this.setDirection(a);this.setLength(e,
r,v)}function ig(a){a=a||1;var c=[0,0,0,a,0,0,0,0,0,0,a,0,0,0,0,0,0,a];a=new va;a.addAttribute("position",new ca(c,3));a.addAttribute("color",new ca([1,0,0,1,.6,0,0,1,0,.6,1,0,0,0,1,0,.6,1],3));c=new Fb({vertexColors:2});Ib.call(this,a,c)}function Zj(a){console.warn("THREE.ClosedSplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.");Zb.call(this,a);this.type="catmullrom";this.closed=!0}function ak(a){console.warn("THREE.SplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.");
Zb.call(this,a);this.type="catmullrom"}function wi(a){console.warn("THREE.Spline has been removed. Use THREE.CatmullRomCurve3 instead.");Zb.call(this,a);this.type="catmullrom"}void 0===Number.EPSILON&&(Number.EPSILON=Math.pow(2,-52));void 0===Number.isInteger&&(Number.isInteger=function(a){return"number"===typeof a&&isFinite(a)&&Math.floor(a)===a});void 0===Math.sign&&(Math.sign=function(a){return 0>a?-1:0<a?1:+a});!1==="name"in Function.prototype&&Object.defineProperty(Function.prototype,"name",
{get:function(){return this.toString().match(/^\s*function\s*([^\(\s]*)/)[1]}});void 0===Object.assign&&(Object.assign=function(a){if(void 0===a||null===a)throw new TypeError("Cannot convert undefined or null to object");for(var c=Object(a),e=1;e<arguments.length;e++){var g=arguments[e];if(void 0!==g&&null!==g)for(var r in g)Object.prototype.hasOwnProperty.call(g,r)&&(c[r]=g[r])}return c});Object.assign(d.prototype,{addEventListener:function(a,c){void 0===this._listeners&&(this._listeners={});var e=
this._listeners;void 0===e[a]&&(e[a]=[]);-1===e[a].indexOf(c)&&e[a].push(c)},hasEventListener:function(a,c){if(void 0===this._listeners)return!1;var e=this._listeners;return void 0!==e[a]&&-1!==e[a].indexOf(c)},removeEventListener:function(a,c){void 0!==this._listeners&&(a=this._listeners[a],void 0!==a&&(c=a.indexOf(c),-1!==c&&a.splice(c,1)))},dispatchEvent:function(a){if(void 0!==this._listeners){var c=this._listeners[a.type];if(void 0!==c){a.target=this;c=c.slice(0);for(var e=0,g=c.length;e<g;e++)c[e].call(this,
a)}}}});for(var Yb=[],jg=0;256>jg;jg++)Yb[jg]=(16>jg?"0":"")+jg.toString(16);var hb={DEG2RAD:Math.PI/180,RAD2DEG:180/Math.PI,generateUUID:function(){var a=4294967295*Math.random()|0,c=4294967295*Math.random()|0,e=4294967295*Math.random()|0,g=4294967295*Math.random()|0;return(Yb[a&255]+Yb[a>>8&255]+Yb[a>>16&255]+Yb[a>>24&255]+"-"+Yb[c&255]+Yb[c>>8&255]+"-"+Yb[c>>16&15|64]+Yb[c>>24&255]+"-"+Yb[e&63|128]+Yb[e>>8&255]+"-"+Yb[e>>16&255]+Yb[e>>24&255]+Yb[g&255]+Yb[g>>8&255]+Yb[g>>16&255]+Yb[g>>24&255]).toUpperCase()},
clamp:function(a,c,e){return Math.max(c,Math.min(e,a))},euclideanModulo:function(a,c){return(a%c+c)%c},mapLinear:function(a,c,e,g,r){return g+(a-c)*(r-g)/(e-c)},lerp:function(a,c,e){return(1-e)*a+e*c},smoothstep:function(a,c,e){if(a<=c)return 0;if(a>=e)return 1;a=(a-c)/(e-c);return a*a*(3-2*a)},smootherstep:function(a,c,e){if(a<=c)return 0;if(a>=e)return 1;a=(a-c)/(e-c);return a*a*a*(a*(6*a-15)+10)},randInt:function(a,c){return a+Math.floor(Math.random()*(c-a+1))},randFloat:function(a,c){return a+
Math.random()*(c-a)},randFloatSpread:function(a){return a*(.5-Math.random())},degToRad:function(a){return a*hb.DEG2RAD},radToDeg:function(a){return a*hb.RAD2DEG},isPowerOfTwo:function(a){return 0===(a&a-1)&&0!==a},ceilPowerOfTwo:function(a){return Math.pow(2,Math.ceil(Math.log(a)/Math.LN2))},floorPowerOfTwo:function(a){return Math.pow(2,Math.floor(Math.log(a)/Math.LN2))}};Object.defineProperties(f.prototype,{width:{get:function(){return this.x},set:function(a){this.x=a}},height:{get:function(){return this.y},
set:function(a){this.y=a}}});Object.assign(f.prototype,{isVector2:!0,set:function(a,c){this.x=a;this.y=c;return this},setScalar:function(a){this.y=this.x=a;return this},setX:function(a){this.x=a;return this},setY:function(a){this.y=a;return this},setComponent:function(a,c){switch(a){case 0:this.x=c;break;case 1:this.y=c;break;default:throw Error("index is out of range: "+a);}return this},getComponent:function(a){switch(a){case 0:return this.x;case 1:return this.y;default:throw Error("index is out of range: "+
a);}},clone:function(){return new this.constructor(this.x,this.y)},copy:function(a){this.x=a.x;this.y=a.y;return this},add:function(a,c){if(void 0!==c)return console.warn("THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(a,c);this.x+=a.x;this.y+=a.y;return this},addScalar:function(a){this.x+=a;this.y+=a;return this},addVectors:function(a,c){this.x=a.x+c.x;this.y=a.y+c.y;return this},addScaledVector:function(a,c){this.x+=a.x*c;this.y+=a.y*c;return this},
sub:function(a,c){if(void 0!==c)return console.warn("THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(a,c);this.x-=a.x;this.y-=a.y;return this},subScalar:function(a){this.x-=a;this.y-=a;return this},subVectors:function(a,c){this.x=a.x-c.x;this.y=a.y-c.y;return this},multiply:function(a){this.x*=a.x;this.y*=a.y;return this},multiplyScalar:function(a){this.x*=a;this.y*=a;return this},divide:function(a){this.x/=a.x;this.y/=a.y;return this},divideScalar:function(a){return this.multiplyScalar(1/
a)},applyMatrix3:function(a){var c=this.x,e=this.y;a=a.elements;this.x=a[0]*c+a[3]*e+a[6];this.y=a[1]*c+a[4]*e+a[7];return this},min:function(a){this.x=Math.min(this.x,a.x);this.y=Math.min(this.y,a.y);return this},max:function(a){this.x=Math.max(this.x,a.x);this.y=Math.max(this.y,a.y);return this},clamp:function(a,c){this.x=Math.max(a.x,Math.min(c.x,this.x));this.y=Math.max(a.y,Math.min(c.y,this.y));return this},clampScalar:function(a,c){this.x=Math.max(a,Math.min(c,this.x));this.y=Math.max(a,Math.min(c,
this.y));return this},clampLength:function(a,c){var e=this.length();return this.divideScalar(e||1).multiplyScalar(Math.max(a,Math.min(c,e)))},floor:function(){this.x=Math.floor(this.x);this.y=Math.floor(this.y);return this},ceil:function(){this.x=Math.ceil(this.x);this.y=Math.ceil(this.y);return this},round:function(){this.x=Math.round(this.x);this.y=Math.round(this.y);return this},roundToZero:function(){this.x=0>this.x?Math.ceil(this.x):Math.floor(this.x);this.y=0>this.y?Math.ceil(this.y):Math.floor(this.y);
return this},negate:function(){this.x=-this.x;this.y=-this.y;return this},dot:function(a){return this.x*a.x+this.y*a.y},cross:function(a){return this.x*a.y-this.y*a.x},lengthSq:function(){return this.x*this.x+this.y*this.y},length:function(){return Math.sqrt(this.x*this.x+this.y*this.y)},manhattanLength:function(){return Math.abs(this.x)+Math.abs(this.y)},normalize:function(){return this.divideScalar(this.length()||1)},angle:function(){var a=Math.atan2(this.y,this.x);0>a&&(a+=2*Math.PI);return a},
distanceTo:function(a){return Math.sqrt(this.distanceToSquared(a))},distanceToSquared:function(a){var c=this.x-a.x;a=this.y-a.y;return c*c+a*a},manhattanDistanceTo:function(a){return Math.abs(this.x-a.x)+Math.abs(this.y-a.y)},setLength:function(a){return this.normalize().multiplyScalar(a)},lerp:function(a,c){this.x+=(a.x-this.x)*c;this.y+=(a.y-this.y)*c;return this},lerpVectors:function(a,c,e){return this.subVectors(c,a).multiplyScalar(e).add(a)},equals:function(a){return a.x===this.x&&a.y===this.y},
fromArray:function(a,c){void 0===c&&(c=0);this.x=a[c];this.y=a[c+1];return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);a[c]=this.x;a[c+1]=this.y;return a},fromBufferAttribute:function(a,c,e){void 0!==e&&console.warn("THREE.Vector2: offset has been removed from .fromBufferAttribute().");this.x=a.getX(c);this.y=a.getY(c);return this},rotateAround:function(a,c){var e=Math.cos(c);c=Math.sin(c);var g=this.x-a.x,r=this.y-a.y;this.x=g*e-r*c+a.x;this.y=g*c+r*e+a.y;return this}});Object.assign(h,
{slerp:function(a,c,e,g){return e.copy(a).slerp(c,g)},slerpFlat:function(a,c,e,g,r,v,z){var E=e[g+0],F=e[g+1],J=e[g+2];e=e[g+3];g=r[v+0];var P=r[v+1],R=r[v+2];r=r[v+3];if(e!==r||E!==g||F!==P||J!==R){v=1-z;var S=E*g+F*P+J*R+e*r,V=0<=S?1:-1,W=1-S*S;W>Number.EPSILON&&(W=Math.sqrt(W),S=Math.atan2(W,S*V),v=Math.sin(v*S)/W,z=Math.sin(z*S)/W);V*=z;E=E*v+g*V;F=F*v+P*V;J=J*v+R*V;e=e*v+r*V;v===1-z&&(z=1/Math.sqrt(E*E+F*F+J*J+e*e),E*=z,F*=z,J*=z,e*=z)}a[c]=E;a[c+1]=F;a[c+2]=J;a[c+3]=e}});Object.defineProperties(h.prototype,
{x:{get:function(){return this._x},set:function(a){this._x=a;this._onChangeCallback()}},y:{get:function(){return this._y},set:function(a){this._y=a;this._onChangeCallback()}},z:{get:function(){return this._z},set:function(a){this._z=a;this._onChangeCallback()}},w:{get:function(){return this._w},set:function(a){this._w=a;this._onChangeCallback()}}});Object.assign(h.prototype,{isQuaternion:!0,set:function(a,c,e,g){this._x=a;this._y=c;this._z=e;this._w=g;this._onChangeCallback();return this},clone:function(){return new this.constructor(this._x,
this._y,this._z,this._w)},copy:function(a){this._x=a.x;this._y=a.y;this._z=a.z;this._w=a.w;this._onChangeCallback();return this},setFromEuler:function(a,c){if(!a||!a.isEuler)throw Error("THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.");var e=a._x,g=a._y,r=a._z;a=a.order;var v=Math.cos,z=Math.sin,E=v(e/2),F=v(g/2);v=v(r/2);e=z(e/2);g=z(g/2);r=z(r/2);"XYZ"===a?(this._x=e*F*v+E*g*r,this._y=E*g*v-e*F*r,this._z=E*F*r+e*g*v,this._w=E*F*v-e*g*r):"YXZ"===
a?(this._x=e*F*v+E*g*r,this._y=E*g*v-e*F*r,this._z=E*F*r-e*g*v,this._w=E*F*v+e*g*r):"ZXY"===a?(this._x=e*F*v-E*g*r,this._y=E*g*v+e*F*r,this._z=E*F*r+e*g*v,this._w=E*F*v-e*g*r):"ZYX"===a?(this._x=e*F*v-E*g*r,this._y=E*g*v+e*F*r,this._z=E*F*r-e*g*v,this._w=E*F*v+e*g*r):"YZX"===a?(this._x=e*F*v+E*g*r,this._y=E*g*v+e*F*r,this._z=E*F*r-e*g*v,this._w=E*F*v-e*g*r):"XZY"===a&&(this._x=e*F*v-E*g*r,this._y=E*g*v-e*F*r,this._z=E*F*r+e*g*v,this._w=E*F*v+e*g*r);!1!==c&&this._onChangeCallback();return this},setFromAxisAngle:function(a,
c){c/=2;var e=Math.sin(c);this._x=a.x*e;this._y=a.y*e;this._z=a.z*e;this._w=Math.cos(c);this._onChangeCallback();return this},setFromRotationMatrix:function(a){var c=a.elements,e=c[0];a=c[4];var g=c[8],r=c[1],v=c[5],z=c[9],E=c[2],F=c[6];c=c[10];var J=e+v+c;0<J?(e=.5/Math.sqrt(J+1),this._w=.25/e,this._x=(F-z)*e,this._y=(g-E)*e,this._z=(r-a)*e):e>v&&e>c?(e=2*Math.sqrt(1+e-v-c),this._w=(F-z)/e,this._x=.25*e,this._y=(a+r)/e,this._z=(g+E)/e):v>c?(e=2*Math.sqrt(1+v-e-c),this._w=(g-E)/e,this._x=(a+r)/e,
this._y=.25*e,this._z=(z+F)/e):(e=2*Math.sqrt(1+c-e-v),this._w=(r-a)/e,this._x=(g+E)/e,this._y=(z+F)/e,this._z=.25*e);this._onChangeCallback();return this},setFromUnitVectors:function(a,c){var e=a.dot(c)+1;1E-6>e?(e=0,Math.abs(a.x)>Math.abs(a.z)?(this._x=-a.y,this._y=a.x,this._z=0):(this._x=0,this._y=-a.z,this._z=a.y)):(this._x=a.y*c.z-a.z*c.y,this._y=a.z*c.x-a.x*c.z,this._z=a.x*c.y-a.y*c.x);this._w=e;return this.normalize()},angleTo:function(a){return 2*Math.acos(Math.abs(hb.clamp(this.dot(a),-1,
1)))},rotateTowards:function(a,c){var e=this.angleTo(a);if(0===e)return this;this.slerp(a,Math.min(1,c/e));return this},inverse:function(){return this.conjugate()},conjugate:function(){this._x*=-1;this._y*=-1;this._z*=-1;this._onChangeCallback();return this},dot:function(a){return this._x*a._x+this._y*a._y+this._z*a._z+this._w*a._w},lengthSq:function(){return this._x*this._x+this._y*this._y+this._z*this._z+this._w*this._w},length:function(){return Math.sqrt(this._x*this._x+this._y*this._y+this._z*
this._z+this._w*this._w)},normalize:function(){var a=this.length();0===a?(this._z=this._y=this._x=0,this._w=1):(a=1/a,this._x*=a,this._y*=a,this._z*=a,this._w*=a);this._onChangeCallback();return this},multiply:function(a,c){return void 0!==c?(console.warn("THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead."),this.multiplyQuaternions(a,c)):this.multiplyQuaternions(this,a)},premultiply:function(a){return this.multiplyQuaternions(a,this)},multiplyQuaternions:function(a,
c){var e=a._x,g=a._y,r=a._z;a=a._w;var v=c._x,z=c._y,E=c._z;c=c._w;this._x=e*c+a*v+g*E-r*z;this._y=g*c+a*z+r*v-e*E;this._z=r*c+a*E+e*z-g*v;this._w=a*c-e*v-g*z-r*E;this._onChangeCallback();return this},slerp:function(a,c){if(0===c)return this;if(1===c)return this.copy(a);var e=this._x,g=this._y,r=this._z,v=this._w,z=v*a._w+e*a._x+g*a._y+r*a._z;0>z?(this._w=-a._w,this._x=-a._x,this._y=-a._y,this._z=-a._z,z=-z):this.copy(a);if(1<=z)return this._w=v,this._x=e,this._y=g,this._z=r,this;a=1-z*z;if(a<=Number.EPSILON)return z=
1-c,this._w=z*v+c*this._w,this._x=z*e+c*this._x,this._y=z*g+c*this._y,this._z=z*r+c*this._z,this.normalize(),this._onChangeCallback(),this;a=Math.sqrt(a);var E=Math.atan2(a,z);z=Math.sin((1-c)*E)/a;c=Math.sin(c*E)/a;this._w=v*z+this._w*c;this._x=e*z+this._x*c;this._y=g*z+this._y*c;this._z=r*z+this._z*c;this._onChangeCallback();return this},equals:function(a){return a._x===this._x&&a._y===this._y&&a._z===this._z&&a._w===this._w},fromArray:function(a,c){void 0===c&&(c=0);this._x=a[c];this._y=a[c+1];
this._z=a[c+2];this._w=a[c+3];this._onChangeCallback();return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);a[c]=this._x;a[c+1]=this._y;a[c+2]=this._z;a[c+3]=this._w;return a},_onChange:function(a){this._onChangeCallback=a;return this},_onChangeCallback:function(){}});var xi=new k,bk=new h;Object.assign(k.prototype,{isVector3:!0,set:function(a,c,e){this.x=a;this.y=c;this.z=e;return this},setScalar:function(a){this.z=this.y=this.x=a;return this},setX:function(a){this.x=a;return this},
setY:function(a){this.y=a;return this},setZ:function(a){this.z=a;return this},setComponent:function(a,c){switch(a){case 0:this.x=c;break;case 1:this.y=c;break;case 2:this.z=c;break;default:throw Error("index is out of range: "+a);}return this},getComponent:function(a){switch(a){case 0:return this.x;case 1:return this.y;case 2:return this.z;default:throw Error("index is out of range: "+a);}},clone:function(){return new this.constructor(this.x,this.y,this.z)},copy:function(a){this.x=a.x;this.y=a.y;
this.z=a.z;return this},add:function(a,c){if(void 0!==c)return console.warn("THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(a,c);this.x+=a.x;this.y+=a.y;this.z+=a.z;return this},addScalar:function(a){this.x+=a;this.y+=a;this.z+=a;return this},addVectors:function(a,c){this.x=a.x+c.x;this.y=a.y+c.y;this.z=a.z+c.z;return this},addScaledVector:function(a,c){this.x+=a.x*c;this.y+=a.y*c;this.z+=a.z*c;return this},sub:function(a,c){if(void 0!==c)return console.warn("THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),
this.subVectors(a,c);this.x-=a.x;this.y-=a.y;this.z-=a.z;return this},subScalar:function(a){this.x-=a;this.y-=a;this.z-=a;return this},subVectors:function(a,c){this.x=a.x-c.x;this.y=a.y-c.y;this.z=a.z-c.z;return this},multiply:function(a,c){if(void 0!==c)return console.warn("THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead."),this.multiplyVectors(a,c);this.x*=a.x;this.y*=a.y;this.z*=a.z;return this},multiplyScalar:function(a){this.x*=a;this.y*=a;this.z*=
a;return this},multiplyVectors:function(a,c){this.x=a.x*c.x;this.y=a.y*c.y;this.z=a.z*c.z;return this},applyEuler:function(a){a&&a.isEuler||console.error("THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.");return this.applyQuaternion(bk.setFromEuler(a))},applyAxisAngle:function(a,c){return this.applyQuaternion(bk.setFromAxisAngle(a,c))},applyMatrix3:function(a){var c=this.x,e=this.y,g=this.z;a=a.elements;this.x=a[0]*c+a[3]*e+a[6]*g;this.y=a[1]*c+a[4]*e+a[7]*
g;this.z=a[2]*c+a[5]*e+a[8]*g;return this},applyMatrix4:function(a){var c=this.x,e=this.y,g=this.z;a=a.elements;var r=1/(a[3]*c+a[7]*e+a[11]*g+a[15]);this.x=(a[0]*c+a[4]*e+a[8]*g+a[12])*r;this.y=(a[1]*c+a[5]*e+a[9]*g+a[13])*r;this.z=(a[2]*c+a[6]*e+a[10]*g+a[14])*r;return this},applyQuaternion:function(a){var c=this.x,e=this.y,g=this.z,r=a.x,v=a.y,z=a.z;a=a.w;var E=a*c+v*g-z*e,F=a*e+z*c-r*g,J=a*g+r*e-v*c;c=-r*c-v*e-z*g;this.x=E*a+c*-r+F*-z-J*-v;this.y=F*a+c*-v+J*-r-E*-z;this.z=J*a+c*-z+E*-v-F*-r;return this},
project:function(a){return this.applyMatrix4(a.matrixWorldInverse).applyMatrix4(a.projectionMatrix)},unproject:function(a){return this.applyMatrix4(a.projectionMatrixInverse).applyMatrix4(a.matrixWorld)},transformDirection:function(a){var c=this.x,e=this.y,g=this.z;a=a.elements;this.x=a[0]*c+a[4]*e+a[8]*g;this.y=a[1]*c+a[5]*e+a[9]*g;this.z=a[2]*c+a[6]*e+a[10]*g;return this.normalize()},divide:function(a){this.x/=a.x;this.y/=a.y;this.z/=a.z;return this},divideScalar:function(a){return this.multiplyScalar(1/
a)},min:function(a){this.x=Math.min(this.x,a.x);this.y=Math.min(this.y,a.y);this.z=Math.min(this.z,a.z);return this},max:function(a){this.x=Math.max(this.x,a.x);this.y=Math.max(this.y,a.y);this.z=Math.max(this.z,a.z);return this},clamp:function(a,c){this.x=Math.max(a.x,Math.min(c.x,this.x));this.y=Math.max(a.y,Math.min(c.y,this.y));this.z=Math.max(a.z,Math.min(c.z,this.z));return this},clampScalar:function(a,c){this.x=Math.max(a,Math.min(c,this.x));this.y=Math.max(a,Math.min(c,this.y));this.z=Math.max(a,
Math.min(c,this.z));return this},clampLength:function(a,c){var e=this.length();return this.divideScalar(e||1).multiplyScalar(Math.max(a,Math.min(c,e)))},floor:function(){this.x=Math.floor(this.x);this.y=Math.floor(this.y);this.z=Math.floor(this.z);return this},ceil:function(){this.x=Math.ceil(this.x);this.y=Math.ceil(this.y);this.z=Math.ceil(this.z);return this},round:function(){this.x=Math.round(this.x);this.y=Math.round(this.y);this.z=Math.round(this.z);return this},roundToZero:function(){this.x=
0>this.x?Math.ceil(this.x):Math.floor(this.x);this.y=0>this.y?Math.ceil(this.y):Math.floor(this.y);this.z=0>this.z?Math.ceil(this.z):Math.floor(this.z);return this},negate:function(){this.x=-this.x;this.y=-this.y;this.z=-this.z;return this},dot:function(a){return this.x*a.x+this.y*a.y+this.z*a.z},lengthSq:function(){return this.x*this.x+this.y*this.y+this.z*this.z},length:function(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z)},manhattanLength:function(){return Math.abs(this.x)+Math.abs(this.y)+
Math.abs(this.z)},normalize:function(){return this.divideScalar(this.length()||1)},setLength:function(a){return this.normalize().multiplyScalar(a)},lerp:function(a,c){this.x+=(a.x-this.x)*c;this.y+=(a.y-this.y)*c;this.z+=(a.z-this.z)*c;return this},lerpVectors:function(a,c,e){return this.subVectors(c,a).multiplyScalar(e).add(a)},cross:function(a,c){return void 0!==c?(console.warn("THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead."),this.crossVectors(a,c)):this.crossVectors(this,
a)},crossVectors:function(a,c){var e=a.x,g=a.y;a=a.z;var r=c.x,v=c.y;c=c.z;this.x=g*c-a*v;this.y=a*r-e*c;this.z=e*v-g*r;return this},projectOnVector:function(a){var c=a.dot(this)/a.lengthSq();return this.copy(a).multiplyScalar(c)},projectOnPlane:function(a){xi.copy(this).projectOnVector(a);return this.sub(xi)},reflect:function(a){return this.sub(xi.copy(a).multiplyScalar(2*this.dot(a)))},angleTo:function(a){return Math.acos(hb.clamp(this.dot(a)/Math.sqrt(this.lengthSq()*a.lengthSq()),-1,1))},distanceTo:function(a){return Math.sqrt(this.distanceToSquared(a))},
distanceToSquared:function(a){var c=this.x-a.x,e=this.y-a.y;a=this.z-a.z;return c*c+e*e+a*a},manhattanDistanceTo:function(a){return Math.abs(this.x-a.x)+Math.abs(this.y-a.y)+Math.abs(this.z-a.z)},setFromSpherical:function(a){return this.setFromSphericalCoords(a.radius,a.phi,a.theta)},setFromSphericalCoords:function(a,c,e){var g=Math.sin(c)*a;this.x=g*Math.sin(e);this.y=Math.cos(c)*a;this.z=g*Math.cos(e);return this},setFromCylindrical:function(a){return this.setFromCylindricalCoords(a.radius,a.theta,
a.y)},setFromCylindricalCoords:function(a,c,e){this.x=a*Math.sin(c);this.y=e;this.z=a*Math.cos(c);return this},setFromMatrixPosition:function(a){a=a.elements;this.x=a[12];this.y=a[13];this.z=a[14];return this},setFromMatrixScale:function(a){var c=this.setFromMatrixColumn(a,0).length(),e=this.setFromMatrixColumn(a,1).length();a=this.setFromMatrixColumn(a,2).length();this.x=c;this.y=e;this.z=a;return this},setFromMatrixColumn:function(a,c){return this.fromArray(a.elements,4*c)},equals:function(a){return a.x===
this.x&&a.y===this.y&&a.z===this.z},fromArray:function(a,c){void 0===c&&(c=0);this.x=a[c];this.y=a[c+1];this.z=a[c+2];return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);a[c]=this.x;a[c+1]=this.y;a[c+2]=this.z;return a},fromBufferAttribute:function(a,c,e){void 0!==e&&console.warn("THREE.Vector3: offset has been removed from .fromBufferAttribute().");this.x=a.getX(c);this.y=a.getY(c);this.z=a.getZ(c);return this}});var ee=new k;Object.assign(t.prototype,{isMatrix3:!0,set:function(a,
c,e,g,r,v,z,E,F){var J=this.elements;J[0]=a;J[1]=g;J[2]=z;J[3]=c;J[4]=r;J[5]=E;J[6]=e;J[7]=v;J[8]=F;return this},identity:function(){this.set(1,0,0,0,1,0,0,0,1);return this},clone:function(){return(new this.constructor).fromArray(this.elements)},copy:function(a){var c=this.elements;a=a.elements;c[0]=a[0];c[1]=a[1];c[2]=a[2];c[3]=a[3];c[4]=a[4];c[5]=a[5];c[6]=a[6];c[7]=a[7];c[8]=a[8];return this},setFromMatrix4:function(a){a=a.elements;this.set(a[0],a[4],a[8],a[1],a[5],a[9],a[2],a[6],a[10]);return this},
applyToBufferAttribute:function(a){for(var c=0,e=a.count;c<e;c++)ee.x=a.getX(c),ee.y=a.getY(c),ee.z=a.getZ(c),ee.applyMatrix3(this),a.setXYZ(c,ee.x,ee.y,ee.z);return a},multiply:function(a){return this.multiplyMatrices(this,a)},premultiply:function(a){return this.multiplyMatrices(a,this)},multiplyMatrices:function(a,c){var e=a.elements,g=c.elements;c=this.elements;a=e[0];var r=e[3],v=e[6],z=e[1],E=e[4],F=e[7],J=e[2],P=e[5];e=e[8];var R=g[0],S=g[3],V=g[6],W=g[1],ha=g[4],fa=g[7],ra=g[2],pa=g[5];g=g[8];
c[0]=a*R+r*W+v*ra;c[3]=a*S+r*ha+v*pa;c[6]=a*V+r*fa+v*g;c[1]=z*R+E*W+F*ra;c[4]=z*S+E*ha+F*pa;c[7]=z*V+E*fa+F*g;c[2]=J*R+P*W+e*ra;c[5]=J*S+P*ha+e*pa;c[8]=J*V+P*fa+e*g;return this},multiplyScalar:function(a){var c=this.elements;c[0]*=a;c[3]*=a;c[6]*=a;c[1]*=a;c[4]*=a;c[7]*=a;c[2]*=a;c[5]*=a;c[8]*=a;return this},determinant:function(){var a=this.elements,c=a[0],e=a[1],g=a[2],r=a[3],v=a[4],z=a[5],E=a[6],F=a[7];a=a[8];return c*v*a-c*z*F-e*r*a+e*z*E+g*r*F-g*v*E},getInverse:function(a,c){a&&a.isMatrix4&&
console.error("THREE.Matrix3: .getInverse() no longer takes a Matrix4 argument.");var e=a.elements;a=this.elements;var g=e[0],r=e[1],v=e[2],z=e[3],E=e[4],F=e[5],J=e[6],P=e[7];e=e[8];var R=e*E-F*P,S=F*J-e*z,V=P*z-E*J,W=g*R+r*S+v*V;if(0===W){if(!0===c)throw Error("THREE.Matrix3: .getInverse() can't invert matrix, determinant is 0");console.warn("THREE.Matrix3: .getInverse() can't invert matrix, determinant is 0");return this.identity()}c=1/W;a[0]=R*c;a[1]=(v*P-e*r)*c;a[2]=(F*r-v*E)*c;a[3]=S*c;a[4]=
(e*g-v*J)*c;a[5]=(v*z-F*g)*c;a[6]=V*c;a[7]=(r*J-P*g)*c;a[8]=(E*g-r*z)*c;return this},transpose:function(){var a=this.elements;var c=a[1];a[1]=a[3];a[3]=c;c=a[2];a[2]=a[6];a[6]=c;c=a[5];a[5]=a[7];a[7]=c;return this},getNormalMatrix:function(a){return this.setFromMatrix4(a).getInverse(this).transpose()},transposeIntoArray:function(a){var c=this.elements;a[0]=c[0];a[1]=c[3];a[2]=c[6];a[3]=c[1];a[4]=c[4];a[5]=c[7];a[6]=c[2];a[7]=c[5];a[8]=c[8];return this},setUvTransform:function(a,c,e,g,r,v,z){var E=
Math.cos(r);r=Math.sin(r);this.set(e*E,e*r,-e*(E*v+r*z)+v+a,-g*r,g*E,-g*(-r*v+E*z)+z+c,0,0,1)},scale:function(a,c){var e=this.elements;e[0]*=a;e[3]*=a;e[6]*=a;e[1]*=c;e[4]*=c;e[7]*=c;return this},rotate:function(a){var c=Math.cos(a);a=Math.sin(a);var e=this.elements,g=e[0],r=e[3],v=e[6],z=e[1],E=e[4],F=e[7];e[0]=c*g+a*z;e[3]=c*r+a*E;e[6]=c*v+a*F;e[1]=-a*g+c*z;e[4]=-a*r+c*E;e[7]=-a*v+c*F;return this},translate:function(a,c){var e=this.elements;e[0]+=a*e[2];e[3]+=a*e[5];e[6]+=a*e[8];e[1]+=c*e[2];e[4]+=
c*e[5];e[7]+=c*e[8];return this},equals:function(a){var c=this.elements;a=a.elements;for(var e=0;9>e;e++)if(c[e]!==a[e])return!1;return!0},fromArray:function(a,c){void 0===c&&(c=0);for(var e=0;9>e;e++)this.elements[e]=a[e+c];return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);var e=this.elements;a[c]=e[0];a[c+1]=e[1];a[c+2]=e[2];a[c+3]=e[3];a[c+4]=e[4];a[c+5]=e[5];a[c+6]=e[6];a[c+7]=e[7];a[c+8]=e[8];return a}});var ef,Dd={getDataURL:function(a){if("undefined"==typeof HTMLCanvasElement)return a.src;
if(!(a instanceof HTMLCanvasElement)){void 0===ef&&(ef=document.createElementNS("http://www.w3.org/1999/xhtml","canvas"));ef.width=a.width;ef.height=a.height;var c=ef.getContext("2d");a instanceof ImageData?c.putImageData(a,0,0):c.drawImage(a,0,0,a.width,a.height);a=ef}return 2048<a.width||2048<a.height?a.toDataURL("image/jpeg",.6):a.toDataURL("image/png")}},Nk=0;l.DEFAULT_IMAGE=void 0;l.DEFAULT_MAPPING=300;l.prototype=Object.assign(Object.create(d.prototype),{constructor:l,isTexture:!0,updateMatrix:function(){this.matrix.setUvTransform(this.offset.x,
this.offset.y,this.repeat.x,this.repeat.y,this.rotation,this.center.x,this.center.y)},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.name=a.name;this.image=a.image;this.mipmaps=a.mipmaps.slice(0);this.mapping=a.mapping;this.wrapS=a.wrapS;this.wrapT=a.wrapT;this.magFilter=a.magFilter;this.minFilter=a.minFilter;this.anisotropy=a.anisotropy;this.format=a.format;this.type=a.type;this.offset.copy(a.offset);this.repeat.copy(a.repeat);this.center.copy(a.center);this.rotation=
a.rotation;this.matrixAutoUpdate=a.matrixAutoUpdate;this.matrix.copy(a.matrix);this.generateMipmaps=a.generateMipmaps;this.premultiplyAlpha=a.premultiplyAlpha;this.flipY=a.flipY;this.unpackAlignment=a.unpackAlignment;this.encoding=a.encoding;return this},toJSON:function(a){var c=void 0===a||"string"===typeof a;if(!c&&void 0!==a.textures[this.uuid])return a.textures[this.uuid];var e={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){var g=this.image;void 0===g.uuid&&(g.uuid=hb.generateUUID());if(!c&&void 0===a.images[g.uuid]){if(Array.isArray(g)){var r=
[];for(var v=0,z=g.length;v<z;v++)r.push(Dd.getDataURL(g[v]))}else r=Dd.getDataURL(g);a.images[g.uuid]={uuid:g.uuid,url:r}}e.image=g.uuid}c||(a.textures[this.uuid]=e);return e},dispose:function(){this.dispatchEvent({type:"dispose"})},transformUv:function(a){if(300!==this.mapping)return a;a.applyMatrix3(this.matrix);if(0>a.x||1<a.x)switch(this.wrapS){case 1E3:a.x-=Math.floor(a.x);break;case 1001:a.x=0>a.x?0:1;break;case 1002:a.x=1===Math.abs(Math.floor(a.x)%2)?Math.ceil(a.x)-a.x:a.x-Math.floor(a.x)}if(0>
a.y||1<a.y)switch(this.wrapT){case 1E3:a.y-=Math.floor(a.y);break;case 1001:a.y=0>a.y?0:1;break;case 1002:a.y=1===Math.abs(Math.floor(a.y)%2)?Math.ceil(a.y)-a.y:a.y-Math.floor(a.y)}this.flipY&&(a.y=1-a.y);return a}});Object.defineProperty(l.prototype,"needsUpdate",{set:function(a){!0===a&&this.version++}});Object.defineProperties(p.prototype,{width:{get:function(){return this.z},set:function(a){this.z=a}},height:{get:function(){return this.w},set:function(a){this.w=a}}});Object.assign(p.prototype,
{isVector4:!0,set:function(a,c,e,g){this.x=a;this.y=c;this.z=e;this.w=g;return this},setScalar:function(a){this.w=this.z=this.y=this.x=a;return this},setX:function(a){this.x=a;return this},setY:function(a){this.y=a;return this},setZ:function(a){this.z=a;return this},setW:function(a){this.w=a;return this},setComponent:function(a,c){switch(a){case 0:this.x=c;break;case 1:this.y=c;break;case 2:this.z=c;break;case 3:this.w=c;break;default:throw Error("index is out of range: "+a);}return this},getComponent:function(a){switch(a){case 0:return this.x;
case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw Error("index is out of range: "+a);}},clone:function(){return new this.constructor(this.x,this.y,this.z,this.w)},copy:function(a){this.x=a.x;this.y=a.y;this.z=a.z;this.w=void 0!==a.w?a.w:1;return this},add:function(a,c){if(void 0!==c)return console.warn("THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead."),this.addVectors(a,c);this.x+=a.x;this.y+=a.y;this.z+=a.z;this.w+=a.w;return this},
addScalar:function(a){this.x+=a;this.y+=a;this.z+=a;this.w+=a;return this},addVectors:function(a,c){this.x=a.x+c.x;this.y=a.y+c.y;this.z=a.z+c.z;this.w=a.w+c.w;return this},addScaledVector:function(a,c){this.x+=a.x*c;this.y+=a.y*c;this.z+=a.z*c;this.w+=a.w*c;return this},sub:function(a,c){if(void 0!==c)return console.warn("THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead."),this.subVectors(a,c);this.x-=a.x;this.y-=a.y;this.z-=a.z;this.w-=a.w;return this},subScalar:function(a){this.x-=
a;this.y-=a;this.z-=a;this.w-=a;return this},subVectors:function(a,c){this.x=a.x-c.x;this.y=a.y-c.y;this.z=a.z-c.z;this.w=a.w-c.w;return this},multiplyScalar:function(a){this.x*=a;this.y*=a;this.z*=a;this.w*=a;return this},applyMatrix4:function(a){var c=this.x,e=this.y,g=this.z,r=this.w;a=a.elements;this.x=a[0]*c+a[4]*e+a[8]*g+a[12]*r;this.y=a[1]*c+a[5]*e+a[9]*g+a[13]*r;this.z=a[2]*c+a[6]*e+a[10]*g+a[14]*r;this.w=a[3]*c+a[7]*e+a[11]*g+a[15]*r;return this},divideScalar:function(a){return this.multiplyScalar(1/
a)},setAxisAngleFromQuaternion:function(a){this.w=2*Math.acos(a.w);var c=Math.sqrt(1-a.w*a.w);1E-4>c?(this.x=1,this.z=this.y=0):(this.x=a.x/c,this.y=a.y/c,this.z=a.z/c);return this},setAxisAngleFromRotationMatrix:function(a){a=a.elements;var c=a[0];var e=a[4];var g=a[8],r=a[1],v=a[5],z=a[9];var E=a[2];var F=a[6];var J=a[10];if(.01>Math.abs(e-r)&&.01>Math.abs(g-E)&&.01>Math.abs(z-F)){if(.1>Math.abs(e+r)&&.1>Math.abs(g+E)&&.1>Math.abs(z+F)&&.1>Math.abs(c+v+J-3))return this.set(1,0,0,0),this;a=Math.PI;
c=(c+1)/2;v=(v+1)/2;J=(J+1)/2;e=(e+r)/4;g=(g+E)/4;z=(z+F)/4;c>v&&c>J?.01>c?(F=0,e=E=.707106781):(F=Math.sqrt(c),E=e/F,e=g/F):v>J?.01>v?(F=.707106781,E=0,e=.707106781):(E=Math.sqrt(v),F=e/E,e=z/E):.01>J?(E=F=.707106781,e=0):(e=Math.sqrt(J),F=g/e,E=z/e);this.set(F,E,e,a);return this}a=Math.sqrt((F-z)*(F-z)+(g-E)*(g-E)+(r-e)*(r-e));.001>Math.abs(a)&&(a=1);this.x=(F-z)/a;this.y=(g-E)/a;this.z=(r-e)/a;this.w=Math.acos((c+v+J-1)/2);return this},min:function(a){this.x=Math.min(this.x,a.x);this.y=Math.min(this.y,
a.y);this.z=Math.min(this.z,a.z);this.w=Math.min(this.w,a.w);return this},max:function(a){this.x=Math.max(this.x,a.x);this.y=Math.max(this.y,a.y);this.z=Math.max(this.z,a.z);this.w=Math.max(this.w,a.w);return this},clamp:function(a,c){this.x=Math.max(a.x,Math.min(c.x,this.x));this.y=Math.max(a.y,Math.min(c.y,this.y));this.z=Math.max(a.z,Math.min(c.z,this.z));this.w=Math.max(a.w,Math.min(c.w,this.w));return this},clampScalar:function(a,c){this.x=Math.max(a,Math.min(c,this.x));this.y=Math.max(a,Math.min(c,
this.y));this.z=Math.max(a,Math.min(c,this.z));this.w=Math.max(a,Math.min(c,this.w));return this},clampLength:function(a,c){var e=this.length();return this.divideScalar(e||1).multiplyScalar(Math.max(a,Math.min(c,e)))},floor:function(){this.x=Math.floor(this.x);this.y=Math.floor(this.y);this.z=Math.floor(this.z);this.w=Math.floor(this.w);return this},ceil:function(){this.x=Math.ceil(this.x);this.y=Math.ceil(this.y);this.z=Math.ceil(this.z);this.w=Math.ceil(this.w);return this},round:function(){this.x=
Math.round(this.x);this.y=Math.round(this.y);this.z=Math.round(this.z);this.w=Math.round(this.w);return this},roundToZero:function(){this.x=0>this.x?Math.ceil(this.x):Math.floor(this.x);this.y=0>this.y?Math.ceil(this.y):Math.floor(this.y);this.z=0>this.z?Math.ceil(this.z):Math.floor(this.z);this.w=0>this.w?Math.ceil(this.w):Math.floor(this.w);return this},negate:function(){this.x=-this.x;this.y=-this.y;this.z=-this.z;this.w=-this.w;return this},dot:function(a){return this.x*a.x+this.y*a.y+this.z*
a.z+this.w*a.w},lengthSq:function(){return this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w},length:function(){return Math.sqrt(this.x*this.x+this.y*this.y+this.z*this.z+this.w*this.w)},manhattanLength:function(){return Math.abs(this.x)+Math.abs(this.y)+Math.abs(this.z)+Math.abs(this.w)},normalize:function(){return this.divideScalar(this.length()||1)},setLength:function(a){return this.normalize().multiplyScalar(a)},lerp:function(a,c){this.x+=(a.x-this.x)*c;this.y+=(a.y-this.y)*c;this.z+=(a.z-
this.z)*c;this.w+=(a.w-this.w)*c;return this},lerpVectors:function(a,c,e){return this.subVectors(c,a).multiplyScalar(e).add(a)},equals:function(a){return a.x===this.x&&a.y===this.y&&a.z===this.z&&a.w===this.w},fromArray:function(a,c){void 0===c&&(c=0);this.x=a[c];this.y=a[c+1];this.z=a[c+2];this.w=a[c+3];return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);a[c]=this.x;a[c+1]=this.y;a[c+2]=this.z;a[c+3]=this.w;return a},fromBufferAttribute:function(a,c,e){void 0!==e&&console.warn("THREE.Vector4: offset has been removed from .fromBufferAttribute().");
this.x=a.getX(c);this.y=a.getY(c);this.z=a.getZ(c);this.w=a.getW(c);return this}});m.prototype=Object.assign(Object.create(d.prototype),{constructor:m,isWebGLRenderTarget:!0,setSize:function(a,c){if(this.width!==a||this.height!==c)this.width=a,this.height=c,this.texture.image.width=a,this.texture.image.height=c,this.dispose();this.viewport.set(0,0,a,c);this.scissor.set(0,0,a,c)},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.width=a.width;this.height=a.height;this.viewport.copy(a.viewport);
this.texture=a.texture.clone();this.depthBuffer=a.depthBuffer;this.stencilBuffer=a.stencilBuffer;this.depthTexture=a.depthTexture;return this},dispose:function(){this.dispatchEvent({type:"dispose"})}});n.prototype=Object.assign(Object.create(m.prototype),{constructor:n,isWebGLMultisampleRenderTarget:!0,copy:function(a){m.prototype.copy.call(this,a);this.samples=a.samples;return this}});var qc=new k,Qb=new q,xm=new k(0,0,0),ym=new k(1,1,1),Ed=new k,gh=new k,fc=new k;Object.assign(q.prototype,{isMatrix4:!0,
set:function(a,c,e,g,r,v,z,E,F,J,P,R,S,V,W,ha){var fa=this.elements;fa[0]=a;fa[4]=c;fa[8]=e;fa[12]=g;fa[1]=r;fa[5]=v;fa[9]=z;fa[13]=E;fa[2]=F;fa[6]=J;fa[10]=P;fa[14]=R;fa[3]=S;fa[7]=V;fa[11]=W;fa[15]=ha;return this},identity:function(){this.set(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1);return this},clone:function(){return(new q).fromArray(this.elements)},copy:function(a){var c=this.elements;a=a.elements;c[0]=a[0];c[1]=a[1];c[2]=a[2];c[3]=a[3];c[4]=a[4];c[5]=a[5];c[6]=a[6];c[7]=a[7];c[8]=a[8];c[9]=a[9];c[10]=
a[10];c[11]=a[11];c[12]=a[12];c[13]=a[13];c[14]=a[14];c[15]=a[15];return this},copyPosition:function(a){var c=this.elements;a=a.elements;c[12]=a[12];c[13]=a[13];c[14]=a[14];return this},extractBasis:function(a,c,e){a.setFromMatrixColumn(this,0);c.setFromMatrixColumn(this,1);e.setFromMatrixColumn(this,2);return this},makeBasis:function(a,c,e){this.set(a.x,c.x,e.x,0,a.y,c.y,e.y,0,a.z,c.z,e.z,0,0,0,0,1);return this},extractRotation:function(a){var c=this.elements,e=a.elements,g=1/qc.setFromMatrixColumn(a,
0).length(),r=1/qc.setFromMatrixColumn(a,1).length();a=1/qc.setFromMatrixColumn(a,2).length();c[0]=e[0]*g;c[1]=e[1]*g;c[2]=e[2]*g;c[3]=0;c[4]=e[4]*r;c[5]=e[5]*r;c[6]=e[6]*r;c[7]=0;c[8]=e[8]*a;c[9]=e[9]*a;c[10]=e[10]*a;c[11]=0;c[12]=0;c[13]=0;c[14]=0;c[15]=1;return this},makeRotationFromEuler:function(a){a&&a.isEuler||console.error("THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.");var c=this.elements,e=a.x,g=a.y,r=a.z,v=Math.cos(e);e=Math.sin(e);
var z=Math.cos(g);g=Math.sin(g);var E=Math.cos(r);r=Math.sin(r);if("XYZ"===a.order){a=v*E;var F=v*r,J=e*E,P=e*r;c[0]=z*E;c[4]=-z*r;c[8]=g;c[1]=F+J*g;c[5]=a-P*g;c[9]=-e*z;c[2]=P-a*g;c[6]=J+F*g;c[10]=v*z}else"YXZ"===a.order?(a=z*E,F=z*r,J=g*E,P=g*r,c[0]=a+P*e,c[4]=J*e-F,c[8]=v*g,c[1]=v*r,c[5]=v*E,c[9]=-e,c[2]=F*e-J,c[6]=P+a*e,c[10]=v*z):"ZXY"===a.order?(a=z*E,F=z*r,J=g*E,P=g*r,c[0]=a-P*e,c[4]=-v*r,c[8]=J+F*e,c[1]=F+J*e,c[5]=v*E,c[9]=P-a*e,c[2]=-v*g,c[6]=e,c[10]=v*z):"ZYX"===a.order?(a=v*E,F=v*r,J=e*
E,P=e*r,c[0]=z*E,c[4]=J*g-F,c[8]=a*g+P,c[1]=z*r,c[5]=P*g+a,c[9]=F*g-J,c[2]=-g,c[6]=e*z,c[10]=v*z):"YZX"===a.order?(a=v*z,F=v*g,J=e*z,P=e*g,c[0]=z*E,c[4]=P-a*r,c[8]=J*r+F,c[1]=r,c[5]=v*E,c[9]=-e*E,c[2]=-g*E,c[6]=F*r+J,c[10]=a-P*r):"XZY"===a.order&&(a=v*z,F=v*g,J=e*z,P=e*g,c[0]=z*E,c[4]=-r,c[8]=g*E,c[1]=a*r+P,c[5]=v*E,c[9]=F*r-J,c[2]=J*r-F,c[6]=e*E,c[10]=P*r+a);c[3]=0;c[7]=0;c[11]=0;c[12]=0;c[13]=0;c[14]=0;c[15]=1;return this},makeRotationFromQuaternion:function(a){return this.compose(xm,a,ym)},lookAt:function(a,
c,e){var g=this.elements;fc.subVectors(a,c);0===fc.lengthSq()&&(fc.z=1);fc.normalize();Ed.crossVectors(e,fc);0===Ed.lengthSq()&&(1===Math.abs(e.z)?fc.x+=1E-4:fc.z+=1E-4,fc.normalize(),Ed.crossVectors(e,fc));Ed.normalize();gh.crossVectors(fc,Ed);g[0]=Ed.x;g[4]=gh.x;g[8]=fc.x;g[1]=Ed.y;g[5]=gh.y;g[9]=fc.y;g[2]=Ed.z;g[6]=gh.z;g[10]=fc.z;return this},multiply:function(a,c){return void 0!==c?(console.warn("THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead."),
this.multiplyMatrices(a,c)):this.multiplyMatrices(this,a)},premultiply:function(a){return this.multiplyMatrices(a,this)},multiplyMatrices:function(a,c){var e=a.elements,g=c.elements;c=this.elements;a=e[0];var r=e[4],v=e[8],z=e[12],E=e[1],F=e[5],J=e[9],P=e[13],R=e[2],S=e[6],V=e[10],W=e[14],ha=e[3],fa=e[7],ra=e[11];e=e[15];var pa=g[0],qa=g[4],ua=g[8],oa=g[12],ta=g[1],Ba=g[5],Ta=g[9],Ua=g[13],Ca=g[2],Ha=g[6],Da=g[10],Ma=g[14],db=g[3],tb=g[7],Ka=g[11];g=g[15];c[0]=a*pa+r*ta+v*Ca+z*db;c[4]=a*qa+r*Ba+v*
Ha+z*tb;c[8]=a*ua+r*Ta+v*Da+z*Ka;c[12]=a*oa+r*Ua+v*Ma+z*g;c[1]=E*pa+F*ta+J*Ca+P*db;c[5]=E*qa+F*Ba+J*Ha+P*tb;c[9]=E*ua+F*Ta+J*Da+P*Ka;c[13]=E*oa+F*Ua+J*Ma+P*g;c[2]=R*pa+S*ta+V*Ca+W*db;c[6]=R*qa+S*Ba+V*Ha+W*tb;c[10]=R*ua+S*Ta+V*Da+W*Ka;c[14]=R*oa+S*Ua+V*Ma+W*g;c[3]=ha*pa+fa*ta+ra*Ca+e*db;c[7]=ha*qa+fa*Ba+ra*Ha+e*tb;c[11]=ha*ua+fa*Ta+ra*Da+e*Ka;c[15]=ha*oa+fa*Ua+ra*Ma+e*g;return this},multiplyScalar:function(a){var c=this.elements;c[0]*=a;c[4]*=a;c[8]*=a;c[12]*=a;c[1]*=a;c[5]*=a;c[9]*=a;c[13]*=a;c[2]*=
a;c[6]*=a;c[10]*=a;c[14]*=a;c[3]*=a;c[7]*=a;c[11]*=a;c[15]*=a;return this},applyToBufferAttribute:function(a){for(var c=0,e=a.count;c<e;c++)qc.x=a.getX(c),qc.y=a.getY(c),qc.z=a.getZ(c),qc.applyMatrix4(this),a.setXYZ(c,qc.x,qc.y,qc.z);return a},determinant:function(){var a=this.elements,c=a[0],e=a[4],g=a[8],r=a[12],v=a[1],z=a[5],E=a[9],F=a[13],J=a[2],P=a[6],R=a[10],S=a[14];return a[3]*(+r*E*P-g*F*P-r*z*R+e*F*R+g*z*S-e*E*S)+a[7]*(+c*E*S-c*F*R+r*v*R-g*v*S+g*F*J-r*E*J)+a[11]*(+c*F*P-c*z*S-r*v*P+e*v*S+
r*z*J-e*F*J)+a[15]*(-g*z*J-c*E*P+c*z*R+g*v*P-e*v*R+e*E*J)},transpose:function(){var a=this.elements;var c=a[1];a[1]=a[4];a[4]=c;c=a[2];a[2]=a[8];a[8]=c;c=a[6];a[6]=a[9];a[9]=c;c=a[3];a[3]=a[12];a[12]=c;c=a[7];a[7]=a[13];a[13]=c;c=a[11];a[11]=a[14];a[14]=c;return this},setPosition:function(a,c,e){var g=this.elements;a.isVector3?(g[12]=a.x,g[13]=a.y,g[14]=a.z):(g[12]=a,g[13]=c,g[14]=e);return this},getInverse:function(a,c){var e=this.elements,g=a.elements;a=g[0];var r=g[1],v=g[2],z=g[3],E=g[4],F=g[5],
J=g[6],P=g[7],R=g[8],S=g[9],V=g[10],W=g[11],ha=g[12],fa=g[13],ra=g[14];g=g[15];var pa=S*ra*P-fa*V*P+fa*J*W-F*ra*W-S*J*g+F*V*g,qa=ha*V*P-R*ra*P-ha*J*W+E*ra*W+R*J*g-E*V*g,ua=R*fa*P-ha*S*P+ha*F*W-E*fa*W-R*F*g+E*S*g,oa=ha*S*J-R*fa*J-ha*F*V+E*fa*V+R*F*ra-E*S*ra,ta=a*pa+r*qa+v*ua+z*oa;if(0===ta){if(!0===c)throw Error("THREE.Matrix4: .getInverse() can't invert matrix, determinant is 0");console.warn("THREE.Matrix4: .getInverse() can't invert matrix, determinant is 0");return this.identity()}c=1/ta;e[0]=
pa*c;e[1]=(fa*V*z-S*ra*z-fa*v*W+r*ra*W+S*v*g-r*V*g)*c;e[2]=(F*ra*z-fa*J*z+fa*v*P-r*ra*P-F*v*g+r*J*g)*c;e[3]=(S*J*z-F*V*z-S*v*P+r*V*P+F*v*W-r*J*W)*c;e[4]=qa*c;e[5]=(R*ra*z-ha*V*z+ha*v*W-a*ra*W-R*v*g+a*V*g)*c;e[6]=(ha*J*z-E*ra*z-ha*v*P+a*ra*P+E*v*g-a*J*g)*c;e[7]=(E*V*z-R*J*z+R*v*P-a*V*P-E*v*W+a*J*W)*c;e[8]=ua*c;e[9]=(ha*S*z-R*fa*z-ha*r*W+a*fa*W+R*r*g-a*S*g)*c;e[10]=(E*fa*z-ha*F*z+ha*r*P-a*fa*P-E*r*g+a*F*g)*c;e[11]=(R*F*z-E*S*z-R*r*P+a*S*P+E*r*W-a*F*W)*c;e[12]=oa*c;e[13]=(R*fa*v-ha*S*v+ha*r*V-a*fa*V-
R*r*ra+a*S*ra)*c;e[14]=(ha*F*v-E*fa*v-ha*r*J+a*fa*J+E*r*ra-a*F*ra)*c;e[15]=(E*S*v-R*F*v+R*r*J-a*S*J-E*r*V+a*F*V)*c;return this},scale:function(a){var c=this.elements,e=a.x,g=a.y;a=a.z;c[0]*=e;c[4]*=g;c[8]*=a;c[1]*=e;c[5]*=g;c[9]*=a;c[2]*=e;c[6]*=g;c[10]*=a;c[3]*=e;c[7]*=g;c[11]*=a;return this},getMaxScaleOnAxis:function(){var a=this.elements;return Math.sqrt(Math.max(a[0]*a[0]+a[1]*a[1]+a[2]*a[2],a[4]*a[4]+a[5]*a[5]+a[6]*a[6],a[8]*a[8]+a[9]*a[9]+a[10]*a[10]))},makeTranslation:function(a,c,e){this.set(1,
0,0,a,0,1,0,c,0,0,1,e,0,0,0,1);return this},makeRotationX:function(a){var c=Math.cos(a);a=Math.sin(a);this.set(1,0,0,0,0,c,-a,0,0,a,c,0,0,0,0,1);return this},makeRotationY:function(a){var c=Math.cos(a);a=Math.sin(a);this.set(c,0,a,0,0,1,0,0,-a,0,c,0,0,0,0,1);return this},makeRotationZ:function(a){var c=Math.cos(a);a=Math.sin(a);this.set(c,-a,0,0,a,c,0,0,0,0,1,0,0,0,0,1);return this},makeRotationAxis:function(a,c){var e=Math.cos(c);c=Math.sin(c);var g=1-e,r=a.x,v=a.y;a=a.z;var z=g*r,E=g*v;this.set(z*
r+e,z*v-c*a,z*a+c*v,0,z*v+c*a,E*v+e,E*a-c*r,0,z*a-c*v,E*a+c*r,g*a*a+e,0,0,0,0,1);return this},makeScale:function(a,c,e){this.set(a,0,0,0,0,c,0,0,0,0,e,0,0,0,0,1);return this},makeShear:function(a,c,e){this.set(1,c,e,0,a,1,e,0,a,c,1,0,0,0,0,1);return this},compose:function(a,c,e){var g=this.elements,r=c._x,v=c._y,z=c._z,E=c._w,F=r+r,J=v+v,P=z+z;c=r*F;var R=r*J;r*=P;var S=v*J;v*=P;z*=P;F*=E;J*=E;E*=P;P=e.x;var V=e.y;e=e.z;g[0]=(1-(S+z))*P;g[1]=(R+E)*P;g[2]=(r-J)*P;g[3]=0;g[4]=(R-E)*V;g[5]=(1-(c+z))*
V;g[6]=(v+F)*V;g[7]=0;g[8]=(r+J)*e;g[9]=(v-F)*e;g[10]=(1-(c+S))*e;g[11]=0;g[12]=a.x;g[13]=a.y;g[14]=a.z;g[15]=1;return this},decompose:function(a,c,e){var g=this.elements,r=qc.set(g[0],g[1],g[2]).length(),v=qc.set(g[4],g[5],g[6]).length(),z=qc.set(g[8],g[9],g[10]).length();0>this.determinant()&&(r=-r);a.x=g[12];a.y=g[13];a.z=g[14];Qb.copy(this);a=1/r;g=1/v;var E=1/z;Qb.elements[0]*=a;Qb.elements[1]*=a;Qb.elements[2]*=a;Qb.elements[4]*=g;Qb.elements[5]*=g;Qb.elements[6]*=g;Qb.elements[8]*=E;Qb.elements[9]*=
E;Qb.elements[10]*=E;c.setFromRotationMatrix(Qb);e.x=r;e.y=v;e.z=z;return this},makePerspective:function(a,c,e,g,r,v){void 0===v&&console.warn("THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.");var z=this.elements;z[0]=2*r/(c-a);z[4]=0;z[8]=(c+a)/(c-a);z[12]=0;z[1]=0;z[5]=2*r/(e-g);z[9]=(e+g)/(e-g);z[13]=0;z[2]=0;z[6]=0;z[10]=-(v+r)/(v-r);z[14]=-2*v*r/(v-r);z[3]=0;z[7]=0;z[11]=-1;z[15]=0;return this},makeOrthographic:function(a,c,e,g,r,v){var z=
this.elements,E=1/(c-a),F=1/(e-g),J=1/(v-r);z[0]=2*E;z[4]=0;z[8]=0;z[12]=-((c+a)*E);z[1]=0;z[5]=2*F;z[9]=0;z[13]=-((e+g)*F);z[2]=0;z[6]=0;z[10]=-2*J;z[14]=-((v+r)*J);z[3]=0;z[7]=0;z[11]=0;z[15]=1;return this},equals:function(a){var c=this.elements;a=a.elements;for(var e=0;16>e;e++)if(c[e]!==a[e])return!1;return!0},fromArray:function(a,c){void 0===c&&(c=0);for(var e=0;16>e;e++)this.elements[e]=a[e+c];return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);var e=this.elements;a[c]=e[0];
a[c+1]=e[1];a[c+2]=e[2];a[c+3]=e[3];a[c+4]=e[4];a[c+5]=e[5];a[c+6]=e[6];a[c+7]=e[7];a[c+8]=e[8];a[c+9]=e[9];a[c+10]=e[10];a[c+11]=e[11];a[c+12]=e[12];a[c+13]=e[13];a[c+14]=e[14];a[c+15]=e[15];return a}});var ck=new q,dk=new h;u.RotationOrders="XYZ YZX ZXY XZY YXZ ZYX".split(" ");u.DefaultOrder="XYZ";Object.defineProperties(u.prototype,{x:{get:function(){return this._x},set:function(a){this._x=a;this._onChangeCallback()}},y:{get:function(){return this._y},set:function(a){this._y=a;this._onChangeCallback()}},
z:{get:function(){return this._z},set:function(a){this._z=a;this._onChangeCallback()}},order:{get:function(){return this._order},set:function(a){this._order=a;this._onChangeCallback()}}});Object.assign(u.prototype,{isEuler:!0,set:function(a,c,e,g){this._x=a;this._y=c;this._z=e;this._order=g||this._order;this._onChangeCallback();return this},clone:function(){return new this.constructor(this._x,this._y,this._z,this._order)},copy:function(a){this._x=a._x;this._y=a._y;this._z=a._z;this._order=a._order;
this._onChangeCallback();return this},setFromRotationMatrix:function(a,c,e){var g=hb.clamp,r=a.elements;a=r[0];var v=r[4],z=r[8],E=r[1],F=r[5],J=r[9],P=r[2],R=r[6];r=r[10];c=c||this._order;"XYZ"===c?(this._y=Math.asin(g(z,-1,1)),.9999999>Math.abs(z)?(this._x=Math.atan2(-J,r),this._z=Math.atan2(-v,a)):(this._x=Math.atan2(R,F),this._z=0)):"YXZ"===c?(this._x=Math.asin(-g(J,-1,1)),.9999999>Math.abs(J)?(this._y=Math.atan2(z,r),this._z=Math.atan2(E,F)):(this._y=Math.atan2(-P,a),this._z=0)):"ZXY"===c?(this._x=
Math.asin(g(R,-1,1)),.9999999>Math.abs(R)?(this._y=Math.atan2(-P,r),this._z=Math.atan2(-v,F)):(this._y=0,this._z=Math.atan2(E,a))):"ZYX"===c?(this._y=Math.asin(-g(P,-1,1)),.9999999>Math.abs(P)?(this._x=Math.atan2(R,r),this._z=Math.atan2(E,a)):(this._x=0,this._z=Math.atan2(-v,F))):"YZX"===c?(this._z=Math.asin(g(E,-1,1)),.9999999>Math.abs(E)?(this._x=Math.atan2(-J,F),this._y=Math.atan2(-P,a)):(this._x=0,this._y=Math.atan2(z,r))):"XZY"===c?(this._z=Math.asin(-g(v,-1,1)),.9999999>Math.abs(v)?(this._x=
Math.atan2(R,F),this._y=Math.atan2(z,a)):(this._x=Math.atan2(-J,r),this._y=0)):console.warn("THREE.Euler: .setFromRotationMatrix() given unsupported order: "+c);this._order=c;!1!==e&&this._onChangeCallback();return this},setFromQuaternion:function(a,c,e){ck.makeRotationFromQuaternion(a);return this.setFromRotationMatrix(ck,c,e)},setFromVector3:function(a,c){return this.set(a.x,a.y,a.z,c||this._order)},reorder:function(a){dk.setFromEuler(this);return this.setFromQuaternion(dk,a)},equals:function(a){return a._x===
this._x&&a._y===this._y&&a._z===this._z&&a._order===this._order},fromArray:function(a){this._x=a[0];this._y=a[1];this._z=a[2];void 0!==a[3]&&(this._order=a[3]);this._onChangeCallback();return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);a[c]=this._x;a[c+1]=this._y;a[c+2]=this._z;a[c+3]=this._order;return a},toVector3:function(a){return a?a.set(this._x,this._y,this._z):new k(this._x,this._y,this._z)},_onChange:function(a){this._onChangeCallback=a;return this},_onChangeCallback:function(){}});
Object.assign(x.prototype,{set:function(a){this.mask=1<<a|0},enable:function(a){this.mask=this.mask|1<<a|0},enableAll:function(){this.mask=-1},toggle:function(a){this.mask^=1<<a|0},disable:function(a){this.mask&=~(1<<a|0)},disableAll:function(){this.mask=0},test:function(a){return 0!==(this.mask&a.mask)}});var Ok=0,ek=new k,ff=new h,jd=new q,hh=new k,kg=new k,zm=new k,Am=new h,fk=new k(1,0,0),gk=new k(0,1,0),hk=new k(0,0,1),Bm={type:"added"},Cm={type:"removed"};A.DefaultUp=new k(0,1,0);A.DefaultMatrixAutoUpdate=
!0;A.prototype=Object.assign(Object.create(d.prototype),{constructor:A,isObject3D:!0,onBeforeRender:function(){},onAfterRender:function(){},applyMatrix:function(a){this.matrixAutoUpdate&&this.updateMatrix();this.matrix.premultiply(a);this.matrix.decompose(this.position,this.quaternion,this.scale)},applyQuaternion:function(a){this.quaternion.premultiply(a);return this},setRotationFromAxisAngle:function(a,c){this.quaternion.setFromAxisAngle(a,c)},setRotationFromEuler:function(a){this.quaternion.setFromEuler(a,
!0)},setRotationFromMatrix:function(a){this.quaternion.setFromRotationMatrix(a)},setRotationFromQuaternion:function(a){this.quaternion.copy(a)},rotateOnAxis:function(a,c){ff.setFromAxisAngle(a,c);this.quaternion.multiply(ff);return this},rotateOnWorldAxis:function(a,c){ff.setFromAxisAngle(a,c);this.quaternion.premultiply(ff);return this},rotateX:function(a){return this.rotateOnAxis(fk,a)},rotateY:function(a){return this.rotateOnAxis(gk,a)},rotateZ:function(a){return this.rotateOnAxis(hk,a)},translateOnAxis:function(a,
c){ek.copy(a).applyQuaternion(this.quaternion);this.position.add(ek.multiplyScalar(c));return this},translateX:function(a){return this.translateOnAxis(fk,a)},translateY:function(a){return this.translateOnAxis(gk,a)},translateZ:function(a){return this.translateOnAxis(hk,a)},localToWorld:function(a){return a.applyMatrix4(this.matrixWorld)},worldToLocal:function(a){return a.applyMatrix4(jd.getInverse(this.matrixWorld))},lookAt:function(a,c,e){a.isVector3?hh.copy(a):hh.set(a,c,e);a=this.parent;this.updateWorldMatrix(!0,
!1);kg.setFromMatrixPosition(this.matrixWorld);this.isCamera||this.isLight?jd.lookAt(kg,hh,this.up):jd.lookAt(hh,kg,this.up);this.quaternion.setFromRotationMatrix(jd);a&&(jd.extractRotation(a.matrixWorld),ff.setFromRotationMatrix(jd),this.quaternion.premultiply(ff.inverse()))},add:function(a){if(1<arguments.length){for(var c=0;c<arguments.length;c++)this.add(arguments[c]);return this}if(a===this)return console.error("THREE.Object3D.add: object can't be added as a child of itself.",a),this;a&&a.isObject3D?
(null!==a.parent&&a.parent.remove(a),a.parent=this,this.children.push(a),a.dispatchEvent(Bm)):console.error("THREE.Object3D.add: object not an instance of THREE.Object3D.",a);return this},remove:function(a){if(1<arguments.length){for(var c=0;c<arguments.length;c++)this.remove(arguments[c]);return this}c=this.children.indexOf(a);-1!==c&&(a.parent=null,this.children.splice(c,1),a.dispatchEvent(Cm));return this},attach:function(a){this.updateWorldMatrix(!0,!1);jd.getInverse(this.matrixWorld);null!==
a.parent&&(a.parent.updateWorldMatrix(!0,!1),jd.multiply(a.parent.matrixWorld));a.applyMatrix(jd);a.updateWorldMatrix(!1,!1);this.add(a);return this},getObjectById:function(a){return this.getObjectByProperty("id",a)},getObjectByName:function(a){return this.getObjectByProperty("name",a)},getObjectByProperty:function(a,c){if(this[a]===c)return this;for(var e=0,g=this.children.length;e<g;e++){var r=this.children[e].getObjectByProperty(a,c);if(void 0!==r)return r}},getWorldPosition:function(a){void 0===
a&&(console.warn("THREE.Object3D: .getWorldPosition() target is now required"),a=new k);this.updateMatrixWorld(!0);return a.setFromMatrixPosition(this.matrixWorld)},getWorldQuaternion:function(a){void 0===a&&(console.warn("THREE.Object3D: .getWorldQuaternion() target is now required"),a=new h);this.updateMatrixWorld(!0);this.matrixWorld.decompose(kg,a,zm);return a},getWorldScale:function(a){void 0===a&&(console.warn("THREE.Object3D: .getWorldScale() target is now required"),a=new k);this.updateMatrixWorld(!0);
this.matrixWorld.decompose(kg,Am,a);return a},getWorldDirection:function(a){void 0===a&&(console.warn("THREE.Object3D: .getWorldDirection() target is now required"),a=new k);this.updateMatrixWorld(!0);var c=this.matrixWorld.elements;return a.set(c[8],c[9],c[10]).normalize()},raycast:function(){},traverse:function(a){a(this);for(var c=this.children,e=0,g=c.length;e<g;e++)c[e].traverse(a)},traverseVisible:function(a){if(!1!==this.visible){a(this);for(var c=this.children,e=0,g=c.length;e<g;e++)c[e].traverseVisible(a)}},
traverseAncestors:function(a){var c=this.parent;null!==c&&(a(c),c.traverseAncestors(a))},updateMatrix:function(){this.matrix.compose(this.position,this.quaternion,this.scale);this.matrixWorldNeedsUpdate=!0},updateMatrixWorld:function(a){this.matrixAutoUpdate&&this.updateMatrix();if(this.matrixWorldNeedsUpdate||a)null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix),this.matrixWorldNeedsUpdate=!1,a=!0;for(var c=this.children,e=
0,g=c.length;e<g;e++)c[e].updateMatrixWorld(a)},updateWorldMatrix:function(a,c){var e=this.parent;!0===a&&null!==e&&e.updateWorldMatrix(!0,!1);this.matrixAutoUpdate&&this.updateMatrix();null===this.parent?this.matrixWorld.copy(this.matrix):this.matrixWorld.multiplyMatrices(this.parent.matrixWorld,this.matrix);if(!0===c)for(a=this.children,c=0,e=a.length;c<e;c++)a[c].updateWorldMatrix(!1,!0)},toJSON:function(a){function c(P,R){void 0===P[R.uuid]&&(P[R.uuid]=R.toJSON(a));return R.uuid}function e(P){var R=
[],S;for(S in P){var V=P[S];delete V.metadata;R.push(V)}return R}var g=void 0===a||"string"===typeof a,r={};g&&(a={geometries:{},materials:{},textures:{},images:{},shapes:{}},r.metadata={version:4.5,type:"Object",generator:"Object3D.toJSON"});var v={};v.uuid=this.uuid;v.type=this.type;""!==this.name&&(v.name=this.name);!0===this.castShadow&&(v.castShadow=!0);!0===this.receiveShadow&&(v.receiveShadow=!0);!1===this.visible&&(v.visible=!1);!1===this.frustumCulled&&(v.frustumCulled=!1);0!==this.renderOrder&&
(v.renderOrder=this.renderOrder);"{}"!==JSON.stringify(this.userData)&&(v.userData=this.userData);v.layers=this.layers.mask;v.matrix=this.matrix.toArray();!1===this.matrixAutoUpdate&&(v.matrixAutoUpdate=!1);this.isMesh&&0!==this.drawMode&&(v.drawMode=this.drawMode);if(this.isMesh||this.isLine||this.isPoints){v.geometry=c(a.geometries,this.geometry);var z=this.geometry.parameters;if(void 0!==z&&void 0!==z.shapes)if(z=z.shapes,Array.isArray(z))for(var E=0,F=z.length;E<F;E++)c(a.shapes,z[E]);else c(a.shapes,
z)}if(void 0!==this.material)if(Array.isArray(this.material)){z=[];E=0;for(F=this.material.length;E<F;E++)z.push(c(a.materials,this.material[E]));v.material=z}else v.material=c(a.materials,this.material);if(0<this.children.length)for(v.children=[],E=0;E<this.children.length;E++)v.children.push(this.children[E].toJSON(a).object);if(g){g=e(a.geometries);E=e(a.materials);F=e(a.textures);var J=e(a.images);z=e(a.shapes);0<g.length&&(r.geometries=g);0<E.length&&(r.materials=E);0<F.length&&(r.textures=F);
0<J.length&&(r.images=J);0<z.length&&(r.shapes=z)}r.object=v;return r},clone:function(a){return(new this.constructor).copy(this,a)},copy:function(a,c){void 0===c&&(c=!0);this.name=a.name;this.up.copy(a.up);this.position.copy(a.position);this.quaternion.copy(a.quaternion);this.scale.copy(a.scale);this.matrix.copy(a.matrix);this.matrixWorld.copy(a.matrixWorld);this.matrixAutoUpdate=a.matrixAutoUpdate;this.matrixWorldNeedsUpdate=a.matrixWorldNeedsUpdate;this.layers.mask=a.layers.mask;this.visible=a.visible;
this.castShadow=a.castShadow;this.receiveShadow=a.receiveShadow;this.frustumCulled=a.frustumCulled;this.renderOrder=a.renderOrder;this.userData=JSON.parse(JSON.stringify(a.userData));if(!0===c)for(c=0;c<a.children.length;c++)this.add(a.children[c].clone());return this}});y.prototype=Object.assign(Object.create(A.prototype),{constructor:y,isScene:!0,copy:function(a,c){A.prototype.copy.call(this,a,c);null!==a.background&&(this.background=a.background.clone());null!==a.fog&&(this.fog=a.fog.clone());
null!==a.overrideMaterial&&(this.overrideMaterial=a.overrideMaterial.clone());this.autoUpdate=a.autoUpdate;this.matrixAutoUpdate=a.matrixAutoUpdate;return this},toJSON:function(a){var c=A.prototype.toJSON.call(this,a);null!==this.background&&(c.object.background=this.background.toJSON(a));null!==this.fog&&(c.object.fog=this.fog.toJSON());return c},dispose:function(){this.dispatchEvent({type:"dispose"})}});var kd=[new k,new k,new k,new k,new k,new k,new k,new k],Wc=new k,gf=new k,hf=new k,jf=new k,
Fd=new k,Gd=new k,fe=new k,lg=new k,ih=new k,jh=new k,Kd=new k;Object.assign(w.prototype,{isBox3:!0,set:function(a,c){this.min.copy(a);this.max.copy(c);return this},setFromArray:function(a){for(var c=Infinity,e=Infinity,g=Infinity,r=-Infinity,v=-Infinity,z=-Infinity,E=0,F=a.length;E<F;E+=3){var J=a[E],P=a[E+1],R=a[E+2];J<c&&(c=J);P<e&&(e=P);R<g&&(g=R);J>r&&(r=J);P>v&&(v=P);R>z&&(z=R)}this.min.set(c,e,g);this.max.set(r,v,z);return this},setFromBufferAttribute:function(a){for(var c=Infinity,e=Infinity,
g=Infinity,r=-Infinity,v=-Infinity,z=-Infinity,E=0,F=a.count;E<F;E++){var J=a.getX(E),P=a.getY(E),R=a.getZ(E);J<c&&(c=J);P<e&&(e=P);R<g&&(g=R);J>r&&(r=J);P>v&&(v=P);R>z&&(z=R)}this.min.set(c,e,g);this.max.set(r,v,z);return this},setFromPoints:function(a){this.makeEmpty();for(var c=0,e=a.length;c<e;c++)this.expandByPoint(a[c]);return this},setFromCenterAndSize:function(a,c){c=Wc.copy(c).multiplyScalar(.5);this.min.copy(a).sub(c);this.max.copy(a).add(c);return this},setFromObject:function(a){this.makeEmpty();
return this.expandByObject(a)},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.min.copy(a.min);this.max.copy(a.max);return this},makeEmpty:function(){this.min.x=this.min.y=this.min.z=Infinity;this.max.x=this.max.y=this.max.z=-Infinity;return this},isEmpty:function(){return this.max.x<this.min.x||this.max.y<this.min.y||this.max.z<this.min.z},getCenter:function(a){void 0===a&&(console.warn("THREE.Box3: .getCenter() target is now required"),a=new k);return this.isEmpty()?
a.set(0,0,0):a.addVectors(this.min,this.max).multiplyScalar(.5)},getSize:function(a){void 0===a&&(console.warn("THREE.Box3: .getSize() target is now required"),a=new k);return this.isEmpty()?a.set(0,0,0):a.subVectors(this.max,this.min)},expandByPoint:function(a){this.min.min(a);this.max.max(a);return this},expandByVector:function(a){this.min.sub(a);this.max.add(a);return this},expandByScalar:function(a){this.min.addScalar(-a);this.max.addScalar(a);return this},expandByObject:function(a){var c;a.updateWorldMatrix(!1,
!1);var e=a.geometry;if(void 0!==e)if(e.isGeometry){var g=e.vertices;e=0;for(c=g.length;e<c;e++)Wc.copy(g[e]),Wc.applyMatrix4(a.matrixWorld),this.expandByPoint(Wc)}else if(e.isBufferGeometry&&(g=e.attributes.position,void 0!==g))for(e=0,c=g.count;e<c;e++)Wc.fromBufferAttribute(g,e).applyMatrix4(a.matrixWorld),this.expandByPoint(Wc);a=a.children;e=0;for(c=a.length;e<c;e++)this.expandByObject(a[e]);return this},containsPoint:function(a){return a.x<this.min.x||a.x>this.max.x||a.y<this.min.y||a.y>this.max.y||
a.z<this.min.z||a.z>this.max.z?!1:!0},containsBox:function(a){return this.min.x<=a.min.x&&a.max.x<=this.max.x&&this.min.y<=a.min.y&&a.max.y<=this.max.y&&this.min.z<=a.min.z&&a.max.z<=this.max.z},getParameter:function(a,c){void 0===c&&(console.warn("THREE.Box3: .getParameter() target is now required"),c=new k);return c.set((a.x-this.min.x)/(this.max.x-this.min.x),(a.y-this.min.y)/(this.max.y-this.min.y),(a.z-this.min.z)/(this.max.z-this.min.z))},intersectsBox:function(a){return a.max.x<this.min.x||
a.min.x>this.max.x||a.max.y<this.min.y||a.min.y>this.max.y||a.max.z<this.min.z||a.min.z>this.max.z?!1:!0},intersectsSphere:function(a){this.clampPoint(a.center,Wc);return Wc.distanceToSquared(a.center)<=a.radius*a.radius},intersectsPlane:function(a){if(0<a.normal.x){var c=a.normal.x*this.min.x;var e=a.normal.x*this.max.x}else c=a.normal.x*this.max.x,e=a.normal.x*this.min.x;0<a.normal.y?(c+=a.normal.y*this.min.y,e+=a.normal.y*this.max.y):(c+=a.normal.y*this.max.y,e+=a.normal.y*this.min.y);0<a.normal.z?
(c+=a.normal.z*this.min.z,e+=a.normal.z*this.max.z):(c+=a.normal.z*this.max.z,e+=a.normal.z*this.min.z);return c<=-a.constant&&e>=-a.constant},intersectsTriangle:function(a){if(this.isEmpty())return!1;this.getCenter(lg);ih.subVectors(this.max,lg);gf.subVectors(a.a,lg);hf.subVectors(a.b,lg);jf.subVectors(a.c,lg);Fd.subVectors(hf,gf);Gd.subVectors(jf,hf);fe.subVectors(gf,jf);a=[0,-Fd.z,Fd.y,0,-Gd.z,Gd.y,0,-fe.z,fe.y,Fd.z,0,-Fd.x,Gd.z,0,-Gd.x,fe.z,0,-fe.x,-Fd.y,Fd.x,0,-Gd.y,Gd.x,0,-fe.y,fe.x,0];if(!C(a,
gf,hf,jf,ih))return!1;a=[1,0,0,0,1,0,0,0,1];if(!C(a,gf,hf,jf,ih))return!1;jh.crossVectors(Fd,Gd);a=[jh.x,jh.y,jh.z];return C(a,gf,hf,jf,ih)},clampPoint:function(a,c){void 0===c&&(console.warn("THREE.Box3: .clampPoint() target is now required"),c=new k);return c.copy(a).clamp(this.min,this.max)},distanceToPoint:function(a){return Wc.copy(a).clamp(this.min,this.max).sub(a).length()},getBoundingSphere:function(a){void 0===a&&console.error("THREE.Box3: .getBoundingSphere() target is now required");this.getCenter(a.center);
a.radius=.5*this.getSize(Wc).length();return a},intersect:function(a){this.min.max(a.min);this.max.min(a.max);this.isEmpty()&&this.makeEmpty();return this},union:function(a){this.min.min(a.min);this.max.max(a.max);return this},applyMatrix4:function(a){if(this.isEmpty())return this;kd[0].set(this.min.x,this.min.y,this.min.z).applyMatrix4(a);kd[1].set(this.min.x,this.min.y,this.max.z).applyMatrix4(a);kd[2].set(this.min.x,this.max.y,this.min.z).applyMatrix4(a);kd[3].set(this.min.x,this.max.y,this.max.z).applyMatrix4(a);
kd[4].set(this.max.x,this.min.y,this.min.z).applyMatrix4(a);kd[5].set(this.max.x,this.min.y,this.max.z).applyMatrix4(a);kd[6].set(this.max.x,this.max.y,this.min.z).applyMatrix4(a);kd[7].set(this.max.x,this.max.y,this.max.z).applyMatrix4(a);this.setFromPoints(kd);return this},translate:function(a){this.min.add(a);this.max.add(a);return this},equals:function(a){return a.min.equals(this.min)&&a.max.equals(this.max)}});var Dm=new w;Object.assign(G.prototype,{set:function(a,c){this.center.copy(a);this.radius=
c;return this},setFromPoints:function(a,c){var e=this.center;void 0!==c?e.copy(c):Dm.setFromPoints(a).getCenter(e);for(var g=c=0,r=a.length;g<r;g++)c=Math.max(c,e.distanceToSquared(a[g]));this.radius=Math.sqrt(c);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.center.copy(a.center);this.radius=a.radius;return this},empty:function(){return 0>=this.radius},containsPoint:function(a){return a.distanceToSquared(this.center)<=this.radius*this.radius},distanceToPoint:function(a){return a.distanceTo(this.center)-
this.radius},intersectsSphere:function(a){var c=this.radius+a.radius;return a.center.distanceToSquared(this.center)<=c*c},intersectsBox:function(a){return a.intersectsSphere(this)},intersectsPlane:function(a){return Math.abs(a.distanceToPoint(this.center))<=this.radius},clampPoint:function(a,c){var e=this.center.distanceToSquared(a);void 0===c&&(console.warn("THREE.Sphere: .clampPoint() target is now required"),c=new k);c.copy(a);e>this.radius*this.radius&&(c.sub(this.center).normalize(),c.multiplyScalar(this.radius).add(this.center));
return c},getBoundingBox:function(a){void 0===a&&(console.warn("THREE.Sphere: .getBoundingBox() target is now required"),a=new w);a.set(this.center,this.center);a.expandByScalar(this.radius);return a},applyMatrix4:function(a){this.center.applyMatrix4(a);this.radius*=a.getMaxScaleOnAxis();return this},translate:function(a){this.center.add(a);return this},equals:function(a){return a.center.equals(this.center)&&a.radius===this.radius}});var ld=new k,yi=new k,kh=new k,Hd=new k,zi=new k,lh=new k,Ai=new k;
Object.assign(D.prototype,{set:function(a,c){this.origin.copy(a);this.direction.copy(c);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.origin.copy(a.origin);this.direction.copy(a.direction);return this},at:function(a,c){void 0===c&&(console.warn("THREE.Ray: .at() target is now required"),c=new k);return c.copy(this.direction).multiplyScalar(a).add(this.origin)},lookAt:function(a){this.direction.copy(a).sub(this.origin).normalize();return this},recast:function(a){this.origin.copy(this.at(a,
ld));return this},closestPointToPoint:function(a,c){void 0===c&&(console.warn("THREE.Ray: .closestPointToPoint() target is now required"),c=new k);c.subVectors(a,this.origin);a=c.dot(this.direction);return 0>a?c.copy(this.origin):c.copy(this.direction).multiplyScalar(a).add(this.origin)},distanceToPoint:function(a){return Math.sqrt(this.distanceSqToPoint(a))},distanceSqToPoint:function(a){var c=ld.subVectors(a,this.origin).dot(this.direction);if(0>c)return this.origin.distanceToSquared(a);ld.copy(this.direction).multiplyScalar(c).add(this.origin);
return ld.distanceToSquared(a)},distanceSqToSegment:function(a,c,e,g){yi.copy(a).add(c).multiplyScalar(.5);kh.copy(c).sub(a).normalize();Hd.copy(this.origin).sub(yi);var r=.5*a.distanceTo(c),v=-this.direction.dot(kh),z=Hd.dot(this.direction),E=-Hd.dot(kh),F=Hd.lengthSq(),J=Math.abs(1-v*v);if(0<J){a=v*E-z;c=v*z-E;var P=r*J;0<=a?c>=-P?c<=P?(r=1/J,a*=r,c*=r,v=a*(a+v*c+2*z)+c*(v*a+c+2*E)+F):(c=r,a=Math.max(0,-(v*c+z)),v=-a*a+c*(c+2*E)+F):(c=-r,a=Math.max(0,-(v*c+z)),v=-a*a+c*(c+2*E)+F):c<=-P?(a=Math.max(0,
-(-v*r+z)),c=0<a?-r:Math.min(Math.max(-r,-E),r),v=-a*a+c*(c+2*E)+F):c<=P?(a=0,c=Math.min(Math.max(-r,-E),r),v=c*(c+2*E)+F):(a=Math.max(0,-(v*r+z)),c=0<a?r:Math.min(Math.max(-r,-E),r),v=-a*a+c*(c+2*E)+F)}else c=0<v?-r:r,a=Math.max(0,-(v*c+z)),v=-a*a+c*(c+2*E)+F;e&&e.copy(this.direction).multiplyScalar(a).add(this.origin);g&&g.copy(kh).multiplyScalar(c).add(yi);return v},intersectSphere:function(a,c){ld.subVectors(a.center,this.origin);var e=ld.dot(this.direction),g=ld.dot(ld)-e*e;a=a.radius*a.radius;
if(g>a)return null;a=Math.sqrt(a-g);g=e-a;e+=a;return 0>g&&0>e?null:0>g?this.at(e,c):this.at(g,c)},intersectsSphere:function(a){return this.distanceSqToPoint(a.center)<=a.radius*a.radius},distanceToPlane:function(a){var c=a.normal.dot(this.direction);if(0===c)return 0===a.distanceToPoint(this.origin)?0:null;a=-(this.origin.dot(a.normal)+a.constant)/c;return 0<=a?a:null},intersectPlane:function(a,c){a=this.distanceToPlane(a);return null===a?null:this.at(a,c)},intersectsPlane:function(a){var c=a.distanceToPoint(this.origin);
return 0===c||0>a.normal.dot(this.direction)*c?!0:!1},intersectBox:function(a,c){var e=1/this.direction.x;var g=1/this.direction.y;var r=1/this.direction.z,v=this.origin;if(0<=e){var z=(a.min.x-v.x)*e;e*=a.max.x-v.x}else z=(a.max.x-v.x)*e,e*=a.min.x-v.x;if(0<=g){var E=(a.min.y-v.y)*g;g*=a.max.y-v.y}else E=(a.max.y-v.y)*g,g*=a.min.y-v.y;if(z>g||E>e)return null;if(E>z||z!==z)z=E;if(g<e||e!==e)e=g;0<=r?(E=(a.min.z-v.z)*r,a=(a.max.z-v.z)*r):(E=(a.max.z-v.z)*r,a=(a.min.z-v.z)*r);if(z>a||E>e)return null;
if(E>z||z!==z)z=E;if(a<e||e!==e)e=a;return 0>e?null:this.at(0<=z?z:e,c)},intersectsBox:function(a){return null!==this.intersectBox(a,ld)},intersectTriangle:function(a,c,e,g,r){zi.subVectors(c,a);lh.subVectors(e,a);Ai.crossVectors(zi,lh);c=this.direction.dot(Ai);if(0<c){if(g)return null;g=1}else if(0>c)g=-1,c=-c;else return null;Hd.subVectors(this.origin,a);a=g*this.direction.dot(lh.crossVectors(Hd,lh));if(0>a)return null;e=g*this.direction.dot(zi.cross(Hd));if(0>e||a+e>c)return null;a=-g*Hd.dot(Ai);
return 0>a?null:this.at(a/c,r)},applyMatrix4:function(a){this.origin.applyMatrix4(a);this.direction.transformDirection(a);return this},equals:function(a){return a.origin.equals(this.origin)&&a.direction.equals(this.direction)}});var Ic=new k,md=new k,Bi=new k,nd=new k,kf=new k,lf=new k,ik=new k,Ci=new k,Di=new k,Ei=new k;Object.assign(B,{getNormal:function(a,c,e,g){void 0===g&&(console.warn("THREE.Triangle: .getNormal() target is now required"),g=new k);g.subVectors(e,c);Ic.subVectors(a,c);g.cross(Ic);
a=g.lengthSq();return 0<a?g.multiplyScalar(1/Math.sqrt(a)):g.set(0,0,0)},getBarycoord:function(a,c,e,g,r){Ic.subVectors(g,c);md.subVectors(e,c);Bi.subVectors(a,c);a=Ic.dot(Ic);c=Ic.dot(md);e=Ic.dot(Bi);var v=md.dot(md);g=md.dot(Bi);var z=a*v-c*c;void 0===r&&(console.warn("THREE.Triangle: .getBarycoord() target is now required"),r=new k);if(0===z)return r.set(-2,-1,-1);z=1/z;v=(v*e-c*g)*z;a=(a*g-c*e)*z;return r.set(1-v-a,a,v)},containsPoint:function(a,c,e,g){B.getBarycoord(a,c,e,g,nd);return 0<=nd.x&&
0<=nd.y&&1>=nd.x+nd.y},getUV:function(a,c,e,g,r,v,z,E){this.getBarycoord(a,c,e,g,nd);E.set(0,0);E.addScaledVector(r,nd.x);E.addScaledVector(v,nd.y);E.addScaledVector(z,nd.z);return E},isFrontFacing:function(a,c,e,g){Ic.subVectors(e,c);md.subVectors(a,c);return 0>Ic.cross(md).dot(g)?!0:!1}});Object.assign(B.prototype,{set:function(a,c,e){this.a.copy(a);this.b.copy(c);this.c.copy(e);return this},setFromPointsAndIndices:function(a,c,e,g){this.a.copy(a[c]);this.b.copy(a[e]);this.c.copy(a[g]);return this},
clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.a.copy(a.a);this.b.copy(a.b);this.c.copy(a.c);return this},getArea:function(){Ic.subVectors(this.c,this.b);md.subVectors(this.a,this.b);return.5*Ic.cross(md).length()},getMidpoint:function(a){void 0===a&&(console.warn("THREE.Triangle: .getMidpoint() target is now required"),a=new k);return a.addVectors(this.a,this.b).add(this.c).multiplyScalar(1/3)},getNormal:function(a){return B.getNormal(this.a,this.b,this.c,a)},getPlane:function(a){void 0===
a&&(console.warn("THREE.Triangle: .getPlane() target is now required"),a=new k);return a.setFromCoplanarPoints(this.a,this.b,this.c)},getBarycoord:function(a,c){return B.getBarycoord(a,this.a,this.b,this.c,c)},getUV:function(a,c,e,g,r){return B.getUV(a,this.a,this.b,this.c,c,e,g,r)},containsPoint:function(a){return B.containsPoint(a,this.a,this.b,this.c)},isFrontFacing:function(a){return B.isFrontFacing(this.a,this.b,this.c,a)},intersectsBox:function(a){return a.intersectsTriangle(this)},closestPointToPoint:function(a,
c){void 0===c&&(console.warn("THREE.Triangle: .closestPointToPoint() target is now required"),c=new k);var e=this.a,g=this.b,r=this.c;kf.subVectors(g,e);lf.subVectors(r,e);Ci.subVectors(a,e);var v=kf.dot(Ci),z=lf.dot(Ci);if(0>=v&&0>=z)return c.copy(e);Di.subVectors(a,g);var E=kf.dot(Di),F=lf.dot(Di);if(0<=E&&F<=E)return c.copy(g);var J=v*F-E*z;if(0>=J&&0<=v&&0>=E)return g=v/(v-E),c.copy(e).addScaledVector(kf,g);Ei.subVectors(a,r);a=kf.dot(Ei);var P=lf.dot(Ei);if(0<=P&&a<=P)return c.copy(r);v=a*z-
v*P;if(0>=v&&0<=z&&0>=P)return J=z/(z-P),c.copy(e).addScaledVector(lf,J);z=E*P-a*F;if(0>=z&&0<=F-E&&0<=a-P)return ik.subVectors(r,g),J=(F-E)/(F-E+(a-P)),c.copy(g).addScaledVector(ik,J);r=1/(z+v+J);g=v*r;J*=r;return c.copy(e).addScaledVector(kf,g).addScaledVector(lf,J)},equals:function(a){return a.a.equals(this.a)&&a.b.equals(this.b)&&a.c.equals(this.c)}});var Em={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},lc={h:0,
s:0,l:0},mh={h:0,s:0,l:0};Object.assign(I.prototype,{isColor:!0,r:1,g:1,b:1,set:function(a){a&&a.isColor?this.copy(a):"number"===typeof a?this.setHex(a):"string"===typeof a&&this.setStyle(a);return this},setScalar:function(a){this.b=this.g=this.r=a;return this},setHex:function(a){a=Math.floor(a);this.r=(a>>16&255)/255;this.g=(a>>8&255)/255;this.b=(a&255)/255;return this},setRGB:function(a,c,e){this.r=a;this.g=c;this.b=e;return this},setHSL:function(a,c,e){a=hb.euclideanModulo(a,1);c=hb.clamp(c,0,
1);e=hb.clamp(e,0,1);0===c?this.r=this.g=this.b=e:(c=.5>=e?e*(1+c):e+c-e*c,e=2*e-c,this.r=N(e,c,a+1/3),this.g=N(e,c,a),this.b=N(e,c,a-1/3));return this},setStyle:function(a){function c(z){void 0!==z&&1>parseFloat(z)&&console.warn("THREE.Color: Alpha component of "+a+" will be ignored.")}var e;if(e=/^((?:rgb|hsl)a?)\(\s*([^\)]*)\)/.exec(a)){var g=e[2];switch(e[1]){case "rgb":case "rgba":if(e=/^(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(g))return this.r=Math.min(255,parseInt(e[1],
10))/255,this.g=Math.min(255,parseInt(e[2],10))/255,this.b=Math.min(255,parseInt(e[3],10))/255,c(e[5]),this;if(e=/^(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(g))return this.r=Math.min(100,parseInt(e[1],10))/100,this.g=Math.min(100,parseInt(e[2],10))/100,this.b=Math.min(100,parseInt(e[3],10))/100,c(e[5]),this;break;case "hsl":case "hsla":if(e=/^([0-9]*\.?[0-9]+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(g)){g=parseFloat(e[1])/360;var r=parseInt(e[2],
10)/100,v=parseInt(e[3],10)/100;c(e[5]);return this.setHSL(g,r,v)}}}else if(e=/^#([A-Fa-f0-9]+)$/.exec(a)){e=e[1];g=e.length;if(3===g)return this.r=parseInt(e.charAt(0)+e.charAt(0),16)/255,this.g=parseInt(e.charAt(1)+e.charAt(1),16)/255,this.b=parseInt(e.charAt(2)+e.charAt(2),16)/255,this;if(6===g)return this.r=parseInt(e.charAt(0)+e.charAt(1),16)/255,this.g=parseInt(e.charAt(2)+e.charAt(3),16)/255,this.b=parseInt(e.charAt(4)+e.charAt(5),16)/255,this}a&&0<a.length&&(e=Em[a],void 0!==e?this.setHex(e):
console.warn("THREE.Color: Unknown color "+a));return this},clone:function(){return new this.constructor(this.r,this.g,this.b)},copy:function(a){this.r=a.r;this.g=a.g;this.b=a.b;return this},copyGammaToLinear:function(a,c){void 0===c&&(c=2);this.r=Math.pow(a.r,c);this.g=Math.pow(a.g,c);this.b=Math.pow(a.b,c);return this},copyLinearToGamma:function(a,c){void 0===c&&(c=2);c=0<c?1/c:1;this.r=Math.pow(a.r,c);this.g=Math.pow(a.g,c);this.b=Math.pow(a.b,c);return this},convertGammaToLinear:function(a){this.copyGammaToLinear(this,
a);return this},convertLinearToGamma:function(a){this.copyLinearToGamma(this,a);return this},copySRGBToLinear:function(a){this.r=O(a.r);this.g=O(a.g);this.b=O(a.b);return this},copyLinearToSRGB:function(a){this.r=H(a.r);this.g=H(a.g);this.b=H(a.b);return this},convertSRGBToLinear:function(){this.copySRGBToLinear(this);return this},convertLinearToSRGB:function(){this.copyLinearToSRGB(this);return this},getHex:function(){return 255*this.r<<16^255*this.g<<8^255*this.b<<0},getHexString:function(){return("000000"+
this.getHex().toString(16)).slice(-6)},getHSL:function(a){void 0===a&&(console.warn("THREE.Color: .getHSL() target is now required"),a={h:0,s:0,l:0});var c=this.r,e=this.g,g=this.b,r=Math.max(c,e,g),v=Math.min(c,e,g),z,E=(v+r)/2;if(v===r)v=z=0;else{var F=r-v;v=.5>=E?F/(r+v):F/(2-r-v);switch(r){case c:z=(e-g)/F+(e<g?6:0);break;case e:z=(g-c)/F+2;break;case g:z=(c-e)/F+4}z/=6}a.h=z;a.s=v;a.l=E;return a},getStyle:function(){return"rgb("+(255*this.r|0)+","+(255*this.g|0)+","+(255*this.b|0)+")"},offsetHSL:function(a,
c,e){this.getHSL(lc);lc.h+=a;lc.s+=c;lc.l+=e;this.setHSL(lc.h,lc.s,lc.l);return this},add:function(a){this.r+=a.r;this.g+=a.g;this.b+=a.b;return this},addColors:function(a,c){this.r=a.r+c.r;this.g=a.g+c.g;this.b=a.b+c.b;return this},addScalar:function(a){this.r+=a;this.g+=a;this.b+=a;return this},sub:function(a){this.r=Math.max(0,this.r-a.r);this.g=Math.max(0,this.g-a.g);this.b=Math.max(0,this.b-a.b);return this},multiply:function(a){this.r*=a.r;this.g*=a.g;this.b*=a.b;return this},multiplyScalar:function(a){this.r*=
a;this.g*=a;this.b*=a;return this},lerp:function(a,c){this.r+=(a.r-this.r)*c;this.g+=(a.g-this.g)*c;this.b+=(a.b-this.b)*c;return this},lerpHSL:function(a,c){this.getHSL(lc);a.getHSL(mh);a=hb.lerp(lc.h,mh.h,c);var e=hb.lerp(lc.s,mh.s,c);c=hb.lerp(lc.l,mh.l,c);this.setHSL(a,e,c);return this},equals:function(a){return a.r===this.r&&a.g===this.g&&a.b===this.b},fromArray:function(a,c){void 0===c&&(c=0);this.r=a[c];this.g=a[c+1];this.b=a[c+2];return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===
c&&(c=0);a[c]=this.r;a[c+1]=this.g;a[c+2]=this.b;return a},toJSON:function(){return this.getHex()}});Object.assign(K.prototype,{clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.a=a.a;this.b=a.b;this.c=a.c;this.normal.copy(a.normal);this.color.copy(a.color);this.materialIndex=a.materialIndex;for(var c=0,e=a.vertexNormals.length;c<e;c++)this.vertexNormals[c]=a.vertexNormals[c].clone();c=0;for(e=a.vertexColors.length;c<e;c++)this.vertexColors[c]=a.vertexColors[c].clone();
return this}});var Pk=0;M.prototype=Object.assign(Object.create(d.prototype),{constructor:M,isMaterial:!0,onBeforeCompile:function(){},setValues:function(a){if(void 0!==a)for(var c in a){var e=a[c];if(void 0===e)console.warn("THREE.Material: '"+c+"' parameter is undefined.");else if("shading"===c)console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead."),this.flatShading=1===e?!0:!1;else{var g=this[c];void 0===g?console.warn("THREE."+this.type+": '"+c+"' is not a property of this material."):
g&&g.isColor?g.set(e):g&&g.isVector3&&e&&e.isVector3?g.copy(e):this[c]=e}}},toJSON:function(a){function c(r){var v=[],z;for(z in r){var E=r[z];delete E.metadata;v.push(E)}return v}var e=void 0===a||"string"===typeof a;e&&(a={textures:{},images:{}});var g={metadata:{version:4.5,type:"Material",generator:"Material.toJSON"}};g.uuid=this.uuid;g.type=this.type;""!==this.name&&(g.name=this.name);this.color&&this.color.isColor&&(g.color=this.color.getHex());void 0!==this.roughness&&(g.roughness=this.roughness);
void 0!==this.metalness&&(g.metalness=this.metalness);this.emissive&&this.emissive.isColor&&(g.emissive=this.emissive.getHex());this.emissiveIntensity&&1!==this.emissiveIntensity&&(g.emissiveIntensity=this.emissiveIntensity);this.specular&&this.specular.isColor&&(g.specular=this.specular.getHex());void 0!==this.shininess&&(g.shininess=this.shininess);void 0!==this.clearcoat&&(g.clearcoat=this.clearcoat);void 0!==this.clearcoatRoughness&&(g.clearcoatRoughness=this.clearcoatRoughness);this.clearcoatNormalMap&&
this.clearcoatNormalMap.isTexture&&(g.clearcoatNormalMap=this.clearcoatNormalMap.toJSON(a).uuid,g.clearcoatNormalScale=this.clearcoatNormalScale.toArray());this.map&&this.map.isTexture&&(g.map=this.map.toJSON(a).uuid);this.matcap&&this.matcap.isTexture&&(g.matcap=this.matcap.toJSON(a).uuid);this.alphaMap&&this.alphaMap.isTexture&&(g.alphaMap=this.alphaMap.toJSON(a).uuid);this.lightMap&&this.lightMap.isTexture&&(g.lightMap=this.lightMap.toJSON(a).uuid);this.aoMap&&this.aoMap.isTexture&&(g.aoMap=this.aoMap.toJSON(a).uuid,
g.aoMapIntensity=this.aoMapIntensity);this.bumpMap&&this.bumpMap.isTexture&&(g.bumpMap=this.bumpMap.toJSON(a).uuid,g.bumpScale=this.bumpScale);this.normalMap&&this.normalMap.isTexture&&(g.normalMap=this.normalMap.toJSON(a).uuid,g.normalMapType=this.normalMapType,g.normalScale=this.normalScale.toArray());this.displacementMap&&this.displacementMap.isTexture&&(g.displacementMap=this.displacementMap.toJSON(a).uuid,g.displacementScale=this.displacementScale,g.displacementBias=this.displacementBias);this.roughnessMap&&
this.roughnessMap.isTexture&&(g.roughnessMap=this.roughnessMap.toJSON(a).uuid);this.metalnessMap&&this.metalnessMap.isTexture&&(g.metalnessMap=this.metalnessMap.toJSON(a).uuid);this.emissiveMap&&this.emissiveMap.isTexture&&(g.emissiveMap=this.emissiveMap.toJSON(a).uuid);this.specularMap&&this.specularMap.isTexture&&(g.specularMap=this.specularMap.toJSON(a).uuid);this.envMap&&this.envMap.isTexture&&(g.envMap=this.envMap.toJSON(a).uuid,g.reflectivity=this.reflectivity,g.refractionRatio=this.refractionRatio,
void 0!==this.combine&&(g.combine=this.combine),void 0!==this.envMapIntensity&&(g.envMapIntensity=this.envMapIntensity));this.gradientMap&&this.gradientMap.isTexture&&(g.gradientMap=this.gradientMap.toJSON(a).uuid);void 0!==this.size&&(g.size=this.size);void 0!==this.sizeAttenuation&&(g.sizeAttenuation=this.sizeAttenuation);1!==this.blending&&(g.blending=this.blending);!0===this.flatShading&&(g.flatShading=this.flatShading);0!==this.side&&(g.side=this.side);0!==this.vertexColors&&(g.vertexColors=
this.vertexColors);1>this.opacity&&(g.opacity=this.opacity);!0===this.transparent&&(g.transparent=this.transparent);g.depthFunc=this.depthFunc;g.depthTest=this.depthTest;g.depthWrite=this.depthWrite;g.stencilWrite=this.stencilWrite;g.stencilFunc=this.stencilFunc;g.stencilRef=this.stencilRef;g.stencilMask=this.stencilMask;g.stencilFail=this.stencilFail;g.stencilZFail=this.stencilZFail;g.stencilZPass=this.stencilZPass;this.rotation&&0!==this.rotation&&(g.rotation=this.rotation);!0===this.polygonOffset&&
(g.polygonOffset=!0);0!==this.polygonOffsetFactor&&(g.polygonOffsetFactor=this.polygonOffsetFactor);0!==this.polygonOffsetUnits&&(g.polygonOffsetUnits=this.polygonOffsetUnits);this.linewidth&&1!==this.linewidth&&(g.linewidth=this.linewidth);void 0!==this.dashSize&&(g.dashSize=this.dashSize);void 0!==this.gapSize&&(g.gapSize=this.gapSize);void 0!==this.scale&&(g.scale=this.scale);!0===this.dithering&&(g.dithering=!0);0<this.alphaTest&&(g.alphaTest=this.alphaTest);!0===this.premultipliedAlpha&&(g.premultipliedAlpha=
this.premultipliedAlpha);!0===this.wireframe&&(g.wireframe=this.wireframe);1<this.wireframeLinewidth&&(g.wireframeLinewidth=this.wireframeLinewidth);"round"!==this.wireframeLinecap&&(g.wireframeLinecap=this.wireframeLinecap);"round"!==this.wireframeLinejoin&&(g.wireframeLinejoin=this.wireframeLinejoin);!0===this.morphTargets&&(g.morphTargets=!0);!0===this.morphNormals&&(g.morphNormals=!0);!0===this.skinning&&(g.skinning=!0);!1===this.visible&&(g.visible=!1);!1===this.toneMapped&&(g.toneMapped=!1);
"{}"!==JSON.stringify(this.userData)&&(g.userData=this.userData);e&&(e=c(a.textures),a=c(a.images),0<e.length&&(g.textures=e),0<a.length&&(g.images=a));return g},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.name=a.name;this.fog=a.fog;this.lights=a.lights;this.blending=a.blending;this.side=a.side;this.flatShading=a.flatShading;this.vertexColors=a.vertexColors;this.opacity=a.opacity;this.transparent=a.transparent;this.blendSrc=a.blendSrc;this.blendDst=a.blendDst;this.blendEquation=
a.blendEquation;this.blendSrcAlpha=a.blendSrcAlpha;this.blendDstAlpha=a.blendDstAlpha;this.blendEquationAlpha=a.blendEquationAlpha;this.depthFunc=a.depthFunc;this.depthTest=a.depthTest;this.depthWrite=a.depthWrite;this.stencilWrite=a.stencilWrite;this.stencilFunc=a.stencilFunc;this.stencilRef=a.stencilRef;this.stencilMask=a.stencilMask;this.stencilFail=a.stencilFail;this.stencilZFail=a.stencilZFail;this.stencilZPass=a.stencilZPass;this.colorWrite=a.colorWrite;this.precision=a.precision;this.polygonOffset=
a.polygonOffset;this.polygonOffsetFactor=a.polygonOffsetFactor;this.polygonOffsetUnits=a.polygonOffsetUnits;this.dithering=a.dithering;this.alphaTest=a.alphaTest;this.premultipliedAlpha=a.premultipliedAlpha;this.visible=a.visible;this.toneMapped=a.toneMapped;this.userData=JSON.parse(JSON.stringify(a.userData));this.clipShadows=a.clipShadows;this.clipIntersection=a.clipIntersection;var c=a.clippingPlanes,e=null;if(null!==c){var g=c.length;e=Array(g);for(var r=0;r!==g;++r)e[r]=c[r].clone()}this.clippingPlanes=
e;this.shadowSide=a.shadowSide;return this},dispose:function(){this.dispatchEvent({type:"dispose"})}});L.prototype=Object.create(M.prototype);L.prototype.constructor=L;L.prototype.isMeshBasicMaterial=!0;L.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);this.map=a.map;this.lightMap=a.lightMap;this.lightMapIntensity=a.lightMapIntensity;this.aoMap=a.aoMap;this.aoMapIntensity=a.aoMapIntensity;this.specularMap=a.specularMap;this.alphaMap=a.alphaMap;this.envMap=a.envMap;
this.combine=a.combine;this.reflectivity=a.reflectivity;this.refractionRatio=a.refractionRatio;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.wireframeLinecap=a.wireframeLinecap;this.wireframeLinejoin=a.wireframeLinejoin;this.skinning=a.skinning;this.morphTargets=a.morphTargets;return this};Object.defineProperty(Q.prototype,"needsUpdate",{set:function(a){!0===a&&this.version++}});Object.assign(Q.prototype,{isBufferAttribute:!0,onUploadCallback:function(){},setArray:function(a){if(Array.isArray(a))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");
this.count=void 0!==a?a.length/this.itemSize:0;this.array=a;return this},setDynamic:function(a){this.dynamic=a;return this},copy:function(a){this.name=a.name;this.array=new a.array.constructor(a.array);this.itemSize=a.itemSize;this.count=a.count;this.normalized=a.normalized;this.dynamic=a.dynamic;return this},copyAt:function(a,c,e){a*=this.itemSize;e*=c.itemSize;for(var g=0,r=this.itemSize;g<r;g++)this.array[a+g]=c.array[e+g];return this},copyArray:function(a){this.array.set(a);return this},copyColorsArray:function(a){for(var c=
this.array,e=0,g=0,r=a.length;g<r;g++){var v=a[g];void 0===v&&(console.warn("THREE.BufferAttribute.copyColorsArray(): color is undefined",g),v=new I);c[e++]=v.r;c[e++]=v.g;c[e++]=v.b}return this},copyVector2sArray:function(a){for(var c=this.array,e=0,g=0,r=a.length;g<r;g++){var v=a[g];void 0===v&&(console.warn("THREE.BufferAttribute.copyVector2sArray(): vector is undefined",g),v=new f);c[e++]=v.x;c[e++]=v.y}return this},copyVector3sArray:function(a){for(var c=this.array,e=0,g=0,r=a.length;g<r;g++){var v=
a[g];void 0===v&&(console.warn("THREE.BufferAttribute.copyVector3sArray(): vector is undefined",g),v=new k);c[e++]=v.x;c[e++]=v.y;c[e++]=v.z}return this},copyVector4sArray:function(a){for(var c=this.array,e=0,g=0,r=a.length;g<r;g++){var v=a[g];void 0===v&&(console.warn("THREE.BufferAttribute.copyVector4sArray(): vector is undefined",g),v=new p);c[e++]=v.x;c[e++]=v.y;c[e++]=v.z;c[e++]=v.w}return this},set:function(a,c){void 0===c&&(c=0);this.array.set(a,c);return this},getX:function(a){return this.array[a*
this.itemSize]},setX:function(a,c){this.array[a*this.itemSize]=c;return this},getY:function(a){return this.array[a*this.itemSize+1]},setY:function(a,c){this.array[a*this.itemSize+1]=c;return this},getZ:function(a){return this.array[a*this.itemSize+2]},setZ:function(a,c){this.array[a*this.itemSize+2]=c;return this},getW:function(a){return this.array[a*this.itemSize+3]},setW:function(a,c){this.array[a*this.itemSize+3]=c;return this},setXY:function(a,c,e){a*=this.itemSize;this.array[a+0]=c;this.array[a+
1]=e;return this},setXYZ:function(a,c,e,g){a*=this.itemSize;this.array[a+0]=c;this.array[a+1]=e;this.array[a+2]=g;return this},setXYZW:function(a,c,e,g,r){a*=this.itemSize;this.array[a+0]=c;this.array[a+1]=e;this.array[a+2]=g;this.array[a+3]=r;return this},onUpload:function(a){this.onUploadCallback=a;return this},clone:function(){return(new this.constructor(this.array,this.itemSize)).copy(this)},toJSON:function(){return{itemSize:this.itemSize,type:this.array.constructor.name,array:Array.prototype.slice.call(this.array),
normalized:this.normalized}}});T.prototype=Object.create(Q.prototype);T.prototype.constructor=T;X.prototype=Object.create(Q.prototype);X.prototype.constructor=X;aa.prototype=Object.create(Q.prototype);aa.prototype.constructor=aa;la.prototype=Object.create(Q.prototype);la.prototype.constructor=la;Z.prototype=Object.create(Q.prototype);Z.prototype.constructor=Z;ba.prototype=Object.create(Q.prototype);ba.prototype.constructor=ba;ea.prototype=Object.create(Q.prototype);ea.prototype.constructor=ea;ca.prototype=
Object.create(Q.prototype);ca.prototype.constructor=ca;ka.prototype=Object.create(Q.prototype);ka.prototype.constructor=ka;Object.assign(Y.prototype,{computeGroups:function(a){var c=[],e=void 0;a=a.faces;for(var g=0;g<a.length;g++){var r=a[g];if(r.materialIndex!==e){e=r.materialIndex;void 0!==v&&(v.count=3*g-v.start,c.push(v));var v={start:3*g,materialIndex:e}}}void 0!==v&&(v.count=3*g-v.start,c.push(v));this.groups=c},fromGeometry:function(a){var c=a.faces,e=a.vertices,g=a.faceVertexUvs,r=g[0]&&
0<g[0].length,v=g[1]&&0<g[1].length,z=a.morphTargets,E=z.length;if(0<E){var F=[];for(var J=0;J<E;J++)F[J]={name:z[J].name,data:[]};this.morphTargets.position=F}var P=a.morphNormals,R=P.length;if(0<R){var S=[];for(J=0;J<R;J++)S[J]={name:P[J].name,data:[]};this.morphTargets.normal=S}var V=a.skinIndices,W=a.skinWeights,ha=V.length===e.length,fa=W.length===e.length;0<e.length&&0===c.length&&console.error("THREE.DirectGeometry: Faceless geometries are not supported.");for(J=0;J<c.length;J++){var ra=c[J];
this.vertices.push(e[ra.a],e[ra.b],e[ra.c]);var pa=ra.vertexNormals;3===pa.length?this.normals.push(pa[0],pa[1],pa[2]):(pa=ra.normal,this.normals.push(pa,pa,pa));pa=ra.vertexColors;3===pa.length?this.colors.push(pa[0],pa[1],pa[2]):(pa=ra.color,this.colors.push(pa,pa,pa));!0===r&&(pa=g[0][J],void 0!==pa?this.uvs.push(pa[0],pa[1],pa[2]):(console.warn("THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ",J),this.uvs.push(new f,new f,new f)));!0===v&&(pa=g[1][J],void 0!==pa?this.uvs2.push(pa[0],
pa[1],pa[2]):(console.warn("THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ",J),this.uvs2.push(new f,new f,new f)));for(pa=0;pa<E;pa++){var qa=z[pa].vertices;F[pa].data.push(qa[ra.a],qa[ra.b],qa[ra.c])}for(pa=0;pa<R;pa++)qa=P[pa].vertexNormals[J],S[pa].data.push(qa.a,qa.b,qa.c);ha&&this.skinIndices.push(V[ra.a],V[ra.b],V[ra.c]);fa&&this.skinWeights.push(W[ra.a],W[ra.b],W[ra.c])}this.computeGroups(a);this.verticesNeedUpdate=a.verticesNeedUpdate;this.normalsNeedUpdate=a.normalsNeedUpdate;
this.colorsNeedUpdate=a.colorsNeedUpdate;this.uvsNeedUpdate=a.uvsNeedUpdate;this.groupsNeedUpdate=a.groupsNeedUpdate;null!==a.boundingSphere&&(this.boundingSphere=a.boundingSphere.clone());null!==a.boundingBox&&(this.boundingBox=a.boundingBox.clone());return this}});var Qk=1,Xc=new q,Fi=new A,nh=new k,ge=new w,Gi=new w,Jc=new k;va.prototype=Object.assign(Object.create(d.prototype),{constructor:va,isBufferGeometry:!0,getIndex:function(){return this.index},setIndex:function(a){this.index=Array.isArray(a)?
new (65535<Ea(a)?ea:Z)(a,1):a},addAttribute:function(a,c,e){if(!(c&&c.isBufferAttribute||c&&c.isInterleavedBufferAttribute))return console.warn("THREE.BufferGeometry: .addAttribute() now expects ( name, attribute )."),this.addAttribute(a,new Q(c,e));if("index"===a)return console.warn("THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute."),this.setIndex(c),this;this.attributes[a]=c;return this},getAttribute:function(a){return this.attributes[a]},removeAttribute:function(a){delete this.attributes[a];
return this},addGroup:function(a,c,e){this.groups.push({start:a,count:c,materialIndex:void 0!==e?e:0})},clearGroups:function(){this.groups=[]},setDrawRange:function(a,c){this.drawRange.start=a;this.drawRange.count=c},applyMatrix:function(a){var c=this.attributes.position;void 0!==c&&(a.applyToBufferAttribute(c),c.needsUpdate=!0);var e=this.attributes.normal;void 0!==e&&(c=(new t).getNormalMatrix(a),c.applyToBufferAttribute(e),e.needsUpdate=!0);e=this.attributes.tangent;void 0!==e&&(c=(new t).getNormalMatrix(a),
c.applyToBufferAttribute(e),e.needsUpdate=!0);null!==this.boundingBox&&this.computeBoundingBox();null!==this.boundingSphere&&this.computeBoundingSphere();return this},rotateX:function(a){Xc.makeRotationX(a);this.applyMatrix(Xc);return this},rotateY:function(a){Xc.makeRotationY(a);this.applyMatrix(Xc);return this},rotateZ:function(a){Xc.makeRotationZ(a);this.applyMatrix(Xc);return this},translate:function(a,c,e){Xc.makeTranslation(a,c,e);this.applyMatrix(Xc);return this},scale:function(a,c,e){Xc.makeScale(a,
c,e);this.applyMatrix(Xc);return this},lookAt:function(a){Fi.lookAt(a);Fi.updateMatrix();this.applyMatrix(Fi.matrix);return this},center:function(){this.computeBoundingBox();this.boundingBox.getCenter(nh).negate();this.translate(nh.x,nh.y,nh.z);return this},setFromObject:function(a){var c=a.geometry;if(a.isPoints||a.isLine){a=new ca(3*c.vertices.length,3);var e=new ca(3*c.colors.length,3);this.addAttribute("position",a.copyVector3sArray(c.vertices));this.addAttribute("color",e.copyColorsArray(c.colors));
c.lineDistances&&c.lineDistances.length===c.vertices.length&&(a=new ca(c.lineDistances.length,1),this.addAttribute("lineDistance",a.copyArray(c.lineDistances)));null!==c.boundingSphere&&(this.boundingSphere=c.boundingSphere.clone());null!==c.boundingBox&&(this.boundingBox=c.boundingBox.clone())}else a.isMesh&&c&&c.isGeometry&&this.fromGeometry(c);return this},setFromPoints:function(a){for(var c=[],e=0,g=a.length;e<g;e++){var r=a[e];c.push(r.x,r.y,r.z||0)}this.addAttribute("position",new ca(c,3));
return this},updateFromObject:function(a){var c=a.geometry;if(a.isMesh){var e=c.__directGeometry;!0===c.elementsNeedUpdate&&(e=void 0,c.elementsNeedUpdate=!1);if(void 0===e)return this.fromGeometry(c);e.verticesNeedUpdate=c.verticesNeedUpdate;e.normalsNeedUpdate=c.normalsNeedUpdate;e.colorsNeedUpdate=c.colorsNeedUpdate;e.uvsNeedUpdate=c.uvsNeedUpdate;e.groupsNeedUpdate=c.groupsNeedUpdate;c.verticesNeedUpdate=!1;c.normalsNeedUpdate=!1;c.colorsNeedUpdate=!1;c.uvsNeedUpdate=!1;c.groupsNeedUpdate=!1;
c=e}!0===c.verticesNeedUpdate&&(e=this.attributes.position,void 0!==e&&(e.copyVector3sArray(c.vertices),e.needsUpdate=!0),c.verticesNeedUpdate=!1);!0===c.normalsNeedUpdate&&(e=this.attributes.normal,void 0!==e&&(e.copyVector3sArray(c.normals),e.needsUpdate=!0),c.normalsNeedUpdate=!1);!0===c.colorsNeedUpdate&&(e=this.attributes.color,void 0!==e&&(e.copyColorsArray(c.colors),e.needsUpdate=!0),c.colorsNeedUpdate=!1);c.uvsNeedUpdate&&(e=this.attributes.uv,void 0!==e&&(e.copyVector2sArray(c.uvs),e.needsUpdate=
!0),c.uvsNeedUpdate=!1);c.lineDistancesNeedUpdate&&(e=this.attributes.lineDistance,void 0!==e&&(e.copyArray(c.lineDistances),e.needsUpdate=!0),c.lineDistancesNeedUpdate=!1);c.groupsNeedUpdate&&(c.computeGroups(a.geometry),this.groups=c.groups,c.groupsNeedUpdate=!1);return this},fromGeometry:function(a){a.__directGeometry=(new Y).fromGeometry(a);return this.fromDirectGeometry(a.__directGeometry)},fromDirectGeometry:function(a){this.addAttribute("position",(new Q(new Float32Array(3*a.vertices.length),
3)).copyVector3sArray(a.vertices));0<a.normals.length&&this.addAttribute("normal",(new Q(new Float32Array(3*a.normals.length),3)).copyVector3sArray(a.normals));0<a.colors.length&&this.addAttribute("color",(new Q(new Float32Array(3*a.colors.length),3)).copyColorsArray(a.colors));0<a.uvs.length&&this.addAttribute("uv",(new Q(new Float32Array(2*a.uvs.length),2)).copyVector2sArray(a.uvs));0<a.uvs2.length&&this.addAttribute("uv2",(new Q(new Float32Array(2*a.uvs2.length),2)).copyVector2sArray(a.uvs2));
this.groups=a.groups;for(var c in a.morphTargets){for(var e=[],g=a.morphTargets[c],r=0,v=g.length;r<v;r++){var z=g[r],E=new ca(3*z.data.length,3);E.name=z.name;e.push(E.copyVector3sArray(z.data))}this.morphAttributes[c]=e}0<a.skinIndices.length&&(c=new ca(4*a.skinIndices.length,4),this.addAttribute("skinIndex",c.copyVector4sArray(a.skinIndices)));0<a.skinWeights.length&&(c=new ca(4*a.skinWeights.length,4),this.addAttribute("skinWeight",c.copyVector4sArray(a.skinWeights)));null!==a.boundingSphere&&
(this.boundingSphere=a.boundingSphere.clone());null!==a.boundingBox&&(this.boundingBox=a.boundingBox.clone());return this},computeBoundingBox:function(){null===this.boundingBox&&(this.boundingBox=new w);var a=this.attributes.position,c=this.morphAttributes.position;if(void 0!==a){if(this.boundingBox.setFromBufferAttribute(a),c){a=0;for(var e=c.length;a<e;a++)ge.setFromBufferAttribute(c[a]),this.boundingBox.expandByPoint(ge.min),this.boundingBox.expandByPoint(ge.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:function(){null===this.boundingSphere&&(this.boundingSphere=new G);var a=this.attributes.position,c=this.morphAttributes.position;if(a){var e=this.boundingSphere.center;ge.setFromBufferAttribute(a);if(c)for(var g=0,r=c.length;g<r;g++){var v=
c[g];Gi.setFromBufferAttribute(v);ge.expandByPoint(Gi.min);ge.expandByPoint(Gi.max)}ge.getCenter(e);var z=0;g=0;for(r=a.count;g<r;g++)Jc.fromBufferAttribute(a,g),z=Math.max(z,e.distanceToSquared(Jc));if(c)for(g=0,r=c.length;g<r;g++){v=c[g];a=0;for(var E=v.count;a<E;a++)Jc.fromBufferAttribute(v,a),z=Math.max(z,e.distanceToSquared(Jc))}this.boundingSphere.radius=Math.sqrt(z);isNaN(this.boundingSphere.radius)&&console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.',
this)}},computeFaceNormals:function(){},computeVertexNormals:function(){var a=this.index,c=this.attributes;if(c.position){var e=c.position.array;if(void 0===c.normal)this.addAttribute("normal",new Q(new Float32Array(e.length),3));else for(var g=c.normal.array,r=0,v=g.length;r<v;r++)g[r]=0;g=c.normal.array;var z=new k,E=new k,F=new k,J=new k,P=new k;if(a){var R=a.array;r=0;for(v=a.count;r<v;r+=3){a=3*R[r+0];var S=3*R[r+1];var V=3*R[r+2];z.fromArray(e,a);E.fromArray(e,S);F.fromArray(e,V);J.subVectors(F,
E);P.subVectors(z,E);J.cross(P);g[a]+=J.x;g[a+1]+=J.y;g[a+2]+=J.z;g[S]+=J.x;g[S+1]+=J.y;g[S+2]+=J.z;g[V]+=J.x;g[V+1]+=J.y;g[V+2]+=J.z}}else for(r=0,v=e.length;r<v;r+=9)z.fromArray(e,r),E.fromArray(e,r+3),F.fromArray(e,r+6),J.subVectors(F,E),P.subVectors(z,E),J.cross(P),g[r]=J.x,g[r+1]=J.y,g[r+2]=J.z,g[r+3]=J.x,g[r+4]=J.y,g[r+5]=J.z,g[r+6]=J.x,g[r+7]=J.y,g[r+8]=J.z;this.normalizeNormals();c.normal.needsUpdate=!0}},merge:function(a,c){if(a&&a.isBufferGeometry){void 0===c&&(c=0,console.warn("THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset\x3d0. Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge."));
var e=this.attributes,g;for(g in e)if(void 0!==a.attributes[g]){var r=e[g].array,v=a.attributes[g],z=v.array,E=v.itemSize*c;v=Math.min(z.length,r.length-E);for(var F=0;F<v;F++,E++)r[E]=z[F]}return this}console.error("THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.",a)},normalizeNormals:function(){for(var a=this.attributes.normal,c=0,e=a.count;c<e;c++)Jc.x=a.getX(c),Jc.y=a.getY(c),Jc.z=a.getZ(c),Jc.normalize(),a.setXYZ(c,Jc.x,Jc.y,Jc.z)},toNonIndexed:function(){function a(P,
R){var S=P.array;P=P.itemSize;for(var V=new S.constructor(R.length*P),W,ha=0,fa=0,ra=R.length;fa<ra;fa++){W=R[fa]*P;for(var pa=0;pa<P;pa++)V[ha++]=S[W++]}return new Q(V,P)}if(null===this.index)return console.warn("THREE.BufferGeometry.toNonIndexed(): Geometry is already non-indexed."),this;var c=new va,e=this.index.array,g=this.attributes,r;for(r in g){var v=g[r];v=a(v,e);c.addAttribute(r,v)}var z=this.morphAttributes;for(r in z){var E=[],F=z[r];g=0;for(var J=F.length;g<J;g++)v=F[g],v=a(v,e),E.push(v);
c.morphAttributes[r]=E}e=this.groups;g=0;for(r=e.length;g<r;g++)v=e[g],c.addGroup(v.start,v.count,v.materialIndex);return c},toJSON:function(){var a={metadata:{version:4.5,type:"BufferGeometry",generator:"BufferGeometry.toJSON"}};a.uuid=this.uuid;a.type=this.type;""!==this.name&&(a.name=this.name);0<Object.keys(this.userData).length&&(a.userData=this.userData);if(void 0!==this.parameters){var c=this.parameters;for(J in c)void 0!==c[J]&&(a[J]=c[J]);return a}a.data={attributes:{}};c=this.index;null!==
c&&(a.data.index={type:c.array.constructor.name,array:Array.prototype.slice.call(c.array)});var e=this.attributes;for(J in e){c=e[J];var g=c.toJSON();""!==c.name&&(g.name=c.name);a.data.attributes[J]=g}e={};var r=!1;for(J in this.morphAttributes){for(var v=this.morphAttributes[J],z=[],E=0,F=v.length;E<F;E++)c=v[E],g=c.toJSON(),""!==c.name&&(g.name=c.name),z.push(g);0<z.length&&(e[J]=z,r=!0)}r&&(a.data.morphAttributes=e);var J=this.groups;0<J.length&&(a.data.groups=JSON.parse(JSON.stringify(J)));J=
this.boundingSphere;null!==J&&(a.data.boundingSphere={center:J.center.toArray(),radius:J.radius});return a},clone:function(){return(new va).copy(this)},copy:function(a){var c;this.index=null;this.attributes={};this.morphAttributes={};this.groups=[];this.boundingSphere=this.boundingBox=null;this.name=a.name;var e=a.index;null!==e&&this.setIndex(e.clone());e=a.attributes;for(z in e)this.addAttribute(z,e[z].clone());var g=a.morphAttributes;for(z in g){var r=[],v=g[z];e=0;for(c=v.length;e<c;e++)r.push(v[e].clone());
this.morphAttributes[z]=r}var z=a.groups;e=0;for(c=z.length;e<c;e++)g=z[e],this.addGroup(g.start,g.count,g.materialIndex);z=a.boundingBox;null!==z&&(this.boundingBox=z.clone());z=a.boundingSphere;null!==z&&(this.boundingSphere=z.clone());this.drawRange.start=a.drawRange.start;this.drawRange.count=a.drawRange.count;this.userData=a.userData;return this},dispose:function(){this.dispatchEvent({type:"dispose"})}});var jk=new q,he=new D,Hi=new G,Ld=new k,Md=new k,Nd=new k,$i=new k,aj=new k,bj=new k,Ih=
new k,Jh=new k,Kh=new k,oe=new f,pe=new f,qe=new f,sf=new k,sg=new k;xa.prototype=Object.assign(Object.create(A.prototype),{constructor:xa,isMesh:!0,setDrawMode:function(a){this.drawMode=a},copy:function(a){A.prototype.copy.call(this,a);this.drawMode=a.drawMode;void 0!==a.morphTargetInfluences&&(this.morphTargetInfluences=a.morphTargetInfluences.slice());void 0!==a.morphTargetDictionary&&(this.morphTargetDictionary=Object.assign({},a.morphTargetDictionary));return this},updateMorphTargets:function(){var a=
this.geometry;if(a.isBufferGeometry){a=a.morphAttributes;var c=Object.keys(a);if(0<c.length){var e=a[c[0]];if(void 0!==e)for(this.morphTargetInfluences=[],this.morphTargetDictionary={},a=0,c=e.length;a<c;a++){var g=e[a].name||String(a);this.morphTargetInfluences.push(0);this.morphTargetDictionary[g]=a}}}else a=a.morphTargets,void 0!==a&&0<a.length&&console.error("THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.")},raycast:function(a,c){var e=this.geometry,
g=this.material,r=this.matrixWorld;if(void 0!==g&&(null===e.boundingSphere&&e.computeBoundingSphere(),Hi.copy(e.boundingSphere),Hi.applyMatrix4(r),!1!==a.ray.intersectsSphere(Hi)&&(jk.getInverse(r),he.copy(a.ray).applyMatrix4(jk),null===e.boundingBox||!1!==he.intersectsBox(e.boundingBox))))if(e.isBufferGeometry){var v=e.index;r=e.attributes.position;var z=e.morphAttributes.position,E=e.attributes.uv,F=e.attributes.uv2,J=e.groups,P=e.drawRange,R,S;if(null!==v)if(Array.isArray(g)){var V=0;for(R=J.length;V<
R;V++){var W=J[V];var ha=g[W.materialIndex];var fa=Math.max(W.start,P.start);for(S=e=Math.min(W.start+W.count,P.start+P.count);fa<S;fa+=3){e=v.getX(fa);var ra=v.getX(fa+1);var pa=v.getX(fa+2);if(e=Fa(this,ha,a,he,r,z,E,F,e,ra,pa))e.faceIndex=Math.floor(fa/3),e.face.materialIndex=W.materialIndex,c.push(e)}}}else for(fa=Math.max(0,P.start),e=Math.min(v.count,P.start+P.count),V=fa,R=e;V<R;V+=3){if(e=v.getX(V),ra=v.getX(V+1),pa=v.getX(V+2),e=Fa(this,g,a,he,r,z,E,F,e,ra,pa))e.faceIndex=Math.floor(V/3),
c.push(e)}else if(void 0!==r)if(Array.isArray(g))for(V=0,R=J.length;V<R;V++)for(W=J[V],ha=g[W.materialIndex],fa=Math.max(W.start,P.start),S=e=Math.min(W.start+W.count,P.start+P.count);fa<S;fa+=3){if(e=fa,ra=fa+1,pa=fa+2,e=Fa(this,ha,a,he,r,z,E,F,e,ra,pa))e.faceIndex=Math.floor(fa/3),e.face.materialIndex=W.materialIndex,c.push(e)}else for(fa=Math.max(0,P.start),e=Math.min(r.count,P.start+P.count),V=fa,R=e;V<R;V+=3)if(e=V,ra=V+1,pa=V+2,e=Fa(this,g,a,he,r,z,E,F,e,ra,pa))e.faceIndex=Math.floor(V/3),c.push(e)}else if(e.isGeometry)for(r=
Array.isArray(g),z=e.vertices,E=e.faces,e=e.faceVertexUvs[0],0<e.length&&(v=e),V=0,R=E.length;V<R;V++)if(W=E[V],e=r?g[W.materialIndex]:g,void 0!==e&&(F=z[W.a],J=z[W.b],P=z[W.c],e=Aa(this,e,a,he,F,J,P,sf)))v&&v[V]&&(ha=v[V],oe.copy(ha[0]),pe.copy(ha[1]),qe.copy(ha[2]),e.uv=B.getUV(sf,F,J,P,oe,pe,qe,new f)),e.face=W,e.faceIndex=V,c.push(e)},clone:function(){return(new this.constructor(this.geometry,this.material)).copy(this)}});var Rk=0,Yc=new q,Ii=new A,oh=new k;ya.prototype=Object.assign(Object.create(d.prototype),
{constructor:ya,isGeometry:!0,applyMatrix:function(a){for(var c=(new t).getNormalMatrix(a),e=0,g=this.vertices.length;e<g;e++)this.vertices[e].applyMatrix4(a);e=0;for(g=this.faces.length;e<g;e++){a=this.faces[e];a.normal.applyMatrix3(c).normalize();for(var r=0,v=a.vertexNormals.length;r<v;r++)a.vertexNormals[r].applyMatrix3(c).normalize()}null!==this.boundingBox&&this.computeBoundingBox();null!==this.boundingSphere&&this.computeBoundingSphere();this.normalsNeedUpdate=this.verticesNeedUpdate=!0;return this},
rotateX:function(a){Yc.makeRotationX(a);this.applyMatrix(Yc);return this},rotateY:function(a){Yc.makeRotationY(a);this.applyMatrix(Yc);return this},rotateZ:function(a){Yc.makeRotationZ(a);this.applyMatrix(Yc);return this},translate:function(a,c,e){Yc.makeTranslation(a,c,e);this.applyMatrix(Yc);return this},scale:function(a,c,e){Yc.makeScale(a,c,e);this.applyMatrix(Yc);return this},lookAt:function(a){Ii.lookAt(a);Ii.updateMatrix();this.applyMatrix(Ii.matrix);return this},fromBufferGeometry:function(a){function c(V,
W,ha,fa){var ra=void 0===E?[]:[e.colors[V].clone(),e.colors[W].clone(),e.colors[ha].clone()],pa=void 0===z?[]:[(new k).fromArray(z,3*V),(new k).fromArray(z,3*W),(new k).fromArray(z,3*ha)];fa=new K(V,W,ha,pa,ra,fa);e.faces.push(fa);void 0!==F&&e.faceVertexUvs[0].push([(new f).fromArray(F,2*V),(new f).fromArray(F,2*W),(new f).fromArray(F,2*ha)]);void 0!==J&&e.faceVertexUvs[1].push([(new f).fromArray(J,2*V),(new f).fromArray(J,2*W),(new f).fromArray(J,2*ha)])}var e=this,g=null!==a.index?a.index.array:
void 0,r=a.attributes,v=r.position.array,z=void 0!==r.normal?r.normal.array:void 0,E=void 0!==r.color?r.color.array:void 0,F=void 0!==r.uv?r.uv.array:void 0,J=void 0!==r.uv2?r.uv2.array:void 0;void 0!==J&&(this.faceVertexUvs[1]=[]);for(r=0;r<v.length;r+=3)e.vertices.push((new k).fromArray(v,r)),void 0!==E&&e.colors.push((new I).fromArray(E,r));var P=a.groups;if(0<P.length)for(r=0;r<P.length;r++){v=P[r];var R=v.start,S=R;for(R+=v.count;S<R;S+=3)void 0!==g?c(g[S],g[S+1],g[S+2],v.materialIndex):c(S,
S+1,S+2,v.materialIndex)}else if(void 0!==g)for(r=0;r<g.length;r+=3)c(g[r],g[r+1],g[r+2]);else for(r=0;r<v.length/3;r+=3)c(r,r+1,r+2);this.computeFaceNormals();null!==a.boundingBox&&(this.boundingBox=a.boundingBox.clone());null!==a.boundingSphere&&(this.boundingSphere=a.boundingSphere.clone());return this},center:function(){this.computeBoundingBox();this.boundingBox.getCenter(oh).negate();this.translate(oh.x,oh.y,oh.z);return this},normalize:function(){this.computeBoundingSphere();var a=this.boundingSphere.center,
c=this.boundingSphere.radius;c=0===c?1:1/c;var e=new q;e.set(c,0,0,-c*a.x,0,c,0,-c*a.y,0,0,c,-c*a.z,0,0,0,1);this.applyMatrix(e);return this},computeFaceNormals:function(){for(var a=new k,c=new k,e=0,g=this.faces.length;e<g;e++){var r=this.faces[e],v=this.vertices[r.a],z=this.vertices[r.b];a.subVectors(this.vertices[r.c],z);c.subVectors(v,z);a.cross(c);a.normalize();r.normal.copy(a)}},computeVertexNormals:function(a){void 0===a&&(a=!0);var c;var e=Array(this.vertices.length);var g=0;for(c=this.vertices.length;g<
c;g++)e[g]=new k;if(a){var r=new k,v=new k;a=0;for(g=this.faces.length;a<g;a++){c=this.faces[a];var z=this.vertices[c.a];var E=this.vertices[c.b];var F=this.vertices[c.c];r.subVectors(F,E);v.subVectors(z,E);r.cross(v);e[c.a].add(r);e[c.b].add(r);e[c.c].add(r)}}else for(this.computeFaceNormals(),a=0,g=this.faces.length;a<g;a++)c=this.faces[a],e[c.a].add(c.normal),e[c.b].add(c.normal),e[c.c].add(c.normal);g=0;for(c=this.vertices.length;g<c;g++)e[g].normalize();a=0;for(g=this.faces.length;a<g;a++)c=
this.faces[a],z=c.vertexNormals,3===z.length?(z[0].copy(e[c.a]),z[1].copy(e[c.b]),z[2].copy(e[c.c])):(z[0]=e[c.a].clone(),z[1]=e[c.b].clone(),z[2]=e[c.c].clone());0<this.faces.length&&(this.normalsNeedUpdate=!0)},computeFlatVertexNormals:function(){var a;this.computeFaceNormals();var c=0;for(a=this.faces.length;c<a;c++){var e=this.faces[c];var g=e.vertexNormals;3===g.length?(g[0].copy(e.normal),g[1].copy(e.normal),g[2].copy(e.normal)):(g[0]=e.normal.clone(),g[1]=e.normal.clone(),g[2]=e.normal.clone())}0<
this.faces.length&&(this.normalsNeedUpdate=!0)},computeMorphNormals:function(){var a,c;var e=0;for(c=this.faces.length;e<c;e++){var g=this.faces[e];g.__originalFaceNormal?g.__originalFaceNormal.copy(g.normal):g.__originalFaceNormal=g.normal.clone();g.__originalVertexNormals||(g.__originalVertexNormals=[]);var r=0;for(a=g.vertexNormals.length;r<a;r++)g.__originalVertexNormals[r]?g.__originalVertexNormals[r].copy(g.vertexNormals[r]):g.__originalVertexNormals[r]=g.vertexNormals[r].clone()}var v=new ya;
v.faces=this.faces;r=0;for(a=this.morphTargets.length;r<a;r++){if(!this.morphNormals[r]){this.morphNormals[r]={};this.morphNormals[r].faceNormals=[];this.morphNormals[r].vertexNormals=[];g=this.morphNormals[r].faceNormals;var z=this.morphNormals[r].vertexNormals;e=0;for(c=this.faces.length;e<c;e++){var E=new k;var F={a:new k,b:new k,c:new k};g.push(E);z.push(F)}}z=this.morphNormals[r];v.vertices=this.morphTargets[r].vertices;v.computeFaceNormals();v.computeVertexNormals();e=0;for(c=this.faces.length;e<
c;e++)g=this.faces[e],E=z.faceNormals[e],F=z.vertexNormals[e],E.copy(g.normal),F.a.copy(g.vertexNormals[0]),F.b.copy(g.vertexNormals[1]),F.c.copy(g.vertexNormals[2])}e=0;for(c=this.faces.length;e<c;e++)g=this.faces[e],g.normal=g.__originalFaceNormal,g.vertexNormals=g.__originalVertexNormals},computeBoundingBox:function(){null===this.boundingBox&&(this.boundingBox=new w);this.boundingBox.setFromPoints(this.vertices)},computeBoundingSphere:function(){null===this.boundingSphere&&(this.boundingSphere=
new G);this.boundingSphere.setFromPoints(this.vertices)},merge:function(a,c,e){if(a&&a.isGeometry){var g,r=this.vertices.length,v=this.vertices,z=a.vertices,E=this.faces,F=a.faces,J=this.colors,P=a.colors;void 0===e&&(e=0);void 0!==c&&(g=(new t).getNormalMatrix(c));for(var R=0,S=z.length;R<S;R++){var V=z[R].clone();void 0!==c&&V.applyMatrix4(c);v.push(V)}R=0;for(S=P.length;R<S;R++)J.push(P[R].clone());R=0;for(S=F.length;R<S;R++){z=F[R];var W=z.vertexNormals;P=z.vertexColors;J=new K(z.a+r,z.b+r,z.c+
r);J.normal.copy(z.normal);void 0!==g&&J.normal.applyMatrix3(g).normalize();c=0;for(v=W.length;c<v;c++)V=W[c].clone(),void 0!==g&&V.applyMatrix3(g).normalize(),J.vertexNormals.push(V);J.color.copy(z.color);c=0;for(v=P.length;c<v;c++)V=P[c],J.vertexColors.push(V.clone());J.materialIndex=z.materialIndex+e;E.push(J)}R=0;for(S=a.faceVertexUvs.length;R<S;R++)for(e=a.faceVertexUvs[R],void 0===this.faceVertexUvs[R]&&(this.faceVertexUvs[R]=[]),c=0,v=e.length;c<v;c++){g=e[c];r=[];E=0;for(F=g.length;E<F;E++)r.push(g[E].clone());
this.faceVertexUvs[R].push(r)}}else console.error("THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.",a)},mergeMesh:function(a){a&&a.isMesh?(a.matrixAutoUpdate&&a.updateMatrix(),this.merge(a.geometry,a.matrix)):console.error("THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.",a)},mergeVertices:function(){var a={},c=[],e=[],g=Math.pow(10,4),r;var v=0;for(r=this.vertices.length;v<r;v++){var z=this.vertices[v];z=Math.round(z.x*g)+"_"+Math.round(z.y*g)+"_"+Math.round(z.z*
g);void 0===a[z]?(a[z]=v,c.push(this.vertices[v]),e[v]=c.length-1):e[v]=e[a[z]]}a=[];v=0;for(r=this.faces.length;v<r;v++)for(g=this.faces[v],g.a=e[g.a],g.b=e[g.b],g.c=e[g.c],g=[g.a,g.b,g.c],z=0;3>z;z++)if(g[z]===g[(z+1)%3]){a.push(v);break}for(v=a.length-1;0<=v;v--)for(g=a[v],this.faces.splice(g,1),e=0,r=this.faceVertexUvs.length;e<r;e++)this.faceVertexUvs[e].splice(g,1);v=this.vertices.length-c.length;this.vertices=c;return v},setFromPoints:function(a){this.vertices=[];for(var c=0,e=a.length;c<e;c++){var g=
a[c];this.vertices.push(new k(g.x,g.y,g.z||0))}return this},sortFacesByMaterialIndex:function(){for(var a=this.faces,c=a.length,e=0;e<c;e++)a[e]._id=e;a.sort(function(F,J){return F.materialIndex-J.materialIndex});var g=this.faceVertexUvs[0],r=this.faceVertexUvs[1],v,z;g&&g.length===c&&(v=[]);r&&r.length===c&&(z=[]);for(e=0;e<c;e++){var E=a[e]._id;v&&v.push(g[E]);z&&z.push(r[E])}v&&(this.faceVertexUvs[0]=v);z&&(this.faceVertexUvs[1]=z)},toJSON:function(){function a(oa,ta,Ba){return Ba?oa|1<<ta:oa&
~(1<<ta)}function c(oa){var ta=oa.x.toString()+oa.y.toString()+oa.z.toString();if(void 0!==J[ta])return J[ta];J[ta]=F.length/3;F.push(oa.x,oa.y,oa.z);return J[ta]}function e(oa){var ta=oa.r.toString()+oa.g.toString()+oa.b.toString();if(void 0!==R[ta])return R[ta];R[ta]=P.length;P.push(oa.getHex());return R[ta]}function g(oa){var ta=oa.x.toString()+oa.y.toString();if(void 0!==V[ta])return V[ta];V[ta]=S.length/2;S.push(oa.x,oa.y);return V[ta]}var r={metadata:{version:4.5,type:"Geometry",generator:"Geometry.toJSON"}};
r.uuid=this.uuid;r.type=this.type;""!==this.name&&(r.name=this.name);if(void 0!==this.parameters){var v=this.parameters,z;for(z in v)void 0!==v[z]&&(r[z]=v[z]);return r}v=[];for(z=0;z<this.vertices.length;z++){var E=this.vertices[z];v.push(E.x,E.y,E.z)}E=[];var F=[],J={},P=[],R={},S=[],V={};for(z=0;z<this.faces.length;z++){var W=this.faces[z],ha=void 0!==this.faceVertexUvs[0][z],fa=0<W.normal.length(),ra=0<W.vertexNormals.length,pa=1!==W.color.r||1!==W.color.g||1!==W.color.b,qa=0<W.vertexColors.length,
ua=0;ua=a(ua,0,0);ua=a(ua,1,!0);ua=a(ua,2,!1);ua=a(ua,3,ha);ua=a(ua,4,fa);ua=a(ua,5,ra);ua=a(ua,6,pa);ua=a(ua,7,qa);E.push(ua);E.push(W.a,W.b,W.c);E.push(W.materialIndex);ha&&(ha=this.faceVertexUvs[0][z],E.push(g(ha[0]),g(ha[1]),g(ha[2])));fa&&E.push(c(W.normal));ra&&(fa=W.vertexNormals,E.push(c(fa[0]),c(fa[1]),c(fa[2])));pa&&E.push(e(W.color));qa&&(W=W.vertexColors,E.push(e(W[0]),e(W[1]),e(W[2])))}r.data={};r.data.vertices=v;r.data.normals=F;0<P.length&&(r.data.colors=P);0<S.length&&(r.data.uvs=
[S]);r.data.faces=E;return r},clone:function(){return(new ya).copy(this)},copy:function(a){var c,e,g;this.vertices=[];this.colors=[];this.faces=[];this.faceVertexUvs=[[]];this.morphTargets=[];this.morphNormals=[];this.skinWeights=[];this.skinIndices=[];this.lineDistances=[];this.boundingSphere=this.boundingBox=null;this.name=a.name;var r=a.vertices;var v=0;for(c=r.length;v<c;v++)this.vertices.push(r[v].clone());r=a.colors;v=0;for(c=r.length;v<c;v++)this.colors.push(r[v].clone());r=a.faces;v=0;for(c=
r.length;v<c;v++)this.faces.push(r[v].clone());v=0;for(c=a.faceVertexUvs.length;v<c;v++){var z=a.faceVertexUvs[v];void 0===this.faceVertexUvs[v]&&(this.faceVertexUvs[v]=[]);r=0;for(e=z.length;r<e;r++){var E=z[r],F=[];var J=0;for(g=E.length;J<g;J++)F.push(E[J].clone());this.faceVertexUvs[v].push(F)}}J=a.morphTargets;v=0;for(c=J.length;v<c;v++){g={};g.name=J[v].name;if(void 0!==J[v].vertices)for(g.vertices=[],r=0,e=J[v].vertices.length;r<e;r++)g.vertices.push(J[v].vertices[r].clone());if(void 0!==J[v].normals)for(g.normals=
[],r=0,e=J[v].normals.length;r<e;r++)g.normals.push(J[v].normals[r].clone());this.morphTargets.push(g)}J=a.morphNormals;v=0;for(c=J.length;v<c;v++){g={};if(void 0!==J[v].vertexNormals)for(g.vertexNormals=[],r=0,e=J[v].vertexNormals.length;r<e;r++)z=J[v].vertexNormals[r],E={},E.a=z.a.clone(),E.b=z.b.clone(),E.c=z.c.clone(),g.vertexNormals.push(E);if(void 0!==J[v].faceNormals)for(g.faceNormals=[],r=0,e=J[v].faceNormals.length;r<e;r++)g.faceNormals.push(J[v].faceNormals[r].clone());this.morphNormals.push(g)}r=
a.skinWeights;v=0;for(c=r.length;v<c;v++)this.skinWeights.push(r[v].clone());r=a.skinIndices;v=0;for(c=r.length;v<c;v++)this.skinIndices.push(r[v].clone());r=a.lineDistances;v=0;for(c=r.length;v<c;v++)this.lineDistances.push(r[v]);v=a.boundingBox;null!==v&&(this.boundingBox=v.clone());v=a.boundingSphere;null!==v&&(this.boundingSphere=v.clone());this.elementsNeedUpdate=a.elementsNeedUpdate;this.verticesNeedUpdate=a.verticesNeedUpdate;this.uvsNeedUpdate=a.uvsNeedUpdate;this.normalsNeedUpdate=a.normalsNeedUpdate;
this.colorsNeedUpdate=a.colorsNeedUpdate;this.lineDistancesNeedUpdate=a.lineDistancesNeedUpdate;this.groupsNeedUpdate=a.groupsNeedUpdate;return this},dispose:function(){this.dispatchEvent({type:"dispose"})}});Sa.prototype=Object.create(ya.prototype);Sa.prototype.constructor=Sa;Xa.prototype=Object.create(va.prototype);Xa.prototype.constructor=Xa;var Fm={clone:ub,merge:Bb};qb.prototype=Object.create(M.prototype);qb.prototype.constructor=qb;qb.prototype.isShaderMaterial=!0;qb.prototype.copy=function(a){M.prototype.copy.call(this,
a);this.fragmentShader=a.fragmentShader;this.vertexShader=a.vertexShader;this.uniforms=ub(a.uniforms);this.defines=Object.assign({},a.defines);this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.lights=a.lights;this.clipping=a.clipping;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;this.extensions=a.extensions;return this};qb.prototype.toJSON=function(a){var c=M.prototype.toJSON.call(this,a);c.uniforms={};for(var e in this.uniforms){var g=
this.uniforms[e].value;c.uniforms[e]=g&&g.isTexture?{type:"t",value:g.toJSON(a).uuid}:g&&g.isColor?{type:"c",value:g.getHex()}:g&&g.isVector2?{type:"v2",value:g.toArray()}:g&&g.isVector3?{type:"v3",value:g.toArray()}:g&&g.isVector4?{type:"v4",value:g.toArray()}:g&&g.isMatrix3?{type:"m3",value:g.toArray()}:g&&g.isMatrix4?{type:"m4",value:g.toArray()}:{value:g}}0<Object.keys(this.defines).length&&(c.defines=this.defines);c.vertexShader=this.vertexShader;c.fragmentShader=this.fragmentShader;a={};for(var r in this.extensions)!0===
this.extensions[r]&&(a[r]=!0);0<Object.keys(a).length&&(c.extensions=a);return c};zb.prototype=Object.assign(Object.create(A.prototype),{constructor:zb,isCamera:!0,copy:function(a,c){A.prototype.copy.call(this,a,c);this.matrixWorldInverse.copy(a.matrixWorldInverse);this.projectionMatrix.copy(a.projectionMatrix);this.projectionMatrixInverse.copy(a.projectionMatrixInverse);return this},getWorldDirection:function(a){void 0===a&&(console.warn("THREE.Camera: .getWorldDirection() target is now required"),
a=new k);this.updateMatrixWorld(!0);var c=this.matrixWorld.elements;return a.set(-c[8],-c[9],-c[10]).normalize()},updateMatrixWorld:function(a){A.prototype.updateMatrixWorld.call(this,a);this.matrixWorldInverse.getInverse(this.matrixWorld)},clone:function(){return(new this.constructor).copy(this)}});vb.prototype=Object.assign(Object.create(zb.prototype),{constructor:vb,isPerspectiveCamera:!0,copy:function(a,c){zb.prototype.copy.call(this,a,c);this.fov=a.fov;this.zoom=a.zoom;this.near=a.near;this.far=
a.far;this.focus=a.focus;this.aspect=a.aspect;this.view=null===a.view?null:Object.assign({},a.view);this.filmGauge=a.filmGauge;this.filmOffset=a.filmOffset;return this},setFocalLength:function(a){this.fov=2*hb.RAD2DEG*Math.atan(.5*this.getFilmHeight()/a);this.updateProjectionMatrix()},getFocalLength:function(){return.5*this.getFilmHeight()/Math.tan(.5*hb.DEG2RAD*this.fov)},getEffectiveFOV:function(){return 2*hb.RAD2DEG*Math.atan(Math.tan(.5*hb.DEG2RAD*this.fov)/this.zoom)},getFilmWidth:function(){return this.filmGauge*
Math.min(this.aspect,1)},getFilmHeight:function(){return this.filmGauge/Math.max(this.aspect,1)},setViewOffset:function(a,c,e,g,r,v){this.aspect=a/c;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=a;this.view.fullHeight=c;this.view.offsetX=e;this.view.offsetY=g;this.view.width=r;this.view.height=v;this.updateProjectionMatrix()},clearViewOffset:function(){null!==this.view&&(this.view.enabled=!1);this.updateProjectionMatrix()},
updateProjectionMatrix:function(){var a=this.near,c=a*Math.tan(.5*hb.DEG2RAD*this.fov)/this.zoom,e=2*c,g=this.aspect*e,r=-.5*g,v=this.view;if(null!==this.view&&this.view.enabled){var z=v.fullWidth,E=v.fullHeight;r+=v.offsetX*g/z;c-=v.offsetY*e/E;g*=v.width/z;e*=v.height/E}v=this.filmOffset;0!==v&&(r+=a*v/this.getFilmWidth());this.projectionMatrix.makePerspective(r,r+g,c,c-e,a,this.far);this.projectionMatrixInverse.getInverse(this.projectionMatrix)},toJSON:function(a){a=A.prototype.toJSON.call(this,
a);a.object.fov=this.fov;a.object.zoom=this.zoom;a.object.near=this.near;a.object.far=this.far;a.object.focus=this.focus;a.object.aspect=this.aspect;null!==this.view&&(a.object.view=Object.assign({},this.view));a.object.filmGauge=this.filmGauge;a.object.filmOffset=this.filmOffset;return a}});Gb.prototype=Object.create(A.prototype);Gb.prototype.constructor=Gb;Nb.prototype=Object.create(m.prototype);Nb.prototype.constructor=Nb;Nb.prototype.isWebGLRenderTargetCube=!0;Nb.prototype.fromEquirectangularTexture=
function(a,c){this.texture.type=c.type;this.texture.format=c.format;this.texture.encoding=c.encoding;var e=new y,g=new qb({type:"CubemapFromEquirect",uniforms:ub({tEquirect:{value:null}}),vertexShader:"varying vec3 vWorldDirection;\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvoid main() {\n\tvWorldDirection \x3d transformDirection( position, modelMatrix );\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n}",
fragmentShader:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#define RECIPROCAL_PI 0.31830988618\n#define RECIPROCAL_PI2 0.15915494\nvoid main() {\n\tvec3 direction \x3d normalize( vWorldDirection );\n\tvec2 sampleUV;\n\tsampleUV.y \x3d asin( clamp( direction.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\tsampleUV.x \x3d atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;\n\tgl_FragColor \x3d texture2D( tEquirect, sampleUV );\n}",side:1,blending:0});g.uniforms.tEquirect.value=c;
c=new xa(new Xa(5,5,5),g);e.add(c);g=new Gb(1,10,1);g.renderTarget=this;g.renderTarget.texture.name="CubeCameraTexture";g.update(a,e);c.geometry.dispose();c.material.dispose();return this};Ab.prototype=Object.create(l.prototype);Ab.prototype.constructor=Ab;Ab.prototype.isDataTexture=!0;var Ji=new k,Gm=new k,Hm=new t;Object.assign(Hb.prototype,{isPlane:!0,set:function(a,c){this.normal.copy(a);this.constant=c;return this},setComponents:function(a,c,e,g){this.normal.set(a,c,e);this.constant=g;return this},
setFromNormalAndCoplanarPoint:function(a,c){this.normal.copy(a);this.constant=-c.dot(this.normal);return this},setFromCoplanarPoints:function(a,c,e){c=Ji.subVectors(e,c).cross(Gm.subVectors(a,c)).normalize();this.setFromNormalAndCoplanarPoint(c,a);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.normal.copy(a.normal);this.constant=a.constant;return this},normalize:function(){var a=1/this.normal.length();this.normal.multiplyScalar(a);this.constant*=a;return this},
negate:function(){this.constant*=-1;this.normal.negate();return this},distanceToPoint:function(a){return this.normal.dot(a)+this.constant},distanceToSphere:function(a){return this.distanceToPoint(a.center)-a.radius},projectPoint:function(a,c){void 0===c&&(console.warn("THREE.Plane: .projectPoint() target is now required"),c=new k);return c.copy(this.normal).multiplyScalar(-this.distanceToPoint(a)).add(a)},intersectLine:function(a,c){void 0===c&&(console.warn("THREE.Plane: .intersectLine() target is now required"),
c=new k);var e=a.delta(Ji),g=this.normal.dot(e);if(0===g){if(0===this.distanceToPoint(a.start))return c.copy(a.start)}else if(g=-(a.start.dot(this.normal)+this.constant)/g,!(0>g||1<g))return c.copy(e).multiplyScalar(g).add(a.start)},intersectsLine:function(a){var c=this.distanceToPoint(a.start);a=this.distanceToPoint(a.end);return 0>c&&0<a||0>a&&0<c},intersectsBox:function(a){return a.intersectsPlane(this)},intersectsSphere:function(a){return a.intersectsPlane(this)},coplanarPoint:function(a){void 0===
a&&(console.warn("THREE.Plane: .coplanarPoint() target is now required"),a=new k);return a.copy(this.normal).multiplyScalar(-this.constant)},applyMatrix4:function(a,c){c=c||Hm.getNormalMatrix(a);a=this.coplanarPoint(Ji).applyMatrix4(a);c=this.normal.applyMatrix3(c).normalize();this.constant=-a.dot(c);return this},translate:function(a){this.constant-=a.dot(this.normal);return this},equals:function(a){return a.normal.equals(this.normal)&&a.constant===this.constant}});var mf=new G,ph=new k;Object.assign(ic.prototype,
{set:function(a,c,e,g,r,v){var z=this.planes;z[0].copy(a);z[1].copy(c);z[2].copy(e);z[3].copy(g);z[4].copy(r);z[5].copy(v);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){for(var c=this.planes,e=0;6>e;e++)c[e].copy(a.planes[e]);return this},setFromMatrix:function(a){var c=this.planes,e=a.elements;a=e[0];var g=e[1],r=e[2],v=e[3],z=e[4],E=e[5],F=e[6],J=e[7],P=e[8],R=e[9],S=e[10],V=e[11],W=e[12],ha=e[13],fa=e[14];e=e[15];c[0].setComponents(v-a,J-z,V-P,e-W).normalize();
c[1].setComponents(v+a,J+z,V+P,e+W).normalize();c[2].setComponents(v+g,J+E,V+R,e+ha).normalize();c[3].setComponents(v-g,J-E,V-R,e-ha).normalize();c[4].setComponents(v-r,J-F,V-S,e-fa).normalize();c[5].setComponents(v+r,J+F,V+S,e+fa).normalize();return this},intersectsObject:function(a){var c=a.geometry;null===c.boundingSphere&&c.computeBoundingSphere();mf.copy(c.boundingSphere).applyMatrix4(a.matrixWorld);return this.intersectsSphere(mf)},intersectsSprite:function(a){mf.center.set(0,0,0);mf.radius=
.7071067811865476;mf.applyMatrix4(a.matrixWorld);return this.intersectsSphere(mf)},intersectsSphere:function(a){var c=this.planes,e=a.center;a=-a.radius;for(var g=0;6>g;g++)if(c[g].distanceToPoint(e)<a)return!1;return!0},intersectsBox:function(a){for(var c=this.planes,e=0;6>e;e++){var g=c[e];ph.x=0<g.normal.x?a.max.x:a.min.x;ph.y=0<g.normal.y?a.max.y:a.min.y;ph.z=0<g.normal.z?a.max.z:a.min.z;if(0>g.distanceToPoint(ph))return!1}return!0},containsPoint:function(a){for(var c=this.planes,e=0;6>e;e++)if(0>
c[e].distanceToPoint(a))return!1;return!0}});var rb={alphamap_fragment:"#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *\x3d texture2D( alphaMap, vUv ).g;\n#endif",alphamap_pars_fragment:"#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif",alphatest_fragment:"#ifdef ALPHATEST\n\tif ( diffuseColor.a \x3c ALPHATEST ) discard;\n#endif",aomap_fragment:"#ifdef USE_AOMAP\n\tfloat ambientOcclusion \x3d ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *\x3d ambientOcclusion;\n\t#if defined( USE_ENVMAP ) \x26\x26 defined( STANDARD )\n\t\tfloat dotNV \x3d saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *\x3d computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\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 \x3d vec3( position );",beginnormal_vertex:"vec3 objectNormal \x3d vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent \x3d vec3( tangent.xyz );\n#endif",bsdfs:"vec2 integrateSpecularBRDF( const in float dotNV, const in float roughness ) {\n\tconst vec4 c0 \x3d vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 \x3d vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r \x3d roughness * c0 + c1;\n\tfloat a004 \x3d min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\treturn vec2( -1.04, 1.04 ) * a004 + r.zw;\n}\nfloat punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n\tfloat distanceFalloff \x3d 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\tif( cutoffDistance \x3e 0.0 ) {\n\t\tdistanceFalloff *\x3d pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t}\n\treturn distanceFalloff;\n#else\n\tif( cutoffDistance \x3e 0.0 \x26\x26 decayExponent \x3e 0.0 ) {\n\t\treturn pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t}\n\treturn 1.0;\n#endif\n}\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\n\tfloat fresnel \x3d exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\n\treturn ( 1.0 - specularColor ) * fresnel + specularColor;\n}\nvec3 F_Schlick_RoughnessDependent( const in vec3 F0, const in float dotNV, const in float roughness ) {\n\tfloat fresnel \x3d exp2( ( -5.55473 * dotNV - 6.98316 ) * dotNV );\n\tvec3 Fr \x3d max( vec3( 1.0 - roughness ), F0 ) - F0;\n\treturn Fr * fresnel + F0;\n}\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 \x3d pow2( alpha );\n\tfloat gl \x3d dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\tfloat gv \x3d dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\treturn 1.0 / ( gl * gv );\n}\nfloat G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 \x3d pow2( alpha );\n\tfloat gv \x3d dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl \x3d 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 \x3d pow2( alpha );\n\tfloat denom \x3d pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat alpha \x3d pow2( roughness );\n\tvec3 halfDir \x3d normalize( incidentLight.direction + viewDir );\n\tfloat dotNL \x3d saturate( dot( normal, incidentLight.direction ) );\n\tfloat dotNV \x3d saturate( dot( normal, viewDir ) );\n\tfloat dotNH \x3d saturate( dot( normal, halfDir ) );\n\tfloat dotLH \x3d saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F \x3d F_Schlick( specularColor, dotLH );\n\tfloat G \x3d G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D \x3d D_GGX( alpha, dotNH );\n\treturn F * ( G * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE  \x3d 64.0;\n\tconst float LUT_SCALE \x3d ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS  \x3d 0.5 / LUT_SIZE;\n\tfloat dotNV \x3d saturate( dot( N, V ) );\n\tvec2 uv \x3d vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv \x3d uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l \x3d 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 \x3d dot( v1, v2 );\n\tfloat y \x3d abs( x );\n\tfloat a \x3d 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b \x3d 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v \x3d a / b;\n\tfloat theta_sintheta \x3d ( x \x3e 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 \x3d rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 \x3d rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal \x3d cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) \x3c 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 \x3d normalize( V - N * dot( V, N ) );\n\tT2 \x3d - cross( N, T1 );\n\tmat3 mat \x3d mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] \x3d mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] \x3d mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] \x3d mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] \x3d mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] \x3d normalize( coords[ 0 ] );\n\tcoords[ 1 ] \x3d normalize( coords[ 1 ] );\n\tcoords[ 2 ] \x3d normalize( coords[ 2 ] );\n\tcoords[ 3 ] \x3d normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor \x3d vec3( 0.0 );\n\tvectorFormFactor +\x3d LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor +\x3d LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor +\x3d LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor +\x3d LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result \x3d LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\nvec3 BRDF_Specular_GGX_Environment( const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat dotNV \x3d saturate( dot( normal, viewDir ) );\n\tvec2 brdf \x3d integrateSpecularBRDF( dotNV, roughness );\n\treturn specularColor * brdf.x + brdf.y;\n}\nvoid BRDF_Specular_Multiscattering_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n\tfloat dotNV \x3d saturate( dot( geometry.normal, geometry.viewDir ) );\n\tvec3 F \x3d F_Schlick_RoughnessDependent( specularColor, dotNV, roughness );\n\tvec2 brdf \x3d integrateSpecularBRDF( dotNV, roughness );\n\tvec3 FssEss \x3d F * brdf.x + brdf.y;\n\tfloat Ess \x3d brdf.x + brdf.y;\n\tfloat Ems \x3d 1.0 - Ess;\n\tvec3 Favg \x3d specularColor + ( 1.0 - specularColor ) * 0.047619;\tvec3 Fms \x3d FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter +\x3d FssEss;\n\tmultiScatter +\x3d Fms * Ems;\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_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir \x3d normalize( incidentLight.direction + geometry.viewDir );\n\tfloat dotNH \x3d saturate( dot( geometry.normal, halfDir ) );\n\tfloat dotLH \x3d saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F \x3d F_Schlick( specularColor, dotLH );\n\tfloat G \x3d G_BlinnPhong_Implicit( );\n\tfloat D \x3d D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n}\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\n\treturn ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );\n}\nfloat BlinnExponentToGGXRoughness( const in float blinnExponent ) {\n\treturn sqrt( 2.0 / ( blinnExponent + 2.0 ) );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie(float roughness, float NoH) {\n\tfloat invAlpha  \x3d 1.0 / roughness;\n\tfloat cos2h \x3d NoH * NoH;\n\tfloat sin2h \x3d max(1.0 - cos2h, 0.0078125);\treturn (2.0 + invAlpha) * pow(sin2h, invAlpha * 0.5) / (2.0 * PI);\n}\nfloat V_Neubelt(float NoV, float NoL) {\n\treturn saturate(1.0 / (4.0 * (NoL + NoV - NoL * NoV)));\n}\nvec3 BRDF_Specular_Sheen( const in float roughness, const in vec3 L, const in GeometricContext geometry, vec3 specularColor ) {\n\tvec3 N \x3d geometry.normal;\n\tvec3 V \x3d geometry.viewDir;\n\tvec3 H \x3d normalize( V + L );\n\tfloat dotNH \x3d saturate( dot( N, H ) );\n\treturn specularColor * D_Charlie( roughness, dotNH ) * V_Neubelt( dot(N, V), dot(N, L) );\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 \x3d dFdx( vUv );\n\t\tvec2 dSTdy \x3d dFdy( vUv );\n\t\tfloat Hll \x3d bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx \x3d bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy \x3d 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 ) {\n\t\tvec3 vSigmaX \x3d vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY \x3d vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\tvec3 vN \x3d surf_norm;\n\t\tvec3 R1 \x3d cross( vSigmaY, vN );\n\t\tvec3 R2 \x3d cross( vN, vSigmaX );\n\t\tfloat fDet \x3d dot( vSigmaX, R1 );\n\t\tfDet *\x3d ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\tvec3 vGrad \x3d 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 \x3e 0\n\tvec4 plane;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane \x3d clippingPlanes[ i ];\n\t\tif ( dot( vViewPosition, plane.xyz ) \x3e plane.w ) discard;\n\t}\n\t#if UNION_CLIPPING_PLANES \x3c NUM_CLIPPING_PLANES\n\t\tbool clipped \x3d true;\n\t\t#pragma unroll_loop\n\t\tfor ( int i \x3d UNION_CLIPPING_PLANES; i \x3c NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane \x3d clippingPlanes[ i ];\n\t\t\tclipped \x3d ( dot( vViewPosition, plane.xyz ) \x3e plane.w ) \x26\x26 clipped;\n\t\t}\n\t\tif ( clipped ) discard;\n\t#endif\n#endif",
clipping_planes_pars_fragment:"#if NUM_CLIPPING_PLANES \x3e 0\n\t#if ! defined( STANDARD ) \x26\x26 ! defined( PHONG ) \x26\x26 ! defined( MATCAP )\n\t\tvarying vec3 vViewPosition;\n\t#endif\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif",clipping_planes_pars_vertex:"#if NUM_CLIPPING_PLANES \x3e 0 \x26\x26 ! defined( STANDARD ) \x26\x26 ! defined( PHONG ) \x26\x26 ! defined( MATCAP )\n\tvarying vec3 vViewPosition;\n#endif",clipping_planes_vertex:"#if NUM_CLIPPING_PLANES \x3e 0 \x26\x26 ! defined( STANDARD ) \x26\x26 ! defined( PHONG ) \x26\x26 ! defined( MATCAP )\n\tvViewPosition \x3d - mvPosition.xyz;\n#endif",
color_fragment:"#ifdef USE_COLOR\n\tdiffuseColor.rgb *\x3d vColor;\n#endif",color_pars_fragment:"#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif",color_pars_vertex:"#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif",color_vertex:"#ifdef USE_COLOR\n\tvColor.xyz \x3d color.xyz;\n#endif",common:"#define PI 3.14159265359\n#define PI2 6.28318530718\n#define PI_HALF 1.5707963267949\n#define RECIPROCAL_PI 0.31830988618\n#define RECIPROCAL_PI2 0.15915494\n#define LOG2 1.442695\n#define EPSILON 1e-6\n#define saturate(a) clamp( a, 0.0, 1.0 )\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 \x3d x*x; return x2*x2; }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a \x3d 12.9898, b \x3d 78.233, c \x3d 43758.5453;\n\thighp float dt \x3d dot( uv.xy, vec2( a,b ) ), sn \x3d 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 max3( vec3 v ) { return max( max( v.x, v.y ), v.z ); }\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent \x3d 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 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}\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\tfloat distance \x3d dot( planeNormal, point - pointOnPlane );\n\treturn - distance * planeNormal + point;\n}\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn sign( dot( point - pointOnPlane, planeNormal ) );\n}\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] \x3d vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] \x3d vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] \x3d vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nfloat linearToRelativeLuminance( const in vec3 color ) {\n\tvec3 weights \x3d vec3( 0.2126, 0.7152, 0.0722 );\n\treturn dot( weights, color.rgb );\n}",
cube_uv_reflection_fragment:"#ifdef ENVMAP_TYPE_CUBE_UV\n#define cubeUV_textureSize (1024.0)\nint getFaceFromDirection(vec3 direction) {\n\tvec3 absDirection \x3d abs(direction);\n\tint face \x3d -1;\n\tif( absDirection.x \x3e absDirection.z ) {\n\t\tif(absDirection.x \x3e absDirection.y )\n\t\t\tface \x3d direction.x \x3e 0.0 ? 0 : 3;\n\t\telse\n\t\t\tface \x3d direction.y \x3e 0.0 ? 1 : 4;\n\t}\n\telse {\n\t\tif(absDirection.z \x3e absDirection.y )\n\t\t\tface \x3d direction.z \x3e 0.0 ? 2 : 5;\n\t\telse\n\t\t\tface \x3d direction.y \x3e 0.0 ? 1 : 4;\n\t}\n\treturn face;\n}\n#define cubeUV_maxLods1  (log2(cubeUV_textureSize*0.25) - 1.0)\n#define cubeUV_rangeClamp (exp2((6.0 - 1.0) * 2.0))\nvec2 MipLevelInfo( vec3 vec, float roughnessLevel, float roughness ) {\n\tfloat scale \x3d exp2(cubeUV_maxLods1 - roughnessLevel);\n\tfloat dxRoughness \x3d dFdx(roughness);\n\tfloat dyRoughness \x3d dFdy(roughness);\n\tvec3 dx \x3d dFdx( vec * scale * dxRoughness );\n\tvec3 dy \x3d dFdy( vec * scale * dyRoughness );\n\tfloat d \x3d max( dot( dx, dx ), dot( dy, dy ) );\n\td \x3d clamp(d, 1.0, cubeUV_rangeClamp);\n\tfloat mipLevel \x3d 0.5 * log2(d);\n\treturn vec2(floor(mipLevel), fract(mipLevel));\n}\n#define cubeUV_maxLods2 (log2(cubeUV_textureSize*0.25) - 2.0)\n#define cubeUV_rcpTextureSize (1.0 / cubeUV_textureSize)\nvec2 getCubeUV(vec3 direction, float roughnessLevel, float mipLevel) {\n\tmipLevel \x3d roughnessLevel \x3e cubeUV_maxLods2 - 3.0 ? 0.0 : mipLevel;\n\tfloat a \x3d 16.0 * cubeUV_rcpTextureSize;\n\tvec2 exp2_packed \x3d exp2( vec2( roughnessLevel, mipLevel ) );\n\tvec2 rcp_exp2_packed \x3d vec2( 1.0 ) / exp2_packed;\n\tfloat powScale \x3d exp2_packed.x * exp2_packed.y;\n\tfloat scale \x3d rcp_exp2_packed.x * rcp_exp2_packed.y * 0.25;\n\tfloat mipOffset \x3d 0.75*(1.0 - rcp_exp2_packed.y) * rcp_exp2_packed.x;\n\tbool bRes \x3d mipLevel \x3d\x3d 0.0;\n\tscale \x3d  bRes \x26\x26 (scale \x3c a) ? a : scale;\n\tvec3 r;\n\tvec2 offset;\n\tint face \x3d getFaceFromDirection(direction);\n\tfloat rcpPowScale \x3d 1.0 / powScale;\n\tif( face \x3d\x3d 0) {\n\t\tr \x3d vec3(direction.x, -direction.z, direction.y);\n\t\toffset \x3d vec2(0.0+mipOffset,0.75 * rcpPowScale);\n\t\toffset.y \x3d bRes \x26\x26 (offset.y \x3c 2.0*a) ? a : offset.y;\n\t}\n\telse if( face \x3d\x3d 1) {\n\t\tr \x3d vec3(direction.y, direction.x, direction.z);\n\t\toffset \x3d vec2(scale+mipOffset, 0.75 * rcpPowScale);\n\t\toffset.y \x3d bRes \x26\x26 (offset.y \x3c 2.0*a) ? a : offset.y;\n\t}\n\telse if( face \x3d\x3d 2) {\n\t\tr \x3d vec3(direction.z, direction.x, direction.y);\n\t\toffset \x3d vec2(2.0*scale+mipOffset, 0.75 * rcpPowScale);\n\t\toffset.y \x3d bRes \x26\x26 (offset.y \x3c 2.0*a) ? a : offset.y;\n\t}\n\telse if( face \x3d\x3d 3) {\n\t\tr \x3d vec3(direction.x, direction.z, direction.y);\n\t\toffset \x3d vec2(0.0+mipOffset,0.5 * rcpPowScale);\n\t\toffset.y \x3d bRes \x26\x26 (offset.y \x3c 2.0*a) ? 0.0 : offset.y;\n\t}\n\telse if( face \x3d\x3d 4) {\n\t\tr \x3d vec3(direction.y, direction.x, -direction.z);\n\t\toffset \x3d vec2(scale+mipOffset, 0.5 * rcpPowScale);\n\t\toffset.y \x3d bRes \x26\x26 (offset.y \x3c 2.0*a) ? 0.0 : offset.y;\n\t}\n\telse {\n\t\tr \x3d vec3(direction.z, -direction.x, direction.y);\n\t\toffset \x3d vec2(2.0*scale+mipOffset, 0.5 * rcpPowScale);\n\t\toffset.y \x3d bRes \x26\x26 (offset.y \x3c 2.0*a) ? 0.0 : offset.y;\n\t}\n\tr \x3d normalize(r);\n\tfloat texelOffset \x3d 0.5 * cubeUV_rcpTextureSize;\n\tvec2 s \x3d ( r.yz / abs( r.x ) + vec2( 1.0 ) ) * 0.5;\n\tvec2 base \x3d offset + vec2( texelOffset );\n\treturn base + s * ( scale - 2.0 * texelOffset );\n}\n#define cubeUV_maxLods3 (log2(cubeUV_textureSize*0.25) - 3.0)\nvec4 textureCubeUV( sampler2D envMap, vec3 reflectedDirection, float roughness ) {\n\tfloat roughnessVal \x3d roughness* cubeUV_maxLods3;\n\tfloat r1 \x3d floor(roughnessVal);\n\tfloat r2 \x3d r1 + 1.0;\n\tfloat t \x3d fract(roughnessVal);\n\tvec2 mipInfo \x3d MipLevelInfo(reflectedDirection, r1, roughness);\n\tfloat s \x3d mipInfo.y;\n\tfloat level0 \x3d mipInfo.x;\n\tfloat level1 \x3d level0 + 1.0;\n\tlevel1 \x3d level1 \x3e 5.0 ? 5.0 : level1;\n\tlevel0 +\x3d min( floor( s + 0.5 ), 5.0 );\n\tvec2 uv_10 \x3d getCubeUV(reflectedDirection, r1, level0);\n\tvec4 color10 \x3d envMapTexelToLinear(texture2D(envMap, uv_10));\n\tvec2 uv_20 \x3d getCubeUV(reflectedDirection, r2, level0);\n\tvec4 color20 \x3d envMapTexelToLinear(texture2D(envMap, uv_20));\n\tvec4 result \x3d mix(color10, color20, t);\n\treturn vec4(result.rgb, 1.0);\n}\n#endif",
defaultnormal_vertex:"vec3 transformedNormal \x3d normalMatrix * objectNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal \x3d - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\tvec3 transformedTangent \x3d normalMatrix * objectTangent;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent \x3d - 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 +\x3d normalize( objectNormal ) * ( texture2D( displacementMap, uv ).x * displacementScale + displacementBias );\n#endif",
emissivemap_fragment:"#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor \x3d texture2D( emissiveMap, vUv );\n\temissiveColor.rgb \x3d emissiveMapTexelToLinear( emissiveColor ).rgb;\n\ttotalEmissiveRadiance *\x3d emissiveColor.rgb;\n#endif",emissivemap_pars_fragment:"#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif",encodings_fragment:"gl_FragColor \x3d linearToOutputTexel( gl_FragColor );",encodings_pars_fragment:"\nvec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( gammaFactor ) ), value.a );\n}\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( 1.0 / gammaFactor ) ), value.a );\n}\nvec4 sRGBToLinear( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.a );\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}\nvec4 RGBEToLinear( in vec4 value ) {\n\treturn vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\n}\nvec4 LinearToRGBE( in vec4 value ) {\n\tfloat maxComponent \x3d max( max( value.r, value.g ), value.b );\n\tfloat fExp \x3d clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\n\treturn vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\n}\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * value.a * maxRange, 1.0 );\n}\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\n\tfloat maxRGB \x3d max( value.r, max( value.g, value.b ) );\n\tfloat M \x3d clamp( maxRGB / maxRange, 0.0, 1.0 );\n\tM \x3d ceil( M * 255.0 ) / 255.0;\n\treturn vec4( value.rgb / ( M * maxRange ), M );\n}\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\n}\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\n\tfloat maxRGB \x3d max( value.r, max( value.g, value.b ) );\n\tfloat D \x3d max( maxRange / maxRGB, 1.0 );\n\tD \x3d min( floor( D ) / 255.0, 1.0 );\n\treturn vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\n}\nconst mat3 cLogLuvM \x3d mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\nvec4 LinearToLogLuv( in vec4 value )  {\n\tvec3 Xp_Y_XYZp \x3d cLogLuvM * value.rgb;\n\tXp_Y_XYZp \x3d max( Xp_Y_XYZp, vec3( 1e-6, 1e-6, 1e-6 ) );\n\tvec4 vResult;\n\tvResult.xy \x3d Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\n\tfloat Le \x3d 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\n\tvResult.w \x3d fract( Le );\n\tvResult.z \x3d ( Le - ( floor( vResult.w * 255.0 ) ) / 255.0 ) / 255.0;\n\treturn vResult;\n}\nconst mat3 cLogLuvInverseM \x3d mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\nvec4 LogLuvToLinear( in vec4 value ) {\n\tfloat Le \x3d value.z * 255.0 + value.w;\n\tvec3 Xp_Y_XYZp;\n\tXp_Y_XYZp.y \x3d exp2( ( Le - 127.0 ) / 2.0 );\n\tXp_Y_XYZp.z \x3d Xp_Y_XYZp.y / value.y;\n\tXp_Y_XYZp.x \x3d value.x * Xp_Y_XYZp.z;\n\tvec3 vRGB \x3d cLogLuvInverseM * Xp_Y_XYZp.rgb;\n\treturn vec4( max( vRGB, 0.0 ), 1.0 );\n}",
envmap_fragment:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToVertex \x3d normalize( vWorldPosition - cameraPosition );\n\t\tvec3 worldNormal \x3d inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec \x3d reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec \x3d refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec \x3d vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor \x3d textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_EQUIREC )\n\t\tvec2 sampleUV;\n\t\treflectVec \x3d normalize( reflectVec );\n\t\tsampleUV.y \x3d asin( clamp( reflectVec.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\t\tsampleUV.x \x3d atan( reflectVec.z, reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n\t\tvec4 envColor \x3d texture2D( envMap, sampleUV );\n\t#elif defined( ENVMAP_TYPE_SPHERE )\n\t\treflectVec \x3d normalize( reflectVec );\n\t\tvec3 reflectView \x3d normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0, 0.0, 1.0 ) );\n\t\tvec4 envColor \x3d texture2D( envMap, reflectView.xy * 0.5 + 0.5 );\n\t#else\n\t\tvec4 envColor \x3d vec4( 0.0 );\n\t#endif\n\tenvColor \x3d envMapTexelToLinear( envColor );\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight \x3d mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight \x3d mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight +\x3d 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\tuniform int maxMipLevel;\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 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\n\t\tvec3 worldNormal \x3d inverseTransformDirection( geometry.normal, viewMatrix );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryVec \x3d vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor \x3d textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor \x3d textureCube( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb \x3d envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 queryVec \x3d vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\tvec4 envMapColor \x3d textureCubeUV( envMap, queryVec, 1.0 );\n\t\t#else\n\t\t\tvec4 envMapColor \x3d vec4( 0.0 );\n\t\t#endif\n\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t}\n\tfloat getSpecularMIPLevel( const in float roughness, const in int maxMIPLevel ) {\n\t\tfloat maxMIPLevelScalar \x3d float( maxMIPLevel );\n\t\tfloat sigma \x3d PI * roughness * roughness / ( 1.0 + roughness );\n\t\tfloat desiredMIPLevel \x3d maxMIPLevelScalar + log2( sigma );\n\t\treturn clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\n\t}\n\tvec3 getLightProbeIndirectRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in int maxMIPLevel ) {\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t  vec3 reflectVec \x3d reflect( -viewDir, normal );\n\t\t  reflectVec \x3d normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t#else\n\t\t  vec3 reflectVec \x3d refract( -viewDir, normal, refractionRatio );\n\t\t#endif\n\t\treflectVec \x3d inverseTransformDirection( reflectVec, viewMatrix );\n\t\tfloat specularMIPLevel \x3d getSpecularMIPLevel( roughness, maxMIPLevel );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryReflectVec \x3d vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor \x3d textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor \x3d textureCube( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb \x3d envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec3 queryReflectVec \x3d vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n\t\t\tvec4 envMapColor \x3d textureCubeUV( envMap, queryReflectVec, roughness );\n\t\t#elif defined( ENVMAP_TYPE_EQUIREC )\n\t\t\tvec2 sampleUV;\n\t\t\tsampleUV.y \x3d asin( clamp( reflectVec.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\t\t\tsampleUV.x \x3d atan( reflectVec.z, reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor \x3d texture2DLodEXT( envMap, sampleUV, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor \x3d texture2D( envMap, sampleUV, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb \x3d envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_SPHERE )\n\t\t\tvec3 reflectView \x3d normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0,0.0,1.0 ) );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor \x3d texture2DLodEXT( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor \x3d texture2D( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb \x3d envMapTexelToLinear( envMapColor ).rgb;\n\t\t#endif\n\t\treturn envMapColor.rgb * envMapIntensity;\n\t}\n#endif",
envmap_vertex:"#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition \x3d worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex \x3d normalize( worldPosition.xyz - cameraPosition );\n\t\tvec3 worldNormal \x3d inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect \x3d reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect \x3d refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif",fog_vertex:"#ifdef USE_FOG\n\tfogDepth \x3d -mvPosition.z;\n#endif",
fog_pars_vertex:"#ifdef USE_FOG\n\tvarying float fogDepth;\n#endif",fog_fragment:"#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor \x3d 1.0 - exp( - fogDensity * fogDensity * fogDepth * fogDepth );\n\t#else\n\t\tfloat fogFactor \x3d smoothstep( fogNear, fogFar, fogDepth );\n\t#endif\n\tgl_FragColor.rgb \x3d mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif",fog_pars_fragment:"#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float fogDepth;\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 TOON\n\tuniform sampler2D gradientMap;\n\tvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\t\tfloat dotNL \x3d dot( normal, lightDirection );\n\t\tvec2 coord \x3d vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t\t#ifdef USE_GRADIENTMAP\n\t\t\treturn texture2D( gradientMap, coord ).rgb;\n\t\t#else\n\t\t\treturn ( coord.x \x3c 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t\t#endif\n\t}\n#endif",lightmap_fragment:"#ifdef USE_LIGHTMAP\n\treflectedLight.indirectDiffuse +\x3d PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n#endif",
lightmap_pars_fragment:"#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif",lights_lambert_vertex:"vec3 diffuse \x3d vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position \x3d mvPosition.xyz;\ngeometry.normal \x3d normalize( transformedNormal );\ngeometry.viewDir \x3d normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position \x3d geometry.position;\nbackGeometry.normal \x3d -geometry.normal;\nbackGeometry.viewDir \x3d geometry.viewDir;\nvLightFront \x3d vec3( 0.0 );\nvIndirectFront \x3d vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n\tvLightBack \x3d vec3( 0.0 );\n\tvIndirectBack \x3d vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\n#if NUM_POINT_LIGHTS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\n\t\tdotNL \x3d dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse \x3d PI * directLight.color;\n\t\tvLightFront +\x3d saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack +\x3d saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_SPOT_LIGHTS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\n\t\tdotNL \x3d dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse \x3d PI * directLight.color;\n\t\tvLightFront +\x3d saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack +\x3d saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_DIR_LIGHTS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\n\t\tdotNL \x3d dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse \x3d PI * directLight.color;\n\t\tvLightFront +\x3d saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack +\x3d saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_HEMI_LIGHTS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvIndirectFront +\x3d getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvIndirectBack +\x3d getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\n\t\t#endif\n\t}\n#endif",
lights_pars_begin:"uniform vec3 ambientLightColor;\nuniform vec3 lightProbe[ 9 ];\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x \x3d normal.x, y \x3d normal.y, z \x3d normal.z;\n\tvec3 result \x3d shCoefficients[ 0 ] * 0.886227;\n\tresult +\x3d shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult +\x3d shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult +\x3d shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult +\x3d shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult +\x3d shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult +\x3d shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult +\x3d shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult +\x3d shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in GeometricContext geometry ) {\n\tvec3 worldNormal \x3d inverseTransformDirection( geometry.normal, viewMatrix );\n\tvec3 irradiance \x3d shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance \x3d ambientLightColor;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *\x3d PI;\n\t#endif\n\treturn irradiance;\n}\n#if NUM_DIR_LIGHTS \x3e 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tdirectLight.color \x3d directionalLight.color;\n\t\tdirectLight.direction \x3d directionalLight.direction;\n\t\tdirectLight.visible \x3d true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS \x3e 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t\tfloat shadowCameraNear;\n\t\tfloat shadowCameraFar;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector \x3d pointLight.position - geometry.position;\n\t\tdirectLight.direction \x3d normalize( lVector );\n\t\tfloat lightDistance \x3d length( lVector );\n\t\tdirectLight.color \x3d pointLight.color;\n\t\tdirectLight.color *\x3d punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\n\t\tdirectLight.visible \x3d ( directLight.color !\x3d vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS \x3e 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\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight  ) {\n\t\tvec3 lVector \x3d spotLight.position - geometry.position;\n\t\tdirectLight.direction \x3d normalize( lVector );\n\t\tfloat lightDistance \x3d length( lVector );\n\t\tfloat angleCos \x3d dot( directLight.direction, spotLight.direction );\n\t\tif ( angleCos \x3e spotLight.coneCos ) {\n\t\t\tfloat spotEffect \x3d smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\t\tdirectLight.color \x3d spotLight.color;\n\t\t\tdirectLight.color *\x3d spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tdirectLight.visible \x3d true;\n\t\t} else {\n\t\t\tdirectLight.color \x3d vec3( 0.0 );\n\t\t\tdirectLight.visible \x3d false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS \x3e 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 \x3e 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 GeometricContext geometry ) {\n\t\tfloat dotNL \x3d dot( geometry.normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight \x3d 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance \x3d mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tirradiance *\x3d PI;\n\t\t#endif\n\t\treturn irradiance;\n\t}\n#endif",
lights_phong_fragment:"BlinnPhongMaterial material;\nmaterial.diffuseColor \x3d diffuseColor.rgb;\nmaterial.specularColor \x3d specular;\nmaterial.specularShininess \x3d shininess;\nmaterial.specularStrength \x3d specularStrength;",lights_phong_pars_fragment:"varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\nstruct BlinnPhongMaterial {\n\tvec3\tdiffuseColor;\n\tvec3\tspecularColor;\n\tfloat\tspecularShininess;\n\tfloat\tspecularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\t#ifdef TOON\n\t\tvec3 irradiance \x3d getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\t#else\n\t\tfloat dotNL \x3d saturate( dot( geometry.normal, directLight.direction ) );\n\t\tvec3 irradiance \x3d dotNL * directLight.color;\n\t#endif\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *\x3d PI;\n\t#endif\n\treflectedLight.directDiffuse +\x3d irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular +\x3d irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, 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 +\x3d irradiance * BRDF_Diffuse_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 \x3d diffuseColor.rgb * ( 1.0 - metalnessFactor );\nmaterial.specularRoughness \x3d clamp( roughnessFactor, 0.04, 1.0 );\n#ifdef REFLECTIVITY\n\tmaterial.specularColor \x3d mix( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor \x3d mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor.rgb, metalnessFactor );\n#endif\n#ifdef CLEARCOAT\n\tmaterial.clearcoat \x3d saturate( clearcoat );\tmaterial.clearcoatRoughness \x3d clamp( clearcoatRoughness, 0.04, 1.0 );\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor \x3d sheen;\n#endif",
lights_physical_pars_fragment:"struct PhysicalMaterial {\n\tvec3\tdiffuseColor;\n\tfloat\tspecularRoughness;\n\tvec3\tspecularColor;\n#ifdef CLEARCOAT\n\tfloat clearcoat;\n\tfloat clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tvec3 sheenColor;\n#endif\n};\n#define MAXIMUM_SPECULAR_COEFFICIENT 0.16\n#define DEFAULT_SPECULAR_COEFFICIENT 0.04\nfloat clearcoatDHRApprox( const in float roughness, const in float dotNL ) {\n\treturn DEFAULT_SPECULAR_COEFFICIENT + ( 1.0 - DEFAULT_SPECULAR_COEFFICIENT ) * ( pow( 1.0 - dotNL, 5.0 ) * pow( 1.0 - roughness, 2.0 ) );\n}\n#if NUM_RECT_AREA_LIGHTS \x3e 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 \x3d geometry.normal;\n\t\tvec3 viewDir \x3d geometry.viewDir;\n\t\tvec3 position \x3d geometry.position;\n\t\tvec3 lightPos \x3d rectAreaLight.position;\n\t\tvec3 halfWidth \x3d rectAreaLight.halfWidth;\n\t\tvec3 halfHeight \x3d rectAreaLight.halfHeight;\n\t\tvec3 lightColor \x3d rectAreaLight.color;\n\t\tfloat roughness \x3d material.specularRoughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] \x3d lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] \x3d lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] \x3d lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] \x3d lightPos + halfWidth + halfHeight;\n\t\tvec2 uv \x3d LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 \x3d texture2D( ltc_1, uv );\n\t\tvec4 t2 \x3d texture2D( ltc_2, uv );\n\t\tmat3 mInv \x3d 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 \x3d ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular +\x3d lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse +\x3d 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 \x3d saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance \x3d dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *\x3d PI;\n\t#endif\n\t#ifdef CLEARCOAT\n\t\tfloat ccDotNL \x3d saturate( dot( geometry.clearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance \x3d ccDotNL * directLight.color;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tccIrradiance *\x3d PI;\n\t\t#endif\n\t\tfloat clearcoatDHR \x3d material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t\treflectedLight.directSpecular +\x3d ccIrradiance * material.clearcoat * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t#else\n\t\tfloat clearcoatDHR \x3d 0.0;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\treflectedLight.directSpecular +\x3d ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_Sheen(\n\t\t\tmaterial.specularRoughness,\n\t\t\tdirectLight.direction,\n\t\t\tgeometry,\n\t\t\tmaterial.sheenColor\n\t\t);\n\t#else\n\t\treflectedLight.directSpecular +\x3d ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.normal, material.specularColor, material.specularRoughness);\n\t#endif\n\treflectedLight.directDiffuse +\x3d ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Diffuse_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 +\x3d irradiance * BRDF_Diffuse_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 CLEARCOAT\n\t\tfloat ccDotNV \x3d saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular +\x3d clearcoatRadiance * material.clearcoat * BRDF_Specular_GGX_Environment( geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t\tfloat ccDotNL \x3d ccDotNV;\n\t\tfloat clearcoatDHR \x3d material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t#else\n\t\tfloat clearcoatDHR \x3d 0.0;\n\t#endif\n\tfloat clearcoatInv \x3d 1.0 - clearcoatDHR;\n\tvec3 singleScattering \x3d vec3( 0.0 );\n\tvec3 multiScattering \x3d vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance \x3d irradiance * RECIPROCAL_PI;\n\tBRDF_Specular_Multiscattering_Environment( geometry, material.specularColor, material.specularRoughness, singleScattering, multiScattering );\n\tvec3 diffuse \x3d material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );\n\treflectedLight.indirectSpecular +\x3d clearcoatInv * radiance * singleScattering;\n\treflectedLight.indirectDiffuse +\x3d multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse +\x3d 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 \x3d - vViewPosition;\ngeometry.normal \x3d normal;\ngeometry.viewDir \x3d normalize( vViewPosition );\n#ifdef CLEARCOAT\n\tgeometry.clearcoatNormal \x3d clearcoatNormal;\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS \x3e 0 ) \x26\x26 defined( RE_Direct )\n\tPointLight pointLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight \x3d pointLights[ i ];\n\t\tgetPointDirectLightIrradiance( pointLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) \x26\x26 ( UNROLLED_LOOP_INDEX \x3c NUM_POINT_LIGHT_SHADOWS )\n\t\tdirectLight.color *\x3d all( bvec2( pointLight.shadow, directLight.visible ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_SPOT_LIGHTS \x3e 0 ) \x26\x26 defined( RE_Direct )\n\tSpotLight spotLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight \x3d spotLights[ i ];\n\t\tgetSpotDirectLightIrradiance( spotLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) \x26\x26 ( UNROLLED_LOOP_INDEX \x3c NUM_SPOT_LIGHT_SHADOWS )\n\t\tdirectLight.color *\x3d all( bvec2( spotLight.shadow, directLight.visible ) ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_DIR_LIGHTS \x3e 0 ) \x26\x26 defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight \x3d directionalLights[ i ];\n\t\tgetDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) \x26\x26 ( UNROLLED_LOOP_INDEX \x3c NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectLight.color *\x3d all( bvec2( directionalLight.shadow, directLight.visible ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_RECT_AREA_LIGHTS \x3e 0 ) \x26\x26 defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight \x3d rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance \x3d vec3( 0.0 );\n\tvec3 irradiance \x3d getAmbientLightIrradiance( ambientLightColor );\n\tirradiance +\x3d getLightProbeIrradiance( lightProbe, geometry );\n\t#if ( NUM_HEMI_LIGHTS \x3e 0 )\n\t\t#pragma unroll_loop\n\t\tfor ( int i \x3d 0; i \x3c NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance +\x3d getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t}\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance \x3d vec3( 0.0 );\n\tvec3 clearcoatRadiance \x3d vec3( 0.0 );\n#endif",
lights_fragment_maps:"#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec3 lightMapIrradiance \x3d texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *\x3d PI;\n\t\t#endif\n\t\tirradiance +\x3d lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) \x26\x26 defined( STANDARD ) \x26\x26 defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance +\x3d getLightProbeIndirectIrradiance( geometry, maxMipLevel );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) \x26\x26 defined( RE_IndirectSpecular )\n\tradiance +\x3d getLightProbeIndirectRadiance( geometry.viewDir, geometry.normal, material.specularRoughness, maxMipLevel );\n\t#ifdef CLEARCOAT\n\t\tclearcoatRadiance +\x3d getLightProbeIndirectRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness, maxMipLevel );\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 ) \x26\x26 defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT \x3d log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif",logdepthbuf_pars_fragment:"#if defined( USE_LOGDEPTHBUF ) \x26\x26 defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n#endif",
logdepthbuf_pars_vertex:"#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\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 \x3d 1.0 + gl_Position.w;\n\t#else\n\t\tgl_Position.z \x3d log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\tgl_Position.z *\x3d gl_Position.w;\n\t#endif\n#endif",map_fragment:"#ifdef USE_MAP\n\tvec4 texelColor \x3d texture2D( map, vUv );\n\ttexelColor \x3d mapTexelToLinear( texelColor );\n\tdiffuseColor *\x3d texelColor;\n#endif",
map_pars_fragment:"#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif",map_particle_fragment:"#ifdef USE_MAP\n\tvec2 uv \x3d ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n\tvec4 mapTexel \x3d texture2D( map, uv );\n\tdiffuseColor *\x3d mapTexelToLinear( mapTexel );\n#endif",map_particle_pars_fragment:"#ifdef USE_MAP\n\tuniform mat3 uvTransform;\n\tuniform sampler2D map;\n#endif",metalnessmap_fragment:"float metalnessFactor \x3d metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness \x3d texture2D( metalnessMap, vUv );\n\tmetalnessFactor *\x3d texelMetalness.b;\n#endif",
metalnessmap_pars_fragment:"#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif",morphnormal_vertex:"#ifdef USE_MORPHNORMALS\n\tobjectNormal +\x3d ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];\n\tobjectNormal +\x3d ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];\n\tobjectNormal +\x3d ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];\n\tobjectNormal +\x3d ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];\n#endif",morphtarget_pars_vertex:"#ifdef USE_MORPHTARGETS\n\t#ifndef USE_MORPHNORMALS\n\tuniform float morphTargetInfluences[ 8 ];\n\t#else\n\tuniform float morphTargetInfluences[ 4 ];\n\t#endif\n#endif",
morphtarget_vertex:"#ifdef USE_MORPHTARGETS\n\ttransformed +\x3d ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];\n\ttransformed +\x3d ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];\n\ttransformed +\x3d ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];\n\ttransformed +\x3d ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];\n\t#ifndef USE_MORPHNORMALS\n\ttransformed +\x3d ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];\n\ttransformed +\x3d ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];\n\ttransformed +\x3d ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];\n\ttransformed +\x3d ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];\n\t#endif\n#endif",
normal_fragment_begin:"#ifdef FLAT_SHADED\n\tvec3 fdx \x3d vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy \x3d vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal \x3d normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal \x3d normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal \x3d normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\t#ifdef USE_TANGENT\n\t\tvec3 tangent \x3d normalize( vTangent );\n\t\tvec3 bitangent \x3d normalize( vBitangent );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\ttangent \x3d tangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t\tbitangent \x3d bitangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t#endif\n\t#endif\n#endif\nvec3 geometryNormal \x3d normal;",
normal_fragment_maps:"#ifdef OBJECTSPACE_NORMALMAP\n\tnormal \x3d texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal \x3d - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal \x3d normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\tnormal \x3d normalize( normalMatrix * normal );\n#elif defined( TANGENTSPACE_NORMALMAP )\n\t#ifdef USE_TANGENT\n\t\tmat3 vTBN \x3d mat3( tangent, bitangent, normal );\n\t\tvec3 mapN \x3d texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t\tmapN.xy \x3d normalScale * mapN.xy;\n\t\tnormal \x3d normalize( vTBN * mapN );\n\t#else\n\t\tnormal \x3d perturbNormal2Arb( -vViewPosition, normal, normalScale, normalMap );\n\t#endif\n#elif defined( USE_BUMPMAP )\n\tnormal \x3d perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\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 ) \x26\x26 ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec2 normalScale, in sampler2D normalMap ) {\n\t\tvec3 q0 \x3d vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 \x3d vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 \x3d dFdx( vUv.st );\n\t\tvec2 st1 \x3d dFdy( vUv.st );\n\t\tfloat scale \x3d sign( st1.t * st0.s - st0.t * st1.s );\n\t\tvec3 S \x3d normalize( ( q0 * st1.t - q1 * st0.t ) * scale );\n\t\tvec3 T \x3d normalize( ( - q0 * st1.s + q1 * st0.s ) * scale );\n\t\tvec3 N \x3d normalize( surf_norm );\n\t\tvec3 mapN \x3d texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t\tmapN.xy *\x3d normalScale;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvec3 NfromST \x3d cross( S, T );\n\t\t\tif( dot( NfromST, N ) \x3e 0.0 ) {\n\t\t\t\tS *\x3d -1.0;\n\t\t\t\tT *\x3d -1.0;\n\t\t\t}\n\t\t#else\n\t\t\tmapN.xy *\x3d ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t#endif\n\t\tmat3 tsn \x3d mat3( S, T, N );\n\t\treturn normalize( tsn * mapN );\n\t}\n#endif",
clearcoat_normal_fragment_begin:"#ifdef CLEARCOAT\n\tvec3 clearcoatNormal \x3d geometryNormal;\n#endif",clearcoat_normal_fragment_maps:"#ifdef USE_CLEARCOAT_NORMALMAP\n\t#ifdef USE_TANGENT\n\t\tmat3 vTBN \x3d mat3( tangent, bitangent, clearcoatNormal );\n\t\tvec3 mapN \x3d texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t\tmapN.xy \x3d clearcoatNormalScale * mapN.xy;\n\t\tclearcoatNormal \x3d normalize( vTBN * mapN );\n\t#else\n\t\tclearcoatNormal \x3d perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatNormalScale, clearcoatNormalMap );\n\t#endif\n#endif",
clearcoat_normalmap_pars_fragment:"#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif",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 \x3d 256. / 255.;const float UnpackDownscale \x3d 255. / 256.;\nconst vec3 PackFactors \x3d vec3( 256. * 256. * 256., 256. * 256.,  256. );\nconst vec4 UnpackFactors \x3d UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 \x3d 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r \x3d vec4( fract( v * PackFactors ), v );\n\tr.yzw -\x3d r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec4 encodeHalfRGBA ( vec2 v ) {\n\tvec4 encoded \x3d vec4( 0.0 );\n\tconst vec2 offset \x3d vec2( 1.0 / 255.0, 0.0 );\n\tencoded.xy \x3d vec2( v.x, fract( v.x * 255.0 ) );\n\tencoded.xy \x3d encoded.xy - ( encoded.yy * offset );\n\tencoded.zw \x3d vec2( v.y, fract( v.y * 255.0 ) );\n\tencoded.zw \x3d encoded.zw - ( encoded.ww * offset );\n\treturn encoded;\n}\nvec2 decodeHalfRGBA( 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 *\x3d gl_FragColor.a;\n#endif",project_vertex:"vec4 mvPosition \x3d modelViewMatrix * vec4( transformed, 1.0 );\ngl_Position \x3d projectionMatrix * mvPosition;",dithering_fragment:"#ifdef DITHERING\n\tgl_FragColor.rgb \x3d dithering( gl_FragColor.rgb );\n#endif",dithering_pars_fragment:"#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position \x3d rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB \x3d vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB \x3d 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 \x3d roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness \x3d texture2D( roughnessMap, vUv );\n\troughnessFactor *\x3d 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 \x3e 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS \x3e 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS \x3e 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ 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 decodeHalfRGBA( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion \x3d 1.0;\n\t\tvec2 distribution \x3d texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow \x3d step( compare , distribution.x );\n\t\tif (hard_shadow !\x3d 1.0 ) {\n\t\t\tfloat distance \x3d compare - distribution.x ;\n\t\t\tfloat variance \x3d max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability \x3d variance / (variance + distance * distance );\t\t\tsoftness_probability \x3d clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion \x3d clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat texture2DShadowLerp( sampler2D depths, vec2 size, vec2 uv, float compare ) {\n\t\tconst vec2 offset \x3d vec2( 0.0, 1.0 );\n\t\tvec2 texelSize \x3d vec2( 1.0 ) / size;\n\t\tvec2 centroidUV \x3d ( floor( uv * size - 0.5 ) + 0.5 ) * texelSize;\n\t\tfloat lb \x3d texture2DCompare( depths, centroidUV + texelSize * offset.xx, compare );\n\t\tfloat lt \x3d texture2DCompare( depths, centroidUV + texelSize * offset.xy, compare );\n\t\tfloat rb \x3d texture2DCompare( depths, centroidUV + texelSize * offset.yx, compare );\n\t\tfloat rt \x3d texture2DCompare( depths, centroidUV + texelSize * offset.yy, compare );\n\t\tvec2 f \x3d fract( uv * size + 0.5 );\n\t\tfloat a \x3d mix( lb, lt, f.y );\n\t\tfloat b \x3d mix( rb, rt, f.y );\n\t\tfloat c \x3d mix( a, b, f.x );\n\t\treturn c;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow \x3d 1.0;\n\t\tshadowCoord.xyz /\x3d shadowCoord.w;\n\t\tshadowCoord.z +\x3d shadowBias;\n\t\tbvec4 inFrustumVec \x3d bvec4 ( shadowCoord.x \x3e\x3d 0.0, shadowCoord.x \x3c\x3d 1.0, shadowCoord.y \x3e\x3d 0.0, shadowCoord.y \x3c\x3d 1.0 );\n\t\tbool inFrustum \x3d all( inFrustumVec );\n\t\tbvec2 frustumTestVec \x3d bvec2( inFrustum, shadowCoord.z \x3c\x3d 1.0 );\n\t\tbool frustumTest \x3d all( frustumTestVec );\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize \x3d vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 \x3d - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 \x3d - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 \x3d + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 \x3d + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 \x3d dx0 / 2.0;\n\t\t\tfloat dy2 \x3d dy0 / 2.0;\n\t\t\tfloat dx3 \x3d dx1 / 2.0;\n\t\t\tfloat dy3 \x3d dy1 / 2.0;\n\t\t\tshadow \x3d (\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 \x3d vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 \x3d - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 \x3d - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 \x3d + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 \x3d + texelSize.y * shadowRadius;\n\t\t\tshadow \x3d (\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow \x3d VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow \x3d 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 \x3d abs( v );\n\t\tfloat scaleToCube \x3d 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *\x3d scaleToCube;\n\t\tv *\x3d scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar \x3d v.xy;\n\t\tfloat almostATexel \x3d 1.5 * texelSizeY;\n\t\tfloat almostOne \x3d 1.0 - almostATexel;\n\t\tif ( absV.z \x3e\x3d almostOne ) {\n\t\t\tif ( v.z \x3e 0.0 )\n\t\t\t\tplanar.x \x3d 4.0 - v.x;\n\t\t} else if ( absV.x \x3e\x3d almostOne ) {\n\t\t\tfloat signX \x3d sign( v.x );\n\t\t\tplanar.x \x3d v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y \x3e\x3d almostOne ) {\n\t\t\tfloat signY \x3d sign( v.y );\n\t\t\tplanar.x \x3d v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y \x3d 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 \x3d vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition \x3d shadowCoord.xyz;\n\t\tfloat dp \x3d ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp +\x3d shadowBias;\n\t\tvec3 bd3D \x3d normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset \x3d 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 \x3e 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS \x3e 0\n\t\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS \x3e 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif",
shadowmap_vertex:"#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tvDirectionalShadowCoord[ i ] \x3d directionalShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tvSpotShadowCoord[ i ] \x3d spotShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS \x3e 0\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tvPointShadowCoord[ i ] \x3d pointShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n#endif",
shadowmask_pars_fragment:"float getShadowMask() {\n\tfloat shadow \x3d 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS \x3e 0\n\tDirectionalLight directionalLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight \x3d directionalLights[ i ];\n\t\tshadow *\x3d bool( directionalLight.shadow ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS \x3e 0\n\tSpotLight spotLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight \x3d spotLights[ i ];\n\t\tshadow *\x3d bool( spotLight.shadow ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t}\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS \x3e 0\n\tPointLight pointLight;\n\t#pragma unroll_loop\n\tfor ( int i \x3d 0; i \x3c NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight \x3d pointLights[ i ];\n\t\tshadow *\x3d bool( pointLight.shadow ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#endif\n\t#endif\n\treturn shadow;\n}",
skinbase_vertex:"#ifdef USE_SKINNING\n\tmat4 boneMatX \x3d getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY \x3d getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ \x3d getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW \x3d 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 \x3d i * 4.0;\n\t\t\tfloat x \x3d mod( j, float( boneTextureSize ) );\n\t\t\tfloat y \x3d floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx \x3d 1.0 / float( boneTextureSize );\n\t\t\tfloat dy \x3d 1.0 / float( boneTextureSize );\n\t\t\ty \x3d dy * ( y + 0.5 );\n\t\t\tvec4 v1 \x3d texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 \x3d texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 \x3d texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 \x3d texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone \x3d 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 \x3d boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif",
skinning_vertex:"#ifdef USE_SKINNING\n\tvec4 skinVertex \x3d bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned \x3d vec4( 0.0 );\n\tskinned +\x3d boneMatX * skinVertex * skinWeight.x;\n\tskinned +\x3d boneMatY * skinVertex * skinWeight.y;\n\tskinned +\x3d boneMatZ * skinVertex * skinWeight.z;\n\tskinned +\x3d boneMatW * skinVertex * skinWeight.w;\n\ttransformed \x3d ( bindMatrixInverse * skinned ).xyz;\n#endif",skinnormal_vertex:"#ifdef USE_SKINNING\n\tmat4 skinMatrix \x3d mat4( 0.0 );\n\tskinMatrix +\x3d skinWeight.x * boneMatX;\n\tskinMatrix +\x3d skinWeight.y * boneMatY;\n\tskinMatrix +\x3d skinWeight.z * boneMatZ;\n\tskinMatrix +\x3d skinWeight.w * boneMatW;\n\tskinMatrix  \x3d bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal \x3d vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent \x3d vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif",
specularmap_fragment:"float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular \x3d texture2D( specularMap, vUv );\n\tspecularStrength \x3d texelSpecular.r;\n#else\n\tspecularStrength \x3d 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 \x3d toneMapping( gl_FragColor.rgb );\n#endif",tonemapping_pars_fragment:"#ifndef saturate\n\t#define saturate(a) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nuniform float toneMappingWhitePoint;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *\x3d toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\n#define Uncharted2Helper( x ) max( ( ( x * ( 0.15 * x + 0.10 * 0.50 ) + 0.20 * 0.02 ) / ( x * ( 0.15 * x + 0.50 ) + 0.20 * 0.30 ) ) - 0.02 / 0.30, vec3( 0.0 ) )\nvec3 Uncharted2ToneMapping( vec3 color ) {\n\tcolor *\x3d toneMappingExposure;\n\treturn saturate( Uncharted2Helper( color ) / Uncharted2Helper( vec3( toneMappingWhitePoint ) ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *\x3d toneMappingExposure;\n\tcolor \x3d 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 ACESFilmicToneMapping( vec3 color ) {\n\tcolor *\x3d toneMappingExposure;\n\treturn saturate( ( color * ( 2.51 * color + 0.03 ) ) / ( color * ( 2.43 * color + 0.59 ) + 0.14 ) );\n}",
uv_pars_fragment:"#ifdef USE_UV\n\tvarying vec2 vUv;\n#endif",uv_pars_vertex:"#ifdef USE_UV\n\tvarying vec2 vUv;\n\tuniform mat3 uvTransform;\n#endif",uv_vertex:"#ifdef USE_UV\n\tvUv \x3d ( 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#endif",uv2_vertex:"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 \x3d uv2;\n#endif",
worldpos_vertex:"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )\n\tvec4 worldPosition \x3d modelMatrix * vec4( transformed, 1.0 );\n#endif",background_frag:"uniform sampler2D t2D;\nvarying vec2 vUv;\nvoid main() {\n\tvec4 texColor \x3d texture2D( t2D, vUv );\n\tgl_FragColor \x3d mapTexelToLinear( texColor );\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n}",background_vert:"varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv \x3d ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position \x3d vec4( position.xy, 1.0, 1.0 );\n}",
cube_frag:"uniform samplerCube tCube;\nuniform float tFlip;\nuniform float opacity;\nvarying vec3 vWorldDirection;\nvoid main() {\n\tvec4 texColor \x3d textureCube( tCube, vec3( tFlip * vWorldDirection.x, vWorldDirection.yz ) );\n\tgl_FragColor \x3d mapTexelToLinear( texColor );\n\tgl_FragColor.a *\x3d opacity;\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n}",cube_vert:"varying vec3 vWorldDirection;\n#include \x3ccommon\x3e\nvoid main() {\n\tvWorldDirection \x3d transformDirection( position, modelMatrix );\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\tgl_Position.z \x3d gl_Position.w;\n}",
depth_frag:"#if DEPTH_PACKING \x3d\x3d 3200\n\tuniform float opacity;\n#endif\n#include \x3ccommon\x3e\n#include \x3cpacking\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( 1.0 );\n\t#if DEPTH_PACKING \x3d\x3d 3200\n\t\tdiffuseColor.a \x3d opacity;\n\t#endif\n\t#include \x3cmap_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#if DEPTH_PACKING \x3d\x3d 3200\n\t\tgl_FragColor \x3d vec4( vec3( 1.0 - gl_FragCoord.z ), opacity );\n\t#elif DEPTH_PACKING \x3d\x3d 3201\n\t\tgl_FragColor \x3d packDepthToRGBA( gl_FragCoord.z );\n\t#endif\n}",
depth_vert:"#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cdisplacementmap_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include \x3cbeginnormal_vertex\x3e\n\t\t#include \x3cmorphnormal_vertex\x3e\n\t\t#include \x3cskinnormal_vertex\x3e\n\t#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cdisplacementmap_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n}",
distanceRGBA_frag:"#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include \x3ccommon\x3e\n#include \x3cpacking\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main () {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( 1.0 );\n\t#include \x3cmap_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\tfloat dist \x3d length( vWorldPosition - referencePosition );\n\tdist \x3d ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist \x3d saturate( dist );\n\tgl_FragColor \x3d packDepthToRGBA( dist );\n}",
distanceRGBA_vert:"#define DISTANCE\nvarying vec3 vWorldPosition;\n#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cdisplacementmap_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include \x3cbeginnormal_vertex\x3e\n\t\t#include \x3cmorphnormal_vertex\x3e\n\t\t#include \x3cskinnormal_vertex\x3e\n\t#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cdisplacementmap_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\tvWorldPosition \x3d worldPosition.xyz;\n}",
equirect_frag:"uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include \x3ccommon\x3e\nvoid main() {\n\tvec3 direction \x3d normalize( vWorldDirection );\n\tvec2 sampleUV;\n\tsampleUV.y \x3d asin( clamp( direction.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\tsampleUV.x \x3d atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;\n\tvec4 texColor \x3d texture2D( tEquirect, sampleUV );\n\tgl_FragColor \x3d mapTexelToLinear( texColor );\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n}",
equirect_vert:"varying vec3 vWorldDirection;\n#include \x3ccommon\x3e\nvoid main() {\n\tvWorldDirection \x3d transformDirection( position, modelMatrix );\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n}",linedashed_frag:"uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include \x3ccommon\x3e\n#include \x3ccolor_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tif ( mod( vLineDistance, totalSize ) \x3e dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight \x3d vec3( 0.0 );\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3ccolor_fragment\x3e\n\toutgoingLight \x3d diffuseColor.rgb;\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n}",
linedashed_vert:"uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include \x3ccommon\x3e\n#include \x3ccolor_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3ccolor_vertex\x3e\n\tvLineDistance \x3d scale * lineDistance;\n\tvec4 mvPosition \x3d modelViewMatrix * vec4( position, 1.0 );\n\tgl_Position \x3d projectionMatrix * mvPosition;\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}",
meshbasic_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include \x3ccommon\x3e\n#include \x3ccolor_pars_fragment\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cuv2_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3caomap_pars_fragment\x3e\n#include \x3clightmap_pars_fragment\x3e\n#include \x3cenvmap_common_pars_fragment\x3e\n#include \x3cenvmap_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3cspecularmap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_fragment\x3e\n\t#include \x3ccolor_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\t#include \x3cspecularmap_fragment\x3e\n\tReflectedLight reflectedLight \x3d ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\treflectedLight.indirectDiffuse +\x3d texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n\t#else\n\t\treflectedLight.indirectDiffuse +\x3d vec3( 1.0 );\n\t#endif\n\t#include \x3caomap_fragment\x3e\n\treflectedLight.indirectDiffuse *\x3d diffuseColor.rgb;\n\tvec3 outgoingLight \x3d reflectedLight.indirectDiffuse;\n\t#include \x3cenvmap_fragment\x3e\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n}",
meshbasic_vert:"#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cuv2_pars_vertex\x3e\n#include \x3cenvmap_pars_vertex\x3e\n#include \x3ccolor_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cuv2_vertex\x3e\n\t#include \x3ccolor_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#ifdef USE_ENVMAP\n\t#include \x3cbeginnormal_vertex\x3e\n\t#include \x3cmorphnormal_vertex\x3e\n\t#include \x3cskinnormal_vertex\x3e\n\t#include \x3cdefaultnormal_vertex\x3e\n\t#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\t#include \x3cenvmap_vertex\x3e\n\t#include \x3cfog_vertex\x3e\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 \x3ccommon\x3e\n#include \x3cpacking\x3e\n#include \x3cdithering_pars_fragment\x3e\n#include \x3ccolor_pars_fragment\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cuv2_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3caomap_pars_fragment\x3e\n#include \x3clightmap_pars_fragment\x3e\n#include \x3cemissivemap_pars_fragment\x3e\n#include \x3cenvmap_common_pars_fragment\x3e\n#include \x3cenvmap_pars_fragment\x3e\n#include \x3cbsdfs\x3e\n#include \x3clights_pars_begin\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3cshadowmap_pars_fragment\x3e\n#include \x3cshadowmask_pars_fragment\x3e\n#include \x3cspecularmap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\tReflectedLight reflectedLight \x3d ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance \x3d emissive;\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_fragment\x3e\n\t#include \x3ccolor_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\t#include \x3cspecularmap_fragment\x3e\n\t#include \x3cemissivemap_fragment\x3e\n\treflectedLight.indirectDiffuse \x3d getAmbientLightIrradiance( ambientLightColor );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.indirectDiffuse +\x3d ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;\n\t#else\n\t\treflectedLight.indirectDiffuse +\x3d vIndirectFront;\n\t#endif\n\t#include \x3clightmap_fragment\x3e\n\treflectedLight.indirectDiffuse *\x3d BRDF_Diffuse_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse \x3d ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse \x3d vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *\x3d BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include \x3caomap_fragment\x3e\n\tvec3 outgoingLight \x3d reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include \x3cenvmap_fragment\x3e\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3cdithering_fragment\x3e\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 \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cuv2_pars_vertex\x3e\n#include \x3cenvmap_pars_vertex\x3e\n#include \x3cbsdfs\x3e\n#include \x3clights_pars_begin\x3e\n#include \x3ccolor_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3cshadowmap_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cuv2_vertex\x3e\n\t#include \x3ccolor_vertex\x3e\n\t#include \x3cbeginnormal_vertex\x3e\n\t#include \x3cmorphnormal_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#include \x3cskinnormal_vertex\x3e\n\t#include \x3cdefaultnormal_vertex\x3e\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cenvmap_vertex\x3e\n\t#include \x3clights_lambert_vertex\x3e\n\t#include \x3cshadowmap_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}",
meshmatcap_frag:"#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include \x3ccommon\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3cbumpmap_pars_fragment\x3e\n#include \x3cnormalmap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\t#include \x3cnormal_fragment_begin\x3e\n\t#include \x3cnormal_fragment_maps\x3e\n\tvec3 viewDir \x3d normalize( vViewPosition );\n\tvec3 x \x3d normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y \x3d cross( viewDir, x );\n\tvec2 uv \x3d vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor \x3d texture2D( matcap, uv );\n\t\tmatcapColor \x3d matcapTexelToLinear( matcapColor );\n\t#else\n\t\tvec4 matcapColor \x3d vec4( 1.0 );\n\t#endif\n\tvec3 outgoingLight \x3d diffuseColor.rgb * matcapColor.rgb;\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n}",
meshmatcap_vert:"#define MATCAP\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cdisplacementmap_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cbeginnormal_vertex\x3e\n\t#include \x3cmorphnormal_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#include \x3cskinnormal_vertex\x3e\n\t#include \x3cdefaultnormal_vertex\x3e\n\t#ifndef FLAT_SHADED\n\t\tvNormal \x3d normalize( transformedNormal );\n\t#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cdisplacementmap_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n\tvViewPosition \x3d - mvPosition.xyz;\n}",
meshphong_frag:"#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include \x3ccommon\x3e\n#include \x3cpacking\x3e\n#include \x3cdithering_pars_fragment\x3e\n#include \x3ccolor_pars_fragment\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cuv2_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3caomap_pars_fragment\x3e\n#include \x3clightmap_pars_fragment\x3e\n#include \x3cemissivemap_pars_fragment\x3e\n#include \x3cenvmap_common_pars_fragment\x3e\n#include \x3cenvmap_pars_fragment\x3e\n#include \x3cgradientmap_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3cbsdfs\x3e\n#include \x3clights_pars_begin\x3e\n#include \x3clights_phong_pars_fragment\x3e\n#include \x3cshadowmap_pars_fragment\x3e\n#include \x3cbumpmap_pars_fragment\x3e\n#include \x3cnormalmap_pars_fragment\x3e\n#include \x3cspecularmap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\tReflectedLight reflectedLight \x3d ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance \x3d emissive;\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_fragment\x3e\n\t#include \x3ccolor_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\t#include \x3cspecularmap_fragment\x3e\n\t#include \x3cnormal_fragment_begin\x3e\n\t#include \x3cnormal_fragment_maps\x3e\n\t#include \x3cemissivemap_fragment\x3e\n\t#include \x3clights_phong_fragment\x3e\n\t#include \x3clights_fragment_begin\x3e\n\t#include \x3clights_fragment_maps\x3e\n\t#include \x3clights_fragment_end\x3e\n\t#include \x3caomap_fragment\x3e\n\tvec3 outgoingLight \x3d reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include \x3cenvmap_fragment\x3e\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3cdithering_fragment\x3e\n}",
meshphong_vert:"#define PHONG\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cuv2_pars_vertex\x3e\n#include \x3cdisplacementmap_pars_vertex\x3e\n#include \x3cenvmap_pars_vertex\x3e\n#include \x3ccolor_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3cshadowmap_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cuv2_vertex\x3e\n\t#include \x3ccolor_vertex\x3e\n\t#include \x3cbeginnormal_vertex\x3e\n\t#include \x3cmorphnormal_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#include \x3cskinnormal_vertex\x3e\n\t#include \x3cdefaultnormal_vertex\x3e\n#ifndef FLAT_SHADED\n\tvNormal \x3d normalize( transformedNormal );\n#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cdisplacementmap_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\tvViewPosition \x3d - mvPosition.xyz;\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cenvmap_vertex\x3e\n\t#include \x3cshadowmap_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}",
meshphysical_frag:"#define STANDARD\n#ifdef PHYSICAL\n\t#define REFLECTIVITY\n\t#define CLEARCOAT\n\t#define TRANSPARENCY\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef TRANSPARENCY\n\tuniform float transparency;\n#endif\n#ifdef REFLECTIVITY\n\tuniform float reflectivity;\n#endif\n#ifdef CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheen;\n#endif\nvarying vec3 vViewPosition;\n#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\n#include \x3ccommon\x3e\n#include \x3cpacking\x3e\n#include \x3cdithering_pars_fragment\x3e\n#include \x3ccolor_pars_fragment\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cuv2_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3calphamap_pars_fragment\x3e\n#include \x3caomap_pars_fragment\x3e\n#include \x3clightmap_pars_fragment\x3e\n#include \x3cemissivemap_pars_fragment\x3e\n#include \x3cbsdfs\x3e\n#include \x3ccube_uv_reflection_fragment\x3e\n#include \x3cenvmap_common_pars_fragment\x3e\n#include \x3cenvmap_physical_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3clights_pars_begin\x3e\n#include \x3clights_physical_pars_fragment\x3e\n#include \x3cshadowmap_pars_fragment\x3e\n#include \x3cbumpmap_pars_fragment\x3e\n#include \x3cnormalmap_pars_fragment\x3e\n#include \x3cclearcoat_normalmap_pars_fragment\x3e\n#include \x3croughnessmap_pars_fragment\x3e\n#include \x3cmetalnessmap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\tReflectedLight reflectedLight \x3d ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance \x3d emissive;\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_fragment\x3e\n\t#include \x3ccolor_fragment\x3e\n\t#include \x3calphamap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\t#include \x3croughnessmap_fragment\x3e\n\t#include \x3cmetalnessmap_fragment\x3e\n\t#include \x3cnormal_fragment_begin\x3e\n\t#include \x3cnormal_fragment_maps\x3e\n\t#include \x3cclearcoat_normal_fragment_begin\x3e\n\t#include \x3cclearcoat_normal_fragment_maps\x3e\n\t#include \x3cemissivemap_fragment\x3e\n\t#include \x3clights_physical_fragment\x3e\n\t#include \x3clights_fragment_begin\x3e\n\t#include \x3clights_fragment_maps\x3e\n\t#include \x3clights_fragment_end\x3e\n\t#include \x3caomap_fragment\x3e\n\tvec3 outgoingLight \x3d reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#ifdef TRANSPARENCY\n\t\tdiffuseColor.a *\x3d saturate( 1. - transparency + linearToRelativeLuminance( reflectedLight.directSpecular + reflectedLight.indirectSpecular ) );\n\t#endif\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3cdithering_fragment\x3e\n}",
meshphysical_vert:"#define STANDARD\nvarying vec3 vViewPosition;\n#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\n#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cuv2_pars_vertex\x3e\n#include \x3cdisplacementmap_pars_vertex\x3e\n#include \x3ccolor_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3cshadowmap_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cuv2_vertex\x3e\n\t#include \x3ccolor_vertex\x3e\n\t#include \x3cbeginnormal_vertex\x3e\n\t#include \x3cmorphnormal_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#include \x3cskinnormal_vertex\x3e\n\t#include \x3cdefaultnormal_vertex\x3e\n#ifndef FLAT_SHADED\n\tvNormal \x3d normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent \x3d normalize( transformedTangent );\n\t\tvBitangent \x3d normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cdisplacementmap_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\tvViewPosition \x3d - mvPosition.xyz;\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cshadowmap_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}",
normal_frag:"#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#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\n#include \x3cpacking\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cbumpmap_pars_fragment\x3e\n#include \x3cnormalmap_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cnormal_fragment_begin\x3e\n\t#include \x3cnormal_fragment_maps\x3e\n\tgl_FragColor \x3d vec4( packNormalToRGB( normal ), opacity );\n}",
normal_vert:"#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#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\n#include \x3cuv_pars_vertex\x3e\n#include \x3cdisplacementmap_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3cskinning_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\t#include \x3cbeginnormal_vertex\x3e\n\t#include \x3cmorphnormal_vertex\x3e\n\t#include \x3cskinbase_vertex\x3e\n\t#include \x3cskinnormal_vertex\x3e\n\t#include \x3cdefaultnormal_vertex\x3e\n#ifndef FLAT_SHADED\n\tvNormal \x3d normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent \x3d normalize( transformedTangent );\n\t\tvBitangent \x3d normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cskinning_vertex\x3e\n\t#include \x3cdisplacementmap_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvViewPosition \x3d - mvPosition.xyz;\n#endif\n}",
points_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include \x3ccommon\x3e\n#include \x3ccolor_pars_fragment\x3e\n#include \x3cmap_particle_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec3 outgoingLight \x3d vec3( 0.0 );\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_particle_fragment\x3e\n\t#include \x3ccolor_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\toutgoingLight \x3d diffuseColor.rgb;\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3cpremultiplied_alpha_fragment\x3e\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n}",
points_vert:"uniform float size;\nuniform float scale;\n#include \x3ccommon\x3e\n#include \x3ccolor_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3cmorphtarget_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3ccolor_vertex\x3e\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cmorphtarget_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\tgl_PointSize \x3d size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective \x3d ( projectionMatrix[ 2 ][ 3 ] \x3d\x3d - 1.0 );\n\t\tif ( isPerspective ) gl_PointSize *\x3d ( scale / - mvPosition.z );\n\t#endif\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}",
shadow_frag:"uniform vec3 color;\nuniform float opacity;\n#include \x3ccommon\x3e\n#include \x3cpacking\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3cbsdfs\x3e\n#include \x3clights_pars_begin\x3e\n#include \x3cshadowmap_pars_fragment\x3e\n#include \x3cshadowmask_pars_fragment\x3e\nvoid main() {\n\tgl_FragColor \x3d vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include \x3cfog_fragment\x3e\n}",shadow_vert:"#include \x3cfog_pars_vertex\x3e\n#include \x3cshadowmap_pars_vertex\x3e\nvoid main() {\n\t#include \x3cbegin_vertex\x3e\n\t#include \x3cproject_vertex\x3e\n\t#include \x3cworldpos_vertex\x3e\n\t#include \x3cshadowmap_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}",
sprite_frag:"uniform vec3 diffuse;\nuniform float opacity;\n#include \x3ccommon\x3e\n#include \x3cuv_pars_fragment\x3e\n#include \x3cmap_pars_fragment\x3e\n#include \x3cfog_pars_fragment\x3e\n#include \x3clogdepthbuf_pars_fragment\x3e\n#include \x3cclipping_planes_pars_fragment\x3e\nvoid main() {\n\t#include \x3cclipping_planes_fragment\x3e\n\tvec3 outgoingLight \x3d vec3( 0.0 );\n\tvec4 diffuseColor \x3d vec4( diffuse, opacity );\n\t#include \x3clogdepthbuf_fragment\x3e\n\t#include \x3cmap_fragment\x3e\n\t#include \x3calphatest_fragment\x3e\n\toutgoingLight \x3d diffuseColor.rgb;\n\tgl_FragColor \x3d vec4( outgoingLight, diffuseColor.a );\n\t#include \x3ctonemapping_fragment\x3e\n\t#include \x3cencodings_fragment\x3e\n\t#include \x3cfog_fragment\x3e\n}",
sprite_vert:"uniform float rotation;\nuniform vec2 center;\n#include \x3ccommon\x3e\n#include \x3cuv_pars_vertex\x3e\n#include \x3cfog_pars_vertex\x3e\n#include \x3clogdepthbuf_pars_vertex\x3e\n#include \x3cclipping_planes_pars_vertex\x3e\nvoid main() {\n\t#include \x3cuv_vertex\x3e\n\tvec4 mvPosition \x3d modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x \x3d length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y \x3d length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective \x3d ( projectionMatrix[ 2 ][ 3 ] \x3d\x3d - 1.0 );\n\t\tif ( isPerspective ) scale *\x3d - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition \x3d ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x \x3d cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y \x3d sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy +\x3d rotatedPosition;\n\tgl_Position \x3d projectionMatrix * mvPosition;\n\t#include \x3clogdepthbuf_vertex\x3e\n\t#include \x3cclipping_planes_vertex\x3e\n\t#include \x3cfog_vertex\x3e\n}"},
Wa={common:{diffuse:{value:new I(15658734)},opacity:{value:1},map:{value:null},uvTransform:{value:new t},alphaMap:{value:null}},specularmap:{specularMap:{value:null}},envmap:{envMap:{value:null},flipEnvMap:{value:-1},reflectivity:{value:1},refractionRatio:{value:.98},maxMipLevel:{value:0}},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 f(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:2.5E-4},fogNear:{value:1},fogFar:{value:2E3},fogColor:{value:new I(16777215)}},lights:{ambientLightColor:{value:[]},lightProbe:{value:[]},directionalLights:{value:[],properties:{direction:{},color:{},shadow:{},shadowBias:{},
shadowRadius:{},shadowMapSize:{}}},directionalShadowMap:{value:[]},directionalShadowMatrix:{value:[]},spotLights:{value:[],properties:{color:{},position:{},direction:{},distance:{},coneCos:{},penumbraCos:{},decay:{},shadow:{},shadowBias:{},shadowRadius:{},shadowMapSize:{}}},spotShadowMap:{value:[]},spotShadowMatrix:{value:[]},pointLights:{value:[],properties:{color:{},position:{},decay:{},distance:{},shadow:{},shadowBias:{},shadowRadius:{},shadowMapSize:{},shadowCameraNear:{},shadowCameraFar:{}}},
pointShadowMap:{value:[]},pointShadowMatrix:{value:[]},hemisphereLights:{value:[],properties:{direction:{},skyColor:{},groundColor:{}}},rectAreaLights:{value:[],properties:{color:{},position:{},width:{},height:{}}}},points:{diffuse:{value:new I(15658734)},opacity:{value:1},size:{value:1},scale:{value:1},map:{value:null},uvTransform:{value:new t}},sprite:{diffuse:{value:new I(15658734)},opacity:{value:1},center:{value:new f(.5,.5)},rotation:{value:0},map:{value:null},uvTransform:{value:new t}}},Mc=
{basic:{uniforms:Bb([Wa.common,Wa.specularmap,Wa.envmap,Wa.aomap,Wa.lightmap,Wa.fog]),vertexShader:rb.meshbasic_vert,fragmentShader:rb.meshbasic_frag},lambert:{uniforms:Bb([Wa.common,Wa.specularmap,Wa.envmap,Wa.aomap,Wa.lightmap,Wa.emissivemap,Wa.fog,Wa.lights,{emissive:{value:new I(0)}}]),vertexShader:rb.meshlambert_vert,fragmentShader:rb.meshlambert_frag},phong:{uniforms:Bb([Wa.common,Wa.specularmap,Wa.envmap,Wa.aomap,Wa.lightmap,Wa.emissivemap,Wa.bumpmap,Wa.normalmap,Wa.displacementmap,Wa.gradientmap,
Wa.fog,Wa.lights,{emissive:{value:new I(0)},specular:{value:new I(1118481)},shininess:{value:30}}]),vertexShader:rb.meshphong_vert,fragmentShader:rb.meshphong_frag},standard:{uniforms:Bb([Wa.common,Wa.envmap,Wa.aomap,Wa.lightmap,Wa.emissivemap,Wa.bumpmap,Wa.normalmap,Wa.displacementmap,Wa.roughnessmap,Wa.metalnessmap,Wa.fog,Wa.lights,{emissive:{value:new I(0)},roughness:{value:.5},metalness:{value:.5},envMapIntensity:{value:1}}]),vertexShader:rb.meshphysical_vert,fragmentShader:rb.meshphysical_frag},
matcap:{uniforms:Bb([Wa.common,Wa.bumpmap,Wa.normalmap,Wa.displacementmap,Wa.fog,{matcap:{value:null}}]),vertexShader:rb.meshmatcap_vert,fragmentShader:rb.meshmatcap_frag},points:{uniforms:Bb([Wa.points,Wa.fog]),vertexShader:rb.points_vert,fragmentShader:rb.points_frag},dashed:{uniforms:Bb([Wa.common,Wa.fog,{scale:{value:1},dashSize:{value:1},totalSize:{value:2}}]),vertexShader:rb.linedashed_vert,fragmentShader:rb.linedashed_frag},depth:{uniforms:Bb([Wa.common,Wa.displacementmap]),vertexShader:rb.depth_vert,
fragmentShader:rb.depth_frag},normal:{uniforms:Bb([Wa.common,Wa.bumpmap,Wa.normalmap,Wa.displacementmap,{opacity:{value:1}}]),vertexShader:rb.normal_vert,fragmentShader:rb.normal_frag},sprite:{uniforms:Bb([Wa.sprite,Wa.fog]),vertexShader:rb.sprite_vert,fragmentShader:rb.sprite_frag},background:{uniforms:{uvTransform:{value:new t},t2D:{value:null}},vertexShader:rb.background_vert,fragmentShader:rb.background_frag},cube:{uniforms:{tCube:{value:null},tFlip:{value:-1},opacity:{value:1}},vertexShader:rb.cube_vert,
fragmentShader:rb.cube_frag},equirect:{uniforms:{tEquirect:{value:null}},vertexShader:rb.equirect_vert,fragmentShader:rb.equirect_frag},distanceRGBA:{uniforms:Bb([Wa.common,Wa.displacementmap,{referencePosition:{value:new k},nearDistance:{value:1},farDistance:{value:1E3}}]),vertexShader:rb.distanceRGBA_vert,fragmentShader:rb.distanceRGBA_frag},shadow:{uniforms:Bb([Wa.lights,Wa.fog,{color:{value:new I(0)},opacity:{value:1}}]),vertexShader:rb.shadow_vert,fragmentShader:rb.shadow_frag}};Mc.physical=
{uniforms:Bb([Mc.standard.uniforms,{transparency:{value:0},clearcoat:{value:0},clearcoatRoughness:{value:0},sheen:{value:new I(0)},clearcoatNormalScale:{value:new f(1,1)},clearcoatNormalMap:{value:null}}]),vertexShader:rb.meshphysical_vert,fragmentShader:rb.meshphysical_frag};rd.prototype=Object.create(ya.prototype);rd.prototype.constructor=rd;Lc.prototype=Object.create(va.prototype);Lc.prototype.constructor=Lc;cd.prototype=Object.create(l.prototype);cd.prototype.constructor=cd;cd.prototype.isCubeTexture=
!0;Object.defineProperty(cd.prototype,"images",{get:function(){return this.image},set:function(a){this.image=a}});re.prototype=Object.create(l.prototype);re.prototype.constructor=re;re.prototype.isDataTexture2DArray=!0;se.prototype=Object.create(l.prototype);se.prototype.constructor=se;se.prototype.isDataTexture3D=!0;var ij=new l,el=new re,gl=new se,jj=new cd,cj=[],ej=[],hj=new Float32Array(16),gj=new Float32Array(9),fj=new Float32Array(4);kj.prototype.updateCache=function(a){var c=this.cache;a instanceof
Float32Array&&c.length!==a.length&&(this.cache=new Float32Array(a.length));mc(c,a)};lj.prototype.setValue=function(a,c,e){for(var g=this.seq,r=0,v=g.length;r!==v;++r){var z=g[r];z.setValue(a,c[z.id],e)}};var Lh=/([\w\d_]+)(\])?(\[|\.)?/g;ud.prototype.setValue=function(a,c,e,g){c=this.map[c];void 0!==c&&c.setValue(a,e,g)};ud.prototype.setOptional=function(a,c,e){c=c[e];void 0!==c&&this.setValue(a,e,c)};ud.upload=function(a,c,e,g){for(var r=0,v=c.length;r!==v;++r){var z=c[r],E=e[z.id];!1!==E.needsUpdate&&
z.setValue(a,E.value,g)}};ud.seqWithValue=function(a,c){for(var e=[],g=0,r=a.length;g!==r;++g){var v=a[g];v.id in c&&e.push(v)}return e};var Kl=0,Tl=0;vd.prototype=Object.create(M.prototype);vd.prototype.constructor=vd;vd.prototype.isMeshDepthMaterial=!0;vd.prototype.copy=function(a){M.prototype.copy.call(this,a);this.depthPacking=a.depthPacking;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.map=a.map;this.alphaMap=a.alphaMap;this.displacementMap=a.displacementMap;this.displacementScale=
a.displacementScale;this.displacementBias=a.displacementBias;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;return this};wd.prototype=Object.create(M.prototype);wd.prototype.constructor=wd;wd.prototype.isMeshDistanceMaterial=!0;wd.prototype.copy=function(a){M.prototype.copy.call(this,a);this.referencePosition.copy(a.referencePosition);this.nearDistance=a.nearDistance;this.farDistance=a.farDistance;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.map=a.map;this.alphaMap=
a.alphaMap;this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;return this};ue.prototype=Object.assign(Object.create(A.prototype),{constructor:ue,isGroup:!0});vf.prototype=Object.assign(Object.create(vb.prototype),{constructor:vf,isArrayCamera:!0});var yj=new k,zj=new k;Object.assign(Nh.prototype,d.prototype);Object.assign(Aj.prototype,d.prototype);Object.assign(zg.prototype,{isFogExp2:!0,clone:function(){return new zg(this.color,
this.density)},toJSON:function(){return{type:"FogExp2",color:this.color.getHex(),density:this.density}}});Object.assign(Ag.prototype,{isFog:!0,clone:function(){return new Ag(this.color,this.near,this.far)},toJSON:function(){return{type:"Fog",color:this.color.getHex(),near:this.near,far:this.far}}});Object.defineProperty(Qd.prototype,"needsUpdate",{set:function(a){!0===a&&this.version++}});Object.assign(Qd.prototype,{isInterleavedBuffer:!0,onUploadCallback:function(){},setArray:function(a){if(Array.isArray(a))throw new TypeError("THREE.BufferAttribute: array should be a Typed Array.");
this.count=void 0!==a?a.length/this.stride:0;this.array=a;return this},setDynamic:function(a){this.dynamic=a;return this},copy:function(a){this.array=new a.array.constructor(a.array);this.count=a.count;this.stride=a.stride;this.dynamic=a.dynamic;return this},copyAt:function(a,c,e){a*=this.stride;e*=c.stride;for(var g=0,r=this.stride;g<r;g++)this.array[a+g]=c.array[e+g];return this},set:function(a,c){void 0===c&&(c=0);this.array.set(a,c);return this},clone:function(){return(new this.constructor).copy(this)},
onUpload:function(a){this.onUploadCallback=a;return this}});Object.defineProperties(xf.prototype,{count:{get:function(){return this.data.count}},array:{get:function(){return this.data.array}}});Object.assign(xf.prototype,{isInterleavedBufferAttribute:!0,setX:function(a,c){this.data.array[a*this.data.stride+this.offset]=c;return this},setY:function(a,c){this.data.array[a*this.data.stride+this.offset+1]=c;return this},setZ:function(a,c){this.data.array[a*this.data.stride+this.offset+2]=c;return this},
setW:function(a,c){this.data.array[a*this.data.stride+this.offset+3]=c;return this},getX:function(a){return this.data.array[a*this.data.stride+this.offset]},getY:function(a){return this.data.array[a*this.data.stride+this.offset+1]},getZ:function(a){return this.data.array[a*this.data.stride+this.offset+2]},getW:function(a){return this.data.array[a*this.data.stride+this.offset+3]},setXY:function(a,c,e){a=a*this.data.stride+this.offset;this.data.array[a+0]=c;this.data.array[a+1]=e;return this},setXYZ:function(a,
c,e,g){a=a*this.data.stride+this.offset;this.data.array[a+0]=c;this.data.array[a+1]=e;this.data.array[a+2]=g;return this},setXYZW:function(a,c,e,g,r){a=a*this.data.stride+this.offset;this.data.array[a+0]=c;this.data.array[a+1]=e;this.data.array[a+2]=g;this.data.array[a+3]=r;return this}});Ad.prototype=Object.create(M.prototype);Ad.prototype.constructor=Ad;Ad.prototype.isSpriteMaterial=!0;Ad.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);this.map=a.map;this.rotation=
a.rotation;this.sizeAttenuation=a.sizeAttenuation;return this};var Ae,mg=new k,nf=new k,of=new k,Be=new f,zf=new f,Fj=new q,qh=new k,ng=new k,rh=new k,kk=new f,Ki=new f,lk=new f;yf.prototype=Object.assign(Object.create(A.prototype),{constructor:yf,isSprite:!0,raycast:function(a,c){null===a.camera&&console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.');nf.setFromMatrixScale(this.matrixWorld);Fj.copy(a.camera.matrixWorld);this.modelViewMatrix.multiplyMatrices(a.camera.matrixWorldInverse,
this.matrixWorld);of.setFromMatrixPosition(this.modelViewMatrix);a.camera.isPerspectiveCamera&&!1===this.material.sizeAttenuation&&nf.multiplyScalar(-of.z);var e=this.material.rotation;if(0!==e){var g=Math.cos(e);var r=Math.sin(e)}e=this.center;Bg(qh.set(-.5,-.5,0),of,e,nf,r,g);Bg(ng.set(.5,-.5,0),of,e,nf,r,g);Bg(rh.set(.5,.5,0),of,e,nf,r,g);kk.set(0,0);Ki.set(1,0);lk.set(1,1);var v=a.ray.intersectTriangle(qh,ng,rh,!1,mg);if(null===v&&(Bg(ng.set(-.5,.5,0),of,e,nf,r,g),Ki.set(0,1),v=a.ray.intersectTriangle(qh,
rh,ng,!1,mg),null===v))return;r=a.ray.origin.distanceTo(mg);r<a.near||r>a.far||c.push({distance:r,point:mg.clone(),uv:B.getUV(mg,qh,ng,rh,kk,Ki,lk,new f),face:null,object:this})},clone:function(){return(new this.constructor(this.material)).copy(this)},copy:function(a){A.prototype.copy.call(this,a);void 0!==a.center&&this.center.copy(a.center);return this}});var sh=new k,mk=new k;Af.prototype=Object.assign(Object.create(A.prototype),{constructor:Af,isLOD:!0,copy:function(a){A.prototype.copy.call(this,
a,!1);a=a.levels;for(var c=0,e=a.length;c<e;c++){var g=a[c];this.addLevel(g.object.clone(),g.distance)}return this},addLevel:function(a,c){void 0===c&&(c=0);c=Math.abs(c);for(var e=this.levels,g=0;g<e.length&&!(c<e[g].distance);g++);e.splice(g,0,{distance:c,object:a});this.add(a);return this},getObjectForDistance:function(a){for(var c=this.levels,e=1,g=c.length;e<g&&!(a<c[e].distance);e++);return c[e-1].object},raycast:function(a,c){sh.setFromMatrixPosition(this.matrixWorld);this.getObjectForDistance(a.ray.origin.distanceTo(sh)).raycast(a,
c)},update:function(a){var c=this.levels;if(1<c.length){sh.setFromMatrixPosition(a.matrixWorld);mk.setFromMatrixPosition(this.matrixWorld);a=sh.distanceTo(mk);c[0].object.visible=!0;for(var e=1,g=c.length;e<g;e++)if(a>=c[e].distance)c[e-1].object.visible=!1,c[e].object.visible=!0;else break;for(;e<g;e++)c[e].object.visible=!1}},toJSON:function(a){a=A.prototype.toJSON.call(this,a);a.object.levels=[];for(var c=this.levels,e=0,g=c.length;e<g;e++){var r=c[e];a.object.levels.push({object:r.object.uuid,
distance:r.distance})}return a}});Bf.prototype=Object.assign(Object.create(xa.prototype),{constructor:Bf,isSkinnedMesh:!0,bind:function(a,c){this.skeleton=a;void 0===c&&(this.updateMatrixWorld(!0),this.skeleton.calculateInverses(),c=this.matrixWorld);this.bindMatrix.copy(c);this.bindMatrixInverse.getInverse(c)},pose:function(){this.skeleton.pose()},normalizeSkinWeights:function(){for(var a=new p,c=this.geometry.attributes.skinWeight,e=0,g=c.count;e<g;e++){a.x=c.getX(e);a.y=c.getY(e);a.z=c.getZ(e);
a.w=c.getW(e);var r=1/a.manhattanLength();Infinity!==r?a.multiplyScalar(r):a.set(1,0,0,0);c.setXYZW(e,a.x,a.y,a.z,a.w)}},updateMatrixWorld:function(a){xa.prototype.updateMatrixWorld.call(this,a);"attached"===this.bindMode?this.bindMatrixInverse.getInverse(this.matrixWorld):"detached"===this.bindMode?this.bindMatrixInverse.getInverse(this.bindMatrix):console.warn("THREE.SkinnedMesh: Unrecognized bindMode: "+this.bindMode)},clone:function(){return(new this.constructor(this.geometry,this.material)).copy(this)}});
var nk=new q,Im=new q;Object.assign(Cg.prototype,{calculateInverses:function(){this.boneInverses=[];for(var a=0,c=this.bones.length;a<c;a++){var e=new q;this.bones[a]&&e.getInverse(this.bones[a].matrixWorld);this.boneInverses.push(e)}},pose:function(){var a,c;var e=0;for(c=this.bones.length;e<c;e++)(a=this.bones[e])&&a.matrixWorld.getInverse(this.boneInverses[e]);e=0;for(c=this.bones.length;e<c;e++)if(a=this.bones[e])a.parent&&a.parent.isBone?(a.matrix.getInverse(a.parent.matrixWorld),a.matrix.multiply(a.matrixWorld)):
a.matrix.copy(a.matrixWorld),a.matrix.decompose(a.position,a.quaternion,a.scale)},update:function(){for(var a=this.bones,c=this.boneInverses,e=this.boneMatrices,g=this.boneTexture,r=0,v=a.length;r<v;r++)nk.multiplyMatrices(a[r]?a[r].matrixWorld:Im,c[r]),nk.toArray(e,16*r);void 0!==g&&(g.needsUpdate=!0)},clone:function(){return new Cg(this.bones,this.boneInverses)},getBoneByName:function(a){for(var c=0,e=this.bones.length;c<e;c++){var g=this.bones[c];if(g.name===a)return g}}});Uh.prototype=Object.assign(Object.create(A.prototype),
{constructor:Uh,isBone:!0});Fb.prototype=Object.create(M.prototype);Fb.prototype.constructor=Fb;Fb.prototype.isLineBasicMaterial=!0;Fb.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);this.linewidth=a.linewidth;this.linecap=a.linecap;this.linejoin=a.linejoin;return this};var ok=new k,pk=new k,qk=new q,th=new D,og=new G;Vb.prototype=Object.assign(Object.create(A.prototype),{constructor:Vb,isLine:!0,computeLineDistances:function(){var a=this.geometry;if(a.isBufferGeometry)if(null===
a.index){for(var c=a.attributes.position,e=[0],g=1,r=c.count;g<r;g++)ok.fromBufferAttribute(c,g-1),pk.fromBufferAttribute(c,g),e[g]=e[g-1],e[g]+=ok.distanceTo(pk);a.addAttribute("lineDistance",new ca(e,1))}else console.warn("THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else if(a.isGeometry)for(c=a.vertices,e=a.lineDistances,e[0]=0,g=1,r=c.length;g<r;g++)e[g]=e[g-1],e[g]+=c[g-1].distanceTo(c[g]);return this},raycast:function(a,c){var e=a.linePrecision,
g=this.geometry,r=this.matrixWorld;null===g.boundingSphere&&g.computeBoundingSphere();og.copy(g.boundingSphere);og.applyMatrix4(r);og.radius+=e;if(!1!==a.ray.intersectsSphere(og)){qk.getInverse(r);th.copy(a.ray).applyMatrix4(qk);e/=(this.scale.x+this.scale.y+this.scale.z)/3;e*=e;var v=new k,z=new k;r=new k;var E=new k,F=this&&this.isLineSegments?2:1;if(g.isBufferGeometry){var J=g.index,P=g.attributes.position.array;if(null!==J){J=J.array;g=0;for(var R=J.length-1;g<R;g+=F){var S=J[g+1];v.fromArray(P,
3*J[g]);z.fromArray(P,3*S);S=th.distanceSqToSegment(v,z,E,r);S>e||(E.applyMatrix4(this.matrixWorld),S=a.ray.origin.distanceTo(E),S<a.near||S>a.far||c.push({distance:S,point:r.clone().applyMatrix4(this.matrixWorld),index:g,face:null,faceIndex:null,object:this}))}}else for(g=0,R=P.length/3-1;g<R;g+=F)v.fromArray(P,3*g),z.fromArray(P,3*g+3),S=th.distanceSqToSegment(v,z,E,r),S>e||(E.applyMatrix4(this.matrixWorld),S=a.ray.origin.distanceTo(E),S<a.near||S>a.far||c.push({distance:S,point:r.clone().applyMatrix4(this.matrixWorld),
index:g,face:null,faceIndex:null,object:this}))}else if(g.isGeometry)for(v=g.vertices,z=v.length,g=0;g<z-1;g+=F)S=th.distanceSqToSegment(v[g],v[g+1],E,r),S>e||(E.applyMatrix4(this.matrixWorld),S=a.ray.origin.distanceTo(E),S<a.near||S>a.far||c.push({distance:S,point:r.clone().applyMatrix4(this.matrixWorld),index:g,face:null,faceIndex:null,object:this}))}},clone:function(){return(new this.constructor(this.geometry,this.material)).copy(this)}});var uh=new k,vh=new k;Ib.prototype=Object.assign(Object.create(Vb.prototype),
{constructor:Ib,isLineSegments:!0,computeLineDistances:function(){var a=this.geometry;if(a.isBufferGeometry)if(null===a.index){for(var c=a.attributes.position,e=[],g=0,r=c.count;g<r;g+=2)uh.fromBufferAttribute(c,g),vh.fromBufferAttribute(c,g+1),e[g]=0===g?0:e[g-1],e[g+1]=e[g]+uh.distanceTo(vh);a.addAttribute("lineDistance",new ca(e,1))}else console.warn("THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.");else if(a.isGeometry)for(c=a.vertices,e=
a.lineDistances,g=0,r=c.length;g<r;g+=2)uh.copy(c[g]),vh.copy(c[g+1]),e[g]=0===g?0:e[g-1],e[g+1]=e[g]+uh.distanceTo(vh);return this}});Dg.prototype=Object.assign(Object.create(Vb.prototype),{constructor:Dg,isLineLoop:!0});Ac.prototype=Object.create(M.prototype);Ac.prototype.constructor=Ac;Ac.prototype.isPointsMaterial=!0;Ac.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);this.map=a.map;this.size=a.size;this.sizeAttenuation=a.sizeAttenuation;this.morphTargets=a.morphTargets;
return this};var rk=new q,Wh=new D,pg=new G,wh=new k;Ce.prototype=Object.assign(Object.create(A.prototype),{constructor:Ce,isPoints:!0,raycast:function(a,c){var e=this.geometry,g=this.matrixWorld,r=a.params.Points.threshold;null===e.boundingSphere&&e.computeBoundingSphere();pg.copy(e.boundingSphere);pg.applyMatrix4(g);pg.radius+=r;if(!1!==a.ray.intersectsSphere(pg))if(rk.getInverse(g),Wh.copy(a.ray).applyMatrix4(rk),r/=(this.scale.x+this.scale.y+this.scale.z)/3,r*=r,e.isBufferGeometry){var v=e.index;
e=e.attributes.position.array;if(null!==v){var z=v.array;v=0;for(var E=z.length;v<E;v++){var F=z[v];wh.fromArray(e,3*F);Vh(wh,F,r,g,a,c,this)}}else for(v=0,z=e.length/3;v<z;v++)wh.fromArray(e,3*v),Vh(wh,v,r,g,a,c,this)}else for(e=e.vertices,v=0,z=e.length;v<z;v++)Vh(e[v],v,r,g,a,c,this)},updateMorphTargets:function(){var a=this.geometry;if(a.isBufferGeometry){a=a.morphAttributes;var c=Object.keys(a);if(0<c.length){var e=a[c[0]];if(void 0!==e)for(this.morphTargetInfluences=[],this.morphTargetDictionary=
{},a=0,c=e.length;a<c;a++){var g=e[a].name||String(a);this.morphTargetInfluences.push(0);this.morphTargetDictionary[g]=a}}}else a=a.morphTargets,void 0!==a&&0<a.length&&console.error("THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.")},clone:function(){return(new this.constructor(this.geometry,this.material)).copy(this)}});Xh.prototype=Object.assign(Object.create(l.prototype),{constructor:Xh,isVideoTexture:!0,update:function(){var a=this.image;a.readyState>=
a.HAVE_CURRENT_DATA&&(this.needsUpdate=!0)}});De.prototype=Object.create(l.prototype);De.prototype.constructor=De;De.prototype.isCompressedTexture=!0;Cf.prototype=Object.create(l.prototype);Cf.prototype.constructor=Cf;Cf.prototype.isCanvasTexture=!0;Df.prototype=Object.create(l.prototype);Df.prototype.constructor=Df;Df.prototype.isDepthTexture=!0;Ee.prototype=Object.create(va.prototype);Ee.prototype.constructor=Ee;Ef.prototype=Object.create(ya.prototype);Ef.prototype.constructor=Ef;Fe.prototype=Object.create(va.prototype);
Fe.prototype.constructor=Fe;Ff.prototype=Object.create(ya.prototype);Ff.prototype.constructor=Ff;jc.prototype=Object.create(va.prototype);jc.prototype.constructor=jc;Gf.prototype=Object.create(ya.prototype);Gf.prototype.constructor=Gf;Ge.prototype=Object.create(jc.prototype);Ge.prototype.constructor=Ge;Hf.prototype=Object.create(ya.prototype);Hf.prototype.constructor=Hf;Rd.prototype=Object.create(jc.prototype);Rd.prototype.constructor=Rd;If.prototype=Object.create(ya.prototype);If.prototype.constructor=
If;He.prototype=Object.create(jc.prototype);He.prototype.constructor=He;Jf.prototype=Object.create(ya.prototype);Jf.prototype.constructor=Jf;Ie.prototype=Object.create(jc.prototype);Ie.prototype.constructor=Ie;Kf.prototype=Object.create(ya.prototype);Kf.prototype.constructor=Kf;Sd.prototype=Object.create(va.prototype);Sd.prototype.constructor=Sd;Sd.prototype.toJSON=function(){var a=va.prototype.toJSON.call(this);a.path=this.parameters.path.toJSON();return a};Lf.prototype=Object.create(ya.prototype);
Lf.prototype.constructor=Lf;Je.prototype=Object.create(va.prototype);Je.prototype.constructor=Je;Mf.prototype=Object.create(ya.prototype);Mf.prototype.constructor=Mf;Ke.prototype=Object.create(va.prototype);Ke.prototype.constructor=Ke;var Jm={triangulate:function(a,c,e){e=e||2;var g=c&&c.length,r=g?c[0]*e:a.length,v=Gj(a,0,r,e,!0),z=[];if(!v||v.next===v.prev)return z;g&&(v=dm(a,c,v,e));if(a.length>80*e){var E=c=a[0];var F=g=a[1];for(var J=e;J<r;J+=e){var P=a[J];var R=a[J+1];P<E&&(E=P);R<F&&(F=R);
P>c&&(c=P);R>g&&(g=R)}P=Math.max(c-E,g-F);P=0!==P?1/P:0}Pf(v,z,e,E,F,P);return z}},ed={area:function(a){for(var c=a.length,e=0,g=c-1,r=0;r<c;g=r++)e+=a[g].x*a[r].y-a[r].x*a[g].y;return.5*e},isClockWise:function(a){return 0>ed.area(a)},triangulateShape:function(a,c){var e=[],g=[],r=[];Kj(a);Lj(e,a);var v=a.length;c.forEach(Kj);for(a=0;a<c.length;a++)g.push(v),v+=c[a].length,Lj(e,c[a]);c=Jm.triangulate(e,g);for(a=0;a<c.length;a+=3)r.push(c.slice(a,a+3));return r}};Ud.prototype=Object.create(ya.prototype);
Ud.prototype.constructor=Ud;Ud.prototype.toJSON=function(){var a=ya.prototype.toJSON.call(this);return Mj(this.parameters.shapes,this.parameters.options,a)};Rc.prototype=Object.create(va.prototype);Rc.prototype.constructor=Rc;Rc.prototype.toJSON=function(){var a=va.prototype.toJSON.call(this);return Mj(this.parameters.shapes,this.parameters.options,a)};var lm={generateTopUV:function(a,c,e,g,r){a=c[3*g];g=c[3*g+1];var v=c[3*r];r=c[3*r+1];return[new f(c[3*e],c[3*e+1]),new f(a,g),new f(v,r)]},generateSideWallUV:function(a,
c,e,g,r,v){a=c[3*e];var z=c[3*e+1];e=c[3*e+2];var E=c[3*g],F=c[3*g+1];g=c[3*g+2];var J=c[3*r],P=c[3*r+1];r=c[3*r+2];var R=c[3*v],S=c[3*v+1];c=c[3*v+2];return.01>Math.abs(z-F)?[new f(a,1-e),new f(E,1-g),new f(J,1-r),new f(R,1-c)]:[new f(z,1-e),new f(F,1-g),new f(P,1-r),new f(S,1-c)]}};Rf.prototype=Object.create(ya.prototype);Rf.prototype.constructor=Rf;Me.prototype=Object.create(Rc.prototype);Me.prototype.constructor=Me;Sf.prototype=Object.create(ya.prototype);Sf.prototype.constructor=Sf;Bd.prototype=
Object.create(va.prototype);Bd.prototype.constructor=Bd;Tf.prototype=Object.create(ya.prototype);Tf.prototype.constructor=Tf;Ne.prototype=Object.create(va.prototype);Ne.prototype.constructor=Ne;Uf.prototype=Object.create(ya.prototype);Uf.prototype.constructor=Uf;Oe.prototype=Object.create(va.prototype);Oe.prototype.constructor=Oe;Vd.prototype=Object.create(ya.prototype);Vd.prototype.constructor=Vd;Vd.prototype.toJSON=function(){var a=ya.prototype.toJSON.call(this);return Nj(this.parameters.shapes,
a)};Wd.prototype=Object.create(va.prototype);Wd.prototype.constructor=Wd;Wd.prototype.toJSON=function(){var a=va.prototype.toJSON.call(this);return Nj(this.parameters.shapes,a)};Pe.prototype=Object.create(va.prototype);Pe.prototype.constructor=Pe;Xd.prototype=Object.create(ya.prototype);Xd.prototype.constructor=Xd;fd.prototype=Object.create(va.prototype);fd.prototype.constructor=fd;Vf.prototype=Object.create(Xd.prototype);Vf.prototype.constructor=Vf;Wf.prototype=Object.create(fd.prototype);Wf.prototype.constructor=
Wf;Xf.prototype=Object.create(ya.prototype);Xf.prototype.constructor=Xf;Qe.prototype=Object.create(va.prototype);Qe.prototype.constructor=Qe;var gc=Object.freeze({WireframeGeometry:Ee,ParametricGeometry:Ef,ParametricBufferGeometry:Fe,TetrahedronGeometry:Gf,TetrahedronBufferGeometry:Ge,OctahedronGeometry:Hf,OctahedronBufferGeometry:Rd,IcosahedronGeometry:If,IcosahedronBufferGeometry:He,DodecahedronGeometry:Jf,DodecahedronBufferGeometry:Ie,PolyhedronGeometry:Ff,PolyhedronBufferGeometry:jc,TubeGeometry:Kf,
TubeBufferGeometry:Sd,TorusKnotGeometry:Lf,TorusKnotBufferGeometry:Je,TorusGeometry:Mf,TorusBufferGeometry:Ke,TextGeometry:Rf,TextBufferGeometry:Me,SphereGeometry:Sf,SphereBufferGeometry:Bd,RingGeometry:Tf,RingBufferGeometry:Ne,PlaneGeometry:rd,PlaneBufferGeometry:Lc,LatheGeometry:Uf,LatheBufferGeometry:Oe,ShapeGeometry:Vd,ShapeBufferGeometry:Wd,ExtrudeGeometry:Ud,ExtrudeBufferGeometry:Rc,EdgesGeometry:Pe,ConeGeometry:Vf,ConeBufferGeometry:Wf,CylinderGeometry:Xd,CylinderBufferGeometry:fd,CircleGeometry:Xf,
CircleBufferGeometry:Qe,BoxGeometry:Sa,BoxBufferGeometry:Xa});Yd.prototype=Object.create(M.prototype);Yd.prototype.constructor=Yd;Yd.prototype.isShadowMaterial=!0;Yd.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);return this};Re.prototype=Object.create(qb.prototype);Re.prototype.constructor=Re;Re.prototype.isRawShaderMaterial=!0;Sc.prototype=Object.create(M.prototype);Sc.prototype.constructor=Sc;Sc.prototype.isMeshStandardMaterial=!0;Sc.prototype.copy=function(a){M.prototype.copy.call(this,
a);this.defines={STANDARD:""};this.color.copy(a.color);this.roughness=a.roughness;this.metalness=a.metalness;this.map=a.map;this.lightMap=a.lightMap;this.lightMapIntensity=a.lightMapIntensity;this.aoMap=a.aoMap;this.aoMapIntensity=a.aoMapIntensity;this.emissive.copy(a.emissive);this.emissiveMap=a.emissiveMap;this.emissiveIntensity=a.emissiveIntensity;this.bumpMap=a.bumpMap;this.bumpScale=a.bumpScale;this.normalMap=a.normalMap;this.normalMapType=a.normalMapType;this.normalScale.copy(a.normalScale);
this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;this.roughnessMap=a.roughnessMap;this.metalnessMap=a.metalnessMap;this.alphaMap=a.alphaMap;this.envMap=a.envMap;this.envMapIntensity=a.envMapIntensity;this.refractionRatio=a.refractionRatio;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.wireframeLinecap=a.wireframeLinecap;this.wireframeLinejoin=a.wireframeLinejoin;this.skinning=a.skinning;this.morphTargets=
a.morphTargets;this.morphNormals=a.morphNormals;return this};Zd.prototype=Object.create(Sc.prototype);Zd.prototype.constructor=Zd;Zd.prototype.isMeshPhysicalMaterial=!0;Zd.prototype.copy=function(a){Sc.prototype.copy.call(this,a);this.defines={STANDARD:"",PHYSICAL:""};this.reflectivity=a.reflectivity;this.clearcoat=a.clearcoat;this.clearcoatRoughness=a.clearcoatRoughness;this.sheen=a.sheen?(this.sheen||new I).copy(a.sheen):null;this.clearcoatNormalMap=a.clearcoatNormalMap;this.clearcoatNormalScale.copy(a.clearcoatNormalScale);
this.transparency=a.transparency;return this};Bc.prototype=Object.create(M.prototype);Bc.prototype.constructor=Bc;Bc.prototype.isMeshPhongMaterial=!0;Bc.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);this.specular.copy(a.specular);this.shininess=a.shininess;this.map=a.map;this.lightMap=a.lightMap;this.lightMapIntensity=a.lightMapIntensity;this.aoMap=a.aoMap;this.aoMapIntensity=a.aoMapIntensity;this.emissive.copy(a.emissive);this.emissiveMap=a.emissiveMap;this.emissiveIntensity=
a.emissiveIntensity;this.bumpMap=a.bumpMap;this.bumpScale=a.bumpScale;this.normalMap=a.normalMap;this.normalMapType=a.normalMapType;this.normalScale.copy(a.normalScale);this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;this.specularMap=a.specularMap;this.alphaMap=a.alphaMap;this.envMap=a.envMap;this.combine=a.combine;this.reflectivity=a.reflectivity;this.refractionRatio=a.refractionRatio;this.wireframe=a.wireframe;this.wireframeLinewidth=
a.wireframeLinewidth;this.wireframeLinecap=a.wireframeLinecap;this.wireframeLinejoin=a.wireframeLinejoin;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};$d.prototype=Object.create(Bc.prototype);$d.prototype.constructor=$d;$d.prototype.isMeshToonMaterial=!0;$d.prototype.copy=function(a){Bc.prototype.copy.call(this,a);this.gradientMap=a.gradientMap;return this};ae.prototype=Object.create(M.prototype);ae.prototype.constructor=ae;ae.prototype.isMeshNormalMaterial=
!0;ae.prototype.copy=function(a){M.prototype.copy.call(this,a);this.bumpMap=a.bumpMap;this.bumpScale=a.bumpScale;this.normalMap=a.normalMap;this.normalMapType=a.normalMapType;this.normalScale.copy(a.normalScale);this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};
be.prototype=Object.create(M.prototype);be.prototype.constructor=be;be.prototype.isMeshLambertMaterial=!0;be.prototype.copy=function(a){M.prototype.copy.call(this,a);this.color.copy(a.color);this.map=a.map;this.lightMap=a.lightMap;this.lightMapIntensity=a.lightMapIntensity;this.aoMap=a.aoMap;this.aoMapIntensity=a.aoMapIntensity;this.emissive.copy(a.emissive);this.emissiveMap=a.emissiveMap;this.emissiveIntensity=a.emissiveIntensity;this.specularMap=a.specularMap;this.alphaMap=a.alphaMap;this.envMap=
a.envMap;this.combine=a.combine;this.reflectivity=a.reflectivity;this.refractionRatio=a.refractionRatio;this.wireframe=a.wireframe;this.wireframeLinewidth=a.wireframeLinewidth;this.wireframeLinecap=a.wireframeLinecap;this.wireframeLinejoin=a.wireframeLinejoin;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};ce.prototype=Object.create(M.prototype);ce.prototype.constructor=ce;ce.prototype.isMeshMatcapMaterial=!0;ce.prototype.copy=function(a){M.prototype.copy.call(this,
a);this.defines={MATCAP:""};this.color.copy(a.color);this.matcap=a.matcap;this.map=a.map;this.bumpMap=a.bumpMap;this.bumpScale=a.bumpScale;this.normalMap=a.normalMap;this.normalMapType=a.normalMapType;this.normalScale.copy(a.normalScale);this.displacementMap=a.displacementMap;this.displacementScale=a.displacementScale;this.displacementBias=a.displacementBias;this.alphaMap=a.alphaMap;this.skinning=a.skinning;this.morphTargets=a.morphTargets;this.morphNormals=a.morphNormals;return this};de.prototype=
Object.create(Fb.prototype);de.prototype.constructor=de;de.prototype.isLineDashedMaterial=!0;de.prototype.copy=function(a){Fb.prototype.copy.call(this,a);this.scale=a.scale;this.dashSize=a.dashSize;this.gapSize=a.gapSize;return this};var Km=Object.freeze({ShadowMaterial:Yd,SpriteMaterial:Ad,RawShaderMaterial:Re,ShaderMaterial:qb,PointsMaterial:Ac,MeshPhysicalMaterial:Zd,MeshStandardMaterial:Sc,MeshPhongMaterial:Bc,MeshToonMaterial:$d,MeshNormalMaterial:ae,MeshLambertMaterial:be,MeshDepthMaterial:vd,
MeshDistanceMaterial:wd,MeshBasicMaterial:L,MeshMatcapMaterial:ce,LineDashedMaterial:de,LineBasicMaterial:Fb,Material:M}),Tb={arraySlice:function(a,c,e){return Tb.isTypedArray(a)?new a.constructor(a.subarray(c,void 0!==e?e:a.length)):a.slice(c,e)},convertArray:function(a,c,e){return!a||!e&&a.constructor===c?a:"number"===typeof c.BYTES_PER_ELEMENT?new c(a):Array.prototype.slice.call(a)},isTypedArray:function(a){return ArrayBuffer.isView(a)&&!(a instanceof DataView)},getKeyframeOrder:function(a){for(var c=
a.length,e=Array(c),g=0;g!==c;++g)e[g]=g;e.sort(function(r,v){return a[r]-a[v]});return e},sortedArray:function(a,c,e){for(var g=a.length,r=new a.constructor(g),v=0,z=0;z!==g;++v)for(var E=e[v]*c,F=0;F!==c;++F)r[z++]=a[E+F];return r},flattenJSON:function(a,c,e,g){for(var r=1,v=a[0];void 0!==v&&void 0===v[g];)v=a[r++];if(void 0!==v){var z=v[g];if(void 0!==z)if(Array.isArray(z)){do z=v[g],void 0!==z&&(c.push(v.time),e.push.apply(e,z)),v=a[r++];while(void 0!==v)}else if(void 0!==z.toArray){do z=v[g],
void 0!==z&&(c.push(v.time),z.toArray(e,e.length)),v=a[r++];while(void 0!==v)}else{do z=v[g],void 0!==z&&(c.push(v.time),e.push(z)),v=a[r++];while(void 0!==v)}}}};Object.assign(oc.prototype,{evaluate:function(a){var c=this.parameterPositions,e=this._cachedIndex,g=c[e],r=c[e-1];a:{b:{c:{d:if(!(a<g)){for(var v=e+2;;){if(void 0===g){if(a<r)break d;this._cachedIndex=e=c.length;return this.afterEnd_(e-1,a,r)}if(e===v)break;r=g;g=c[++e];if(a<g)break b}g=c.length;break c}if(a>=r)break a;else{v=c[1];a<v&&
(e=2,r=v);for(v=e-2;;){if(void 0===r)return this._cachedIndex=0,this.beforeStart_(0,a,g);if(e===v)break;g=r;r=c[--e-1];if(a>=r)break b}g=e;e=0}}for(;e<g;)r=e+g>>>1,a<c[r]?g=r:e=r+1;g=c[e];r=c[e-1];if(void 0===r)return this._cachedIndex=0,this.beforeStart_(0,a,g);if(void 0===g)return this._cachedIndex=e=c.length,this.afterEnd_(e-1,r,a)}this._cachedIndex=e;this.intervalChanged_(e,r,g)}return this.interpolate_(e,r,a,g)},settings:null,DefaultSettings_:{},getSettings_:function(){return this.settings||
this.DefaultSettings_},copySampleValue_:function(a){var c=this.resultBuffer,e=this.sampleValues,g=this.valueSize;a*=g;for(var r=0;r!==g;++r)c[r]=e[a+r];return c},interpolate_:function(){throw Error("call to abstract method");},intervalChanged_:function(){}});Object.assign(oc.prototype,{beforeStart_:oc.prototype.copySampleValue_,afterEnd_:oc.prototype.copySampleValue_});Eg.prototype=Object.assign(Object.create(oc.prototype),{constructor:Eg,DefaultSettings_:{endingStart:2400,endingEnd:2400},intervalChanged_:function(a,
c,e){var g=this.parameterPositions,r=a-2,v=a+1,z=g[r],E=g[v];if(void 0===z)switch(this.getSettings_().endingStart){case 2401:r=a;z=2*c-e;break;case 2402:r=g.length-2;z=c+g[r]-g[r+1];break;default:r=a,z=e}if(void 0===E)switch(this.getSettings_().endingEnd){case 2401:v=a;E=2*e-c;break;case 2402:v=1;E=e+g[1]-g[0];break;default:v=a-1,E=c}a=.5*(e-c);g=this.valueSize;this._weightPrev=a/(c-z);this._weightNext=a/(E-e);this._offsetPrev=r*g;this._offsetNext=v*g},interpolate_:function(a,c,e,g){var r=this.resultBuffer,
v=this.sampleValues,z=this.valueSize;a*=z;var E=a-z,F=this._offsetPrev,J=this._offsetNext,P=this._weightPrev,R=this._weightNext,S=(e-c)/(g-c);e=S*S;g=e*S;c=-P*g+2*P*e-P*S;P=(1+P)*g+(-1.5-2*P)*e+(-.5+P)*S+1;S=(-1-R)*g+(1.5+R)*e+.5*S;R=R*g-R*e;for(e=0;e!==z;++e)r[e]=c*v[F+e]+P*v[E+e]+S*v[a+e]+R*v[J+e];return r}});Yf.prototype=Object.assign(Object.create(oc.prototype),{constructor:Yf,interpolate_:function(a,c,e,g){var r=this.resultBuffer,v=this.sampleValues,z=this.valueSize;a*=z;var E=a-z;c=(e-c)/(g-
c);e=1-c;for(g=0;g!==z;++g)r[g]=v[E+g]*e+v[a+g]*c;return r}});Fg.prototype=Object.assign(Object.create(oc.prototype),{constructor:Fg,interpolate_:function(a){return this.copySampleValue_(a-1)}});Object.assign(Xb,{toJSON:function(a){var c=a.constructor;if(void 0!==c.toJSON)c=c.toJSON(a);else{c={name:a.name,times:Tb.convertArray(a.times,Array),values:Tb.convertArray(a.values,Array)};var e=a.getInterpolation();e!==a.DefaultInterpolation&&(c.interpolation=e)}c.type=a.ValueTypeName;return c}});Object.assign(Xb.prototype,
{constructor:Xb,TimeBufferType:Float32Array,ValueBufferType:Float32Array,DefaultInterpolation:2301,InterpolantFactoryMethodDiscrete:function(a){return new Fg(this.times,this.values,this.getValueSize(),a)},InterpolantFactoryMethodLinear:function(a){return new Yf(this.times,this.values,this.getValueSize(),a)},InterpolantFactoryMethodSmooth:function(a){return new Eg(this.times,this.values,this.getValueSize(),a)},setInterpolation:function(a){switch(a){case 2300:var c=this.InterpolantFactoryMethodDiscrete;
break;case 2301:c=this.InterpolantFactoryMethodLinear;break;case 2302:c=this.InterpolantFactoryMethodSmooth}if(void 0===c){c="unsupported interpolation for "+this.ValueTypeName+" keyframe track named "+this.name;if(void 0===this.createInterpolant)if(a!==this.DefaultInterpolation)this.setInterpolation(this.DefaultInterpolation);else throw Error(c);console.warn("THREE.KeyframeTrack:",c);return this}this.createInterpolant=c;return this},getInterpolation:function(){switch(this.createInterpolant){case this.InterpolantFactoryMethodDiscrete:return 2300;
case this.InterpolantFactoryMethodLinear:return 2301;case this.InterpolantFactoryMethodSmooth:return 2302}},getValueSize:function(){return this.values.length/this.times.length},shift:function(a){if(0!==a)for(var c=this.times,e=0,g=c.length;e!==g;++e)c[e]+=a;return this},scale:function(a){if(1!==a)for(var c=this.times,e=0,g=c.length;e!==g;++e)c[e]*=a;return this},trim:function(a,c){for(var e=this.times,g=e.length,r=0,v=g-1;r!==g&&e[r]<a;)++r;for(;-1!==v&&e[v]>c;)--v;++v;if(0!==r||v!==g)r>=v&&(v=Math.max(v,
1),r=v-1),a=this.getValueSize(),this.times=Tb.arraySlice(e,r,v),this.values=Tb.arraySlice(this.values,r*a,v*a);return this},validate:function(){var a=!0,c=this.getValueSize();0!==c-Math.floor(c)&&(console.error("THREE.KeyframeTrack: Invalid value size in track.",this),a=!1);var e=this.times;c=this.values;var g=e.length;0===g&&(console.error("THREE.KeyframeTrack: Track is empty.",this),a=!1);for(var r=null,v=0;v!==g;v++){var z=e[v];if("number"===typeof z&&isNaN(z)){console.error("THREE.KeyframeTrack: Time is not a valid number.",
this,v,z);a=!1;break}if(null!==r&&r>z){console.error("THREE.KeyframeTrack: Out of order keys.",this,v,z,r);a=!1;break}r=z}if(void 0!==c&&Tb.isTypedArray(c))for(v=0,e=c.length;v!==e;++v)if(g=c[v],isNaN(g)){console.error("THREE.KeyframeTrack: Value is not a valid number.",this,v,g);a=!1;break}return a},optimize:function(){for(var a=this.times,c=this.values,e=this.getValueSize(),g=2302===this.getInterpolation(),r=1,v=a.length-1,z=1;z<v;++z){var E=!1,F=a[z];if(F!==a[z+1]&&(1!==z||F!==F[0]))if(g)E=!0;
else{var J=z*e,P=J-e,R=J+e;for(F=0;F!==e;++F){var S=c[J+F];if(S!==c[P+F]||S!==c[R+F]){E=!0;break}}}if(E){if(z!==r)for(a[r]=a[z],E=z*e,J=r*e,F=0;F!==e;++F)c[J+F]=c[E+F];++r}}if(0<v){a[r]=a[v];E=v*e;J=r*e;for(F=0;F!==e;++F)c[J+F]=c[E+F];++r}r!==a.length&&(this.times=Tb.arraySlice(a,0,r),this.values=Tb.arraySlice(c,0,r*e));return this},clone:function(){var a=Tb.arraySlice(this.times,0),c=Tb.arraySlice(this.values,0);a=new this.constructor(this.name,a,c);a.createInterpolant=this.createInterpolant;return a}});
Gg.prototype=Object.assign(Object.create(Xb.prototype),{constructor:Gg,ValueTypeName:"bool",ValueBufferType:Array,DefaultInterpolation:2300,InterpolantFactoryMethodLinear:void 0,InterpolantFactoryMethodSmooth:void 0});Hg.prototype=Object.assign(Object.create(Xb.prototype),{constructor:Hg,ValueTypeName:"color"});Se.prototype=Object.assign(Object.create(Xb.prototype),{constructor:Se,ValueTypeName:"number"});Ig.prototype=Object.assign(Object.create(oc.prototype),{constructor:Ig,interpolate_:function(a,
c,e,g){var r=this.resultBuffer,v=this.sampleValues,z=this.valueSize;a*=z;c=(e-c)/(g-c);for(e=a+z;a!==e;a+=4)h.slerpFlat(r,0,v,a-z,v,a,c);return r}});Zf.prototype=Object.assign(Object.create(Xb.prototype),{constructor:Zf,ValueTypeName:"quaternion",DefaultInterpolation:2301,InterpolantFactoryMethodLinear:function(a){return new Ig(this.times,this.values,this.getValueSize(),a)},InterpolantFactoryMethodSmooth:void 0});Jg.prototype=Object.assign(Object.create(Xb.prototype),{constructor:Jg,ValueTypeName:"string",
ValueBufferType:Array,DefaultInterpolation:2300,InterpolantFactoryMethodLinear:void 0,InterpolantFactoryMethodSmooth:void 0});Te.prototype=Object.assign(Object.create(Xb.prototype),{constructor:Te,ValueTypeName:"vector"});Object.assign(tc,{parse:function(a){for(var c=[],e=a.tracks,g=1/(a.fps||1),r=0,v=e.length;r!==v;++r)c.push(nm(e[r]).scale(g));return new tc(a.name,a.duration,c)},toJSON:function(a){var c=[],e=a.tracks;a={name:a.name,duration:a.duration,tracks:c,uuid:a.uuid};for(var g=0,r=e.length;g!==
r;++g)c.push(Xb.toJSON(e[g]));return a},CreateFromMorphTargetSequence:function(a,c,e,g){for(var r=c.length,v=[],z=0;z<r;z++){var E=[],F=[];E.push((z+r-1)%r,z,(z+1)%r);F.push(0,1,0);var J=Tb.getKeyframeOrder(E);E=Tb.sortedArray(E,1,J);F=Tb.sortedArray(F,1,J);g||0!==E[0]||(E.push(r),F.push(F[0]));v.push((new Se(".morphTargetInfluences["+c[z].name+"]",E,F)).scale(1/e))}return new tc(a,-1,v)},findByName:function(a,c){var e=a;Array.isArray(a)||(e=a.geometry&&a.geometry.animations||a.animations);for(a=
0;a<e.length;a++)if(e[a].name===c)return e[a];return null},CreateClipsFromMorphTargetSequences:function(a,c,e){for(var g={},r=/^([\w-]*?)([\d]+)$/,v=0,z=a.length;v<z;v++){var E=a[v],F=E.name.match(r);if(F&&1<F.length){var J=F[1];(F=g[J])||(g[J]=F=[]);F.push(E)}}a=[];for(J in g)a.push(tc.CreateFromMorphTargetSequence(J,g[J],c,e));return a},parseAnimation:function(a,c){function e(ha,fa,ra,pa,qa){if(0!==ra.length){var ua=[],oa=[];Tb.flattenJSON(ra,ua,oa,pa);0!==ua.length&&qa.push(new ha(fa,ua,oa))}}
if(!a)return console.error("THREE.AnimationClip: No animation in JSONLoader data."),null;var g=[],r=a.name||"default",v=a.length||-1,z=a.fps||30;a=a.hierarchy||[];for(var E=0;E<a.length;E++){var F=a[E].keys;if(F&&0!==F.length)if(F[0].morphTargets){v={};for(var J=0;J<F.length;J++)if(F[J].morphTargets)for(var P=0;P<F[J].morphTargets.length;P++)v[F[J].morphTargets[P]]=-1;for(var R in v){var S=[],V=[];for(P=0;P!==F[J].morphTargets.length;++P){var W=F[J];S.push(W.time);V.push(W.morphTarget===R?1:0)}g.push(new Se(".morphTargetInfluence["+
R+"]",S,V))}v=v.length*(z||1)}else J=".bones["+c[E].name+"]",e(Te,J+".position",F,"pos",g),e(Zf,J+".quaternion",F,"rot",g),e(Te,J+".scale",F,"scl",g)}return 0===g.length?null:new tc(r,v,g)}});Object.assign(tc.prototype,{resetDuration:function(){for(var a=0,c=0,e=this.tracks.length;c!==e;++c){var g=this.tracks[c];a=Math.max(a,g.times[g.times.length-1])}this.duration=a;return this},trim:function(){for(var a=0;a<this.tracks.length;a++)this.tracks[a].trim(0,this.duration);return this},validate:function(){for(var a=
!0,c=0;c<this.tracks.length;c++)a=a&&this.tracks[c].validate();return a},optimize:function(){for(var a=0;a<this.tracks.length;a++)this.tracks[a].optimize();return this},clone:function(){for(var a=[],c=0;c<this.tracks.length;c++)a.push(this.tracks[c].clone());return new tc(this.name,this.duration,a)}});var ie={enabled:!1,files:{},add:function(a,c){!1!==this.enabled&&(this.files[a]=c)},get:function(a){if(!1!==this.enabled)return this.files[a]},remove:function(a){delete this.files[a]},clear:function(){this.files=
{}}},Oj=new $h;Object.assign(Db.prototype,{load:function(){},parse:function(){},setCrossOrigin:function(a){this.crossOrigin=a;return this},setPath:function(a){this.path=a;return this},setResourcePath:function(a){this.resourcePath=a;return this}});Db.Handlers={handlers:[],add:function(a,c){this.handlers.push(a,c)},get:function(a){for(var c=this.handlers,e=0,g=c.length;e<g;e+=2){var r=c[e+1];if(c[e].test(a))return r}return null}};var Kc={};uc.prototype=Object.assign(Object.create(Db.prototype),{constructor:uc,
load:function(a,c,e,g){void 0===a&&(a="");void 0!==this.path&&(a=this.path+a);a=this.manager.resolveURL(a);var r=this,v=ie.get(a);if(void 0!==v)return r.manager.itemStart(a),setTimeout(function(){c&&c(v);r.manager.itemEnd(a)},0),v;if(void 0!==Kc[a])Kc[a].push({onLoad:c,onProgress:e,onError:g});else{var z=a.match(/^data:(.*?)(;base64)?,(.*)$/);if(z){e=z[1];var E=!!z[2];z=z[3];z=decodeURIComponent(z);E&&(z=atob(z));try{var F=(this.responseType||"").toLowerCase();switch(F){case "arraybuffer":case "blob":var J=
new Uint8Array(z.length);for(E=0;E<z.length;E++)J[E]=z.charCodeAt(E);var P="blob"===F?new Blob([J.buffer],{type:e}):J.buffer;break;case "document":P=(new DOMParser).parseFromString(z,e);break;case "json":P=JSON.parse(z);break;default:P=z}setTimeout(function(){c&&c(P);r.manager.itemEnd(a)},0)}catch(S){setTimeout(function(){g&&g(S);r.manager.itemError(a);r.manager.itemEnd(a)},0)}}else{Kc[a]=[];Kc[a].push({onLoad:c,onProgress:e,onError:g});var R=new XMLHttpRequest;R.open("GET",a,!0);R.addEventListener("load",
function(S){var V=this.response;ie.add(a,V);var W=Kc[a];delete Kc[a];if(200===this.status||0===this.status){0===this.status&&console.warn("THREE.FileLoader: HTTP Status 0 received.");for(var ha=0,fa=W.length;ha<fa;ha++){var ra=W[ha];if(ra.onLoad)ra.onLoad(V)}}else{ha=0;for(fa=W.length;ha<fa;ha++)if(ra=W[ha],ra.onError)ra.onError(S);r.manager.itemError(a)}r.manager.itemEnd(a)},!1);R.addEventListener("progress",function(S){for(var V=Kc[a],W=0,ha=V.length;W<ha;W++){var fa=V[W];if(fa.onProgress)fa.onProgress(S)}},
!1);R.addEventListener("error",function(S){var V=Kc[a];delete Kc[a];for(var W=0,ha=V.length;W<ha;W++){var fa=V[W];if(fa.onError)fa.onError(S)}r.manager.itemError(a);r.manager.itemEnd(a)},!1);R.addEventListener("abort",function(S){var V=Kc[a];delete Kc[a];for(var W=0,ha=V.length;W<ha;W++){var fa=V[W];if(fa.onError)fa.onError(S)}r.manager.itemError(a);r.manager.itemEnd(a)},!1);void 0!==this.responseType&&(R.responseType=this.responseType);void 0!==this.withCredentials&&(R.withCredentials=this.withCredentials);
R.overrideMimeType&&R.overrideMimeType(void 0!==this.mimeType?this.mimeType:"text/plain");for(E in this.requestHeader)R.setRequestHeader(E,this.requestHeader[E]);R.send(null)}r.manager.itemStart(a);return R}},setResponseType:function(a){this.responseType=a;return this},setWithCredentials:function(a){this.withCredentials=a;return this},setMimeType:function(a){this.mimeType=a;return this},setRequestHeader:function(a){this.requestHeader=a;return this}});ai.prototype=Object.assign(Object.create(Db.prototype),
{constructor:ai,load:function(a,c,e,g){var r=this,v=new uc(r.manager);v.setPath(r.path);v.load(a,function(z){c(r.parse(JSON.parse(z)))},e,g)},parse:function(a){for(var c=[],e=0;e<a.length;e++){var g=tc.parse(a[e]);c.push(g)}return c}});bi.prototype=Object.assign(Object.create(Db.prototype),{constructor:bi,load:function(a,c,e,g){function r(S){F.load(a[S],function(V){V=v._parser(V,!0);z[S]={width:V.width,height:V.height,format:V.format,mipmaps:V.mipmaps};J+=1;6===J&&(1===V.mipmapCount&&(E.minFilter=
1006),E.format=V.format,E.needsUpdate=!0,c&&c(E))},e,g)}var v=this,z=[],E=new De;E.image=z;var F=new uc(this.manager);F.setPath(this.path);F.setResponseType("arraybuffer");if(Array.isArray(a))for(var J=0,P=0,R=a.length;P<R;++P)r(P);else F.load(a,function(S){S=v._parser(S,!0);if(S.isCubemap)for(var V=S.mipmaps.length/S.mipmapCount,W=0;W<V;W++){z[W]={mipmaps:[]};for(var ha=0;ha<S.mipmapCount;ha++)z[W].mipmaps.push(S.mipmaps[W*S.mipmapCount+ha]),z[W].format=S.format,z[W].width=S.width,z[W].height=S.height}else E.image.width=
S.width,E.image.height=S.height,E.mipmaps=S.mipmaps;1===S.mipmapCount&&(E.minFilter=1006);E.format=S.format;E.needsUpdate=!0;c&&c(E)},e,g);return E}});Kg.prototype=Object.assign(Object.create(Db.prototype),{constructor:Kg,load:function(a,c,e,g){var r=this,v=new Ab,z=new uc(this.manager);z.setResponseType("arraybuffer");z.setPath(this.path);z.load(a,function(E){if(E=r._parser(E))void 0!==E.image?v.image=E.image:void 0!==E.data&&(v.image.width=E.width,v.image.height=E.height,v.image.data=E.data),v.wrapS=
void 0!==E.wrapS?E.wrapS:1001,v.wrapT=void 0!==E.wrapT?E.wrapT:1001,v.magFilter=void 0!==E.magFilter?E.magFilter:1006,v.minFilter=void 0!==E.minFilter?E.minFilter:1008,v.anisotropy=void 0!==E.anisotropy?E.anisotropy:1,void 0!==E.format&&(v.format=E.format),void 0!==E.type&&(v.type=E.type),void 0!==E.mipmaps&&(v.mipmaps=E.mipmaps),1===E.mipmapCount&&(v.minFilter=1006),v.needsUpdate=!0,c&&c(v,E)},e,g);return v}});Ue.prototype=Object.assign(Object.create(Db.prototype),{constructor:Ue,load:function(a,
c,e,g){function r(){F.removeEventListener("load",r,!1);F.removeEventListener("error",v,!1);ie.add(a,this);c&&c(this);z.manager.itemEnd(a)}function v(J){F.removeEventListener("load",r,!1);F.removeEventListener("error",v,!1);g&&g(J);z.manager.itemError(a);z.manager.itemEnd(a)}void 0!==this.path&&(a=this.path+a);a=this.manager.resolveURL(a);var z=this,E=ie.get(a);if(void 0!==E)return z.manager.itemStart(a),setTimeout(function(){c&&c(E);z.manager.itemEnd(a)},0),E;var F=document.createElementNS("http://www.w3.org/1999/xhtml",
"img");F.addEventListener("load",r,!1);F.addEventListener("error",v,!1);"data:"!==a.substr(0,5)&&void 0!==this.crossOrigin&&(F.crossOrigin=this.crossOrigin);z.manager.itemStart(a);F.src=a;return F}});Lg.prototype=Object.assign(Object.create(Db.prototype),{constructor:Lg,load:function(a,c,e,g){function r(F){z.load(a[F],function(J){v.images[F]=J;E++;6===E&&(v.needsUpdate=!0,c&&c(v))},void 0,g)}var v=new cd,z=new Ue(this.manager);z.setCrossOrigin(this.crossOrigin);z.setPath(this.path);var E=0;for(e=
0;e<a.length;++e)r(e);return v}});Mg.prototype=Object.assign(Object.create(Db.prototype),{constructor:Mg,load:function(a,c,e,g){var r=new l,v=new Ue(this.manager);v.setCrossOrigin(this.crossOrigin);v.setPath(this.path);v.load(a,function(z){r.image=z;z=0<a.search(/\.jpe?g($|\?)/i)||0===a.search(/^data:image\/jpeg/);r.format=z?1022:1023;r.needsUpdate=!0;void 0!==c&&c(r)},e,g);return r}});Object.assign(Za.prototype,{getPoint:function(){console.warn("THREE.Curve: .getPoint() not implemented.");return null},
getPointAt:function(a,c){a=this.getUtoTmapping(a);return this.getPoint(a,c)},getPoints:function(a){void 0===a&&(a=5);for(var c=[],e=0;e<=a;e++)c.push(this.getPoint(e/a));return c},getSpacedPoints:function(a){void 0===a&&(a=5);for(var c=[],e=0;e<=a;e++)c.push(this.getPointAt(e/a));return c},getLength:function(){var a=this.getLengths();return a[a.length-1]},getLengths:function(a){void 0===a&&(a=this.arcLengthDivisions);if(this.cacheArcLengths&&this.cacheArcLengths.length===a+1&&!this.needsUpdate)return this.cacheArcLengths;
this.needsUpdate=!1;var c=[],e=this.getPoint(0),g,r=0;c.push(0);for(g=1;g<=a;g++){var v=this.getPoint(g/a);r+=v.distanceTo(e);c.push(r);e=v}return this.cacheArcLengths=c},updateArcLengths:function(){this.needsUpdate=!0;this.getLengths()},getUtoTmapping:function(a,c){var e=this.getLengths(),g=e.length;c=c?c:a*e[g-1];for(var r=0,v=g-1,z;r<=v;)if(a=Math.floor(r+(v-r)/2),z=e[a]-c,0>z)r=a+1;else if(0<z)v=a-1;else{v=a;break}a=v;if(e[a]===c)return a/(g-1);r=e[a];return(a+(c-r)/(e[a+1]-r))/(g-1)},getTangent:function(a){var c=
a-1E-4;a+=1E-4;0>c&&(c=0);1<a&&(a=1);c=this.getPoint(c);return this.getPoint(a).clone().sub(c).normalize()},getTangentAt:function(a){a=this.getUtoTmapping(a);return this.getTangent(a)},computeFrenetFrames:function(a,c){var e=new k,g=[],r=[],v=[],z=new k,E=new q,F;for(F=0;F<=a;F++){var J=F/a;g[F]=this.getTangentAt(J);g[F].normalize()}r[0]=new k;v[0]=new k;F=Number.MAX_VALUE;J=Math.abs(g[0].x);var P=Math.abs(g[0].y),R=Math.abs(g[0].z);J<=F&&(F=J,e.set(1,0,0));P<=F&&(F=P,e.set(0,1,0));R<=F&&e.set(0,
0,1);z.crossVectors(g[0],e).normalize();r[0].crossVectors(g[0],z);v[0].crossVectors(g[0],r[0]);for(F=1;F<=a;F++)r[F]=r[F-1].clone(),v[F]=v[F-1].clone(),z.crossVectors(g[F-1],g[F]),z.length()>Number.EPSILON&&(z.normalize(),e=Math.acos(hb.clamp(g[F-1].dot(g[F]),-1,1)),r[F].applyMatrix4(E.makeRotationAxis(z,e))),v[F].crossVectors(g[F],r[F]);if(!0===c)for(e=Math.acos(hb.clamp(r[0].dot(r[a]),-1,1)),e/=a,0<g[0].dot(z.crossVectors(r[0],r[a]))&&(e=-e),F=1;F<=a;F++)r[F].applyMatrix4(E.makeRotationAxis(g[F],
e*F)),v[F].crossVectors(g[F],r[F]);return{tangents:g,normals:r,binormals:v}},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.arcLengthDivisions=a.arcLengthDivisions;return this},toJSON:function(){var a={metadata:{version:4.5,type:"Curve",generator:"Curve.toJSON"}};a.arcLengthDivisions=this.arcLengthDivisions;a.type=this.type;return a},fromJSON:function(a){this.arcLengthDivisions=a.arcLengthDivisions;return this}});pc.prototype=Object.create(Za.prototype);pc.prototype.constructor=
pc;pc.prototype.isEllipseCurve=!0;pc.prototype.getPoint=function(a,c){c=c||new f;for(var e=2*Math.PI,g=this.aEndAngle-this.aStartAngle,r=Math.abs(g)<Number.EPSILON;0>g;)g+=e;for(;g>e;)g-=e;g<Number.EPSILON&&(g=r?0:e);!0!==this.aClockwise||r||(g=g===e?-e:g-e);e=this.aStartAngle+a*g;a=this.aX+this.xRadius*Math.cos(e);var v=this.aY+this.yRadius*Math.sin(e);0!==this.aRotation&&(e=Math.cos(this.aRotation),g=Math.sin(this.aRotation),r=a-this.aX,v-=this.aY,a=r*e-v*g+this.aX,v=r*g+v*e+this.aY);return c.set(a,
v)};pc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.aX=a.aX;this.aY=a.aY;this.xRadius=a.xRadius;this.yRadius=a.yRadius;this.aStartAngle=a.aStartAngle;this.aEndAngle=a.aEndAngle;this.aClockwise=a.aClockwise;this.aRotation=a.aRotation;return this};pc.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.aX=this.aX;a.aY=this.aY;a.xRadius=this.xRadius;a.yRadius=this.yRadius;a.aStartAngle=this.aStartAngle;a.aEndAngle=this.aEndAngle;a.aClockwise=this.aClockwise;a.aRotation=
this.aRotation;return a};pc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.aX=a.aX;this.aY=a.aY;this.xRadius=a.xRadius;this.yRadius=a.yRadius;this.aStartAngle=a.aStartAngle;this.aEndAngle=a.aEndAngle;this.aClockwise=a.aClockwise;this.aRotation=a.aRotation;return this};Ve.prototype=Object.create(pc.prototype);Ve.prototype.constructor=Ve;Ve.prototype.isArcCurve=!0;var xh=new k,Li=new ci,Mi=new ci,Ni=new ci;Zb.prototype=Object.create(Za.prototype);Zb.prototype.constructor=Zb;
Zb.prototype.isCatmullRomCurve3=!0;Zb.prototype.getPoint=function(a,c){c=c||new k;var e=this.points,g=e.length;a*=g-(this.closed?0:1);var r=Math.floor(a);a-=r;this.closed?r+=0<r?0:(Math.floor(Math.abs(r)/g)+1)*g:0===a&&r===g-1&&(r=g-2,a=1);if(this.closed||0<r)var v=e[(r-1)%g];else xh.subVectors(e[0],e[1]).add(e[0]),v=xh;var z=e[r%g];var E=e[(r+1)%g];this.closed||r+2<g?e=e[(r+2)%g]:(xh.subVectors(e[g-1],e[g-2]).add(e[g-1]),e=xh);if("centripetal"===this.curveType||"chordal"===this.curveType){var F=
"chordal"===this.curveType?.5:.25;g=Math.pow(v.distanceToSquared(z),F);r=Math.pow(z.distanceToSquared(E),F);F=Math.pow(E.distanceToSquared(e),F);1E-4>r&&(r=1);1E-4>g&&(g=r);1E-4>F&&(F=r);Li.initNonuniformCatmullRom(v.x,z.x,E.x,e.x,g,r,F);Mi.initNonuniformCatmullRom(v.y,z.y,E.y,e.y,g,r,F);Ni.initNonuniformCatmullRom(v.z,z.z,E.z,e.z,g,r,F)}else"catmullrom"===this.curveType&&(Li.initCatmullRom(v.x,z.x,E.x,e.x,this.tension),Mi.initCatmullRom(v.y,z.y,E.y,e.y,this.tension),Ni.initCatmullRom(v.z,z.z,E.z,
e.z,this.tension));c.set(Li.calc(a),Mi.calc(a),Ni.calc(a));return c};Zb.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.points=[];for(var c=0,e=a.points.length;c<e;c++)this.points.push(a.points[c].clone());this.closed=a.closed;this.curveType=a.curveType;this.tension=a.tension;return this};Zb.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.points=[];for(var c=0,e=this.points.length;c<e;c++)a.points.push(this.points[c].toArray());a.closed=this.closed;a.curveType=this.curveType;
a.tension=this.tension;return a};Zb.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.points=[];for(var c=0,e=a.points.length;c<e;c++){var g=a.points[c];this.points.push((new k).fromArray(g))}this.closed=a.closed;this.curveType=a.curveType;this.tension=a.tension;return this};Cc.prototype=Object.create(Za.prototype);Cc.prototype.constructor=Cc;Cc.prototype.isCubicBezierCurve=!0;Cc.prototype.getPoint=function(a,c){c=c||new f;var e=this.v0,g=this.v1,r=this.v2,v=this.v3;c.set(ag(a,
e.x,g.x,r.x,v.x),ag(a,e.y,g.y,r.y,v.y));return c};Cc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.v0.copy(a.v0);this.v1.copy(a.v1);this.v2.copy(a.v2);this.v3.copy(a.v3);return this};Cc.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.v0=this.v0.toArray();a.v1=this.v1.toArray();a.v2=this.v2.toArray();a.v3=this.v3.toArray();return a};Cc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.v0.fromArray(a.v0);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);
this.v3.fromArray(a.v3);return this};Tc.prototype=Object.create(Za.prototype);Tc.prototype.constructor=Tc;Tc.prototype.isCubicBezierCurve3=!0;Tc.prototype.getPoint=function(a,c){c=c||new k;var e=this.v0,g=this.v1,r=this.v2,v=this.v3;c.set(ag(a,e.x,g.x,r.x,v.x),ag(a,e.y,g.y,r.y,v.y),ag(a,e.z,g.z,r.z,v.z));return c};Tc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.v0.copy(a.v0);this.v1.copy(a.v1);this.v2.copy(a.v2);this.v3.copy(a.v3);return this};Tc.prototype.toJSON=function(){var a=
Za.prototype.toJSON.call(this);a.v0=this.v0.toArray();a.v1=this.v1.toArray();a.v2=this.v2.toArray();a.v3=this.v3.toArray();return a};Tc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.v0.fromArray(a.v0);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);this.v3.fromArray(a.v3);return this};kc.prototype=Object.create(Za.prototype);kc.prototype.constructor=kc;kc.prototype.isLineCurve=!0;kc.prototype.getPoint=function(a,c){c=c||new f;1===a?c.copy(this.v2):(c.copy(this.v2).sub(this.v1),
c.multiplyScalar(a).add(this.v1));return c};kc.prototype.getPointAt=function(a,c){return this.getPoint(a,c)};kc.prototype.getTangent=function(){return this.v2.clone().sub(this.v1).normalize()};kc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.v1.copy(a.v1);this.v2.copy(a.v2);return this};kc.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.v1=this.v1.toArray();a.v2=this.v2.toArray();return a};kc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.v1.fromArray(a.v1);
this.v2.fromArray(a.v2);return this};Dc.prototype=Object.create(Za.prototype);Dc.prototype.constructor=Dc;Dc.prototype.isLineCurve3=!0;Dc.prototype.getPoint=function(a,c){c=c||new k;1===a?c.copy(this.v2):(c.copy(this.v2).sub(this.v1),c.multiplyScalar(a).add(this.v1));return c};Dc.prototype.getPointAt=function(a,c){return this.getPoint(a,c)};Dc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.v1.copy(a.v1);this.v2.copy(a.v2);return this};Dc.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);
a.v1=this.v1.toArray();a.v2=this.v2.toArray();return a};Dc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);return this};Ec.prototype=Object.create(Za.prototype);Ec.prototype.constructor=Ec;Ec.prototype.isQuadraticBezierCurve=!0;Ec.prototype.getPoint=function(a,c){c=c||new f;var e=this.v0,g=this.v1,r=this.v2;c.set($f(a,e.x,g.x,r.x),$f(a,e.y,g.y,r.y));return c};Ec.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.v0.copy(a.v0);
this.v1.copy(a.v1);this.v2.copy(a.v2);return this};Ec.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.v0=this.v0.toArray();a.v1=this.v1.toArray();a.v2=this.v2.toArray();return a};Ec.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.v0.fromArray(a.v0);this.v1.fromArray(a.v1);this.v2.fromArray(a.v2);return this};Uc.prototype=Object.create(Za.prototype);Uc.prototype.constructor=Uc;Uc.prototype.isQuadraticBezierCurve3=!0;Uc.prototype.getPoint=function(a,c){c=c||
new k;var e=this.v0,g=this.v1,r=this.v2;c.set($f(a,e.x,g.x,r.x),$f(a,e.y,g.y,r.y),$f(a,e.z,g.z,r.z));return c};Uc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.v0.copy(a.v0);this.v1.copy(a.v1);this.v2.copy(a.v2);return this};Uc.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.v0=this.v0.toArray();a.v1=this.v1.toArray();a.v2=this.v2.toArray();return a};Uc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.v0.fromArray(a.v0);this.v1.fromArray(a.v1);
this.v2.fromArray(a.v2);return this};Fc.prototype=Object.create(Za.prototype);Fc.prototype.constructor=Fc;Fc.prototype.isSplineCurve=!0;Fc.prototype.getPoint=function(a,c){c=c||new f;var e=this.points,g=(e.length-1)*a;a=Math.floor(g);g-=a;var r=e[0===a?a:a-1],v=e[a],z=e[a>e.length-2?e.length-1:a+1];e=e[a>e.length-3?e.length-1:a+2];c.set(Pj(g,r.x,v.x,z.x,e.x),Pj(g,r.y,v.y,z.y,e.y));return c};Fc.prototype.copy=function(a){Za.prototype.copy.call(this,a);this.points=[];for(var c=0,e=a.points.length;c<
e;c++)this.points.push(a.points[c].clone());return this};Fc.prototype.toJSON=function(){var a=Za.prototype.toJSON.call(this);a.points=[];for(var c=0,e=this.points.length;c<e;c++)a.points.push(this.points[c].toArray());return a};Fc.prototype.fromJSON=function(a){Za.prototype.fromJSON.call(this,a);this.points=[];for(var c=0,e=a.points.length;c<e;c++){var g=a.points[c];this.points.push((new f).fromArray(g))}return this};var Oi=Object.freeze({ArcCurve:Ve,CatmullRomCurve3:Zb,CubicBezierCurve:Cc,CubicBezierCurve3:Tc,
EllipseCurve:pc,LineCurve:kc,LineCurve3:Dc,QuadraticBezierCurve:Ec,QuadraticBezierCurve3:Uc,SplineCurve:Fc});gd.prototype=Object.assign(Object.create(Za.prototype),{constructor:gd,add:function(a){this.curves.push(a)},closePath:function(){var a=this.curves[0].getPoint(0),c=this.curves[this.curves.length-1].getPoint(1);a.equals(c)||this.curves.push(new kc(c,a))},getPoint:function(a){var c=a*this.getLength(),e=this.getCurveLengths();for(a=0;a<e.length;){if(e[a]>=c)return c=e[a]-c,a=this.curves[a],e=
a.getLength(),a.getPointAt(0===e?0:1-c/e);a++}return null},getLength:function(){var a=this.getCurveLengths();return a[a.length-1]},updateArcLengths:function(){this.needsUpdate=!0;this.cacheLengths=null;this.getCurveLengths()},getCurveLengths:function(){if(this.cacheLengths&&this.cacheLengths.length===this.curves.length)return this.cacheLengths;for(var a=[],c=0,e=0,g=this.curves.length;e<g;e++)c+=this.curves[e].getLength(),a.push(c);return this.cacheLengths=a},getSpacedPoints:function(a){void 0===
a&&(a=40);for(var c=[],e=0;e<=a;e++)c.push(this.getPoint(e/a));this.autoClose&&c.push(c[0]);return c},getPoints:function(a){a=a||12;for(var c=[],e,g=0,r=this.curves;g<r.length;g++){var v=r[g];v=v.getPoints(v&&v.isEllipseCurve?2*a:v&&(v.isLineCurve||v.isLineCurve3)?1:v&&v.isSplineCurve?a*v.points.length:a);for(var z=0;z<v.length;z++){var E=v[z];e&&e.equals(E)||(c.push(E),e=E)}}this.autoClose&&1<c.length&&!c[c.length-1].equals(c[0])&&c.push(c[0]);return c},copy:function(a){Za.prototype.copy.call(this,
a);this.curves=[];for(var c=0,e=a.curves.length;c<e;c++)this.curves.push(a.curves[c].clone());this.autoClose=a.autoClose;return this},toJSON:function(){var a=Za.prototype.toJSON.call(this);a.autoClose=this.autoClose;a.curves=[];for(var c=0,e=this.curves.length;c<e;c++)a.curves.push(this.curves[c].toJSON());return a},fromJSON:function(a){Za.prototype.fromJSON.call(this,a);this.autoClose=a.autoClose;this.curves=[];for(var c=0,e=a.curves.length;c<e;c++){var g=a.curves[c];this.curves.push((new Oi[g.type]).fromJSON(g))}return this}});
Gc.prototype=Object.assign(Object.create(gd.prototype),{constructor:Gc,setFromPoints:function(a){this.moveTo(a[0].x,a[0].y);for(var c=1,e=a.length;c<e;c++)this.lineTo(a[c].x,a[c].y)},moveTo:function(a,c){this.currentPoint.set(a,c)},lineTo:function(a,c){var e=new kc(this.currentPoint.clone(),new f(a,c));this.curves.push(e);this.currentPoint.set(a,c)},quadraticCurveTo:function(a,c,e,g){a=new Ec(this.currentPoint.clone(),new f(a,c),new f(e,g));this.curves.push(a);this.currentPoint.set(e,g)},bezierCurveTo:function(a,
c,e,g,r,v){a=new Cc(this.currentPoint.clone(),new f(a,c),new f(e,g),new f(r,v));this.curves.push(a);this.currentPoint.set(r,v)},splineThru:function(a){var c=[this.currentPoint.clone()].concat(a);c=new Fc(c);this.curves.push(c);this.currentPoint.copy(a[a.length-1])},arc:function(a,c,e,g,r,v){this.absarc(a+this.currentPoint.x,c+this.currentPoint.y,e,g,r,v)},absarc:function(a,c,e,g,r,v){this.absellipse(a,c,e,e,g,r,v)},ellipse:function(a,c,e,g,r,v,z,E){this.absellipse(a+this.currentPoint.x,c+this.currentPoint.y,
e,g,r,v,z,E)},absellipse:function(a,c,e,g,r,v,z,E){a=new pc(a,c,e,g,r,v,z,E);0<this.curves.length&&(c=a.getPoint(0),c.equals(this.currentPoint)||this.lineTo(c.x,c.y));this.curves.push(a);a=a.getPoint(1);this.currentPoint.copy(a)},copy:function(a){gd.prototype.copy.call(this,a);this.currentPoint.copy(a.currentPoint);return this},toJSON:function(){var a=gd.prototype.toJSON.call(this);a.currentPoint=this.currentPoint.toArray();return a},fromJSON:function(a){gd.prototype.fromJSON.call(this,a);this.currentPoint.fromArray(a.currentPoint);
return this}});Cd.prototype=Object.assign(Object.create(Gc.prototype),{constructor:Cd,getPointsHoles:function(a){for(var c=[],e=0,g=this.holes.length;e<g;e++)c[e]=this.holes[e].getPoints(a);return c},extractPoints:function(a){return{shape:this.getPoints(a),holes:this.getPointsHoles(a)}},copy:function(a){Gc.prototype.copy.call(this,a);this.holes=[];for(var c=0,e=a.holes.length;c<e;c++)this.holes.push(a.holes[c].clone());return this},toJSON:function(){var a=Gc.prototype.toJSON.call(this);a.uuid=this.uuid;
a.holes=[];for(var c=0,e=this.holes.length;c<e;c++)a.holes.push(this.holes[c].toJSON());return a},fromJSON:function(a){Gc.prototype.fromJSON.call(this,a);this.uuid=a.uuid;this.holes=[];for(var c=0,e=a.holes.length;c<e;c++){var g=a.holes[c];this.holes.push((new Gc).fromJSON(g))}return this}});Jb.prototype=Object.assign(Object.create(A.prototype),{constructor:Jb,isLight:!0,copy:function(a){A.prototype.copy.call(this,a);this.color.copy(a.color);this.intensity=a.intensity;return this},toJSON:function(a){a=
A.prototype.toJSON.call(this,a);a.object.color=this.color.getHex();a.object.intensity=this.intensity;void 0!==this.groundColor&&(a.object.groundColor=this.groundColor.getHex());void 0!==this.distance&&(a.object.distance=this.distance);void 0!==this.angle&&(a.object.angle=this.angle);void 0!==this.decay&&(a.object.decay=this.decay);void 0!==this.penumbra&&(a.object.penumbra=this.penumbra);void 0!==this.shadow&&(a.object.shadow=this.shadow.toJSON());return a}});Ng.prototype=Object.assign(Object.create(Jb.prototype),
{constructor:Ng,isHemisphereLight:!0,copy:function(a){Jb.prototype.copy.call(this,a);this.groundColor.copy(a.groundColor);return this}});Object.assign(Vc.prototype,{_projScreenMatrix:new q,_lightPositionWorld:new k,_lookTarget:new k,getViewportCount:function(){return this._viewportCount},getFrustum:function(){return this._frustum},updateMatrices:function(a){var c=this.camera,e=this.matrix,g=this._projScreenMatrix,r=this._lookTarget,v=this._lightPositionWorld;v.setFromMatrixPosition(a.matrixWorld);
c.position.copy(v);r.setFromMatrixPosition(a.target.matrixWorld);c.lookAt(r);c.updateMatrixWorld();g.multiplyMatrices(c.projectionMatrix,c.matrixWorldInverse);this._frustum.setFromMatrix(g);e.set(.5,0,0,.5,0,.5,0,.5,0,0,.5,.5,0,0,0,1);e.multiply(c.projectionMatrix);e.multiply(c.matrixWorldInverse)},getViewport:function(a){return this._viewports[a]},getFrameExtents:function(){return this._frameExtents},copy:function(a){this.camera=a.camera.clone();this.bias=a.bias;this.radius=a.radius;this.mapSize.copy(a.mapSize);
return this},clone:function(){return(new this.constructor).copy(this)},toJSON:function(){var a={};0!==this.bias&&(a.bias=this.bias);1!==this.radius&&(a.radius=this.radius);if(512!==this.mapSize.x||512!==this.mapSize.y)a.mapSize=this.mapSize.toArray();a.camera=this.camera.toJSON(!1).object;delete a.camera.matrix;return a}});Og.prototype=Object.assign(Object.create(Vc.prototype),{constructor:Og,isSpotLightShadow:!0,updateMatrices:function(a,c,e){var g=this.camera,r=2*hb.RAD2DEG*a.angle,v=this.mapSize.width/
this.mapSize.height,z=a.distance||g.far;if(r!==g.fov||v!==g.aspect||z!==g.far)g.fov=r,g.aspect=v,g.far=z,g.updateProjectionMatrix();Vc.prototype.updateMatrices.call(this,a,c,e)}});Pg.prototype=Object.assign(Object.create(Jb.prototype),{constructor:Pg,isSpotLight:!0,copy:function(a){Jb.prototype.copy.call(this,a);this.distance=a.distance;this.angle=a.angle;this.penumbra=a.penumbra;this.decay=a.decay;this.target=a.target.clone();this.shadow=a.shadow.clone();return this}});di.prototype=Object.assign(Object.create(Vc.prototype),
{constructor:di,isPointLightShadow:!0,updateMatrices:function(a,c,e){c=this.camera;var g=this.matrix,r=this._lightPositionWorld,v=this._lookTarget,z=this._projScreenMatrix;r.setFromMatrixPosition(a.matrixWorld);c.position.copy(r);v.copy(c.position);v.add(this._cubeDirections[e]);c.up.copy(this._cubeUps[e]);c.lookAt(v);c.updateMatrixWorld();g.makeTranslation(-r.x,-r.y,-r.z);z.multiplyMatrices(c.projectionMatrix,c.matrixWorldInverse);this._frustum.setFromMatrix(z)}});Qg.prototype=Object.assign(Object.create(Jb.prototype),
{constructor:Qg,isPointLight:!0,copy:function(a){Jb.prototype.copy.call(this,a);this.distance=a.distance;this.decay=a.decay;this.shadow=a.shadow.clone();return this}});bg.prototype=Object.assign(Object.create(zb.prototype),{constructor:bg,isOrthographicCamera:!0,copy:function(a,c){zb.prototype.copy.call(this,a,c);this.left=a.left;this.right=a.right;this.top=a.top;this.bottom=a.bottom;this.near=a.near;this.far=a.far;this.zoom=a.zoom;this.view=null===a.view?null:Object.assign({},a.view);return this},
setViewOffset:function(a,c,e,g,r,v){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=a;this.view.fullHeight=c;this.view.offsetX=e;this.view.offsetY=g;this.view.width=r;this.view.height=v;this.updateProjectionMatrix()},clearViewOffset:function(){null!==this.view&&(this.view.enabled=!1);this.updateProjectionMatrix()},updateProjectionMatrix:function(){var a=(this.right-this.left)/(2*this.zoom),c=(this.top-
this.bottom)/(2*this.zoom),e=(this.right+this.left)/2,g=(this.top+this.bottom)/2,r=e-a;e+=a;a=g+c;c=g-c;if(null!==this.view&&this.view.enabled){e=this.zoom/(this.view.width/this.view.fullWidth);c=this.zoom/(this.view.height/this.view.fullHeight);var v=(this.right-this.left)/this.view.width;g=(this.top-this.bottom)/this.view.height;r+=this.view.offsetX/e*v;e=r+this.view.width/e*v;a-=this.view.offsetY/c*g;c=a-this.view.height/c*g}this.projectionMatrix.makeOrthographic(r,e,a,c,this.near,this.far);this.projectionMatrixInverse.getInverse(this.projectionMatrix)},
toJSON:function(a){a=A.prototype.toJSON.call(this,a);a.object.zoom=this.zoom;a.object.left=this.left;a.object.right=this.right;a.object.top=this.top;a.object.bottom=this.bottom;a.object.near=this.near;a.object.far=this.far;null!==this.view&&(a.object.view=Object.assign({},this.view));return a}});Rg.prototype=Object.assign(Object.create(Vc.prototype),{constructor:Rg,isDirectionalLightShadow:!0,updateMatrices:function(a,c,e){Vc.prototype.updateMatrices.call(this,a,c,e)}});Sg.prototype=Object.assign(Object.create(Jb.prototype),
{constructor:Sg,isDirectionalLight:!0,copy:function(a){Jb.prototype.copy.call(this,a);this.target=a.target.clone();this.shadow=a.shadow.clone();return this}});Tg.prototype=Object.assign(Object.create(Jb.prototype),{constructor:Tg,isAmbientLight:!0});Ug.prototype=Object.assign(Object.create(Jb.prototype),{constructor:Ug,isRectAreaLight:!0,copy:function(a){Jb.prototype.copy.call(this,a);this.width=a.width;this.height=a.height;return this},toJSON:function(a){a=Jb.prototype.toJSON.call(this,a);a.object.width=
this.width;a.object.height=this.height;return a}});Vg.prototype=Object.assign(Object.create(Db.prototype),{constructor:Vg,load:function(a,c,e,g){var r=this,v=new uc(r.manager);v.setPath(r.path);v.load(a,function(z){c(r.parse(JSON.parse(z)))},e,g)},parse:function(a){function c(E){void 0===e[E]&&console.warn("THREE.MaterialLoader: Undefined texture",E);return e[E]}var e=this.textures,g=new Km[a.type];void 0!==a.uuid&&(g.uuid=a.uuid);void 0!==a.name&&(g.name=a.name);void 0!==a.color&&g.color.setHex(a.color);
void 0!==a.roughness&&(g.roughness=a.roughness);void 0!==a.metalness&&(g.metalness=a.metalness);void 0!==a.emissive&&g.emissive.setHex(a.emissive);void 0!==a.specular&&g.specular.setHex(a.specular);void 0!==a.shininess&&(g.shininess=a.shininess);void 0!==a.clearcoat&&(g.clearcoat=a.clearcoat);void 0!==a.clearcoatRoughness&&(g.clearcoatRoughness=a.clearcoatRoughness);void 0!==a.vertexColors&&(g.vertexColors=a.vertexColors);void 0!==a.fog&&(g.fog=a.fog);void 0!==a.flatShading&&(g.flatShading=a.flatShading);
void 0!==a.blending&&(g.blending=a.blending);void 0!==a.combine&&(g.combine=a.combine);void 0!==a.side&&(g.side=a.side);void 0!==a.opacity&&(g.opacity=a.opacity);void 0!==a.transparent&&(g.transparent=a.transparent);void 0!==a.alphaTest&&(g.alphaTest=a.alphaTest);void 0!==a.depthTest&&(g.depthTest=a.depthTest);void 0!==a.depthWrite&&(g.depthWrite=a.depthWrite);void 0!==a.colorWrite&&(g.colorWrite=a.colorWrite);void 0!==a.wireframe&&(g.wireframe=a.wireframe);void 0!==a.wireframeLinewidth&&(g.wireframeLinewidth=
a.wireframeLinewidth);void 0!==a.wireframeLinecap&&(g.wireframeLinecap=a.wireframeLinecap);void 0!==a.wireframeLinejoin&&(g.wireframeLinejoin=a.wireframeLinejoin);void 0!==a.rotation&&(g.rotation=a.rotation);1!==a.linewidth&&(g.linewidth=a.linewidth);void 0!==a.dashSize&&(g.dashSize=a.dashSize);void 0!==a.gapSize&&(g.gapSize=a.gapSize);void 0!==a.scale&&(g.scale=a.scale);void 0!==a.polygonOffset&&(g.polygonOffset=a.polygonOffset);void 0!==a.polygonOffsetFactor&&(g.polygonOffsetFactor=a.polygonOffsetFactor);
void 0!==a.polygonOffsetUnits&&(g.polygonOffsetUnits=a.polygonOffsetUnits);void 0!==a.skinning&&(g.skinning=a.skinning);void 0!==a.morphTargets&&(g.morphTargets=a.morphTargets);void 0!==a.morphNormals&&(g.morphNormals=a.morphNormals);void 0!==a.dithering&&(g.dithering=a.dithering);void 0!==a.visible&&(g.visible=a.visible);void 0!==a.toneMapped&&(g.toneMapped=a.toneMapped);void 0!==a.userData&&(g.userData=a.userData);if(void 0!==a.uniforms)for(var r in a.uniforms){var v=a.uniforms[r];g.uniforms[r]=
{};switch(v.type){case "t":g.uniforms[r].value=c(v.value);break;case "c":g.uniforms[r].value=(new I).setHex(v.value);break;case "v2":g.uniforms[r].value=(new f).fromArray(v.value);break;case "v3":g.uniforms[r].value=(new k).fromArray(v.value);break;case "v4":g.uniforms[r].value=(new p).fromArray(v.value);break;case "m3":g.uniforms[r].value=(new t).fromArray(v.value);case "m4":g.uniforms[r].value=(new q).fromArray(v.value);break;default:g.uniforms[r].value=v.value}}void 0!==a.defines&&(g.defines=a.defines);
void 0!==a.vertexShader&&(g.vertexShader=a.vertexShader);void 0!==a.fragmentShader&&(g.fragmentShader=a.fragmentShader);if(void 0!==a.extensions)for(var z in a.extensions)g.extensions[z]=a.extensions[z];void 0!==a.shading&&(g.flatShading=1===a.shading);void 0!==a.size&&(g.size=a.size);void 0!==a.sizeAttenuation&&(g.sizeAttenuation=a.sizeAttenuation);void 0!==a.map&&(g.map=c(a.map));void 0!==a.matcap&&(g.matcap=c(a.matcap));void 0!==a.alphaMap&&(g.alphaMap=c(a.alphaMap),g.transparent=!0);void 0!==
a.bumpMap&&(g.bumpMap=c(a.bumpMap));void 0!==a.bumpScale&&(g.bumpScale=a.bumpScale);void 0!==a.normalMap&&(g.normalMap=c(a.normalMap));void 0!==a.normalMapType&&(g.normalMapType=a.normalMapType);void 0!==a.normalScale&&(r=a.normalScale,!1===Array.isArray(r)&&(r=[r,r]),g.normalScale=(new f).fromArray(r));void 0!==a.displacementMap&&(g.displacementMap=c(a.displacementMap));void 0!==a.displacementScale&&(g.displacementScale=a.displacementScale);void 0!==a.displacementBias&&(g.displacementBias=a.displacementBias);
void 0!==a.roughnessMap&&(g.roughnessMap=c(a.roughnessMap));void 0!==a.metalnessMap&&(g.metalnessMap=c(a.metalnessMap));void 0!==a.emissiveMap&&(g.emissiveMap=c(a.emissiveMap));void 0!==a.emissiveIntensity&&(g.emissiveIntensity=a.emissiveIntensity);void 0!==a.specularMap&&(g.specularMap=c(a.specularMap));void 0!==a.envMap&&(g.envMap=c(a.envMap));void 0!==a.envMapIntensity&&(g.envMapIntensity=a.envMapIntensity);void 0!==a.reflectivity&&(g.reflectivity=a.reflectivity);void 0!==a.refractionRatio&&(g.refractionRatio=
a.refractionRatio);void 0!==a.lightMap&&(g.lightMap=c(a.lightMap));void 0!==a.lightMapIntensity&&(g.lightMapIntensity=a.lightMapIntensity);void 0!==a.aoMap&&(g.aoMap=c(a.aoMap));void 0!==a.aoMapIntensity&&(g.aoMapIntensity=a.aoMapIntensity);void 0!==a.gradientMap&&(g.gradientMap=c(a.gradientMap));void 0!==a.clearcoatNormalMap&&(g.clearcoatNormalMap=c(a.clearcoatNormalMap));void 0!==a.clearcoatNormalScale&&(g.clearcoatNormalScale=(new f).fromArray(a.clearcoatNormalScale));return g},setTextures:function(a){this.textures=
a;return this}});var Pi={decodeText:function(a){if("undefined"!==typeof TextDecoder)return(new TextDecoder).decode(a);for(var c="",e=0,g=a.length;e<g;e++)c+=String.fromCharCode(a[e]);try{return decodeURIComponent(escape(c))}catch(r){return c}},extractUrlBase:function(a){var c=a.lastIndexOf("/");return-1===c?"./":a.substr(0,c+1)}};Wg.prototype=Object.assign(Object.create(va.prototype),{constructor:Wg,isInstancedBufferGeometry:!0,copy:function(a){va.prototype.copy.call(this,a);this.maxInstancedCount=
a.maxInstancedCount;return this},clone:function(){return(new this.constructor).copy(this)},toJSON:function(){var a=va.prototype.toJSON.call(this);a.maxInstancedCount=this.maxInstancedCount;a.isInstancedBufferGeometry=!0;return a}});Xg.prototype=Object.assign(Object.create(Q.prototype),{constructor:Xg,isInstancedBufferAttribute:!0,copy:function(a){Q.prototype.copy.call(this,a);this.meshPerAttribute=a.meshPerAttribute;return this},toJSON:function(){var a=Q.prototype.toJSON.call(this);a.meshPerAttribute=
this.meshPerAttribute;a.isInstancedBufferAttribute=!0;return a}});Yg.prototype=Object.assign(Object.create(Db.prototype),{constructor:Yg,load:function(a,c,e,g){var r=this,v=new uc(r.manager);v.setPath(r.path);v.load(a,function(z){c(r.parse(JSON.parse(z)))},e,g)},parse:function(a){var c=a.isInstancedBufferGeometry?new Wg:new va,e=a.data.index;if(void 0!==e){var g=new Qi[e.type](e.array);c.setIndex(new Q(g,1))}e=a.data.attributes;for(var r in e){var v=e[r];g=new Qi[v.type](v.array);g=new (v.isInstancedBufferAttribute?
Xg:Q)(g,v.itemSize,v.normalized);void 0!==v.name&&(g.name=v.name);c.addAttribute(r,g)}var z=a.data.morphAttributes;if(z)for(r in z){var E=z[r],F=[];e=0;for(var J=E.length;e<J;e++)v=E[e],g=new Qi[v.type](v.array),g=new Q(g,v.itemSize,v.normalized),void 0!==v.name&&(g.name=v.name),F.push(g);c.morphAttributes[r]=F}r=a.data.groups||a.data.drawcalls||a.data.offsets;if(void 0!==r)for(e=0,v=r.length;e!==v;++e)g=r[e],c.addGroup(g.start,g.count,g.materialIndex);e=a.data.boundingSphere;void 0!==e&&(r=new k,
void 0!==e.center&&r.fromArray(e.center),c.boundingSphere=new G(r,e.radius));a.name&&(c.name=a.name);a.userData&&(c.userData=a.userData);return c}});var Qi={Int8Array,Uint8Array,Uint8ClampedArray:"undefined"!==typeof Uint8ClampedArray?Uint8ClampedArray:Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array};Zg.prototype=Object.assign(Object.create(Db.prototype),{constructor:Zg,load:function(a,c,e,g){var r=this,v=""===this.path?Pi.extractUrlBase(a):this.path;this.resourcePath=
this.resourcePath||v;v=new uc(r.manager);v.setPath(this.path);v.load(a,function(z){var E=null;try{E=JSON.parse(z)}catch(F){void 0!==g&&g(F);console.error("THREE:ObjectLoader: Can't parse "+a+".",F.message);return}z=E.metadata;void 0===z||void 0===z.type||"geometry"===z.type.toLowerCase()?console.error("THREE.ObjectLoader: Can't load "+a):r.parse(E,c)},e,g)},parse:function(a,c){var e=this.parseShape(a.shapes);e=this.parseGeometries(a.geometries,e);var g=this.parseImages(a.images,function(){void 0!==
c&&c(r)});g=this.parseTextures(a.textures,g);g=this.parseMaterials(a.materials,g);var r=this.parseObject(a.object,e,g);a.animations&&(r.animations=this.parseAnimations(a.animations));void 0!==a.images&&0!==a.images.length||void 0===c||c(r);return r},parseShape:function(a){var c={};if(void 0!==a)for(var e=0,g=a.length;e<g;e++){var r=(new Cd).fromJSON(a[e]);c[r.uuid]=r}return c},parseGeometries:function(a,c){var e={};if(void 0!==a)for(var g=new Yg,r=0,v=a.length;r<v;r++){var z=a[r];switch(z.type){case "PlaneGeometry":case "PlaneBufferGeometry":var E=
new gc[z.type](z.width,z.height,z.widthSegments,z.heightSegments);break;case "BoxGeometry":case "BoxBufferGeometry":case "CubeGeometry":E=new gc[z.type](z.width,z.height,z.depth,z.widthSegments,z.heightSegments,z.depthSegments);break;case "CircleGeometry":case "CircleBufferGeometry":E=new gc[z.type](z.radius,z.segments,z.thetaStart,z.thetaLength);break;case "CylinderGeometry":case "CylinderBufferGeometry":E=new gc[z.type](z.radiusTop,z.radiusBottom,z.height,z.radialSegments,z.heightSegments,z.openEnded,
z.thetaStart,z.thetaLength);break;case "ConeGeometry":case "ConeBufferGeometry":E=new gc[z.type](z.radius,z.height,z.radialSegments,z.heightSegments,z.openEnded,z.thetaStart,z.thetaLength);break;case "SphereGeometry":case "SphereBufferGeometry":E=new gc[z.type](z.radius,z.widthSegments,z.heightSegments,z.phiStart,z.phiLength,z.thetaStart,z.thetaLength);break;case "DodecahedronGeometry":case "DodecahedronBufferGeometry":case "IcosahedronGeometry":case "IcosahedronBufferGeometry":case "OctahedronGeometry":case "OctahedronBufferGeometry":case "TetrahedronGeometry":case "TetrahedronBufferGeometry":E=
new gc[z.type](z.radius,z.detail);break;case "RingGeometry":case "RingBufferGeometry":E=new gc[z.type](z.innerRadius,z.outerRadius,z.thetaSegments,z.phiSegments,z.thetaStart,z.thetaLength);break;case "TorusGeometry":case "TorusBufferGeometry":E=new gc[z.type](z.radius,z.tube,z.radialSegments,z.tubularSegments,z.arc);break;case "TorusKnotGeometry":case "TorusKnotBufferGeometry":E=new gc[z.type](z.radius,z.tube,z.tubularSegments,z.radialSegments,z.p,z.q);break;case "TubeGeometry":case "TubeBufferGeometry":E=
new gc[z.type]((new Oi[z.path.type]).fromJSON(z.path),z.tubularSegments,z.radius,z.radialSegments,z.closed);break;case "LatheGeometry":case "LatheBufferGeometry":E=new gc[z.type](z.points,z.segments,z.phiStart,z.phiLength);break;case "PolyhedronGeometry":case "PolyhedronBufferGeometry":E=new gc[z.type](z.vertices,z.indices,z.radius,z.details);break;case "ShapeGeometry":case "ShapeBufferGeometry":E=[];for(var F=0,J=z.shapes.length;F<J;F++){var P=c[z.shapes[F]];E.push(P)}E=new gc[z.type](E,z.curveSegments);
break;case "ExtrudeGeometry":case "ExtrudeBufferGeometry":E=[];F=0;for(J=z.shapes.length;F<J;F++)P=c[z.shapes[F]],E.push(P);F=z.options.extrudePath;void 0!==F&&(z.options.extrudePath=(new Oi[F.type]).fromJSON(F));E=new gc[z.type](E,z.options);break;case "BufferGeometry":case "InstancedBufferGeometry":E=g.parse(z);break;case "Geometry":"THREE"in window&&"LegacyJSONLoader"in THREE?E=(new THREE.LegacyJSONLoader).parse(z,this.resourcePath).geometry:console.error('THREE.ObjectLoader: You have to import LegacyJSONLoader in order load geometry data of type "Geometry".');
break;default:console.warn('THREE.ObjectLoader: Unsupported geometry type "'+z.type+'"');continue}E.uuid=z.uuid;void 0!==z.name&&(E.name=z.name);!0===E.isBufferGeometry&&void 0!==z.userData&&(E.userData=z.userData);e[z.uuid]=E}return e},parseMaterials:function(a,c){var e={},g={};if(void 0!==a){var r=new Vg;r.setTextures(c);c=0;for(var v=a.length;c<v;c++){var z=a[c];if("MultiMaterial"===z.type){for(var E=[],F=0;F<z.materials.length;F++){var J=z.materials[F];void 0===e[J.uuid]&&(e[J.uuid]=r.parse(J));
E.push(e[J.uuid])}g[z.uuid]=E}else void 0===e[z.uuid]&&(e[z.uuid]=r.parse(z)),g[z.uuid]=e[z.uuid]}}return g},parseAnimations:function(a){for(var c=[],e=0;e<a.length;e++){var g=a[e],r=tc.parse(g);void 0!==g.uuid&&(r.uuid=g.uuid);c.push(r)}return c},parseImages:function(a,c){function e(S){g.manager.itemStart(S);return v.load(S,function(){g.manager.itemEnd(S)},void 0,function(){g.manager.itemError(S);g.manager.itemEnd(S)})}var g=this,r={};if(void 0!==a&&0<a.length){c=new $h(c);var v=new Ue(c);v.setCrossOrigin(this.crossOrigin);
c=0;for(var z=a.length;c<z;c++){var E=a[c],F=E.url;if(Array.isArray(F)){r[E.uuid]=[];for(var J=0,P=F.length;J<P;J++){var R=F[J];R=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(R)?R:g.resourcePath+R;r[E.uuid].push(e(R))}}else R=/^(\/\/)|([a-z]+:(\/\/)?)/i.test(E.url)?E.url:g.resourcePath+E.url,r[E.uuid]=e(R)}}return r},parseTextures:function(a,c){function e(F,J){if("number"===typeof F)return F;console.warn("THREE.ObjectLoader.parseTexture: Constant should be in numeric form.",F);return J[F]}var g={};if(void 0!==
a)for(var r=0,v=a.length;r<v;r++){var z=a[r];void 0===z.image&&console.warn('THREE.ObjectLoader: No "image" specified for',z.uuid);void 0===c[z.image]&&console.warn("THREE.ObjectLoader: Undefined image",z.image);var E=Array.isArray(c[z.image])?new cd(c[z.image]):new l(c[z.image]);E.needsUpdate=!0;E.uuid=z.uuid;void 0!==z.name&&(E.name=z.name);void 0!==z.mapping&&(E.mapping=e(z.mapping,Lm));void 0!==z.offset&&E.offset.fromArray(z.offset);void 0!==z.repeat&&E.repeat.fromArray(z.repeat);void 0!==z.center&&
E.center.fromArray(z.center);void 0!==z.rotation&&(E.rotation=z.rotation);void 0!==z.wrap&&(E.wrapS=e(z.wrap[0],sk),E.wrapT=e(z.wrap[1],sk));void 0!==z.format&&(E.format=z.format);void 0!==z.type&&(E.type=z.type);void 0!==z.encoding&&(E.encoding=z.encoding);void 0!==z.minFilter&&(E.minFilter=e(z.minFilter,tk));void 0!==z.magFilter&&(E.magFilter=e(z.magFilter,tk));void 0!==z.anisotropy&&(E.anisotropy=z.anisotropy);void 0!==z.flipY&&(E.flipY=z.flipY);void 0!==z.premultiplyAlpha&&(E.premultiplyAlpha=
z.premultiplyAlpha);void 0!==z.unpackAlignment&&(E.unpackAlignment=z.unpackAlignment);g[z.uuid]=E}return g},parseObject:function(a,c,e){function g(J){void 0===c[J]&&console.warn("THREE.ObjectLoader: Undefined geometry",J);return c[J]}function r(J){if(void 0!==J){if(Array.isArray(J)){for(var P=[],R=0,S=J.length;R<S;R++){var V=J[R];void 0===e[V]&&console.warn("THREE.ObjectLoader: Undefined material",V);P.push(e[V])}return P}void 0===e[J]&&console.warn("THREE.ObjectLoader: Undefined material",J);return e[J]}}
switch(a.type){case "Scene":var v=new y;void 0!==a.background&&Number.isInteger(a.background)&&(v.background=new I(a.background));void 0!==a.fog&&("Fog"===a.fog.type?v.fog=new Ag(a.fog.color,a.fog.near,a.fog.far):"FogExp2"===a.fog.type&&(v.fog=new zg(a.fog.color,a.fog.density)));break;case "PerspectiveCamera":v=new vb(a.fov,a.aspect,a.near,a.far);void 0!==a.focus&&(v.focus=a.focus);void 0!==a.zoom&&(v.zoom=a.zoom);void 0!==a.filmGauge&&(v.filmGauge=a.filmGauge);void 0!==a.filmOffset&&(v.filmOffset=
a.filmOffset);void 0!==a.view&&(v.view=Object.assign({},a.view));break;case "OrthographicCamera":v=new bg(a.left,a.right,a.top,a.bottom,a.near,a.far);void 0!==a.zoom&&(v.zoom=a.zoom);void 0!==a.view&&(v.view=Object.assign({},a.view));break;case "AmbientLight":v=new Tg(a.color,a.intensity);break;case "DirectionalLight":v=new Sg(a.color,a.intensity);break;case "PointLight":v=new Qg(a.color,a.intensity,a.distance,a.decay);break;case "RectAreaLight":v=new Ug(a.color,a.intensity,a.width,a.height);break;
case "SpotLight":v=new Pg(a.color,a.intensity,a.distance,a.angle,a.penumbra,a.decay);break;case "HemisphereLight":v=new Ng(a.color,a.groundColor,a.intensity);break;case "SkinnedMesh":console.warn("THREE.ObjectLoader.parseObject() does not support SkinnedMesh yet.");case "Mesh":v=g(a.geometry);var z=r(a.material);v=v.bones&&0<v.bones.length?new Bf(v,z):new xa(v,z);void 0!==a.drawMode&&v.setDrawMode(a.drawMode);break;case "LOD":v=new Af;break;case "Line":v=new Vb(g(a.geometry),r(a.material),a.mode);
break;case "LineLoop":v=new Dg(g(a.geometry),r(a.material));break;case "LineSegments":v=new Ib(g(a.geometry),r(a.material));break;case "PointCloud":case "Points":v=new Ce(g(a.geometry),r(a.material));break;case "Sprite":v=new yf(r(a.material));break;case "Group":v=new ue;break;default:v=new A}v.uuid=a.uuid;void 0!==a.name&&(v.name=a.name);void 0!==a.matrix?(v.matrix.fromArray(a.matrix),void 0!==a.matrixAutoUpdate&&(v.matrixAutoUpdate=a.matrixAutoUpdate),v.matrixAutoUpdate&&v.matrix.decompose(v.position,
v.quaternion,v.scale)):(void 0!==a.position&&v.position.fromArray(a.position),void 0!==a.rotation&&v.rotation.fromArray(a.rotation),void 0!==a.quaternion&&v.quaternion.fromArray(a.quaternion),void 0!==a.scale&&v.scale.fromArray(a.scale));void 0!==a.castShadow&&(v.castShadow=a.castShadow);void 0!==a.receiveShadow&&(v.receiveShadow=a.receiveShadow);a.shadow&&(void 0!==a.shadow.bias&&(v.shadow.bias=a.shadow.bias),void 0!==a.shadow.radius&&(v.shadow.radius=a.shadow.radius),void 0!==a.shadow.mapSize&&
v.shadow.mapSize.fromArray(a.shadow.mapSize),void 0!==a.shadow.camera&&(v.shadow.camera=this.parseObject(a.shadow.camera)));void 0!==a.visible&&(v.visible=a.visible);void 0!==a.frustumCulled&&(v.frustumCulled=a.frustumCulled);void 0!==a.renderOrder&&(v.renderOrder=a.renderOrder);void 0!==a.userData&&(v.userData=a.userData);void 0!==a.layers&&(v.layers.mask=a.layers);if(void 0!==a.children){z=a.children;for(var E=0;E<z.length;E++)v.add(this.parseObject(z[E],c,e))}if("LOD"===a.type)for(a=a.levels,z=
0;z<a.length;z++){E=a[z];var F=v.getObjectByProperty("uuid",E.object);void 0!==F&&v.addLevel(F,E.distance)}return v}});var Lm={UVMapping:300,CubeReflectionMapping:301,CubeRefractionMapping:302,EquirectangularReflectionMapping:303,EquirectangularRefractionMapping:304,SphericalReflectionMapping:305,CubeUVReflectionMapping:306,CubeUVRefractionMapping:307},sk={RepeatWrapping:1E3,ClampToEdgeWrapping:1001,MirroredRepeatWrapping:1002},tk={NearestFilter:1003,NearestMipmapNearestFilter:1004,NearestMipmapLinearFilter:1005,
LinearFilter:1006,LinearMipmapNearestFilter:1007,LinearMipmapLinearFilter:1008};ei.prototype=Object.assign(Object.create(Db.prototype),{constructor:ei,setOptions:function(a){this.options=a;return this},load:function(a,c,e,g){void 0===a&&(a="");void 0!==this.path&&(a=this.path+a);a=this.manager.resolveURL(a);var r=this,v=ie.get(a);if(void 0!==v)return r.manager.itemStart(a),setTimeout(function(){c&&c(v);r.manager.itemEnd(a)},0),v;fetch(a).then(function(z){return z.blob()}).then(function(z){return void 0===
r.options?createImageBitmap(z):createImageBitmap(z,r.options)}).then(function(z){ie.add(a,z);c&&c(z);r.manager.itemEnd(a)}).catch(function(z){g&&g(z);r.manager.itemError(a);r.manager.itemEnd(a)});r.manager.itemStart(a)}});Object.assign(fi.prototype,{moveTo:function(a,c){this.currentPath=new Gc;this.subPaths.push(this.currentPath);this.currentPath.moveTo(a,c)},lineTo:function(a,c){this.currentPath.lineTo(a,c)},quadraticCurveTo:function(a,c,e,g){this.currentPath.quadraticCurveTo(a,c,e,g)},bezierCurveTo:function(a,
c,e,g,r,v){this.currentPath.bezierCurveTo(a,c,e,g,r,v)},splineThru:function(a){this.currentPath.splineThru(a)},toShapes:function(a,c){function e(fa){for(var ra=[],pa=0,qa=fa.length;pa<qa;pa++){var ua=fa[pa],oa=new Cd;oa.curves=ua.curves;ra.push(oa)}return ra}function g(fa,ra){for(var pa=ra.length,qa=!1,ua=pa-1,oa=0;oa<pa;ua=oa++){var ta=ra[ua],Ba=ra[oa],Ta=Ba.x-ta.x,Ua=Ba.y-ta.y;if(Math.abs(Ua)>Number.EPSILON){if(0>Ua&&(ta=ra[oa],Ta=-Ta,Ba=ra[ua],Ua=-Ua),!(fa.y<ta.y||fa.y>Ba.y))if(fa.y===ta.y){if(fa.x===
ta.x)return!0}else{ua=Ua*(fa.x-ta.x)-Ta*(fa.y-ta.y);if(0===ua)return!0;0>ua||(qa=!qa)}}else if(fa.y===ta.y&&(Ba.x<=fa.x&&fa.x<=ta.x||ta.x<=fa.x&&fa.x<=Ba.x))return!0}return qa}var r=ed.isClockWise,v=this.subPaths;if(0===v.length)return[];if(!0===c)return e(v);c=[];if(1===v.length){var z=v[0];var E=new Cd;E.curves=z.curves;c.push(E);return c}var F=!r(v[0].getPoints());F=a?!F:F;E=[];var J=[],P=[],R=0;J[R]=void 0;P[R]=[];for(var S=0,V=v.length;S<V;S++){z=v[S];var W=z.getPoints();var ha=r(W);(ha=a?!ha:
ha)?(!F&&J[R]&&R++,J[R]={s:new Cd,p:W},J[R].s.curves=z.curves,F&&R++,P[R]=[]):P[R].push({h:z,p:W[0]})}if(!J[0])return e(v);if(1<J.length){S=!1;a=[];r=0;for(v=J.length;r<v;r++)E[r]=[];r=0;for(v=J.length;r<v;r++)for(z=P[r],ha=0;ha<z.length;ha++){F=z[ha];R=!0;for(W=0;W<J.length;W++)g(F.p,J[W].p)&&(r!==W&&a.push({froms:r,tos:W,hole:ha}),R?(R=!1,E[W].push(F)):S=!0);R&&E[r].push(F)}0<a.length&&(S||(P=E))}S=0;for(r=J.length;S<r;S++)for(E=J[S].s,c.push(E),a=P[S],v=0,z=a.length;v<z;v++)E.holes.push(a[v].h);
return c}});Object.assign(gi.prototype,{isFont:!0,generateShapes:function(a,c){void 0===c&&(c=100);var e=[];a=vm(a,c,this.data);c=0;for(var g=a.length;c<g;c++)Array.prototype.push.apply(e,a[c].toShapes());return e}});hi.prototype=Object.assign(Object.create(Db.prototype),{constructor:hi,load:function(a,c,e,g){var r=this,v=new uc(this.manager);v.setPath(this.path);v.load(a,function(z){try{var E=JSON.parse(z)}catch(F){console.warn("THREE.FontLoader: typeface.js support is being deprecated. Use typeface.json instead."),
E=JSON.parse(z.substring(65,z.length-2))}z=r.parse(E);c&&c(z)},e,g)},parse:function(a){return new gi(a)}});var yh,mi={getContext:function(){void 0===yh&&(yh=new (window.AudioContext||window.webkitAudioContext));return yh},setContext:function(a){yh=a}};$g.prototype=Object.assign(Object.create(Db.prototype),{constructor:$g,load:function(a,c,e,g){var r=new uc(this.manager);r.setResponseType("arraybuffer");r.setPath(this.path);r.load(a,function(v){v=v.slice(0);mi.getContext().decodeAudioData(v,function(z){c(z)})},
e,g)}});Object.assign(ah.prototype,{isSphericalHarmonics3:!0,set:function(a){for(var c=0;9>c;c++)this.coefficients[c].copy(a[c]);return this},zero:function(){for(var a=0;9>a;a++)this.coefficients[a].set(0,0,0);return this},getAt:function(a,c){var e=a.x,g=a.y;a=a.z;var r=this.coefficients;c.copy(r[0]).multiplyScalar(.282095);c.addScale(r[1],.488603*g);c.addScale(r[2],.488603*a);c.addScale(r[3],.488603*e);c.addScale(r[4],1.092548*e*g);c.addScale(r[5],1.092548*g*a);c.addScale(r[6],.315392*(3*a*a-1));
c.addScale(r[7],1.092548*e*a);c.addScale(r[8],.546274*(e*e-g*g));return c},getIrradianceAt:function(a,c){var e=a.x,g=a.y;a=a.z;var r=this.coefficients;c.copy(r[0]).multiplyScalar(.886227);c.addScale(r[1],1.023328*g);c.addScale(r[2],1.023328*a);c.addScale(r[3],1.023328*e);c.addScale(r[4],.858086*e*g);c.addScale(r[5],.858086*g*a);c.addScale(r[6],.743125*a*a-.247708);c.addScale(r[7],.858086*e*a);c.addScale(r[8],.429043*(e*e-g*g));return c},add:function(a){for(var c=0;9>c;c++)this.coefficients[c].add(a.coefficients[c]);
return this},scale:function(a){for(var c=0;9>c;c++)this.coefficients[c].multiplyScalar(a);return this},lerp:function(a,c){for(var e=0;9>e;e++)this.coefficients[e].lerp(a.coefficients[e],c);return this},equals:function(a){for(var c=0;9>c;c++)if(!this.coefficients[c].equals(a.coefficients[c]))return!1;return!0},copy:function(a){return this.set(a.coefficients)},clone:function(){return(new this.constructor).copy(this)},fromArray:function(a,c){void 0===c&&(c=0);for(var e=this.coefficients,g=0;9>g;g++)e[g].fromArray(a,
c+3*g);return this},toArray:function(a,c){void 0===a&&(a=[]);void 0===c&&(c=0);for(var e=this.coefficients,g=0;9>g;g++)e[g].toArray(a,c+3*g);return a}});Object.assign(ah,{getBasisAt:function(a,c){var e=a.x,g=a.y;a=a.z;c[0]=.282095;c[1]=.488603*g;c[2]=.488603*a;c[3]=.488603*e;c[4]=1.092548*e*g;c[5]=1.092548*g*a;c[6]=.315392*(3*a*a-1);c[7]=1.092548*e*a;c[8]=.546274*(e*e-g*g)}});Hc.prototype=Object.assign(Object.create(Jb.prototype),{constructor:Hc,isLightProbe:!0,copy:function(a){Jb.prototype.copy.call(this,
a);this.sh.copy(a.sh);this.intensity=a.intensity;return this},toJSON:function(a){return Jb.prototype.toJSON.call(this,a)}});ii.prototype=Object.assign(Object.create(Hc.prototype),{constructor:ii,isHemisphereLightProbe:!0,copy:function(a){Hc.prototype.copy.call(this,a);return this},toJSON:function(a){return Hc.prototype.toJSON.call(this,a)}});ji.prototype=Object.assign(Object.create(Hc.prototype),{constructor:ji,isAmbientLightProbe:!0,copy:function(a){Hc.prototype.copy.call(this,a);return this},toJSON:function(a){return Hc.prototype.toJSON.call(this,
a)}});var uk=new q,vk=new q;Object.assign(Qj.prototype,{update:function(a){var c=this._cache;if(c.focus!==a.focus||c.fov!==a.fov||c.aspect!==a.aspect*this.aspect||c.near!==a.near||c.far!==a.far||c.zoom!==a.zoom||c.eyeSep!==this.eyeSep){c.focus=a.focus;c.fov=a.fov;c.aspect=a.aspect*this.aspect;c.near=a.near;c.far=a.far;c.zoom=a.zoom;c.eyeSep=this.eyeSep;var e=a.projectionMatrix.clone(),g=c.eyeSep/2,r=g*c.near/c.focus,v=c.near*Math.tan(hb.DEG2RAD*c.fov*.5)/c.zoom;vk.elements[12]=-g;uk.elements[12]=
g;g=-v*c.aspect+r;var z=v*c.aspect+r;e.elements[0]=2*c.near/(z-g);e.elements[8]=(z+g)/(z-g);this.cameraL.projectionMatrix.copy(e);g=-v*c.aspect-r;z=v*c.aspect-r;e.elements[0]=2*c.near/(z-g);e.elements[8]=(z+g)/(z-g);this.cameraR.projectionMatrix.copy(e)}this.cameraL.matrixWorld.copy(a.matrixWorld).multiply(vk);this.cameraR.matrixWorld.copy(a.matrixWorld).multiply(uk)}});Object.assign(ki.prototype,{start:function(){this.oldTime=this.startTime=("undefined"===typeof performance?Date:performance).now();
this.elapsedTime=0;this.running=!0},stop:function(){this.getElapsedTime();this.autoStart=this.running=!1},getElapsedTime:function(){this.getDelta();return this.elapsedTime},getDelta:function(){var a=0;if(this.autoStart&&!this.running)return this.start(),0;if(this.running){var c=("undefined"===typeof performance?Date:performance).now();a=(c-this.oldTime)/1E3;this.oldTime=c;this.elapsedTime+=a}return a}});var je=new k,wk=new h,Mm=new k,ke=new k;li.prototype=Object.assign(Object.create(A.prototype),
{constructor:li,getInput:function(){return this.gain},removeFilter:function(){null!==this.filter&&(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination),this.gain.connect(this.context.destination),this.filter=null);return this},getFilter:function(){return this.filter},setFilter:function(a){null!==this.filter?(this.gain.disconnect(this.filter),this.filter.disconnect(this.context.destination)):this.gain.disconnect(this.context.destination);this.filter=a;this.gain.connect(this.filter);
this.filter.connect(this.context.destination);return this},getMasterVolume:function(){return this.gain.gain.value},setMasterVolume:function(a){this.gain.gain.setTargetAtTime(a,this.context.currentTime,.01);return this},updateMatrixWorld:function(a){A.prototype.updateMatrixWorld.call(this,a);a=this.context.listener;var c=this.up;this.timeDelta=this._clock.getDelta();this.matrixWorld.decompose(je,wk,Mm);ke.set(0,0,-1).applyQuaternion(wk);if(a.positionX){var e=this.context.currentTime+this.timeDelta;
a.positionX.linearRampToValueAtTime(je.x,e);a.positionY.linearRampToValueAtTime(je.y,e);a.positionZ.linearRampToValueAtTime(je.z,e);a.forwardX.linearRampToValueAtTime(ke.x,e);a.forwardY.linearRampToValueAtTime(ke.y,e);a.forwardZ.linearRampToValueAtTime(ke.z,e);a.upX.linearRampToValueAtTime(c.x,e);a.upY.linearRampToValueAtTime(c.y,e);a.upZ.linearRampToValueAtTime(c.z,e)}else a.setPosition(je.x,je.y,je.z),a.setOrientation(ke.x,ke.y,ke.z,c.x,c.y,c.z)}});We.prototype=Object.assign(Object.create(A.prototype),
{constructor:We,getOutput:function(){return this.gain},setNodeSource:function(a){this.hasPlaybackControl=!1;this.sourceType="audioNode";this.source=a;this.connect();return this},setMediaElementSource:function(a){this.hasPlaybackControl=!1;this.sourceType="mediaNode";this.source=this.context.createMediaElementSource(a);this.connect();return this},setBuffer:function(a){this.buffer=a;this.sourceType="buffer";this.autoplay&&this.play();return this},play:function(){if(!0===this.isPlaying)console.warn("THREE.Audio: Audio is already playing.");
else if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");else{var a=this.context.createBufferSource();a.buffer=this.buffer;a.loop=this.loop;a.onended=this.onEnded.bind(this);this.startTime=this.context.currentTime;a.start(this.startTime,this.offset,this.duration);this.isPlaying=!0;this.source=a;this.setDetune(this.detune);this.setPlaybackRate(this.playbackRate);return this.connect()}},pause:function(){if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");
else return!0===this.isPlaying&&(this.source.stop(),this.source.onended=null,this.offset+=(this.context.currentTime-this.startTime)*this.playbackRate,this.isPlaying=!1),this},stop:function(){if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");else return this.source.stop(),this.source.onended=null,this.offset=0,this.isPlaying=!1,this},connect:function(){if(0<this.filters.length){this.source.connect(this.filters[0]);for(var a=1,c=this.filters.length;a<c;a++)this.filters[a-
1].connect(this.filters[a]);this.filters[this.filters.length-1].connect(this.getOutput())}else this.source.connect(this.getOutput());return this},disconnect:function(){if(0<this.filters.length){this.source.disconnect(this.filters[0]);for(var a=1,c=this.filters.length;a<c;a++)this.filters[a-1].disconnect(this.filters[a]);this.filters[this.filters.length-1].disconnect(this.getOutput())}else this.source.disconnect(this.getOutput());return this},getFilters:function(){return this.filters},setFilters:function(a){a||
(a=[]);!0===this.isPlaying?(this.disconnect(),this.filters=a,this.connect()):this.filters=a;return this},setDetune:function(a){this.detune=a;if(void 0!==this.source.detune)return!0===this.isPlaying&&this.source.detune.setTargetAtTime(this.detune,this.context.currentTime,.01),this},getDetune:function(){return this.detune},getFilter:function(){return this.getFilters()[0]},setFilter:function(a){return this.setFilters(a?[a]:[])},setPlaybackRate:function(a){if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");
else return this.playbackRate=a,!0===this.isPlaying&&this.source.playbackRate.setTargetAtTime(this.playbackRate,this.context.currentTime,.01),this},getPlaybackRate:function(){return this.playbackRate},onEnded:function(){this.isPlaying=!1},getLoop:function(){return!1===this.hasPlaybackControl?(console.warn("THREE.Audio: this Audio has no playback control."),!1):this.loop},setLoop:function(a){if(!1===this.hasPlaybackControl)console.warn("THREE.Audio: this Audio has no playback control.");else return this.loop=
a,!0===this.isPlaying&&(this.source.loop=this.loop),this},getVolume:function(){return this.gain.gain.value},setVolume:function(a){this.gain.gain.setTargetAtTime(a,this.context.currentTime,.01);return this}});var le=new k,xk=new h,Nm=new k,me=new k;ni.prototype=Object.assign(Object.create(We.prototype),{constructor:ni,getOutput:function(){return this.panner},getRefDistance:function(){return this.panner.refDistance},setRefDistance:function(a){this.panner.refDistance=a;return this},getRolloffFactor:function(){return this.panner.rolloffFactor},
setRolloffFactor:function(a){this.panner.rolloffFactor=a;return this},getDistanceModel:function(){return this.panner.distanceModel},setDistanceModel:function(a){this.panner.distanceModel=a;return this},getMaxDistance:function(){return this.panner.maxDistance},setMaxDistance:function(a){this.panner.maxDistance=a;return this},setDirectionalCone:function(a,c,e){this.panner.coneInnerAngle=a;this.panner.coneOuterAngle=c;this.panner.coneOuterGain=e;return this},updateMatrixWorld:function(a){A.prototype.updateMatrixWorld.call(this,
a);if(!0!==this.hasPlaybackControl||!1!==this.isPlaying)if(this.matrixWorld.decompose(le,xk,Nm),me.set(0,0,1).applyQuaternion(xk),a=this.panner,a.positionX){var c=this.context.currentTime+this.listener.timeDelta;a.positionX.linearRampToValueAtTime(le.x,c);a.positionY.linearRampToValueAtTime(le.y,c);a.positionZ.linearRampToValueAtTime(le.z,c);a.orientationX.linearRampToValueAtTime(me.x,c);a.orientationY.linearRampToValueAtTime(me.y,c);a.orientationZ.linearRampToValueAtTime(me.z,c)}else a.setPosition(le.x,
le.y,le.z),a.setOrientation(me.x,me.y,me.z)}});Object.assign(oi.prototype,{getFrequencyData:function(){this.analyser.getByteFrequencyData(this.data);return this.data},getAverageFrequency:function(){for(var a=0,c=this.getFrequencyData(),e=0;e<c.length;e++)a+=c[e];return a/c.length}});Object.assign(pi.prototype,{accumulate:function(a,c){var e=this.buffer,g=this.valueSize;a=a*g+g;var r=this.cumulativeWeight;if(0===r){for(r=0;r!==g;++r)e[a+r]=e[r];r=c}else r+=c,this._mixBufferRegion(e,a,0,c/r,g);this.cumulativeWeight=
r},apply:function(a){var c=this.valueSize,e=this.buffer;a=a*c+c;var g=this.cumulativeWeight,r=this.binding;this.cumulativeWeight=0;1>g&&this._mixBufferRegion(e,a,3*c,1-g,c);g=c;for(var v=c+c;g!==v;++g)if(e[g]!==e[g+c]){r.setValue(e,a);break}},saveOriginalState:function(){var a=this.buffer,c=this.valueSize,e=3*c;this.binding.getValue(a,e);for(var g=c;g!==e;++g)a[g]=a[e+g%c];this.cumulativeWeight=0},restoreOriginalState:function(){this.binding.setValue(this.buffer,3*this.valueSize)},_select:function(a,
c,e,g,r){if(.5<=g)for(g=0;g!==r;++g)a[c+g]=a[e+g]},_slerp:function(a,c,e,g){h.slerpFlat(a,c,a,c,a,e,g)},_lerp:function(a,c,e,g,r){for(var v=1-g,z=0;z!==r;++z){var E=c+z;a[E]=a[E]*v+a[e+z]*g}}});var Om=/[\[\]\.:\/]/g,Pm="[^"+"\\[\\]\\.:\\/".replace("\\.","")+"]",Qm=/((?:WC+[\/:])*)/.source.replace("WC","[^\\[\\]\\.:\\/]"),Rm=/(WCOD+)?/.source.replace("WCOD",Pm),Sm=/(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace("WC","[^\\[\\]\\.:\\/]"),Tm=/\.(WC+)(?:\[(.+)\])?/.source.replace("WC","[^\\[\\]\\.:\\/]"),Um=
new RegExp("^"+Qm+Rm+Sm+Tm+"$"),Vm=["material","materials","bones"];Object.assign(Rj.prototype,{getValue:function(a,c){this.bind();var e=this._bindings[this._targetGroup.nCachedObjects_];void 0!==e&&e.getValue(a,c)},setValue:function(a,c){for(var e=this._bindings,g=this._targetGroup.nCachedObjects_,r=e.length;g!==r;++g)e[g].setValue(a,c)},bind:function(){for(var a=this._bindings,c=this._targetGroup.nCachedObjects_,e=a.length;c!==e;++c)a[c].bind()},unbind:function(){for(var a=this._bindings,c=this._targetGroup.nCachedObjects_,
e=a.length;c!==e;++c)a[c].unbind()}});Object.assign($b,{Composite:Rj,create:function(a,c,e){return a&&a.isAnimationObjectGroup?new $b.Composite(a,c,e):new $b(a,c,e)},sanitizeNodeName:function(a){return a.replace(/\s/g,"_").replace(Om,"")},parseTrackName:function(a){var c=Um.exec(a);if(!c)throw Error("PropertyBinding: Cannot parse trackName: "+a);c={nodeName:c[2],objectName:c[3],objectIndex:c[4],propertyName:c[5],propertyIndex:c[6]};var e=c.nodeName&&c.nodeName.lastIndexOf(".");if(void 0!==e&&-1!==
e){var g=c.nodeName.substring(e+1);-1!==Vm.indexOf(g)&&(c.nodeName=c.nodeName.substring(0,e),c.objectName=g)}if(null===c.propertyName||0===c.propertyName.length)throw Error("PropertyBinding: can not parse propertyName from trackName: "+a);return c},findNode:function(a,c){if(!c||""===c||"root"===c||"."===c||-1===c||c===a.name||c===a.uuid)return a;if(a.skeleton){var e=a.skeleton.getBoneByName(c);if(void 0!==e)return e}if(a.children){var g=function(r){for(var v=0;v<r.length;v++){var z=r[v];if(z.name===
c||z.uuid===c)return z;if(z=g(z.children))return z}return null};if(a=g(a.children))return a}return null}});Object.assign($b.prototype,{_getValue_unavailable:function(){},_setValue_unavailable:function(){},BindingType:{Direct:0,EntireArray:1,ArrayElement:2,HasFromToArray:3},Versioning:{None:0,NeedsUpdate:1,MatrixWorldNeedsUpdate:2},GetterByBindingType:[function(a,c){a[c]=this.node[this.propertyName]},function(a,c){for(var e=this.resolvedProperty,g=0,r=e.length;g!==r;++g)a[c++]=e[g]},function(a,c){a[c]=
this.resolvedProperty[this.propertyIndex]},function(a,c){this.resolvedProperty.toArray(a,c)}],SetterByBindingTypeAndVersioning:[[function(a,c){this.targetObject[this.propertyName]=a[c]},function(a,c){this.targetObject[this.propertyName]=a[c];this.targetObject.needsUpdate=!0},function(a,c){this.targetObject[this.propertyName]=a[c];this.targetObject.matrixWorldNeedsUpdate=!0}],[function(a,c){for(var e=this.resolvedProperty,g=0,r=e.length;g!==r;++g)e[g]=a[c++]},function(a,c){for(var e=this.resolvedProperty,
g=0,r=e.length;g!==r;++g)e[g]=a[c++];this.targetObject.needsUpdate=!0},function(a,c){for(var e=this.resolvedProperty,g=0,r=e.length;g!==r;++g)e[g]=a[c++];this.targetObject.matrixWorldNeedsUpdate=!0}],[function(a,c){this.resolvedProperty[this.propertyIndex]=a[c]},function(a,c){this.resolvedProperty[this.propertyIndex]=a[c];this.targetObject.needsUpdate=!0},function(a,c){this.resolvedProperty[this.propertyIndex]=a[c];this.targetObject.matrixWorldNeedsUpdate=!0}],[function(a,c){this.resolvedProperty.fromArray(a,
c)},function(a,c){this.resolvedProperty.fromArray(a,c);this.targetObject.needsUpdate=!0},function(a,c){this.resolvedProperty.fromArray(a,c);this.targetObject.matrixWorldNeedsUpdate=!0}]],getValue:function(a,c){this.bind();this.getValue(a,c)},setValue:function(a,c){this.bind();this.setValue(a,c)},bind:function(){var a=this.node,c=this.parsedPath,e=c.objectName,g=c.propertyName,r=c.propertyIndex;a||(this.node=a=$b.findNode(this.rootNode,c.nodeName)||this.rootNode);this.getValue=this._getValue_unavailable;
this.setValue=this._setValue_unavailable;if(a){if(e){var v=c.objectIndex;switch(e){case "materials":if(!a.material){console.error("THREE.PropertyBinding: Can not bind to material as node does not have a material.",this);return}if(!a.material.materials){console.error("THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.",this);return}a=a.material.materials;break;case "bones":if(!a.skeleton){console.error("THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.",
this);return}a=a.skeleton.bones;for(e=0;e<a.length;e++)if(a[e].name===v){v=e;break}break;default:if(void 0===a[e]){console.error("THREE.PropertyBinding: Can not bind to objectName of node undefined.",this);return}a=a[e]}if(void 0!==v){if(void 0===a[v]){console.error("THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.",this,a);return}a=a[v]}}v=a[g];if(void 0===v)console.error("THREE.PropertyBinding: Trying to update property for track: "+c.nodeName+"."+g+" but it wasn't found.",
a);else{c=this.Versioning.None;this.targetObject=a;void 0!==a.needsUpdate?c=this.Versioning.NeedsUpdate:void 0!==a.matrixWorldNeedsUpdate&&(c=this.Versioning.MatrixWorldNeedsUpdate);e=this.BindingType.Direct;if(void 0!==r){if("morphTargetInfluences"===g){if(!a.geometry){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.",this);return}if(a.geometry.isBufferGeometry){if(!a.geometry.morphAttributes){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.",
this);return}for(e=0;e<this.node.geometry.morphAttributes.position.length;e++)if(a.geometry.morphAttributes.position[e].name===r){r=e;break}}else{if(!a.geometry.morphTargets){console.error("THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphTargets.",this);return}for(e=0;e<this.node.geometry.morphTargets.length;e++)if(a.geometry.morphTargets[e].name===r){r=e;break}}}e=this.BindingType.ArrayElement;this.resolvedProperty=v;this.propertyIndex=r}else void 0!==
v.fromArray&&void 0!==v.toArray?(e=this.BindingType.HasFromToArray,this.resolvedProperty=v):Array.isArray(v)?(e=this.BindingType.EntireArray,this.resolvedProperty=v):this.propertyName=g;this.getValue=this.GetterByBindingType[e];this.setValue=this.SetterByBindingTypeAndVersioning[e][c]}}else console.error("THREE.PropertyBinding: Trying to update node for track: "+this.path+" but it wasn't found.")},unbind:function(){this.node=null;this.getValue=this._getValue_unbound;this.setValue=this._setValue_unbound}});
Object.assign($b.prototype,{_getValue_unbound:$b.prototype.getValue,_setValue_unbound:$b.prototype.setValue});Object.assign(Sj.prototype,{isAnimationObjectGroup:!0,add:function(){for(var a=this._objects,c=a.length,e=this.nCachedObjects_,g=this._indicesByUUID,r=this._paths,v=this._parsedPaths,z=this._bindings,E=z.length,F=void 0,J=0,P=arguments.length;J!==P;++J){var R=arguments[J],S=R.uuid,V=g[S];if(void 0===V){V=c++;g[S]=V;a.push(R);S=0;for(var W=E;S!==W;++S)z[S].push(new $b(R,r[S],v[S]))}else if(V<
e){F=a[V];var ha=--e;W=a[ha];g[W.uuid]=V;a[V]=W;g[S]=ha;a[ha]=R;S=0;for(W=E;S!==W;++S){var fa=z[S],ra=fa[V];fa[V]=fa[ha];void 0===ra&&(ra=new $b(R,r[S],v[S]));fa[ha]=ra}}else a[V]!==F&&console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.")}this.nCachedObjects_=e},remove:function(){for(var a=this._objects,c=this.nCachedObjects_,e=this._indicesByUUID,g=this._bindings,r=g.length,v=0,z=arguments.length;v!==
z;++v){var E=arguments[v],F=E.uuid,J=e[F];if(void 0!==J&&J>=c){var P=c++,R=a[P];e[R.uuid]=J;a[J]=R;e[F]=P;a[P]=E;E=0;for(F=r;E!==F;++E){R=g[E];var S=R[J];R[J]=R[P];R[P]=S}}}this.nCachedObjects_=c},uncache:function(){for(var a=this._objects,c=a.length,e=this.nCachedObjects_,g=this._indicesByUUID,r=this._bindings,v=r.length,z=0,E=arguments.length;z!==E;++z){var F=arguments[z].uuid,J=g[F];if(void 0!==J)if(delete g[F],J<e){F=--e;var P=a[F],R=--c,S=a[R];g[P.uuid]=J;a[J]=P;g[S.uuid]=F;a[F]=S;a.pop();P=
0;for(S=v;P!==S;++P){var V=r[P],W=V[R];V[J]=V[F];V[F]=W;V.pop()}}else for(R=--c,S=a[R],g[S.uuid]=J,a[J]=S,a.pop(),P=0,S=v;P!==S;++P)V=r[P],V[J]=V[R],V.pop()}this.nCachedObjects_=e},subscribe_:function(a,c){var e=this._bindingsIndicesByPath,g=e[a],r=this._bindings;if(void 0!==g)return r[g];var v=this._paths,z=this._parsedPaths,E=this._objects,F=this.nCachedObjects_,J=Array(E.length);g=r.length;e[a]=g;v.push(a);z.push(c);r.push(J);e=F;for(g=E.length;e!==g;++e)J[e]=new $b(E[e],a,c);return J},unsubscribe_:function(a){var c=
this._bindingsIndicesByPath,e=c[a];if(void 0!==e){var g=this._paths,r=this._parsedPaths,v=this._bindings,z=v.length-1,E=v[z];c[a[z]]=e;v[e]=E;v.pop();r[e]=r[z];r.pop();g[e]=g[z];g.pop()}}});Object.assign(Tj.prototype,{play:function(){this._mixer._activateAction(this);return this},stop:function(){this._mixer._deactivateAction(this);return this.reset()},reset:function(){this.paused=!1;this.enabled=!0;this.time=0;this._loopCount=-1;this._startTime=null;return this.stopFading().stopWarping()},isRunning:function(){return this.enabled&&
!this.paused&&0!==this.timeScale&&null===this._startTime&&this._mixer._isActiveAction(this)},isScheduled:function(){return this._mixer._isActiveAction(this)},startAt:function(a){this._startTime=a;return this},setLoop:function(a,c){this.loop=a;this.repetitions=c;return this},setEffectiveWeight:function(a){this.weight=a;this._effectiveWeight=this.enabled?a:0;return this.stopFading()},getEffectiveWeight:function(){return this._effectiveWeight},fadeIn:function(a){return this._scheduleFading(a,0,1)},fadeOut:function(a){return this._scheduleFading(a,
1,0)},crossFadeFrom:function(a,c,e){a.fadeOut(c);this.fadeIn(c);if(e){e=this._clip.duration;var g=a._clip.duration,r=e/g;a.warp(1,g/e,c);this.warp(r,1,c)}return this},crossFadeTo:function(a,c,e){return a.crossFadeFrom(this,c,e)},stopFading:function(){var a=this._weightInterpolant;null!==a&&(this._weightInterpolant=null,this._mixer._takeBackControlInterpolant(a));return this},setEffectiveTimeScale:function(a){this.timeScale=a;this._effectiveTimeScale=this.paused?0:a;return this.stopWarping()},getEffectiveTimeScale:function(){return this._effectiveTimeScale},
setDuration:function(a){this.timeScale=this._clip.duration/a;return this.stopWarping()},syncWith:function(a){this.time=a.time;this.timeScale=a.timeScale;return this.stopWarping()},halt:function(a){return this.warp(this._effectiveTimeScale,0,a)},warp:function(a,c,e){var g=this._mixer,r=g.time,v=this._timeScaleInterpolant,z=this.timeScale;null===v&&(this._timeScaleInterpolant=v=g._lendControlInterpolant());g=v.parameterPositions;v=v.sampleValues;g[0]=r;g[1]=r+e;v[0]=a/z;v[1]=c/z;return this},stopWarping:function(){var a=
this._timeScaleInterpolant;null!==a&&(this._timeScaleInterpolant=null,this._mixer._takeBackControlInterpolant(a));return this},getMixer:function(){return this._mixer},getClip:function(){return this._clip},getRoot:function(){return this._localRoot||this._mixer._root},_update:function(a,c,e,g){if(this.enabled){var r=this._startTime;if(null!==r){c=(a-r)*e;if(0>c||0===e)return;this._startTime=null;c*=e}c*=this._updateTimeScale(a);e=this._updateTime(c);a=this._updateWeight(a);if(0<a){c=this._interpolants;
r=this._propertyBindings;for(var v=0,z=c.length;v!==z;++v)c[v].evaluate(e),r[v].accumulate(g,a)}}else this._updateWeight(a)},_updateWeight:function(a){var c=0;if(this.enabled){c=this.weight;var e=this._weightInterpolant;if(null!==e){var g=e.evaluate(a)[0];c*=g;a>e.parameterPositions[1]&&(this.stopFading(),0===g&&(this.enabled=!1))}}return this._effectiveWeight=c},_updateTimeScale:function(a){var c=0;if(!this.paused){c=this.timeScale;var e=this._timeScaleInterpolant;if(null!==e){var g=e.evaluate(a)[0];
c*=g;a>e.parameterPositions[1]&&(this.stopWarping(),0===c?this.paused=!0:this.timeScale=c)}}return this._effectiveTimeScale=c},_updateTime:function(a){var c=this.time+a,e=this._clip.duration,g=this.loop,r=this._loopCount,v=2202===g;if(0===a)return-1===r?c:v&&1===(r&1)?e-c:c;if(2200===g)a:{if(-1===r&&(this._loopCount=0,this._setEndings(!0,!0,!1)),c>=e)c=e;else if(0>c)c=0;else{this.time=c;break a}this.clampWhenFinished?this.paused=!0:this.enabled=!1;this.time=c;this._mixer.dispatchEvent({type:"finished",
action:this,direction:0>a?-1:1})}else{-1===r&&(0<=a?(r=0,this._setEndings(!0,0===this.repetitions,v)):this._setEndings(0===this.repetitions,!0,v));if(c>=e||0>c){g=Math.floor(c/e);c-=e*g;r+=Math.abs(g);var z=this.repetitions-r;0>=z?(this.clampWhenFinished?this.paused=!0:this.enabled=!1,this.time=c=0<a?e:0,this._mixer.dispatchEvent({type:"finished",action:this,direction:0<a?1:-1})):(1===z?(a=0>a,this._setEndings(a,!a,v)):this._setEndings(!1,!1,v),this._loopCount=r,this.time=c,this._mixer.dispatchEvent({type:"loop",
action:this,loopDelta:g}))}else this.time=c;if(v&&1===(r&1))return e-c}return c},_setEndings:function(a,c,e){var g=this._interpolantSettings;e?(g.endingStart=2401,g.endingEnd=2401):(g.endingStart=a?this.zeroSlopeAtStart?2401:2400:2402,g.endingEnd=c?this.zeroSlopeAtEnd?2401:2400:2402)},_scheduleFading:function(a,c,e){var g=this._mixer,r=g.time,v=this._weightInterpolant;null===v&&(this._weightInterpolant=v=g._lendControlInterpolant());g=v.parameterPositions;v=v.sampleValues;g[0]=r;v[0]=c;g[1]=r+a;v[1]=
e;return this}});qi.prototype=Object.assign(Object.create(d.prototype),{constructor:qi,_bindAction:function(a,c){var e=a._localRoot||this._root,g=a._clip.tracks,r=g.length,v=a._propertyBindings;a=a._interpolants;var z=e.uuid,E=this._bindingsByRootAndName,F=E[z];void 0===F&&(F={},E[z]=F);for(E=0;E!==r;++E){var J=g[E],P=J.name,R=F[P];if(void 0===R){R=v[E];if(void 0!==R){null===R._cacheIndex&&(++R.referenceCount,this._addInactiveBinding(R,z,P));continue}R=new pi($b.create(e,P,c&&c._propertyBindings[E].binding.parsedPath),
J.ValueTypeName,J.getValueSize());++R.referenceCount;this._addInactiveBinding(R,z,P)}v[E]=R;a[E].resultBuffer=R.buffer}},_activateAction:function(a){if(!this._isActiveAction(a)){if(null===a._cacheIndex){var c=(a._localRoot||this._root).uuid,e=a._clip.uuid,g=this._actionsByClip[e];this._bindAction(a,g&&g.knownActions[0]);this._addInactiveAction(a,e,c)}c=a._propertyBindings;e=0;for(g=c.length;e!==g;++e){var r=c[e];0===r.useCount++&&(this._lendBinding(r),r.saveOriginalState())}this._lendAction(a)}},
_deactivateAction:function(a){if(this._isActiveAction(a)){for(var c=a._propertyBindings,e=0,g=c.length;e!==g;++e){var r=c[e];0===--r.useCount&&(r.restoreOriginalState(),this._takeBackBinding(r))}this._takeBackAction(a)}},_initMemoryManager:function(){this._actions=[];this._nActiveActions=0;this._actionsByClip={};this._bindings=[];this._nActiveBindings=0;this._bindingsByRootAndName={};this._controlInterpolants=[];this._nActiveControlInterpolants=0;var a=this;this.stats={actions:{get total(){return a._actions.length},
get inUse(){return a._nActiveActions}},bindings:{get total(){return a._bindings.length},get inUse(){return a._nActiveBindings}},controlInterpolants:{get total(){return a._controlInterpolants.length},get inUse(){return a._nActiveControlInterpolants}}}},_isActiveAction:function(a){a=a._cacheIndex;return null!==a&&a<this._nActiveActions},_addInactiveAction:function(a,c,e){var g=this._actions,r=this._actionsByClip,v=r[c];void 0===v?(v={knownActions:[a],actionByRoot:{}},a._byClipCacheIndex=0,r[c]=v):(c=
v.knownActions,a._byClipCacheIndex=c.length,c.push(a));a._cacheIndex=g.length;g.push(a);v.actionByRoot[e]=a},_removeInactiveAction:function(a){var c=this._actions,e=c[c.length-1],g=a._cacheIndex;e._cacheIndex=g;c[g]=e;c.pop();a._cacheIndex=null;c=a._clip.uuid;e=this._actionsByClip;g=e[c];var r=g.knownActions,v=r[r.length-1],z=a._byClipCacheIndex;v._byClipCacheIndex=z;r[z]=v;r.pop();a._byClipCacheIndex=null;delete g.actionByRoot[(a._localRoot||this._root).uuid];0===r.length&&delete e[c];this._removeInactiveBindingsForAction(a)},
_removeInactiveBindingsForAction:function(a){a=a._propertyBindings;for(var c=0,e=a.length;c!==e;++c){var g=a[c];0===--g.referenceCount&&this._removeInactiveBinding(g)}},_lendAction:function(a){var c=this._actions,e=a._cacheIndex,g=this._nActiveActions++,r=c[g];a._cacheIndex=g;c[g]=a;r._cacheIndex=e;c[e]=r},_takeBackAction:function(a){var c=this._actions,e=a._cacheIndex,g=--this._nActiveActions,r=c[g];a._cacheIndex=g;c[g]=a;r._cacheIndex=e;c[e]=r},_addInactiveBinding:function(a,c,e){var g=this._bindingsByRootAndName,
r=g[c],v=this._bindings;void 0===r&&(r={},g[c]=r);r[e]=a;a._cacheIndex=v.length;v.push(a)},_removeInactiveBinding:function(a){var c=this._bindings,e=a.binding,g=e.rootNode.uuid;e=e.path;var r=this._bindingsByRootAndName,v=r[g],z=c[c.length-1];a=a._cacheIndex;z._cacheIndex=a;c[a]=z;c.pop();delete v[e];0===Object.keys(v).length&&delete r[g]},_lendBinding:function(a){var c=this._bindings,e=a._cacheIndex,g=this._nActiveBindings++,r=c[g];a._cacheIndex=g;c[g]=a;r._cacheIndex=e;c[e]=r},_takeBackBinding:function(a){var c=
this._bindings,e=a._cacheIndex,g=--this._nActiveBindings,r=c[g];a._cacheIndex=g;c[g]=a;r._cacheIndex=e;c[e]=r},_lendControlInterpolant:function(){var a=this._controlInterpolants,c=this._nActiveControlInterpolants++,e=a[c];void 0===e&&(e=new Yf(new Float32Array(2),new Float32Array(2),1,this._controlInterpolantsResultBuffer),e.__cacheIndex=c,a[c]=e);return e},_takeBackControlInterpolant:function(a){var c=this._controlInterpolants,e=a.__cacheIndex,g=--this._nActiveControlInterpolants,r=c[g];a.__cacheIndex=
g;c[g]=a;r.__cacheIndex=e;c[e]=r},_controlInterpolantsResultBuffer:new Float32Array(1),clipAction:function(a,c){var e=c||this._root,g=e.uuid;e="string"===typeof a?tc.findByName(e,a):a;a=null!==e?e.uuid:a;var r=this._actionsByClip[a],v=null;if(void 0!==r){v=r.actionByRoot[g];if(void 0!==v)return v;v=r.knownActions[0];null===e&&(e=v._clip)}if(null===e)return null;c=new Tj(this,e,c);this._bindAction(c,v);this._addInactiveAction(c,a,g);return c},existingAction:function(a,c){var e=c||this._root;c=e.uuid;
e="string"===typeof a?tc.findByName(e,a):a;a=this._actionsByClip[e?e.uuid:a];return void 0!==a?a.actionByRoot[c]||null:null},stopAllAction:function(){for(var a=this._actions,c=this._nActiveActions,e=this._bindings,g=this._nActiveBindings,r=this._nActiveBindings=this._nActiveActions=0;r!==c;++r)a[r].reset();for(r=0;r!==g;++r)e[r].useCount=0;return this},update:function(a){a*=this.timeScale;for(var c=this._actions,e=this._nActiveActions,g=this.time+=a,r=Math.sign(a),v=this._accuIndex^=1,z=0;z!==e;++z)c[z]._update(g,
a,r,v);a=this._bindings;c=this._nActiveBindings;for(z=0;z!==c;++z)a[z].apply(v);return this},getRoot:function(){return this._root},uncacheClip:function(a){var c=this._actions;a=a.uuid;var e=this._actionsByClip,g=e[a];if(void 0!==g){g=g.knownActions;for(var r=0,v=g.length;r!==v;++r){var z=g[r];this._deactivateAction(z);var E=z._cacheIndex,F=c[c.length-1];z._cacheIndex=null;z._byClipCacheIndex=null;F._cacheIndex=E;c[E]=F;c.pop();this._removeInactiveBindingsForAction(z)}delete e[a]}},uncacheRoot:function(a){a=
a.uuid;var c=this._actionsByClip;for(g in c){var e=c[g].actionByRoot[a];void 0!==e&&(this._deactivateAction(e),this._removeInactiveAction(e))}var g=this._bindingsByRootAndName[a];if(void 0!==g)for(var r in g)a=g[r],a.restoreOriginalState(),this._removeInactiveBinding(a)},uncacheAction:function(a,c){a=this.existingAction(a,c);null!==a&&(this._deactivateAction(a),this._removeInactiveAction(a))}});bh.prototype.clone=function(){return new bh(void 0===this.value.clone?this.value:this.value.clone())};ri.prototype=
Object.assign(Object.create(Qd.prototype),{constructor:ri,isInstancedInterleavedBuffer:!0,copy:function(a){Qd.prototype.copy.call(this,a);this.meshPerAttribute=a.meshPerAttribute;return this}});Object.assign(Uj.prototype,{linePrecision:1,set:function(a,c){this.ray.set(a,c)},setFromCamera:function(a,c){c&&c.isPerspectiveCamera?(this.ray.origin.setFromMatrixPosition(c.matrixWorld),this.ray.direction.set(a.x,a.y,.5).unproject(c).sub(this.ray.origin).normalize(),this.camera=c):c&&c.isOrthographicCamera?
(this.ray.origin.set(a.x,a.y,(c.near+c.far)/(c.near-c.far)).unproject(c),this.ray.direction.set(0,0,-1).transformDirection(c.matrixWorld),this.camera=c):console.error("THREE.Raycaster: Unsupported camera type.")},intersectObject:function(a,c,e){e=e||[];si(a,this,e,c);e.sort(Vj);return e},intersectObjects:function(a,c,e){e=e||[];if(!1===Array.isArray(a))return console.warn("THREE.Raycaster.intersectObjects: objects is not an Array."),e;for(var g=0,r=a.length;g<r;g++)si(a[g],this,e,c);e.sort(Vj);return e}});
Object.assign(Wj.prototype,{set:function(a,c,e){this.radius=a;this.phi=c;this.theta=e;return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.radius=a.radius;this.phi=a.phi;this.theta=a.theta;return this},makeSafe:function(){this.phi=Math.max(1E-6,Math.min(Math.PI-1E-6,this.phi));return this},setFromVector3:function(a){return this.setFromCartesianCoords(a.x,a.y,a.z)},setFromCartesianCoords:function(a,c,e){this.radius=Math.sqrt(a*a+c*c+e*e);0===this.radius?this.phi=
this.theta=0:(this.theta=Math.atan2(a,e),this.phi=Math.acos(hb.clamp(c/this.radius,-1,1)));return this}});Object.assign(Xj.prototype,{set:function(a,c,e){this.radius=a;this.theta=c;this.y=e;return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.radius=a.radius;this.theta=a.theta;this.y=a.y;return this},setFromVector3:function(a){return this.setFromCartesianCoords(a.x,a.y,a.z)},setFromCartesianCoords:function(a,c,e){this.radius=Math.sqrt(a*a+e*e);this.theta=Math.atan2(a,
e);this.y=c;return this}});var yk=new f;Object.assign(ti.prototype,{set:function(a,c){this.min.copy(a);this.max.copy(c);return this},setFromPoints:function(a){this.makeEmpty();for(var c=0,e=a.length;c<e;c++)this.expandByPoint(a[c]);return this},setFromCenterAndSize:function(a,c){c=yk.copy(c).multiplyScalar(.5);this.min.copy(a).sub(c);this.max.copy(a).add(c);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.min.copy(a.min);this.max.copy(a.max);return this},
makeEmpty:function(){this.min.x=this.min.y=Infinity;this.max.x=this.max.y=-Infinity;return this},isEmpty:function(){return this.max.x<this.min.x||this.max.y<this.min.y},getCenter:function(a){void 0===a&&(console.warn("THREE.Box2: .getCenter() target is now required"),a=new f);return this.isEmpty()?a.set(0,0):a.addVectors(this.min,this.max).multiplyScalar(.5)},getSize:function(a){void 0===a&&(console.warn("THREE.Box2: .getSize() target is now required"),a=new f);return this.isEmpty()?a.set(0,0):a.subVectors(this.max,
this.min)},expandByPoint:function(a){this.min.min(a);this.max.max(a);return this},expandByVector:function(a){this.min.sub(a);this.max.add(a);return this},expandByScalar:function(a){this.min.addScalar(-a);this.max.addScalar(a);return this},containsPoint:function(a){return a.x<this.min.x||a.x>this.max.x||a.y<this.min.y||a.y>this.max.y?!1:!0},containsBox:function(a){return this.min.x<=a.min.x&&a.max.x<=this.max.x&&this.min.y<=a.min.y&&a.max.y<=this.max.y},getParameter:function(a,c){void 0===c&&(console.warn("THREE.Box2: .getParameter() target is now required"),
c=new f);return c.set((a.x-this.min.x)/(this.max.x-this.min.x),(a.y-this.min.y)/(this.max.y-this.min.y))},intersectsBox:function(a){return a.max.x<this.min.x||a.min.x>this.max.x||a.max.y<this.min.y||a.min.y>this.max.y?!1:!0},clampPoint:function(a,c){void 0===c&&(console.warn("THREE.Box2: .clampPoint() target is now required"),c=new f);return c.copy(a).clamp(this.min,this.max)},distanceToPoint:function(a){return yk.copy(a).clamp(this.min,this.max).sub(a).length()},intersect:function(a){this.min.max(a.min);
this.max.min(a.max);return this},union:function(a){this.min.min(a.min);this.max.max(a.max);return this},translate:function(a){this.min.add(a);this.max.add(a);return this},equals:function(a){return a.min.equals(this.min)&&a.max.equals(this.max)}});var zk=new k,zh=new k;Object.assign(ui.prototype,{set:function(a,c){this.start.copy(a);this.end.copy(c);return this},clone:function(){return(new this.constructor).copy(this)},copy:function(a){this.start.copy(a.start);this.end.copy(a.end);return this},getCenter:function(a){void 0===
a&&(console.warn("THREE.Line3: .getCenter() target is now required"),a=new k);return a.addVectors(this.start,this.end).multiplyScalar(.5)},delta:function(a){void 0===a&&(console.warn("THREE.Line3: .delta() target is now required"),a=new k);return a.subVectors(this.end,this.start)},distanceSq:function(){return this.start.distanceToSquared(this.end)},distance:function(){return this.start.distanceTo(this.end)},at:function(a,c){void 0===c&&(console.warn("THREE.Line3: .at() target is now required"),c=
new k);return this.delta(c).multiplyScalar(a).add(this.start)},closestPointToPointParameter:function(a,c){zk.subVectors(a,this.start);zh.subVectors(this.end,this.start);a=zh.dot(zk)/zh.dot(zh);c&&(a=hb.clamp(a,0,1));return a},closestPointToPoint:function(a,c,e){a=this.closestPointToPointParameter(a,c);void 0===e&&(console.warn("THREE.Line3: .closestPointToPoint() target is now required"),e=new k);return this.delta(e).multiplyScalar(a).add(this.start)},applyMatrix4:function(a){this.start.applyMatrix4(a);
this.end.applyMatrix4(a);return this},equals:function(a){return a.start.equals(this.start)&&a.end.equals(this.end)}});cg.prototype=Object.create(A.prototype);cg.prototype.constructor=cg;cg.prototype.isImmediateRenderObject=!0;var Zc=new k,od=new k,Ri=new t,Wm=["a","b","c"];dg.prototype=Object.create(Ib.prototype);dg.prototype.constructor=dg;dg.prototype.update=function(){this.object.updateMatrixWorld(!0);Ri.getNormalMatrix(this.object.matrixWorld);var a=this.object.matrixWorld,c=this.geometry.attributes.position,
e=this.object.geometry;if(e&&e.isGeometry)for(var g=e.vertices,r=e.faces,v=e=0,z=r.length;v<z;v++)for(var E=r[v],F=0,J=E.vertexNormals.length;F<J;F++){var P=E.vertexNormals[F];Zc.copy(g[E[Wm[F]]]).applyMatrix4(a);od.copy(P).applyMatrix3(Ri).normalize().multiplyScalar(this.size).add(Zc);c.setXYZ(e,Zc.x,Zc.y,Zc.z);e+=1;c.setXYZ(e,od.x,od.y,od.z);e+=1}else if(e&&e.isBufferGeometry)for(g=e.attributes.position,r=e.attributes.normal,F=e=0,J=g.count;F<J;F++)Zc.set(g.getX(F),g.getY(F),g.getZ(F)).applyMatrix4(a),
od.set(r.getX(F),r.getY(F),r.getZ(F)),od.applyMatrix3(Ri).normalize().multiplyScalar(this.size).add(Zc),c.setXYZ(e,Zc.x,Zc.y,Zc.z),e+=1,c.setXYZ(e,od.x,od.y,od.z),e+=1;c.needsUpdate=!0};var Ak=new k;Xe.prototype=Object.create(A.prototype);Xe.prototype.constructor=Xe;Xe.prototype.dispose=function(){this.cone.geometry.dispose();this.cone.material.dispose()};Xe.prototype.update=function(){this.light.updateMatrixWorld();var a=this.light.distance?this.light.distance:1E3,c=a*Math.tan(this.light.angle);
this.cone.scale.set(c,c,a);Ak.setFromMatrixPosition(this.light.target.matrixWorld);this.cone.lookAt(Ak);void 0!==this.color?this.cone.material.color.set(this.color):this.cone.material.color.copy(this.light.color)};var Id=new k,Ah=new q,Si=new q;Ye.prototype=Object.create(Ib.prototype);Ye.prototype.constructor=Ye;Ye.prototype.updateMatrixWorld=function(a){var c=this.bones,e=this.geometry,g=e.getAttribute("position");Si.getInverse(this.root.matrixWorld);for(var r=0,v=0;r<c.length;r++){var z=c[r];z.parent&&
z.parent.isBone&&(Ah.multiplyMatrices(Si,z.matrixWorld),Id.setFromMatrixPosition(Ah),g.setXYZ(v,Id.x,Id.y,Id.z),Ah.multiplyMatrices(Si,z.parent.matrixWorld),Id.setFromMatrixPosition(Ah),g.setXYZ(v+1,Id.x,Id.y,Id.z),v+=2)}e.getAttribute("position").needsUpdate=!0;A.prototype.updateMatrixWorld.call(this,a)};Ze.prototype=Object.create(xa.prototype);Ze.prototype.constructor=Ze;Ze.prototype.dispose=function(){this.geometry.dispose();this.material.dispose()};Ze.prototype.update=function(){void 0!==this.color?
this.material.color.set(this.color):this.material.color.copy(this.light.color)};$e.prototype=Object.create(Vb.prototype);$e.prototype.constructor=$e;$e.prototype.update=function(){this.scale.set(.5*this.light.width,.5*this.light.height,1);if(void 0!==this.color)this.material.color.set(this.color),this.children[0].material.color.set(this.color);else{this.material.color.copy(this.light.color).multiplyScalar(this.light.intensity);var a=this.material.color,c=Math.max(a.r,a.g,a.b);1<c&&a.multiplyScalar(1/
c);this.children[0].material.color.copy(this.material.color)}};$e.prototype.dispose=function(){this.geometry.dispose();this.material.dispose();this.children[0].geometry.dispose();this.children[0].material.dispose()};var Xm=new k,Bk=new I,Ck=new I;af.prototype=Object.create(A.prototype);af.prototype.constructor=af;af.prototype.dispose=function(){this.children[0].geometry.dispose();this.children[0].material.dispose()};af.prototype.update=function(){var a=this.children[0];if(void 0!==this.color)this.material.color.set(this.color);
else{var c=a.geometry.getAttribute("color");Bk.copy(this.light.color);Ck.copy(this.light.groundColor);for(var e=0,g=c.count;e<g;e++){var r=e<g/2?Bk:Ck;c.setXYZ(e,r.r,r.g,r.b)}c.needsUpdate=!0}a.lookAt(Xm.setFromMatrixPosition(this.light.matrixWorld).negate())};bf.prototype=Object.create(xa.prototype);bf.prototype.constructor=bf;bf.prototype.dispose=function(){this.geometry.dispose();this.material.dispose()};bf.prototype.onBeforeRender=function(){this.position.copy(this.lightProbe.position);this.scale.set(1,
1,1).multiplyScalar(this.size);this.material.uniforms.intensity.value=this.lightProbe.intensity};ch.prototype=Object.assign(Object.create(Ib.prototype),{constructor:ch,copy:function(a){Ib.prototype.copy.call(this,a);this.geometry.copy(a.geometry);this.material.copy(a.material);return this},clone:function(){return(new this.constructor).copy(this)}});dh.prototype=Object.create(Ib.prototype);dh.prototype.constructor=dh;cf.prototype=Object.create(Vb.prototype);cf.prototype.constructor=cf;cf.prototype.update=
function(){function a(W,ha,fa,ra){fa=(ha-W)/fa;V.setXYZ(F,0,0,0);J++;for(P=W;P<ha;P+=fa)R=F+J,V.setXYZ(R,Math.sin(P)*e,0,Math.cos(P)*e),V.setXYZ(R+1,Math.sin(Math.min(P+fa,ha))*e,0,Math.cos(Math.min(P+fa,ha))*e),V.setXYZ(R+2,0,0,0),J+=3;S.addGroup(F,J,ra);F+=J;J=0}var c=this.audio,e=this.range,g=this.divisionsInnerAngle,r=this.divisionsOuterAngle,v=hb.degToRad(c.panner.coneInnerAngle);c=hb.degToRad(c.panner.coneOuterAngle);var z=v/2,E=c/2,F=0,J=0,P,R,S=this.geometry,V=S.attributes.position;S.clearGroups();
a(-E,-z,r,0);a(-z,z,g,1);a(z,E,r,0);V.needsUpdate=!0;v===c&&(this.material[0].visible=!1)};cf.prototype.dispose=function(){this.geometry.dispose();this.material[0].dispose();this.material[1].dispose()};var qg=new k,Bh=new k,Dk=new t;eg.prototype=Object.create(Ib.prototype);eg.prototype.constructor=eg;eg.prototype.update=function(){this.object.updateMatrixWorld(!0);Dk.getNormalMatrix(this.object.matrixWorld);var a=this.object.matrixWorld,c=this.geometry.attributes.position,e=this.object.geometry,g=
e.vertices;e=e.faces;for(var r=0,v=0,z=e.length;v<z;v++){var E=e[v],F=E.normal;qg.copy(g[E.a]).add(g[E.b]).add(g[E.c]).divideScalar(3).applyMatrix4(a);Bh.copy(F).applyMatrix3(Dk).normalize().multiplyScalar(this.size).add(qg);c.setXYZ(r,qg.x,qg.y,qg.z);r+=1;c.setXYZ(r,Bh.x,Bh.y,Bh.z);r+=1}c.needsUpdate=!0};var Ek=new k,Ch=new k,Fk=new k;df.prototype=Object.create(A.prototype);df.prototype.constructor=df;df.prototype.dispose=function(){this.lightPlane.geometry.dispose();this.lightPlane.material.dispose();
this.targetLine.geometry.dispose();this.targetLine.material.dispose()};df.prototype.update=function(){Ek.setFromMatrixPosition(this.light.matrixWorld);Ch.setFromMatrixPosition(this.light.target.matrixWorld);Fk.subVectors(Ch,Ek);this.lightPlane.lookAt(Ch);void 0!==this.color?(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(Ch);
this.targetLine.scale.z=Fk.length()};var eh=new k,Ob=new zb;fg.prototype=Object.create(Ib.prototype);fg.prototype.constructor=fg;fg.prototype.update=function(){var a=this.geometry,c=this.pointMap;Ob.projectionMatrixInverse.copy(this.camera.projectionMatrixInverse);Pb("c",c,a,Ob,0,0,-1);Pb("t",c,a,Ob,0,0,1);Pb("n1",c,a,Ob,-1,-1,-1);Pb("n2",c,a,Ob,1,-1,-1);Pb("n3",c,a,Ob,-1,1,-1);Pb("n4",c,a,Ob,1,1,-1);Pb("f1",c,a,Ob,-1,-1,1);Pb("f2",c,a,Ob,1,-1,1);Pb("f3",c,a,Ob,-1,1,1);Pb("f4",c,a,Ob,1,1,1);Pb("u1",
c,a,Ob,.7,1.1,-1);Pb("u2",c,a,Ob,-.7,1.1,-1);Pb("u3",c,a,Ob,0,2,-1);Pb("cf1",c,a,Ob,-1,0,1);Pb("cf2",c,a,Ob,1,0,1);Pb("cf3",c,a,Ob,0,-1,1);Pb("cf4",c,a,Ob,0,1,1);Pb("cn1",c,a,Ob,-1,0,-1);Pb("cn2",c,a,Ob,1,0,-1);Pb("cn3",c,a,Ob,0,-1,-1);Pb("cn4",c,a,Ob,0,1,-1);a.getAttribute("position").needsUpdate=!0};var Dh=new w;hd.prototype=Object.create(Ib.prototype);hd.prototype.constructor=hd;hd.prototype.update=function(a){void 0!==a&&console.warn("THREE.BoxHelper: .update() has no longer arguments.");void 0!==
this.object&&Dh.setFromObject(this.object);if(!Dh.isEmpty()){a=Dh.min;var c=Dh.max,e=this.geometry.attributes.position,g=e.array;g[0]=c.x;g[1]=c.y;g[2]=c.z;g[3]=a.x;g[4]=c.y;g[5]=c.z;g[6]=a.x;g[7]=a.y;g[8]=c.z;g[9]=c.x;g[10]=a.y;g[11]=c.z;g[12]=c.x;g[13]=c.y;g[14]=a.z;g[15]=a.x;g[16]=c.y;g[17]=a.z;g[18]=a.x;g[19]=a.y;g[20]=a.z;g[21]=c.x;g[22]=a.y;g[23]=a.z;e.needsUpdate=!0;this.geometry.computeBoundingSphere()}};hd.prototype.setFromObject=function(a){this.object=a;this.update();return this};hd.prototype.copy=
function(a){Ib.prototype.copy.call(this,a);this.object=a.object;return this};hd.prototype.clone=function(){return(new this.constructor).copy(this)};gg.prototype=Object.create(Ib.prototype);gg.prototype.constructor=gg;gg.prototype.updateMatrixWorld=function(a){var c=this.box;c.isEmpty()||(c.getCenter(this.position),c.getSize(this.scale),this.scale.multiplyScalar(.5),A.prototype.updateMatrixWorld.call(this,a))};hg.prototype=Object.create(Vb.prototype);hg.prototype.constructor=hg;hg.prototype.updateMatrixWorld=
function(a){var c=-this.plane.constant;1E-8>Math.abs(c)&&(c=1E-8);this.scale.set(.5*this.size,.5*this.size,c);this.children[0].material.side=0>c?1:0;this.lookAt(this.plane.normal);A.prototype.updateMatrixWorld.call(this,a)};var Gk=new k,fh,vi;id.prototype=Object.create(A.prototype);id.prototype.constructor=id;id.prototype.setDirection=function(a){.99999<a.y?this.quaternion.set(0,0,0,1):-.99999>a.y?this.quaternion.set(1,0,0,0):(Gk.set(a.z,0,-a.x).normalize(),this.quaternion.setFromAxisAngle(Gk,Math.acos(a.y)))};
id.prototype.setLength=function(a,c,e){void 0===c&&(c=.2*a);void 0===e&&(e=.2*c);this.line.scale.set(1,Math.max(0,a-c),1);this.line.updateMatrix();this.cone.scale.set(e,c,e);this.cone.position.y=a;this.cone.updateMatrix()};id.prototype.setColor=function(a){this.line.material.color.set(a);this.cone.material.color.set(a)};id.prototype.copy=function(a){A.prototype.copy.call(this,a,!1);this.line.copy(a.line);this.cone.copy(a.cone);return this};id.prototype.clone=function(){return(new this.constructor).copy(this)};
ig.prototype=Object.create(Ib.prototype);ig.prototype.constructor=ig;Za.create=function(a,c){console.log("THREE.Curve.create() has been deprecated");a.prototype=Object.create(Za.prototype);a.prototype.constructor=a;a.prototype.getPoint=c;return a};Object.assign(gd.prototype,{createPointsGeometry:function(a){console.warn("THREE.CurvePath: .createPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.");a=this.getPoints(a);return this.createGeometry(a)},createSpacedPointsGeometry:function(a){console.warn("THREE.CurvePath: .createSpacedPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.");
a=this.getSpacedPoints(a);return this.createGeometry(a)},createGeometry:function(a){console.warn("THREE.CurvePath: .createGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.");for(var c=new ya,e=0,g=a.length;e<g;e++){var r=a[e];c.vertices.push(new k(r.x,r.y,r.z||0))}return c}});Object.assign(Gc.prototype,{fromPoints:function(a){console.warn("THREE.Path: .fromPoints() has been renamed to .setFromPoints().");this.setFromPoints(a)}});Zj.prototype=Object.create(Zb.prototype);
ak.prototype=Object.create(Zb.prototype);wi.prototype=Object.create(Zb.prototype);Object.assign(wi.prototype,{initFromArray:function(){console.error("THREE.Spline: .initFromArray() has been removed.")},getControlPointsArray:function(){console.error("THREE.Spline: .getControlPointsArray() has been removed.")},reparametrizeByArcLength:function(){console.error("THREE.Spline: .reparametrizeByArcLength() has been removed.")}});ch.prototype.setColors=function(){console.error("THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.")};
Ye.prototype.update=function(){console.error("THREE.SkeletonHelper: update() no longer needs to be called.")};Object.assign(Db.prototype,{extractUrlBase:function(a){console.warn("THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead.");return Pi.extractUrlBase(a)}});Object.assign(Zg.prototype,{setTexturePath:function(a){console.warn("THREE.ObjectLoader: .setTexturePath() has been renamed to .setResourcePath().");return this.setResourcePath(a)}});Object.assign(ti.prototype,
{center:function(a){console.warn("THREE.Box2: .center() has been renamed to .getCenter().");return this.getCenter(a)},empty:function(){console.warn("THREE.Box2: .empty() has been renamed to .isEmpty().");return this.isEmpty()},isIntersectionBox:function(a){console.warn("THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox().");return this.intersectsBox(a)},size:function(a){console.warn("THREE.Box2: .size() has been renamed to .getSize().");return this.getSize(a)}});Object.assign(w.prototype,
{center:function(a){console.warn("THREE.Box3: .center() has been renamed to .getCenter().");return this.getCenter(a)},empty:function(){console.warn("THREE.Box3: .empty() has been renamed to .isEmpty().");return this.isEmpty()},isIntersectionBox:function(a){console.warn("THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox().");return this.intersectsBox(a)},isIntersectionSphere:function(a){console.warn("THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere().");return this.intersectsSphere(a)},
size:function(a){console.warn("THREE.Box3: .size() has been renamed to .getSize().");return this.getSize(a)}});ui.prototype.center=function(a){console.warn("THREE.Line3: .center() has been renamed to .getCenter().");return this.getCenter(a)};Object.assign(hb,{random16:function(){console.warn("THREE.Math: .random16() has been deprecated. Use Math.random() instead.");return Math.random()},nearestPowerOfTwo:function(a){console.warn("THREE.Math: .nearestPowerOfTwo() has been renamed to .floorPowerOfTwo().");
return hb.floorPowerOfTwo(a)},nextPowerOfTwo:function(a){console.warn("THREE.Math: .nextPowerOfTwo() has been renamed to .ceilPowerOfTwo().");return hb.ceilPowerOfTwo(a)}});Object.assign(t.prototype,{flattenToArrayOffset:function(a,c){console.warn("THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.");return this.toArray(a,c)},multiplyVector3:function(a){console.warn("THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead.");return a.applyMatrix3(this)},
multiplyVector3Array:function(){console.error("THREE.Matrix3: .multiplyVector3Array() has been removed.")},applyToBuffer:function(a){console.warn("THREE.Matrix3: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.");return this.applyToBufferAttribute(a)},applyToVector3Array:function(){console.error("THREE.Matrix3: .applyToVector3Array() has been removed.")}});Object.assign(q.prototype,{extractPosition:function(a){console.warn("THREE.Matrix4: .extractPosition() has been renamed to .copyPosition().");
return this.copyPosition(a)},flattenToArrayOffset:function(a,c){console.warn("THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.");return this.toArray(a,c)},getPosition:function(){console.warn("THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead.");return(new k).setFromMatrixColumn(this,3)},setRotationFromQuaternion:function(a){console.warn("THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion().");
return this.makeRotationFromQuaternion(a)},multiplyToArray:function(){console.warn("THREE.Matrix4: .multiplyToArray() has been removed.")},multiplyVector3:function(a){console.warn("THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead.");return a.applyMatrix4(this)},multiplyVector4:function(a){console.warn("THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead.");return a.applyMatrix4(this)},multiplyVector3Array:function(){console.error("THREE.Matrix4: .multiplyVector3Array() has been removed.")},
rotateAxis:function(a){console.warn("THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead.");a.transformDirection(this)},crossVector:function(a){console.warn("THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead.");return a.applyMatrix4(this)},translate:function(){console.error("THREE.Matrix4: .translate() has been removed.")},rotateX:function(){console.error("THREE.Matrix4: .rotateX() has been removed.")},rotateY:function(){console.error("THREE.Matrix4: .rotateY() has been removed.")},
rotateZ:function(){console.error("THREE.Matrix4: .rotateZ() has been removed.")},rotateByAxis:function(){console.error("THREE.Matrix4: .rotateByAxis() has been removed.")},applyToBuffer:function(a){console.warn("THREE.Matrix4: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.");return this.applyToBufferAttribute(a)},applyToVector3Array:function(){console.error("THREE.Matrix4: .applyToVector3Array() has been removed.")},makeFrustum:function(a,c,e,g,r,v){console.warn("THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead.");
return this.makePerspective(a,c,g,e,r,v)}});Hb.prototype.isIntersectionLine=function(a){console.warn("THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine().");return this.intersectsLine(a)};h.prototype.multiplyVector3=function(a){console.warn("THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead.");return a.applyQuaternion(this)};Object.assign(D.prototype,{isIntersectionBox:function(a){console.warn("THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox().");
return this.intersectsBox(a)},isIntersectionPlane:function(a){console.warn("THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane().");return this.intersectsPlane(a)},isIntersectionSphere:function(a){console.warn("THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere().");return this.intersectsSphere(a)}});Object.assign(B.prototype,{area:function(){console.warn("THREE.Triangle: .area() has been renamed to .getArea().");return this.getArea()},barycoordFromPoint:function(a,
c){console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord().");return this.getBarycoord(a,c)},midpoint:function(a){console.warn("THREE.Triangle: .midpoint() has been renamed to .getMidpoint().");return this.getMidpoint(a)},normal:function(a){console.warn("THREE.Triangle: .normal() has been renamed to .getNormal().");return this.getNormal(a)},plane:function(a){console.warn("THREE.Triangle: .plane() has been renamed to .getPlane().");return this.getPlane(a)}});Object.assign(B,
{barycoordFromPoint:function(a,c,e,g,r){console.warn("THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord().");return B.getBarycoord(a,c,e,g,r)},normal:function(a,c,e,g){console.warn("THREE.Triangle: .normal() has been renamed to .getNormal().");return B.getNormal(a,c,e,g)}});Object.assign(Cd.prototype,{extractAllPoints:function(a){console.warn("THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead.");return this.extractPoints(a)},extrude:function(a){console.warn("THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead.");
return new Ud(this,a)},makeGeometry:function(a){console.warn("THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead.");return new Vd(this,a)}});Object.assign(f.prototype,{fromAttribute:function(a,c,e){console.warn("THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute().");return this.fromBufferAttribute(a,c,e)},distanceToManhattan:function(a){console.warn("THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo().");return this.manhattanDistanceTo(a)},
lengthManhattan:function(){console.warn("THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength().");return this.manhattanLength()}});Object.assign(k.prototype,{setEulerFromRotationMatrix:function(){console.error("THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.")},setEulerFromQuaternion:function(){console.error("THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.")},getPositionFromMatrix:function(a){console.warn("THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().");
return this.setFromMatrixPosition(a)},getScaleFromMatrix:function(a){console.warn("THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().");return this.setFromMatrixScale(a)},getColumnFromMatrix:function(a,c){console.warn("THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().");return this.setFromMatrixColumn(c,a)},applyProjection:function(a){console.warn("THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead.");return this.applyMatrix4(a)},
fromAttribute:function(a,c,e){console.warn("THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute().");return this.fromBufferAttribute(a,c,e)},distanceToManhattan:function(a){console.warn("THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo().");return this.manhattanDistanceTo(a)},lengthManhattan:function(){console.warn("THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength().");return this.manhattanLength()}});Object.assign(p.prototype,
{fromAttribute:function(a,c,e){console.warn("THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute().");return this.fromBufferAttribute(a,c,e)},lengthManhattan:function(){console.warn("THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength().");return this.manhattanLength()}});Object.assign(ya.prototype,{computeTangents:function(){console.error("THREE.Geometry: .computeTangents() has been removed.")},computeLineDistances:function(){console.error("THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead.")}});
Object.assign(A.prototype,{getChildByName:function(a){console.warn("THREE.Object3D: .getChildByName() has been renamed to .getObjectByName().");return this.getObjectByName(a)},renderDepth:function(){console.warn("THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.")},translate:function(a,c){console.warn("THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead.");return this.translateOnAxis(c,a)},getWorldRotation:function(){console.error("THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.")}});
Object.defineProperties(A.prototype,{eulerOrder:{get:function(){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order.");return this.rotation.order},set:function(a){console.warn("THREE.Object3D: .eulerOrder is now .rotation.order.");this.rotation.order=a}},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.")}}});
Object.defineProperties(Af.prototype,{objects:{get:function(){console.warn("THREE.LOD: .objects has been renamed to .levels.");return this.levels}}});Object.defineProperty(Cg.prototype,"useVertexTexture",{get:function(){console.warn("THREE.Skeleton: useVertexTexture has been removed.")},set:function(){console.warn("THREE.Skeleton: useVertexTexture has been removed.")}});Bf.prototype.initBones=function(){console.error("THREE.SkinnedMesh: initBones() has been removed.")};Object.defineProperty(Za.prototype,
"__arcLengthDivisions",{get:function(){console.warn("THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.");return this.arcLengthDivisions},set:function(a){console.warn("THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.");this.arcLengthDivisions=a}});vb.prototype.setLens=function(a,c){console.warn("THREE.PerspectiveCamera.setLens is deprecated. Use .setFocalLength and .filmGauge for a photographic setup.");void 0!==c&&(this.filmGauge=c);this.setFocalLength(a)};Object.defineProperties(Jb.prototype,
{onlyShadow:{set:function(){console.warn("THREE.Light: .onlyShadow has been removed.")}},shadowCameraFov:{set:function(a){console.warn("THREE.Light: .shadowCameraFov is now .shadow.camera.fov.");this.shadow.camera.fov=a}},shadowCameraLeft:{set:function(a){console.warn("THREE.Light: .shadowCameraLeft is now .shadow.camera.left.");this.shadow.camera.left=a}},shadowCameraRight:{set:function(a){console.warn("THREE.Light: .shadowCameraRight is now .shadow.camera.right.");this.shadow.camera.right=a}},shadowCameraTop:{set:function(a){console.warn("THREE.Light: .shadowCameraTop is now .shadow.camera.top.");
this.shadow.camera.top=a}},shadowCameraBottom:{set:function(a){console.warn("THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom.");this.shadow.camera.bottom=a}},shadowCameraNear:{set:function(a){console.warn("THREE.Light: .shadowCameraNear is now .shadow.camera.near.");this.shadow.camera.near=a}},shadowCameraFar:{set:function(a){console.warn("THREE.Light: .shadowCameraFar is now .shadow.camera.far.");this.shadow.camera.far=a}},shadowCameraVisible:{set:function(){console.warn("THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.")}},
shadowBias:{set:function(a){console.warn("THREE.Light: .shadowBias is now .shadow.bias.");this.shadow.bias=a}},shadowDarkness:{set:function(){console.warn("THREE.Light: .shadowDarkness has been removed.")}},shadowMapWidth:{set:function(a){console.warn("THREE.Light: .shadowMapWidth is now .shadow.mapSize.width.");this.shadow.mapSize.width=a}},shadowMapHeight:{set:function(a){console.warn("THREE.Light: .shadowMapHeight is now .shadow.mapSize.height.");this.shadow.mapSize.height=a}}});Object.defineProperties(Q.prototype,
{length:{get:function(){console.warn("THREE.BufferAttribute: .length has been deprecated. Use .count instead.");return this.array.length}},copyIndicesArray:function(){console.error("THREE.BufferAttribute: .copyIndicesArray() has been removed.")}});Object.assign(va.prototype,{addIndex:function(a){console.warn("THREE.BufferGeometry: .addIndex() has been renamed to .setIndex().");this.setIndex(a)},addDrawCall:function(a,c,e){void 0!==e&&console.warn("THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset.");
console.warn("THREE.BufferGeometry: .addDrawCall() is now .addGroup().");this.addGroup(a,c)},clearDrawCalls:function(){console.warn("THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups().");this.clearGroups()},computeTangents:function(){console.warn("THREE.BufferGeometry: .computeTangents() has been removed.")},computeOffsets:function(){console.warn("THREE.BufferGeometry: .computeOffsets() has been removed.")}});Object.defineProperties(va.prototype,{drawcalls:{get:function(){console.error("THREE.BufferGeometry: .drawcalls has been renamed to .groups.");
return this.groups}},offsets:{get:function(){console.warn("THREE.BufferGeometry: .offsets has been renamed to .groups.");return this.groups}}});Object.assign(Rc.prototype,{getArrays:function(){console.error("THREE.ExtrudeBufferGeometry: .getArrays() has been removed.")},addShapeList:function(){console.error("THREE.ExtrudeBufferGeometry: .addShapeList() has been removed.")},addShape:function(){console.error("THREE.ExtrudeBufferGeometry: .addShape() has been removed.")}});Object.defineProperties(bh.prototype,
{dynamic:{set:function(){console.warn("THREE.Uniform: .dynamic has been removed. Use object.onBeforeRender() instead.")}},onUpdate:{value:function(){console.warn("THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead.");return this}}});Object.defineProperties(M.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(){console.warn("THREE.Material: .wrapRGB has been removed.");return new I}},shading:{get:function(){console.error("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.")},set:function(a){console.warn("THREE."+this.type+": .shading has been removed. Use the boolean .flatShading instead.");this.flatShading=1===a}}});Object.defineProperties(Bc.prototype,{metal:{get:function(){console.warn("THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead.");
return!1},set:function(){console.warn("THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead")}}});Object.defineProperties(qb.prototype,{derivatives:{get:function(){console.warn("THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives.");return this.extensions.derivatives},set:function(a){console.warn("THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives.");this.extensions.derivatives=a}}});Object.assign(Oh.prototype,
{clearTarget:function(a,c,e,g){console.warn("THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead.");this.setRenderTarget(a);this.clear(c,e,g)},animate:function(a){console.warn("THREE.WebGLRenderer: .animate() is now .setAnimationLoop().");this.setAnimationLoop(a)},getCurrentRenderTarget:function(){console.warn("THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget().");return this.getRenderTarget()},getMaxAnisotropy:function(){console.warn("THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy().");
return this.capabilities.getMaxAnisotropy()},getPrecision:function(){console.warn("THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision.");return this.capabilities.precision},resetGLState:function(){console.warn("THREE.WebGLRenderer: .resetGLState() is now .state.reset().");return this.state.reset()},supportsFloatTextures:function(){console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' ).");return this.extensions.get("OES_texture_float")},
supportsHalfFloatTextures:function(){console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' ).");return this.extensions.get("OES_texture_half_float")},supportsStandardDerivatives:function(){console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' ).");return this.extensions.get("OES_standard_derivatives")},supportsCompressedTextureS3TC:function(){console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' ).");
return this.extensions.get("WEBGL_compressed_texture_s3tc")},supportsCompressedTexturePVRTC:function(){console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' ).");return this.extensions.get("WEBGL_compressed_texture_pvrtc")},supportsBlendMinMax:function(){console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' ).");return this.extensions.get("EXT_blend_minmax")},supportsVertexTextures:function(){console.warn("THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures.");
return this.capabilities.vertexTextures},supportsInstancedArrays:function(){console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' ).");return this.extensions.get("ANGLE_instanced_arrays")},enableScissorTest:function(a){console.warn("THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest().");this.setScissorTest(a)},initMaterial:function(){console.warn("THREE.WebGLRenderer: .initMaterial() has been removed.")},addPrePlugin:function(){console.warn("THREE.WebGLRenderer: .addPrePlugin() has been removed.")},
addPostPlugin:function(){console.warn("THREE.WebGLRenderer: .addPostPlugin() has been removed.")},updateShadowMap:function(){console.warn("THREE.WebGLRenderer: .updateShadowMap() has been removed.")},setFaceCulling:function(){console.warn("THREE.WebGLRenderer: .setFaceCulling() has been removed.")},allocTextureUnit:function(){console.warn("THREE.WebGLRenderer: .allocTextureUnit() has been removed.")},setTexture:function(){console.warn("THREE.WebGLRenderer: .setTexture() has been removed.")},setTexture2D:function(){console.warn("THREE.WebGLRenderer: .setTexture2D() has been removed.")},
setTextureCube:function(){console.warn("THREE.WebGLRenderer: .setTextureCube() has been removed.")},getActiveMipMapLevel:function(){console.warn("THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel().");return this.getActiveMipmapLevel()}});Object.defineProperties(Oh.prototype,{shadowMapEnabled:{get:function(){return this.shadowMap.enabled},set:function(a){console.warn("THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled.");this.shadowMap.enabled=a}},shadowMapType:{get:function(){return this.shadowMap.type},
set:function(a){console.warn("THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type.");this.shadowMap.type=a}},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(){console.warn("THREE.WebGLRenderer: .context has been removed. Use .getContext() instead.");return this.getContext()}}});
Object.defineProperties(vj.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(Nb.prototype,{activeCubeFace:{set:function(){console.warn("THREE.WebGLRenderTargetCube: .activeCubeFace has been removed. It is now the second parameter of WebGLRenderer.setRenderTarget().")}},
activeMipMapLevel:{set:function(){console.warn("THREE.WebGLRenderTargetCube: .activeMipMapLevel has been removed. It is now the third parameter of WebGLRenderer.setRenderTarget().")}}});Object.defineProperties(m.prototype,{wrapS:{get:function(){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.");return this.texture.wrapS},set:function(a){console.warn("THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.");this.texture.wrapS=a}},wrapT:{get:function(){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.");
return this.texture.wrapT},set:function(a){console.warn("THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.");this.texture.wrapT=a}},magFilter:{get:function(){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.");return this.texture.magFilter},set:function(a){console.warn("THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.");this.texture.magFilter=a}},minFilter:{get:function(){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.");return this.texture.minFilter},
set:function(a){console.warn("THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.");this.texture.minFilter=a}},anisotropy:{get:function(){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.");return this.texture.anisotropy},set:function(a){console.warn("THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.");this.texture.anisotropy=a}},offset:{get:function(){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset.");return this.texture.offset},
set:function(a){console.warn("THREE.WebGLRenderTarget: .offset is now .texture.offset.");this.texture.offset=a}},repeat:{get:function(){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat.");return this.texture.repeat},set:function(a){console.warn("THREE.WebGLRenderTarget: .repeat is now .texture.repeat.");this.texture.repeat=a}},format:{get:function(){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format.");return this.texture.format},set:function(a){console.warn("THREE.WebGLRenderTarget: .format is now .texture.format.");
this.texture.format=a}},type:{get:function(){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type.");return this.texture.type},set:function(a){console.warn("THREE.WebGLRenderTarget: .type is now .texture.type.");this.texture.type=a}},generateMipmaps:{get:function(){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.");return this.texture.generateMipmaps},set:function(a){console.warn("THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.");
this.texture.generateMipmaps=a}}});Object.defineProperties(Nh.prototype,{standing:{set:function(){console.warn("THREE.WebVRManager: .standing has been removed.")}},userHeight:{set:function(){console.warn("THREE.WebVRManager: .userHeight has been removed.")}}});We.prototype.load=function(a){console.warn("THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.");var c=this;(new $g).load(a,function(e){c.setBuffer(e)});return this};oi.prototype.getData=function(){console.warn("THREE.AudioAnalyser: .getData() is now .getFrequencyData().");
return this.getFrequencyData()};Gb.prototype.updateCubeMap=function(a,c){console.warn("THREE.CubeCamera: .updateCubeMap() is now .update().");return this.update(a,c)};Dd.crossOrigin=void 0;Dd.loadTexture=function(a,c,e,g){console.warn("THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.");var r=new Mg;r.setCrossOrigin(this.crossOrigin);a=r.load(a,e,void 0,g);c&&(a.mapping=c);return a};Dd.loadTextureCube=function(a,c,e,g){console.warn("THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.");
var r=new Lg;r.setCrossOrigin(this.crossOrigin);a=r.load(a,e,void 0,g);c&&(a.mapping=c);return a};Dd.loadCompressedTexture=function(){console.error("THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.")};Dd.loadCompressedTextureCube=function(){console.error("THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.")};b.ACESFilmicToneMapping=5;b.AddEquation=100;b.AddOperation=2;b.AdditiveBlending=2;b.AlphaFormat=1021;b.AlwaysDepth=
1;b.AlwaysStencilFunc=519;b.AmbientLight=Tg;b.AmbientLightProbe=ji;b.AnimationClip=tc;b.AnimationLoader=ai;b.AnimationMixer=qi;b.AnimationObjectGroup=Sj;b.AnimationUtils=Tb;b.ArcCurve=Ve;b.ArrayCamera=vf;b.ArrowHelper=id;b.Audio=We;b.AudioAnalyser=oi;b.AudioContext=mi;b.AudioListener=li;b.AudioLoader=$g;b.AxesHelper=ig;b.AxisHelper=function(a){console.warn("THREE.AxisHelper has been renamed to THREE.AxesHelper.");return new ig(a)};b.BackSide=1;b.BasicDepthPacking=3200;b.BasicShadowMap=0;b.BinaryTextureLoader=
function(a){console.warn("THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader.");return new Kg(a)};b.Bone=Uh;b.BooleanKeyframeTrack=Gg;b.BoundingBoxHelper=function(a,c){console.warn("THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead.");return new hd(a,c)};b.Box2=ti;b.Box3=w;b.Box3Helper=gg;b.BoxBufferGeometry=Xa;b.BoxGeometry=Sa;b.BoxHelper=hd;b.BufferAttribute=Q;b.BufferGeometry=va;b.BufferGeometryLoader=Yg;b.ByteType=1010;b.Cache=ie;b.Camera=zb;b.CameraHelper=
fg;b.CanvasRenderer=function(){console.error("THREE.CanvasRenderer has been removed")};b.CanvasTexture=Cf;b.CatmullRomCurve3=Zb;b.CineonToneMapping=4;b.CircleBufferGeometry=Qe;b.CircleGeometry=Xf;b.ClampToEdgeWrapping=1001;b.Clock=ki;b.ClosedSplineCurve3=Zj;b.Color=I;b.ColorKeyframeTrack=Hg;b.CompressedTexture=De;b.CompressedTextureLoader=bi;b.ConeBufferGeometry=Wf;b.ConeGeometry=Vf;b.CubeCamera=Gb;b.CubeGeometry=Sa;b.CubeReflectionMapping=301;b.CubeRefractionMapping=302;b.CubeTexture=cd;b.CubeTextureLoader=
Lg;b.CubeUVReflectionMapping=306;b.CubeUVRefractionMapping=307;b.CubicBezierCurve=Cc;b.CubicBezierCurve3=Tc;b.CubicInterpolant=Eg;b.CullFaceBack=1;b.CullFaceFront=2;b.CullFaceFrontBack=3;b.CullFaceNone=0;b.Curve=Za;b.CurvePath=gd;b.CustomBlending=5;b.CylinderBufferGeometry=fd;b.CylinderGeometry=Xd;b.Cylindrical=Xj;b.DataTexture=Ab;b.DataTexture2DArray=re;b.DataTexture3D=se;b.DataTextureLoader=Kg;b.DecrementStencilOp=7683;b.DecrementWrapStencilOp=34056;b.DefaultLoadingManager=Oj;b.DepthFormat=1026;
b.DepthStencilFormat=1027;b.DepthTexture=Df;b.DirectionalLight=Sg;b.DirectionalLightHelper=df;b.DirectionalLightShadow=Rg;b.DiscreteInterpolant=Fg;b.DodecahedronBufferGeometry=Ie;b.DodecahedronGeometry=Jf;b.DoubleSide=2;b.DstAlphaFactor=206;b.DstColorFactor=208;b.DynamicBufferAttribute=function(a,c){console.warn("THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setDynamic( true ) instead.");return(new Q(a,c)).setDynamic(!0)};b.EdgesGeometry=Pe;b.EdgesHelper=function(a,
c){console.warn("THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead.");return new Ib(new Pe(a.geometry),new Fb({color:void 0!==c?c:16777215}))};b.EllipseCurve=pc;b.EqualDepth=4;b.EqualStencilFunc=514;b.EquirectangularReflectionMapping=303;b.EquirectangularRefractionMapping=304;b.Euler=u;b.EventDispatcher=d;b.ExtrudeBufferGeometry=Rc;b.ExtrudeGeometry=Ud;b.Face3=K;b.Face4=function(a,c,e,g,r,v,z){console.warn("THREE.Face4 has been removed. A THREE.Face3 will be created instead.");return new K(a,
c,e,r,v,z)};b.FaceColors=1;b.FaceNormalsHelper=eg;b.FileLoader=uc;b.FlatShading=1;b.Float32Attribute=function(a,c){console.warn("THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead.");return new ca(a,c)};b.Float32BufferAttribute=ca;b.Float64Attribute=function(a,c){console.warn("THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead.");return new ka(a,c)};b.Float64BufferAttribute=ka;b.FloatType=1015;b.Fog=Ag;b.FogExp2=zg;b.Font=gi;
b.FontLoader=hi;b.FrontFaceDirectionCCW=1;b.FrontFaceDirectionCW=0;b.FrontSide=0;b.Frustum=ic;b.GammaEncoding=3007;b.Geometry=ya;b.GeometryUtils={merge:function(a,c,e){console.warn("THREE.GeometryUtils: .merge() has been moved to Geometry. Use geometry.merge( geometry2, matrix, materialIndexOffset ) instead.");if(c.isMesh){c.matrixAutoUpdate&&c.updateMatrix();var g=c.matrix;c=c.geometry}a.merge(c,g,e)},center:function(a){console.warn("THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead.");
return a.center()}};b.GreaterDepth=6;b.GreaterEqualDepth=5;b.GreaterEqualStencilFunc=518;b.GreaterStencilFunc=516;b.GridHelper=ch;b.Group=ue;b.HalfFloatType=1016;b.HemisphereLight=Ng;b.HemisphereLightHelper=af;b.HemisphereLightProbe=ii;b.IcosahedronBufferGeometry=He;b.IcosahedronGeometry=If;b.ImageBitmapLoader=ei;b.ImageLoader=Ue;b.ImageUtils=Dd;b.ImmediateRenderObject=cg;b.IncrementStencilOp=7682;b.IncrementWrapStencilOp=34055;b.InstancedBufferAttribute=Xg;b.InstancedBufferGeometry=Wg;b.InstancedInterleavedBuffer=
ri;b.Int16Attribute=function(a,c){console.warn("THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead.");return new la(a,c)};b.Int16BufferAttribute=la;b.Int32Attribute=function(a,c){console.warn("THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead.");return new ba(a,c)};b.Int32BufferAttribute=ba;b.Int8Attribute=function(a,c){console.warn("THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead.");return new T(a,
c)};b.Int8BufferAttribute=T;b.IntType=1013;b.InterleavedBuffer=Qd;b.InterleavedBufferAttribute=xf;b.Interpolant=oc;b.InterpolateDiscrete=2300;b.InterpolateLinear=2301;b.InterpolateSmooth=2302;b.InvertStencilOp=5386;b.JSONLoader=function(){console.error("THREE.JSONLoader has been removed.")};b.KeepStencilOp=7680;b.KeyframeTrack=Xb;b.LOD=Af;b.LatheBufferGeometry=Oe;b.LatheGeometry=Uf;b.Layers=x;b.LensFlare=function(){console.error("THREE.LensFlare has been moved to /examples/js/objects/Lensflare.js")};
b.LessDepth=2;b.LessEqualDepth=3;b.LessEqualStencilFunc=515;b.LessStencilFunc=513;b.Light=Jb;b.LightProbe=Hc;b.LightProbeHelper=bf;b.LightShadow=Vc;b.Line=Vb;b.Line3=ui;b.LineBasicMaterial=Fb;b.LineCurve=kc;b.LineCurve3=Dc;b.LineDashedMaterial=de;b.LineLoop=Dg;b.LinePieces=1;b.LineSegments=Ib;b.LineStrip=0;b.LinearEncoding=3E3;b.LinearFilter=1006;b.LinearInterpolant=Yf;b.LinearMipMapLinearFilter=1008;b.LinearMipMapNearestFilter=1007;b.LinearMipmapLinearFilter=1008;b.LinearMipmapNearestFilter=1007;
b.LinearToneMapping=1;b.Loader=Db;b.LoaderUtils=Pi;b.LoadingManager=$h;b.LogLuvEncoding=3003;b.LoopOnce=2200;b.LoopPingPong=2202;b.LoopRepeat=2201;b.LuminanceAlphaFormat=1025;b.LuminanceFormat=1024;b.MOUSE={LEFT:0,MIDDLE:1,RIGHT:2,ROTATE:0,DOLLY:1,PAN:2};b.Material=M;b.MaterialLoader=Vg;b.Math=hb;b.Matrix3=t;b.Matrix4=q;b.MaxEquation=104;b.Mesh=xa;b.MeshBasicMaterial=L;b.MeshDepthMaterial=vd;b.MeshDistanceMaterial=wd;b.MeshFaceMaterial=function(a){console.warn("THREE.MeshFaceMaterial has been removed. Use an Array instead.");
return a};b.MeshLambertMaterial=be;b.MeshMatcapMaterial=ce;b.MeshNormalMaterial=ae;b.MeshPhongMaterial=Bc;b.MeshPhysicalMaterial=Zd;b.MeshStandardMaterial=Sc;b.MeshToonMaterial=$d;b.MinEquation=103;b.MirroredRepeatWrapping=1002;b.MixOperation=1;b.MultiMaterial=function(a){void 0===a&&(a=[]);console.warn("THREE.MultiMaterial has been removed. Use an Array instead.");a.isMultiMaterial=!0;a.materials=a;a.clone=function(){return a.slice()};return a};b.MultiplyBlending=4;b.MultiplyOperation=0;b.NearestFilter=
1003;b.NearestMipMapLinearFilter=1005;b.NearestMipMapNearestFilter=1004;b.NearestMipmapLinearFilter=1005;b.NearestMipmapNearestFilter=1004;b.NeverDepth=0;b.NeverStencilFunc=512;b.NoBlending=0;b.NoColors=0;b.NoToneMapping=0;b.NormalBlending=1;b.NotEqualDepth=7;b.NotEqualStencilFunc=517;b.NumberKeyframeTrack=Se;b.Object3D=A;b.ObjectLoader=Zg;b.ObjectSpaceNormalMap=1;b.OctahedronBufferGeometry=Rd;b.OctahedronGeometry=Hf;b.OneFactor=201;b.OneMinusDstAlphaFactor=207;b.OneMinusDstColorFactor=209;b.OneMinusSrcAlphaFactor=
205;b.OneMinusSrcColorFactor=203;b.OrthographicCamera=bg;b.PCFShadowMap=1;b.PCFSoftShadowMap=2;b.ParametricBufferGeometry=Fe;b.ParametricGeometry=Ef;b.Particle=function(a){console.warn("THREE.Particle has been renamed to THREE.Sprite.");return new yf(a)};b.ParticleBasicMaterial=function(a){console.warn("THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial.");return new Ac(a)};b.ParticleSystem=function(a,c){console.warn("THREE.ParticleSystem has been renamed to THREE.Points.");return new Ce(a,
c)};b.ParticleSystemMaterial=function(a){console.warn("THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial.");return new Ac(a)};b.Path=Gc;b.PerspectiveCamera=vb;b.Plane=Hb;b.PlaneBufferGeometry=Lc;b.PlaneGeometry=rd;b.PlaneHelper=hg;b.PointCloud=function(a,c){console.warn("THREE.PointCloud has been renamed to THREE.Points.");return new Ce(a,c)};b.PointCloudMaterial=function(a){console.warn("THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial.");return new Ac(a)};b.PointLight=
Qg;b.PointLightHelper=Ze;b.Points=Ce;b.PointsMaterial=Ac;b.PolarGridHelper=dh;b.PolyhedronBufferGeometry=jc;b.PolyhedronGeometry=Ff;b.PositionalAudio=ni;b.PositionalAudioHelper=cf;b.PropertyBinding=$b;b.PropertyMixer=pi;b.QuadraticBezierCurve=Ec;b.QuadraticBezierCurve3=Uc;b.Quaternion=h;b.QuaternionKeyframeTrack=Zf;b.QuaternionLinearInterpolant=Ig;b.REVISION="108";b.RGBADepthPacking=3201;b.RGBAFormat=1023;b.RGBA_ASTC_10x10_Format=37819;b.RGBA_ASTC_10x5_Format=37816;b.RGBA_ASTC_10x6_Format=37817;b.RGBA_ASTC_10x8_Format=
37818;b.RGBA_ASTC_12x10_Format=37820;b.RGBA_ASTC_12x12_Format=37821;b.RGBA_ASTC_4x4_Format=37808;b.RGBA_ASTC_5x4_Format=37809;b.RGBA_ASTC_5x5_Format=37810;b.RGBA_ASTC_6x5_Format=37811;b.RGBA_ASTC_6x6_Format=37812;b.RGBA_ASTC_8x5_Format=37813;b.RGBA_ASTC_8x6_Format=37814;b.RGBA_ASTC_8x8_Format=37815;b.RGBA_PVRTC_2BPPV1_Format=35843;b.RGBA_PVRTC_4BPPV1_Format=35842;b.RGBA_S3TC_DXT1_Format=33777;b.RGBA_S3TC_DXT3_Format=33778;b.RGBA_S3TC_DXT5_Format=33779;b.RGBDEncoding=3006;b.RGBEEncoding=3002;b.RGBEFormat=
1023;b.RGBFormat=1022;b.RGBM16Encoding=3005;b.RGBM7Encoding=3004;b.RGB_ETC1_Format=36196;b.RGB_PVRTC_2BPPV1_Format=35841;b.RGB_PVRTC_4BPPV1_Format=35840;b.RGB_S3TC_DXT1_Format=33776;b.RawShaderMaterial=Re;b.Ray=D;b.Raycaster=Uj;b.RectAreaLight=Ug;b.RectAreaLightHelper=$e;b.RedFormat=1028;b.ReinhardToneMapping=2;b.RepeatWrapping=1E3;b.ReplaceStencilOp=7681;b.ReverseSubtractEquation=102;b.RingBufferGeometry=Ne;b.RingGeometry=Tf;b.Scene=y;b.SceneUtils={createMultiMaterialObject:function(){console.error("THREE.SceneUtils has been moved to /examples/js/utils/SceneUtils.js")},
detach:function(){console.error("THREE.SceneUtils has been moved to /examples/js/utils/SceneUtils.js")},attach:function(){console.error("THREE.SceneUtils has been moved to /examples/js/utils/SceneUtils.js")}};b.ShaderChunk=rb;b.ShaderLib=Mc;b.ShaderMaterial=qb;b.ShadowMaterial=Yd;b.Shape=Cd;b.ShapeBufferGeometry=Wd;b.ShapeGeometry=Vd;b.ShapePath=fi;b.ShapeUtils=ed;b.ShortType=1011;b.Skeleton=Cg;b.SkeletonHelper=Ye;b.SkinnedMesh=Bf;b.SmoothShading=2;b.Sphere=G;b.SphereBufferGeometry=Bd;b.SphereGeometry=
Sf;b.Spherical=Wj;b.SphericalHarmonics3=ah;b.SphericalReflectionMapping=305;b.Spline=wi;b.SplineCurve=Fc;b.SplineCurve3=ak;b.SpotLight=Pg;b.SpotLightHelper=Xe;b.SpotLightShadow=Og;b.Sprite=yf;b.SpriteMaterial=Ad;b.SrcAlphaFactor=204;b.SrcAlphaSaturateFactor=210;b.SrcColorFactor=202;b.StereoCamera=Qj;b.StringKeyframeTrack=Jg;b.SubtractEquation=101;b.SubtractiveBlending=3;b.TOUCH={ROTATE:0,PAN:1,DOLLY_PAN:2,DOLLY_ROTATE:3};b.TangentSpaceNormalMap=0;b.TetrahedronBufferGeometry=Ge;b.TetrahedronGeometry=
Gf;b.TextBufferGeometry=Me;b.TextGeometry=Rf;b.Texture=l;b.TextureLoader=Mg;b.TorusBufferGeometry=Ke;b.TorusGeometry=Mf;b.TorusKnotBufferGeometry=Je;b.TorusKnotGeometry=Lf;b.Triangle=B;b.TriangleFanDrawMode=2;b.TriangleStripDrawMode=1;b.TrianglesDrawMode=0;b.TubeBufferGeometry=Sd;b.TubeGeometry=Kf;b.UVMapping=300;b.Uint16Attribute=function(a,c){console.warn("THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead.");return new Z(a,c)};b.Uint16BufferAttribute=Z;b.Uint32Attribute=
function(a,c){console.warn("THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead.");return new ea(a,c)};b.Uint32BufferAttribute=ea;b.Uint8Attribute=function(a,c){console.warn("THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead.");return new X(a,c)};b.Uint8BufferAttribute=X;b.Uint8ClampedAttribute=function(a,c){console.warn("THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead.");return new aa(a,
c)};b.Uint8ClampedBufferAttribute=aa;b.Uncharted2ToneMapping=3;b.Uniform=bh;b.UniformsLib=Wa;b.UniformsUtils=Fm;b.UnsignedByteType=1009;b.UnsignedInt248Type=1020;b.UnsignedIntType=1014;b.UnsignedShort4444Type=1017;b.UnsignedShort5551Type=1018;b.UnsignedShort565Type=1019;b.UnsignedShortType=1012;b.VSMShadowMap=3;b.Vector2=f;b.Vector3=k;b.Vector4=p;b.VectorKeyframeTrack=Te;b.Vertex=function(a,c,e){console.warn("THREE.Vertex has been removed. Use THREE.Vector3 instead.");return new k(a,c,e)};b.VertexColors=
2;b.VertexNormalsHelper=dg;b.VideoTexture=Xh;b.WebGLMultisampleRenderTarget=n;b.WebGLRenderTarget=m;b.WebGLRenderTargetCube=Nb;b.WebGLRenderer=Oh;b.WebGLUtils=wj;b.WireframeGeometry=Ee;b.WireframeHelper=function(a,c){console.warn("THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead.");return new Ib(new Ee(a.geometry),new Fb({color:void 0!==c?c:16777215}))};b.WrapAroundEnding=2402;b.XHRLoader=function(a){console.warn("THREE.XHRLoader has been renamed to THREE.FileLoader.");
return new uc(a)};b.ZeroCurvatureEnding=2400;b.ZeroFactor=200;b.ZeroSlopeEnding=2401;b.ZeroStencilOp=0;b.sRGBEncoding=3001;Object.defineProperty(b,"__esModule",{value:!0})});

//# sourceURL=build://tf-imports/OrbitControls.js
THREE.OrbitControls=function(b,d){function f(){return 2*Math.PI/60/60*Y.autoRotateSpeed}function h(){return Math.pow(.95,Y.zoomSpeed)}function k(sa){Xa.theta-=sa}function t(sa){Xa.phi-=sa}function l(sa){Y.object.isPerspectiveCamera?ub/=sa:Y.object.isOrthographicCamera?(Y.object.zoom=Math.max(Y.minZoom,Math.min(Y.maxZoom,Y.object.zoom*sa)),Y.object.updateProjectionMatrix(),qb=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),Y.enableZoom=!1)}function p(sa){Y.object.isPerspectiveCamera?
ub*=sa:Y.object.isOrthographicCamera?(Y.object.zoom=Math.max(Y.minZoom,Math.min(Y.maxZoom,Y.object.zoom/sa)),Y.object.updateProjectionMatrix(),qb=!0):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."),Y.enableZoom=!1)}function m(sa){zb.set(sa.clientX,sa.clientY)}function n(sa){ic.set(sa.clientX,sa.clientY)}function q(sa){Nb.set(sa.clientX,sa.clientY)}function u(sa){vb.set(sa.clientX,sa.clientY);Gb.subVectors(vb,zb).multiplyScalar(Y.rotateSpeed);sa=
Y.domElement===document?Y.domElement.body:Y.domElement;k(2*Math.PI*Gb.x/sa.clientHeight);t(2*Math.PI*Gb.y/sa.clientHeight);zb.copy(vb);Y.update()}function x(sa){bc.set(sa.clientX,sa.clientY);Od.subVectors(bc,ic);0<Od.y?l(h()):0>Od.y&&p(h());ic.copy(bc);Y.update()}function A(sa){Ab.set(sa.clientX,sa.clientY);Hb.subVectors(Ab,Nb).multiplyScalar(Y.panSpeed);sd(Hb.x,Hb.y);Nb.copy(Ab);Y.update()}function y(){}function w(sa){0>sa.deltaY?p(h()):0<sa.deltaY&&l(h());Y.update()}function C(sa){var Mb=!1;switch(sa.keyCode){case Y.keys.UP:sd(0,
Y.keyPanSpeed);Mb=!0;break;case Y.keys.BOTTOM:sd(0,-Y.keyPanSpeed);Mb=!0;break;case Y.keys.LEFT:sd(Y.keyPanSpeed,0);Mb=!0;break;case Y.keys.RIGHT:sd(-Y.keyPanSpeed,0),Mb=!0}Mb&&(sa.preventDefault(),Y.update())}function G(sa){1==sa.touches.length?zb.set(sa.touches[0].pageX,sa.touches[0].pageY):zb.set(.5*(sa.touches[0].pageX+sa.touches[1].pageX),.5*(sa.touches[0].pageY+sa.touches[1].pageY))}function D(sa){1==sa.touches.length?Nb.set(sa.touches[0].pageX,sa.touches[0].pageY):Nb.set(.5*(sa.touches[0].pageX+
sa.touches[1].pageX),.5*(sa.touches[0].pageY+sa.touches[1].pageY))}function B(sa){var Mb=sa.touches[0].pageX-sa.touches[1].pageX;sa=sa.touches[0].pageY-sa.touches[1].pageY;ic.set(0,Math.sqrt(Mb*Mb+sa*sa))}function I(sa){Y.enableZoom&&B(sa);Y.enablePan&&D(sa)}function N(sa){Y.enableZoom&&B(sa);Y.enableRotate&&G(sa)}function O(sa){1==sa.touches.length?vb.set(sa.touches[0].pageX,sa.touches[0].pageY):vb.set(.5*(sa.touches[0].pageX+sa.touches[1].pageX),.5*(sa.touches[0].pageY+sa.touches[1].pageY));Gb.subVectors(vb,
zb).multiplyScalar(Y.rotateSpeed);sa=Y.domElement===document?Y.domElement.body:Y.domElement;k(2*Math.PI*Gb.x/sa.clientHeight);t(2*Math.PI*Gb.y/sa.clientHeight);zb.copy(vb)}function H(sa){1==sa.touches.length?Ab.set(sa.touches[0].pageX,sa.touches[0].pageY):Ab.set(.5*(sa.touches[0].pageX+sa.touches[1].pageX),.5*(sa.touches[0].pageY+sa.touches[1].pageY));Hb.subVectors(Ab,Nb).multiplyScalar(Y.panSpeed);sd(Hb.x,Hb.y);Nb.copy(Ab)}function K(sa){var Mb=sa.touches[0].pageX-sa.touches[1].pageX;sa=sa.touches[0].pageY-
sa.touches[1].pageY;bc.set(0,Math.sqrt(Mb*Mb+sa*sa));Od.set(0,Math.pow(bc.y/ic.y,Y.zoomSpeed));l(Od.y);ic.copy(bc)}function M(sa){Y.enableZoom&&K(sa);Y.enablePan&&H(sa)}function L(sa){Y.enableZoom&&K(sa);Y.enableRotate&&O(sa)}function Q(){}function T(sa){if(!1!==Y.enabled){sa.preventDefault();Y.domElement.focus?Y.domElement.focus():window.focus();switch(sa.button){case 0:switch(Y.mouseButtons.LEFT){case THREE.MOUSE.ROTATE:if(sa.ctrlKey||sa.metaKey||sa.shiftKey){if(!1===Y.enablePan)return;q(sa);Fa=
Aa.PAN}else{if(!1===Y.enableRotate)return;m(sa);Fa=Aa.ROTATE}break;case THREE.MOUSE.PAN:if(sa.ctrlKey||sa.metaKey||sa.shiftKey){if(!1===Y.enableRotate)return;m(sa);Fa=Aa.ROTATE}else{if(!1===Y.enablePan)return;q(sa);Fa=Aa.PAN}break;default:Fa=Aa.NONE}break;case 1:switch(Y.mouseButtons.MIDDLE){case THREE.MOUSE.DOLLY:if(!1===Y.enableZoom)return;n(sa);Fa=Aa.DOLLY;break;default:Fa=Aa.NONE}break;case 2:switch(Y.mouseButtons.RIGHT){case THREE.MOUSE.ROTATE:if(!1===Y.enableRotate)return;m(sa);Fa=Aa.ROTATE;
break;case THREE.MOUSE.PAN:if(!1===Y.enablePan)return;q(sa);Fa=Aa.PAN;break;default:Fa=Aa.NONE}}Fa!==Aa.NONE&&(document.addEventListener("mousemove",X,!1),document.addEventListener("mouseup",aa,!1),Y.dispatchEvent(va))}}function X(sa){if(!1!==Y.enabled)switch(sa.preventDefault(),Fa){case Aa.ROTATE:if(!1===Y.enableRotate)break;u(sa);break;case Aa.DOLLY:if(!1===Y.enableZoom)break;x(sa);break;case Aa.PAN:!1!==Y.enablePan&&A(sa)}}function aa(sa){!1!==Y.enabled&&(y(sa),document.removeEventListener("mousemove",
X,!1),document.removeEventListener("mouseup",aa,!1),Y.dispatchEvent(xa),Fa=Aa.NONE)}function la(sa){!1===Y.enabled||!1===Y.enableZoom||Fa!==Aa.NONE&&Fa!==Aa.ROTATE||(sa.preventDefault(),sa.stopPropagation(),Y.dispatchEvent(va),w(sa),Y.dispatchEvent(xa))}function Z(sa){!1!==Y.enabled&&!1!==Y.enableKeys&&!1!==Y.enablePan&&C(sa)}function ba(sa){if(!1!==Y.enabled){sa.preventDefault();switch(sa.touches.length){case 1:switch(Y.touches.ONE){case THREE.TOUCH.ROTATE:if(!1===Y.enableRotate)return;G(sa);Fa=
Aa.TOUCH_ROTATE;break;case THREE.TOUCH.PAN:if(!1===Y.enablePan)return;D(sa);Fa=Aa.TOUCH_PAN;break;default:Fa=Aa.NONE}break;case 2:switch(Y.touches.TWO){case THREE.TOUCH.DOLLY_PAN:if(!1===Y.enableZoom&&!1===Y.enablePan)return;I(sa);Fa=Aa.TOUCH_DOLLY_PAN;break;case THREE.TOUCH.DOLLY_ROTATE:if(!1===Y.enableZoom&&!1===Y.enableRotate)return;N(sa);Fa=Aa.TOUCH_DOLLY_ROTATE;break;default:Fa=Aa.NONE}break;default:Fa=Aa.NONE}Fa!==Aa.NONE&&Y.dispatchEvent(va)}}function ea(sa){if(!1!==Y.enabled)switch(sa.preventDefault(),
sa.stopPropagation(),Fa){case Aa.TOUCH_ROTATE:if(!1===Y.enableRotate)break;O(sa);Y.update();break;case Aa.TOUCH_PAN:if(!1===Y.enablePan)break;H(sa);Y.update();break;case Aa.TOUCH_DOLLY_PAN:if(!1===Y.enableZoom&&!1===Y.enablePan)break;M(sa);Y.update();break;case Aa.TOUCH_DOLLY_ROTATE:if(!1===Y.enableZoom&&!1===Y.enableRotate)break;L(sa);Y.update();break;default:Fa=Aa.NONE}}function ca(sa){!1!==Y.enabled&&(Q(sa),Y.dispatchEvent(xa),Fa=Aa.NONE)}function ka(sa){!1!==Y.enabled&&sa.preventDefault()}this.object=
b;this.domElement=void 0!==d?d:document;this.enabled=!0;this.target=new THREE.Vector3;this.minDistance=0;this.maxDistance=Infinity;this.minZoom=0;this.maxZoom=Infinity;this.minPolarAngle=0;this.maxPolarAngle=Math.PI;this.minAzimuthAngle=-Infinity;this.maxAzimuthAngle=Infinity;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=!1;this.keyPanSpeed=7;this.autoRotate=!1;this.autoRotateSpeed=
2;this.enableKeys=!0;this.keys={LEFT:37,UP:38,RIGHT:39,BOTTOM:40};this.mouseButtons={LEFT:THREE.MOUSE.ROTATE,MIDDLE:THREE.MOUSE.DOLLY,RIGHT:THREE.MOUSE.PAN};this.touches={ONE:THREE.TOUCH.ROTATE,TWO:THREE.TOUCH.DOLLY_PAN};this.target0=this.target.clone();this.position0=this.object.position.clone();this.zoom0=this.object.zoom;this.getPolarAngle=function(){return Sa.phi};this.getAzimuthalAngle=function(){return Sa.theta};this.saveState=function(){Y.target0.copy(Y.target);Y.position0.copy(Y.object.position);
Y.zoom0=Y.object.zoom};this.reset=function(){Y.target.copy(Y.target0);Y.object.position.copy(Y.position0);Y.object.zoom=Y.zoom0;Y.object.updateProjectionMatrix();Y.dispatchEvent(Ea);Y.update();Fa=Aa.NONE};this.update=function(){var sa=new THREE.Vector3,Mb=(new THREE.Quaternion).setFromUnitVectors(b.up,new THREE.Vector3(0,1,0)),wc=Mb.clone().inverse(),bd=new THREE.Vector3,td=new THREE.Quaternion;return function(){var tg=Y.object.position;sa.copy(tg).sub(Y.target);sa.applyQuaternion(Mb);Sa.setFromVector3(sa);
Y.autoRotate&&Fa===Aa.NONE&&k(f());Y.enableDamping?(Sa.theta+=Xa.theta*Y.dampingFactor,Sa.phi+=Xa.phi*Y.dampingFactor):(Sa.theta+=Xa.theta,Sa.phi+=Xa.phi);Sa.theta=Math.max(Y.minAzimuthAngle,Math.min(Y.maxAzimuthAngle,Sa.theta));Sa.phi=Math.max(Y.minPolarAngle,Math.min(Y.maxPolarAngle,Sa.phi));Sa.makeSafe();Sa.radius*=ub;Sa.radius=Math.max(Y.minDistance,Math.min(Y.maxDistance,Sa.radius));!0===Y.enableDamping?Y.target.addScaledVector(Bb,Y.dampingFactor):Y.target.add(Bb);sa.setFromSpherical(Sa);sa.applyQuaternion(wc);
tg.copy(Y.target).add(sa);Y.object.lookAt(Y.target);!0===Y.enableDamping?(Xa.theta*=1-Y.dampingFactor,Xa.phi*=1-Y.dampingFactor,Bb.multiplyScalar(1-Y.dampingFactor)):(Xa.set(0,0,0),Bb.set(0,0,0));ub=1;return qb||bd.distanceToSquared(Y.object.position)>ya||8*(1-td.dot(Y.object.quaternion))>ya?(Y.dispatchEvent(Ea),bd.copy(Y.object.position),td.copy(Y.object.quaternion),qb=!1,!0):!1}}();this.dispose=function(){Y.domElement.removeEventListener("contextmenu",ka,!1);Y.domElement.removeEventListener("mousedown",
T,!1);Y.domElement.removeEventListener("wheel",la,!1);Y.domElement.removeEventListener("touchstart",ba,!1);Y.domElement.removeEventListener("touchend",ca,!1);Y.domElement.removeEventListener("touchmove",ea,!1);document.removeEventListener("mousemove",X,!1);document.removeEventListener("mouseup",aa,!1);window.removeEventListener("keydown",Z,!1)};var Y=this,Ea={type:"change"},va={type:"start"},xa={type:"end"},Aa={NONE:-1,ROTATE:0,DOLLY:1,PAN:2,TOUCH_ROTATE:3,TOUCH_PAN:4,TOUCH_DOLLY_PAN:5,TOUCH_DOLLY_ROTATE:6},
Fa=Aa.NONE,ya=1E-6,Sa=new THREE.Spherical,Xa=new THREE.Spherical,ub=1,Bb=new THREE.Vector3,qb=!1,zb=new THREE.Vector2,vb=new THREE.Vector2,Gb=new THREE.Vector2,Nb=new THREE.Vector2,Ab=new THREE.Vector2,Hb=new THREE.Vector2,ic=new THREE.Vector2,bc=new THREE.Vector2,Od=new THREE.Vector2,rd=function(){var sa=new THREE.Vector3;return function(Mb,wc){sa.setFromMatrixColumn(wc,0);sa.multiplyScalar(-Mb);Bb.add(sa)}}(),Lc=function(){var sa=new THREE.Vector3;return function(Mb,wc){!0===Y.screenSpacePanning?
sa.setFromMatrixColumn(wc,1):(sa.setFromMatrixColumn(wc,0),sa.crossVectors(Y.object.up,sa));sa.multiplyScalar(Mb);Bb.add(sa)}}(),sd=function(){var sa=new THREE.Vector3;return function(Mb,wc){var bd=Y.domElement===document?Y.domElement.body:Y.domElement;if(Y.object.isPerspectiveCamera){sa.copy(Y.object.position).sub(Y.target);var td=sa.length();td*=Math.tan(Y.object.fov/2*Math.PI/180);rd(2*Mb*td/bd.clientHeight,Y.object.matrix);Lc(2*wc*td/bd.clientHeight,Y.object.matrix)}else Y.object.isOrthographicCamera?
(rd(Mb*(Y.object.right-Y.object.left)/Y.object.zoom/bd.clientWidth,Y.object.matrix),Lc(wc*(Y.object.top-Y.object.bottom)/Y.object.zoom/bd.clientHeight,Y.object.matrix)):(console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."),Y.enablePan=!1)}}();Y.domElement.addEventListener("contextmenu",ka,!1);Y.domElement.addEventListener("mousedown",T,!1);Y.domElement.addEventListener("wheel",la,!1);Y.domElement.addEventListener("touchstart",ba,!1);Y.domElement.addEventListener("touchend",
ca,!1);Y.domElement.addEventListener("touchmove",ea,!1);window.addEventListener("keydown",Z,!1);this.update()};THREE.OrbitControls.prototype=Object.create(THREE.EventDispatcher.prototype);THREE.OrbitControls.prototype.constructor=THREE.OrbitControls;THREE.MapControls=function(b,d){THREE.OrbitControls.call(this,b,d);this.mouseButtons.LEFT=THREE.MOUSE.PAN;this.mouseButtons.RIGHT=THREE.MOUSE.ROTATE;this.touches.ONE=THREE.TOUCH.PAN;this.touches.TWO=THREE.TOUCH.DOLLY_ROTATE};
THREE.MapControls.prototype=Object.create(THREE.EventDispatcher.prototype);THREE.MapControls.prototype.constructor=THREE.MapControls;

//# sourceURL=build://tf-imports/array-buffer-data-provider.js
var Lk;
(function(b){b.ErrorCodes={CANCELLED:1};const d={VERTEX:1,FACE:2,COLOR:3},f={VERTEX:"float32",FACE:"int32",COLOR:"uint8"};class h{constructor(k){this._requestManager=k;this._canceller=new vc.Canceller}reload(k,t,l){this._canceller.cancelAll();return this._fetchMetadata(k,t,l)}_fetchDataByStep(k,t,l,p,m,n){function q(u){let x=[];for(let A=0;A<u.length/3;A++){let y=[];for(let w=0;3>w;w++)y.push(u[3*A+w]);x.push(y)}return x}k=vc.getRouter().pluginRoute("mesh","/data",new URLSearchParams({tag:t,run:k,
content_type:l,sample:p,step:m}));t=this._canceller.cancellable(u=>{if(u.cancelled)return Promise.reject({code:b.ErrorCodes.CANCELLED,message:"Response was invalidated."});u=u.value;switch(l){case "VERTEX":n.vertices=q(new Float32Array(u));break;case "FACE":n.faces=q(new Int32Array(u));break;case "COLOR":n.colors=q(new Uint8Array(u))}return n});return this._requestManager.fetch(k,null,"arraybuffer",f[l]).then(u=>u.arrayBuffer()).then(t)}fetchData(k,t,l,p){let m=[],n=new Map;Object.keys(d).forEach(q=>
{k.components&1<<d[q]&&m.push(this._fetchDataByStep(t,l,q,p,k.step,n))});return Promise.all(m)}_fetchMetadata(k,t,l){this._canceller.cancelAll();k=vc.getRouter().pluginRoute("mesh","/meshes",new URLSearchParams({tag:t,run:k,sample:l}));t=this._canceller.cancellable(p=>p.cancelled?Promise.reject({code:b.ErrorCodes.CANCELLED,message:"Response was invalidated."}):p.value);return this._requestManager.fetch(k).then(p=>p.json()).then(t).then(this._processMetadata.bind(this))}_processMetadata(k){if(k){var t=
new Map;for(let p=0;p<k.length;p++){let m=k[p];t.has(m.step)||t.set(m.step,[]);t.get(m.step).push(m)}var l=[];t.forEach(p=>{p=this._createStepDatum(p[0]);l.push(p)});return l}}_createStepDatum(k){return{wall_time:new Date(1E3*k.wall_time),step:k.step,config:k.config,content_type:k.content_type,components:k.components}}}b.ArrayBufferDataProvider=h})(Lk||(Lk={}));

//# sourceURL=build://tf-imports/mesh-viewer.js
(function(b){class d extends THREE.EventDispatcher{constructor(f){super();this._lastMesh=null;this._clock=new THREE.Clock;this._canvasSize=null;this._runColor=f}_isObject(f){return"object"==typeof f&&null!=f&&!Array.isArray(f)}_applyDefaults(f,h){let k={};f=[f,h];for(h=0;h<f.length;h++){const t=f[h];for(let l in t){const p=l in k;this._isObject(t[l])?k[l]=this._applyDefaults(k[l]||{},t[l]):p||(k[l]=t[l])}}return k}_createWorld(f,h){this.isReady()||(this._scene=new THREE.Scene,this._camera=f=new THREE[f.camera.cls](f.camera.fov,
this._canvasSize.width/this._canvasSize.height,f.camera.near,f.camera.far),h=new THREE.OrbitControls(f,h),h.lookSpeed=.4,h.movementSpeed=20,h.noFly=!0,h.lookVertical=!0,h.constrainVertical=!0,h.verticalMin=1,h.verticalMax=2,h.addEventListener("change",this._onCameraPositionChange.bind(this)),this._cameraControls=h,this._renderer=new THREE.WebGLRenderer({antialias:!0}),this._renderer.setPixelRatio(),this._renderer.setSize(this._canvasSize.width,this._canvasSize.height),this._renderer.setClearColor(16777215,
1))}_clearScene(){for(;0<this._scene.children.length;)this._scene.remove(this._scene.children[0])}getRenderer(){return this._renderer}getCameraControls(){return this._cameraControls}isReady(){return!!this._camera&&!!this._cameraControls}getCameraPosition(){return{far:this._camera.far,position:this._camera.position.clone(),target:this._cameraControls.target.clone()}}setCanvasSize(f){this._canvasSize=f}draw(){this._animationFrameIndex&&cancelAnimationFrame(this._animationFrameIndex);this._camera.aspect=
this._canvasSize.width/this._canvasSize.height;this._camera.updateProjectionMatrix();this._renderer.setSize(this._canvasSize.width,this._canvasSize.height);const f=function(){var h=this._clock.getDelta();this._cameraControls.update(h);this._animationFrameIndex=requestAnimationFrame(f);this._renderer.render(this._scene,this._camera)}.bind(this);f()}updateScene(f,h){let k={};"config"in f&&f.config&&(k=JSON.parse(f.config));this.dispatchEvent({type:"beforeUpdateScene"});k=this._applyDefaults(k,{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]}]});this._createWorld(k,h);this._clearScene();this._createLights(this._scene,k);this._createGeometry(f,k);this.draw()}resetView(){if(this.isReady()){this._cameraControls.reset();if(!f&&this._lastMesh)var f=this._lastMesh;f&&(this._fitObjectToViewport(f),this._lastMesh=f);this._cameraControls.update()}}_createGeometry(f,h){f=f.mesh;f.vertices&&f.faces&&
f.faces.length?this._createMesh(f,h):this._createPointCloud(f,h)}_createPointCloud(f,h){var k=f.vertices;f=f.colors;let t={material:{cls:"PointsMaterial",size:.005}};f&&f.length==k.length?t.material.vertexColors=THREE.VertexColors:t.material.color=this._runColor;h=this._applyDefaults(h,t);var l=new THREE.Geometry;k.forEach(function(p){var m=new THREE.Vector3(p[0],p[1],p[2]);m.x=1*p[0];m.y=1*p[1];m.z=1*p[2];l.vertices.push(m)});f&&f.length==k.length&&f.forEach(function(p){p=new THREE.Color(p[0]/255,
p[1]/255,p[2]/255);l.colors.push(p)});k=new THREE[h.material.cls](h.material);k=new THREE.Points(l,k);this._scene.add(k);this._lastMesh=k}setCameraViewpoint(f,h,k){this._silent=!0;this._camera.far=h;this._camera.position.set(f.x,f.y,f.z);this._camera.lookAt(k.clone());this._camera.updateProjectionMatrix();this._cameraControls.target=k.clone();this._cameraControls.update();this._silent=!1}_onCameraPositionChange(f){this._silent||this.dispatchEvent({type:"cameraPositionChange",event:f})}_fitObjectToViewport(f){var h=
new THREE.Box3;h.setFromObject(f);f=h.center();var k=h.size();k=1.25*Math.abs(Math.max(k.x,k.y,k.z)/(2*Math.tan(Math.PI/180*this._camera.fov/2)));h=h.min.z;this.setCameraViewpoint({x:f.x,y:f.y,z:k},3*(0>h?-h+k:k-h),f)}_createMesh(f,h){var k=f.vertices;const t=f.faces,l=f.colors;f=this._applyDefaults(h,{material:{cls:"MeshStandardMaterial",color:"#a0a0a0",roughness:1,metalness:0}});let p=new THREE.Geometry;k.forEach(function(m){let n=new THREE.Vector3(m[0],m[1],m[2]);n.x=1*m[0];n.y=1*m[1];n.z=1*m[2];
p.vertices.push(n)});t.forEach(function(m){let n=new THREE.Face3(m[0],m[1],m[2]);if(l&&l.length){m=[l[m[0]],l[m[1]],l[m[2]]];for(let u=0;u<m.length;u++){var q=m[u];q=new THREE.Color(q[0]/255,q[1]/255,q[2]/255);n.vertexColors.push(q)}}p.faces.push(n)});l&&l.length&&(f.material=f.material||{},f.material.vertexColors=THREE.VertexColors);p.center();p.computeBoundingSphere();p.computeVertexNormals();k=new THREE[f.material.cls](f.material);k=new THREE.Mesh(p,k);k.castShadow=!0;k.receiveShadow=!0;this._scene.add(k);
this._lastMesh=k}_createLights(f,h){for(let k=0;k<h.lights.length;k++){const t=h.lights[k];let l=new THREE[t.cls](t.color,t.intensity);t.position&&l.position.set(t.position[0],t.position[1],t.position[2]);f.add(l)}}}b.MeshViewer=d})(Lk||(Lk={}));

//# sourceURL=build://tf-mesh-dashboard/mesh-loader.js
(function(b){Polymer({is:"tf-mesh-loader",properties:{run:String,tag:String,sample:Number,ofSamples:Number,selectedView:{type:String,value:"all"},active:{type:Boolean,value:!1},requestManager:Object,_meshViewer:{type:Object},_dataProvider:{type:Object},_colorScaleFunction:{type:Object,value:()=>pf.runsColorScale},_runColor:{type:String,computed:"_computeRunColor(run)"},_steps:{type:Array,value:()=>[],notify:!0},_stepIndex:{type:Number,notify:!0},_currentStep:{type:Object,computed:"_computeCurrentStep(_steps, _stepIndex)"},
_meshViewerAttached:{type:Boolean,value:!1},_cameraPositionInitialized:{type:Boolean,value:!1},_stepValue:{type:Number,computed:"_computeStepValue(_currentStep)"},_currentWallTime:{type:String,computed:"_computeCurrentWallTime(_currentStep)"},_isMeshLoading:{type:Boolean,value:!1}},observers:["reload(run, tag, active, _dataProvider, _meshViewer)","_updateScene(_currentStep.*, _meshViewer)","_debouncedFetchMesh(_currentStep)","_updateView(selectedView)"],_computeRunColor:function(d){return this._colorScaleFunction(d)},
attached:function(){this._dataProvider=new b.ArrayBufferDataProvider(this.requestManager);const d=new b.MeshViewer(this._runColor);d.addEventListener("beforeUpdateScene",this._updateCanvasSize.bind(this));d.addEventListener("cameraPositionChange",this._onCameraPositionChange.bind(this));this._meshViewer=d},reload:function(){this.active&&this._dataProvider&&(this.set("_isMeshLoading",!0),this._dataProvider.reload(this.run,this.tag,this.sample).then(d=>{d&&(this.set("_steps",d),this.set("_stepIndex",
d.length-1))}).catch(d=>{if(!d||!d.code||d.code!=b.ErrorCodes.CANCELLED)throw Error(d||"Response processing failed.");}))},_updateScene:function(){const d=this._currentStep;d&&d.mesh&&(this._meshViewer.updateScene(d,this),this._cameraPositionInitialized||(this._meshViewer.resetView(),this._cameraPositionInitialized=!0),this._meshViewerAttached||(this.root.appendChild(this._meshViewer.getRenderer().domElement),this._meshViewerAttached=!0))},_debouncedFetchMesh(){this.debounce("fetchMesh",()=>this._maybeFetchMesh(),
100)},_maybeFetchMesh(){const d=this;return hc(function*(){const f=d._currentStep;if(f&&!f.mesh&&!f.meshFetching){f.meshFetching=!0;d._isMeshLoading=!0;try{const h=yield d._dataProvider.fetchData(f,d.run,d.tag,d.sample);f.mesh=h[0];d.notifyPath("_currentStep.mesh")}catch(h){if(!h||!h.code||h.code!=b.ErrorCodes.CANCELLED)throw h=h||"Response processing failed.",Error(h);}finally{d._isMeshLoading=!1,f.meshFetching=!1}}})},_onCameraPositionChange:function(){if(this._meshViewer.isReady()){var d=new CustomEvent("camera-position-change",
{detail:this._meshViewer.getCameraPosition()});this.dispatchEvent(d)}},setCameraViewpoint:function(d,f,h){this._meshViewer.setCameraViewpoint(d,f,h)},_updateCanvasSize:function(){const d=this.offsetWidth,f=this.$$(".tf-mesh-loader-header").offsetHeight;this._meshViewer.setCanvasSize({width:d,height:d-f})},redraw:function(){this._updateCanvasSize();this.isConnected&&this._meshViewer.draw()},_hasAtLeastOneStep:function(d){return!!d&&0<d.length},_hasMultipleSteps:function(d){return!!d&&1<d.length},_computeCurrentStep:function(d,
f){return d[f]||null},_computeStepValue:function(d){return d?d.step:0},_computeCurrentWallTime:function(d){return d?Hh.formatDate(d.wall_time):""},_getMaxStepIndex:function(d){return d.length-1},_getSampleText:function(d){return String(d+1)},_hasMultipleSamples:function(d){return 1<d},_updateView:function(d){this._meshViewer&&"all"==d&&this._meshViewer.resetView()},toLocaleString_:function(d){return d.toLocaleString()}})})(Lk||(Lk={}));

//# sourceURL=build://tf-mesh-dashboard/tf-mesh-dashboard.html.js
(function(){Polymer({is:"mesh-dashboard",properties:{_selectedRuns:Array,_runToTagInfo:Object,_dataNotFound:Boolean,_tagFilter:{type:String,value:".*"},_selectedView:{type:String,notify:!0,value:"all"},_categories:{type:Array,computed:"_makeCategories(_runToTagInfo, _selectedRuns, _tagFilter)"},_requestManager:{type:Object,value:()=>new vc.RequestManager}},ready(){window.addEventListener("resize",()=>{this._handleWindowResize()},!1);this.reload()},_getAllChildren(){return this.root.querySelectorAll("tf-mesh-loader")},
_onCameraPositionChanged(b){"share"==this._selectedView&&this._getAllChildren().forEach(d=>{b.target!=d&&d.setCameraViewpoint(b.detail.position,b.detail.far,b.detail.target)})},_shouldOpen(b){return 2>=b},reload(){this._fetchTags().then(this._reloadMeshes.bind(this))},_handleWindowResize(){this._getAllChildren().forEach(b=>{b.redraw()})},_fetchTags(){const b=vc.getRouter().pluginRoute("mesh","/tags");return this._requestManager.request(b).then(d=>{if(!_.isEqual(d,this._runToTagInfo)){var f=_.mapValues(d,
h=>Object.keys(h));f=vc.getTags(f);this.set("_dataNotFound",0===f.length);this.set("_runToTagInfo",d)}})},_reloadMeshes(){this._getAllChildren().forEach(b=>{b.reload()})},_makeCategories(b,d,f){function h(t){const l=b[t.run][t.tag].samples;return _.range(l).map(p=>Object.assign({},t,{sample:p,ofSamples:l}))}const k=_.mapValues(b,t=>Object.keys(t));return $c.categorizeRunTagCombinations(k,d,f).map(t=>Object.assign({},t,{items:[].concat.apply([],t.items.map(h))}))}})})();

//# sourceURL=build://tf-plugin-util/message.js
Ui=this&&this.__awaiter||function(b,d,f,h){return new (f||(f=Promise))(function(k,t){function l(n){try{m(h.next(n))}catch(q){t(q)}}function p(n){try{m(h["throw"](n))}catch(q){t(q)}}function m(n){n.done?k(n.value):(new f(function(q){q(n.value)})).then(l,p)}m((h=h.apply(b,d||[])).next())})};var Mk;
(function(b){(function(d){(function(f){class h{constructor(k){this.port=k;this.id=0;this.responseWaits=new Map;this.listeners=new Map;this.port.addEventListener("message",t=>this.onMessage(t))}listen(k,t){this.listeners.set(k,t)}unlisten(k){this.listeners.delete(k)}onMessage(k){return Ui(this,void 0,void 0,function*(){var t=JSON.parse(k.data);const l=t.type,p=t.id,m=t.payload;var n=t.error;if(t.isReply){if(this.responseWaits.has(p)){var {resolve:q,reject:u}=this.responseWaits.get(p);this.responseWaits.delete(p);
n?u(Error(n)):q(m)}}else{n=t=null;if(this.listeners.has(l)){const x=this.listeners.get(l);try{t=yield x(m)}catch(A){n=A}}this.postMessage({["type"]:l,["id"]:p,["payload"]:t,["error"]:n,["isReply"]:!0})}})}postMessage(k){this.port.postMessage(JSON.stringify(k))}sendMessage(k){const t=this.id++;this.postMessage({type:"experimental.RunsChanged",id:t,payload:k,error:null,isReply:!1});return new Promise((l,p)=>{this.responseWaits.set(t,{resolve:l,reject:p})})}}f.IPC=h})(d.DO_NOT_USE_INTERNAL||(d.DO_NOT_USE_INTERNAL=
{}))})(b.lib||(b.lib={}))})(Mk||(Mk={}));

//# sourceURL=build://tf-plugin-util/plugin-host-ipc.js
(function(b){(function(d){function f(m,n){const q=new b.lib.DO_NOT_USE_INTERNAL.IPC(m);t.add(q);p.set(q,n);m.start();for(const [u,x]of l)m=h(x,q),q.listen(u,m)}function h(m,n){return q=>{var u=p.get(n);u=k.get(u)||null;return m(u,q)}}d.registerPluginIframe=function(m,n){k.set(m,{pluginName:n})};const k=new WeakMap,t=new Set,l=new Map,p=new Map;window.addEventListener("message",m=>{if("experimental.bootstrap"===m.data){var n=m.ports[0];n&&(m=m.source?m.source.frameElement:null)&&f(n,m)}});d.broadcast=
function(){var m=vc.runsStore.getRuns();for(var n of t)p.get(n).isConnected||(t.delete(n),p.delete(n));n=[...t].map(q=>q.sendMessage(m));return Promise.all(n)};d.listen=function(m,n){l.set(m,n);for(const q of t){const u=h(n,q);q.listen(m,u)}};d.unlisten=function(m){l.delete(m);for(const n of t)n.unlisten(m)}})(b.host||(b.host={}))})(Mk||(Mk={}));

//# sourceURL=build://tf-plugin-util/core-host-impl.js
Mk.host.listen("experimental.GetURLPluginData",b=>{if(b){b=`p.${b.pluginName}.`;var d={};for(let f in pd.urlDict)f.startsWith(b)&&(d[f.substring(b.length)]=pd.urlDict[f]);return d}});

//# sourceURL=build://tf-plugin-util/runs-host-impl.js
Mk.host.listen("experimental.GetRuns",()=>vc.runsStore.getRuns());vc.runsStore.addListener(()=>Mk.host.broadcast());

//# sourceURL=build://tf-tensorboard/autoReloadBehavior.js
(function(b){function d(){return(new URLSearchParams(window.location.search)).has("_DisableAutoReload")}b.AUTORELOAD_LOCALSTORAGE_KEY="TF.TensorBoard.autoReloadEnabled";b.AutoReloadBehavior={properties:{autoReloadEnabled:{type:Boolean,observer:"_autoReloadObserver",value:()=>{var f=window.localStorage.getItem(b.AUTORELOAD_LOCALSTORAGE_KEY);return"true"===f||null==f}},_autoReloadId:{type:Number},_missedAutoReload:{type:Boolean,value:!1},_boundHandleVisibilityChange:{type:Object},autoReloadIntervalSecs:{type:Number,
value:30}},attached:function(){this._boundHandleVisibilityChange=this._handleVisibilityChange.bind(this);document.addEventListener("visibilitychange",this._boundHandleVisibilityChange)},detached:function(){window.clearTimeout(this._autoReloadId);document.removeEventListener("visibilitychange",this._boundHandleVisibilityChange)},_autoReloadObserver:function(f){window.localStorage.setItem(b.AUTORELOAD_LOCALSTORAGE_KEY,f);f&&!d()?this._autoReloadId=window.setTimeout(()=>this._doAutoReload(),1E3*this.autoReloadIntervalSecs):
window.clearTimeout(this._autoReloadId)},_doAutoReload:function(){this._isDocumentVisible()?this._doReload():this._missedAutoReload=!0;this._autoReloadId=window.setTimeout(()=>this._doAutoReload(),1E3*this.autoReloadIntervalSecs)},_doReload:function(){if(null==this.reload)throw Error("AutoReloadBehavior requires a reload method");this.reload()},_handleVisibilityChange:function(){this._isDocumentVisible()&&this._missedAutoReload&&(this._missedAutoReload=!1,this._doReload())},_isDocumentVisible:function(){return"visible"===
document.visibilityState}}})(qf||(qf={}));

//# sourceURL=build://tf-tensorboard/tf-tensorboard.html.js
const Ym={getLocation(){return window.location}};
Polymer({is:"tf-tensorboard",behaviors:[qf.AutoReloadBehavior],properties:{brand:{type:String,value:"TensorBoard-X"},homePath:{type:String,value:""},_homePath:{type:String,computed:"_sanitizeHomePath(homePath)"},title:{type:String,observer:"_updateTitle"},router:{type:Object,observer:"_updateRouter"},demoDir:{type:String,value:null},useHash:{type:Boolean,value:!1},disabledDashboards:{type:String,value:""},_dashboardData:{type:Array,computed:"_computeDashboardData(_dashboardRegistry)"},_dashboardRegistry:{type:Object,
computed:"_computeDashboardRegistry(_pluginsListing)"},_pluginsListing:{type:Object,value:()=>({})},_activeDashboards:{type:Array,computed:"_computeActiveDashboard(_dashboardData, _pluginsListing)"},_activeDashboardsLoadState:{type:String,value:qf.ActiveDashboardsLoadState.NOT_LOADED},_activeDashboardsNotLoaded:{type:Boolean,computed:"_computeActiveDashboardsNotLoaded(_activeDashboardsLoadState)"},_activeDashboardsLoaded:{type:Boolean,computed:"_computeActiveDashboardsLoaded(_activeDashboardsLoadState)"},
_activeDashboardsFailedToLoad:{type:Boolean,computed:"_computeActiveDashboardsFailedToLoad(_activeDashboardsLoadState)"},_showNoDashboardsMessage:{type:Boolean,computed:"_computeShowNoDashboardsMessage(_activeDashboardsLoaded, _activeDashboards, _selectedDashboard)"},_showNoSuchDashboardMessage:{type:Boolean,computed:"_computeShowNoSuchDashboardMessage(_activeDashboardsLoaded, _dashboardRegistry, _selectedDashboard)"},_selectedDashboard:{type:String,value:pd.getString(pd.TAB)||null,observer:"_selectedDashboardChanged"},
_dashboardToMaybeRemove:String,_dashboardContainersStamped:{type:Object,value:()=>({})},_isReloadDisabled:{type:Boolean,value:!1},_lastReloadTime:{type:String,value:"not yet loaded"},_lastReloadTimeShort:{type:String,value:"Not yet loaded"},_dataLocation:{type:String,value:null},_requestManager:{type:Object,value:()=>new vc.RequestManager},_canceller:{type:Object,value:()=>new vc.Canceller},_refreshing:{type:Boolean,value:!1}},observers:["_updateSelectedDashboardFromActive(_selectedDashboard, _activeDashboards)",
"_ensureSelectedDashboardStamped(_dashboardRegistry, _dashboardContainersStamped, _activeDashboards, _selectedDashboard)"],_sanitizeHomePath(b){if(!b)return"";const d=Ym.getLocation(),f=new URL(b,d.href),h="http:"===f.protocol||"https:"===f.protocol,k=f.origin===d.origin;if(!h)throw new RangeError(`Expect 'homePath' to be of http: or https:. ${b}`);if(!k)throw new RangeError(`Expect 'homePath' be a path or have the same origin. ${b} vs. ${d.origin}`);return h&&k?f.toString():""},_activeDashboardsUpdated(){},
_isDashboardActive(b,d,f){return 0<=(b||"").split(",").indexOf(f.plugin)||!(d||[]).includes(f.plugin)?!1:!0},_isDashboardInactive(b,d,f){return 0<=(b||"").split(",").indexOf(f.plugin)?!1:(d||[]).includes(f.plugin)?!1:!0},_inactiveDashboardsExist(b,d,f){if(!f)return!1;const h=new Set;b.forEach(k=>{h.add(k.plugin)});(d||"").split(",").forEach(k=>{h.delete(k.plugin)});f.forEach(k=>{h.delete(k)});return 0<h.size},_getDashboardFromIndex(b,d){return b[d]},_selectedStatus(b,d){return b===d},_selectedDashboardChanged(b){b=
b||"";pd.setString(pd.TAB,b);let d=window.location.pathname;d+=d.endsWith("/")?b:"/"+b;ga("set","page",d);ga("send","pageview")},_updateSelectedDashboardFromActive(b,d){d&&null==b&&(b=d[0]||null,null!=b&&(pd.setString(pd.TAB,b,{useLocationReplace:!0}),this._selectedDashboard=b))},_updateSelectedDashboardFromHash(){const b=pd.getString(pd.TAB);this.set("_selectedDashboard",b||null)},_ensureSelectedDashboardStamped(b,d,f,h){if(f&&h&&d[h]&&(d=this._dashboardToMaybeRemove,this._dashboardToMaybeRemove=
h,d&&d!=h&&b[d].removeDom&&(d=this.$$(`.dashboard-container[data-dashboard=${d}]`),d.firstChild&&d.firstChild.remove()),d=this.$$(`.dashboard-container[data-dashboard=${h}]`))){b=b[h];if(0===d.children.length)switch(f=b.loadingMechanism,f.type){case "CUSTOM_ELEMENT":h=document.createElement(f.elementName);h.id="dashboard";d.appendChild(h);break;case "IFRAME":this._renderPluginIframe(d,h,f);break;default:console.warn("Invariant violation:",f)}this.set("_isReloadDisabled",b.disableReload)}},_renderPluginIframe(b,
d){const f=document.createElement("iframe");f.id="dashboard";Mk.host.registerPluginIframe(f,d);const h=new URL("data/plugin_entry.html",window.location.href);h.searchParams.set("name",d);f.setAttribute("src",h.toString());b.appendChild(f)},_selectedDashboardComponent(){return this.$$(`.dashboard-container[data-dashboard=${this._selectedDashboard}] #dashboard`)},ready(){ad.setUseHash(this.useHash);this._updateSelectedDashboardFromHash();window.addEventListener("hashchange",()=>{this._updateSelectedDashboardFromHash()},
!1);vc.environmentStore.addListener(()=>{this._dataLocation=vc.environmentStore.getDataLocation();const b=vc.environmentStore.getWindowTitle();b&&(window.document.title=b)});pd.migrateLegacyURLScheme();this._reloadData();this._lastReloadTime=(new Date).toString()},_computeActiveDashboard(){return this._dashboardData?this._dashboardData.map(b=>b.plugin).filter(b=>{b=this._pluginsListing[b];return"boolean"===typeof b?b:b&&b.enabled}):[]},_onTemplateChanged(){const b={};for(const d of this.root.querySelectorAll(".dashboard-container"))b[d.dataset.dashboard]=
!0;this._dashboardContainersStamped=b},_computeDashboardRegistry(b){const d={};for(const [h,k]of Object.entries(qf.dashboardRegistry))d[h]={plugin:k.plugin,loadingMechanism:{type:"CUSTOM_ELEMENT",elementName:k.elementName},tabName:k.tabName.toUpperCase(),disableReload:k.isReloadDisabled||!1,removeDom:k.removeDom||!1};if(null!=b)for(const [h,k]of Object.entries(b))if("boolean"!==typeof k){switch(k.loading_mechanism.type){case "NONE":null==d[h]&&console.warn("Plugin has no loading mechanism and no baked-in registry entry: %s",
h);continue;case "CUSTOM_ELEMENT":var f={type:"CUSTOM_ELEMENT",elementName:k.loading_mechanism.element_name};break;case "IFRAME":f={type:"IFRAME",modulePath:k.loading_mechanism.module_path};break;default:console.warn("Unknown loading mechanism for plugin %s: %s",h,k.loading_mechanism);continue}null==f&&console.error("Invariant violation: loadingMechanism is %s for %s",f,h);d[h]={plugin:h,loadingMechanism:f,tabName:k.tab_name.toUpperCase(),disableReload:k.disable_reload,removeDom:k.remove_dom}}f={};
for(const h of Object.keys(b))d[h]&&(f[h]=d[h]);Object.assign(f,d);return f},_computeDashboardData(b){return Object.values(b)},_fetchPluginsListing(){this._canceller.cancelAll();const b=this._canceller.cancellable(d=>{d.cancelled||(this._pluginsListing=d.value,this._activeDashboardsLoadState=qf.ActiveDashboardsLoadState.LOADED)});return this._requestManager.request(vc.getRouter().pluginsListing()).then(b,()=>{this._activeDashboardsLoadState===qf.ActiveDashboardsLoadState.NOT_LOADED?this._activeDashboardsLoadState=
qf.ActiveDashboardsLoadState.FAILED:console.warn("Failed to reload the set of active plugins; using old value.")})},_computeActiveDashboardsNotLoaded(b){return b===qf.ActiveDashboardsLoadState.NOT_LOADED},_computeActiveDashboardsLoaded(b){return b===qf.ActiveDashboardsLoadState.LOADED},_computeActiveDashboardsFailedToLoad(b){return b===qf.ActiveDashboardsLoadState.FAILED},_computeShowNoDashboardsMessage(b,d,f){return b&&0===d.length&&null==f},_computeShowNoSuchDashboardMessage(b,d,f){return b&&!!f&&
null==d[f]},_updateRouter(b){vc.setRouter(b)},_updateTitle(b){b&&this.set("brand",b)},reload(){this._isReloadDisabled||(this._reloadData().then(()=>{const b=this._selectedDashboardComponent();b&&b.reload&&b.reload()}),this._lastReloadTime=(new Date).toString())},_reloadData(){this._refreshing=!0;return Promise.all([this._fetchPluginsListing(),vc.environmentStore.refresh(),vc.runsStore.refresh(),vc.experimentsStore.refresh()]).then(()=>{this._lastReloadTimeShort=(new Date).toLocaleDateString(void 0,
{month:"long",day:"numeric",hour:"numeric",minute:"numeric",second:"numeric"})}).finally(()=>{this._refreshing=!1})},_getDataRefreshingClass(){return this._refreshing?"refreshing":""},openSettings(){this.$.settings.open();this.$.paginationLimitInput.value=ne.getLimit()},_paginationLimitValidate(b){b.target.validate()},_paginationLimitChanged(b){b=Number.parseInt(b.target.value,10);b===+b&&0<b&&ne.setLimit(b)}});
",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/javascript; charset=utf-8"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/environment": {
+ "data": "eyJkYXRhX2xvY2F0aW9uIjogInRiX2xvZ3MvIiwgIndpbmRvd190aXRsZSI6ICIifQ==",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "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/runs": {
+ "data": "WyJ0ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucy92ZXJzaW9uXzAiLCAidGVzdGluZ19mb3JfYWN0aXZhdGlvbnMvdmVyc2lvbl8xIiwgInRlc3RpbmdfZm9yX2FjdGl2YXRpb25zL3ZlcnNpb25fMiIsICJ0ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucy92ZXJzaW9uXzMiLCAidGVzdGluZ19mb3JfYWN0aXZhdGlvbnMvdmVyc2lvbl80Il0=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/experiments": {
+ "data": "W10=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/tags": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy&run=testing_for_activations%2Fversion_0": {
+ "data": "W1sxNTkwNDA1Njc1LjQ2NjEzMiwgNDI5LCAwLjk1ODQwMDAxMTA2MjYyMjFdXQ==",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy&run=testing_for_activations%2Fversion_3": {
+ "data": "W1sxNTkwNDA2MDQ0LjU1OTQyODcsIDQyOSwgMC45NTA2MDAwMjgwMzgwMjQ5XSwgWzE1OTA0MDYwNDUuMzg1MjQzMiwgNDMwLCAwLjgwNjgwMDAwNzgyMDEyOTRdLCBbMTU5MDQwNjA1OC44ODkwNDIsIDg1OSwgMC45NzExOTk5ODkzMTg4NDc3XSwgWzE1OTA0MDYwNTkuODAzNTQzOCwgODYwLCAwLjk0MTg5MDg5NTM2NjY2ODddLCBbMTU5MDQwNjA3My40Njk2NzgsIDEyODksIDAuOTgwNDAwMDI1ODQ0NTc0XSwgWzE1OTA0MDYwNzQuNDgzMDg5NCwgMTI5MCwgMC45NTgyMzYzMzY3MDgwNjg4XSwgWzE1OTA0MDYwODguMzYxMjkzNiwgMTcxOSwgMC45ODI4MDAwMDY4NjY0NTUxXSwgWzE1OTA0MDYwODkuMTQ4NTUxMiwgMTcyMCwgMC45NjUxNjM2NDgxMjg1MDk1XSwgWzE1OTA0MDYxMDIuODE1MDMxMywgMjE0OSwgMC45ODU4MDAwMjc4NDcyOV0sIFsxNTkwNDA2MTAzLjYyMzM0MDgsIDIxNTAsIDAuOTY4MTgxNzg4OTIxMzU2Ml0sIFsxNTkwNDA2MTE3LjM5MTg2NjcsIDI1NzksIDAuOTg1ODAwMDI3ODQ3MjldLCBbMTU5MDQwNjExOC4xNzAyMDEsIDI1ODAsIDAuOTcxNjM2MzU0OTIzMjQ4M10sIFsxNTkwNDA2MTMxLjc4MzI1MzQsIDMwMDksIDAuOTg2OTk5OTg4NTU1OTA4Ml0sIFsxNTkwNDA2MTMyLjU4MDY0MjIsIDMwMTAsIDAuOTc0MzA5MDg2Nzk5NjIxNl0sIFsxNTkwNDA2MTQ2LjQyNDQ2NTcsIDM0MzksIDAuOTg4MjAwMDA4ODY5MTcxMV0sIFsxNTkwNDA2MTQ3LjIwNTg4NSwgMzQ0MCwgMC45NzY4MDAwMjQ1MDk0Mjk5XSwgWzE1OTA0MDYxNjEuMDU1MjIzNSwgMzg2OSwgMC45ODkwMDAwMjI0MTEzNDY0XSwgWzE1OTA0MDYxNjEuODM5ODcwNywgMzg3MCwgMC45NzczMjcyODcxOTcxMTNdLCBbMTU5MDQwNjE3NS41ODcxOTIzLCA0Mjk5LCAwLjk4ODYwMDAxNTY0MDI1ODhdLCBbMTU5MDQwNjE3Ni41ODQ0MjM4LCA0MzAwLCAwLjk3ODcyNzI4MTA5MzU5NzRdXQ==",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Loss%2FVal&run=testing_for_activations%2Fversion_3": {
+ "data": "W1sxNTkwNDA2MDMwLjU3NjM4NDMsIDAsIDIuMzAyOTY4MDI1MjA3NTE5NV0sIFsxNTkwNDA2MDQ0LjU1ODQ4NjIsIDAsIDEuNzY1NTM0OTk2OTg2Mzg5Ml0sIFsxNTkwNDA2MDU4Ljg4ODE4NDgsIDEsIDEuNjUyNjM1OTMxOTY4Njg5XSwgWzE1OTA0MDYwNzMuNDY4ODA0OCwgMiwgMS42MDgyMDUwODAwMzIzNDg2XSwgWzE1OTA0MDYwODguMzYwNDI3NiwgMywgMS41NjkyMDM3MzQzOTc4ODgyXSwgWzE1OTA0MDYxMDIuODEzOTEzMywgNCwgMS41NTA2MjEwMzI3MTQ4NDM4XSwgWzE1OTA0MDYxMTcuMzkwODU2MywgNSwgMS41MzM2NTIxODYzOTM3Mzc4XSwgWzE1OTA0MDYxMzEuNzgyMzA4LCA2LCAxLjUxOTQzODAyODMzNTU3MTNdLCBbMTU5MDQwNjE0Ni40MjM2MjMzLCA3LCAxLjUxMTk5MTM4MTY0NTIwMjZdLCBbMTU5MDQwNjE2MS4wNTQxODc4LCA4LCAxLjUwNDI2MzA0MzQwMzYyNTVdLCBbMTU5MDQwNjE3NS41ODYzNDgsIDksIDEuNTAwMjQ3MDAxNjQ3OTQ5Ml1d",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy&run=testing_for_activations%2Fversion_1": {
+ "data": "W1sxNTkwNDA1NzM1LjkzMDMwNTIsIDQyOSwgMC45NTU2MDAwMjMyNjk2NTMzXV0=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy%2FVal&run=testing_for_activations%2Fversion_3": {
+ "data": "W1sxNTkwNDA2MDMwLjU3NjUwNCwgMCwgMC4xMjg5MDYyNV0sIFsxNTkwNDA2MDQ0LjU1ODYxNTIsIDAsIDAuOTUwNjAwMDI4MDM4MDI0OV0sIFsxNTkwNDA2MDU4Ljg4ODMwNjEsIDEsIDAuOTcxMTk5OTg5MzE4ODQ3N10sIFsxNTkwNDA2MDczLjQ2ODkxOSwgMiwgMC45ODA0MDAwMjU4NDQ1NzRdLCBbMTU5MDQwNjA4OC4zNjA1NTQ3LCAzLCAwLjk4MjgwMDAwNjg2NjQ1NTFdLCBbMTU5MDQwNjEwMi44MTQwNjksIDQsIDAuOTg1ODAwMDI3ODQ3MjldLCBbMTU5MDQwNjExNy4zOTA5ODgsIDUsIDAuOTg1ODAwMDI3ODQ3MjldLCBbMTU5MDQwNjEzMS43ODI0NDExLCA2LCAwLjk4Njk5OTk4ODU1NTkwODJdLCBbMTU5MDQwNjE0Ni40MjM3NCwgNywgMC45ODgyMDAwMDg4NjkxNzExXSwgWzE1OTA0MDYxNjEuMDU0MzE3LCA4LCAwLjk4OTAwMDAyMjQxMTM0NjRdLCBbMTU5MDQwNjE3NS41ODY0NjksIDksIDAuOTg4NjAwMDE1NjQwMjU4OF1d",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy&run=testing_for_activations%2Fversion_2": {
+ "data": "W1sxNTkwNDA1Nzg0Ljc2MzM2MTUsIDQyOSwgMC45NjExOTk5OTg4NTU1OTA4XV0=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy%2FTrain&run=testing_for_activations%2Fversion_3": {
+ "data": "W1sxNTkwNDA2MDQ1LjE5Mzk1LCAwLCAwLjgwNjgwMDAwNzgyMDEyOTRdLCBbMTU5MDQwNjA1OS42MTgxOTgsIDEsIDAuOTQxODkwODk1MzY2NjY4N10sIFsxNTkwNDA2MDc0LjI5NDM2NTQsIDIsIDAuOTU4MjM2MzM2NzA4MDY4OF0sIFsxNTkwNDA2MDg4Ljk3MTcyMzYsIDMsIDAuOTY1MTYzNjQ4MTI4NTA5NV0sIFsxNTkwNDA2MTAzLjQ0NTQ1MDUsIDQsIDAuOTY4MTgxNzg4OTIxMzU2Ml0sIFsxNTkwNDA2MTE3Ljk5MzAzNjMsIDUsIDAuOTcxNjM2MzU0OTIzMjQ4M10sIFsxNTkwNDA2MTMyLjM5NDM0MTIsIDYsIDAuOTc0MzA5MDg2Nzk5NjIxNl0sIFsxNTkwNDA2MTQ3LjAzMDAyODMsIDcsIDAuOTc2ODAwMDI0NTA5NDI5OV0sIFsxNTkwNDA2MTYxLjY1ODU2NDMsIDgsIDAuOTc3MzI3Mjg3MTk3MTEzXSwgWzE1OTA0MDYxNzYuMzk1NjExOCwgOSwgMC45Nzg3MjcyODEwOTM1OTc0XV0=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy%2FVal&run=testing_for_activations%2Fversion_0": {
+ "data": "W1sxNTkwNDA1NjYxLjY4Njc5MjQsIDAsIDAuMDU4NTkzNzVdLCBbMTU5MDQwNTY3NS40NjUxOTk1LCAwLCAwLjk1ODQwMDAxMTA2MjYyMjFdXQ==",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy%2FTrain&run=testing_for_activations%2Fversion_4": {
+ "data": "W1sxNTkwNDA4NzUzLjMyMTYxNzEsIDAsIDAuODEyMTQ1NDcxNTcyODc2XSwgWzE1OTA0MDg3NjcuNzQxMjA5NSwgMSwgMC45NDcyNTQ1Mzg1MzYwNzE4XSwgWzE1OTA0MDg3ODEuNjQzMjIyOCwgMiwgMC45NjExNjM2NDAwMjIyNzc4XSwgWzE1OTA0MDg3OTUuNjI3MTg2LCAzLCAwLjk2NzQzNjM3MzIzMzc5NTJdLCBbMTU5MDQwODgwOS42NTM3NTE2LCA0LCAwLjk3MjA3MjcyMDUyNzY0ODldLCBbMTU5MDQwODgyNC4xMTM2NzU2LCA1LCAwLjk3NDIxODE4OTcxNjMzOTFdLCBbMTU5MDQwODgzNy45MzI3NTY3LCA2LCAwLjk3NTU0NTQ2NTk0NjE5NzVdLCBbMTU5MDQwODg1Mi4wNjc4OTIsIDcsIDAuOTc3NDE4MTg0MjgwMzk1NV0sIFsxNTkwNDA4ODY2LjE2OTczMjgsIDgsIDAuOTc4NTI3MjQ3OTA1NzMxMl0sIFsxNTkwNDA4ODgwLjQyNTI3NzcsIDksIDAuOTc5MTA5MTA4NDQ4MDI4Nl1d",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy&run=testing_for_activations%2Fversion_4": {
+ "data": "W1sxNTkwNDA4NzUyLjYzMjg2NzgsIDQyOSwgMC45NTk4MDAwMDQ5NTkxMDY0XSwgWzE1OTA0MDg3NTMuNDk2OTQ2NiwgNDMwLCAwLjgxMjE0NTQ3MTU3Mjg3Nl0sIFsxNTkwNDA4NzY3LjAxNjc1MDYsIDg1OSwgMC45NzYwMDAwMTA5NjcyNTQ2XSwgWzE1OTA0MDg3NjcuOTExOTgzMywgODYwLCAwLjk0NzI1NDUzODUzNjA3MThdLCBbMTU5MDQwODc4MS4wNDMyMjEyLCAxMjg5LCAwLjk4MDU5OTk5OTQyNzc5NTRdLCBbMTU5MDQwODc4MS44MjIxNTAyLCAxMjkwLCAwLjk2MTE2MzY0MDAyMjI3NzhdLCBbMTU5MDQwODc5NS4wNDM5MjkzLCAxNzE5LCAwLjk4MzIwMDAxMzYzNzU0MjddLCBbMTU5MDQwODc5NS43OTgyMzY4LCAxNzIwLCAwLjk2NzQzNjM3MzIzMzc5NTJdLCBbMTU5MDQwODgwOS4wMDc0OTA0LCAyMTQ5LCAwLjk4NDc5OTk4MTExNzI0ODVdLCBbMTU5MDQwODgwOS44MzE2OTc3LCAyMTUwLCAwLjk3MjA3MjcyMDUyNzY0ODldLCBbMTU5MDQwODgyMy4zMTUyNDc4LCAyNTc5LCAwLjk4NjE5OTk3NTAxMzczMjldLCBbMTU5MDQwODgyNC4yODkxNzU3LCAyNTgwLCAwLjk3NDIxODE4OTcxNjMzOTFdLCBbMTU5MDQwODgzNy4zMTc0Mjg4LCAzMDA5LCAwLjk4NzM5OTk5NTMyNjk5NThdLCBbMTU5MDQwODgzOC4xMTAzNzE0LCAzMDEwLCAwLjk3NTU0NTQ2NTk0NjE5NzVdLCBbMTU5MDQwODg1MS40NTA0OTQ1LCAzNDM5LCAwLjk4ODM5OTk4MjQ1MjM5MjZdLCBbMTU5MDQwODg1Mi4yNTc3NTc3LCAzNDQwLCAwLjk3NzQxODE4NDI4MDM5NTVdLCBbMTU5MDQwODg2NS41NjQ3MDAxLCAzODY5LCAwLjk4Nzk5OTk3NTY4MTMwNDldLCBbMTU5MDQwODg2Ni4zNDE4MjU1LCAzODcwLCAwLjk3ODUyNzI0NzkwNTczMTJdLCBbMTU5MDQwODg3OS44Mzk3MjY3LCA0Mjk5LCAwLjk4ODc5OTk4OTIyMzQ4MDJdLCBbMTU5MDQwODg4MC42MTIwNTI0LCA0MzAwLCAwLjk3OTEwOTEwODQ0ODAyODZdXQ==",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Loss%2FVal&run=testing_for_activations%2Fversion_1": {
+ "data": "W1sxNTkwNDA1NzIyLjE1OTUyMywgMCwgMi4zMDM4Njk0ODU4NTUxMDI1XSwgWzE1OTA0MDU3MzUuOTI5NDI3NCwgMCwgMS43NTg4NTU0NjIwNzQyNzk4XV0=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy%2FVal&run=testing_for_activations%2Fversion_2": {
+ "data": "W1sxNTkwNDA1NzcwLjk4NDI5MjMsIDAsIDAuMTIxMDkzNzVdLCBbMTU5MDQwNTc4NC43NjI2MjQsIDAsIDAuOTYxMTk5OTk4ODU1NTkwOF1d",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy%2FVal&run=testing_for_activations%2Fversion_1": {
+ "data": "W1sxNTkwNDA1NzIyLjE1OTY0OTQsIDAsIDAuMDg5ODQzNzVdLCBbMTU5MDQwNTczNS45Mjk1NDUsIDAsIDAuOTU1NjAwMDIzMjY5NjUzM11d",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Accuracy%2FVal&run=testing_for_activations%2Fversion_4": {
+ "data": "W1sxNTkwNDA4NzM4LjgwNDgwODYsIDAsIDAuMTQwNjI1XSwgWzE1OTA0MDg3NTIuNjMxODIxOSwgMCwgMC45NTk4MDAwMDQ5NTkxMDY0XSwgWzE1OTA0MDg3NjcuMDE2MDgyNSwgMSwgMC45NzYwMDAwMTA5NjcyNTQ2XSwgWzE1OTA0MDg3ODEuMDQyMzM5NiwgMiwgMC45ODA1OTk5OTk0Mjc3OTU0XSwgWzE1OTA0MDg3OTUuMDQzMDU4LCAzLCAwLjk4MzIwMDAxMzYzNzU0MjddLCBbMTU5MDQwODgwOS4wMDY2OTksIDQsIDAuOTg0Nzk5OTgxMTE3MjQ4NV0sIFsxNTkwNDA4ODIzLjMxNDUwMjUsIDUsIDAuOTg2MTk5OTc1MDEzNzMyOV0sIFsxNTkwNDA4ODM3LjMxNjY1NywgNiwgMC45ODczOTk5OTUzMjY5OTU4XSwgWzE1OTA0MDg4NTEuNDQ5NzUxOSwgNywgMC45ODgzOTk5ODI0NTIzOTI2XSwgWzE1OTA0MDg4NjUuNTY0MDA1LCA4LCAwLjk4Nzk5OTk3NTY4MTMwNDldLCBbMTU5MDQwODg3OS44Mzg4MDc4LCA5LCAwLjk4ODc5OTk4OTIyMzQ4MDJdXQ==",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Loss%2FVal&run=testing_for_activations%2Fversion_0": {
+ "data": "W1sxNTkwNDA1NjYxLjY4NjY0NzQsIDAsIDIuMzAzNTcwNzQ3Mzc1NDg4M10sIFsxNTkwNDA1Njc1LjQ2NTA3NjQsIDAsIDEuNzQ1NDE4MTkwOTU2MTE1N11d",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Loss%2FVal&run=testing_for_activations%2Fversion_2": {
+ "data": "W1sxNTkwNDA1NzcwLjk4NDAzNjIsIDAsIDIuMzAyNTc2MDY1MDYzNDc2Nl0sIFsxNTkwNDA1Nzg0Ljc2MjQ5NzQsIDAsIDEuNzUzMDg3ODc4MjI3MjMzOV1d",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Loss%2FVal&run=testing_for_activations%2Fversion_4": {
+ "data": "W1sxNTkwNDA4NzM4LjgwNDY4NjUsIDAsIDIuMzAyNTE1OTgzNTgxNTQzXSwgWzE1OTA0MDg3NTIuNjMxNjY4OCwgMCwgMS43NDA3ODU5NTYzODI3NTE1XSwgWzE1OTA0MDg3NjcuMDE1OTM0NywgMSwgMS42NDMyMTA0MTEwNzE3NzczXSwgWzE1OTA0MDg3ODEuMDQyMjE4NCwgMiwgMS41ODgxMzIwMjM4MTEzNDAzXSwgWzE1OTA0MDg3OTUuMDQyODk1OCwgMywgMS41NjE2ODIzNDM0ODI5NzEyXSwgWzE1OTA0MDg4MDkuMDA2NTY1MywgNCwgMS41MzQ5MTA5MTcyODIxMDQ1XSwgWzE1OTA0MDg4MjMuMzE0Mzc4NywgNSwgMS41MjQ1OTg5NTYxMDgwOTMzXSwgWzE1OTA0MDg4MzcuMzE2NTE4NSwgNiwgMS41MTUxNjQ3MzI5MzMwNDQ0XSwgWzE1OTA0MDg4NTEuNDQ5NjIyLCA3LCAxLjUwNzM0MDMxMjAwNDA4OTRdLCBbMTU5MDQwODg2NS41NjM4Mjg1LCA4LCAxLjUwMDExMTIyMjI2NzE1MDldLCBbMTU5MDQwODg3OS44Mzg2NzQ4LCA5LCAxLjQ5NTQxNzgzMzMyODI0N11d",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/scalars/scalars?tag=Loss%2FTrain&run=testing_for_activations%2Fversion_3": {
+ "data": "W1sxNTkwNDA2MDQ1LjE5Mzc5MTYsIDAsIDEuODk1MzUyODQwNDIzNTg0XSwgWzE1OTA0MDYwNTkuNjE4MTE3NiwgMSwgMS43MTEzNDU0MzQxODg4NDI4XSwgWzE1OTA0MDYwNzQuMjk0MjMxNCwgMiwgMS42NDQ2MzI1Nzc4OTYxMTgyXSwgWzE1OTA0MDYwODguOTcxNTk5LCAzLCAxLjYwNTA3NzUwNTExMTY5NDNdLCBbMTU5MDQwNjEwMy40NDUzMzEsIDQsIDEuNTc4Nzk5ODQzNzg4MTQ3XSwgWzE1OTA0MDYxMTcuOTkyODg5NiwgNSwgMS41NjA2MTI5MTY5NDY0MTExXSwgWzE1OTA0MDYxMzIuMzk0MjI5LCA2LCAxLjU0NjI3ODk1MzU1MjI0Nl0sIFsxNTkwNDA2MTQ3LjAyOTkxMiwgNywgMS41MzU2MjIxMTk5MDM1NjQ1XSwgWzE1OTA0MDYxNjEuNjU4NDU3LCA4LCAxLjUyNzg4MDMxMTAxMjI2OF0sIFsxNTkwNDA2MTc2LjM5NTQ4NTQsIDksIDEuNTIwOTEwMzgyMjcwODEzXV0=",
+ "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/data/plugin/scalars/scalars?tag=Loss%2FTrain&run=testing_for_activations%2Fversion_4": {
+ "data": "W1sxNTkwNDA4NzUzLjMyMTUxMTcsIDAsIDEuODkwMjA1MDI1NjcyOTEyNl0sIFsxNTkwNDA4NzY3Ljc0MTEzMywgMSwgMS43MDMxNDUxNDYzNjk5MzRdLCBbMTU5MDQwODc4MS42NDMxMTU4LCAyLCAxLjYzOTc1OTE4MjkyOTk5MjddLCBbMTU5MDQwODc5NS42MjcwNzc4LCAzLCAxLjYwMDcwODI0NjIzMTA3OV0sIFsxNTkwNDA4ODA5LjY1MzY0MTUsIDQsIDEuNTc1MDczMjQyMTg3NV0sIFsxNTkwNDA4ODI0LjExMzUzOCwgNSwgMS41NTczMjE0MjkyNTI2MjQ1XSwgWzE1OTA0MDg4MzcuOTMyNjcyMywgNiwgMS41NDM0ODE1ODgzNjM2NDc1XSwgWzE1OTA0MDg4NTIuMDY3NzgyNiwgNywgMS41MzMzNzg3MjAyODM1MDgzXSwgWzE1OTA0MDg4NjYuMTY5NjA3NCwgOCwgMS41MjU1NDQ2NDM0MDIwOTk2XSwgWzE1OTA0MDg4ODAuNDI1MTgyOCwgOSwgMS41MTk1NTE5OTI0MTYzODE4XV0=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/tags": {
+ "data": "eyJ0ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucy92ZXJzaW9uXzIiOiB7fSwgInRlc3RpbmdfZm9yX2FjdGl2YXRpb25zL3ZlcnNpb25fMCI6IHt9LCAidGVzdGluZ19mb3JfYWN0aXZhdGlvbnMvdmVyc2lvbl8xIjoge30sICJ0ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucy92ZXJzaW9uXzMiOiB7ImxheWVyIDEiOiB7ImRpc3BsYXlOYW1lIjogImxheWVyIDEiLCAiZGVzY3JpcHRpb24iOiAiIiwgInNhbXBsZXMiOiAxfSwgImxheWVyIDIiOiB7ImRpc3BsYXlOYW1lIjogImxheWVyIDIiLCAiZGVzY3JpcHRpb24iOiAiIiwgInNhbXBsZXMiOiAxfSwgImxheWVyIDMiOiB7ImRpc3BsYXlOYW1lIjogImxheWVyIDMiLCAiZGVzY3JpcHRpb24iOiAiIiwgInNhbXBsZXMiOiAxfX0sICJ0ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucy92ZXJzaW9uXzQiOiB7ImlucHV0IjogeyJkaXNwbGF5TmFtZSI6ICJpbnB1dCIsICJkZXNjcmlwdGlvbiI6ICIiLCAic2FtcGxlcyI6IDF9LCAibGF5ZXIgMSI6IHsiZGlzcGxheU5hbWUiOiAibGF5ZXIgMSIsICJkZXNjcmlwdGlvbiI6ICIiLCAic2FtcGxlcyI6IDF9LCAibGF5ZXIgMiI6IHsiZGlzcGxheU5hbWUiOiAibGF5ZXIgMiIsICJkZXNjcmlwdGlvbiI6ICIiLCAic2FtcGxlcyI6IDF9LCAibGF5ZXIgMyI6IHsiZGlzcGxheU5hbWUiOiAibGF5ZXIgMyIsICJkZXNjcmlwdGlvbiI6ICIiLCAic2FtcGxlcyI6IDF9fX0=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/images?run=testing_for_activations%2Fversion_3&sample=0&tag=layer%201": {
+ "data": "W3sid2FsbF90aW1lIjogMTU5MDQwNjA0NC44NzM4OTc4LCAic3RlcCI6IDAsICJxdWVyeSI6ICJydW49dGVzdGluZ19mb3JfYWN0aXZhdGlvbnMlMkZ2ZXJzaW9uXzMmdGFnPWxheWVyKzEmc2FtcGxlPTAmaW5kZXg9MCJ9LCB7IndhbGxfdGltZSI6IDE1OTA0MDYwNTkuMTc1MTc4OCwgInN0ZXAiOiAxLCAicXVlcnkiOiAicnVuPXRlc3RpbmdfZm9yX2FjdGl2YXRpb25zJTJGdmVyc2lvbl8zJnRhZz1sYXllcisxJnNhbXBsZT0wJmluZGV4PTEifSwgeyJ3YWxsX3RpbWUiOiAxNTkwNDA2MDczLjc1NTA1ODgsICJzdGVwIjogMiwgInF1ZXJ5IjogInJ1bj10ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucyUyRnZlcnNpb25fMyZ0YWc9bGF5ZXIrMSZzYW1wbGU9MCZpbmRleD0yIn0sIHsid2FsbF90aW1lIjogMTU5MDQwNjA4OC42NDYyNzgsICJzdGVwIjogMywgInF1ZXJ5IjogInJ1bj10ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucyUyRnZlcnNpb25fMyZ0YWc9bGF5ZXIrMSZzYW1wbGU9MCZpbmRleD0zIn0sIHsid2FsbF90aW1lIjogMTU5MDQwNjEwMy4xMDA3MjA0LCAic3RlcCI6IDQsICJxdWVyeSI6ICJydW49dGVzdGluZ19mb3JfYWN0aXZhdGlvbnMlMkZ2ZXJzaW9uXzMmdGFnPWxheWVyKzEmc2FtcGxlPTAmaW5kZXg9NCJ9LCB7IndhbGxfdGltZSI6IDE1OTA0MDYxMTcuNjcyMDUyNiwgInN0ZXAiOiA1LCAicXVlcnkiOiAicnVuPXRlc3RpbmdfZm9yX2FjdGl2YXRpb25zJTJGdmVyc2lvbl8zJnRhZz1sYXllcisxJnNhbXBsZT0wJmluZGV4PTUifSwgeyJ3YWxsX3RpbWUiOiAxNTkwNDA2MTMyLjA3MzE2MywgInN0ZXAiOiA2LCAicXVlcnkiOiAicnVuPXRlc3RpbmdfZm9yX2FjdGl2YXRpb25zJTJGdmVyc2lvbl8zJnRhZz1sYXllcisxJnNhbXBsZT0wJmluZGV4PTYifSwgeyJ3YWxsX3RpbWUiOiAxNTkwNDA2MTQ2LjY5ODAyMzgsICJzdGVwIjogNywgInF1ZXJ5IjogInJ1bj10ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucyUyRnZlcnNpb25fMyZ0YWc9bGF5ZXIrMSZzYW1wbGU9MCZpbmRleD03In0sIHsid2FsbF90aW1lIjogMTU5MDQwNjE2MS4zMzM3NTg0LCAic3RlcCI6IDgsICJxdWVyeSI6ICJydW49dGVzdGluZ19mb3JfYWN0aXZhdGlvbnMlMkZ2ZXJzaW9uXzMmdGFnPWxheWVyKzEmc2FtcGxlPTAmaW5kZXg9OCJ9LCB7IndhbGxfdGltZSI6IDE1OTA0MDYxNzUuODY5MTQ1LCAic3RlcCI6IDksICJxdWVyeSI6ICJydW49dGVzdGluZ19mb3JfYWN0aXZhdGlvbnMlMkZ2ZXJzaW9uXzMmdGFnPWxheWVyKzEmc2FtcGxlPTAmaW5kZXg9OSJ9XQ==",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/images?run=testing_for_activations%2Fversion_4&sample=0&tag=layer%201": {
+ "data": "W3sid2FsbF90aW1lIjogMTU5MDQwODc1Mi45NTc4MTA0LCAic3RlcCI6IDAsICJxdWVyeSI6ICJydW49dGVzdGluZ19mb3JfYWN0aXZhdGlvbnMlMkZ2ZXJzaW9uXzQmdGFnPWxheWVyKzEmc2FtcGxlPTAmaW5kZXg9MCJ9LCB7IndhbGxfdGltZSI6IDE1OTA0MDg3NjcuMjkxMTA5NiwgInN0ZXAiOiAxLCAicXVlcnkiOiAicnVuPXRlc3RpbmdfZm9yX2FjdGl2YXRpb25zJTJGdmVyc2lvbl80JnRhZz1sYXllcisxJnNhbXBsZT0wJmluZGV4PTEifSwgeyJ3YWxsX3RpbWUiOiAxNTkwNDA4NzgxLjMxNDM0ODUsICJzdGVwIjogMiwgInF1ZXJ5IjogInJ1bj10ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucyUyRnZlcnNpb25fNCZ0YWc9bGF5ZXIrMSZzYW1wbGU9MCZpbmRleD0yIn0sIHsid2FsbF90aW1lIjogMTU5MDQwODc5NS4zMTE3MzA5LCAic3RlcCI6IDMsICJxdWVyeSI6ICJydW49dGVzdGluZ19mb3JfYWN0aXZhdGlvbnMlMkZ2ZXJzaW9uXzQmdGFnPWxheWVyKzEmc2FtcGxlPTAmaW5kZXg9MyJ9LCB7IndhbGxfdGltZSI6IDE1OTA0MDg4MDkuMzE0ODQ0MSwgInN0ZXAiOiA0LCAicXVlcnkiOiAicnVuPXRlc3RpbmdfZm9yX2FjdGl2YXRpb25zJTJGdmVyc2lvbl80JnRhZz1sYXllcisxJnNhbXBsZT0wJmluZGV4PTQifSwgeyJ3YWxsX3RpbWUiOiAxNTkwNDA4ODIzLjc4MzIyODIsICJzdGVwIjogNSwgInF1ZXJ5IjogInJ1bj10ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucyUyRnZlcnNpb25fNCZ0YWc9bGF5ZXIrMSZzYW1wbGU9MCZpbmRleD01In0sIHsid2FsbF90aW1lIjogMTU5MDQwODg1MS43NDIzODMyLCAic3RlcCI6IDcsICJxdWVyeSI6ICJydW49dGVzdGluZ19mb3JfYWN0aXZhdGlvbnMlMkZ2ZXJzaW9uXzQmdGFnPWxheWVyKzEmc2FtcGxlPTAmaW5kZXg9NiJ9LCB7IndhbGxfdGltZSI6IDE1OTA0MDg4NjUuODM0NzEwNCwgInN0ZXAiOiA4LCAicXVlcnkiOiAicnVuPXRlc3RpbmdfZm9yX2FjdGl2YXRpb25zJTJGdmVyc2lvbl80JnRhZz1sYXllcisxJnNhbXBsZT0wJmluZGV4PTcifSwgeyJ3YWxsX3RpbWUiOiAxNTkwNDA4ODgwLjEwOTI3NDQsICJzdGVwIjogOSwgInF1ZXJ5IjogInJ1bj10ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucyUyRnZlcnNpb25fNCZ0YWc9bGF5ZXIrMSZzYW1wbGU9MCZpbmRleD04In0sIHsid2FsbF90aW1lIjogMTU5MDQwOTA0Mi45OTI0MTIzLCAic3RlcCI6IDksICJxdWVyeSI6ICJydW49dGVzdGluZ19mb3JfYWN0aXZhdGlvbnMlMkZ2ZXJzaW9uXzQmdGFnPWxheWVyKzEmc2FtcGxlPTAmaW5kZXg9OSJ9XQ==",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590406175.869145&run=testing_for_activations%2Fversion_3&tag=layer+1&sample=0&index=9": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/images?run=testing_for_activations%2Fversion_4&sample=0&tag=input": {
+ "data": "W3sid2FsbF90aW1lIjogMTU5MDQwODc1Mi42NjM4MTAzLCAic3RlcCI6IDAsICJxdWVyeSI6ICJydW49dGVzdGluZ19mb3JfYWN0aXZhdGlvbnMlMkZ2ZXJzaW9uXzQmdGFnPWlucHV0JnNhbXBsZT0wJmluZGV4PTAifSwgeyJ3YWxsX3RpbWUiOiAxNTkwNDA4NzY3LjA0NTg0NTUsICJzdGVwIjogMSwgInF1ZXJ5IjogInJ1bj10ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucyUyRnZlcnNpb25fNCZ0YWc9aW5wdXQmc2FtcGxlPTAmaW5kZXg9MSJ9LCB7IndhbGxfdGltZSI6IDE1OTA0MDg3ODEuMDcxMTQ5NiwgInN0ZXAiOiAyLCAicXVlcnkiOiAicnVuPXRlc3RpbmdfZm9yX2FjdGl2YXRpb25zJTJGdmVyc2lvbl80JnRhZz1pbnB1dCZzYW1wbGU9MCZpbmRleD0yIn0sIHsid2FsbF90aW1lIjogMTU5MDQwODc5NS4wNzM4NTE2LCAic3RlcCI6IDMsICJxdWVyeSI6ICJydW49dGVzdGluZ19mb3JfYWN0aXZhdGlvbnMlMkZ2ZXJzaW9uXzQmdGFnPWlucHV0JnNhbXBsZT0wJmluZGV4PTMifSwgeyJ3YWxsX3RpbWUiOiAxNTkwNDA4ODA5LjAzODM4NjMsICJzdGVwIjogNCwgInF1ZXJ5IjogInJ1bj10ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucyUyRnZlcnNpb25fNCZ0YWc9aW5wdXQmc2FtcGxlPTAmaW5kZXg9NCJ9LCB7IndhbGxfdGltZSI6IDE1OTA0MDg4MjMuMzQyMjUwNiwgInN0ZXAiOiA1LCAicXVlcnkiOiAicnVuPXRlc3RpbmdfZm9yX2FjdGl2YXRpb25zJTJGdmVyc2lvbl80JnRhZz1pbnB1dCZzYW1wbGU9MCZpbmRleD01In0sIHsid2FsbF90aW1lIjogMTU5MDQwODg1MS40NzkwMzQsICJzdGVwIjogNywgInF1ZXJ5IjogInJ1bj10ZXN0aW5nX2Zvcl9hY3RpdmF0aW9ucyUyRnZlcnNpb25fNCZ0YWc9aW5wdXQmc2FtcGxlPTAmaW5kZXg9NiJ9LCB7IndhbGxfdGltZSI6IDE1OTA0MDg4NjUuNTkwNjEwNywgInN0ZXAiOiA4LCAicXVlcnkiOiAicnVuPXRlc3RpbmdfZm9yX2FjdGl2YXRpb25zJTJGdmVyc2lvbl80JnRhZz1pbnB1dCZzYW1wbGU9MCZpbmRleD03In0sIHsid2FsbF90aW1lIjogMTU5MDQwODg3OS44NjcxODI1LCAic3RlcCI6IDksICJxdWVyeSI6ICJydW49dGVzdGluZ19mb3JfYWN0aXZhdGlvbnMlMkZ2ZXJzaW9uXzQmdGFnPWlucHV0JnNhbXBsZT0wJmluZGV4PTgifSwgeyJ3YWxsX3RpbWUiOiAxNTkwNDA5MDQyLjc0MTM0NSwgInN0ZXAiOiA5LCAicXVlcnkiOiAicnVuPXRlc3RpbmdfZm9yX2FjdGl2YXRpb25zJTJGdmVyc2lvbl80JnRhZz1pbnB1dCZzYW1wbGU9MCZpbmRleD05In1d",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "application/json"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408880.1092744&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=9": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408879.8671825&run=testing_for_activations%2Fversion_4&tag=input&sample=0&index=9": {
+ "data": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABlUlEQVR4nO2Uz6sBURTHv/MaYyHSUBQ1SSz8Awor+Rf8CbJgrKwo/wB/gQULRdnKxoIoC5m1tYWNBflZI907b3F702teaQyL1+t9FrfbuadP55zbvcA/f594PF6v11Op1Ht0mUym3W5TSgkhqqoqiuL3+63rIpFIpVI5Ho+EECZlzGYzPYd/ypjNZjudjs1m0yOKojQajUQicbvdni5QEIR+v69pGqWUUqqq6nA4TKfTT4u+U61W9X6n02kul3uQbLZ9h8MB4Hq9tlqtcrl8v99fqhGAy+UajUaEkFKpZCb/w0zS6XTa7XYA2PoeKYBut8txXCgUsiKNxWK1Wi0YDBriTqdT0zRRFM1IjRdVLBbz+bwsy71eb7/fz+fz5XJ5OBzsdjsAQRCsSD0eDwBRFAuFAgCO49br9Xa79fl8ALxerxXp+Xw2RCRJkiSJ7ZvNphmpkUAgMB6P6Rf6E2Ikk0krUgA8z8uy/PPLWCwWbLLWCYfDk8lks9kw42AwYGM1A/f42O12R6NRAKvV6nK5vFTmP7+OT0CY0ZIgB24RAAAAAElFTkSuQmCC",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408865.5906107&run=testing_for_activations%2Fversion_4&tag=input&sample=0&index=8": {
+ "data": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABlUlEQVR4nO2Uz6sBURTHv/MaYyHSUBQ1SSz8Awor+Rf8CbJgrKwo/wB/gQULRdnKxoIoC5m1tYWNBflZI907b3F702teaQyL1+t9FrfbuadP55zbvcA/f594PF6v11Op1Ht0mUym3W5TSgkhqqoqiuL3+63rIpFIpVI5Ho+EECZlzGYzPYd/ypjNZjudjs1m0yOKojQajUQicbvdni5QEIR+v69pGqWUUqqq6nA4TKfTT4u+U61W9X6n02kul3uQbLZ9h8MB4Hq9tlqtcrl8v99fqhGAy+UajUaEkFKpZCb/w0zS6XTa7XYA2PoeKYBut8txXCgUsiKNxWK1Wi0YDBriTqdT0zRRFM1IjRdVLBbz+bwsy71eb7/fz+fz5XJ5OBzsdjsAQRCsSD0eDwBRFAuFAgCO49br9Xa79fl8ALxerxXp+Xw2RCRJkiSJ7ZvNphmpkUAgMB6P6Rf6E2Ikk0krUgA8z8uy/PPLWCwWbLLWCYfDk8lks9kw42AwYGM1A/f42O12R6NRAKvV6nK5vFTmP7+OT0CY0ZIgB24RAAAAAElFTkSuQmCC",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408851.479034&run=testing_for_activations%2Fversion_4&tag=input&sample=0&index=7": {
+ "data": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABlUlEQVR4nO2Uz6sBURTHv/MaYyHSUBQ1SSz8Awor+Rf8CbJgrKwo/wB/gQULRdnKxoIoC5m1tYWNBflZI907b3F702teaQyL1+t9FrfbuadP55zbvcA/f594PF6v11Op1Ht0mUym3W5TSgkhqqoqiuL3+63rIpFIpVI5Ho+EECZlzGYzPYd/ypjNZjudjs1m0yOKojQajUQicbvdni5QEIR+v69pGqWUUqqq6nA4TKfTT4u+U61W9X6n02kul3uQbLZ9h8MB4Hq9tlqtcrl8v99fqhGAy+UajUaEkFKpZCb/w0zS6XTa7XYA2PoeKYBut8txXCgUsiKNxWK1Wi0YDBriTqdT0zRRFM1IjRdVLBbz+bwsy71eb7/fz+fz5XJ5OBzsdjsAQRCsSD0eDwBRFAuFAgCO49br9Xa79fl8ALxerxXp+Xw2RCRJkiSJ7ZvNphmpkUAgMB6P6Rf6E2Ikk0krUgA8z8uy/PPLWCwWbLLWCYfDk8lks9kw42AwYGM1A/f42O12R6NRAKvV6nK5vFTmP7+OT0CY0ZIgB24RAAAAAElFTkSuQmCC",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408823.3422506&run=testing_for_activations%2Fversion_4&tag=input&sample=0&index=5": {
+ "data": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABlUlEQVR4nO2Uz6sBURTHv/MaYyHSUBQ1SSz8Awor+Rf8CbJgrKwo/wB/gQULRdnKxoIoC5m1tYWNBflZI907b3F702teaQyL1+t9FrfbuadP55zbvcA/f594PF6v11Op1Ht0mUym3W5TSgkhqqoqiuL3+63rIpFIpVI5Ho+EECZlzGYzPYd/ypjNZjudjs1m0yOKojQajUQicbvdni5QEIR+v69pGqWUUqqq6nA4TKfTT4u+U61W9X6n02kul3uQbLZ9h8MB4Hq9tlqtcrl8v99fqhGAy+UajUaEkFKpZCb/w0zS6XTa7XYA2PoeKYBut8txXCgUsiKNxWK1Wi0YDBriTqdT0zRRFM1IjRdVLBbz+bwsy71eb7/fz+fz5XJ5OBzsdjsAQRCsSD0eDwBRFAuFAgCO49br9Xa79fl8ALxerxXp+Xw2RCRJkiSJ7ZvNphmpkUAgMB6P6Rf6E2Ikk0krUgA8z8uy/PPLWCwWbLLWCYfDk8lks9kw42AwYGM1A/f42O12R6NRAKvV6nK5vFTmP7+OT0CY0ZIgB24RAAAAAElFTkSuQmCC",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408837.3473294&run=testing_for_activations%2Fversion_4&tag=input&sample=0&index=6": {
+ "data": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABlUlEQVR4nO2Uz6sBURTHv/MaYyHSUBQ1SSz8Awor+Rf8CbJgrKwo/wB/gQULRdnKxoIoC5m1tYWNBflZI907b3F702teaQyL1+t9FrfbuadP55zbvcA/f594PF6v11Op1Ht0mUym3W5TSgkhqqoqiuL3+63rIpFIpVI5Ho+EECZlzGYzPYd/ypjNZjudjs1m0yOKojQajUQicbvdni5QEIR+v69pGqWUUqqq6nA4TKfTT4u+U61W9X6n02kul3uQbLZ9h8MB4Hq9tlqtcrl8v99fqhGAy+UajUaEkFKpZCb/w0zS6XTa7XYA2PoeKYBut8txXCgUsiKNxWK1Wi0YDBriTqdT0zRRFM1IjRdVLBbz+bwsy71eb7/fz+fz5XJ5OBzsdjsAQRCsSD0eDwBRFAuFAgCO49br9Xa79fl8ALxerxXp+Xw2RCRJkiSJ7ZvNphmpkUAgMB6P6Rf6E2Ikk0krUgA8z8uy/PPLWCwWbLLWCYfDk8lks9kw42AwYGM1A/f42O12R6NRAKvV6nK5vFTmP7+OT0CY0ZIgB24RAAAAAElFTkSuQmCC",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408795.0738516&run=testing_for_activations%2Fversion_4&tag=input&sample=0&index=3": {
+ "data": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABlUlEQVR4nO2Uz6sBURTHv/MaYyHSUBQ1SSz8Awor+Rf8CbJgrKwo/wB/gQULRdnKxoIoC5m1tYWNBflZI907b3F702teaQyL1+t9FrfbuadP55zbvcA/f594PF6v11Op1Ht0mUym3W5TSgkhqqoqiuL3+63rIpFIpVI5Ho+EECZlzGYzPYd/ypjNZjudjs1m0yOKojQajUQicbvdni5QEIR+v69pGqWUUqqq6nA4TKfTT4u+U61W9X6n02kul3uQbLZ9h8MB4Hq9tlqtcrl8v99fqhGAy+UajUaEkFKpZCb/w0zS6XTa7XYA2PoeKYBut8txXCgUsiKNxWK1Wi0YDBriTqdT0zRRFM1IjRdVLBbz+bwsy71eb7/fz+fz5XJ5OBzsdjsAQRCsSD0eDwBRFAuFAgCO49br9Xa79fl8ALxerxXp+Xw2RCRJkiSJ7ZvNphmpkUAgMB6P6Rf6E2Ikk0krUgA8z8uy/PPLWCwWbLLWCYfDk8lks9kw42AwYGM1A/f42O12R6NRAKvV6nK5vFTmP7+OT0CY0ZIgB24RAAAAAElFTkSuQmCC",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408809.0383863&run=testing_for_activations%2Fversion_4&tag=input&sample=0&index=4": {
+ "data": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABlUlEQVR4nO2Uz6sBURTHv/MaYyHSUBQ1SSz8Awor+Rf8CbJgrKwo/wB/gQULRdnKxoIoC5m1tYWNBflZI907b3F702teaQyL1+t9FrfbuadP55zbvcA/f594PF6v11Op1Ht0mUym3W5TSgkhqqoqiuL3+63rIpFIpVI5Ho+EECZlzGYzPYd/ypjNZjudjs1m0yOKojQajUQicbvdni5QEIR+v69pGqWUUqqq6nA4TKfTT4u+U61W9X6n02kul3uQbLZ9h8MB4Hq9tlqtcrl8v99fqhGAy+UajUaEkFKpZCb/w0zS6XTa7XYA2PoeKYBut8txXCgUsiKNxWK1Wi0YDBriTqdT0zRRFM1IjRdVLBbz+bwsy71eb7/fz+fz5XJ5OBzsdjsAQRCsSD0eDwBRFAuFAgCO49br9Xa79fl8ALxerxXp+Xw2RCRJkiSJ7ZvNphmpkUAgMB6P6Rf6E2Ikk0krUgA8z8uy/PPLWCwWbLLWCYfDk8lks9kw42AwYGM1A/f42O12R6NRAKvV6nK5vFTmP7+OT0CY0ZIgB24RAAAAAElFTkSuQmCC",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408781.0711496&run=testing_for_activations%2Fversion_4&tag=input&sample=0&index=2": {
+ "data": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAABlUlEQVR4nO2Uz6sBURTHv/MaYyHSUBQ1SSz8Awor+Rf8CbJgrKwo/wB/gQULRdnKxoIoC5m1tYWNBflZI907b3F702teaQyL1+t9FrfbuadP55zbvcA/f594PF6v11Op1Ht0mUym3W5TSgkhqqoqiuL3+63rIpFIpVI5Ho+EECZlzGYzPYd/ypjNZjudjs1m0yOKojQajUQicbvdni5QEIR+v69pGqWUUqqq6nA4TKfTT4u+U61W9X6n02kul3uQbLZ9h8MB4Hq9tlqtcrl8v99fqhGAy+UajUaEkFKpZCb/w0zS6XTa7XYA2PoeKYBut8txXCgUsiKNxWK1Wi0YDBriTqdT0zRRFM1IjRdVLBbz+bwsy71eb7/fz+fz5XJ5OBzsdjsAQRCsSD0eDwBRFAuFAgCO49br9Xa79fl8ALxerxXp+Xw2RCRJkiSJ7ZvNphmpkUAgMB6P6Rf6E2Ikk0krUgA8z8uy/PPLWCwWbLLWCYfDk8lks9kw42AwYGM1A/f42O12R6NRAKvV6nK5vFTmP7+OT0CY0ZIgB24RAAAAAElFTkSuQmCC",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408865.8347104&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=8": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408851.7423832&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=7": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408837.5963132&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=6": {
+ "data": "iVBORw0KGgoAAAANSUhEUgAAAHAAAAA4CAIAAACqiesdAAAJAklEQVR4nO2cXUhUzxvHn3X10Kpr2dZm2wtqebTSzNI0K61FWwuMs6USZWHRC0FaKqFCUawV9CIURvRmSdkLRFmI1N5YBBkJIhZR2FVdGHlR0oXREvi/mP+O45xz5szZPebvx8/PxTIz5zkzs9995vXMWYAJJvi34nQ6AaCrq8vYbOvr6y9cuMBvP336dB6zOXPmBFojVT59+qT3lhDGtY6ODgDo7u7eunVr4JXyY7PZHA5HTk7Oly9fnE7n9evXOW988OCB2qW4uDgUuHXr1o4dO1JTUxn5TJo0iae4xMREABBF8eDBgw6H4+TJk5z1ZDFv3jxd9pWVlU1NTc+fP8/KylKzEUUxJydn1apVKFpSUhJUFQG2bNkCAI2NjadOnQKAwsJChnFNTU1JScmKFSt4cnY4HPzVmD17Nr+xNoIglJeXc6pTXFy8fPlyA0uvra3NyMiIiopim+3Zs8fAQkkaGhqam5vHKHNtOH/5Fy9eLFiwQNOstLSUv2i2/5K0trayuw42I31oa2srDuO+KRgEQSA7oObm5qGhIZ4bh4aG5s+fr3gpKysLj1ExMTGJiYkmk4knz+/fv/OYAYDb7e7t7eU0ljMiqNvtvnv3LgBUV1f//Pkz4BwxPp8vNjYWRy0WS2hoqJrxiRMnmpqaACA3N/f379+TJ09WNLPb7dXV1SgsCEJSUtLw8LBanmTpr169YlS1s7Ozt7f348ePKLphwwaGscGcO3eO39jtdqNAcXGxsdXweDxsA8bwyCAiIgIA1Lw+PT1drekEhdfrBYCwsDDg6BxSUlKKiop0jemrV69mXE1OTgYOQQFg1qxZ/IViGhoaGFcbGxuxQWC/GYv4+HhOS6vVanDZ48fLly/NZvO3b9/GuyITTBAAXHMOkrS0tJ6enrS0NBQlwyhqWNWCRhRFAOjr6xNFsa+vD6dgUOK4keYHR8lL2GB8KjcaURSRdpSCZIr8kiGwNkcUoXwQKYgSe3p6Vq5cybh36tSpKPD161e95fJDKoXcE+sLAE+fPvV4PNhnGeiaIAaI3AH5XdLj8aD51lhDKog/79+/T9qYTCa2h9bV1aGZGdtFMBs3bgywugwF2XPDe/fu6SoIL+c1f7PCwsLTp0/jqCjjyJEjnIXGx8fX1tYWFBRwzvOqq6vfvXv34cOHR48ecRYxQhoByL4n1cNSzJw5U1dZCQkJubm54eHhmpYZGRlUCtXGk5OTyR02RvcaGFevXg3qfqwa3lskR6Tgx6W6ujoes8jIyMzMTIYBVo0chahowJU0m81oUcPYndAGKWW1WlF/sWbNGrY97tRjYmL4S8HL/+D59esXAOTl5aEoqSAZTkhIAOLrVFRU8GQeFxeXlJQU1LacpvcpGgwODgLA+fPnGTcmJSUFXi0ZpFhnzpwBgJycHHyJ8lOS9vb23bt3szO3WCwokJeXt2vXrqCao9rNapNTfg4fPsxpyd65QKjpRRmQNrm5uZs2bQKAbdu2FRUVqd1YUVEhimJKSgpO4enlWSC91PZfg+lA29raUIC94XLjxg3NrHg6x2A6UEmSQGuDlQtSrzdv3gBAenq63CaYIq5cuaJpM3fuXABob29nm1FDObuxB4CRe3fUolNtIjVecIo4RktPHcgX7/LEf46m1EoJp4NSH2oguneb/pu4XC6v1+tyuVCUDJMpXq9X9+bIBAiv14u3JsZkjyI6Ojo/P9/ADK1W66VLlzo7OzUtbTabgeUycPnBYbmBdi48Zw7wY8IlS5ZoGqM1ybRp0xg23d3d4J+Qs2epaBJTVVX1+fNn/k0QvWARqU9FM1Xw6arIyEiGGefDRfTN9+7di6bQDLq6umpqajQz1OuY165d47RcunTp4sWLqUTKPcnmGB0djY6xqAoa/EkuOZWVlfv37zc8Wx7QucxgYHglZRMseG1rLIIgGJibIccxXQRUOvApziI0NJTdD+jlwIEDx44d2759u667OJcr0dHRaEspYCgdcZgMGOOh+DERm7KysrVr1zIMQkJCsrOzDx06dPbsWYaZyWT68eMHAPT397NLzM/Px8dmbt++zVNJAMjMzOQ/vQGa4z7a3ZsxYwZ/jppwno7jx2w2h4WFpaamojM5ahj7LQDA5XItW7ZMMR0HFJzUbrc7HA50bslAnE4nz4xq3GH0IVgvxd7DmPb+34EajjZv3ozTqc+JtTwXSCxyiUm6JF7IT/ipbtSmR9h/TWiK39LSgq+RZ9dbWlrkBgYiSdLjx4/JMFpQAQCVjmamPp9PEASfzwcqc1V0afxBqul6DcAoJEnCIoJ/hUpF0SdSEH9iQQU/f6W+fJT6AZmsaM9YU+vAlndYPlJWyY/NZouKisJqkgriHMjHMGOhqd5HHSNNnpTMYrEMDg6Sr7CVlpaqtfrQ0NA/f/4AQH9//8KFC9FzY36QXrix45auCWr79fX1R48e1VXiokWL3r9/zzDYuXOny+VCL5bxcPz48eHhYZfLlZ2dPdLYSUFDQkZtPDMOH9hsNp5zDOTE1mQyUa6EXVLx3ra2NkmSFN2TetwfGxvL6aTsAwoPHz4E7mNiAwMDAwMDAIBfTxnV3oEYwtBsy9iOlVoykF0kBXpOS17CrZ5SDR+cMqTJV1VV6bK/ePHiqLi89yTfd8NqjtF4JRGQ6c+ePYPRPSwoDUcYAwcl/hc9Ozo68KurI5BKoTD55FJz9L9z5w5P2REREWqbDpIkrVu3Tp4IMrkFQcDuQMmn5rycIB8PCwsz5h1xRb0ot6Vsbt68+fbt2/LycgBYv369AZUYDakj9lNFsRT7VjnswVqSpOLi4vLycs3zExT79u2jk9S8j0pXMysrK+MpmHxLkIQxFpFOilIEQVB83KKm6ZQpU3BY841lRHp6uub2mN1ux+Ow8jkEuVgFBQVsA4yme16+fJnKjYQ9voNsYk9Jhvbo1KaoASA/XKSG6p89yIcd6iHaX14+PXny5PXr12QK5aSkfOHh4aSCf22xhP71QfHxj4nSS23xzpjYGwU5wycX8iiAlvNoLQ/+RT34F++klOO7nP//iWakI5IMa/p3fBPriEVUXDXJ1cRRUJJ1vPgfWOMA9gvhLSUAAAAASUVORK5CYII=",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408823.7832282&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=5": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408809.3148441&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=4": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408795.3117309&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=3": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408767.2911096&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=1": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408781.3143485&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=2": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408752.9578104&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=0": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590409042.741345&run=testing_for_activations%2Fversion_4&tag=input&sample=0&index=9": {
+ "data": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAACUElEQVR4nO2UvWvqUBjGT+SKg4M0W6Gl0MYlSqEQHRziplOrIpEiCC4uTt2cxCCugqBLXcXi0KWULB1K/RgMif4F7SDikIQOFYkHSU7uEAglV9t4ucu93Gc7D+/5vc/JeU8A+K+/QphtHQgEkskkx3Hv7++RSISmacMwRFFcr9fBYJAgCIqiLi4uVqvVHk0QQrquQwglSdJ13VxaMpeFQuFryI+trtvt9vl8iqJgGPb6+vr09GT6xWLRMAyfz7dHTCtpuVyORqP77fwk13bX5er3+38Mms1mMQyjaXrXBhzHcRz/Gmq//ePjY0EQPB7P+fn5fD43zUQi8fHxQVHUyclJLBZbr9eiKAqCcHt76zR8tVrVNC2XywEAWJbtdDqapkEIN5uNbRhkWS6VSi6X/bj2pKYkSTIMo9/vMwxjGIZpCoKgqurDw8NisQAAXF9fp9NphFClUmm327IsfxO20Wh8HszxeHx5eenxeGxlJEnyPK/r+v39/fdfgGVZhBBCaDgcxuPxLyoJgpjNZjzP/9rSLoZher1eKpX6vj8ALMvquk6SpJNipzKhrVbLcrYPv6VwOOwQfXp66hQ6GAxCoZAT6Nvbm1Ooqqp3d3etVuvq6mrXVRwcHGAYNhqNnPQGAAC/3z+dTs3x4nm+2Wze3NyYdIIgMplMt9uFEE4mE6/X6xQKAMjn84+Pj6qqWmOrKIokScvl0npgHMftQbSUTqefn5+3/rPr9frR0dHn4u3PdJeq1SqE8PDwMB6Pn52dDYfDWq328vKiadrvJP1H9RPtZlgCJoRfhwAAAABJRU5ErkJggg==",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590409042.9924123&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=9": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408880.1092744&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=8": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408851.7423832&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=6": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ },
+ "https://localhost:6006/data/plugin/images/individualImage?ts=1590408865.8347104&run=testing_for_activations%2Fversion_4&tag=layer+1&sample=0&index=7": {
+ "data": "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",
+ "ok": true,
+ "headers": [
+ [
+ "content-type",
+ "image/png"
+ ]
+ ],
+ "status": 200,
+ "status_text": ""
+ }
+ },
+ "base_uri": "https://localhost:8080/",
+ "height": 873
+ }
+ },
+ "source": [
+ "%load_ext tensorboard\n",
+ "%tensorboard --logdir tb_logs/"
+ ],
+ "execution_count": 0,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "text": [
+ "The tensorboard extension is already loaded. To reload it, use:\n",
+ " %reload_ext tensorboard\n"
+ ],
+ "name": "stdout"
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ "Reusing TensorBoard on port 6006 (pid 69682), started 0:43:08 ago. (Use '!kill 69682' to kill it.)"
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ },
+ {
+ "output_type": "display_data",
+ "data": {
+ "application/javascript": [
+ "\n",
+ " (async () => {\n",
+ " const url = await google.colab.kernel.proxyPort(6006, {\"cache\": 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",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ }
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/TensorFlow-Fully-Convolutional-Image-Classification/FullyConvolutionalResnet50.py b/TensorFlow-Fully-Convolutional-Image-Classification/FullyConvolutionalResnet50.py
new file mode 100644
index 000000000..d29e92614
--- /dev/null
+++ b/TensorFlow-Fully-Convolutional-Image-Classification/FullyConvolutionalResnet50.py
@@ -0,0 +1,186 @@
+import cv2
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras import Input
+from tensorflow.keras.applications import ResNet50
+from tensorflow.keras.applications.resnet import preprocess_input
+from tensorflow.keras.layers import (
+ Activation,
+ AveragePooling2D,
+ BatchNormalization,
+ Conv2D,
+ MaxPooling2D,
+ ZeroPadding2D,
+)
+from tensorflow.python.keras.engine import training
+from tensorflow.python.keras.utils import data_utils
+
+from utils import (
+ BASE_WEIGHTS_PATH,
+ WEIGHTS_HASHES,
+ stack1,
+)
+
+
+# setting FC weights to the final convolutional layer
+def set_conv_weights(model, feature_extractor):
+ # get pre-trained ResNet50 FC weights
+ dense_layer_weights = feature_extractor.layers[-1].get_weights()
+ weights_list = [
+ tf.reshape(
+ dense_layer_weights[0], (1, 1, *dense_layer_weights[0].shape),
+ ).numpy(),
+ dense_layer_weights[1],
+ ]
+ model.get_layer(name="last_conv").set_weights(weights_list)
+
+
+def fully_convolutional_resnet50(
+ input_shape, num_classes=1000, pretrained_resnet=True, use_bias=True,
+):
+ # init input layer
+ img_input = Input(shape=input_shape)
+
+ # define basic model pipeline
+ x = ZeroPadding2D(padding=((3, 3), (3, 3)), name="conv1_pad")(img_input)
+ x = Conv2D(64, 7, strides=2, use_bias=use_bias, name="conv1_conv")(x)
+ x = BatchNormalization(axis=3, epsilon=1.001e-5, name="conv1_bn")(x)
+ x = Activation("relu", name="conv1_relu")(x)
+
+ x = ZeroPadding2D(padding=((1, 1), (1, 1)), name="pool1_pad")(x)
+ x = MaxPooling2D(3, strides=2, name="pool1_pool")(x)
+
+ # the sequence of stacked residual blocks
+ x = stack1(x, 64, 3, stride1=1, name="conv2")
+ x = stack1(x, 128, 4, name="conv3")
+ x = stack1(x, 256, 6, name="conv4")
+ x = stack1(x, 512, 3, name="conv5")
+
+ # add avg pooling layer after feature extraction layers
+ x = AveragePooling2D(pool_size=7)(x)
+
+ # add final convolutional layer
+ conv_layer_final = Conv2D(
+ filters=num_classes, kernel_size=1, use_bias=use_bias, name="last_conv",
+ )(x)
+
+ # configure fully convolutional ResNet50 model
+ model = training.Model(img_input, x)
+
+ # load model weights
+ if pretrained_resnet:
+ model_name = "resnet50"
+ # configure full file name
+ file_name = model_name + "_weights_tf_dim_ordering_tf_kernels_notop.h5"
+ # get the file hash from TF WEIGHTS_HASHES
+ file_hash = WEIGHTS_HASHES[model_name][1]
+ weights_path = data_utils.get_file(
+ file_name,
+ BASE_WEIGHTS_PATH + file_name,
+ cache_subdir="models",
+ file_hash=file_hash,
+ )
+
+ model.load_weights(weights_path)
+
+ # form final model
+ model = training.Model(inputs=model.input, outputs=[conv_layer_final])
+
+ if pretrained_resnet:
+ # get model with the dense layer for further FC weights extraction
+ resnet50_extractor = ResNet50(
+ include_top=True, weights="imagenet", classes=num_classes,
+ )
+ # set ResNet50 FC-layer weights to final convolutional layer
+ set_conv_weights(model=model, feature_extractor=resnet50_extractor)
+ return model
+
+
+if __name__ == "__main__":
+
+ # read ImageNet class ids to a list of labels
+ with open("imagenet_classes.txt") as f:
+ labels = [line.strip() for line in f.readlines()]
+
+ # read image
+ original_image = cv2.imread("camel.jpg")
+
+ # convert image to the RGB format
+ image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
+
+ # pre-process image
+ image = preprocess_input(image)
+
+ # convert image to NCHW tf.tensor
+ image = tf.expand_dims(image, 0)
+
+ # load modified resnet50 model with pre-trained ImageNet weights
+ model = fully_convolutional_resnet50(input_shape=(image.shape[-3:]))
+
+ # Perform inference.
+ # Instead of a 1×1000 vector, we will get a
+ # 1×1000×n×m output ( i.e. a probability map
+ # of size n × m for each 1000 class,
+ # where n and m depend on the size of the image).
+ preds = model.predict(image)
+ preds = tf.transpose(preds, perm=[0, 3, 1, 2])
+ preds = tf.nn.softmax(preds, axis=1)
+ print("Response map shape : ", preds.shape)
+
+ # find the class with the maximum score in the n × m output map
+ pred = tf.math.reduce_max(preds, axis=1)
+ class_idx = tf.math.argmax(preds, axis=1)
+ print(class_idx)
+
+ row_max = tf.math.reduce_max(pred, axis=1)
+ row_idx = tf.math.argmax(pred, axis=1)
+
+ col_idx = tf.math.argmax(row_max, axis=1)
+
+ predicted_class = tf.gather_nd(
+ class_idx, (0, tf.gather_nd(row_idx, (0, col_idx[0])), col_idx[0]),
+ )
+
+ # print top predicted class
+ print("Predicted Class : ", labels[predicted_class], predicted_class)
+
+ # find the n × m score map for the predicted class
+ score_map = tf.expand_dims(preds[0, predicted_class, :, :], 0).numpy()
+ score_map = score_map[0]
+
+ # resize score map to the original image size
+ score_map = cv2.resize(
+ score_map, (original_image.shape[1], original_image.shape[0]),
+ )
+
+ # binarize score map
+ _, score_map_for_contours = cv2.threshold(
+ score_map, 0.65, 1, type=cv2.THRESH_BINARY,
+ )
+ score_map_for_contours = score_map_for_contours.astype(np.uint8).copy()
+
+ # find the contour of the binary blob
+ contours, _ = cv2.findContours(
+ score_map_for_contours, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_SIMPLE,
+ )
+
+ # find bounding box around the object.
+ rect = cv2.boundingRect(contours[0])
+
+ # apply score map as a mask to original image
+ score_map = score_map - np.min(score_map[:])
+ score_map = score_map / np.max(score_map[:])
+
+ score_map = cv2.cvtColor(score_map, cv2.COLOR_GRAY2BGR)
+ masked_image = (original_image * score_map).astype(np.uint8)
+
+ # display bounding box
+ cv2.rectangle(
+ masked_image, rect[:2], (rect[0] + rect[2], rect[1] + rect[3]), (0, 0, 255), 2,
+ )
+
+ # display images
+ cv2.imshow("Original Image", original_image)
+ cv2.imshow("scaled_score_map", score_map)
+ cv2.imshow("activations_and_bbox", masked_image)
+ cv2.waitKey(0)
diff --git a/TensorFlow-Fully-Convolutional-Image-Classification/README.md b/TensorFlow-Fully-Convolutional-Image-Classification/README.md
new file mode 100644
index 000000000..4305db6ef
--- /dev/null
+++ b/TensorFlow-Fully-Convolutional-Image-Classification/README.md
@@ -0,0 +1,12 @@
+This contains the code for **CNN Fully Convolutional Image Classification with TensorFlow**. For more information - visit
+[**CNN Fully Convolutional Image Classification with TensorFlow**](https://www.learnopencv.com/cnn-fully-convolutional-image-classification-with-tensorflow)
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
+
+
+
+
+
diff --git a/TensorFlow-Fully-Convolutional-Image-Classification/camel.jpg b/TensorFlow-Fully-Convolutional-Image-Classification/camel.jpg
new file mode 100644
index 000000000..f1eae1f94
Binary files /dev/null and b/TensorFlow-Fully-Convolutional-Image-Classification/camel.jpg differ
diff --git a/TensorFlow-Fully-Convolutional-Image-Classification/imagenet_classes.txt b/TensorFlow-Fully-Convolutional-Image-Classification/imagenet_classes.txt
new file mode 100644
index 000000000..a509c0074
--- /dev/null
+++ b/TensorFlow-Fully-Convolutional-Image-Classification/imagenet_classes.txt
@@ -0,0 +1,1000 @@
+tench, Tinca tinca
+goldfish, Carassius auratus
+great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+tiger shark, Galeocerdo cuvieri
+hammerhead, hammerhead shark
+electric ray, crampfish, numbfish, torpedo
+stingray
+cock
+hen
+ostrich, Struthio camelus
+brambling, Fringilla montifringilla
+goldfinch, Carduelis carduelis
+house finch, linnet, Carpodacus mexicanus
+junco, snowbird
+indigo bunting, indigo finch, indigo bird, Passerina cyanea
+robin, American robin, Turdus migratorius
+bulbul
+jay
+magpie
+chickadee
+water ouzel, dipper
+kite
+bald eagle, American eagle, Haliaeetus leucocephalus
+vulture
+great grey owl, great gray owl, Strix nebulosa
+European fire salamander, Salamandra salamandra
+common newt, Triturus vulgaris
+eft
+spotted salamander, Ambystoma maculatum
+axolotl, mud puppy, Ambystoma mexicanum
+bullfrog, Rana catesbeiana
+tree frog, tree-frog
+tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+loggerhead, loggerhead turtle, Caretta caretta
+leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+mud turtle
+terrapin
+box turtle, box tortoise
+banded gecko
+common iguana, iguana, Iguana iguana
+American chameleon, anole, Anolis carolinensis
+whiptail, whiptail lizard
+agama
+frilled lizard, Chlamydosaurus kingi
+alligator lizard
+Gila monster, Heloderma suspectum
+green lizard, Lacerta viridis
+African chameleon, Chamaeleo chamaeleon
+Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+African crocodile, Nile crocodile, Crocodylus niloticus
+American alligator, Alligator mississipiensis
+triceratops
+thunder snake, worm snake, Carphophis amoenus
+ringneck snake, ring-necked snake, ring snake
+hognose snake, puff adder, sand viper
+green snake, grass snake
+king snake, kingsnake
+garter snake, grass snake
+water snake
+vine snake
+night snake, Hypsiglena torquata
+boa constrictor, Constrictor constrictor
+rock python, rock snake, Python sebae
+Indian cobra, Naja naja
+green mamba
+sea snake
+horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+diamondback, diamondback rattlesnake, Crotalus adamanteus
+sidewinder, horned rattlesnake, Crotalus cerastes
+trilobite
+harvestman, daddy longlegs, Phalangium opilio
+scorpion
+black and gold garden spider, Argiope aurantia
+barn spider, Araneus cavaticus
+garden spider, Aranea diademata
+black widow, Latrodectus mactans
+tarantula
+wolf spider, hunting spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse, partridge, Bonasa umbellus
+prairie chicken, prairie grouse, prairie fowl
+peacock
+quail
+partridge
+African grey, African gray, Psittacus erithacus
+macaw
+sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser, Mergus serrator
+goose
+black swan, Cygnus atratus
+tusker
+echidna, spiny anteater, anteater
+platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+wallaby, brush kangaroo
+koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+wombat
+jellyfish
+sea anemone, anemone
+brain coral
+flatworm, platyhelminth
+nematode, nematode worm, roundworm
+conch
+snail
+slug
+sea slug, nudibranch
+chiton, coat-of-mail shell, sea cradle, polyplacophore
+chambered nautilus, pearly nautilus, nautilus
+Dungeness crab, Cancer magister
+rock crab, Cancer irroratus
+fiddler crab
+king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+American lobster, Northern lobster, Maine lobster, Homarus americanus
+spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+crayfish, crawfish, crawdad, crawdaddy
+hermit crab
+isopod
+white stork, Ciconia ciconia
+black stork, Ciconia nigra
+spoonbill
+flamingo
+little blue heron, Egretta caerulea
+American egret, great white heron, Egretta albus
+bittern
+crane
+limpkin, Aramus pictus
+European gallinule, Porphyrio porphyrio
+American coot, marsh hen, mud hen, water hen, Fulica americana
+bustard
+ruddy turnstone, Arenaria interpres
+red-backed sandpiper, dunlin, Erolia alpina
+redshank, Tringa totanus
+dowitcher
+oystercatcher, oyster catcher
+pelican
+king penguin, Aptenodytes patagonica
+albatross, mollymawk
+grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+dugong, Dugong dugon
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog, Maltese terrier, Maltese
+Pekinese, Pekingese, Peke
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound, Afghan
+basset, basset hound
+beagle
+bloodhound, sleuthhound
+bluetick
+black-and-tan coonhound
+Walker hound, Walker foxhound
+English foxhound
+redbone
+borzoi, Russian wolfhound
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound, Ibizan Podenco
+Norwegian elkhound, elkhound
+otterhound, otter hound
+Saluki, gazelle hound
+Scottish deerhound, deerhound
+Weimaraner
+Staffordshire bullterrier, Staffordshire bull terrier
+American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier, Sealyham
+Airedale, Airedale terrier
+cairn, cairn terrier
+Australian terrier
+Dandie Dinmont, Dandie Dinmont terrier
+Boston bull, Boston terrier
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier, Scottish terrier, Scottie
+Tibetan terrier, chrysanthemum dog
+silky terrier, Sydney silky
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa, Lhasa apso
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla, Hungarian pointer
+English setter
+Irish setter, red setter
+Gordon setter
+Brittany spaniel
+clumber, clumber spaniel
+English springer, English springer spaniel
+Welsh springer spaniel
+cocker spaniel, English cocker spaniel, cocker
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog, bobtail
+Shetland sheepdog, Shetland sheep dog, Shetland
+collie
+Border collie
+Bouvier des Flandres, Bouviers des Flandres
+Rottweiler
+German shepherd, German shepherd dog, German police dog, alsatian
+Doberman, Doberman pinscher
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard, St Bernard
+Eskimo dog, husky
+malamute, malemute, Alaskan malamute
+Siberian husky
+dalmatian, coach dog, carriage dog
+affenpinscher, monkey pinscher, monkey dog
+basenji
+pug, pug-dog
+Leonberg
+Newfoundland, Newfoundland dog
+Great Pyrenees
+Samoyed, Samoyede
+Pomeranian
+chow, chow chow
+keeshond
+Brabancon griffon
+Pembroke, Pembroke Welsh corgi
+Cardigan, Cardigan Welsh corgi
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf, grey wolf, gray wolf, Canis lupus
+white wolf, Arctic wolf, Canis lupus tundrarum
+red wolf, maned wolf, Canis rufus, Canis niger
+coyote, prairie wolf, brush wolf, Canis latrans
+dingo, warrigal, warragal, Canis dingo
+dhole, Cuon alpinus
+African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+hyena, hyaena
+red fox, Vulpes vulpes
+kit fox, Vulpes macrotis
+Arctic fox, white fox, Alopex lagopus
+grey fox, gray fox, Urocyon cinereoargenteus
+tabby, tabby cat
+tiger cat
+Persian cat
+Siamese cat, Siamese
+Egyptian cat
+cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+lynx, catamount
+leopard, Panthera pardus
+snow leopard, ounce, Panthera uncia
+jaguar, panther, Panthera onca, Felis onca
+lion, king of beasts, Panthera leo
+tiger, Panthera tigris
+cheetah, chetah, Acinonyx jubatus
+brown bear, bruin, Ursus arctos
+American black bear, black bear, Ursus americanus, Euarctos americanus
+ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+sloth bear, Melursus ursinus, Ursus ursinus
+mongoose
+meerkat, mierkat
+tiger beetle
+ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+ground beetle, carabid beetle
+long-horned beetle, longicorn, longicorn beetle
+leaf beetle, chrysomelid
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant, emmet, pismire
+grasshopper, hopper
+cricket
+walking stick, walkingstick, stick insect
+cockroach, roach
+mantis, mantid
+cicada, cicala
+leafhopper
+lacewing, lacewing fly
+dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+damselfly
+admiral
+ringlet, ringlet butterfly
+monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+cabbage butterfly
+sulphur butterfly, sulfur butterfly
+lycaenid, lycaenid butterfly
+starfish, sea star
+sea urchin
+sea cucumber, holothurian
+wood rabbit, cottontail, cottontail rabbit
+hare
+Angora, Angora rabbit
+hamster
+porcupine, hedgehog
+fox squirrel, eastern fox squirrel, Sciurus niger
+marmot
+beaver
+guinea pig, Cavia cobaya
+sorrel
+zebra
+hog, pig, grunter, squealer, Sus scrofa
+wild boar, boar, Sus scrofa
+warthog
+hippopotamus, hippo, river horse, Hippopotamus amphibius
+ox
+water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+bison
+ram, tup
+bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+ibex, Capra ibex
+hartebeest
+impala, Aepyceros melampus
+gazelle
+Arabian camel, dromedary, Camelus dromedarius
+llama
+weasel
+mink
+polecat, fitch, foulmart, foumart, Mustela putorius
+black-footed ferret, ferret, Mustela nigripes
+otter
+skunk, polecat, wood pussy
+badger
+armadillo
+three-toed sloth, ai, Bradypus tridactylus
+orangutan, orang, orangutang, Pongo pygmaeus
+gorilla, Gorilla gorilla
+chimpanzee, chimp, Pan troglodytes
+gibbon, Hylobates lar
+siamang, Hylobates syndactylus, Symphalangus syndactylus
+guenon, guenon monkey
+patas, hussar monkey, Erythrocebus patas
+baboon
+macaque
+langur
+colobus, colobus monkey
+proboscis monkey, Nasalis larvatus
+marmoset
+capuchin, ringtail, Cebus capucinus
+howler monkey, howler
+titi, titi monkey
+spider monkey, Ateles geoffroyi
+squirrel monkey, Saimiri sciureus
+Madagascar cat, ring-tailed lemur, Lemur catta
+indri, indris, Indri indri, Indri brevicaudatus
+Indian elephant, Elephas maximus
+African elephant, Loxodonta africana
+lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+barracouta, snoek
+eel
+coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+rock beauty, Holocanthus tricolor
+anemone fish
+sturgeon
+gar, garfish, garpike, billfish, Lepisosteus osseus
+lionfish
+puffer, pufferfish, blowfish, globefish
+abacus
+abaya
+academic gown, academic robe, judge's robe
+accordion, piano accordion, squeeze box
+acoustic guitar
+aircraft carrier, carrier, flattop, attack aircraft carrier
+airliner
+airship, dirigible
+altar
+ambulance
+amphibian, amphibious vehicle
+analog clock
+apiary, bee house
+apron
+ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+assault rifle, assault gun
+backpack, back pack, knapsack, packsack, rucksack, haversack
+bakery, bakeshop, bakehouse
+balance beam, beam
+balloon
+ballpoint, ballpoint pen, ballpen, Biro
+Band Aid
+banjo
+bannister, banister, balustrade, balusters, handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel, cask
+barrow, garden cart, lawn cart, wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap, swimming cap
+bath towel
+bathtub, bathing tub, bath, tub
+beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+beacon, lighthouse, beacon light, pharos
+beaker
+bearskin, busby, shako
+beer bottle
+beer glass
+bell cote, bell cot
+bib
+bicycle-built-for-two, tandem bicycle, tandem
+bikini, two-piece
+binder, ring-binder
+binoculars, field glasses, opera glasses
+birdhouse
+boathouse
+bobsled, bobsleigh, bob
+bolo tie, bolo, bola tie, bola
+bonnet, poke bonnet
+bookcase
+bookshop, bookstore, bookstall
+bottlecap
+bow
+bow tie, bow-tie, bowtie
+brass, memorial tablet, plaque
+brassiere, bra, bandeau
+breakwater, groin, groyne, mole, bulwark, seawall, jetty
+breastplate, aegis, egis
+broom
+bucket, pail
+buckle
+bulletproof vest
+bullet train, bullet
+butcher shop, meat market
+cab, hack, taxi, taxicab
+caldron, cauldron
+candle, taper, wax light
+cannon
+canoe
+can opener, tin opener
+cardigan
+car mirror
+carousel, carrousel, merry-go-round, roundabout, whirligig
+carpenter's kit, tool kit
+carton
+car wheel
+cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello, violoncello
+cellular telephone, cellular phone, cellphone, cell, mobile phone
+chain
+chainlink fence
+chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+chain saw, chainsaw
+chest
+chiffonier, commode
+chime, bell, gong
+china cabinet, china closet
+Christmas stocking
+church, church building
+cinema, movie theater, movie theatre, movie house, picture palace
+cleaver, meat cleaver, chopper
+cliff dwelling
+cloak
+clog, geta, patten, sabot
+cocktail shaker
+coffee mug
+coffeepot
+coil, spiral, volute, whorl, helix
+combination lock
+computer keyboard, keypad
+confectionery, confectionary, candy store
+container ship, containership, container vessel
+convertible
+corkscrew, bottle screw
+cornet, horn, trumpet, trump
+cowboy boot
+cowboy hat, ten-gallon hat
+cradle
+crane
+crash helmet
+crate
+crib, cot
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam, dike, dyke
+desk
+desktop computer
+dial telephone, dial phone
+diaper, nappy, napkin
+digital clock
+digital watch
+dining table, board
+dishrag, dishcloth
+dishwasher, dish washer, dishwashing machine
+disk brake, disc brake
+dock, dockage, docking facility
+dogsled, dog sled, dog sleigh
+dome
+doormat, welcome mat
+drilling platform, offshore rig
+drum, membranophone, tympan
+drumstick
+dumbbell
+Dutch oven
+electric fan, blower
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa, boa
+file, file cabinet, filing cabinet
+fireboat
+fire engine, fire truck
+fire screen, fireguard
+flagpole, flagstaff
+flute, transverse flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn, horn
+frying pan, frypan, skillet
+fur coat
+garbage truck, dustcart
+gasmask, respirator, gas helmet
+gas pump, gasoline pump, petrol pump, island dispenser
+goblet
+go-kart
+golf ball
+golfcart, golf cart
+gondola
+gong, tam-tam
+gown
+grand piano, grand
+greenhouse, nursery, glasshouse
+grille, radiator grille
+grocery store, grocery, food market, market
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower, blow dryer, blow drier, hair dryer, hair drier
+hand-held computer, hand-held microcomputer
+handkerchief, hankie, hanky, hankey
+hard disc, hard disk, fixed disk
+harmonica, mouth organ, harp, mouth harp
+harp
+harvester, reaper
+hatchet
+holster
+home theater, home theatre
+honeycomb
+hook, claw
+hoopskirt, crinoline
+horizontal bar, high bar
+horse cart, horse-cart
+hourglass
+iPod
+iron, smoothing iron
+jack-o'-lantern
+jean, blue jean, denim
+jeep, landrover
+jersey, T-shirt, tee shirt
+jigsaw puzzle
+jinrikisha, ricksha, rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat, laboratory coat
+ladle
+lampshade, lamp shade
+laptop, laptop computer
+lawn mower, mower
+lens cap, lens cover
+letter opener, paper knife, paperknife
+library
+lifeboat
+lighter, light, igniter, ignitor
+limousine, limo
+liner, ocean liner
+lipstick, lip rouge
+Loafer
+lotion
+loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+loupe, jeweler's loupe
+lumbermill, sawmill
+magnetic compass
+mailbag, postbag
+mailbox, letter box
+maillot
+maillot, tank suit
+manhole cover
+maraca
+marimba, xylophone
+mask
+matchstick
+maypole
+maze, labyrinth
+measuring cup
+medicine chest, medicine cabinet
+megalith, megalithic structure
+microphone, mike
+microwave, microwave oven
+military uniform
+milk can
+minibus
+miniskirt, mini
+minivan
+missile
+mitten
+mixing bowl
+mobile home, manufactured home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter, scooter
+mountain bike, all-terrain bike, off-roader
+mountain tent
+mouse, computer mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook, notebook computer
+obelisk
+oboe, hautboy, hautbois
+ocarina, sweet potato
+odometer, hodometer, mileometer, milometer
+oil filter
+organ, pipe organ
+oscilloscope, scope, cathode-ray oscilloscope, CRO
+overskirt
+oxcart
+oxygen mask
+packet
+paddle, boat paddle
+paddlewheel, paddle wheel
+padlock
+paintbrush
+pajama, pyjama, pj's, jammies
+palace
+panpipe, pandean pipe, syrinx
+paper towel
+parachute, chute
+parallel bars, bars
+park bench
+parking meter
+passenger car, coach, carriage
+patio, terrace
+pay-phone, pay-station
+pedestal, plinth, footstall
+pencil box, pencil case
+pencil sharpener
+perfume, essence
+Petri dish
+photocopier
+pick, plectrum, plectron
+pickelhaube
+picket fence, paling
+pickup, pickup truck
+pier
+piggy bank, penny bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate, pirate ship
+pitcher, ewer
+plane, carpenter's plane, woodworking plane
+planetarium
+plastic bag
+plate rack
+plow, plough
+plunger, plumber's helper
+Polaroid camera, Polaroid Land camera
+pole
+police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+poncho
+pool table, billiard table, snooker table
+pop bottle, soda bottle
+pot, flowerpot
+potter's wheel
+power drill
+prayer rug, prayer mat
+printer
+prison, prison house
+projectile, missile
+projector
+puck, hockey puck
+punching bag, punch bag, punching ball, punchball
+purse
+quill, quill pen
+quilt, comforter, comfort, puff
+racer, race car, racing car
+racket, racquet
+radiator
+radio, wireless
+radio telescope, radio reflector
+rain barrel
+recreational vehicle, RV, R.V.
+reel
+reflex camera
+refrigerator, icebox
+remote control, remote
+restaurant, eating house, eating place, eatery
+revolver, six-gun, six-shooter
+rifle
+rocking chair, rocker
+rotisserie
+rubber eraser, rubber, pencil eraser
+rugby ball
+rule, ruler
+running shoe
+safe
+safety pin
+saltshaker, salt shaker
+sandal
+sarong
+sax, saxophone
+scabbard
+scale, weighing machine
+school bus
+schooner
+scoreboard
+screen, CRT screen
+screw
+screwdriver
+seat belt, seatbelt
+sewing machine
+shield, buckler
+shoe shop, shoe-shop, shoe store
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule, slipstick
+sliding door
+slot, one-armed bandit
+snorkel
+snowmobile
+snowplow, snowplough
+soap dispenser
+soccer ball
+sock
+solar dish, solar collector, solar furnace
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web, spider's web
+spindle
+sports car, sport car
+spotlight, spot
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch, stop watch
+stove
+strainer
+streetcar, tram, tramcar, trolley, trolley car
+stretcher
+studio couch, day bed
+stupa, tope
+submarine, pigboat, sub, U-boat
+suit, suit of clothes
+sundial
+sunglass
+sunglasses, dark glasses, shades
+sunscreen, sunblock, sun blocker
+suspension bridge
+swab, swob, mop
+sweatshirt
+swimming trunks, bathing trunks
+swing
+switch, electric switch, electrical switch
+syringe
+table lamp
+tank, army tank, armored combat vehicle, armoured combat vehicle
+tape player
+teapot
+teddy, teddy bear
+television, television system
+tennis ball
+thatch, thatched roof
+theater curtain, theatre curtain
+thimble
+thresher, thrasher, threshing machine
+throne
+tile roof
+toaster
+tobacco shop, tobacconist shop, tobacconist
+toilet seat
+torch
+totem pole
+tow truck, tow car, wrecker
+toyshop
+tractor
+trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+tray
+trench coat
+tricycle, trike, velocipede
+trimaran
+tripod
+triumphal arch
+trolleybus, trolley coach, trackless trolley
+trombone
+tub, vat
+turnstile
+typewriter keyboard
+umbrella
+unicycle, monocycle
+upright, upright piano
+vacuum, vacuum cleaner
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin, fiddle
+volleyball
+waffle iron
+wall clock
+wallet, billfold, notecase, pocketbook
+wardrobe, closet, press
+warplane, military plane
+washbasin, handbasin, washbowl, lavabo, wash-hand basin
+washer, automatic washer, washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool, woolen, woollen
+worm fence, snake fence, snake-rail fence, Virginia fence
+wreck
+yawl
+yurt
+web site, website, internet site, site
+comic book
+crossword puzzle, crossword
+street sign
+traffic light, traffic signal, stoplight
+book jacket, dust cover, dust jacket, dust wrapper
+menu
+plate
+guacamole
+consomme
+hot pot, hotpot
+trifle
+ice cream, icecream
+ice lolly, lolly, lollipop, popsicle
+French loaf
+bagel, beigel
+pretzel
+cheeseburger
+hotdog, hot dog, red hot
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini, courgette
+spaghetti squash
+acorn squash
+butternut squash
+cucumber, cuke
+artichoke, globe artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple, ananas
+banana
+jackfruit, jak, jack
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce, chocolate syrup
+dough
+meat loaf, meatloaf
+pizza, pizza pie
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff, drop, drop-off
+coral reef
+geyser
+lakeside, lakeshore
+promontory, headland, head, foreland
+sandbar, sand bar
+seashore, coast, seacoast, sea-coast
+valley, vale
+volcano
+ballplayer, baseball player
+groom, bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+corn
+acorn
+hip, rose hip, rosehip
+buckeye, horse chestnut, conker
+coral fungus
+agaric
+gyromitra
+stinkhorn, carrion fungus
+earthstar
+hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+bolete
+ear, spike, capitulum
+toilet tissue, toilet paper, bathroom tissue
diff --git a/TensorFlow-Fully-Convolutional-Image-Classification/requirements.txt b/TensorFlow-Fully-Convolutional-Image-Classification/requirements.txt
new file mode 100644
index 000000000..ab1f58a1c
--- /dev/null
+++ b/TensorFlow-Fully-Convolutional-Image-Classification/requirements.txt
@@ -0,0 +1,2 @@
+opencv-python>=3.4.1.15
+tensorflow==2.1.0
diff --git a/TensorFlow-Fully-Convolutional-Image-Classification/utils.py b/TensorFlow-Fully-Convolutional-Image-Classification/utils.py
new file mode 100644
index 000000000..ecd4b4f8f
--- /dev/null
+++ b/TensorFlow-Fully-Convolutional-Image-Classification/utils.py
@@ -0,0 +1,75 @@
+from tensorflow.keras.layers import (
+ Activation,
+ Add,
+ BatchNormalization,
+ Conv2D,
+)
+
+# https://github.com/tensorflow/tensorflow/blob/2b96f3662bd776e277f86997659e61046b56c315/tensorflow/python/keras/applications/resnet.py#L32
+BASE_WEIGHTS_PATH = (
+ "https://storage.googleapis.com/tensorflow/keras-applications/resnet/"
+)
+WEIGHTS_HASHES = {
+ "resnet50": "4d473c1dd8becc155b73f8504c6f6626",
+}
+
+
+# https://github.com/tensorflow/tensorflow/blob/2b96f3662bd776e277f86997659e61046b56c315/tensorflow/python/keras/applications/resnet.py#L262
+def stack1(x, filters, blocks, stride1=2, name=None):
+ """
+ A set of stacked residual blocks.
+ Arguments:
+ x: input tensor.
+ filters: integer, filters of the bottleneck layer in a block.
+ blocks: integer, blocks in the stacked blocks.
+ stride1: default 2, stride of the first layer in the first block.
+ name: string, stack label.
+ Returns:
+ Output tensor for the stacked blocks.
+ """
+ x = block1(x, filters, stride=stride1, name=name + "_block1")
+ for i in range(2, blocks + 1):
+ x = block1(x, filters, conv_shortcut=False, name=name + "_block" + str(i))
+ return x
+
+
+# https://github.com/tensorflow/tensorflow/blob/2b96f3662bd776e277f86997659e61046b56c315/tensorflow/python/keras/applications/resnet.py#L217
+def block1(x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None):
+ """
+ A residual block.
+ Arguments:
+ x: input tensor.
+ filters: integer, filters of the bottleneck layer.
+ kernel_size: default 3, kernel size of the bottleneck layer.
+ stride: default 1, stride of the first layer.
+ conv_shortcut: default True, use convolution shortcut if True,
+ otherwise identity shortcut.
+ name: string, block label.
+ Returns:
+ Output tensor for the residual block.
+ """
+ # channels_last format
+ bn_axis = 3
+
+ if conv_shortcut:
+ shortcut = Conv2D(4 * filters, 1, strides=stride, name=name + "_0_conv")(x)
+ shortcut = BatchNormalization(
+ axis=bn_axis, epsilon=1.001e-5, name=name + "_0_bn",
+ )(shortcut)
+ else:
+ shortcut = x
+
+ x = Conv2D(filters, 1, strides=stride, name=name + "_1_conv")(x)
+ x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name=name + "_1_bn")(x)
+ x = Activation("relu", name=name + "_1_relu")(x)
+
+ x = Conv2D(filters, kernel_size, padding="SAME", name=name + "_2_conv")(x)
+ x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name=name + "_2_bn")(x)
+ x = Activation("relu", name=name + "_2_relu")(x)
+
+ x = Conv2D(4 * filters, 1, name=name + "_3_conv")(x)
+ x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name=name + "_3_bn")(x)
+
+ x = Add(name=name + "_add")([shortcut, x])
+ x = Activation("relu", name=name + "_out")(x)
+ return x
diff --git a/TensorFlow-Receptive-Field-With-Backprop/FullyConvolutionalResnet50.py b/TensorFlow-Receptive-Field-With-Backprop/FullyConvolutionalResnet50.py
new file mode 100644
index 000000000..72d36f78a
--- /dev/null
+++ b/TensorFlow-Receptive-Field-With-Backprop/FullyConvolutionalResnet50.py
@@ -0,0 +1,96 @@
+import cv2
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras import Input
+from tensorflow.keras.applications import ResNet50
+from tensorflow.keras.applications.resnet import preprocess_input
+from tensorflow.keras.layers import (
+ Activation,
+ AveragePooling2D,
+ BatchNormalization,
+ Conv2D,
+ MaxPooling2D,
+ ZeroPadding2D,
+)
+from tensorflow.python.keras.engine import training
+from tensorflow.python.keras.utils import data_utils
+
+from utils import (
+ BASE_WEIGHTS_PATH,
+ WEIGHTS_HASHES,
+ stack1,
+)
+
+
+# setting FC weights to the final convolutional layer
+def set_conv_weights(model, feature_extractor):
+ # get pre-trained ResNet50 FC weights
+ dense_layer_weights = feature_extractor.layers[-1].get_weights()
+ weights_list = [
+ tf.reshape(
+ dense_layer_weights[0], (1, 1, *dense_layer_weights[0].shape),
+ ).numpy(),
+ dense_layer_weights[1],
+ ]
+ model.get_layer(name="last_conv").set_weights(weights_list)
+
+
+def fully_convolutional_resnet50(
+ input_shape, num_classes=1000, pretrained_resnet=True, use_bias=True,
+):
+ # init input layer
+ img_input = Input(shape=input_shape)
+
+ # define basic model pipeline
+ x = ZeroPadding2D(padding=((3, 3), (3, 3)), name="conv1_pad")(img_input)
+ x = Conv2D(64, 7, strides=2, use_bias=use_bias, name="conv1_conv")(x)
+ x = BatchNormalization(axis=3, epsilon=1.001e-5, name="conv1_bn")(x)
+ x = Activation("relu", name="conv1_relu")(x)
+
+ x = ZeroPadding2D(padding=((1, 1), (1, 1)), name="pool1_pad")(x)
+ x = MaxPooling2D(3, strides=2, name="pool1_pool")(x)
+
+ # the sequence of stacked residual blocks
+ x = stack1(x, 64, 3, stride1=1, name="conv2")
+ x = stack1(x, 128, 4, name="conv3")
+ x = stack1(x, 256, 6, name="conv4")
+ x = stack1(x, 512, 3, name="conv5")
+
+ # add avg pooling layer after feature extraction layers
+ x = AveragePooling2D(pool_size=7)(x)
+
+ # add final convolutional layer
+ conv_layer_final = Conv2D(
+ filters=num_classes, kernel_size=1, use_bias=use_bias, name="last_conv",
+ )(x)
+
+ # configure fully convolutional ResNet50 model
+ model = training.Model(img_input, x)
+
+ # load model weights
+ if pretrained_resnet:
+ model_name = "resnet50"
+ # configure full file name
+ file_name = model_name + "_weights_tf_dim_ordering_tf_kernels_notop.h5"
+ # get the file hash from TF WEIGHTS_HASHES
+ file_hash = WEIGHTS_HASHES[model_name][1]
+ weights_path = data_utils.get_file(
+ file_name,
+ BASE_WEIGHTS_PATH + file_name,
+ cache_subdir="models",
+ file_hash=file_hash,
+ )
+
+ model.load_weights(weights_path)
+
+ # form final model
+ model = training.Model(inputs=model.input, outputs=[conv_layer_final])
+
+ if pretrained_resnet:
+ # get model with the dense layer for further FC weights extraction
+ resnet50_extractor = ResNet50(
+ include_top=True, weights="imagenet", classes=num_classes,
+ )
+ # set ResNet50 FC-layer weights to final convolutional layer
+ set_conv_weights(model=model, feature_extractor=resnet50_extractor)
+ return model
diff --git a/TensorFlow-Receptive-Field-With-Backprop/README.md b/TensorFlow-Receptive-Field-With-Backprop/README.md
new file mode 100644
index 000000000..3baf133e8
--- /dev/null
+++ b/TensorFlow-Receptive-Field-With-Backprop/README.md
@@ -0,0 +1,12 @@
+This contains the code for **CNN Receptive Field Computation Using Backprop**. For more information - visit
+[**CNN Receptive Field Computation Using Backprop with Tensorflow**](https://www.learnopencv.com/cnn-receptive-field-computation-using-backprop-with-tensorflow/)
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
+
+
+
+
+
diff --git a/TensorFlow-Receptive-Field-With-Backprop/camel.jpg b/TensorFlow-Receptive-Field-With-Backprop/camel.jpg
new file mode 100644
index 000000000..f1eae1f94
Binary files /dev/null and b/TensorFlow-Receptive-Field-With-Backprop/camel.jpg differ
diff --git a/TensorFlow-Receptive-Field-With-Backprop/imagenet_classes.txt b/TensorFlow-Receptive-Field-With-Backprop/imagenet_classes.txt
new file mode 100644
index 000000000..a509c0074
--- /dev/null
+++ b/TensorFlow-Receptive-Field-With-Backprop/imagenet_classes.txt
@@ -0,0 +1,1000 @@
+tench, Tinca tinca
+goldfish, Carassius auratus
+great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+tiger shark, Galeocerdo cuvieri
+hammerhead, hammerhead shark
+electric ray, crampfish, numbfish, torpedo
+stingray
+cock
+hen
+ostrich, Struthio camelus
+brambling, Fringilla montifringilla
+goldfinch, Carduelis carduelis
+house finch, linnet, Carpodacus mexicanus
+junco, snowbird
+indigo bunting, indigo finch, indigo bird, Passerina cyanea
+robin, American robin, Turdus migratorius
+bulbul
+jay
+magpie
+chickadee
+water ouzel, dipper
+kite
+bald eagle, American eagle, Haliaeetus leucocephalus
+vulture
+great grey owl, great gray owl, Strix nebulosa
+European fire salamander, Salamandra salamandra
+common newt, Triturus vulgaris
+eft
+spotted salamander, Ambystoma maculatum
+axolotl, mud puppy, Ambystoma mexicanum
+bullfrog, Rana catesbeiana
+tree frog, tree-frog
+tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+loggerhead, loggerhead turtle, Caretta caretta
+leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+mud turtle
+terrapin
+box turtle, box tortoise
+banded gecko
+common iguana, iguana, Iguana iguana
+American chameleon, anole, Anolis carolinensis
+whiptail, whiptail lizard
+agama
+frilled lizard, Chlamydosaurus kingi
+alligator lizard
+Gila monster, Heloderma suspectum
+green lizard, Lacerta viridis
+African chameleon, Chamaeleo chamaeleon
+Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+African crocodile, Nile crocodile, Crocodylus niloticus
+American alligator, Alligator mississipiensis
+triceratops
+thunder snake, worm snake, Carphophis amoenus
+ringneck snake, ring-necked snake, ring snake
+hognose snake, puff adder, sand viper
+green snake, grass snake
+king snake, kingsnake
+garter snake, grass snake
+water snake
+vine snake
+night snake, Hypsiglena torquata
+boa constrictor, Constrictor constrictor
+rock python, rock snake, Python sebae
+Indian cobra, Naja naja
+green mamba
+sea snake
+horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+diamondback, diamondback rattlesnake, Crotalus adamanteus
+sidewinder, horned rattlesnake, Crotalus cerastes
+trilobite
+harvestman, daddy longlegs, Phalangium opilio
+scorpion
+black and gold garden spider, Argiope aurantia
+barn spider, Araneus cavaticus
+garden spider, Aranea diademata
+black widow, Latrodectus mactans
+tarantula
+wolf spider, hunting spider
+tick
+centipede
+black grouse
+ptarmigan
+ruffed grouse, partridge, Bonasa umbellus
+prairie chicken, prairie grouse, prairie fowl
+peacock
+quail
+partridge
+African grey, African gray, Psittacus erithacus
+macaw
+sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+lorikeet
+coucal
+bee eater
+hornbill
+hummingbird
+jacamar
+toucan
+drake
+red-breasted merganser, Mergus serrator
+goose
+black swan, Cygnus atratus
+tusker
+echidna, spiny anteater, anteater
+platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+wallaby, brush kangaroo
+koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+wombat
+jellyfish
+sea anemone, anemone
+brain coral
+flatworm, platyhelminth
+nematode, nematode worm, roundworm
+conch
+snail
+slug
+sea slug, nudibranch
+chiton, coat-of-mail shell, sea cradle, polyplacophore
+chambered nautilus, pearly nautilus, nautilus
+Dungeness crab, Cancer magister
+rock crab, Cancer irroratus
+fiddler crab
+king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+American lobster, Northern lobster, Maine lobster, Homarus americanus
+spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+crayfish, crawfish, crawdad, crawdaddy
+hermit crab
+isopod
+white stork, Ciconia ciconia
+black stork, Ciconia nigra
+spoonbill
+flamingo
+little blue heron, Egretta caerulea
+American egret, great white heron, Egretta albus
+bittern
+crane
+limpkin, Aramus pictus
+European gallinule, Porphyrio porphyrio
+American coot, marsh hen, mud hen, water hen, Fulica americana
+bustard
+ruddy turnstone, Arenaria interpres
+red-backed sandpiper, dunlin, Erolia alpina
+redshank, Tringa totanus
+dowitcher
+oystercatcher, oyster catcher
+pelican
+king penguin, Aptenodytes patagonica
+albatross, mollymawk
+grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+dugong, Dugong dugon
+sea lion
+Chihuahua
+Japanese spaniel
+Maltese dog, Maltese terrier, Maltese
+Pekinese, Pekingese, Peke
+Shih-Tzu
+Blenheim spaniel
+papillon
+toy terrier
+Rhodesian ridgeback
+Afghan hound, Afghan
+basset, basset hound
+beagle
+bloodhound, sleuthhound
+bluetick
+black-and-tan coonhound
+Walker hound, Walker foxhound
+English foxhound
+redbone
+borzoi, Russian wolfhound
+Irish wolfhound
+Italian greyhound
+whippet
+Ibizan hound, Ibizan Podenco
+Norwegian elkhound, elkhound
+otterhound, otter hound
+Saluki, gazelle hound
+Scottish deerhound, deerhound
+Weimaraner
+Staffordshire bullterrier, Staffordshire bull terrier
+American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+Bedlington terrier
+Border terrier
+Kerry blue terrier
+Irish terrier
+Norfolk terrier
+Norwich terrier
+Yorkshire terrier
+wire-haired fox terrier
+Lakeland terrier
+Sealyham terrier, Sealyham
+Airedale, Airedale terrier
+cairn, cairn terrier
+Australian terrier
+Dandie Dinmont, Dandie Dinmont terrier
+Boston bull, Boston terrier
+miniature schnauzer
+giant schnauzer
+standard schnauzer
+Scotch terrier, Scottish terrier, Scottie
+Tibetan terrier, chrysanthemum dog
+silky terrier, Sydney silky
+soft-coated wheaten terrier
+West Highland white terrier
+Lhasa, Lhasa apso
+flat-coated retriever
+curly-coated retriever
+golden retriever
+Labrador retriever
+Chesapeake Bay retriever
+German short-haired pointer
+vizsla, Hungarian pointer
+English setter
+Irish setter, red setter
+Gordon setter
+Brittany spaniel
+clumber, clumber spaniel
+English springer, English springer spaniel
+Welsh springer spaniel
+cocker spaniel, English cocker spaniel, cocker
+Sussex spaniel
+Irish water spaniel
+kuvasz
+schipperke
+groenendael
+malinois
+briard
+kelpie
+komondor
+Old English sheepdog, bobtail
+Shetland sheepdog, Shetland sheep dog, Shetland
+collie
+Border collie
+Bouvier des Flandres, Bouviers des Flandres
+Rottweiler
+German shepherd, German shepherd dog, German police dog, alsatian
+Doberman, Doberman pinscher
+miniature pinscher
+Greater Swiss Mountain dog
+Bernese mountain dog
+Appenzeller
+EntleBucher
+boxer
+bull mastiff
+Tibetan mastiff
+French bulldog
+Great Dane
+Saint Bernard, St Bernard
+Eskimo dog, husky
+malamute, malemute, Alaskan malamute
+Siberian husky
+dalmatian, coach dog, carriage dog
+affenpinscher, monkey pinscher, monkey dog
+basenji
+pug, pug-dog
+Leonberg
+Newfoundland, Newfoundland dog
+Great Pyrenees
+Samoyed, Samoyede
+Pomeranian
+chow, chow chow
+keeshond
+Brabancon griffon
+Pembroke, Pembroke Welsh corgi
+Cardigan, Cardigan Welsh corgi
+toy poodle
+miniature poodle
+standard poodle
+Mexican hairless
+timber wolf, grey wolf, gray wolf, Canis lupus
+white wolf, Arctic wolf, Canis lupus tundrarum
+red wolf, maned wolf, Canis rufus, Canis niger
+coyote, prairie wolf, brush wolf, Canis latrans
+dingo, warrigal, warragal, Canis dingo
+dhole, Cuon alpinus
+African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+hyena, hyaena
+red fox, Vulpes vulpes
+kit fox, Vulpes macrotis
+Arctic fox, white fox, Alopex lagopus
+grey fox, gray fox, Urocyon cinereoargenteus
+tabby, tabby cat
+tiger cat
+Persian cat
+Siamese cat, Siamese
+Egyptian cat
+cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+lynx, catamount
+leopard, Panthera pardus
+snow leopard, ounce, Panthera uncia
+jaguar, panther, Panthera onca, Felis onca
+lion, king of beasts, Panthera leo
+tiger, Panthera tigris
+cheetah, chetah, Acinonyx jubatus
+brown bear, bruin, Ursus arctos
+American black bear, black bear, Ursus americanus, Euarctos americanus
+ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+sloth bear, Melursus ursinus, Ursus ursinus
+mongoose
+meerkat, mierkat
+tiger beetle
+ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+ground beetle, carabid beetle
+long-horned beetle, longicorn, longicorn beetle
+leaf beetle, chrysomelid
+dung beetle
+rhinoceros beetle
+weevil
+fly
+bee
+ant, emmet, pismire
+grasshopper, hopper
+cricket
+walking stick, walkingstick, stick insect
+cockroach, roach
+mantis, mantid
+cicada, cicala
+leafhopper
+lacewing, lacewing fly
+dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+damselfly
+admiral
+ringlet, ringlet butterfly
+monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+cabbage butterfly
+sulphur butterfly, sulfur butterfly
+lycaenid, lycaenid butterfly
+starfish, sea star
+sea urchin
+sea cucumber, holothurian
+wood rabbit, cottontail, cottontail rabbit
+hare
+Angora, Angora rabbit
+hamster
+porcupine, hedgehog
+fox squirrel, eastern fox squirrel, Sciurus niger
+marmot
+beaver
+guinea pig, Cavia cobaya
+sorrel
+zebra
+hog, pig, grunter, squealer, Sus scrofa
+wild boar, boar, Sus scrofa
+warthog
+hippopotamus, hippo, river horse, Hippopotamus amphibius
+ox
+water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+bison
+ram, tup
+bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+ibex, Capra ibex
+hartebeest
+impala, Aepyceros melampus
+gazelle
+Arabian camel, dromedary, Camelus dromedarius
+llama
+weasel
+mink
+polecat, fitch, foulmart, foumart, Mustela putorius
+black-footed ferret, ferret, Mustela nigripes
+otter
+skunk, polecat, wood pussy
+badger
+armadillo
+three-toed sloth, ai, Bradypus tridactylus
+orangutan, orang, orangutang, Pongo pygmaeus
+gorilla, Gorilla gorilla
+chimpanzee, chimp, Pan troglodytes
+gibbon, Hylobates lar
+siamang, Hylobates syndactylus, Symphalangus syndactylus
+guenon, guenon monkey
+patas, hussar monkey, Erythrocebus patas
+baboon
+macaque
+langur
+colobus, colobus monkey
+proboscis monkey, Nasalis larvatus
+marmoset
+capuchin, ringtail, Cebus capucinus
+howler monkey, howler
+titi, titi monkey
+spider monkey, Ateles geoffroyi
+squirrel monkey, Saimiri sciureus
+Madagascar cat, ring-tailed lemur, Lemur catta
+indri, indris, Indri indri, Indri brevicaudatus
+Indian elephant, Elephas maximus
+African elephant, Loxodonta africana
+lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+barracouta, snoek
+eel
+coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+rock beauty, Holocanthus tricolor
+anemone fish
+sturgeon
+gar, garfish, garpike, billfish, Lepisosteus osseus
+lionfish
+puffer, pufferfish, blowfish, globefish
+abacus
+abaya
+academic gown, academic robe, judge's robe
+accordion, piano accordion, squeeze box
+acoustic guitar
+aircraft carrier, carrier, flattop, attack aircraft carrier
+airliner
+airship, dirigible
+altar
+ambulance
+amphibian, amphibious vehicle
+analog clock
+apiary, bee house
+apron
+ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+assault rifle, assault gun
+backpack, back pack, knapsack, packsack, rucksack, haversack
+bakery, bakeshop, bakehouse
+balance beam, beam
+balloon
+ballpoint, ballpoint pen, ballpen, Biro
+Band Aid
+banjo
+bannister, banister, balustrade, balusters, handrail
+barbell
+barber chair
+barbershop
+barn
+barometer
+barrel, cask
+barrow, garden cart, lawn cart, wheelbarrow
+baseball
+basketball
+bassinet
+bassoon
+bathing cap, swimming cap
+bath towel
+bathtub, bathing tub, bath, tub
+beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+beacon, lighthouse, beacon light, pharos
+beaker
+bearskin, busby, shako
+beer bottle
+beer glass
+bell cote, bell cot
+bib
+bicycle-built-for-two, tandem bicycle, tandem
+bikini, two-piece
+binder, ring-binder
+binoculars, field glasses, opera glasses
+birdhouse
+boathouse
+bobsled, bobsleigh, bob
+bolo tie, bolo, bola tie, bola
+bonnet, poke bonnet
+bookcase
+bookshop, bookstore, bookstall
+bottlecap
+bow
+bow tie, bow-tie, bowtie
+brass, memorial tablet, plaque
+brassiere, bra, bandeau
+breakwater, groin, groyne, mole, bulwark, seawall, jetty
+breastplate, aegis, egis
+broom
+bucket, pail
+buckle
+bulletproof vest
+bullet train, bullet
+butcher shop, meat market
+cab, hack, taxi, taxicab
+caldron, cauldron
+candle, taper, wax light
+cannon
+canoe
+can opener, tin opener
+cardigan
+car mirror
+carousel, carrousel, merry-go-round, roundabout, whirligig
+carpenter's kit, tool kit
+carton
+car wheel
+cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+cassette
+cassette player
+castle
+catamaran
+CD player
+cello, violoncello
+cellular telephone, cellular phone, cellphone, cell, mobile phone
+chain
+chainlink fence
+chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+chain saw, chainsaw
+chest
+chiffonier, commode
+chime, bell, gong
+china cabinet, china closet
+Christmas stocking
+church, church building
+cinema, movie theater, movie theatre, movie house, picture palace
+cleaver, meat cleaver, chopper
+cliff dwelling
+cloak
+clog, geta, patten, sabot
+cocktail shaker
+coffee mug
+coffeepot
+coil, spiral, volute, whorl, helix
+combination lock
+computer keyboard, keypad
+confectionery, confectionary, candy store
+container ship, containership, container vessel
+convertible
+corkscrew, bottle screw
+cornet, horn, trumpet, trump
+cowboy boot
+cowboy hat, ten-gallon hat
+cradle
+crane
+crash helmet
+crate
+crib, cot
+Crock Pot
+croquet ball
+crutch
+cuirass
+dam, dike, dyke
+desk
+desktop computer
+dial telephone, dial phone
+diaper, nappy, napkin
+digital clock
+digital watch
+dining table, board
+dishrag, dishcloth
+dishwasher, dish washer, dishwashing machine
+disk brake, disc brake
+dock, dockage, docking facility
+dogsled, dog sled, dog sleigh
+dome
+doormat, welcome mat
+drilling platform, offshore rig
+drum, membranophone, tympan
+drumstick
+dumbbell
+Dutch oven
+electric fan, blower
+electric guitar
+electric locomotive
+entertainment center
+envelope
+espresso maker
+face powder
+feather boa, boa
+file, file cabinet, filing cabinet
+fireboat
+fire engine, fire truck
+fire screen, fireguard
+flagpole, flagstaff
+flute, transverse flute
+folding chair
+football helmet
+forklift
+fountain
+fountain pen
+four-poster
+freight car
+French horn, horn
+frying pan, frypan, skillet
+fur coat
+garbage truck, dustcart
+gasmask, respirator, gas helmet
+gas pump, gasoline pump, petrol pump, island dispenser
+goblet
+go-kart
+golf ball
+golfcart, golf cart
+gondola
+gong, tam-tam
+gown
+grand piano, grand
+greenhouse, nursery, glasshouse
+grille, radiator grille
+grocery store, grocery, food market, market
+guillotine
+hair slide
+hair spray
+half track
+hammer
+hamper
+hand blower, blow dryer, blow drier, hair dryer, hair drier
+hand-held computer, hand-held microcomputer
+handkerchief, hankie, hanky, hankey
+hard disc, hard disk, fixed disk
+harmonica, mouth organ, harp, mouth harp
+harp
+harvester, reaper
+hatchet
+holster
+home theater, home theatre
+honeycomb
+hook, claw
+hoopskirt, crinoline
+horizontal bar, high bar
+horse cart, horse-cart
+hourglass
+iPod
+iron, smoothing iron
+jack-o'-lantern
+jean, blue jean, denim
+jeep, landrover
+jersey, T-shirt, tee shirt
+jigsaw puzzle
+jinrikisha, ricksha, rickshaw
+joystick
+kimono
+knee pad
+knot
+lab coat, laboratory coat
+ladle
+lampshade, lamp shade
+laptop, laptop computer
+lawn mower, mower
+lens cap, lens cover
+letter opener, paper knife, paperknife
+library
+lifeboat
+lighter, light, igniter, ignitor
+limousine, limo
+liner, ocean liner
+lipstick, lip rouge
+Loafer
+lotion
+loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+loupe, jeweler's loupe
+lumbermill, sawmill
+magnetic compass
+mailbag, postbag
+mailbox, letter box
+maillot
+maillot, tank suit
+manhole cover
+maraca
+marimba, xylophone
+mask
+matchstick
+maypole
+maze, labyrinth
+measuring cup
+medicine chest, medicine cabinet
+megalith, megalithic structure
+microphone, mike
+microwave, microwave oven
+military uniform
+milk can
+minibus
+miniskirt, mini
+minivan
+missile
+mitten
+mixing bowl
+mobile home, manufactured home
+Model T
+modem
+monastery
+monitor
+moped
+mortar
+mortarboard
+mosque
+mosquito net
+motor scooter, scooter
+mountain bike, all-terrain bike, off-roader
+mountain tent
+mouse, computer mouse
+mousetrap
+moving van
+muzzle
+nail
+neck brace
+necklace
+nipple
+notebook, notebook computer
+obelisk
+oboe, hautboy, hautbois
+ocarina, sweet potato
+odometer, hodometer, mileometer, milometer
+oil filter
+organ, pipe organ
+oscilloscope, scope, cathode-ray oscilloscope, CRO
+overskirt
+oxcart
+oxygen mask
+packet
+paddle, boat paddle
+paddlewheel, paddle wheel
+padlock
+paintbrush
+pajama, pyjama, pj's, jammies
+palace
+panpipe, pandean pipe, syrinx
+paper towel
+parachute, chute
+parallel bars, bars
+park bench
+parking meter
+passenger car, coach, carriage
+patio, terrace
+pay-phone, pay-station
+pedestal, plinth, footstall
+pencil box, pencil case
+pencil sharpener
+perfume, essence
+Petri dish
+photocopier
+pick, plectrum, plectron
+pickelhaube
+picket fence, paling
+pickup, pickup truck
+pier
+piggy bank, penny bank
+pill bottle
+pillow
+ping-pong ball
+pinwheel
+pirate, pirate ship
+pitcher, ewer
+plane, carpenter's plane, woodworking plane
+planetarium
+plastic bag
+plate rack
+plow, plough
+plunger, plumber's helper
+Polaroid camera, Polaroid Land camera
+pole
+police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+poncho
+pool table, billiard table, snooker table
+pop bottle, soda bottle
+pot, flowerpot
+potter's wheel
+power drill
+prayer rug, prayer mat
+printer
+prison, prison house
+projectile, missile
+projector
+puck, hockey puck
+punching bag, punch bag, punching ball, punchball
+purse
+quill, quill pen
+quilt, comforter, comfort, puff
+racer, race car, racing car
+racket, racquet
+radiator
+radio, wireless
+radio telescope, radio reflector
+rain barrel
+recreational vehicle, RV, R.V.
+reel
+reflex camera
+refrigerator, icebox
+remote control, remote
+restaurant, eating house, eating place, eatery
+revolver, six-gun, six-shooter
+rifle
+rocking chair, rocker
+rotisserie
+rubber eraser, rubber, pencil eraser
+rugby ball
+rule, ruler
+running shoe
+safe
+safety pin
+saltshaker, salt shaker
+sandal
+sarong
+sax, saxophone
+scabbard
+scale, weighing machine
+school bus
+schooner
+scoreboard
+screen, CRT screen
+screw
+screwdriver
+seat belt, seatbelt
+sewing machine
+shield, buckler
+shoe shop, shoe-shop, shoe store
+shoji
+shopping basket
+shopping cart
+shovel
+shower cap
+shower curtain
+ski
+ski mask
+sleeping bag
+slide rule, slipstick
+sliding door
+slot, one-armed bandit
+snorkel
+snowmobile
+snowplow, snowplough
+soap dispenser
+soccer ball
+sock
+solar dish, solar collector, solar furnace
+sombrero
+soup bowl
+space bar
+space heater
+space shuttle
+spatula
+speedboat
+spider web, spider's web
+spindle
+sports car, sport car
+spotlight, spot
+stage
+steam locomotive
+steel arch bridge
+steel drum
+stethoscope
+stole
+stone wall
+stopwatch, stop watch
+stove
+strainer
+streetcar, tram, tramcar, trolley, trolley car
+stretcher
+studio couch, day bed
+stupa, tope
+submarine, pigboat, sub, U-boat
+suit, suit of clothes
+sundial
+sunglass
+sunglasses, dark glasses, shades
+sunscreen, sunblock, sun blocker
+suspension bridge
+swab, swob, mop
+sweatshirt
+swimming trunks, bathing trunks
+swing
+switch, electric switch, electrical switch
+syringe
+table lamp
+tank, army tank, armored combat vehicle, armoured combat vehicle
+tape player
+teapot
+teddy, teddy bear
+television, television system
+tennis ball
+thatch, thatched roof
+theater curtain, theatre curtain
+thimble
+thresher, thrasher, threshing machine
+throne
+tile roof
+toaster
+tobacco shop, tobacconist shop, tobacconist
+toilet seat
+torch
+totem pole
+tow truck, tow car, wrecker
+toyshop
+tractor
+trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+tray
+trench coat
+tricycle, trike, velocipede
+trimaran
+tripod
+triumphal arch
+trolleybus, trolley coach, trackless trolley
+trombone
+tub, vat
+turnstile
+typewriter keyboard
+umbrella
+unicycle, monocycle
+upright, upright piano
+vacuum, vacuum cleaner
+vase
+vault
+velvet
+vending machine
+vestment
+viaduct
+violin, fiddle
+volleyball
+waffle iron
+wall clock
+wallet, billfold, notecase, pocketbook
+wardrobe, closet, press
+warplane, military plane
+washbasin, handbasin, washbowl, lavabo, wash-hand basin
+washer, automatic washer, washing machine
+water bottle
+water jug
+water tower
+whiskey jug
+whistle
+wig
+window screen
+window shade
+Windsor tie
+wine bottle
+wing
+wok
+wooden spoon
+wool, woolen, woollen
+worm fence, snake fence, snake-rail fence, Virginia fence
+wreck
+yawl
+yurt
+web site, website, internet site, site
+comic book
+crossword puzzle, crossword
+street sign
+traffic light, traffic signal, stoplight
+book jacket, dust cover, dust jacket, dust wrapper
+menu
+plate
+guacamole
+consomme
+hot pot, hotpot
+trifle
+ice cream, icecream
+ice lolly, lolly, lollipop, popsicle
+French loaf
+bagel, beigel
+pretzel
+cheeseburger
+hotdog, hot dog, red hot
+mashed potato
+head cabbage
+broccoli
+cauliflower
+zucchini, courgette
+spaghetti squash
+acorn squash
+butternut squash
+cucumber, cuke
+artichoke, globe artichoke
+bell pepper
+cardoon
+mushroom
+Granny Smith
+strawberry
+orange
+lemon
+fig
+pineapple, ananas
+banana
+jackfruit, jak, jack
+custard apple
+pomegranate
+hay
+carbonara
+chocolate sauce, chocolate syrup
+dough
+meat loaf, meatloaf
+pizza, pizza pie
+potpie
+burrito
+red wine
+espresso
+cup
+eggnog
+alp
+bubble
+cliff, drop, drop-off
+coral reef
+geyser
+lakeside, lakeshore
+promontory, headland, head, foreland
+sandbar, sand bar
+seashore, coast, seacoast, sea-coast
+valley, vale
+volcano
+ballplayer, baseball player
+groom, bridegroom
+scuba diver
+rapeseed
+daisy
+yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+corn
+acorn
+hip, rose hip, rosehip
+buckeye, horse chestnut, conker
+coral fungus
+agaric
+gyromitra
+stinkhorn, carrion fungus
+earthstar
+hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+bolete
+ear, spike, capitulum
+toilet tissue, toilet paper, bathroom tissue
diff --git a/TensorFlow-Receptive-Field-With-Backprop/receptive_field_backpropagation.py b/TensorFlow-Receptive-Field-With-Backprop/receptive_field_backpropagation.py
new file mode 100644
index 000000000..6a73b7686
--- /dev/null
+++ b/TensorFlow-Receptive-Field-With-Backprop/receptive_field_backpropagation.py
@@ -0,0 +1,226 @@
+from collections import namedtuple
+
+import cv2
+import numpy as np
+import tensorflow as tf
+import tensorflow.keras.backend as K
+from tensorflow.keras.applications.resnet import preprocess_input
+from tensorflow.keras.layers import (
+ BatchNormalization,
+ Conv2D,
+)
+
+from FullyConvolutionalResnet50 import fully_convolutional_resnet50
+
+Rect = namedtuple("Rect", "x1 y1 x2 y2")
+
+
+def backprop_receptive_field(
+ image, predicted_class, scoremap, use_max_activation=False,
+):
+ model = fully_convolutional_resnet50(
+ input_shape=(image.shape[-3:]), pretrained_resnet=False,
+ )
+
+ for module in model.layers:
+ try:
+ if isinstance(module, Conv2D):
+ conv_weights = np.full(module.get_weights()[0].shape, 0.005)
+ if len(module.get_weights()) > 1:
+ conv_biases = np.full(module.get_weights()[1].shape, 0.0)
+ module.set_weights([conv_weights, conv_biases])
+ # cases when use_bias = False
+ else:
+ module.set_weights([conv_weights])
+ if isinstance(module, BatchNormalization):
+ # weight sequence: gamma, beta, running mean, running variance
+ bn_weights = [
+ module.get_weights()[0],
+ module.get_weights()[1],
+ np.full(module.get_weights()[2].shape, 0.0),
+ np.full(module.get_weights()[3].shape, 1.0),
+ ]
+ module.set_weights(bn_weights)
+ except:
+ pass
+
+ input = tf.ones_like(image)
+ out = model.predict(image)
+ receptive_field_mask = tf.Variable(tf.zeros_like(out))
+
+ if not use_max_activation:
+ receptive_field_mask[:, :, :, predicted_class].assign(scoremap)
+ else:
+ scoremap_max_row_values = tf.math.reduce_max(scoremap, axis=1)
+ max_row_id = tf.math.argmax(scoremap, axis=1)
+ max_col_id = tf.math.argmax(scoremap_max_row_values, axis=1).numpy()[0]
+ max_row_id = max_row_id[0, max_col_id].numpy()
+ print(
+ "Coords of the max activation:", max_row_id, max_col_id,
+ )
+ # update gradient
+ receptive_field_mask = tf.tensor_scatter_nd_update(
+ receptive_field_mask, [(0, max_row_id, max_col_id, 0)], [1],
+ )
+
+ grads = []
+ with tf.GradientTape() as tf_gradient_tape:
+ tf_gradient_tape.watch(input)
+ # get the predictions
+ preds = model(input)
+ # apply the mask
+ pseudo_loss = preds * receptive_field_mask
+ pseudo_loss = K.mean(pseudo_loss)
+ # get gradient
+ grad = tf_gradient_tape.gradient(pseudo_loss, input)
+ grad = tf.transpose(grad, perm=[0, 3, 1, 2])
+ grads.append(grad)
+ return grads[0][0, 0]
+
+
+def find_rect(activations):
+ # Dilate and erode the activations to remove grid-like artifacts
+ kernel = np.ones((5, 5), np.uint8)
+ activations = cv2.dilate(activations, kernel=kernel)
+ activations = cv2.erode(activations, kernel=kernel)
+
+ # Binarize the activations
+ _, activations = cv2.threshold(activations, 0.65, 1, type=cv2.THRESH_BINARY)
+ activations = activations.astype(np.uint8).copy()
+
+ # Find the contour of the binary blob
+ contours, _ = cv2.findContours(
+ activations, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_SIMPLE,
+ )
+
+ # Find bounding box around the object.
+ rect = cv2.boundingRect(contours[0])
+ return Rect(rect[0], rect[1], rect[0] + rect[2], rect[1] + rect[3])
+
+
+def normalize(activations):
+ activations = activations - np.min(activations[:])
+ activations = activations / np.max(activations[:])
+ return activations
+
+
+def visualize_activations(image, activations, show_bounding_rect=False):
+ activations = normalize(activations)
+
+ activations_multichannel = np.stack([activations, activations, activations], axis=2)
+ masked_image = (image * activations_multichannel).astype(np.uint8)
+
+ if show_bounding_rect:
+ rect = find_rect(activations.numpy())
+ cv2.rectangle(
+ masked_image,
+ (rect.x1, rect.y1),
+ (rect.x2, rect.y2),
+ color=(0, 0, 255),
+ thickness=2,
+ )
+
+ return masked_image
+
+
+def run_resnet_inference(original_image):
+
+ # read ImageNet class ids to a list of labels
+ with open("imagenet_classes.txt") as f:
+ labels = [line.strip() for line in f.readlines()]
+
+ # convert image to the RGB format
+ image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
+
+ # pre-process image
+ image = preprocess_input(image)
+
+ # convert image to NCHW tf.tensor
+ image = tf.expand_dims(image, 0)
+
+ # load resnet50 model with pretrained ImageNet weights
+ model = fully_convolutional_resnet50(input_shape=(image.shape[-3:]))
+
+ # Perform inference.
+ # Instead of a 1×1000 vector, we will get a
+ # 1×1000×n×m output ( i.e. a probability map
+ # of size n × m for each 1000 class,
+ # where n and m depend on the size of the image).
+ preds = model.predict(image)
+ preds = tf.transpose(preds, perm=[0, 3, 1, 2])
+ preds = tf.nn.softmax(preds, axis=1)
+ print("Response map shape : ", preds.shape)
+
+ # find class with the maximum score in the n × m output map
+ pred = tf.math.reduce_max(preds, axis=1)
+ class_idx = tf.math.argmax(preds, axis=1)
+
+ row_max = tf.math.reduce_max(pred, axis=1)
+ row_idx = tf.math.argmax(pred, axis=1)
+
+ col_idx = tf.math.argmax(row_max, axis=1)
+
+ predicted_class = tf.gather_nd(
+ class_idx, (0, tf.gather_nd(row_idx, (0, col_idx[0])), col_idx[0]),
+ )
+
+ # print the top predicted class
+ print("Predicted Class : ", labels[predicted_class], predicted_class)
+
+ # find the n × m score map for the predicted class
+ score_map = tf.expand_dims(preds[0, predicted_class, :, :], 0).numpy()
+ print("Score Map shape : ", score_map.shape)
+
+ # compute the receptive filed for max activation pixel
+ receptive_field_max_activation = backprop_receptive_field(
+ image,
+ scoremap=score_map,
+ predicted_class=predicted_class,
+ use_max_activation=True,
+ )
+ # compute the receptive filed for the whole image
+ receptive_field_image = backprop_receptive_field(
+ image,
+ scoremap=score_map,
+ predicted_class=predicted_class,
+ use_max_activation=False,
+ )
+
+ # resize score map to the original image size
+ score_map = score_map[0]
+ score_map = cv2.resize(
+ score_map, (original_image.shape[1], original_image.shape[0]),
+ )
+
+ # display the images
+ cv2.imshow("Original Image", original_image)
+ cv2.imshow(
+ "Score map: activations and bbox",
+ visualize_activations(original_image, score_map),
+ )
+ cv2.imshow(
+ "receptive_field_max_activation",
+ visualize_activations(
+ original_image, receptive_field_max_activation, show_bounding_rect=True,
+ ),
+ )
+ cv2.imshow(
+ "receptive_field_the_whole_image",
+ visualize_activations(
+ original_image, receptive_field_image, show_bounding_rect=True,
+ ),
+ )
+ cv2.waitKey(0)
+
+
+def main():
+ # read the image
+ image_path = "camel.jpg"
+ image = cv2.imread(image_path)
+
+ # run inference
+ run_resnet_inference(image)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/TensorFlow-Receptive-Field-With-Backprop/requirements.txt b/TensorFlow-Receptive-Field-With-Backprop/requirements.txt
new file mode 100644
index 000000000..ab1f58a1c
--- /dev/null
+++ b/TensorFlow-Receptive-Field-With-Backprop/requirements.txt
@@ -0,0 +1,2 @@
+opencv-python>=3.4.1.15
+tensorflow==2.1.0
diff --git a/TensorFlow-Receptive-Field-With-Backprop/utils.py b/TensorFlow-Receptive-Field-With-Backprop/utils.py
new file mode 100644
index 000000000..ecd4b4f8f
--- /dev/null
+++ b/TensorFlow-Receptive-Field-With-Backprop/utils.py
@@ -0,0 +1,75 @@
+from tensorflow.keras.layers import (
+ Activation,
+ Add,
+ BatchNormalization,
+ Conv2D,
+)
+
+# https://github.com/tensorflow/tensorflow/blob/2b96f3662bd776e277f86997659e61046b56c315/tensorflow/python/keras/applications/resnet.py#L32
+BASE_WEIGHTS_PATH = (
+ "https://storage.googleapis.com/tensorflow/keras-applications/resnet/"
+)
+WEIGHTS_HASHES = {
+ "resnet50": "4d473c1dd8becc155b73f8504c6f6626",
+}
+
+
+# https://github.com/tensorflow/tensorflow/blob/2b96f3662bd776e277f86997659e61046b56c315/tensorflow/python/keras/applications/resnet.py#L262
+def stack1(x, filters, blocks, stride1=2, name=None):
+ """
+ A set of stacked residual blocks.
+ Arguments:
+ x: input tensor.
+ filters: integer, filters of the bottleneck layer in a block.
+ blocks: integer, blocks in the stacked blocks.
+ stride1: default 2, stride of the first layer in the first block.
+ name: string, stack label.
+ Returns:
+ Output tensor for the stacked blocks.
+ """
+ x = block1(x, filters, stride=stride1, name=name + "_block1")
+ for i in range(2, blocks + 1):
+ x = block1(x, filters, conv_shortcut=False, name=name + "_block" + str(i))
+ return x
+
+
+# https://github.com/tensorflow/tensorflow/blob/2b96f3662bd776e277f86997659e61046b56c315/tensorflow/python/keras/applications/resnet.py#L217
+def block1(x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None):
+ """
+ A residual block.
+ Arguments:
+ x: input tensor.
+ filters: integer, filters of the bottleneck layer.
+ kernel_size: default 3, kernel size of the bottleneck layer.
+ stride: default 1, stride of the first layer.
+ conv_shortcut: default True, use convolution shortcut if True,
+ otherwise identity shortcut.
+ name: string, block label.
+ Returns:
+ Output tensor for the residual block.
+ """
+ # channels_last format
+ bn_axis = 3
+
+ if conv_shortcut:
+ shortcut = Conv2D(4 * filters, 1, strides=stride, name=name + "_0_conv")(x)
+ shortcut = BatchNormalization(
+ axis=bn_axis, epsilon=1.001e-5, name=name + "_0_bn",
+ )(shortcut)
+ else:
+ shortcut = x
+
+ x = Conv2D(filters, 1, strides=stride, name=name + "_1_conv")(x)
+ x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name=name + "_1_bn")(x)
+ x = Activation("relu", name=name + "_1_relu")(x)
+
+ x = Conv2D(filters, kernel_size, padding="SAME", name=name + "_2_conv")(x)
+ x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name=name + "_2_bn")(x)
+ x = Activation("relu", name=name + "_2_relu")(x)
+
+ x = Conv2D(4 * filters, 1, name=name + "_3_conv")(x)
+ x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name=name + "_3_bn")(x)
+
+ x = Add(name=name + "_add")([shortcut, x])
+ x = Activation("relu", name=name + "_out")(x)
+ return x
diff --git a/Training_a_custom_hand_detector_with_dlib/Hand_Detector.svm b/Training_a_custom_hand_detector_with_dlib/Hand_Detector.svm
new file mode 100644
index 000000000..1fedce3fe
Binary files /dev/null and b/Training_a_custom_hand_detector_with_dlib/Hand_Detector.svm differ
diff --git a/Training_a_custom_hand_detector_with_dlib/Head_Detector.svm b/Training_a_custom_hand_detector_with_dlib/Head_Detector.svm
new file mode 100644
index 000000000..75934e5f0
Binary files /dev/null and b/Training_a_custom_hand_detector_with_dlib/Head_Detector.svm differ
diff --git a/Training_a_custom_hand_detector_with_dlib/README.md b/Training_a_custom_hand_detector_with_dlib/README.md
new file mode 100644
index 000000000..72f4d5652
--- /dev/null
+++ b/Training_a_custom_hand_detector_with_dlib/README.md
@@ -0,0 +1,19 @@
+# Training a Custom Object Detector with DLIB & Making Gesture Controlled Applications
+
+You can access the Tutorial for this repo [here](https://www.learnopencv.com/training-a-custom-object-detector-with-dlib-making-gesture-controlled-applications/).
+
+[Training a Custom Object Detector with DLIB & Making Gesture Controlled Applications Notebook](Training_a_custom_hand_Detector.ipynb)
+
+You can use the `.svm` models here but its best to train your own models. If you're unable to install dlib by doing `pip install dlib` then you should do: `pip install dlib==19.8.1`
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
+
+
+
+
+
+
+
diff --git a/Training_a_custom_hand_detector_with_dlib/Training_a_custom_hand_Detector.ipynb b/Training_a_custom_hand_detector_with_dlib/Training_a_custom_hand_Detector.ipynb
new file mode 100644
index 000000000..3ed4aed89
--- /dev/null
+++ b/Training_a_custom_hand_detector_with_dlib/Training_a_custom_hand_Detector.ipynb
@@ -0,0 +1,1186 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Training a Custom Hand Detector with Dlib \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Part 1 : Training a Custom Hand Detector with DLIB \n",
+ "- Step 1: Data Generation & Automatic Annotation.\n",
+ "- Step 2: Preprocessing Data.\n",
+ "- Step 3: Display Images (Optional)\n",
+ "- Step 4: Train the Detector.\n",
+ "- Step 5: Save & Evaluate the Detector.\n",
+ "- Step 6: Test the Trained Detector on Live Webcam.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Lets start by importing the required libraries"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Import Libraries\n",
+ "import dlib\n",
+ "import glob\n",
+ "import cv2\n",
+ "import os\n",
+ "import sys\n",
+ "import time\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "import pyautogui as pyg\n",
+ "import shutil"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 1: Data Generation & Automatic Annotation:\n",
+ "Normally when you're training a hand detector you're going to need several images of the hand and then you'll need to annotate them meaning you'll have to draw bounding boxes over the hand in each hand.\n",
+ "\n",
+ "So now you have two options:\n",
+ "\n",
+ "#### Option 1: Annotate Images Manually\n",
+ "\n",
+ "Record a video of yourself and in the video wave your hand, move it around, rotate a bit and so on but don't deform your hand (palm should face the camera each time). After the recording, split the video into images and then download an annotation tool. You can install labelimg (a popular annotation tool) by just doing: `pip install labelimg`. After that you have to annotate each image with a bounding box. Now depending upon the number of images this would probably take some hours.\n",
+ "\n",
+ "#### Option 2: Automate the Annotation Process\n",
+ "\n",
+ "A smarter way to go about is to automate this annotation process while you're collecting training images.\n",
+ "\n",
+ "How are we going to do that?\n",
+ "\n",
+ "Well, all you need to do is use a sliding window, I've already explained what a sliding window is above.\n",
+ "\n",
+ "Now what we're going to do is put our hand inside the window and whenever the window moves we will move our hand with it, after that is done we will save that image and the window box will be our annotated box.\n",
+ "\n",
+ "This way we will automate the annotation process. How cool is that.\n",
+ "\n",
+ "The script below does just that, it saves the images in the folder named `training_images` and appends the window box locations in a python list."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# If cleanup is True then the new images and annotations will be appended to previous ones\n",
+ "# If False then all previous images and annotations will be deleted.\n",
+ "cleanup = True\n",
+ "\n",
+ "# Set the window to a normal one so we can adjust it\n",
+ "cv2.namedWindow('frame', cv2.WINDOW_NORMAL)\n",
+ "\n",
+ "# Resize the window and adjust it to the center\n",
+ "# This is done so we're ready for capturing the images.\n",
+ "cv2.resizeWindow('frame', 1920,1080)\n",
+ "cv2.moveWindow(\"frame\", 0,0)\n",
+ "\n",
+ "# Initialize webcam\n",
+ "cap = cv2.VideoCapture(0,cv2.CAP_DSHOW)\n",
+ "\n",
+ "# Initalize sliding window's x1,y1\n",
+ "x1 ,y1 = 0,0\n",
+ "\n",
+ "# These will be the width and height of the sliding window.\n",
+ "window_width = 190#140 \n",
+ "window_height = 190\n",
+ "\n",
+ "# We will save images after every 4 frames\n",
+ "# This is done so we don't have lot's of duplicate images\n",
+ "skip_frames = 3\n",
+ "frame_gap = 0\n",
+ "\n",
+ "# This is the directory where our images will be stored\n",
+ "# Make sure to change both names if you're saving a different Detector\n",
+ "directory = 'train_images_h'\n",
+ "box_file = 'boxes_h.txt'\n",
+ "\n",
+ "# If cleanup is True then delete all imaages and bounding_box annotations.\n",
+ "if cleanup:\n",
+ " \n",
+ " # Delete the images directory if it exists\n",
+ " if os.path.exists(directory):\n",
+ " shutil.rmtree(directory)\n",
+ " \n",
+ " # Clear up all previous bounding boxes\n",
+ " open(box_file, 'w').close()\n",
+ " \n",
+ " # Initialize the counter to 0\n",
+ " counter = 0\n",
+ " \n",
+ "elif os.path.exists(box_file):\n",
+ "\n",
+ " # If cleanup is false then we must append the new boxes with the old\n",
+ " with open(box_file,'r') as text_file:\n",
+ " box_content = text_file.read()\n",
+ " \n",
+ " # Set the counter to the previous highest checkpoint\n",
+ " counter = int(box_content.split(':')[-2].split(',')[-1])\n",
+ "\n",
+ "# Open up this text file or create it if it does not exists\n",
+ "fr = open(box_file, 'a')\n",
+ "\n",
+ "# Create our image directory if it does not exists.\n",
+ "if not os.path.exists(directory):\n",
+ " os.mkdir(directory)\n",
+ "\n",
+ "# Initial wait before you start recording each row\n",
+ "initial_wait = 0\n",
+ " \n",
+ "# Start the loop for the sliding window\n",
+ "while(True):\n",
+ " \n",
+ " # Start reading from camera\n",
+ " ret, frame = cap.read()\n",
+ " if not ret:\n",
+ " break\n",
+ " \n",
+ " # Invert the image laterally to get the mirror reflection.\n",
+ " frame = cv2.flip( frame, 1 )\n",
+ " \n",
+ " # Make a copy of the original frame\n",
+ " orig = frame.copy() \n",
+ " \n",
+ " # Wait the first 50 frames so that you can place your hand correctly\n",
+ " if initial_wait > 60:\n",
+ " \n",
+ " # Increment frame_gap by 1.\n",
+ " frame_gap +=1 \n",
+ " \n",
+ " # Move the window to the right by some amount in each iteration. \n",
+ " if x1 + window_width < frame.shape[1]:\n",
+ " x1 += 4\n",
+ " time.sleep(0.1) \n",
+ " \n",
+ " elif y1 + window_height + 270 < frame.shape[1]:\n",
+ "\n",
+ " # If the sliding_window has reached the end of the row then move down by some amount.\n",
+ " # Also start the window from start of the row\n",
+ " y1 += 80 \n",
+ " x1 = 0\n",
+ "\n",
+ " # Setting frame_gap and init_wait to 0.\n",
+ " # This is done so that the user has the time to place the hand correctly\n",
+ " # in the next row before image is saved.\n",
+ " frame_gap = 0\n",
+ " initial_wait = 0\n",
+ " \n",
+ " # Break the loop if we have gone over the whole screen.\n",
+ " else:\n",
+ " break\n",
+ " \n",
+ " else: \n",
+ " initial_wait += 1\n",
+ "\n",
+ " # Save the image every nth frame.\n",
+ " if frame_gap == skip_frames:\n",
+ "\n",
+ " # Set the image name equal to the counter value\n",
+ " img_name = str(counter) + '.png'\n",
+ "\n",
+ " # Save the Image in the defined directory\n",
+ " img_full_name = directory + '/' + str(counter) + '.png'\n",
+ " cv2.imwrite(img_full_name, orig)\n",
+ " \n",
+ " # Save the bounding box coordinates in the text file.\n",
+ " fr.write('{}:({},{},{},{}),'.format(counter, x1, y1, x1+window_width, y1+window_height))\n",
+ "\n",
+ " # Increment the counter \n",
+ " counter += 1\n",
+ "\n",
+ " # Set the frame_gap back to 0.\n",
+ " frame_gap = 0\n",
+ "\n",
+ " # Draw the sliding window\n",
+ " cv2.rectangle(frame,(x1,y1),(x1+window_width,y1+window_height),(0,255,0),3)\n",
+ " \n",
+ " # Display the frame\n",
+ " cv2.imshow('frame', frame)\n",
+ " if cv2.waitKey(1) == ord('q'):\n",
+ " break\n",
+ "\n",
+ "# Release camera and close the file and window\n",
+ "cap.release()\n",
+ "cv2.destroyAllWindows()\n",
+ "fr.close()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Note:** The Code above is structured in a way that when you run the code the second time it will append new images with the previous one, this is done so you can gather more samples at different places with different backgrounds, so you have diverse dataset. You can choose to delete all previous images by setting `clear_images` variable to `True`. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Before we move forward, you should also know that the detector we're training is not a full fledge hand detector but its actually a hand palm detector this is because a HOG + SVM model is not robust enough to capture the deformation of objects like a hand. If we were training a deep learning based detector then this wouldn't be much of an issue but for this case make sure you're not collecting images of deformed hands with different variations, make sure the palm is facing the camera. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Step 2: Preprocessing Data.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Before you start training you just need to load and preprocess the data (images and labels) slightly so they are in the required format.\n",
+ "\n",
+ "First we will extract all the image names from the images directory. Then we will use the indexes of those images to extract their associated bounding box. The bounding box will be converted to a dlib rectangle format and then the image and its box will be stored together in a dictionary in the format: `index: (image, bounding_box) ...` At the time of training we will separate the images from bounding_boxes, for now we'll keep them together.\n",
+ "\n",
+ "**Note:** You could get away by just reading in all images and labels directly from their locations in a list but its a bad practice since if you delete a single image from its directory after recording images. Then it would cause trouble. Ideally you should get rid of any image in `train_images` directory before training if you feel its not right."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# In this dictionary our images and annotations will be stored.\n",
+ "data = {}\n",
+ "\n",
+ "# Get the indexes of all images.\n",
+ "image_indexes = [int(img_name.split('.')[0]) for img_name in os.listdir(directory)]\n",
+ "\n",
+ "# Shuffle the indexes to have random train/test split later on.\n",
+ "np.random.shuffle(image_indexes)\n",
+ "\n",
+ "# Open and read the content of the boxes.txt file\n",
+ "f = open(box_file, \"r\")\n",
+ "box_content = f.read()\n",
+ "\n",
+ "# Convert the bounding boxes to dictionary in the format `index: (x1,y1,x2,y2)` ...\n",
+ "box_dict = eval( '{' +box_content + '}' )\n",
+ "\n",
+ "# Close the file\n",
+ "f.close()\n",
+ "\n",
+ "# Loop over all indexes\n",
+ "for index in image_indexes:\n",
+ " \n",
+ " # Read the image in memmory and append it to the list\n",
+ " img = cv2.imread(os.path.join(directory, str(index) + '.png')) \n",
+ " \n",
+ " # Read the associated bounding_box\n",
+ " bounding_box = box_dict[index]\n",
+ " \n",
+ " # Convert the bounding box to dlib format\n",
+ " x1, y1, x2, y2 = bounding_box\n",
+ " dlib_box = [ dlib.rectangle(left=x1 , top=y1, right=x2, bottom=y2) ]\n",
+ " \n",
+ " # Store the image and the box together\n",
+ " data[index] = (img, dlib_box)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's also check the total number of images and boxes present."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Number of Images and Boxes Present: 148\n"
+ ]
+ }
+ ],
+ "source": [
+ "print('Number of Images and Boxes Present: {}'.format(len(data)))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 3: Display Images (Optional)\n",
+ "\n",
+ "\n",
+ "You can optionally choose to display images along with their bounding box, this way you can visualize if the boxes were drawn properly or not."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "no_of_samples = 10\n",
+ "\n",
+ "image_names = os.listdir(directory)\n",
+ "\n",
+ "np.random.shuffle(data)\n",
+ "\n",
+ "# Extract the subset of boxes\n",
+ "#subset = data[][:no_of_samples ]\n",
+ "\n",
+ "cols = 5\n",
+ "\n",
+ "# Given the number of samples to display, what's the number of rows required.\n",
+ "rows = int(np.ceil(no_of_samples / cols))\n",
+ "\n",
+ "# Set the figure size\n",
+ "plt.figure(figsize=(cols*cols, rows*cols))\n",
+ "\n",
+ "#Loop for each class\n",
+ "for i in range(no_of_samples):\n",
+ " \n",
+ " # Extract the bonding box coordinates\n",
+ " d_box = data[i][1][0]\n",
+ " left, top, right,bottom = d_box.left(), d_box.top(), d_box.right(), d_box.bottom()\n",
+ " \n",
+ " # Get the image\n",
+ " image = data[i][0]\n",
+ " \n",
+ " # Draw reectangle on the detected hand\n",
+ " cv2.rectangle(image,(left,top),(right,bottom),(0,255,0),3)\n",
+ " \n",
+ " # Display the image\n",
+ " plt.subplot(rows,cols,i+1);plt.imshow(image[:,:,::-1]);plt.axis('off');"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Step 4: Train the Detector\n",
+ "\n",
+ "You can start training the detector by calling `dlib.train_simple_object_detector` and passing in a list of images and a list of associated dlib rectangles. First we will extract the images and bounding box rectangles from our dictionary and then pass it to the training function.\n",
+ "\n",
+ "Before you start training you can also specify other training options."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Training Completed, Total Time taken: 22.48 seconds\n"
+ ]
+ }
+ ],
+ "source": [
+ "# This is the percentage of data we will use to train\n",
+ "# The rest will be used for testing\n",
+ "percent = 0.8\n",
+ "\n",
+ "# How many examples make 80%.\n",
+ "split = int(len(data) * percent)\n",
+ "\n",
+ "# Seperate the images and bounding boxes in different lists.\n",
+ "images = [tuple_value[0] for tuple_value in data.values()]\n",
+ "bounding_boxes = [tuple_value[1] for tuple_value in data.values()]\n",
+ "\n",
+ "# Initialize object detector Options\n",
+ "options = dlib.simple_object_detector_training_options()\n",
+ "\n",
+ "# I'm disabling the horizontal flipping, becauase it confuses the detector if you're training on few examples\n",
+ "# By doing this the detector will only detect left or right hand (whichever you trained on). \n",
+ "options.add_left_right_image_flips = False\n",
+ "\n",
+ "# Set the c parameter of SVM equal to 5\n",
+ "# A bigger C encourages the model to better fit the training data, it can lead to overfitting.\n",
+ "# So set an optimal C value via trail and error.\n",
+ "options.C = 5\n",
+ "\n",
+ "# Note the start time before training.\n",
+ "st = time.time()\n",
+ "\n",
+ "# You can start the training now\n",
+ "detector = dlib.train_simple_object_detector(images[:split], bounding_boxes[:split], options)\n",
+ "\n",
+ "# Print the Total time taken to train the detector\n",
+ "print('Training Completed, Total Time taken: {:.2f} seconds'.format(time.time() - st))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Step 5: Save & Evaluate the Detector."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Save The Trained Detector \n",
+ "You should now save the detector so you don't have to train it again the next time you want to use it. The extension of the model is `.svm` as in Support Vector Machine. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "file_name = 'Head_Detector.svm'\n",
+ "detector.save(file_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Check the Hog Descriptor:**\n",
+ "\n",
+ "You can even checkout the final hog descriptor from the code below, the descriptor should look something like the target object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "win_det = dlib.image_window()\n",
+ "win_det.set_image(detector)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Check Training Metrics \n",
+ "You can call `dlib.test_simple_object_detector()` to test your model on training data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Training Metrics: precision: 0.991379, recall: 0.974576, average precision: 0.974576\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Training Metrics: {}\".format(dlib.test_simple_object_detector(images[:split], bounding_boxes[:split], detector)))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Check Testing Metrics:\n",
+ "Similarly we can also check the testing accuracy by using the reamining 20% of the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Testing accuracy: precision: 1, recall: 0.933333, average precision: 0.933333\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Testing accuracy: {}\".format(dlib.test_simple_object_detector(images[split:], bounding_boxes[split:], detector)))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Train the Final Detector\n",
+ "We trained the model on 80% of the data, if you're satisfied with the metrics above then you now can retrain the detector on 100% of the data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "detector = dlib.train_simple_object_detector(images, bounding_boxes, options)\n",
+ "detector.save(file_name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "One thing you may have noted is that the precision of the model is pretty high, this is really good since we don't want any false positive when we try to gesture control games."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Step 6: Test the Trained Detector on Live Webcam.\n",
+ "\n",
+ "Finally let's test our detector. Now we're going to do inference with our trained detector. You can load the detector by calling `detector = dlib.simple_object_detector()` After loading the detector you can pass in a frame by doing `detector(frame)` and it will return the bounding box location of the hand if it was detected."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#file_name = 'Hand_Detector.svm'\n",
+ "\n",
+ "# Load our trained detector \n",
+ "detector = dlib.simple_object_detector(file_name)\n",
+ "\n",
+ "# Set the window name\n",
+ "cv2.namedWindow('frame', cv2.WINDOW_NORMAL)\n",
+ "\n",
+ "# Initialize webcam\n",
+ "cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)\n",
+ "\n",
+ "# Setting the downscaling size, for faster detection\n",
+ "# If you're not getting any detections then you can set this to 1\n",
+ "scale_factor = 2.0\n",
+ "\n",
+ "# Initially the size of the hand and its center x point will be 0\n",
+ "size, center_x = 0,0\n",
+ "\n",
+ "# Initialize these variables for calculating FPS\n",
+ "fps = 0 \n",
+ "frame_counter = 0\n",
+ "start_time = time.time()\n",
+ "\n",
+ "# Set the while loop\n",
+ "while(True):\n",
+ " \n",
+ " # Read frame by frame\n",
+ " ret, frame = cap.read()\n",
+ " \n",
+ " if not ret:\n",
+ " break\n",
+ " \n",
+ " # Laterally flip the frame\n",
+ " frame = cv2.flip( frame, 1 )\n",
+ " \n",
+ " # Calculate the Average FPS\n",
+ " frame_counter += 1\n",
+ " fps = (frame_counter / (time.time() - start_time))\n",
+ " \n",
+ " # Create a clean copy of the frame\n",
+ " copy = frame.copy() \n",
+ " \n",
+ " # Downsize the frame.\n",
+ " new_width = int(frame.shape[1]/scale_factor)\n",
+ " new_height = int(frame.shape[0]/scale_factor)\n",
+ " resized_frame = cv2.resize(copy, (new_width, new_height))\n",
+ " \n",
+ " # Detect with detector\n",
+ " detections = detector(resized_frame)\n",
+ " \n",
+ " # Loop for each detection.\n",
+ " for detection in (detections): \n",
+ " \n",
+ " # Since we downscaled the image we will need to resacle the coordinates according to the original image.\n",
+ " x1 = int(detection.left() * scale_factor )\n",
+ " y1 = int(detection.top() * scale_factor )\n",
+ " x2 = int(detection.right() * scale_factor )\n",
+ " y2 = int(detection.bottom()* scale_factor )\n",
+ " \n",
+ " # Draw the bounding box\n",
+ " cv2.rectangle(frame,(x1,y1),(x2,y2),(0,255,0), 2 )\n",
+ " cv2.putText(frame, 'Hand Detected', (x1, y2+20), cv2.FONT_HERSHEY_COMPLEX, 0.6, (0, 0, 255),2)\n",
+ "\n",
+ " # Calculate size of the hand. \n",
+ " size = int( (x2 - x1) * (y2-y1) )\n",
+ " \n",
+ " # Extract the center of the hand on x-axis.\n",
+ " center_x = x2 - x1 // 2\n",
+ " \n",
+ " # Display FPS and size of hand\n",
+ " cv2.putText(frame, 'FPS: {:.2f}'.format(fps), (20, 20), cv2.FONT_HERSHEY_COMPLEX, 0.6, (0, 0, 255),2)\n",
+ "\n",
+ " # This information is useful for when you'll be building hand gesture applications\n",
+ " cv2.putText(frame, 'Center: {}'.format(center_x), (540, 20), cv2.FONT_HERSHEY_COMPLEX, 0.5, (233, 100, 25))\n",
+ " cv2.putText(frame, 'size: {}'.format(size), (540, 40), cv2.FONT_HERSHEY_COMPLEX, 0.5, (233, 100, 25))\n",
+ " \n",
+ " # Display the image\n",
+ " cv2.imshow('frame',frame)\n",
+ " \n",
+ " if cv2.waitKey(1) & 0xFF == ord('q'):\n",
+ " break\n",
+ "\n",
+ "# Relase the webcam and destroy all windows\n",
+ "cap.release()\n",
+ "cv2.destroyAllWindows()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If you noticed above I actually down sized the frame by factor of 2 before passing it to the detector.\n",
+ "\n",
+ "Why did I do that?\n",
+ "\n",
+ "Well remember that our HOG + SVM is actually a classifier, the things that allows it to become a detector are sliding windows and image pyramids. Now we already have seen that bigger an image is, the more time a sliding window is going to take to go over its rows and columns so its safe to say that our detector will run faster if the frame is small.\n",
+ "\n",
+ "This is the reason we are downsizing the frames. Although if you downsize too much then the detector's accuracy will be effected, you will need to figure out the right scaling factor, in my case a factor of 2.0 which reduces the size by 50% gives the best balance of speed and accuracy. \n",
+ "\n",
+ "After you have resized the image and perform detection, you then must resacle the detected coordinates according to the original image. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Using Multiple Object Detectors Together:\n",
+ "\n",
+ "Now if you wanted to train a detector on multiple classes and not just hands then unfortunately you can't just do that. The only way to do that is to train multiple detectors and run them simultaneously, This of course will significantly reduce your speed.\n",
+ "\n",
+ "There is a silver lining here which is that dlib comes with a function called `dlib.fhog_object_detector.run_multiple()` which allows you to run multiple object detectors simultaneously in an efficient way. Of course the more detectors you add, the slower your code gets. This method also gives you confidence scores for each detection.\n",
+ "\n",
+ "Here’s an example of me using two detectors One is trained on my hand and one on my face."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Load our trained detector \n",
+ "detector = dlib.simple_object_detector(file_name)\n",
+ "\n",
+ "# Set the window to normal\n",
+ "cv2.namedWindow('frame', cv2.WINDOW_NORMAL)\n",
+ "\n",
+ "# Initialize webcam\n",
+ "cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)\n",
+ "\n",
+ "# Setting the downscaling size, for faster detection\n",
+ "# If you're not getting any detections then you can set this to 1\n",
+ "scale_factor = 2.0\n",
+ "\n",
+ "# Initially the size of the hand and its center x point will be 0\n",
+ "size, center_x = 0,0\n",
+ "\n",
+ "# Initialize these variables for calculating FPS\n",
+ "fps = 0 \n",
+ "frame_counter = 0\n",
+ "start_time = time.time()\n",
+ "\n",
+ "# load up all the detectors using this function.\n",
+ "hand_detector = dlib.fhog_object_detector(\"Hand_Detector.svm\")\n",
+ "head_detector = dlib.fhog_object_detector(\"Head_Detector.svm\") \n",
+ "\n",
+ "# Now insert all detectors in a list\n",
+ "detectors = [hand_detector, head_detector]\n",
+ "\n",
+ "# Create a list of detector names in the same order\n",
+ "names = ['Hand Detected', 'Head Detected']\n",
+ "\n",
+ "\n",
+ "# Set the while loop\n",
+ "while(True):\n",
+ " \n",
+ " # Read frame by frame\n",
+ " ret, frame = cap.read()\n",
+ " \n",
+ " if not ret:\n",
+ " break\n",
+ " \n",
+ " # Laterally flip the frame\n",
+ " frame = cv2.flip( frame, 1 )\n",
+ " \n",
+ " # Calculate the Average FPS\n",
+ " frame_counter += 1\n",
+ " fps = (frame_counter / (time.time() - start_time))\n",
+ " \n",
+ " # Create a clean copy of the frame\n",
+ " copy = frame.copy() \n",
+ " \n",
+ " # Downsize the frame.\n",
+ " new_width = int(frame.shape[1]/scale_factor)\n",
+ " new_height = int(frame.shape[0]/scale_factor)\n",
+ " resized_frame = cv2.resize(copy, (new_width, new_height))\n",
+ " \n",
+ " # Perform the Detection\n",
+ " # Beside's boxes you will also get confidence scores and ID's of the detector\n",
+ " [detections, confidences, detector_idxs] = dlib.fhog_object_detector.run_multiple(detectors, resized_frame, \n",
+ " upsample_num_times=1)\n",
+ " \n",
+ " # Loop for each detected box\n",
+ " for i in range(len(detections)): \n",
+ " \n",
+ " # Since we downscaled the image we will need to resacle the coordinates according to the original image.\n",
+ " x1 = int(detections[i].left() * scale_factor )\n",
+ " y1 = int(detections[i].top() * scale_factor )\n",
+ " x2 = int(detections[i].right() * scale_factor )\n",
+ " y2 = int(detections[i].bottom()* scale_factor )\n",
+ " \n",
+ " # Draw the bounding box with confidence scores and the names of the detector\n",
+ " cv2.rectangle(frame,(x1,y1),(x2,y2),(0,255,0), 2 )\n",
+ " cv2.putText(frame, '{}: {:.2f}%'.format(names[detector_idxs[i]], confidences[i]*100), (x1, y2+20), \n",
+ " cv2.FONT_HERSHEY_COMPLEX, 0.6, (0, 0, 255),2)\n",
+ "\n",
+ " # Calculate size of the hand. \n",
+ " size = int( (x2 - x1) * (y2-y1) )\n",
+ " \n",
+ " # Extract the center of the hand on x-axis.\n",
+ " center_x = int(x1 + (x2 - x1) / 2)\n",
+ " \n",
+ " # Display FPS and size of hand\n",
+ " cv2.putText(frame, 'FPS: {:.2f}'.format(fps), (20, 20), cv2.FONT_HERSHEY_COMPLEX, 0.6, (0, 0, 255),2)\n",
+ "\n",
+ " # This information is useful for when you'll be building hand gesture applications\n",
+ " cv2.putText(frame, 'Center: {}'.format(center_x), (540, 20), cv2.FONT_HERSHEY_COMPLEX, 0.5, (233, 100, 25))\n",
+ " cv2.putText(frame, 'size: {}'.format(size), (540, 40), cv2.FONT_HERSHEY_COMPLEX, 0.5, (233, 100, 25))\n",
+ " \n",
+ " # Display the image\n",
+ " cv2.imshow('frame',frame)\n",
+ " \n",
+ " if cv2.waitKey(1) & 0xFF == ord('q'):\n",
+ " break\n",
+ "\n",
+ "# Relase the webcam and destroy all windows\n",
+ "cap.release()\n",
+ "cv2.destroyAllWindows()"
+ ]
+ },
+ {
+ "attachments": {
+ "leftright.png": {
+ "image/png": "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"
+ },
+ "topdown.png": {
+ "image/png": "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"
+ }
+ },
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Part 2: Integrating Gesture controls with Applications. \n",
+ "\n",
+ "Now that we have learned how to train a single and multi Object Detector, lets move onto the fun part where we automate a game and a video player via hand gestures.\n",
+ "\n",
+ "For this tutorial I'll be controlling following two applications:\n",
+ "1. [VLC Media Player](https://vlc-media-player.en.softonic.com/)\n",
+ "2. [Temple Run Game](https://m.plonga.com/adventure/Temple-Run-2-Online-Tablet)\n",
+ "\n",
+ "In the part, I'll control the VLC media player to pause/play and move forward and backward. Then using the same code I'll control then in the second part I'll control a clone of the infamous temple run game.\n",
+ "\n",
+ "Ofcourse you can feel free to control other applications too.\n",
+ "\n",
+ "**So how are we going to accomplish this ?**\n",
+ "\n",
+ "We'll its pretty simple, We are going to use the pyautogui library. This library allows you to control keyboard buttons and mouse cursor programmatically. You can learn more about this [library here](https://pyautogui.readthedocs.io/en/latest/install.html).\n",
+ "\n",
+ "So now we'll make a program that when we move our hand to the left of the screen pyautogui will press the left arrow key and when the hand is moved to the right, right arrow key is pressed.\n",
+ "\n",
+ "\n",
+ "\n",
+ "Similarly If our hand is closer to the screen we'll want to press the Up button and the hand is further from the screen we'll want to press the down button.\n",
+ "\n",
+ "\n",
+ "\n",
+ "This can easily be accomplished by measuring the size of the bounding box of the hand. As the size increases or decreases when the hand moves closer or far from the camera. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Let's start with the code**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Tuning Our Thresholds:\n",
+ "Before we start controlling the game, we need to visualize how the buttons will be triggered and if our defined thresholds are correct. This script draws lines between thresholds and displays the buttons that should be pressed. If these default thresholds don't work for you then Change them, especially the `size_up_th` and `size_down_th`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Set these thresholds accordingly.\n",
+ "\n",
+ "# If hand size is larger than this then up, button is triggered\n",
+ "size_up_th = 80000\n",
+ "\n",
+ "# If hand size is smaller than this then down key is triggered\n",
+ "size_down_th = 25000\n",
+ "\n",
+ "# If the center_x location is less than this then left key is triggered\n",
+ "left = 160\n",
+ "\n",
+ "# If the center_x location is greater than this then right key is triggered\n",
+ "right = 480\n",
+ "\n",
+ "# Load our trained detector \n",
+ "detector = dlib.simple_object_detector('Hand_Detector.svm')\n",
+ "\n",
+ "# Set the window to normal\n",
+ "cv2.namedWindow('frame', cv2.WINDOW_NORMAL)\n",
+ "\n",
+ "# Initialize webcam\n",
+ "cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)\n",
+ "\n",
+ "# Setting the downscaling size, for faster detection\n",
+ "# If you're not getting any detections then you can set this to 1\n",
+ "scale_factor = 2.0\n",
+ "\n",
+ "# Initially the size of the hand and its center x point will be 0\n",
+ "size, center_x = 0,0\n",
+ "\n",
+ "# Initialize these variables for calculating FPS\n",
+ "fps = 0 \n",
+ "frame_counter = 0\n",
+ "start_time = time.time()\n",
+ "\n",
+ "# Set the while loop\n",
+ "while(True):\n",
+ " \n",
+ " # Read frame by frame\n",
+ " ret, frame = cap.read()\n",
+ " \n",
+ " if not ret:\n",
+ " break\n",
+ " \n",
+ " # Laterally flip the frame\n",
+ " frame = cv2.flip( frame, 1 )\n",
+ " \n",
+ " # Calculate the Average FPS\n",
+ " frame_counter += 1\n",
+ " fps = (frame_counter / (time.time() - start_time))\n",
+ " \n",
+ " # Create a clean copy of the frame\n",
+ " copy = frame.copy() \n",
+ " \n",
+ " # Downsize the frame.\n",
+ " new_width = int(frame.shape[1]/scale_factor)\n",
+ " new_height = int(frame.shape[0]/scale_factor)\n",
+ " resized_frame = cv2.resize(copy, (new_width, new_height))\n",
+ " \n",
+ " # Detect with detector\n",
+ " detections = detector(resized_frame)\n",
+ " \n",
+ " # Set Default values\n",
+ " text = 'No Hand Detected'\n",
+ " center_x = 0\n",
+ " size = 0\n",
+ "\n",
+ " # Loop for each detection.\n",
+ " for detection in (detections): \n",
+ " \n",
+ " # Since we downscaled the image we will need to resacle the coordinates according to the original image.\n",
+ " x1 = int(detection.left() * scale_factor )\n",
+ " y1 = int(detection.top() * scale_factor )\n",
+ " x2 = int(detection.right() * scale_factor )\n",
+ " y2 = int(detection.bottom()* scale_factor )\n",
+ " \n",
+ " # Calculate size of the hand. \n",
+ " size = int( (x2 - x1) * (y2-y1) )\n",
+ " \n",
+ " # Extract the center of the hand on x-axis.\n",
+ " center_x = int(x1 + (x2 - x1) / 2)\n",
+ " \n",
+ " # Draw the bounding box of the detected hand\n",
+ " cv2.rectangle(frame,(x1,y1),(x2,y2),(0,255,0), 2 )\n",
+ " \n",
+ " # Now based on the size or center_x location set the required text\n",
+ " if center_x > right:\n",
+ " text = 'Right'\n",
+ "\n",
+ " elif center_x < left:\n",
+ " text = 'Left'\n",
+ "\n",
+ " elif size > size_up_th:\n",
+ " text = 'Up'\n",
+ "\n",
+ " elif size < size_down_th:\n",
+ " text = 'Down'\n",
+ " \n",
+ " else:\n",
+ " text = 'Neutral'\n",
+ " \n",
+ " # Now we should draw lines for left/right threshold\n",
+ " cv2.line(frame, (left,0),(left, frame.shape[0]),(25,25,255), 2)\n",
+ " cv2.line(frame, (right,0),(right, frame.shape[0]),(25,25,255), 2) \n",
+ "\n",
+ " # Display Center_x value and size.\n",
+ " cv2.putText(frame, 'Center: {}'.format(center_x), (500, 20), cv2.FONT_HERSHEY_COMPLEX, 0.6, (233, 100, 25), 1)\n",
+ " cv2.putText(frame, 'size: {}'.format(size), (500, 40), cv2.FONT_HERSHEY_COMPLEX, 0.6, (233, 100, 25))\n",
+ "\n",
+ " # Finally display the text showing which key should be triggered\n",
+ " cv2.putText(frame, text, (220, 30), cv2.FONT_HERSHEY_COMPLEX, 0.7, (33, 100, 185), 2)\n",
+ "\n",
+ " # Display the image\n",
+ " cv2.imshow('frame',frame)\n",
+ "\n",
+ " if cv2.waitKey(1) & 0xFF == ord('q'):\n",
+ " break\n",
+ "\n",
+ "# Relase the webcam and destroy all windows\n",
+ "cap.release()\n",
+ "cv2.destroyAllWindows() "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Make sure you're satisfied with the above results and the keys are triggered correctly based on the location of your hand, if not then change the thresholds, if you're facing trouble detecting the hand then you have to train the detector again with more examples.**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now that we have configured our thresholds we will make a script that will press the required button based on those thresholds. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Main Function\n",
+ "\n",
+ "This is our main script which will control the keyboard keys based on the hand movement. Now with this script I've controlled both the temple run game and the VLC media player.\n",
+ "\n",
+ "When controlling the media player I make the variable `player = True`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Load our trained detector \n",
+ "detector = dlib.simple_object_detector('Hand_Detector.svm')\n",
+ "\n",
+ "# Initialize webcam\n",
+ "cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)\n",
+ "\n",
+ "# Setting the downscaling size, for faster detection\n",
+ "# If you're not getting any detections then you can set this to 1\n",
+ "scale_factor = 2.0\n",
+ "\n",
+ "# Initially the size of the hand and its center x point will be 0\n",
+ "size, center_x = 0,0\n",
+ "\n",
+ "# Initialize these variables for calculating FPS\n",
+ "fps = 0 \n",
+ "frame_counter = 0\n",
+ "start_time = time.time()\n",
+ "\n",
+ "# Set Player = True in order to use this script for the VLC video palyer\n",
+ "player = True\n",
+ "\n",
+ "# This variable is True when we press a key and False when there is no detection.\n",
+ "# Its only used in the video Player\n",
+ "status = False\n",
+ "\n",
+ "# We're recording the whole screen to view it later\n",
+ "screen_width, screen_height = tuple(pyg.size())\n",
+ "out = cv2.VideoWriter(r'videorecord.mp4', cv2.VideoWriter_fourcc(*'XVID'), 15.0, (screen_width,screen_height ))\n",
+ "\n",
+ "# Set the while loop\n",
+ "while(True):\n",
+ " \n",
+ " try:\n",
+ " \n",
+ " # Read frame by frame\n",
+ " ret, frame = cap.read()\n",
+ "\n",
+ " if not ret:\n",
+ " break\n",
+ "\n",
+ " # Laterally flip the frame\n",
+ " frame = cv2.flip( frame, 1 )\n",
+ "\n",
+ " # Calculate the Average FPS\n",
+ " frame_counter += 1\n",
+ " fps = (frame_counter / (time.time() - start_time))\n",
+ "\n",
+ " # Create a clean copy of the frame\n",
+ " copy = frame.copy() \n",
+ "\n",
+ " # Downsize the frame.\n",
+ " new_width = int(frame.shape[1]/scale_factor)\n",
+ " new_height = int(frame.shape[0]/scale_factor)\n",
+ " resized_frame = cv2.resize(copy, (new_width, new_height))\n",
+ "\n",
+ " # Detect with detector\n",
+ " detections = detector(resized_frame)\n",
+ " \n",
+ " # Key will initially be None\n",
+ " key = None\n",
+ "\n",
+ " if len(detections) > 0:\n",
+ " \n",
+ " # Grab the first detection\n",
+ " detection = detections[0]\n",
+ "\n",
+ " # Since we downscaled the image we will need to resacle the coordinates according to the original image.\n",
+ " x1 = int(detection.left() * scale_factor )\n",
+ " y1 = int(detection.top() * scale_factor )\n",
+ " x2 = int(detection.right() * scale_factor )\n",
+ " y2 = int(detection.bottom()* scale_factor )\n",
+ " \n",
+ " cv2.rectangle(frame,(x1,y1),(x2,y2),(0,255,0), 2 )\n",
+ " cv2.putText(frame, 'Hand Detected', (x1, y2+20), cv2.FONT_HERSHEY_COMPLEX, 0.6, (0, 0, 255),2)\n",
+ "\n",
+ " # Calculate size of the hand. \n",
+ " size = int( (x2 - x1) * (y2-y1) )\n",
+ "\n",
+ " # Extract the center of the hand on x-axis.\n",
+ " center_x = int(x1 + (x2 - x1) / 2)\n",
+ "\n",
+ " # Press the requird button based on center_x location and size \n",
+ " # The behaviour of keys will be different depending upon if we're controlling a game or a video player.\n",
+ " # The status variable makes sure we do not double press the key in case of a video player.\n",
+ "\n",
+ " if center_x > right:\n",
+ " \n",
+ " key = 'right'\n",
+ " if player and not status:\n",
+ " pyg.hotkey('ctrl', 'right') \n",
+ " status = True\n",
+ "\n",
+ " elif center_x < left:\n",
+ " \n",
+ " key = 'left' \n",
+ " if player and not status:\n",
+ " pyg.hotkey('ctrl', 'left')\n",
+ " status = True\n",
+ "\n",
+ " elif size > size_up_th:\n",
+ " \n",
+ " key = 'up'\n",
+ " if player and not status:\n",
+ " pyg.press('space')\n",
+ " status = True\n",
+ "\n",
+ " elif size < size_down_th:\n",
+ " key = 'down'\n",
+ " \n",
+ " # Check if we're playing a game then press the requried key\n",
+ " if key is not None and player == False: \n",
+ " pyg.press(key) \n",
+ " \n",
+ " # If there was'nt a detection then status is made False\n",
+ " else:\n",
+ " status = False\n",
+ " \n",
+ " \n",
+ " # Capture the screen\n",
+ " image = pyg.screenshot()\n",
+ " \n",
+ " # Convert to BGR, numpy array (Opencv format of image)\n",
+ " img = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)\n",
+ " \n",
+ " # Resize the camera frame and attach it to screen.\n",
+ " resized_frame = cv2.resize(frame, (0,0), fx=0.6, fy=0.6)\n",
+ " h = resized_frame.shape[0]\n",
+ " w = resized_frame.shape[1]\n",
+ " img[0:h, 0:w] = resized_frame\n",
+ " \n",
+ " # Save the video frame\n",
+ " out.write(img)\n",
+ " \n",
+ " #time.sleep(0.2)\n",
+ " except KeyboardInterrupt:\n",
+ " print('Releasing the Camera and exiting since the program was stopped')\n",
+ " cap.release()\n",
+ " out.release()\n",
+ " sys.exit()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Release the camera and the videowriter if the code above exited from an exception other than KeyboardInterrupt\n",
+ "cap.release()\n",
+ "out.release()"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.7.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Training_a_custom_hand_detector_with_dlib/boxes.txt b/Training_a_custom_hand_detector_with_dlib/boxes.txt
new file mode 100644
index 000000000..a2cb5dd0b
--- /dev/null
+++ b/Training_a_custom_hand_detector_with_dlib/boxes.txt
@@ -0,0 +1 @@
+0:(12,0,202,190),1:(24,0,214,190),2:(36,0,226,190),3:(48,0,238,190),4:(60,0,250,190),5:(72,0,262,190),6:(84,0,274,190),7:(96,0,286,190),8:(108,0,298,190),9:(120,0,310,190),10:(132,0,322,190),11:(144,0,334,190),12:(156,0,346,190),13:(168,0,358,190),14:(180,0,370,190),15:(192,0,382,190),16:(204,0,394,190),17:(216,0,406,190),18:(228,0,418,190),19:(240,0,430,190),20:(252,0,442,190),21:(264,0,454,190),22:(276,0,466,190),23:(288,0,478,190),24:(300,0,490,190),25:(312,0,502,190),26:(324,0,514,190),27:(336,0,526,190),28:(348,0,538,190),29:(360,0,550,190),30:(372,0,562,190),31:(384,0,574,190),32:(396,0,586,190),33:(408,0,598,190),34:(420,0,610,190),35:(432,0,622,190),36:(444,0,634,190),37:(12,80,202,270),38:(24,80,214,270),39:(36,80,226,270),40:(48,80,238,270),41:(60,80,250,270),42:(72,80,262,270),43:(84,80,274,270),44:(96,80,286,270),45:(108,80,298,270),46:(120,80,310,270),47:(132,80,322,270),48:(144,80,334,270),49:(156,80,346,270),50:(168,80,358,270),51:(180,80,370,270),52:(192,80,382,270),53:(204,80,394,270),54:(216,80,406,270),55:(228,80,418,270),56:(240,80,430,270),57:(252,80,442,270),58:(264,80,454,270),59:(276,80,466,270),60:(288,80,478,270),61:(300,80,490,270),62:(312,80,502,270),63:(324,80,514,270),64:(336,80,526,270),65:(348,80,538,270),66:(360,80,550,270),67:(372,80,562,270),68:(384,80,574,270),69:(396,80,586,270),70:(408,80,598,270),71:(420,80,610,270),72:(432,80,622,270),73:(444,80,634,270),74:(12,160,202,350),75:(24,160,214,350),76:(36,160,226,350),77:(48,160,238,350),78:(60,160,250,350),79:(72,160,262,350),80:(84,160,274,350),81:(96,160,286,350),82:(108,160,298,350),83:(120,160,310,350),84:(132,160,322,350),85:(144,160,334,350),86:(156,160,346,350),87:(168,160,358,350),88:(180,160,370,350),89:(192,160,382,350),90:(204,160,394,350),91:(216,160,406,350),92:(228,160,418,350),93:(240,160,430,350),94:(252,160,442,350),95:(264,160,454,350),96:(276,160,466,350),97:(288,160,478,350),98:(300,160,490,350),99:(312,160,502,350),100:(324,160,514,350),101:(336,160,526,350),102:(348,160,538,350),103:(360,160,550,350),104:(372,160,562,350),105:(384,160,574,350),106:(396,160,586,350),107:(408,160,598,350),108:(420,160,610,350),109:(432,160,622,350),110:(444,160,634,350),111:(12,240,202,430),112:(24,240,214,430),113:(36,240,226,430),114:(48,240,238,430),115:(60,240,250,430),116:(72,240,262,430),117:(84,240,274,430),118:(96,240,286,430),119:(108,240,298,430),120:(120,240,310,430),121:(132,240,322,430),122:(144,240,334,430),123:(156,240,346,430),124:(168,240,358,430),125:(180,240,370,430),126:(192,240,382,430),127:(204,240,394,430),128:(216,240,406,430),129:(228,240,418,430),130:(240,240,430,430),131:(252,240,442,430),132:(264,240,454,430),133:(276,240,466,430),134:(288,240,478,430),135:(300,240,490,430),136:(312,240,502,430),137:(324,240,514,430),138:(336,240,526,430),139:(348,240,538,430),140:(360,240,550,430),141:(372,240,562,430),142:(384,240,574,430),143:(396,240,586,430),144:(408,240,598,430),145:(420,240,610,430),146:(432,240,622,430),147:(444,240,634,430),
\ No newline at end of file
diff --git a/Training_a_custom_hand_detector_with_dlib/boxes_h.txt b/Training_a_custom_hand_detector_with_dlib/boxes_h.txt
new file mode 100644
index 000000000..a2cb5dd0b
--- /dev/null
+++ b/Training_a_custom_hand_detector_with_dlib/boxes_h.txt
@@ -0,0 +1 @@
+0:(12,0,202,190),1:(24,0,214,190),2:(36,0,226,190),3:(48,0,238,190),4:(60,0,250,190),5:(72,0,262,190),6:(84,0,274,190),7:(96,0,286,190),8:(108,0,298,190),9:(120,0,310,190),10:(132,0,322,190),11:(144,0,334,190),12:(156,0,346,190),13:(168,0,358,190),14:(180,0,370,190),15:(192,0,382,190),16:(204,0,394,190),17:(216,0,406,190),18:(228,0,418,190),19:(240,0,430,190),20:(252,0,442,190),21:(264,0,454,190),22:(276,0,466,190),23:(288,0,478,190),24:(300,0,490,190),25:(312,0,502,190),26:(324,0,514,190),27:(336,0,526,190),28:(348,0,538,190),29:(360,0,550,190),30:(372,0,562,190),31:(384,0,574,190),32:(396,0,586,190),33:(408,0,598,190),34:(420,0,610,190),35:(432,0,622,190),36:(444,0,634,190),37:(12,80,202,270),38:(24,80,214,270),39:(36,80,226,270),40:(48,80,238,270),41:(60,80,250,270),42:(72,80,262,270),43:(84,80,274,270),44:(96,80,286,270),45:(108,80,298,270),46:(120,80,310,270),47:(132,80,322,270),48:(144,80,334,270),49:(156,80,346,270),50:(168,80,358,270),51:(180,80,370,270),52:(192,80,382,270),53:(204,80,394,270),54:(216,80,406,270),55:(228,80,418,270),56:(240,80,430,270),57:(252,80,442,270),58:(264,80,454,270),59:(276,80,466,270),60:(288,80,478,270),61:(300,80,490,270),62:(312,80,502,270),63:(324,80,514,270),64:(336,80,526,270),65:(348,80,538,270),66:(360,80,550,270),67:(372,80,562,270),68:(384,80,574,270),69:(396,80,586,270),70:(408,80,598,270),71:(420,80,610,270),72:(432,80,622,270),73:(444,80,634,270),74:(12,160,202,350),75:(24,160,214,350),76:(36,160,226,350),77:(48,160,238,350),78:(60,160,250,350),79:(72,160,262,350),80:(84,160,274,350),81:(96,160,286,350),82:(108,160,298,350),83:(120,160,310,350),84:(132,160,322,350),85:(144,160,334,350),86:(156,160,346,350),87:(168,160,358,350),88:(180,160,370,350),89:(192,160,382,350),90:(204,160,394,350),91:(216,160,406,350),92:(228,160,418,350),93:(240,160,430,350),94:(252,160,442,350),95:(264,160,454,350),96:(276,160,466,350),97:(288,160,478,350),98:(300,160,490,350),99:(312,160,502,350),100:(324,160,514,350),101:(336,160,526,350),102:(348,160,538,350),103:(360,160,550,350),104:(372,160,562,350),105:(384,160,574,350),106:(396,160,586,350),107:(408,160,598,350),108:(420,160,610,350),109:(432,160,622,350),110:(444,160,634,350),111:(12,240,202,430),112:(24,240,214,430),113:(36,240,226,430),114:(48,240,238,430),115:(60,240,250,430),116:(72,240,262,430),117:(84,240,274,430),118:(96,240,286,430),119:(108,240,298,430),120:(120,240,310,430),121:(132,240,322,430),122:(144,240,334,430),123:(156,240,346,430),124:(168,240,358,430),125:(180,240,370,430),126:(192,240,382,430),127:(204,240,394,430),128:(216,240,406,430),129:(228,240,418,430),130:(240,240,430,430),131:(252,240,442,430),132:(264,240,454,430),133:(276,240,466,430),134:(288,240,478,430),135:(300,240,490,430),136:(312,240,502,430),137:(324,240,514,430),138:(336,240,526,430),139:(348,240,538,430),140:(360,240,550,430),141:(372,240,562,430),142:(384,240,574,430),143:(396,240,586,430),144:(408,240,598,430),145:(420,240,610,430),146:(432,240,622,430),147:(444,240,634,430),
\ No newline at end of file
diff --git a/Training_a_custom_hand_detector_with_dlib/requirements.txt b/Training_a_custom_hand_detector_with_dlib/requirements.txt
new file mode 100644
index 000000000..664d64cd7
--- /dev/null
+++ b/Training_a_custom_hand_detector_with_dlib/requirements.txt
@@ -0,0 +1,5 @@
+pyautogui==0.9.48
+matplotlib==3.1.0
+numpy==1.18.3
+opencv-contrib-python==4.3.0
+dlib==19.18.0
diff --git a/UI-cvui/canny.cpp b/UI-cvui/canny.cpp
index 6ec2b9784..a394c9165 100644
--- a/UI-cvui/canny.cpp
+++ b/UI-cvui/canny.cpp
@@ -26,7 +26,7 @@ int main(int argc, const char *argv[])
// Should we apply Canny edge?
if (use_canny) {
// Yes, we should apply it.
- cv::cvtColor(lena, frame, CV_BGR2GRAY);
+ cv::cvtColor(lena, frame, cv::COLOR_BGR2GRAY);
cv::Canny(frame, frame, low_threshold, high_threshold, 3);
} else {
// No, so just copy the original image to the displaying frame.
diff --git a/UI-cvui/cvui.h b/UI-cvui/cvui.h
index 269d2caa3..c1cd356c5 100644
--- a/UI-cvui/cvui.h
+++ b/UI-cvui/cvui.h
@@ -1715,7 +1715,7 @@ namespace render
// Then the filling.
theContent.x++; theContent.y++; theContent.width -= 2; theContent.height -= 2;
- cv::rectangle(aOverlay, theContent, cv::Scalar(0x31, 0x31, 0x31), CVUI_FILLED);
+ cv::rectangle(theBlock.where, theContent, cv::Scalar(0x31, 0x31, 0x31), CVUI_FILLED);
if (aTransparecy) {
theBlock.where.copyTo(aOverlay);
diff --git a/UnderstandingLensDistortion/CMakeLists.txt b/UnderstandingLensDistortion/CMakeLists.txt
new file mode 100644
index 000000000..3e64982fe
--- /dev/null
+++ b/UnderstandingLensDistortion/CMakeLists.txt
@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 2.8.12)
+
+set(CMAKE_CXX_STANDARD 14)
+
+PROJECT(cameracalib)
+
+find_package( OpenCV REQUIRED )
+
+include_directories( ${OpenCV_INCLUDE_DIRS})
+
+MACRO(add_example name)
+ ADD_EXECUTABLE(${name} ${name}.cpp)
+ TARGET_LINK_LIBRARIES(${name} ${OpenCV_LIBS})
+ENDMACRO()
+
+add_example(Undistort)
diff --git a/UnderstandingLensDistortion/README.md b/UnderstandingLensDistortion/README.md
new file mode 100644
index 000000000..0eeaff5d0
--- /dev/null
+++ b/UnderstandingLensDistortion/README.md
@@ -0,0 +1,40 @@
+# Understanding Lens Distortion
+
+Understanding lens distortion using OpenCV.
+
+## Using the C++ code
+### Compilation
+To compile the `Undistort.cpp` code file, use the following:
+```shell
+mkdir build
+cd build
+cmake ..
+cmake --build . --config Release
+```
+## Usage
+
+### Using the C++ code
+
+Refer to the following to use the compiled file:
+
+```shell
+./build/Undistort
+```
+
+### Using the python code
+
+Refer to the following to use the `Undistort.py` file:
+
+```shell
+python3 Undistort.py
+```
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
+
+
+
+
+
diff --git a/UnderstandingLensDistortion/Undistort.cpp b/UnderstandingLensDistortion/Undistort.cpp
new file mode 100644
index 000000000..a32b3f87c
--- /dev/null
+++ b/UnderstandingLensDistortion/Undistort.cpp
@@ -0,0 +1,114 @@
+#include
+#include
+#include
+#include
+#include
+#include
+
+// Defining the dimensions of checkerboard
+int CHECKERBOARD[2]{6,9};
+
+int main()
+{
+ // Creating vector to store vectors of 3D points for each checkerboard image
+ std::vector > objpoints;
+
+ // Creating vector to store vectors of 2D points for each checkerboard image
+ std::vector > imgpoints;
+
+ // Defining the world coordinates for 3D points
+ std::vector objp;
+ for(int i{0}; i images;
+ // Path of the folder containing checkerboard images
+ std::string path = "./images/*.jpg";
+
+ cv::glob(path, images);
+
+ cv::Mat frame, gray;
+ // vector to store the pixel coordinates of detected checker board corners
+ std::vector corner_pts;
+ bool success;
+
+ // Looping over all the images in the directory
+ for(int i{0}; i &trainCells, vector &testCells,vector &trainLabels, vector &testLabels)
{
-
- Mat img = imread(pathName,CV_LOAD_IMAGE_GRAYSCALE);
+ Mat img = imread(pathName, cv::IMREAD_GRAYSCALE);
int ImgCount = 0;
for(int i = 0; i < img.rows; i = i + SZ)
{
@@ -46,7 +45,7 @@ void loadTrainTestLabel(string &pathName, vector &trainCells, vector &
ImgCount++;
}
}
-
+
cout << "Image Count : " << ImgCount << endl;
float digitClassNumber = 0;
@@ -66,7 +65,6 @@ void loadTrainTestLabel(string &pathName, vector &trainCells, vector &
}
void CreateDeskewedTrainTest(vector &deskewedTrainCells,vector &deskewedTestCells, vector &trainCells, vector &testCells){
-
for(int i=0;i &deskewedTrainCells,vector &deskew
}
HOGDescriptor hog(
- Size(20,20), //winSize
- Size(8,8), //blocksize
- Size(4,4), //blockStride,
- Size(8,8), //cellSize,
- 9, //nbins,
- 1, //derivAper,
- -1, //winSigma,
- 0, //histogramNormType,
- 0.2, //L2HysThresh,
- 0,//gammal correction,
- 64,//nlevels=64
- 1);
+ Size(20,20), //winSize
+ Size(8,8), //blocksize
+ Size(4,4), //blockStride,
+ Size(8,8), //cellSize,
+ 9, //nbins,
+ 1, //derivAper,
+ -1, //winSigma,
+ cv::HOGDescriptor::HistogramNormType::L2Hys, //histogramNormType,
+ 0.2, //L2HysThresh,
+ 0, //gammal correction,
+ 64, //nlevels=64
+ 1
+);
+
void CreateTrainTestHOG(vector > &trainHOG, vector > &testHOG, vector &deskewedtrainCells, vector &deskewedtestCells){
for(int y=0;y > &trainHOG, vector >
hog.compute(deskewedtrainCells[y],descriptors);
trainHOG.push_back(descriptors);
}
-
+
for(int y=0;y descriptors;
hog.compute(deskewedtestCells[y],descriptors);
testHOG.push_back(descriptors);
- }
+ }
}
+
void ConvertVectortoMatrix(vector > &trainHOG, vector > &testHOG, Mat &trainMat, Mat &testMat)
{
-
int descriptor_size = trainHOG[0].size();
-
+
for(int i = 0;i(i,j) = trainHOG[i][j];
+ trainMat.at(i,j) = trainHOG[i][j];
}
}
for(int i = 0;i(i,j) = testHOG[i][j];
+ testMat.at(i,j) = testHOG[i][j];
}
}
}
@@ -165,7 +165,7 @@ void SVMevaluate(Mat &testResponse, float &count, float &accuracy, vector &
{
// cout << testResponse.at(i,0) << " " << testLabels[i] << endl;
if(testResponse.at
+
+
+# Classifying Knee MRI images using Deep Learning
+
+**This repo contains code for the post [Stanford MRNet Challenge: Classifying Knee MRIs](https://www.learnopencv.com/stanford-mrnet-challenge-classifying-knee-mris/)**
+
+
+For details about the dataset and the competition, refer to https://stanfordmlgroup.github.io/competitions/mrnet/
+
+
+
+
+
+
+![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
+ ]
+},
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "T__5bQVhKp3r",
+ "colab_type": "text"
+ },
+ "source": [
+ "# Introduction\n",
+ "\n",
+ "In this notebook, we're going to apply experiment tracking to the Object Detection Task on COCO dataset using Torchvision. We are going to use the code from torchvision as is, we won't change anything as the idea is to show how an experiment logging functionality can be brought into some existing training framework."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "UhHQFy6P606e",
+ "colab_type": "text"
+ },
+ "source": [
+ "# Set everything up\n",
+ "\n",
+ "In this part, we are going to set up the environment, i.e. download the source\n",
+ "code, initialize functions, download and prepare COCO dataset and its annotations, install and import required libraries, and log in to the Weights & Biases tool."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "0SaKUS4EaZri",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Download torchvision code from sources\n",
+ "\n",
+ "Using the command below we'll download the detection task code from PyTorch repository. Please, visit [pytorch repository](https://github.com/pytorch/vision) for more information."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "hBvcjvZZapxb",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "!wget https://raw.githubusercontent.com/pytorch/vision/3974cfeb447be9f5ef1fc95e5c320f0498fe68ae/references/detection/coco_eval.py && \\\n",
+ " wget https://raw.githubusercontent.com/pytorch/vision/3974cfeb447be9f5ef1fc95e5c320f0498fe68ae/references/detection/coco_utils.py && \\\n",
+ " wget https://raw.githubusercontent.com/pytorch/vision/3974cfeb447be9f5ef1fc95e5c320f0498fe68ae/references/detection/engine.py && \\\n",
+ " wget https://raw.githubusercontent.com/pytorch/vision/3974cfeb447be9f5ef1fc95e5c320f0498fe68ae/references/detection/group_by_aspect_ratio.py && \\\n",
+ " wget https://raw.githubusercontent.com/pytorch/vision/3974cfeb447be9f5ef1fc95e5c320f0498fe68ae/references/detection/train.py && \\\n",
+ " wget https://raw.githubusercontent.com/pytorch/vision/3974cfeb447be9f5ef1fc95e5c320f0498fe68ae/references/detection/transforms.py && \\\n",
+ " wget https://raw.githubusercontent.com/pytorch/vision/3974cfeb447be9f5ef1fc95e5c320f0498fe68ae/references/detection/utils.py"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "5ZqebrClaIaX",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Download COCO dataset\n",
+ "In this section, we'll download COCO validation images and annotations. We're going to use the validation set for training and validation.\n",
+ "\n",
+ "**Please, don't do this in real life as models should be trained on training images and validated on the validation set. Otherwise, you'll face [overfitting](https://https://en.wikipedia.org/wiki/Overfitting)**. \n",
+ "\n",
+ "So we're using validation set for training because the complete dataset is very large and training on it will take a lot of time. While our goal is to show how the experiment logging works and we want to do it in a reasonable amount of time!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "d3Hbz3IMaugx",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "!mkdir coco && mkdir coco/annotations\n",
+ "\n",
+ "!wget http://images.cocodataset.org/zips/val2017.zip && \\\n",
+ " wget http://images.cocodataset.org/annotations/annotations_trainval2017.zip\n",
+ "\n",
+ "!unzip val2017.zip && unzip annotations_trainval2017.zip\n",
+ "\n",
+ "!cp -r val2017 coco/train2017\n",
+ "!cp annotations/instances_val2017.json coco/annotations/instances_val2017.json\n",
+ "\n",
+ "!mv val2017 coco/val2017\n",
+ "!mv annotations/instances_val2017.json coco/annotations/instances_train2017.json"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xUJAxouGjeAo",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Install required libraries"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "O6F5KFzSkYDx",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "!pip install numpy==1.17.3\n",
+ "!pip install tensorboardX==2.0\n",
+ "!pip install wandb==0.8.36"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Cn-BrTwM41tF",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Log in to Weights & Biases\n",
+ "\n",
+ "Please go to https://www.wandb.com/ and create an account if you don't have one yet. Then, you need to open https://app.wandb.ai/authorize to get the W&B API key to be able to start streaming logging to W&B. Paste an API key from your profile and hit enter after running the next cell."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "1zfNvGTqXtKT",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "!wandb login"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "dUDDmQe06yrt",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Import dependencies"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "G59dSjd06Xz_",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "import datetime\n",
+ "import math\n",
+ "import os\n",
+ "import os.path as osp\n",
+ "import sys\n",
+ "import time\n",
+ "\n",
+ "import tensorboardX\n",
+ "import torch\n",
+ "import torch.utils.data\n",
+ "import torchvision\n",
+ "import torchvision.models.detection\n",
+ "import torchvision.models.detection.mask_rcnn\n",
+ "import torchvision.models.detection.mask_rcnn\n",
+ "import wandb\n",
+ "\n",
+ "import utils\n",
+ "from coco_eval import CocoEvaluator\n",
+ "from coco_utils import get_coco_api_from_dataset\n",
+ "from engine import _get_iou_types\n",
+ "from group_by_aspect_ratio import GroupedBatchSampler, create_aspect_ratio_groups\n",
+ "from train import get_transform, get_dataset"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "n-lIOk1E_1gL",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Initialization"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FVMZRHjfKdFC",
+ "colab_type": "text"
+ },
+ "source": [
+ "### COCO labels\n",
+ "\n",
+ "Let's initialize mapping so as to be able to see human-readable labels."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "NvGt0crlJ8sw",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "# COCO labels mapping\n",
+ "COCO_INSTANCE_CATEGORY_NAMES = [\n",
+ " \"__background__\",\"person\",\"bicycle\",\"car\",\"motorcycle\",\"airplane\",\"bus\",\n",
+ " \"train\",\"truck\",\"boat\",\"trafficlight\",\"firehydrant\",\"N/A\",\"stopsign\",\n",
+ " \"parkingmeter\",\"bench\",\"bird\",\"cat\",\"dog\",\"horse\",\"sheep\",\"cow\",\"elephant\",\n",
+ " \"bear\",\"zebra\",\"giraffe\",\"N/A\",\"backpack\",\"umbrella\",\"N/A\",\"N/A\",\"handbag\",\n",
+ " \"tie\",\"suitcase\",\"frisbee\",\"skis\",\"snowboard\",\"sportsball\",\"kite\",\n",
+ " \"baseballbat\",\"baseballglove\",\"skateboard\",\"surfboard\",\"tennisracket\",\n",
+ " \"bottle\",\"N/A\",\"wineglass\",\"cup\",\"fork\",\"knife\",\"spoon\",\"bowl\",\"banana\",\n",
+ " \"apple\",\"sandwich\",\"orange\",\"broccoli\",\"carrot\",\"hotdog\",\"pizza\",\"donut\",\n",
+ " \"cake\",\"chair\",\"couch\",\"pottedplant\",\"bed\",\"N/A\",\"diningtable\",\"N/A\",\"N/A\",\n",
+ " \"toilet\",\"N/A\",\"tv\",\"laptop\",\"mouse\",\"remote\",\"keyboard\",\"cellphone\",\n",
+ " \"microwave\",\"oven\",\"toaster\",\"sink\",\"refrigerator\",\"N/A\",\"book\",\"clock\",\n",
+ " \"vase\",\"scissors\",\"teddybear\",\"hairdrier\",\"toothbrush\",\n",
+ "]"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Uh3zrzSKKTUE",
+ "colab_type": "text"
+ },
+ "source": [
+ "### Define main function\n",
+ "\n",
+ "Let's take the main function of the code from PyTorch detection as is."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "htq1VnoxKjHL",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "def main(args):\n",
+ " utils.init_distributed_mode(args)\n",
+ " print(args)\n",
+ "\n",
+ " device = torch.device(args.device)\n",
+ "\n",
+ " # Data loading code\n",
+ " print(\"Loading data\")\n",
+ "\n",
+ " dataset, num_classes = get_dataset(args.dataset, \"train\", get_transform(train=True), args.data_path)\n",
+ " dataset_test, _ = get_dataset(args.dataset, \"val\", get_transform(train=False), args.data_path)\n",
+ "\n",
+ " print(\"Creating data loaders\")\n",
+ " if args.distributed:\n",
+ " train_sampler = torch.utils.data.distributed.DistributedSampler(dataset)\n",
+ " test_sampler = torch.utils.data.distributed.DistributedSampler(dataset_test)\n",
+ " else:\n",
+ " train_sampler = torch.utils.data.RandomSampler(dataset)\n",
+ " test_sampler = torch.utils.data.SequentialSampler(dataset_test)\n",
+ "\n",
+ " if args.aspect_ratio_group_factor >= 0:\n",
+ " group_ids = create_aspect_ratio_groups(dataset, k=args.aspect_ratio_group_factor)\n",
+ " train_batch_sampler = GroupedBatchSampler(train_sampler, group_ids, args.batch_size)\n",
+ " else:\n",
+ " train_batch_sampler = torch.utils.data.BatchSampler(\n",
+ " train_sampler, args.batch_size, drop_last=True)\n",
+ "\n",
+ " data_loader = torch.utils.data.DataLoader(\n",
+ " dataset, batch_sampler=train_batch_sampler, num_workers=args.workers,\n",
+ " collate_fn=utils.collate_fn)\n",
+ "\n",
+ " data_loader_test = torch.utils.data.DataLoader(\n",
+ " dataset_test, batch_size=5,\n",
+ " sampler=test_sampler, num_workers=args.workers,\n",
+ " collate_fn=utils.collate_fn)\n",
+ "\n",
+ " print(\"Creating model\")\n",
+ " model = torchvision.models.detection.__dict__[args.model](num_classes=num_classes,\n",
+ " pretrained=args.pretrained)\n",
+ " model.to(device)\n",
+ "\n",
+ " model_without_ddp = model\n",
+ " if args.distributed:\n",
+ " model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu])\n",
+ " model_without_ddp = model.module\n",
+ "\n",
+ " params = [p for p in model.parameters() if p.requires_grad]\n",
+ " optimizer = torch.optim.SGD(\n",
+ " params, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay)\n",
+ "\n",
+ " # lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.lr_step_size, gamma=args.lr_gamma)\n",
+ " lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.lr_steps, gamma=args.lr_gamma)\n",
+ "\n",
+ " if args.resume:\n",
+ " checkpoint = torch.load(args.resume, map_location='cpu')\n",
+ " model_without_ddp.load_state_dict(checkpoint['model'])\n",
+ " optimizer.load_state_dict(checkpoint['optimizer'])\n",
+ " lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n",
+ " args.start_epoch = checkpoint['epoch'] + 1\n",
+ "\n",
+ " if args.test_only:\n",
+ " evaluate(model, data_loader_test, device=device)\n",
+ " return\n",
+ "\n",
+ " print(\"Start training\")\n",
+ " start_time = time.time()\n",
+ " for epoch in range(args.start_epoch, args.epochs):\n",
+ " if args.distributed:\n",
+ " train_sampler.set_epoch(epoch)\n",
+ " train_one_epoch(model, optimizer, data_loader, device, epoch, args.print_freq)\n",
+ " lr_scheduler.step()\n",
+ " if args.output_dir:\n",
+ " utils.save_on_master({\n",
+ " 'model': model_without_ddp.state_dict(),\n",
+ " 'optimizer': optimizer.state_dict(),\n",
+ " 'lr_scheduler': lr_scheduler.state_dict(),\n",
+ " 'args': args,\n",
+ " 'epoch': epoch},\n",
+ " os.path.join(args.output_dir, 'model_{}.pth'.format(epoch)))\n",
+ "\n",
+ " # evaluate after every epoch\n",
+ " evaluate(model, data_loader_test, device=device)\n",
+ "\n",
+ " total_time = time.time() - start_time\n",
+ " total_time_str = str(datetime.timedelta(seconds=int(total_time)))\n",
+ " print('Training time {}'.format(total_time_str))"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "mAt7M_0CLZjI",
+ "colab_type": "text"
+ },
+ "source": [
+ "# Logging\n",
+ "\n",
+ "In this part, we'll add TensorBoard and W&B logging to the original PyTorch detection code."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "auqJJWRJLKV5",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Define custom TensorBoard Summary Writer\n",
+ "\n",
+ "In the next cell, we'll extend the default Summary writer by adding the function that combines plots to subgroups by adding a prefix to a group of loss dictionary keys."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "p_Wa90RzLHwp",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "# create a new class inheriting from tensorboardX.SummaryWriter\n",
+ "class SummaryWriter(tensorboardX.SummaryWriter):\n",
+ " def __init__(self, log_dir=None, comment=\"\", **kwargs):\n",
+ " super().__init__(log_dir, comment, **kwargs)\n",
+ "\n",
+ " # create a new function that will take dictionary as input and uses built-in add_scalar() function\n",
+ " # that function combines all plots into one subgroup by a tag\n",
+ " def add_scalar_dict(self, dictionary, global_step, tag=None):\n",
+ " for name, val in dictionary.items():\n",
+ " if tag is not None:\n",
+ " name = osp.join(tag, name)\n",
+ " self.add_scalar(name, val.item(), global_step)"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "8xDcn0PaLmyx",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Applying logging"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FtnU6ZWj6WW5",
+ "colab_type": "text"
+ },
+ "source": [
+ "### Tracking loss in the training procedure\n",
+ "\n",
+ "We want TensorBoard to track the loss. In this section, we'll use our TensorBoard Summary Writer."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "IJ5raW_gIUnp",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "def train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq):\n",
+ " global global_iter\n",
+ " model.train()\n",
+ " metric_logger = utils.MetricLogger(delimiter=\" \")\n",
+ " metric_logger.add_meter('lr', utils.SmoothedValue(window_size=1, fmt='{value:.6f}'))\n",
+ " header = 'Epoch: [{}]'.format(epoch)\n",
+ "\n",
+ " lr_scheduler = None\n",
+ " if epoch == 0:\n",
+ " warmup_factor = 1. / 1000\n",
+ " warmup_iters = min(1000, len(data_loader) - 1)\n",
+ "\n",
+ " lr_scheduler = utils.warmup_lr_scheduler(optimizer, warmup_iters, warmup_factor)\n",
+ "\n",
+ " for images, targets in metric_logger.log_every(data_loader, print_freq, header):\n",
+ " images = list(image.to(device) for image in images)\n",
+ " targets = [{k: v.to(device) for k, v in t.items()} for t in targets]\n",
+ " loss_dict = model(images, targets)\n",
+ "\n",
+ " # ### OUR CODE ###\n",
+ " # let's track the losses here by adding scalars\n",
+ " logger.add_scalar_dict(\n",
+ " # passing the dictionary of losses (pairs - loss_key: loss_value)\n",
+ " loss_dict,\n",
+ " # passing the global step (number of iterations)\n",
+ " global_step=global_iter,\n",
+ " # adding the tag to combine plots in a subgroup\n",
+ " tag=\"loss\"\n",
+ " )\n",
+ " # incrementing the global step (number of iterations)\n",
+ " global_iter += 1\n",
+ " # ### END OF OUR CODE ###\n",
+ "\n",
+ " losses = sum(loss for loss in loss_dict.values())\n",
+ "\n",
+ " # reduce losses over all GPUs for logging purposes\n",
+ " loss_dict_reduced = utils.reduce_dict(loss_dict)\n",
+ " losses_reduced = sum(loss for loss in loss_dict_reduced.values())\n",
+ "\n",
+ " loss_value = losses_reduced.item()\n",
+ "\n",
+ " if not math.isfinite(loss_value):\n",
+ " print(\"Loss is {}, stopping training\".format(loss_value))\n",
+ " print(loss_dict_reduced)\n",
+ " sys.exit(1)\n",
+ "\n",
+ " optimizer.zero_grad()\n",
+ " losses.backward()\n",
+ " optimizer.step()\n",
+ "\n",
+ " if lr_scheduler is not None:\n",
+ " lr_scheduler.step()\n",
+ "\n",
+ " metric_logger.update(loss=losses_reduced, **loss_dict_reduced)\n",
+ " metric_logger.update(lr=optimizer.param_groups[0][\"lr\"])\n",
+ "\n",
+ " return metric_logger"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "BTSJr-n3MEVD",
+ "colab_type": "text"
+ },
+ "source": [
+ "### Visualizing predicted bounding boxes in the validation procedure\n",
+ "\n",
+ "In this part, we'll add the code saves the first 50 images with the predicted bounding boxes and labels for each epoch. That way we will be able to see how they are changing during the process."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "5f1cjABEMFRO",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "@torch.no_grad()\n",
+ "def evaluate(model, data_loader, device):\n",
+ " n_threads = torch.get_num_threads()\n",
+ " # FIXME remove this and make paste_masks_in_image run on the GPU\n",
+ " torch.set_num_threads(1)\n",
+ " cpu_device = torch.device(\"cpu\")\n",
+ " model.eval()\n",
+ " metric_logger = utils.MetricLogger(delimiter=\" \")\n",
+ " header = 'Test:'\n",
+ "\n",
+ " coco = get_coco_api_from_dataset(data_loader.dataset)\n",
+ " iou_types = _get_iou_types(model)\n",
+ " coco_evaluator = CocoEvaluator(coco, iou_types)\n",
+ "\n",
+ " # changing these two lines a bit to have iteration number and to keep image tensor\n",
+ " for i, (images, targets) in enumerate(metric_logger.log_every(data_loader, 100, header)):\n",
+ " img = images[0]\n",
+ "\n",
+ " images = list(img.to(device) for img in images)\n",
+ " targets = [{k: v.to(device) for k, v in t.items()} for t in targets]\n",
+ "\n",
+ " torch.cuda.synchronize()\n",
+ " model_time = time.time()\n",
+ " outputs = model(images)\n",
+ "\n",
+ " # ### OUR CODE ###\n",
+ " # let's track bounding box and labels predictions for the first 50 images\n",
+ " # as we hardly want to track all validation images\n",
+ " # but want to see how the predicted bounding boxes and labels are changing during the process\n",
+ " if i < 50:\n",
+ " # let's add tracking images with predicted bounding boxes\n",
+ " logger.add_image_with_boxes(\n",
+ " # adding pred_images tag to combine images in one subgroup\n",
+ " \"pred_images/PD-{}\".format(i),\n",
+ " # passing image tensor\n",
+ " img,\n",
+ " # passing predicted bounding boxes\n",
+ " outputs[0][\"boxes\"].cpu(),\n",
+ " # mapping & passing predicted labels\n",
+ " labels=[\n",
+ " COCO_INSTANCE_CATEGORY_NAMES[i]\n",
+ " for i in outputs[0][\"labels\"].cpu().numpy()\n",
+ " ],\n",
+ " )\n",
+ " # ### END OUR CODE ###\n",
+ " outputs = [{k: v.to(cpu_device) for k, v in t.items()} for t in outputs]\n",
+ " model_time = time.time() - model_time\n",
+ "\n",
+ " res = {target[\"image_id\"].item(): output for target, output in zip(targets, outputs)}\n",
+ " evaluator_time = time.time()\n",
+ " coco_evaluator.update(res)\n",
+ " evaluator_time = time.time() - evaluator_time\n",
+ " metric_logger.update(model_time=model_time, evaluator_time=evaluator_time)\n",
+ "\n",
+ " # gather the stats from all processes\n",
+ " metric_logger.synchronize_between_processes()\n",
+ " print(\"Averaged stats:\", metric_logger)\n",
+ " coco_evaluator.synchronize_between_processes()\n",
+ "\n",
+ " # accumulate predictions from all images\n",
+ " coco_evaluator.accumulate()\n",
+ " coco_evaluator.summarize()\n",
+ " torch.set_num_threads(n_threads)\n",
+ " return coco_evaluator"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-OtKa0GSM5tU",
+ "colab_type": "text"
+ },
+ "source": [
+ "### Saving config and COCO metrics\n",
+ "\n",
+ "Finally, we want to track the metric values and bind them to model hyperparameters. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "fqHEpFp_M4vY",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "class CocoEvaluator(CocoEvaluator):\n",
+ " def summarize(self):\n",
+ " global config, total_epochs\n",
+ " for iou_type, coco_eval in self.coco_eval.items():\n",
+ " print(\"IoU metric: {}\".format(iou_type))\n",
+ " coco_eval.summarize()\n",
+ " # ### OUR CODE ###\n",
+ " if iou_type == \"bbox\":\n",
+ " # let's add hyperparameters and bind them to metric values\n",
+ " logger.add_hparams(\n",
+ " # passing hyperparameters dictionary (in our case argparse values)\n",
+ " config,\n",
+ " # passing COCO metrics\n",
+ " {\n",
+ " \"AP/IoU/0.50-0.95/all/100\": coco_eval.stats[0],\n",
+ " \"AP/IoU/0.50/all/100\": coco_eval.stats[1],\n",
+ " \"AP/IoU/0.75/all/100\": coco_eval.stats[2],\n",
+ " \"AP/IoU/0.50-0.95/small/100\": coco_eval.stats[3],\n",
+ " \"AP/IoU/0.50-0.95/medium/100\": coco_eval.stats[4],\n",
+ " \"AP/IoU/0.50-0.95/large/100\": coco_eval.stats[5],\n",
+ " \"AR/IoU/0.50-0.95/all/1\": coco_eval.stats[6],\n",
+ " \"AR/IoU/0.50-0.95/all/10\": coco_eval.stats[7],\n",
+ " \"AR/IoU/0.50-0.95/all/100\": coco_eval.stats[8],\n",
+ " \"AR/IoU/0.50-0.95/small/100\": coco_eval.stats[9],\n",
+ " \"AR/IoU/0.50-0.95/medium/100\": coco_eval.stats[10],\n",
+ " \"AR/IoU/0.50-0.95/large/100\": coco_eval.stats[11],\n",
+ " },\n",
+ " name=\".\",\n",
+ " # passing the current iteration (epoch)\n",
+ " global_step=total_epochs,\n",
+ " )\n",
+ " # incrementing the number of epochs\n",
+ " total_epochs += 1\n",
+ " # ### END OF OUR CODE ###"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "N5ErQPjgNV7J",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Experiment setup\n",
+ "\n",
+ "Let's create some variables to keep everything organized. Usually, everything is stored in a config file but we use the PyTorch detection code as is and in the project, all hyperparameters are stored using Python argparse. We want to highlight everything that is used for experiment management so in the next cell, we'll create the following variables:\n",
+ "\n",
+ "\n",
+ "\n",
+ "* config - will be used as config i.e. argument dictionary in this project\n",
+ "* log_dir - the place where log files will be saved\n",
+ "* total_epochs - the number of epochs\n",
+ "* global_iter - the number of iterations\n",
+ "* logger - custom TensorBoard SummaryWriter that is used for logging"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "ElPLsK8EZ54b",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "# define variables as globals to have an access everywhere\n",
+ "config = None # will be replaced to argparse dictionary\n",
+ "total_epochs = 0 # init total number of epochs\n",
+ "global_iter = 0 # init total number of iterations\n",
+ "\n",
+ "name = \"exp-000\" # init experiment name\n",
+ "log_dir = \"experiments\" # init path where tensorboard logs will be stored\n",
+ "# (if log_dir is not specified writer object will automatically generate filename)\n",
+ "# Log files will be saved in 'experiments/exp-000'\n",
+ "# create our custom logger\n",
+ "logger = SummaryWriter(log_dir=osp.join(log_dir, name))"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "OzdzsBtgPTYw",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Config initialization\n",
+ "\n",
+ "Here, let's use the project's parser with default parameters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "Fj-W4GR_UOPf",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "import argparse\n",
+ "\n",
+ "parser = argparse.ArgumentParser(description=__doc__)\n",
+ "\n",
+ "parser.add_argument('--data-path', default='/datasets01/COCO/022719/', help='dataset')\n",
+ "parser.add_argument('--dataset', default='coco', help='dataset')\n",
+ "parser.add_argument('--model', default='maskrcnn_resnet50_fpn', help='model')\n",
+ "parser.add_argument('--device', default='cuda', help='device')\n",
+ "parser.add_argument('-b', '--batch-size', default=2, type=int,\n",
+ " help='images per gpu, the total batch size is $NGPU x batch_size')\n",
+ "parser.add_argument('--epochs', default=26, type=int, metavar='N',\n",
+ " help='number of total epochs to run')\n",
+ "parser.add_argument('-j', '--workers', default=4, type=int, metavar='N',\n",
+ " help='number of data loading workers (default: 4)')\n",
+ "parser.add_argument('--lr', default=0.02, type=float,\n",
+ " help='initial learning rate, 0.02 is the default value for training '\n",
+ " 'on 8 gpus and 2 images_per_gpu')\n",
+ "parser.add_argument('--momentum', default=0.9, type=float, metavar='M',\n",
+ " help='momentum')\n",
+ "parser.add_argument('--wd', '--weight-decay', default=1e-4, type=float,\n",
+ " metavar='W', help='weight decay (default: 1e-4)',\n",
+ " dest='weight_decay')\n",
+ "parser.add_argument('--lr-step-size', default=8, type=int, help='decrease lr every step-size epochs')\n",
+ "parser.add_argument('--lr-steps', default=[16, 22], nargs='+', type=int, help='decrease lr every step-size epochs')\n",
+ "parser.add_argument('--lr-gamma', default=0.1, type=float, help='decrease lr by a factor of lr-gamma')\n",
+ "parser.add_argument('--print-freq', default=20, type=int, help='print frequency')\n",
+ "parser.add_argument('--output-dir', default='.', help='path where to save')\n",
+ "parser.add_argument('--resume', default='', help='resume from checkpoint')\n",
+ "parser.add_argument('--start_epoch', default=0, type=int, help='start epoch')\n",
+ "parser.add_argument('--aspect-ratio-group-factor', default=3, type=int)\n",
+ "parser.add_argument(\n",
+ " \"--test-only\",\n",
+ " dest=\"test_only\",\n",
+ " help=\"Only test the model\",\n",
+ " action=\"store_true\",\n",
+ ")\n",
+ "parser.add_argument(\n",
+ " \"--pretrained\",\n",
+ " dest=\"pretrained\",\n",
+ " help=\"Use pre-trained models from the modelzoo\",\n",
+ " action=\"store_true\",\n",
+ ")\n",
+ "\n",
+ "# distributed training parameters\n",
+ "parser.add_argument('--world-size', default=1, type=int,\n",
+ " help='number of distributed processes')\n",
+ "parser.add_argument('--dist-url', default='env://', help='url used to set up distributed training')"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "b_OMSXLYP1KY",
+ "colab_type": "text"
+ },
+ "source": [
+ "Here we need to modify the default path with the path where the COCO **validation** dataset was unzipped. \n",
+ "\n",
+ "As the idea is to show how experiment management works in a reasonable time, we'll start with the pre-trained weights and will train the model on the validation set. As was mentioned before, **don't do this in real life as models should be trained on training images and validated on the validation set**. You'll see that metrics are increasing and it is expected because the model is trained and validated on the same data. We're doing this to save time! \n",
+ "\n",
+ "Also, we'll change learning rate to *0.0001* and increase batch size from *2* to *6*."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "aofDb-VcZmgk",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "args = parser.parse_args([\"--data-path\" ,'/content/coco', '--lr', \"1e-4\", '--pretrained', '--batch-size', \"6\"])\n",
+ "config = vars(args)"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1wEcq5w1QKJi",
+ "colab_type": "text"
+ },
+ "source": [
+ "## Weights & Biases synchronization\n",
+ "\n",
+ "The last thing that we need to do before training is to connect to the Weights & Biases. Fortunately, we don't need to do much since it can be done by adding just two lines of code:\n",
+ "\n",
+ "1. The first line initializes experiment with config and experiment name\n",
+ "2. The second line is used to enable TensorBoard synchronization"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "YqsHS8rfbDYh",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "wandb.init(config=config, name=name)\n",
+ "wandb.init(sync_tensorboard=True)"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "AJ7G6xx_Q4ov",
+ "colab_type": "text"
+ },
+ "source": [
+ "# Running train/val loop\n",
+ "\n",
+ "Here we go! Let's start the ball rolling. Please, visit [Weights & Biases](https://www.wandb.com/) to see how the experiment logging works in real-time!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "JhKTNZEnUg_g",
+ "colab_type": "code",
+ "colab": {}
+ },
+ "source": [
+ "main(args)"
+ ],
+ "execution_count": 0,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/PyTorch-Vision-Experiment-Logging/coco_eval.py b/PyTorch-Vision-Experiment-Logging/coco_eval.py
new file mode 100644
index 000000000..69bcc488a
--- /dev/null
+++ b/PyTorch-Vision-Experiment-Logging/coco_eval.py
@@ -0,0 +1,381 @@
+import json
+import tempfile
+
+import numpy as np
+import copy
+import time
+import torch
+import torch._six
+
+from pycocotools.cocoeval import COCOeval
+from pycocotools.coco import COCO
+import pycocotools.mask as mask_util
+
+from collections import defaultdict
+
+import utils
+
+# ### OUR CODE ###
+# let's import our tensorboard module to track metrics
+import tensorboard
+# ### END OF OUR CODE ###
+
+class CocoEvaluator(object):
+ def __init__(self, coco_gt, iou_types):
+ assert isinstance(iou_types, (list, tuple))
+ coco_gt = copy.deepcopy(coco_gt)
+ self.coco_gt = coco_gt
+
+ self.iou_types = iou_types
+ self.coco_eval = {}
+ for iou_type in iou_types:
+ self.coco_eval[iou_type] = COCOeval(coco_gt, iouType=iou_type)
+
+ self.img_ids = []
+ self.eval_imgs = {k: [] for k in iou_types}
+
+ def update(self, predictions):
+ img_ids = list(np.unique(list(predictions.keys())))
+ self.img_ids.extend(img_ids)
+
+ for iou_type in self.iou_types:
+ results = self.prepare(predictions, iou_type)
+ coco_dt = loadRes(self.coco_gt, results) if results else COCO()
+ coco_eval = self.coco_eval[iou_type]
+
+ coco_eval.cocoDt = coco_dt
+ coco_eval.params.imgIds = list(img_ids)
+ img_ids, eval_imgs = evaluate(coco_eval)
+
+ self.eval_imgs[iou_type].append(eval_imgs)
+
+ def synchronize_between_processes(self):
+ for iou_type in self.iou_types:
+ self.eval_imgs[iou_type] = np.concatenate(self.eval_imgs[iou_type], 2)
+ create_common_coco_eval(self.coco_eval[iou_type], self.img_ids, self.eval_imgs[iou_type])
+
+ def accumulate(self):
+ for coco_eval in self.coco_eval.values():
+ coco_eval.accumulate()
+
+ def summarize(self):
+ for iou_type, coco_eval in self.coco_eval.items():
+ print("IoU metric: {}".format(iou_type))
+ coco_eval.summarize()
+ # ### OUR CODE ###
+ if iou_type == "bbox":
+ # let's add hyperparameters and bind them to metric values
+ tensorboard.logger.add_hparams(
+ # passing hyperparameters dictionary (in our case argparse values)
+ tensorboard.args,
+ # passing COCO metrics
+ {
+ "AP/IoU/0.50-0.95/all/100": coco_eval.stats[0],
+ "AP/IoU/0.50/all/100": coco_eval.stats[1],
+ "AP/IoU/0.75/all/100": coco_eval.stats[2],
+ "AP/IoU/0.50-0.95/small/100": coco_eval.stats[3],
+ "AP/IoU/0.50-0.95/medium/100": coco_eval.stats[4],
+ "AP/IoU/0.50-0.95/large/100": coco_eval.stats[5],
+ "AR/IoU/0.50-0.95/all/1": coco_eval.stats[6],
+ "AR/IoU/0.50-0.95/all/10": coco_eval.stats[7],
+ "AR/IoU/0.50-0.95/all/100": coco_eval.stats[8],
+ "AR/IoU/0.50-0.95/small/100": coco_eval.stats[9],
+ "AR/IoU/0.50-0.95/medium/100": coco_eval.stats[10],
+ "AR/IoU/0.50-0.95/large/100": coco_eval.stats[11],
+ },
+ name=".",
+ # passing the current iteration (epoch)
+ global_step=tensorboard.total_epochs,
+ )
+ # incrementing the number of epochs
+ tensorboard.total_epochs += 1
+ # ### END OF OUR CODE ###
+
+ def prepare(self, predictions, iou_type):
+ if iou_type == "bbox":
+ return self.prepare_for_coco_detection(predictions)
+ elif iou_type == "segm":
+ return self.prepare_for_coco_segmentation(predictions)
+ elif iou_type == "keypoints":
+ return self.prepare_for_coco_keypoint(predictions)
+ else:
+ raise ValueError("Unknown iou type {}".format(iou_type))
+
+ def prepare_for_coco_detection(self, predictions):
+ coco_results = []
+ for original_id, prediction in predictions.items():
+ if len(prediction) == 0:
+ continue
+
+ boxes = prediction["boxes"]
+ boxes = convert_to_xywh(boxes).tolist()
+ scores = prediction["scores"].tolist()
+ labels = prediction["labels"].tolist()
+
+ coco_results.extend(
+ [
+ {
+ "image_id": original_id,
+ "category_id": labels[k],
+ "bbox": box,
+ "score": scores[k],
+ }
+ for k, box in enumerate(boxes)
+ ]
+ )
+ return coco_results
+
+ def prepare_for_coco_segmentation(self, predictions):
+ coco_results = []
+ for original_id, prediction in predictions.items():
+ if len(prediction) == 0:
+ continue
+
+ scores = prediction["scores"]
+ labels = prediction["labels"]
+ masks = prediction["masks"]
+
+ masks = masks > 0.5
+
+ scores = prediction["scores"].tolist()
+ labels = prediction["labels"].tolist()
+
+ rles = [
+ mask_util.encode(np.array(mask[0, :, :, np.newaxis], dtype=np.uint8, order="F"))[0]
+ for mask in masks
+ ]
+ for rle in rles:
+ rle["counts"] = rle["counts"].decode("utf-8")
+
+ coco_results.extend(
+ [
+ {
+ "image_id": original_id,
+ "category_id": labels[k],
+ "segmentation": rle,
+ "score": scores[k],
+ }
+ for k, rle in enumerate(rles)
+ ]
+ )
+ return coco_results
+
+ def prepare_for_coco_keypoint(self, predictions):
+ coco_results = []
+ for original_id, prediction in predictions.items():
+ if len(prediction) == 0:
+ continue
+
+ boxes = prediction["boxes"]
+ boxes = convert_to_xywh(boxes).tolist()
+ scores = prediction["scores"].tolist()
+ labels = prediction["labels"].tolist()
+ keypoints = prediction["keypoints"]
+ keypoints = keypoints.flatten(start_dim=1).tolist()
+
+ coco_results.extend(
+ [
+ {
+ "image_id": original_id,
+ "category_id": labels[k],
+ 'keypoints': keypoint,
+ "score": scores[k],
+ }
+ for k, keypoint in enumerate(keypoints)
+ ]
+ )
+ return coco_results
+
+
+def convert_to_xywh(boxes):
+ xmin, ymin, xmax, ymax = boxes.unbind(1)
+ return torch.stack((xmin, ymin, xmax - xmin, ymax - ymin), dim=1)
+
+
+def merge(img_ids, eval_imgs):
+ all_img_ids = utils.all_gather(img_ids)
+ all_eval_imgs = utils.all_gather(eval_imgs)
+
+ merged_img_ids = []
+ for p in all_img_ids:
+ merged_img_ids.extend(p)
+
+ merged_eval_imgs = []
+ for p in all_eval_imgs:
+ merged_eval_imgs.append(p)
+
+ merged_img_ids = np.array(merged_img_ids)
+ merged_eval_imgs = np.concatenate(merged_eval_imgs, 2)
+
+ # keep only unique (and in sorted order) images
+ merged_img_ids, idx = np.unique(merged_img_ids, return_index=True)
+ merged_eval_imgs = merged_eval_imgs[..., idx]
+
+ return merged_img_ids, merged_eval_imgs
+
+
+def create_common_coco_eval(coco_eval, img_ids, eval_imgs):
+ img_ids, eval_imgs = merge(img_ids, eval_imgs)
+ img_ids = list(img_ids)
+ eval_imgs = list(eval_imgs.flatten())
+
+ coco_eval.evalImgs = eval_imgs
+ coco_eval.params.imgIds = img_ids
+ coco_eval._paramsEval = copy.deepcopy(coco_eval.params)
+
+
+#################################################################
+# From pycocotools, just removed the prints and fixed
+# a Python3 bug about unicode not defined
+#################################################################
+
+# Ideally, pycocotools wouldn't have hard-coded prints
+# so that we could avoid copy-pasting those two functions
+
+def createIndex(self):
+ # create index
+ # print('creating index...')
+ anns, cats, imgs = {}, {}, {}
+ imgToAnns, catToImgs = defaultdict(list), defaultdict(list)
+ if 'annotations' in self.dataset:
+ for ann in self.dataset['annotations']:
+ imgToAnns[ann['image_id']].append(ann)
+ anns[ann['id']] = ann
+
+ if 'images' in self.dataset:
+ for img in self.dataset['images']:
+ imgs[img['id']] = img
+
+ if 'categories' in self.dataset:
+ for cat in self.dataset['categories']:
+ cats[cat['id']] = cat
+
+ if 'annotations' in self.dataset and 'categories' in self.dataset:
+ for ann in self.dataset['annotations']:
+ catToImgs[ann['category_id']].append(ann['image_id'])
+
+ # print('index created!')
+
+ # create class members
+ self.anns = anns
+ self.imgToAnns = imgToAnns
+ self.catToImgs = catToImgs
+ self.imgs = imgs
+ self.cats = cats
+
+
+maskUtils = mask_util
+
+
+def loadRes(self, resFile):
+ """
+ Load result file and return a result api object.
+ :param resFile (str) : file name of result file
+ :return: res (obj) : result api object
+ """
+ res = COCO()
+ res.dataset['images'] = [img for img in self.dataset['images']]
+
+ # print('Loading and preparing results...')
+ # tic = time.time()
+ if isinstance(resFile, torch._six.string_classes):
+ anns = json.load(open(resFile))
+ elif type(resFile) == np.ndarray:
+ anns = self.loadNumpyAnnotations(resFile)
+ else:
+ anns = resFile
+ assert type(anns) == list, 'results in not an array of objects'
+ annsImgIds = [ann['image_id'] for ann in anns]
+ assert set(annsImgIds) == (set(annsImgIds) & set(self.getImgIds())), \
+ 'Results do not correspond to current coco set'
+ if 'caption' in anns[0]:
+ imgIds = set([img['id'] for img in res.dataset['images']]) & set([ann['image_id'] for ann in anns])
+ res.dataset['images'] = [img for img in res.dataset['images'] if img['id'] in imgIds]
+ for id, ann in enumerate(anns):
+ ann['id'] = id + 1
+ elif 'bbox' in anns[0] and not anns[0]['bbox'] == []:
+ res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])
+ for id, ann in enumerate(anns):
+ bb = ann['bbox']
+ x1, x2, y1, y2 = [bb[0], bb[0] + bb[2], bb[1], bb[1] + bb[3]]
+ if 'segmentation' not in ann:
+ ann['segmentation'] = [[x1, y1, x1, y2, x2, y2, x2, y1]]
+ ann['area'] = bb[2] * bb[3]
+ ann['id'] = id + 1
+ ann['iscrowd'] = 0
+ elif 'segmentation' in anns[0]:
+ res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])
+ for id, ann in enumerate(anns):
+ # now only support compressed RLE format as segmentation results
+ ann['area'] = maskUtils.area(ann['segmentation'])
+ if 'bbox' not in ann:
+ ann['bbox'] = maskUtils.toBbox(ann['segmentation'])
+ ann['id'] = id + 1
+ ann['iscrowd'] = 0
+ elif 'keypoints' in anns[0]:
+ res.dataset['categories'] = copy.deepcopy(self.dataset['categories'])
+ for id, ann in enumerate(anns):
+ s = ann['keypoints']
+ x = s[0::3]
+ y = s[1::3]
+ x1, x2, y1, y2 = np.min(x), np.max(x), np.min(y), np.max(y)
+ ann['area'] = (x2 - x1) * (y2 - y1)
+ ann['id'] = id + 1
+ ann['bbox'] = [x1, y1, x2 - x1, y2 - y1]
+ # print('DONE (t={:0.2f}s)'.format(time.time()- tic))
+
+ res.dataset['annotations'] = anns
+ createIndex(res)
+ return res
+
+
+def evaluate(self):
+ '''
+ Run per image evaluation on given images and store results (a list of dict) in self.evalImgs
+ :return: None
+ '''
+ # tic = time.time()
+ # print('Running per image evaluation...')
+ p = self.params
+ # add backward compatibility if useSegm is specified in params
+ if p.useSegm is not None:
+ p.iouType = 'segm' if p.useSegm == 1 else 'bbox'
+ print('useSegm (deprecated) is not None. Running {} evaluation'.format(p.iouType))
+ # print('Evaluate annotation type *{}*'.format(p.iouType))
+ p.imgIds = list(np.unique(p.imgIds))
+ if p.useCats:
+ p.catIds = list(np.unique(p.catIds))
+ p.maxDets = sorted(p.maxDets)
+ self.params = p
+
+ self._prepare()
+ # loop through images, area range, max detection number
+ catIds = p.catIds if p.useCats else [-1]
+
+ if p.iouType == 'segm' or p.iouType == 'bbox':
+ computeIoU = self.computeIoU
+ elif p.iouType == 'keypoints':
+ computeIoU = self.computeOks
+ self.ious = {
+ (imgId, catId): computeIoU(imgId, catId)
+ for imgId in p.imgIds
+ for catId in catIds}
+
+ evaluateImg = self.evaluateImg
+ maxDet = p.maxDets[-1]
+ evalImgs = [
+ evaluateImg(imgId, catId, areaRng, maxDet)
+ for catId in catIds
+ for areaRng in p.areaRng
+ for imgId in p.imgIds
+ ]
+ # this is NOT in the pycocotools code, but could be done outside
+ evalImgs = np.asarray(evalImgs).reshape(len(catIds), len(p.areaRng), len(p.imgIds))
+ self._paramsEval = copy.deepcopy(self.params)
+ # toc = time.time()
+ # print('DONE (t={:0.2f}s).'.format(toc-tic))
+ return p.imgIds, evalImgs
+
+#################################################################
+# end of straight copy from pycocotools, just removing the prints
+#################################################################
diff --git a/PyTorch-Vision-Experiment-Logging/coco_utils.py b/PyTorch-Vision-Experiment-Logging/coco_utils.py
new file mode 100644
index 000000000..26701a2cb
--- /dev/null
+++ b/PyTorch-Vision-Experiment-Logging/coco_utils.py
@@ -0,0 +1,252 @@
+import copy
+import os
+from PIL import Image
+
+import torch
+import torch.utils.data
+import torchvision
+
+from pycocotools import mask as coco_mask
+from pycocotools.coco import COCO
+
+import transforms as T
+
+
+class FilterAndRemapCocoCategories(object):
+ def __init__(self, categories, remap=True):
+ self.categories = categories
+ self.remap = remap
+
+ def __call__(self, image, target):
+ anno = target["annotations"]
+ anno = [obj for obj in anno if obj["category_id"] in self.categories]
+ if not self.remap:
+ target["annotations"] = anno
+ return image, target
+ anno = copy.deepcopy(anno)
+ for obj in anno:
+ obj["category_id"] = self.categories.index(obj["category_id"])
+ target["annotations"] = anno
+ return image, target
+
+
+def convert_coco_poly_to_mask(segmentations, height, width):
+ masks = []
+ for polygons in segmentations:
+ rles = coco_mask.frPyObjects(polygons, height, width)
+ mask = coco_mask.decode(rles)
+ if len(mask.shape) < 3:
+ mask = mask[..., None]
+ mask = torch.as_tensor(mask, dtype=torch.uint8)
+ mask = mask.any(dim=2)
+ masks.append(mask)
+ if masks:
+ masks = torch.stack(masks, dim=0)
+ else:
+ masks = torch.zeros((0, height, width), dtype=torch.uint8)
+ return masks
+
+
+class ConvertCocoPolysToMask(object):
+ def __call__(self, image, target):
+ w, h = image.size
+
+ image_id = target["image_id"]
+ image_id = torch.tensor([image_id])
+
+ anno = target["annotations"]
+
+ anno = [obj for obj in anno if obj['iscrowd'] == 0]
+
+ boxes = [obj["bbox"] for obj in anno]
+ # guard against no boxes via resizing
+ boxes = torch.as_tensor(boxes, dtype=torch.float32).reshape(-1, 4)
+ boxes[:, 2:] += boxes[:, :2]
+ boxes[:, 0::2].clamp_(min=0, max=w)
+ boxes[:, 1::2].clamp_(min=0, max=h)
+
+ classes = [obj["category_id"] for obj in anno]
+ classes = torch.tensor(classes, dtype=torch.int64)
+
+ segmentations = [obj["segmentation"] for obj in anno]
+ masks = convert_coco_poly_to_mask(segmentations, h, w)
+
+ keypoints = None
+ if anno and "keypoints" in anno[0]:
+ keypoints = [obj["keypoints"] for obj in anno]
+ keypoints = torch.as_tensor(keypoints, dtype=torch.float32)
+ num_keypoints = keypoints.shape[0]
+ if num_keypoints:
+ keypoints = keypoints.view(num_keypoints, -1, 3)
+
+ keep = (boxes[:, 3] > boxes[:, 1]) & (boxes[:, 2] > boxes[:, 0])
+ boxes = boxes[keep]
+ classes = classes[keep]
+ masks = masks[keep]
+ if keypoints is not None:
+ keypoints = keypoints[keep]
+
+ target = {}
+ target["boxes"] = boxes
+ target["labels"] = classes
+ target["masks"] = masks
+ target["image_id"] = image_id
+ if keypoints is not None:
+ target["keypoints"] = keypoints
+
+ # for conversion to coco api
+ area = torch.tensor([obj["area"] for obj in anno])
+ iscrowd = torch.tensor([obj["iscrowd"] for obj in anno])
+ target["area"] = area
+ target["iscrowd"] = iscrowd
+
+ return image, target
+
+
+def _coco_remove_images_without_annotations(dataset, cat_list=None):
+ def _has_only_empty_bbox(anno):
+ return all(any(o <= 1 for o in obj["bbox"][2:]) for obj in anno)
+
+ def _count_visible_keypoints(anno):
+ return sum(sum(1 for v in ann["keypoints"][2::3] if v > 0) for ann in anno)
+
+ min_keypoints_per_image = 10
+
+ def _has_valid_annotation(anno):
+ # if it's empty, there is no annotation
+ if len(anno) == 0:
+ return False
+ # if all boxes have close to zero area, there is no annotation
+ if _has_only_empty_bbox(anno):
+ return False
+ # keypoints task have a slight different critera for considering
+ # if an annotation is valid
+ if "keypoints" not in anno[0]:
+ return True
+ # for keypoint detection tasks, only consider valid images those
+ # containing at least min_keypoints_per_image
+ if _count_visible_keypoints(anno) >= min_keypoints_per_image:
+ return True
+ return False
+
+ assert isinstance(dataset, torchvision.datasets.CocoDetection)
+ ids = []
+ for ds_idx, img_id in enumerate(dataset.ids):
+ ann_ids = dataset.coco.getAnnIds(imgIds=img_id, iscrowd=None)
+ anno = dataset.coco.loadAnns(ann_ids)
+ if cat_list:
+ anno = [obj for obj in anno if obj["category_id"] in cat_list]
+ if _has_valid_annotation(anno):
+ ids.append(ds_idx)
+
+ dataset = torch.utils.data.Subset(dataset, ids)
+ return dataset
+
+
+def convert_to_coco_api(ds):
+ coco_ds = COCO()
+ # annotation IDs need to start at 1, not 0, see torchvision issue #1530
+ ann_id = 1
+ dataset = {'images': [], 'categories': [], 'annotations': []}
+ categories = set()
+ for img_idx in range(len(ds)):
+ # find better way to get target
+ # targets = ds.get_annotations(img_idx)
+ img, targets = ds[img_idx]
+ image_id = targets["image_id"].item()
+ img_dict = {}
+ img_dict['id'] = image_id
+ img_dict['height'] = img.shape[-2]
+ img_dict['width'] = img.shape[-1]
+ dataset['images'].append(img_dict)
+ bboxes = targets["boxes"]
+ bboxes[:, 2:] -= bboxes[:, :2]
+ bboxes = bboxes.tolist()
+ labels = targets['labels'].tolist()
+ areas = targets['area'].tolist()
+ iscrowd = targets['iscrowd'].tolist()
+ if 'masks' in targets:
+ masks = targets['masks']
+ # make masks Fortran contiguous for coco_mask
+ masks = masks.permute(0, 2, 1).contiguous().permute(0, 2, 1)
+ if 'keypoints' in targets:
+ keypoints = targets['keypoints']
+ keypoints = keypoints.reshape(keypoints.shape[0], -1).tolist()
+ num_objs = len(bboxes)
+ for i in range(num_objs):
+ ann = {}
+ ann['image_id'] = image_id
+ ann['bbox'] = bboxes[i]
+ ann['category_id'] = labels[i]
+ categories.add(labels[i])
+ ann['area'] = areas[i]
+ ann['iscrowd'] = iscrowd[i]
+ ann['id'] = ann_id
+ if 'masks' in targets:
+ ann["segmentation"] = coco_mask.encode(masks[i].numpy())
+ if 'keypoints' in targets:
+ ann['keypoints'] = keypoints[i]
+ ann['num_keypoints'] = sum(k != 0 for k in keypoints[i][2::3])
+ dataset['annotations'].append(ann)
+ ann_id += 1
+ dataset['categories'] = [{'id': i} for i in sorted(categories)]
+ coco_ds.dataset = dataset
+ coco_ds.createIndex()
+ return coco_ds
+
+
+def get_coco_api_from_dataset(dataset):
+ for _ in range(10):
+ if isinstance(dataset, torchvision.datasets.CocoDetection):
+ break
+ if isinstance(dataset, torch.utils.data.Subset):
+ dataset = dataset.dataset
+ if isinstance(dataset, torchvision.datasets.CocoDetection):
+ return dataset.coco
+ return convert_to_coco_api(dataset)
+
+
+class CocoDetection(torchvision.datasets.CocoDetection):
+ def __init__(self, img_folder, ann_file, transforms):
+ super(CocoDetection, self).__init__(img_folder, ann_file)
+ self._transforms = transforms
+
+ def __getitem__(self, idx):
+ img, target = super(CocoDetection, self).__getitem__(idx)
+ image_id = self.ids[idx]
+ target = dict(image_id=image_id, annotations=target)
+ if self._transforms is not None:
+ img, target = self._transforms(img, target)
+ return img, target
+
+
+def get_coco(root, image_set, transforms, mode='instances'):
+ anno_file_template = "{}_{}2017.json"
+ PATHS = {
+ "train": ("train2017", os.path.join("annotations", anno_file_template.format(mode, "train"))),
+ "val": ("val2017", os.path.join("annotations", anno_file_template.format(mode, "val"))),
+ # "train": ("val2017", os.path.join("annotations", anno_file_template.format(mode, "val")))
+ }
+
+ t = [ConvertCocoPolysToMask()]
+
+ if transforms is not None:
+ t.append(transforms)
+ transforms = T.Compose(t)
+
+ img_folder, ann_file = PATHS[image_set]
+ img_folder = os.path.join(root, img_folder)
+ ann_file = os.path.join(root, ann_file)
+
+ dataset = CocoDetection(img_folder, ann_file, transforms=transforms)
+
+ if image_set == "train":
+ dataset = _coco_remove_images_without_annotations(dataset)
+
+ # dataset = torch.utils.data.Subset(dataset, [i for i in range(500)])
+
+ return dataset
+
+
+def get_coco_kp(root, image_set, transforms):
+ return get_coco(root, image_set, transforms, mode="person_keypoints")
diff --git a/PyTorch-Vision-Experiment-Logging/engine.py b/PyTorch-Vision-Experiment-Logging/engine.py
new file mode 100644
index 000000000..39d45aa35
--- /dev/null
+++ b/PyTorch-Vision-Experiment-Logging/engine.py
@@ -0,0 +1,156 @@
+import math
+import sys
+import time
+import torch
+
+import torchvision.models.detection.mask_rcnn
+
+from coco_utils import get_coco_api_from_dataset
+from coco_eval import CocoEvaluator
+import utils
+
+# ### OUR CODE ###
+# let's import tensorboard
+import tensorboard
+# ### END OF OUR CODE ###
+
+def train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq):
+ model.train()
+ metric_logger = utils.MetricLogger(delimiter=" ")
+ metric_logger.add_meter('lr', utils.SmoothedValue(window_size=1, fmt='{value:.6f}'))
+ header = 'Epoch: [{}]'.format(epoch)
+
+ lr_scheduler = None
+ if epoch == 0:
+ warmup_factor = 1. / 1000
+ warmup_iters = min(1000, len(data_loader) - 1)
+
+ lr_scheduler = utils.warmup_lr_scheduler(optimizer, warmup_iters, warmup_factor)
+
+ for images, targets in metric_logger.log_every(data_loader, print_freq, header):
+ images = list(image.to(device) for image in images)
+ targets = [{k: v.to(device) for k, v in t.items()} for t in targets]
+ loss_dict = model(images, targets)
+
+ # applying logging only in the main process
+ # ### OUR CODE ###
+ if utils.is_main_process():
+ # let's track the losses here by adding scalars
+ tensorboard.logger.add_scalar_dict(
+ # passing the dictionary of losses (pairs - loss_key: loss_value)
+ loss_dict,
+ # passing the global step (number of iterations)
+ global_step=tensorboard.global_iter,
+ # adding the tag to combine plots in a subgroup
+ tag="loss"
+ )
+ # incrementing the global step (number of iterations)
+ tensorboard.global_iter += 1
+ # ### END OF OUR CODE ###
+
+ losses = sum(loss for loss in loss_dict.values())
+
+ # reduce losses over all GPUs for logging purposes
+ loss_dict_reduced = utils.reduce_dict(loss_dict)
+ losses_reduced = sum(loss for loss in loss_dict_reduced.values())
+
+ loss_value = losses_reduced.item()
+
+ if not math.isfinite(loss_value):
+ print("Loss is {}, stopping training".format(loss_value))
+ print(loss_dict_reduced)
+ sys.exit(1)
+
+ optimizer.zero_grad()
+ losses.backward()
+ optimizer.step()
+
+ if lr_scheduler is not None:
+ lr_scheduler.step()
+
+ metric_logger.update(loss=losses_reduced, **loss_dict_reduced)
+ metric_logger.update(lr=optimizer.param_groups[0]["lr"])
+
+ return metric_logger
+
+
+def _get_iou_types(model):
+ model_without_ddp = model
+ if isinstance(model, torch.nn.parallel.DistributedDataParallel):
+ model_without_ddp = model.module
+ iou_types = ["bbox"]
+ if isinstance(model_without_ddp, torchvision.models.detection.MaskRCNN):
+ iou_types.append("segm")
+ if isinstance(model_without_ddp, torchvision.models.detection.KeypointRCNN):
+ iou_types.append("keypoints")
+ return iou_types
+
+
+@torch.no_grad()
+def evaluate(model, data_loader, device):
+ n_threads = torch.get_num_threads()
+ # FIXME remove this and make paste_masks_in_image run on the GPU
+ torch.set_num_threads(1)
+ cpu_device = torch.device("cpu")
+ model.eval()
+ metric_logger = utils.MetricLogger(delimiter=" ")
+ header = 'Test:'
+
+ coco = get_coco_api_from_dataset(data_loader.dataset)
+ iou_types = _get_iou_types(model)
+ coco_evaluator = CocoEvaluator(coco, iou_types)
+
+ # changing these two lines a bit to have iteration number and to keep image tensor
+ for i, (images, targets) in enumerate(metric_logger.log_every(data_loader, 100, header)):
+ img = images[0]
+
+ images = list(img.to(device) for img in images)
+ targets = [{k: v.to(device) for k, v in t.items()} for t in targets]
+
+ torch.cuda.synchronize()
+ model_time = time.time()
+ outputs = model(images)
+
+ # applying logging only in the main process
+ # ### OUR CODE ###
+ if utils.is_main_process():
+ # let's track bounding box and labels predictions for the first 50 images
+ # as we hardly want to track all validation images
+ # but want to see how the predicted bounding boxes and labels are changing during the process
+ if i < 50:
+ # let's add tracking images with predicted bounding boxes
+ tensorboard.logger.add_image_with_boxes(
+ # adding pred_images tag to combine images in one subgroup
+ "pred_images/PD-{}".format(i),
+ # passing image tensor
+ img,
+ # passing predicted bounding boxes
+ outputs[0]["boxes"].cpu(),
+ # mapping & passing predicted labels
+ labels=[
+ tensorboard.COCO_INSTANCE_CATEGORY_NAMES[i]
+ for i in outputs[0]["labels"].cpu().numpy()
+ ],
+ )
+ # ### END OUR CODE ###
+ outputs = [{k: v.to(cpu_device) for k, v in t.items()} for t in outputs]
+ model_time = time.time() - model_time
+
+ res = {target["image_id"].item(): output for target, output in zip(targets, outputs)}
+ evaluator_time = time.time()
+ coco_evaluator.update(res)
+ evaluator_time = time.time() - evaluator_time
+ metric_logger.update(model_time=model_time, evaluator_time=evaluator_time)
+
+ # gather the stats from all processes
+ metric_logger.synchronize_between_processes()
+ print("Averaged stats:", metric_logger)
+ coco_evaluator.synchronize_between_processes()
+
+ # accumulate predictions from all images
+ # add main process check for multi-gpu training (torch.distributed)
+ if utils.is_main_process():
+ coco_evaluator.accumulate()
+ coco_evaluator.summarize()
+ torch.set_num_threads(n_threads)
+ return coco_evaluator
diff --git a/PyTorch-Vision-Experiment-Logging/group_by_aspect_ratio.py b/PyTorch-Vision-Experiment-Logging/group_by_aspect_ratio.py
new file mode 100644
index 000000000..517056056
--- /dev/null
+++ b/PyTorch-Vision-Experiment-Logging/group_by_aspect_ratio.py
@@ -0,0 +1,195 @@
+import bisect
+from collections import defaultdict
+import copy
+from itertools import repeat, chain
+import math
+import numpy as np
+
+import torch
+import torch.utils.data
+from torch.utils.data.sampler import BatchSampler, Sampler
+from torch.utils.model_zoo import tqdm
+import torchvision
+
+from PIL import Image
+
+
+def _repeat_to_at_least(iterable, n):
+ repeat_times = math.ceil(n / len(iterable))
+ repeated = chain.from_iterable(repeat(iterable, repeat_times))
+ return list(repeated)
+
+
+class GroupedBatchSampler(BatchSampler):
+ """
+ Wraps another sampler to yield a mini-batch of indices.
+ It enforces that the batch only contain elements from the same group.
+ It also tries to provide mini-batches which follows an ordering which is
+ as close as possible to the ordering from the original sampler.
+ Arguments:
+ sampler (Sampler): Base sampler.
+ group_ids (list[int]): If the sampler produces indices in range [0, N),
+ `group_ids` must be a list of `N` ints which contains the group id of each sample.
+ The group ids must be a continuous set of integers starting from
+ 0, i.e. they must be in the range [0, num_groups).
+ batch_size (int): Size of mini-batch.
+ """
+ def __init__(self, sampler, group_ids, batch_size):
+ if not isinstance(sampler, Sampler):
+ raise ValueError(
+ "sampler should be an instance of "
+ "torch.utils.data.Sampler, but got sampler={}".format(sampler)
+ )
+ self.sampler = sampler
+ self.group_ids = group_ids
+ self.batch_size = batch_size
+
+ def __iter__(self):
+ buffer_per_group = defaultdict(list)
+ samples_per_group = defaultdict(list)
+
+ num_batches = 0
+ for idx in self.sampler:
+ group_id = self.group_ids[idx]
+ buffer_per_group[group_id].append(idx)
+ samples_per_group[group_id].append(idx)
+ if len(buffer_per_group[group_id]) == self.batch_size:
+ yield buffer_per_group[group_id]
+ num_batches += 1
+ del buffer_per_group[group_id]
+ assert len(buffer_per_group[group_id]) < self.batch_size
+
+ # now we have run out of elements that satisfy
+ # the group criteria, let's return the remaining
+ # elements so that the size of the sampler is
+ # deterministic
+ expected_num_batches = len(self)
+ num_remaining = expected_num_batches - num_batches
+ if num_remaining > 0:
+ # for the remaining batches, take first the buffers with largest number
+ # of elements
+ for group_id, _ in sorted(buffer_per_group.items(),
+ key=lambda x: len(x[1]), reverse=True):
+ remaining = self.batch_size - len(buffer_per_group[group_id])
+ samples_from_group_id = _repeat_to_at_least(samples_per_group[group_id], remaining)
+ buffer_per_group[group_id].extend(samples_from_group_id[:remaining])
+ assert len(buffer_per_group[group_id]) == self.batch_size
+ yield buffer_per_group[group_id]
+ num_remaining -= 1
+ if num_remaining == 0:
+ break
+ assert num_remaining == 0
+
+ def __len__(self):
+ return len(self.sampler) // self.batch_size
+
+
+def _compute_aspect_ratios_slow(dataset, indices=None):
+ print("Your dataset doesn't support the fast path for "
+ "computing the aspect ratios, so will iterate over "
+ "the full dataset and load every image instead. "
+ "This might take some time...")
+ if indices is None:
+ indices = range(len(dataset))
+
+ class SubsetSampler(Sampler):
+ def __init__(self, indices):
+ self.indices = indices
+
+ def __iter__(self):
+ return iter(self.indices)
+
+ def __len__(self):
+ return len(self.indices)
+
+ sampler = SubsetSampler(indices)
+ data_loader = torch.utils.data.DataLoader(
+ dataset, batch_size=1, sampler=sampler,
+ num_workers=14, # you might want to increase it for faster processing
+ collate_fn=lambda x: x[0])
+ aspect_ratios = []
+ with tqdm(total=len(dataset)) as pbar:
+ for _i, (img, _) in enumerate(data_loader):
+ pbar.update(1)
+ height, width = img.shape[-2:]
+ aspect_ratio = float(width) / float(height)
+ aspect_ratios.append(aspect_ratio)
+ return aspect_ratios
+
+
+def _compute_aspect_ratios_custom_dataset(dataset, indices=None):
+ if indices is None:
+ indices = range(len(dataset))
+ aspect_ratios = []
+ for i in indices:
+ height, width = dataset.get_height_and_width(i)
+ aspect_ratio = float(width) / float(height)
+ aspect_ratios.append(aspect_ratio)
+ return aspect_ratios
+
+
+def _compute_aspect_ratios_coco_dataset(dataset, indices=None):
+ if indices is None:
+ indices = range(len(dataset))
+ aspect_ratios = []
+ for i in indices:
+ img_info = dataset.coco.imgs[dataset.ids[i]]
+ aspect_ratio = float(img_info["width"]) / float(img_info["height"])
+ aspect_ratios.append(aspect_ratio)
+ return aspect_ratios
+
+
+def _compute_aspect_ratios_voc_dataset(dataset, indices=None):
+ if indices is None:
+ indices = range(len(dataset))
+ aspect_ratios = []
+ for i in indices:
+ # this doesn't load the data into memory, because PIL loads it lazily
+ width, height = Image.open(dataset.images[i]).size
+ aspect_ratio = float(width) / float(height)
+ aspect_ratios.append(aspect_ratio)
+ return aspect_ratios
+
+
+def _compute_aspect_ratios_subset_dataset(dataset, indices=None):
+ if indices is None:
+ indices = range(len(dataset))
+
+ ds_indices = [dataset.indices[i] for i in indices]
+ return compute_aspect_ratios(dataset.dataset, ds_indices)
+
+
+def compute_aspect_ratios(dataset, indices=None):
+ if hasattr(dataset, "get_height_and_width"):
+ return _compute_aspect_ratios_custom_dataset(dataset, indices)
+
+ if isinstance(dataset, torchvision.datasets.CocoDetection):
+ return _compute_aspect_ratios_coco_dataset(dataset, indices)
+
+ if isinstance(dataset, torchvision.datasets.VOCDetection):
+ return _compute_aspect_ratios_voc_dataset(dataset, indices)
+
+ if isinstance(dataset, torch.utils.data.Subset):
+ return _compute_aspect_ratios_subset_dataset(dataset, indices)
+
+ # slow path
+ return _compute_aspect_ratios_slow(dataset, indices)
+
+
+def _quantize(x, bins):
+ bins = copy.deepcopy(bins)
+ bins = sorted(bins)
+ quantized = list(map(lambda y: bisect.bisect_right(bins, y), x))
+ return quantized
+
+
+def create_aspect_ratio_groups(dataset, k=0):
+ aspect_ratios = compute_aspect_ratios(dataset)
+ bins = (2 ** np.linspace(-1, 1, 2 * k + 1)).tolist() if k > 0 else [1.0]
+ groups = _quantize(aspect_ratios, bins)
+ # count number of elements per group
+ counts = np.unique(groups, return_counts=True)[1]
+ fbins = [0] + bins + [np.inf]
+ print("Using {} as bins for aspect ratio quantization".format(fbins))
+ print("Count of instances per bin: {}".format(counts))
+ return groups
diff --git a/PyTorch-Vision-Experiment-Logging/requirements.txt b/PyTorch-Vision-Experiment-Logging/requirements.txt
new file mode 100644
index 000000000..6171b0079
--- /dev/null
+++ b/PyTorch-Vision-Experiment-Logging/requirements.txt
@@ -0,0 +1,7 @@
+torchvision==0.3.0
+numpy==1.17.3
+wandb==0.8.36
+pycocotools==2.0
+torch==1.1.0
+Pillow==7.1.2
+tensorboardX==2.0
diff --git a/PyTorch-Vision-Experiment-Logging/tensorboard.py b/PyTorch-Vision-Experiment-Logging/tensorboard.py
new file mode 100644
index 000000000..f6a9582ee
--- /dev/null
+++ b/PyTorch-Vision-Experiment-Logging/tensorboard.py
@@ -0,0 +1,124 @@
+# ### OUR CODE ###
+import os.path as osp
+import tensorboardX
+
+# create a new class inheriting from tensorboardX.SummaryWriter
+class SummaryWriter(tensorboardX.SummaryWriter):
+ def __init__(self, log_dir=None, comment="", **kwargs):
+ super().__init__(log_dir, comment, **kwargs)
+ # create a new function that will take dictionary as input and uses built-in add_scalar() function
+ # that function combines all plots into one subgroup by a tag
+ def add_scalar_dict(self, dictionary, global_step, tag=None):
+ for name, val in dictionary.items():
+ if tag is not None:
+ name = osp.join(tag, name)
+ self.add_scalar(name, val.item(), global_step)
+
+# COCO labels mapping
+COCO_INSTANCE_CATEGORY_NAMES = [
+ "__background__",
+ "person",
+ "bicycle",
+ "car",
+ "motorcycle",
+ "airplane",
+ "bus",
+ "train",
+ "truck",
+ "boat",
+ "traffic light",
+ "fire hydrant",
+ "N/A",
+ "stop sign",
+ "parking meter",
+ "bench",
+ "bird",
+ "cat",
+ "dog",
+ "horse",
+ "sheep",
+ "cow",
+ "elephant",
+ "bear",
+ "zebra",
+ "giraffe",
+ "N/A",
+ "backpack",
+ "umbrella",
+ "N/A",
+ "N/A",
+ "handbag",
+ "tie",
+ "suitcase",
+ "frisbee",
+ "skis",
+ "snowboard",
+ "sports ball",
+ "kite",
+ "baseball bat",
+ "baseball glove",
+ "skateboard",
+ "surfboard",
+ "tennis racket",
+ "bottle",
+ "N/A",
+ "wine glass",
+ "cup",
+ "fork",
+ "knife",
+ "spoon",
+ "bowl",
+ "banana",
+ "apple",
+ "sandwich",
+ "orange",
+ "broccoli",
+ "carrot",
+ "hot dog",
+ "pizza",
+ "donut",
+ "cake",
+ "chair",
+ "couch",
+ "potted plant",
+ "bed",
+ "N/A",
+ "dining table",
+ "N/A",
+ "N/A",
+ "toilet",
+ "N/A",
+ "tv",
+ "laptop",
+ "mouse",
+ "remote",
+ "keyboard",
+ "cell phone",
+ "microwave",
+ "oven",
+ "toaster",
+ "sink",
+ "refrigerator",
+ "N/A",
+ "book",
+ "clock",
+ "vase",
+ "scissors",
+ "teddy bear",
+ "hair drier",
+ "toothbrush",
+]
+
+# define variables as globals to have an access everywhere
+args = None # will be replaced to argparse dictionary
+total_epochs = 0 # init total number of epochs
+global_iter = 0 # init total number of iterations
+
+name = "exp-000" # init experiment name
+log_dir = "experiments" # init path where tensorboard logs will be stored
+# (if log_dir is not specified writer object will automatically generate filename)
+# Log files will be saved in 'experiments/exp-000'
+# create our custom logger
+logger = SummaryWriter(log_dir=osp.join(log_dir, name))
+
+# ### END OF OUR CODE ###
diff --git a/PyTorch-Vision-Experiment-Logging/train.py b/PyTorch-Vision-Experiment-Logging/train.py
new file mode 100644
index 000000000..007e1a917
--- /dev/null
+++ b/PyTorch-Vision-Experiment-Logging/train.py
@@ -0,0 +1,217 @@
+r"""PyTorch Detection Training.
+
+To run in a multi-gpu environment, use the distributed launcher::
+
+ python -m torch.distributed.launch --nproc_per_node=$NGPU --use_env \
+ train.py ... --world-size $NGPU
+
+The default hyperparameters are tuned for training on 8 gpus and 2 images per gpu.
+ --lr 0.02 --batch-size 2 --world-size 8
+If you use different number of gpus, the learning rate should be changed to 0.02/8*$NGPU.
+
+On top of that, for training Faster/Mask R-CNN, the default hyperparameters are
+ --epochs 26 --lr-steps 16 22 --aspect-ratio-group-factor 3
+
+Also, if you train Keypoint R-CNN, the default hyperparameters are
+ --epochs 46 --lr-steps 36 43 --aspect-ratio-group-factor 3
+Because the number of images is smaller in the person keypoint subset of COCO,
+the number of epochs should be adapted so that we have the same number of iterations.
+"""
+import datetime
+import os
+import time
+
+import torch
+import torch.utils.data
+from torch import nn
+import torchvision
+import torchvision.models.detection
+import torchvision.models.detection.mask_rcnn
+
+from coco_utils import get_coco, get_coco_kp
+
+from group_by_aspect_ratio import GroupedBatchSampler, create_aspect_ratio_groups
+from engine import train_one_epoch, evaluate
+
+import utils
+import transforms as T
+
+# ### OUR CODE
+# import tensorboard and w&b
+import tensorboard
+import wandb
+# ### END OF OUR CODE
+
+
+def get_dataset(name, image_set, transform, data_path):
+ paths = {
+ "coco": (data_path, get_coco, 91),
+ "coco_kp": (data_path, get_coco_kp, 2)
+ }
+ p, ds_fn, num_classes = paths[name]
+
+ ds = ds_fn(p, image_set=image_set, transforms=transform)
+ return ds, num_classes
+
+
+def get_transform(train):
+ transforms = []
+ transforms.append(T.ToTensor())
+ if train:
+ transforms.append(T.RandomHorizontalFlip(0.5))
+ return T.Compose(transforms)
+
+
+def main(args):
+ utils.init_distributed_mode(args)
+ print(args)
+ # applying logging only in the main process
+ # ### OUR CODE ###
+ if utils.is_main_process():
+ # passing argparse config with hyperparameters
+ tensorboard.args = vars(args)
+ # init wandb using config and experiment name
+ wandb.init(config=vars(args), name=tensorboard.name)
+ # enable tensorboard sync
+ wandb.init(sync_tensorboard=True)
+ # ### END OF OUR CODE ###
+
+ device = torch.device(args.device)
+
+ # Data loading code
+ print("Loading data")
+
+ dataset, num_classes = get_dataset(args.dataset, "train", get_transform(train=True), args.data_path)
+ dataset_test, _ = get_dataset(args.dataset, "val", get_transform(train=False), args.data_path)
+
+ print("Creating data loaders")
+ if args.distributed:
+ train_sampler = torch.utils.data.distributed.DistributedSampler(dataset)
+ test_sampler = torch.utils.data.distributed.DistributedSampler(dataset_test)
+ else:
+ train_sampler = torch.utils.data.RandomSampler(dataset)
+ test_sampler = torch.utils.data.SequentialSampler(dataset_test)
+
+ if args.aspect_ratio_group_factor >= 0:
+ group_ids = create_aspect_ratio_groups(dataset, k=args.aspect_ratio_group_factor)
+ train_batch_sampler = GroupedBatchSampler(train_sampler, group_ids, args.batch_size)
+ else:
+ train_batch_sampler = torch.utils.data.BatchSampler(
+ train_sampler, args.batch_size, drop_last=True)
+
+ data_loader = torch.utils.data.DataLoader(
+ dataset, batch_sampler=train_batch_sampler, num_workers=args.workers,
+ collate_fn=utils.collate_fn)
+
+ data_loader_test = torch.utils.data.DataLoader(
+ dataset_test, batch_size=1,
+ sampler=test_sampler, num_workers=args.workers,
+ collate_fn=utils.collate_fn)
+
+ print("Creating model")
+ model = torchvision.models.detection.__dict__[args.model](num_classes=num_classes,
+ pretrained=args.pretrained)
+ model.to(device)
+
+ model_without_ddp = model
+ if args.distributed:
+ model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu])
+ model_without_ddp = model.module
+
+ params = [p for p in model.parameters() if p.requires_grad]
+ optimizer = torch.optim.SGD(
+ params, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay)
+
+ # lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=args.lr_step_size, gamma=args.lr_gamma)
+ lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.lr_steps, gamma=args.lr_gamma)
+
+ if args.resume:
+ checkpoint = torch.load(args.resume, map_location='cpu')
+ model_without_ddp.load_state_dict(checkpoint['model'])
+ optimizer.load_state_dict(checkpoint['optimizer'])
+ lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
+ args.start_epoch = checkpoint['epoch'] + 1
+
+ if args.test_only:
+ evaluate(model, data_loader_test, device=device)
+ return
+
+ print("Start training")
+ start_time = time.time()
+ for epoch in range(args.start_epoch, args.epochs):
+ if args.distributed:
+ train_sampler.set_epoch(epoch)
+ train_one_epoch(model, optimizer, data_loader, device, epoch, args.print_freq)
+ lr_scheduler.step()
+ if args.output_dir:
+ utils.save_on_master({
+ 'model': model_without_ddp.state_dict(),
+ 'optimizer': optimizer.state_dict(),
+ 'lr_scheduler': lr_scheduler.state_dict(),
+ 'args': args,
+ 'epoch': epoch},
+ os.path.join(args.output_dir, 'model_{}.pth'.format(epoch)))
+
+ # evaluate after every epoch
+ evaluate(model, data_loader_test, device=device)
+
+ total_time = time.time() - start_time
+ total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+ print('Training time {}'.format(total_time_str))
+
+
+if __name__ == "__main__":
+ import argparse
+ parser = argparse.ArgumentParser(
+ description=__doc__)
+
+ parser.add_argument('--data-path', default='/datasets01/COCO/022719/', help='dataset')
+ parser.add_argument('--dataset', default='coco', help='dataset')
+ parser.add_argument('--model', default='maskrcnn_resnet50_fpn', help='model')
+ parser.add_argument('--device', default='cuda', help='device')
+ parser.add_argument('-b', '--batch-size', default=2, type=int,
+ help='images per gpu, the total batch size is $NGPU x batch_size')
+ parser.add_argument('--epochs', default=26, type=int, metavar='N',
+ help='number of total epochs to run')
+ parser.add_argument('-j', '--workers', default=4, type=int, metavar='N',
+ help='number of data loading workers (default: 4)')
+ parser.add_argument('--lr', default=0.02, type=float,
+ help='initial learning rate, 0.02 is the default value for training '
+ 'on 8 gpus and 2 images_per_gpu')
+ parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
+ help='momentum')
+ parser.add_argument('--wd', '--weight-decay', default=1e-4, type=float,
+ metavar='W', help='weight decay (default: 1e-4)',
+ dest='weight_decay')
+ parser.add_argument('--lr-step-size', default=8, type=int, help='decrease lr every step-size epochs')
+ parser.add_argument('--lr-steps', default=[16, 22], nargs='+', type=int, help='decrease lr every step-size epochs')
+ parser.add_argument('--lr-gamma', default=0.1, type=float, help='decrease lr by a factor of lr-gamma')
+ parser.add_argument('--print-freq', default=20, type=int, help='print frequency')
+ parser.add_argument('--output-dir', default='.', help='path where to save')
+ parser.add_argument('--resume', default='', help='resume from checkpoint')
+ parser.add_argument('--start_epoch', default=0, type=int, help='start epoch')
+ parser.add_argument('--aspect-ratio-group-factor', default=3, type=int)
+ parser.add_argument(
+ "--test-only",
+ dest="test_only",
+ help="Only test the model",
+ action="store_true",
+ )
+ parser.add_argument(
+ "--pretrained",
+ dest="pretrained",
+ help="Use pre-trained models from the modelzoo",
+ action="store_true",
+ )
+
+ # distributed training parameters
+ parser.add_argument('--world-size', default=1, type=int,
+ help='number of distributed processes')
+ parser.add_argument('--dist-url', default='env://', help='url used to set up distributed training')
+
+ args = parser.parse_args()
+
+ if args.output_dir:
+ utils.mkdir(args.output_dir)
+
+ main(args)
diff --git a/PyTorch-Vision-Experiment-Logging/transforms.py b/PyTorch-Vision-Experiment-Logging/transforms.py
new file mode 100644
index 000000000..73efc92bd
--- /dev/null
+++ b/PyTorch-Vision-Experiment-Logging/transforms.py
@@ -0,0 +1,50 @@
+import random
+import torch
+
+from torchvision.transforms import functional as F
+
+
+def _flip_coco_person_keypoints(kps, width):
+ flip_inds = [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]
+ flipped_data = kps[:, flip_inds]
+ flipped_data[..., 0] = width - flipped_data[..., 0]
+ # Maintain COCO convention that if visibility == 0, then x, y = 0
+ inds = flipped_data[..., 2] == 0
+ flipped_data[inds] = 0
+ return flipped_data
+
+
+class Compose(object):
+ def __init__(self, transforms):
+ self.transforms = transforms
+
+ def __call__(self, image, target):
+ for t in self.transforms:
+ image, target = t(image, target)
+ return image, target
+
+
+class RandomHorizontalFlip(object):
+ def __init__(self, prob):
+ self.prob = prob
+
+ def __call__(self, image, target):
+ if random.random() < self.prob:
+ height, width = image.shape[-2:]
+ image = image.flip(-1)
+ bbox = target["boxes"]
+ bbox[:, [0, 2]] = width - bbox[:, [2, 0]]
+ target["boxes"] = bbox
+ if "masks" in target:
+ target["masks"] = target["masks"].flip(-1)
+ if "keypoints" in target:
+ keypoints = target["keypoints"]
+ keypoints = _flip_coco_person_keypoints(keypoints, width)
+ target["keypoints"] = keypoints
+ return image, target
+
+
+class ToTensor(object):
+ def __call__(self, image, target):
+ image = F.to_tensor(image)
+ return image, target
diff --git a/PyTorch-Vision-Experiment-Logging/utils.py b/PyTorch-Vision-Experiment-Logging/utils.py
new file mode 100644
index 000000000..82ae79bc3
--- /dev/null
+++ b/PyTorch-Vision-Experiment-Logging/utils.py
@@ -0,0 +1,324 @@
+from collections import defaultdict, deque
+import datetime
+import pickle
+import time
+
+import torch
+import torch.distributed as dist
+
+import errno
+import os
+
+
+class SmoothedValue(object):
+ """Track a series of values and provide access to smoothed values over a
+ window or the global series average.
+ """
+
+ def __init__(self, window_size=20, fmt=None):
+ if fmt is None:
+ fmt = "{median:.4f} ({global_avg:.4f})"
+ self.deque = deque(maxlen=window_size)
+ self.total = 0.0
+ self.count = 0
+ self.fmt = fmt
+
+ def update(self, value, n=1):
+ self.deque.append(value)
+ self.count += n
+ self.total += value * n
+
+ def synchronize_between_processes(self):
+ """
+ Warning: does not synchronize the deque!
+ """
+ if not is_dist_avail_and_initialized():
+ return
+ t = torch.tensor([self.count, self.total], dtype=torch.float64, device='cuda')
+ dist.barrier()
+ dist.all_reduce(t)
+ t = t.tolist()
+ self.count = int(t[0])
+ self.total = t[1]
+
+ @property
+ def median(self):
+ d = torch.tensor(list(self.deque))
+ return d.median().item()
+
+ @property
+ def avg(self):
+ d = torch.tensor(list(self.deque), dtype=torch.float32)
+ return d.mean().item()
+
+ @property
+ def global_avg(self):
+ return self.total / self.count
+
+ @property
+ def max(self):
+ return max(self.deque)
+
+ @property
+ def value(self):
+ return self.deque[-1]
+
+ def __str__(self):
+ return self.fmt.format(
+ median=self.median,
+ avg=self.avg,
+ global_avg=self.global_avg,
+ max=self.max,
+ value=self.value)
+
+
+def all_gather(data):
+ """
+ Run all_gather on arbitrary picklable data (not necessarily tensors)
+ Args:
+ data: any picklable object
+ Returns:
+ list[data]: list of data gathered from each rank
+ """
+ world_size = get_world_size()
+ if world_size == 1:
+ return [data]
+
+ # serialized to a Tensor
+ buffer = pickle.dumps(data)
+ storage = torch.ByteStorage.from_buffer(buffer)
+ tensor = torch.ByteTensor(storage).to("cuda")
+
+ # obtain Tensor size of each rank
+ local_size = torch.tensor([tensor.numel()], device="cuda")
+ size_list = [torch.tensor([0], device="cuda") for _ in range(world_size)]
+ dist.all_gather(size_list, local_size)
+ size_list = [int(size.item()) for size in size_list]
+ max_size = max(size_list)
+
+ # receiving Tensor from all ranks
+ # we pad the tensor because torch all_gather does not support
+ # gathering tensors of different shapes
+ tensor_list = []
+ for _ in size_list:
+ tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device="cuda"))
+ if local_size != max_size:
+ padding = torch.empty(size=(max_size - local_size,), dtype=torch.uint8, device="cuda")
+ tensor = torch.cat((tensor, padding), dim=0)
+ dist.all_gather(tensor_list, tensor)
+
+ data_list = []
+ for size, tensor in zip(size_list, tensor_list):
+ buffer = tensor.cpu().numpy().tobytes()[:size]
+ data_list.append(pickle.loads(buffer))
+
+ return data_list
+
+
+def reduce_dict(input_dict, average=True):
+ """
+ Args:
+ input_dict (dict): all the values will be reduced
+ average (bool): whether to do average or sum
+ Reduce the values in the dictionary from all processes so that all processes
+ have the averaged results. Returns a dict with the same fields as
+ input_dict, after reduction.
+ """
+ world_size = get_world_size()
+ if world_size < 2:
+ return input_dict
+ with torch.no_grad():
+ names = []
+ values = []
+ # sort the keys so that they are consistent across processes
+ for k in sorted(input_dict.keys()):
+ names.append(k)
+ values.append(input_dict[k])
+ values = torch.stack(values, dim=0)
+ dist.all_reduce(values)
+ if average:
+ values /= world_size
+ reduced_dict = {k: v for k, v in zip(names, values)}
+ return reduced_dict
+
+
+class MetricLogger(object):
+ def __init__(self, delimiter="\t"):
+ self.meters = defaultdict(SmoothedValue)
+ self.delimiter = delimiter
+
+ def update(self, **kwargs):
+ for k, v in kwargs.items():
+ if isinstance(v, torch.Tensor):
+ v = v.item()
+ assert isinstance(v, (float, int))
+ self.meters[k].update(v)
+
+ def __getattr__(self, attr):
+ if attr in self.meters:
+ return self.meters[attr]
+ if attr in self.__dict__:
+ return self.__dict__[attr]
+ raise AttributeError("'{}' object has no attribute '{}'".format(
+ type(self).__name__, attr))
+
+ def __str__(self):
+ loss_str = []
+ for name, meter in self.meters.items():
+ loss_str.append(
+ "{}: {}".format(name, str(meter))
+ )
+ return self.delimiter.join(loss_str)
+
+ def synchronize_between_processes(self):
+ for meter in self.meters.values():
+ meter.synchronize_between_processes()
+
+ def add_meter(self, name, meter):
+ self.meters[name] = meter
+
+ def log_every(self, iterable, print_freq, header=None):
+ i = 0
+ if not header:
+ header = ''
+ start_time = time.time()
+ end = time.time()
+ iter_time = SmoothedValue(fmt='{avg:.4f}')
+ data_time = SmoothedValue(fmt='{avg:.4f}')
+ space_fmt = ':' + str(len(str(len(iterable)))) + 'd'
+ if torch.cuda.is_available():
+ log_msg = self.delimiter.join([
+ header,
+ '[{0' + space_fmt + '}/{1}]',
+ 'eta: {eta}',
+ '{meters}',
+ 'time: {time}',
+ 'data: {data}',
+ 'max mem: {memory:.0f}'
+ ])
+ else:
+ log_msg = self.delimiter.join([
+ header,
+ '[{0' + space_fmt + '}/{1}]',
+ 'eta: {eta}',
+ '{meters}',
+ 'time: {time}',
+ 'data: {data}'
+ ])
+ MB = 1024.0 * 1024.0
+ for obj in iterable:
+ data_time.update(time.time() - end)
+ yield obj
+ iter_time.update(time.time() - end)
+ if i % print_freq == 0 or i == len(iterable) - 1:
+ eta_seconds = iter_time.global_avg * (len(iterable) - i)
+ eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
+ if torch.cuda.is_available():
+ print(log_msg.format(
+ i, len(iterable), eta=eta_string,
+ meters=str(self),
+ time=str(iter_time), data=str(data_time),
+ memory=torch.cuda.max_memory_allocated() / MB))
+ else:
+ print(log_msg.format(
+ i, len(iterable), eta=eta_string,
+ meters=str(self),
+ time=str(iter_time), data=str(data_time)))
+ i += 1
+ end = time.time()
+ total_time = time.time() - start_time
+ total_time_str = str(datetime.timedelta(seconds=int(total_time)))
+ print('{} Total time: {} ({:.4f} s / it)'.format(
+ header, total_time_str, total_time / len(iterable)))
+
+
+def collate_fn(batch):
+ return tuple(zip(*batch))
+
+
+def warmup_lr_scheduler(optimizer, warmup_iters, warmup_factor):
+
+ def f(x):
+ if x >= warmup_iters:
+ return 1
+ alpha = float(x) / warmup_iters
+ return warmup_factor * (1 - alpha) + alpha
+
+ return torch.optim.lr_scheduler.LambdaLR(optimizer, f)
+
+
+def mkdir(path):
+ try:
+ os.makedirs(path)
+ except OSError as e:
+ if e.errno != errno.EEXIST:
+ raise
+
+
+def setup_for_distributed(is_master):
+ """
+ This function disables printing when not in master process
+ """
+ import builtins as __builtin__
+ builtin_print = __builtin__.print
+
+ def print(*args, **kwargs):
+ force = kwargs.pop('force', False)
+ if is_master or force:
+ builtin_print(*args, **kwargs)
+
+ __builtin__.print = print
+
+
+def is_dist_avail_and_initialized():
+ if not dist.is_available():
+ return False
+ if not dist.is_initialized():
+ return False
+ return True
+
+
+def get_world_size():
+ if not is_dist_avail_and_initialized():
+ return 1
+ return dist.get_world_size()
+
+
+def get_rank():
+ if not is_dist_avail_and_initialized():
+ return 0
+ return dist.get_rank()
+
+
+def is_main_process():
+ return get_rank() == 0
+
+
+def save_on_master(*args, **kwargs):
+ if is_main_process():
+ torch.save(*args, **kwargs)
+
+
+def init_distributed_mode(args):
+ if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ:
+ args.rank = int(os.environ["RANK"])
+ args.world_size = int(os.environ['WORLD_SIZE'])
+ args.gpu = int(os.environ['LOCAL_RANK'])
+ elif 'SLURM_PROCID' in os.environ:
+ args.rank = int(os.environ['SLURM_PROCID'])
+ args.gpu = args.rank % torch.cuda.device_count()
+ else:
+ print('Not using distributed mode')
+ args.distributed = False
+ return
+
+ args.distributed = True
+
+ torch.cuda.set_device(args.gpu)
+ args.dist_backend = 'nccl'
+ print('| distributed init (rank {}): {}'.format(
+ args.rank, args.dist_url), flush=True)
+ torch.distributed.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
+ world_size=args.world_size, rank=args.rank)
+ torch.distributed.barrier()
+ setup_for_distributed(args.rank == 0)
diff --git a/PyTorch-to-CoreML-model-conversion/README.md b/PyTorch-to-CoreML-model-conversion/README.md
new file mode 100644
index 000000000..936401eb3
--- /dev/null
+++ b/PyTorch-to-CoreML-model-conversion/README.md
@@ -0,0 +1,33 @@
+This contains the code for **PyTorch to CoreML model conversion**. For more information - visit
+[**PyTorch to CoreML model conversion**](https://www.learnopencv.com/pytorch-to-coreml-model-conversion/)
+
+## Installation
+
+All required libraries collected in the requirements.txt file. To create a new virtual environment and install the
+requirements, you can use these commands:
+
+```
+$ virtualenv -p python3.7 venv
+$ source venv/bin/activate
+$ pip install -r requirements.txt
+```
+
+## Run the script
+
+To convert any model from `torchvision.models` you can try our script by using this command:
+
+```
+$ python3 torch_to_coreml.py --model_name resnet18 --simplify
+```
+
+The `--model_name` argument should contain the name of any model from `torchvision.models`
+
+# AI Courses by OpenCV
+
+Want to become an expert in AI? [AI Courses by OpenCV](https://opencv.org/courses/) is a great place to start.
+
+
+